@Override public HttpServerResponse push(HttpMethod method, String host, String path, MultiMap headers, Handler<AsyncResult<HttpServerResponse>> handler) { handler.handle(Future.failedFuture("Push promise is only supported with HTTP2")); return this; }
private void notifyHandler(ChannelFuture future) { if (future.isSuccess()) { handler.handle(Future.succeededFuture(result)); } else { handler.handle(Future.failedFuture(future.cause())); } } }
@Override public void clear(Handler<AsyncResult<Void>> resultHandler) { map.clear(); resultHandler.handle(Future.succeededFuture()); }
@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()); } }
/** * 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); }); }
@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 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)); } }
@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; }
@Override public void values(Handler<AsyncResult<List<V>>> asyncResultHandler) { List<V> result = map.values().stream() .filter(Holder::hasNotExpired) .map(h -> h.value) .collect(toList()); asyncResultHandler.handle(Future.succeededFuture(result)); }
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(); }
void timeout() { if (status.compareAndSet(Status.WAITING, Status.TIMED_OUT)) { handler.handle(Future.failedFuture("Timed out waiting to get lock")); } }
/** * Undeploys the previously deployed verticle. * * @param completionHandler the completion handler */ public void undeploy(Handler<AsyncResult<Void>> completionHandler) { vertx.undeploy(deploymentId, res -> { if (res.failed()) { log.error("Failed in undeploying " + deploymentId, res.cause()); } else { log.info("Succeeded in undeploying " + deploymentId); } deploymentId = null; completionHandler.handle(res); }); }
@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())); } }); } }