Fixes updates to traffic shaping options with shared servers

src/main/java/io/vertx/core/net/impl/TCPServerBase.java

@@ -153,14 +153,16 @@ public void updateTrafficShapingOptions(TrafficShapingOptions options) {
     if (options == null) {
       throw new IllegalArgumentException("Invalid null value passed for traffic shaping options update");
     }
-    if (trafficShapingHandler == null) {
-      throw new IllegalStateException("Unable to update traffic shaping options because the server was not configured " +
-                                      "to use traffic shaping during startup");
-    }
     TCPServerBase server = actualServer;
+    // Update the traffic shaping options only for the actual/main server
     if (server != null && server != this) {
-      server.updateTrafficShapingOptions(options);
+       server.updateTrafficShapingOptions(options);
     } else {
+      if (trafficShapingHandler == null) {
+        throw new IllegalStateException("Unable to update traffic shaping options because the server was not configured " +
+                                        "to use traffic shaping during startup");
+      }
+
       long checkIntervalForStatsInMillis = options.getCheckIntervalForStatsTimeUnit().toMillis(options.getCheckIntervalForStats());
       trafficShapingHandler.configure(options.getOutboundGlobalBandwidth(), options.getInboundGlobalBandwidth(), checkIntervalForStatsInMillis);
 
@@ -292,8 +294,10 @@ private synchronized Future<Channel> listen(SocketAddress localAddress, ContextI
       } else {
         // Server already exists with that host/port - we will use that
         actualServer = main;
-        metrics = main.metrics;
-        childHandler =  childHandler(listenContext, localAddress, main.trafficShapingHandler);
+        metrics = actualServer.metrics;
+        // Ensure the workers inherit the actual server's traffic-shaping handler
+        trafficShapingHandler = actualServer.trafficShapingHandler;
+        childHandler =  childHandler(listenContext, localAddress, actualServer.trafficShapingHandler);
         worker = ch -> childHandler.accept(ch, actualServer.sslChannelProvider.result().sslChannelProvider());
         actualServer.servers.add(this);
         actualServer.channelBalancer.addWorker(eventLoop, worker);

src/test/java/io/vertx/core/http/HttpBandwidthLimitingTest.java

@@ -13,9 +13,10 @@
 import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
-import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
@@ -204,6 +205,54 @@ public void start(Promise<Void> startPromise) {
     Assert.assertTrue(elapsedMillis > expectedTimeMillis(totalReceivedLength.get(), OUTBOUND_LIMIT)); // because there are simultaneous 2 requests
   }
 
+  @Test
+  public void testDynamicOutboundRateUpdateSharedServers() throws IOException, InterruptedException
+  {
+    int numEventLoops = 5; // We start a shared TCP server with 2 event-loops
+    List<HttpServer> servers = new ArrayList<>();
+    Future<String> listenLatch = vertx.deployVerticle(() -> new AbstractVerticle() {
+      @Override
+      public void start(Promise<Void> startPromise) {
+        HttpServer testServer = serverFactory.apply(vertx);
+        servers.add(testServer);
+        testServer.requestHandler(HANDLERS.getFile(sampleF))
+                  .listen(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST).<Void>mapEmpty().onComplete(startPromise);
+      }
+    }, new DeploymentOptions().setInstances(numEventLoops));
+
+    HttpClient testClient = clientFactory.apply(vertx);
+    CountDownLatch waitForResponse = new CountDownLatch(2);
+    AtomicLong startTime = new AtomicLong();
+    AtomicLong totalReceivedLength = new AtomicLong();
+    long expectedLength = Files.size(Paths.get(sampleF.getAbsolutePath()));
+    listenLatch.onComplete(onSuccess(v -> {
+      startTime.set(System.nanoTime());
+      for (int i = 0; i < 2; i++) {
+        testClient.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/get-file")
+                  .compose(req -> req.send()
+                                     .andThen(onSuccess(resp -> assertEquals(200, resp.statusCode())))
+                                     .compose(HttpClientResponse::body))
+                  .onComplete(onSuccess(body -> {
+                    long receivedBytes = body.getBytes().length;
+                    totalReceivedLength.addAndGet(receivedBytes);
+                    Assert.assertEquals(expectedLength, receivedBytes);
+                    waitForResponse.countDown();
+                  }));
+      }
+    }));
+    awaitLatch(waitForResponse);
+    TrafficShapingOptions updatedTrafficOptions = new TrafficShapingOptions()
+                                             .setInboundGlobalBandwidth(INBOUND_LIMIT) // unchanged
+                                             .setOutboundGlobalBandwidth(OUTBOUND_LIMIT);
+
+    for (int i = 0; i < numEventLoops; i++) {
+      servers.forEach(s -> s.updateTrafficShapingOptions(updatedTrafficOptions));
+    }
+
+    long elapsedMillis = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime.get());
+    Assert.assertTrue(elapsedMillis > expectedTimeMillis(totalReceivedLength.get(), OUTBOUND_LIMIT));
+  }
+
   @Test
   public void testDynamicOutboundRateUpdate() throws Exception {
     Buffer expectedBuffer = TestUtils.randomBuffer(TEST_CONTENT_SIZE);