@Override public <K, V> void getClusterWideMap(String name, Handler<AsyncResult<AsyncMap<K, V>>> resultHandler) { Objects.requireNonNull(name, "name"); Objects.requireNonNull(resultHandler, "resultHandler"); if (clusterManager == null) { throw new IllegalStateException("Can't get cluster wide map if not clustered"); } clusterManager.<K, V>getAsyncMap(name, ar -> { if (ar.succeeded()) { // Wrap it resultHandler.handle(Future.succeededFuture(new WrappedAsyncMap<K, V>(ar.result()))); } else { resultHandler.handle(Future.failedFuture(ar.cause())); } }); }
/** * Create a blank new clustered Vert.x instance with @{@code options} closed when tear down executes. */ protected void clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> ar) { if (created == null) { created = Collections.synchronizedList(new ArrayList<>()); } Vertx.clusteredVertx(options, event -> { if (event.succeeded()) { created.add(event.result()); } ar.handle(event); }); }
@Test public void testAsyncUndeployCalledSynchronously() throws Exception { MyAsyncVerticle verticle = new MyAsyncVerticle(f -> f.complete(null), f -> f.complete(null)); vertx.deployVerticle(verticle, ar -> { assertTrue(ar.succeeded()); vertx.undeploy(ar.result(), ar2 -> { assertTrue(ar2.succeeded()); assertFalse(vertx.deploymentIDs().contains(ar.result())); testComplete(); }); }); await(); }
@Test public void testAsyncDeployFailureCalledSynchronously() throws Exception { MyAsyncVerticle verticle = new MyAsyncVerticle(f -> f.fail(new Exception("foobar")), null); vertx.deployVerticle(verticle, ar -> { assertFalse(ar.succeeded()); assertEquals("foobar", ar.cause().getMessage()); testComplete(); }); await(); }
@Test public void testAsyncUndeployFailureCalledSynchronously() throws Exception { MyAsyncVerticle verticle = new MyAsyncVerticle(f -> f.complete(null), f -> f.fail(new Exception("foobar"))); vertx.deployVerticle(verticle, ar -> { assertTrue(ar.succeeded()); vertx.undeploy(ar.result(), ar2 -> { assertFalse(ar2.succeeded()); assertEquals("foobar", ar2.cause().getMessage()); assertFalse(vertx.deploymentIDs().contains(ar.result())); testComplete(); }); }); await(); }
@Override public NetSocket upgradeToSsl(String serverName, Handler<Void> handler) { ChannelOutboundHandler sslHandler = (ChannelOutboundHandler) chctx.pipeline().get("ssl"); if (sslHandler == null) { chctx.pipeline().addFirst("handshaker", new SslHandshakeCompletionHandler(ar -> { if (ar.succeeded()) { handler.handle(null); } else { chctx.channel().closeFuture(); handleException(ar.cause()); } })); if (remoteAddress != null) { sslHandler = new SslHandler(helper.createEngine(vertx, remoteAddress, serverName)); } else { if (helper.isSNI()) { sslHandler = new SniHandler(helper.serverNameMapper(vertx)); } else { sslHandler = new SslHandler(helper.createEngine(vertx)); } } chctx.pipeline().addFirst("ssl", sslHandler); } return this; }
@Test public void testExecuteBlockingTTCL() throws Exception { ClassLoader cl = Thread.currentThread().getContextClassLoader(); assertNotNull(cl); CountDownLatch latch = new CountDownLatch(1); AtomicReference<ClassLoader> blockingTCCL = new AtomicReference<>(); vertx.<String>executeBlocking(future -> { future.complete("whatever"); blockingTCCL.set(Thread.currentThread().getContextClassLoader()); }, ar -> { assertTrue(ar.succeeded()); assertEquals("whatever", ar.result()); latch.countDown(); }); assertSame(cl, Thread.currentThread().getContextClassLoader()); awaitLatch(latch); assertSame(cl, blockingTCCL.get()); }
@Test public void testUndeployTwice() throws Exception { MyVerticle verticle = new MyVerticle(); vertx.deployVerticle(verticle, ar -> { assertTrue(ar.succeeded()); vertx.undeploy(ar.result(), ar2 -> { assertTrue(ar2.succeeded()); vertx.undeploy(ar.result(), ar3 -> { assertFalse(ar3.succeeded()); assertTrue(ar3.cause() instanceof IllegalStateException); testComplete(); }); }); }); await(); }
private void removeSub(String subName, ClusterNodeInfo node, Handler<AsyncResult<Void>> completionHandler) { subs.remove(subName, node, ar -> { if (!ar.succeeded()) { log.error("Failed to remove sub", ar.cause()); } else { if (ar.result()) { if (completionHandler != null) { completionHandler.handle(Future.succeededFuture()); } } else { if (completionHandler != null) { completionHandler.handle(Future.failedFuture("sub not found")); } } } }); }
if (sslHelper.isSSL()) { ch.pipeline().addFirst("handshaker", new SslHandshakeCompletionHandler(ar -> { if (ar.succeeded()) { connected(handler, ch); } else { if (exceptionHandler != null) { handler.context.executeFromIO(v -> { exceptionHandler.handle(ar.cause()); }); } else { log.error("Client from origin " + ch.remoteAddress() + " failed to connect over ssl: " + ar.cause());
@Test public void testListenOnWildcardPort() { server.close(); server = vertx.createNetServer(new NetServerOptions().setPort(0)); server.connectHandler((netSocket) -> { }).listen(ar -> { assertFalse(ar.failed()); assertTrue(ar.succeeded()); assertNull(ar.cause()); assertTrue(server.actualPort() > 1024); assertEquals(server, ar.result()); testComplete(); }); await(); }
void getConnectionForRequest(ContextInternal ctx, String peerHost, boolean ssl, int port, String host, Handler<AsyncResult<HttpClientStream>> handler) { httpCM.getConnection(ctx, peerHost, ssl, port, host, ar -> { if (ar.succeeded()) { ar.result().createStream(handler); } else { handler.handle(Future.failedFuture(ar.cause())); } }); }