@SuppressWarnings("unchecked") @Override public void handle(AsyncResult event) { if (event.failed()) { handler.handle(event); } else { List<String> txts = new ArrayList<>(); List<List<String>> records = (List<List<String>>) event.result(); for (List<String> txt: records) { txts.addAll(txt); } handler.handle(Future.succeededFuture(txts)); } } }, DnsRecordType.TXT);
@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())); } }); }
@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 testSucceededAsyncResultMap() { Future<String> f = Future.future(); AsyncResult<String> res = asyncResult(f); AsyncResult<Integer> map1 = res.map(String::length); AsyncResult<Integer> map2 = res.map(17); f.complete("foobar"); assertEquals(6, (int)map1.result()); assertNull(map1.cause()); assertEquals(17, (int)map2.result()); assertNull(map2.cause()); }
@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(); }
@Test public void testFailedAsyncResultMap() { Future<String> f = Future.future(); AsyncResult<String> res = asyncResult(f); AsyncResult<Integer> map1 = res.map(String::length); AsyncResult<Integer> map2 = res.map(17); Throwable cause = new Throwable(); f.fail(cause); assertNull(map1.result()); assertSame(cause, map1.cause()); assertNull(map2.result()); assertSame(cause, map2.cause()); }
@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(); }
@Test public void testExecuteUnorderedBlocking() throws Exception { Context context = vertx.getOrCreateContext(); context.executeBlocking(f -> { assertTrue(Context.isOnWorkerThread()); f.complete(1 + 2); }, false, r -> { assertTrue(Context.isOnEventLoopThread()); assertEquals(r.result(), 3); 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")); } } } }); }
@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 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(); }
@Test public void testExecuteOrderedBlocking() throws Exception { Context context = vertx.getOrCreateContext(); context.executeBlocking(f -> { assertTrue(Context.isOnWorkerThread()); f.complete(1 + 2); }, r -> { assertTrue(Context.isOnEventLoopThread()); assertEquals(r.result(), 3); testComplete(); }); await(); }