protected <T> void addRegistration(boolean newAddress, String address, boolean replyHandler, boolean localOnly, Handler<AsyncResult<Void>> completionHandler) { completionHandler.handle(Future.succeededFuture()); }
private void notifyHandler(ChannelFuture future) { if (future.isSuccess()) { handler.handle(Future.succeededFuture(result)); } else { handler.handle(Future.failedFuture(future.cause())); } } }
@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())); } }); }
private synchronized void doUndeployChildren(ContextInternal undeployingContext, Handler<AsyncResult<Void>> completionHandler) { if (!children.isEmpty()) { final int size = children.size(); AtomicInteger childCount = new AtomicInteger(); boolean undeployedSome = false; for (Deployment childDeployment: new HashSet<>(children)) { undeployedSome = true; childDeployment.doUndeploy(undeployingContext, ar -> { children.remove(childDeployment); if (ar.failed()) { reportFailure(ar.cause(), undeployingContext, completionHandler); } else if (childCount.incrementAndGet() == size) { // All children undeployed completionHandler.handle(Future.succeededFuture()); } }); } if (!undeployedSome) { // It's possible that children became empty before iterating completionHandler.handle(Future.succeededFuture()); } } else { completionHandler.handle(Future.succeededFuture()); } }
@Test public void testCloseHooksCalled() throws Exception { AtomicInteger closedCount = new AtomicInteger(); Closeable myCloseable1 = completionHandler -> { closedCount.incrementAndGet(); completionHandler.handle(Future.succeededFuture()); }; Closeable myCloseable2 = completionHandler -> { closedCount.incrementAndGet(); completionHandler.handle(Future.succeededFuture()); }; VertxInternal vertx = (VertxInternal) Vertx.vertx(); vertx.addCloseHook(myCloseable1); vertx.addCloseHook(myCloseable2); // Now undeploy vertx.close(ar -> { assertTrue(ar.succeeded()); assertEquals(2, closedCount.get()); testComplete(); }); await(); }
@Test public void testSetResultOnCompletedFuture() { ArrayList<Future<Object>> futures = new ArrayList<>(); futures.add(Future.succeededFuture()); futures.add(Future.succeededFuture()); futures.add(Future.succeededFuture(new Object())); futures.add(Future.succeededFuture(new Object())); futures.add(Future.failedFuture(new Exception())); futures.add(Future.failedFuture(new Exception())); for (Future<Object> future : futures) { try { future.complete(new Object()); fail(); } catch (IllegalStateException ignore) { } assertFalse(future.tryComplete(new Object())); try { future.complete(null); fail(); } catch (IllegalStateException ignore) { } assertFalse(future.tryComplete(null)); try { future.fail(new Exception()); fail(); } catch (IllegalStateException ignore) { } assertFalse(future.tryFail(new Exception())); } }
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")); } } } }); }
private void executeCloseDone(ContextInternal closeContext, Handler<AsyncResult<Void>> done, Exception e) { if (done != null) { Future<Void> fut = e == null ? Future.succeededFuture() : Future.failedFuture(e); closeContext.runOnContext(v -> done.handle(fut)); } }
public synchronized void start(Handler<AsyncResult<Void>> completionHandler) { if (started) { throw new IllegalStateException("Already started"); } started = true; completionHandler.handle(Future.succeededFuture()); }
private void closeClusterManager(Handler<AsyncResult<Void>> completionHandler) { if (clusterManager != null) { clusterManager.leave(ar -> { if (ar.failed()) { log.error("Failed to leave cluster", ar.cause()); } if (completionHandler != null) { runOnContext(v -> completionHandler.handle(Future.succeededFuture())); } }); } else if (completionHandler != null) { runOnContext(v -> completionHandler.handle(Future.succeededFuture())); } }
@Test public void testFailedDeployRunsContextShutdownHook() throws Exception { AtomicBoolean closeHookCalledBeforeDeployFailure = new AtomicBoolean(false); Closeable closeable = completionHandler -> { closeHookCalledBeforeDeployFailure.set(true); completionHandler.handle(Future.succeededFuture()); }; Verticle v = new AbstractVerticle() { @Override public void start(Future<Void> startFuture) throws Exception { this.context.addCloseHook(closeable); startFuture.fail("Fail to deploy."); } }; vertx.deployVerticle(v, asyncResult -> { assertTrue(closeHookCalledBeforeDeployFailure.get()); assertTrue(asyncResult.failed()); assertNull(asyncResult.result()); testComplete(); }); await(); }
@Test public void testCloseHooksCalled() throws Exception { AtomicInteger closedCount = new AtomicInteger(); Closeable myCloseable1 = completionHandler -> { closedCount.incrementAndGet(); completionHandler.handle(Future.succeededFuture()); }; Closeable myCloseable2 = completionHandler -> { closedCount.incrementAndGet(); completionHandler.handle(Future.succeededFuture()); }; VertxInternal vertx = (VertxInternal) Vertx.vertx(); vertx.addCloseHook(myCloseable1); vertx.addCloseHook(myCloseable2); // Now undeploy vertx.close(ar -> { assertTrue(ar.succeeded()); assertEquals(2, closedCount.get()); testComplete(); }); await(); }
@Test public void testToString() { assertEquals("Future{unresolved}", Future.future().toString()); assertEquals("Future{result=abc}", Future.succeededFuture("abc").toString()); assertEquals("Future{cause=It's like that, and that's the way it is}", Future.failedFuture("It's like that, and that's the way it is").toString()); Future<String> f = Future.future(); f.complete("abc"); assertEquals("Future{result=abc}", f.toString()); f = Future.future(); f.fail("abc"); assertEquals("Future{cause=abc}", f.toString()); }
@Override public <K, V> void getAsyncMap(String name, Handler<AsyncResult<AsyncMap<K, V>>> resultHandler) { Objects.requireNonNull(name, "name"); Objects.requireNonNull(resultHandler, "resultHandler"); if (clusterManager == null) { getLocalAsyncMap(name, resultHandler); } else { 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())); } }); } }
private void executeCloseDone(final ContextInternal closeContext, final Handler<AsyncResult<Void>> done, final Exception e) { if (done != null) { Future<Void> fut = e != null ? Future.failedFuture(e) : Future.succeededFuture(); closeContext.runOnContext((v) -> done.handle(fut)); } }
@Override public void clear(Handler<AsyncResult<Void>> resultHandler) { map.clear(); resultHandler.handle(Future.succeededFuture()); }
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())); } }
@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);
private void testAllLargeList(int size) { List<Future> list = new ArrayList<>(); for (int i = 0;i < size;i++) { list.add(Future.succeededFuture()); } CompositeFuture composite = CompositeFuture.all(list); Checker<CompositeFuture> checker = new Checker<>(composite); checker.assertSucceeded(composite); for (int i = 0;i < size;i++) { list.clear(); Throwable cause = new Exception(); for (int j = 0;j < size;j++) { list.add(i == j ? Future.failedFuture(cause) : Future.succeededFuture()); } composite = CompositeFuture.all(list); checker = new Checker<>(composite); checker.assertFailed(cause); for (int j = 0;j < size;j++) { if (i == j) { assertTrue(composite.failed(j)); } else { assertTrue(composite.succeeded(j)); } } } }