public void undeployAll(Handler<AsyncResult<Void>> completionHandler) { // TODO timeout if it takes too long - e.g. async stop verticle fails to call future // We only deploy the top level verticles as the children will be undeployed when the parent is Set<String> deploymentIDs = new HashSet<>(); for (Map.Entry<String, Deployment> entry: deployments.entrySet()) { if (!entry.getValue().isChild()) { deploymentIDs.add(entry.getKey()); } } if (!deploymentIDs.isEmpty()) { AtomicInteger count = new AtomicInteger(0); for (String deploymentID : deploymentIDs) { undeployVerticle(deploymentID, ar -> { if (ar.failed()) { // Log but carry on regardless log.error("Undeploy failed", ar.cause()); } if (count.incrementAndGet() == deploymentIDs.size()) { completionHandler.handle(Future.succeededFuture()); } }); } } else { Context context = vertx.getOrCreateContext(); context.runOnContext(v -> completionHandler.handle(Future.succeededFuture())); } }
@Override public void start() throws Exception { processArgs = context.processArgs(); conf = context.config(); // if (Thread.currentThread().getContextClassLoader() != getClass().getClassLoader()) { // throw new IllegalStateException("Wrong tccl!"); // } vertx.eventBus().send("testcounts", new JsonObject().put("deploymentID", context.deploymentID()).put("count", instanceCount.incrementAndGet())); }
@Override public HttpServerFileUpload streamToFileSystem(String filename) { pause(); context.owner().fileSystem().open(filename, new OpenOptions(), ar -> { if (ar.succeeded()) { file = ar.result(); Pump p = Pump.pump(HttpServerFileUploadImpl.this, ar.result()); p.start(); resume(); } else { notifyExceptionHandler(ar.cause()); } }); return this; }
void acquireLock() { if (status.compareAndSet(Status.WAITING, Status.ACQUIRED)) { if (timerId != null) { context.owner().cancelTimer(timerId); } context.runOnContext(v -> handler.handle(Future.succeededFuture(new AsyncLock(lockName)))); } else { context.runOnContext(v -> nextWaiter(lockName)); } } }
@Override public void start() throws Exception { thread.set(Thread.currentThread()); assertTrue(Context.isOnVertxThread()); assertTrue(Context.isOnWorkerThread()); assertFalse(Context.isOnEventLoopThread()); assertTrue(Thread.currentThread().getName().startsWith(poolName + "-")); context.runOnContext(v -> { vertx.undeploy(context.deploymentID()); }); } }, new DeploymentOptions().setWorker(true).setWorkerPoolName(poolName), onSuccess(deployment::set));
@Test public void testNetSocketStreamCallbackIsAsync() { this.server = vertx.createNetServer(new NetServerOptions()); AtomicInteger done = new AtomicInteger(); ReadStream<NetSocket> stream = server.connectStream(); stream.handler(req -> {}); stack.set(true); stream.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); if (done.incrementAndGet() == 2) { testComplete(); assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); ThreadLocal<Object> stack2 = new ThreadLocal<>(); stack2.set(true); server.close(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack2.get()); if (done.incrementAndGet() == 2) { testComplete();
CompletableFuture<Void> done = new CompletableFuture<>(); AtomicBoolean paused = new AtomicBoolean(); AtomicInteger numPause = new AtomicInteger(); server.requestHandler(req -> { Context ctx = vertx.getOrCreateContext(); done.thenAccept(v1 -> { paused.set(false); ctx.runOnContext(v2 -> { req.resume(); }); }); numPause.incrementAndGet(); req.pause(); paused.set(true); fail(); }); AtomicInteger sent = new AtomicInteger(); AtomicInteger count = new AtomicInteger(); AtomicInteger drained = new AtomicInteger(); vertx.setPeriodic(1, timerID -> { Context ctx = vertx.getOrCreateContext(); if (req.writeQueueFull()) { assertTrue(paused.get());
@Test public void testMultipleServerClose() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); AtomicInteger times = new AtomicInteger(); // We assume the endHandler and the close completion handler are invoked in the same context task ThreadLocal stack = new ThreadLocal(); stack.set(true); server.websocketStream().endHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); times.incrementAndGet(); }); server.close(ar1 -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); server.close(ar2 -> { server.close(ar3 -> { assertEquals(1, times.get()); testComplete(); }); }); }); await(); }
@Test public void testMultipleServerClose() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); AtomicInteger times = new AtomicInteger(); // We assume the endHandler and the close completion handler are invoked in the same context task ThreadLocal stack = new ThreadLocal(); stack.set(true); server.requestStream().endHandler(v -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); times.incrementAndGet(); }); server.close(ar1 -> { assertNull(stack.get()); assertTrue(Vertx.currentContext().isEventLoopContext()); server.close(ar2 -> { server.close(ar3 -> { assertEquals(1, times.get()); testComplete(); }); }); }); await(); }
@Test public void testCheckThatPauseAfterResumeWontDoAnyEmission() { context.runOnContext(v1 -> { buffer = new InboundBuffer<>(context, 4L); AtomicInteger emitted = new AtomicInteger(); buffer.handler(elt -> emitted.incrementAndGet()); buffer.pause(); fill(); // Resume will execute an asynchronous drain operation buffer.resume(); // Pause just after to ensure that no elements will be delivered to he handler buffer.pause(); // Give enough time to have elements delivered vertx.setTimer(20, id -> { // Check we haven't received anything assertEquals(0, emitted.get()); testComplete(); }); }); await(); }
int contentLength = numBuffers * chunkSize; AtomicReference<HttpServerMetric> serverMetric = new AtomicReference<>(); server.requestHandler(req -> { assertEquals(protocol, req.version()); FakeHttpServerMetrics serverMetrics = FakeMetricsBase.getMetrics(server); }); startServer(); CountDownLatch latch = new CountDownLatch(1); AtomicReference<HttpClientMetric> clientMetric = new AtomicReference<>(); FakeHttpClientMetrics metrics = FakeMetricsBase.getMetrics(client); Context ctx = vertx.getOrCreateContext(); ctx.runOnContext(v -> { assertEquals(Collections.emptySet(), metrics.endpoints()); HttpClientRequest req = client.get(DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, "/somepath", assertNull(metrics.getMetric(resp.request())); assertEquals(contentLength, buff.length()); latch.countDown(); }); }))
CountDownLatch requestBeginLatch = new CountDownLatch(1); CountDownLatch requestBodyLatch = new CountDownLatch(1); CountDownLatch requestEndLatch = new CountDownLatch(1); CompletableFuture<Void> beginResponse = new CompletableFuture<>(); CompletableFuture<Void> endResponse = new CompletableFuture<>(); server.requestHandler(req -> { Context ctx = vertx.getOrCreateContext(); beginResponse.thenAccept(v1 -> { ctx.runOnContext(v2 -> { req.response().setChunked(true).write(TestUtils.randomAlphaString(1024)); }); }); endResponse.thenAccept(v1 -> { ctx.runOnContext(v2 -> { req.response().end(); }); server.listen(8080, "localhost", onSuccess(s -> { listenLatch.countDown(); })); awaitLatch(listenLatch); FakeHttpClientMetrics clientMetrics = FakeMetricsBase.getMetrics(client);
@Test public void testWebsocketStreamCallbackAsynchronously() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(DEFAULT_HTTP_PORT)); AtomicInteger done = new AtomicInteger(); ReadStream<ServerWebSocket> stream = server.websocketStream(); stream.handler(req -> { }); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); if (done.incrementAndGet() == 2) { testComplete(); server.listen(ar -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); ThreadLocal<Object> stack2 = new ThreadLocal<>(); stack2.set(true); server.close(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack2.get()); if (done.incrementAndGet() == 2) { testComplete();
@Test public void testCloseServerAsynchronously() { this.server = vertx.createHttpServer(new HttpServerOptions().setPort(HttpTestBase.DEFAULT_HTTP_PORT)); AtomicInteger done = new AtomicInteger(); ReadStream<HttpServerRequest> stream = server.requestStream(); stream.handler(req -> {}); ThreadLocal<Object> stack = new ThreadLocal<>(); stack.set(true); stream.endHandler(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); if (done.incrementAndGet() == 2) { testComplete(); server.listen(ar -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack.get()); ThreadLocal<Object> stack2 = new ThreadLocal<>(); stack2.set(true); server.close(v -> { assertTrue(Vertx.currentContext().isEventLoopContext()); assertNull(stack2.get()); if (done.incrementAndGet() == 2) { testComplete();
int size = getOptions().getWorkerPoolSize(); List<Context> workers = createWorkers(size + 1); CountDownLatch latch1 = new CountDownLatch(workers.size() - 1); workers.get(0).runOnContext(v -> { NetServer server = vertx.createNetServer(); server.connectHandler(so -> { so.handler(buf -> { }); server.listen(testAddress, ar -> { assertTrue(ar.succeeded()); workers.get(i).runOnContext(v2 -> { latch1.countDown(); try { Thread.sleep(1000); }); awaitLatch(latch1); NetClient client = vertx.createNetClient(); client.connect(testAddress, ar -> { assertTrue(ar.succeeded()); NetSocket so = ar.result(); so.write(Buffer.buffer("hello")); });
@Test public void testAcquireDifferentLocksOnSameEventLoop() { Vertx vertx = getVertx(); Context context = vertx.getOrCreateContext(); SharedData sharedData = vertx.sharedData(); AtomicInteger stage = new AtomicInteger(); context.runOnContext(v -> { sharedData.getLock("foo", onSuccess(foo -> { assertTrue(stage.compareAndSet(0, 1)); // Create another lock request sharedData.getLock("foo", onSuccess(foo1 -> { assertEquals(2, stage.get()); foo1.release(); testComplete(); })); // Should not be blocked by second request for lock "foo" sharedData.getLock("bar", onSuccess(bar -> { assertTrue(stage.compareAndSet(1, 2)); foo.release(); bar.release(); })); })); }); await(); }
@Test public void testOrdered() { String poolName = "vert.x-" + TestUtils.randomAlphaString(10); WorkerExecutor worker = vertx.createSharedWorkerExecutor(poolName); int num = 1000; AtomicReference<Thread> t = new AtomicReference<>(); CountDownLatch submitted = new CountDownLatch(1); Context ctx = vertx.getOrCreateContext(); ctx.runOnContext(v -> { for (int i = 0;i < num;i++) { boolean first = i == 0; fut.complete(null); }, ar -> { if (last) { submitted.countDown(); }); await();
CountDownLatch latch = new CountDownLatch(1); Vertx vertx = vertx(new VertxOptions().setMetricsOptions(new MetricsOptions().setEnabled(true).setFactory(factory))); Context ctx = contextFactory.apply(vertx); ctx.runOnContext(v1 -> { NetServer server = vertx.createNetServer().connectHandler(so -> { so.handler(buf -> { so.write("bye"); server.listen(1234, "localhost", onSuccess(s -> { expectedThread.set(Thread.currentThread()); expectedContext.set(Vertx.currentContext()); checker.accept(expectedThread.get(), expectedContext.get()); latch.countDown(); })); }); awaitLatch(latch); NetClient client = vertx.createNetClient(); client.connect(1234, "localhost", onSuccess(so -> { so.handler(buf -> {
@Test public void testContextExceptionHandlerFailing() { RuntimeException failure = new RuntimeException(); Context context = vertx.getOrCreateContext(); AtomicInteger count = new AtomicInteger(); context.exceptionHandler(err -> { if (count.getAndIncrement() == 0) { throw new RuntimeException(); } else { assertSame(failure, err); testComplete(); } }); context.runOnContext(v -> { throw new RuntimeException(); }); context.runOnContext(v -> { throw failure; }); await(); }
io.vertx.core.http.Http2Settings expectedSettings = TestUtils.randomHttp2Settings(); expectedSettings.setHeaderTableSize((int)io.vertx.core.http.Http2Settings.DEFAULT_HEADER_TABLE_SIZE); server.close(); server = vertx.createHttpServer(serverOptions); Context otherContext = vertx.getOrCreateContext(); server.connectionHandler(conn -> { otherContext.runOnContext(v -> { conn.updateSettings(expectedSettings); }); }); server.requestHandler(req -> { }); startServer(); AtomicInteger count = new AtomicInteger(); client.get(DEFAULT_HTTPS_PORT, DEFAULT_HTTPS_HOST, "/somepath", onFailure(resp -> {})).connectionHandler(conn -> { conn.remoteSettingsHandler(settings -> { switch (count.getAndIncrement()) { case 0: assertEquals(expectedSettings.getMaxHeaderListSize(), settings.getMaxHeaderListSize());