@Override public void undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler) { HAManager haManager = haManager(); Future<Void> haFuture = Future.future(); if (haManager != null && haManager.isEnabled()) { this.executeBlocking(fut -> { haManager.removeFromHA(deploymentID); fut.complete(); }, false, haFuture); } else { haFuture.complete(); } haFuture.compose(v -> { Future<Void> deploymentFuture = Future.future(); deploymentManager.undeployVerticle(deploymentID, deploymentFuture); return deploymentFuture; }).setHandler(completionHandler); }
@Override public void process(JsonObject document, Handler<AsyncResult<JsonObject>> resultHandler) { System.out.println("Processing..."); JsonObject result = document.copy(); if (!document.containsKey("name")) { resultHandler.handle(ServiceException.fail(NO_NAME_ERROR, "No name in the document")); } else if (document.getString("name").isEmpty() || document.getString("name").equalsIgnoreCase("bad")) { resultHandler.handle(ServiceException.fail(BAD_NAME_ERROR, "Bad name in the document: " + document.getString("name"), new JsonObject().put("name", document.getString("name")))); } else { result.put("approved", true); resultHandler.handle(Future.succeededFuture(result)); } }
@Override public void start(Future<Void> startFuture) throws Exception { JsonObject options = new JsonObject().put("telnetOptions", new JsonObject(). put("host", "localhost"). put("port", 3000) ); vertx.deployVerticle("service:io.vertx.ext.shell", new DeploymentOptions().setConfig(options), ar -> { if (ar.succeeded()) { startFuture.succeeded(); } else { startFuture.fail(ar.cause()); } }); } }
public Push(Http2Stream stream, String contentEncoding, HttpMethod method, String uri, boolean writable, Handler<AsyncResult<HttpServerResponse>> completionHandler) { super(Http2ServerConnection.this, stream, writable); this.method = method; this.uri = uri; this.contentEncoding = contentEncoding; this.completionHandler = Future.<HttpServerResponse>future().setHandler(completionHandler); }
@Override public void connect(ConnectionListener<HttpClientConnection> listener, ContextInternal context, Handler<AsyncResult<ConnectResult<HttpClientConnection>>> handler) { Future<ConnectResult<HttpClientConnection>> future = Future.<ConnectResult<HttpClientConnection>>future().setHandler(handler); try { doConnect(listener, context, future); } catch(Exception e) { future.tryFail(e); } }
private void notifyHandler(ChannelFuture future) { if (future.isSuccess()) { handler.handle(Future.succeededFuture(result)); } else { handler.handle(Future.failedFuture(future.cause())); } } }
@Override public void methodWithHandlerAsyncResultListComplexJsonArray(Handler<AsyncResult<List<JsonArray>>> listHandler) { List<JsonArray> list = Arrays.asList(new JsonArray().add(new JsonObject().put("foo", "hello")), new JsonArray().add(new JsonObject().put("bar", "bye"))); listHandler.handle(Future.succeededFuture(list)); }
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())); } }); }
@Override public void start(Handler<AsyncResult<Void>> resultHandler) { HAManager haManager = vertx.haManager(); setClusterViewChangedHandler(haManager); clusterManager.<String, ClusterNodeInfo>getAsyncMultiMap(SUBS_MAP_NAME, ar1 -> { if (ar1.succeeded()) { subs = ar1.result(); server = vertx.createNetServer(getServerOptions()); if (asyncResult.succeeded()) { int serverPort = getClusterPublicPort(options, server.actualPort()); String serverHost = getClusterPublicHost(options); serverID = new ServerID(serverPort, serverHost); nodeInfo = new ClusterNodeInfo(clusterManager.getNodeID(), serverID); vertx.executeBlocking(fut -> { haManager.addDataToAHAInfo(SERVER_ID_HA_KEY, new JsonObject().put("host", serverID.host).put("port", serverID.port)); fut.complete(); }, false, ar2 -> { if (ar2.succeeded()) { started = true; resultHandler.handle(Future.succeededFuture()); } else { resultHandler.handle(Future.failedFuture(ar2.cause())); resultHandler.handle(Future.failedFuture(asyncResult.cause())); resultHandler.handle(Future.failedFuture(ar1.cause()));
@Override public void parseCredentials(RoutingContext context, Handler<AsyncResult<JsonObject>> handler) { if (skip != null && context.normalisedPath().startsWith(skip)) { context.next(); return; } parseAuthorization(context, false, parseAuthorization -> { if (parseAuthorization.failed()) { handler.handle(Future.failedFuture(parseAuthorization.cause())); return; } handler.handle(Future.succeededFuture(new JsonObject().put("jwt", parseAuthorization.result()).put("options", options))); }); }
@Override public void start(Future<Void> startFuture) throws Exception { HttpServerOptions options = new HttpServerOptions().setPort(config().getInteger("port")); vertx.createHttpServer(options).requestHandler(request -> { String name = request.getParam("name"); if (name == null) { request.response().setStatusCode(400).end("Missing name"); } else { vertx.eventBus().<String>send("hello", name, ar -> { if (ar.succeeded()) { request.response().end(ar.result().body()); } else { request.response().setStatusCode(500).end(ar.cause().getMessage()); } }); } }).listen(ar -> { if (ar.succeeded()) { startFuture.complete(); } else { startFuture.fail(ar.cause()); } }); } }
void subscribe(Handler<WebSocket> completionHandler, Handler<Throwable> failureHandler) { Future<WebSocket> fut = Future.future(); fut.setHandler(ar -> { if (ar.succeeded()) { completionHandler.handle(ar.result()); } else { failureHandler.handle(ar.cause()); } }); exceptionHandler(fut::tryFail); handler(fut::tryComplete); }
@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 SomeDatabaseService getDataById(int id, Handler<AsyncResult<JsonObject>> resultHandler) { if (id > 0) { resultHandler.handle(Future.succeededFuture(new JsonObject() .put("id", id) .put("name", "vertx"))); } else { resultHandler.handle(Future.failedFuture("Invalid id")); } return this; } }
protected <K> void removeOne(K id, String sql, Handler<AsyncResult<Void>> resultHandler) { client.getConnection(connHandler(resultHandler, connection -> { JsonArray params = new JsonArray().add(id); connection.updateWithParams(sql, params, r -> { if (r.succeeded()) { resultHandler.handle(Future.succeededFuture()); } else { resultHandler.handle(Future.failedFuture(r.cause())); } connection.close(); }); })); }
@Override public void start(Future<Void> startFuture) throws Exception { vertx.deployVerticle("java:" + ChildVerticle.class.getName(), ar -> { if (ar.succeeded()) { startFuture.complete(null); } else { ar.cause().printStackTrace(); } }); } }
Handler<AsyncResult<String>> completionHandler, ClassLoader tccl, Verticle... verticles) { JsonObject conf = options.getConfig() == null ? new JsonObject() : options.getConfig().copy(); // Copy it String poolName = options.getWorkerPoolName(); AtomicBoolean failureReported = new AtomicBoolean(); for (Verticle verticle: verticles) { WorkerExecutorInternal workerExec = poolName != null ? vertx.createSharedWorkerExecutor(poolName, options.getWorkerPoolSize(), options.getMaxWorkerExecuteTime(), options.getMaxWorkerExecuteTimeUnit()) : null; WorkerPool pool = workerExec != null ? workerExec.getPool() : null; ContextImpl context = options.isWorker() ? vertx.createWorkerContext(deploymentID, pool, conf, tccl) : vertx.createEventLoopContext(deploymentID, pool, conf, tccl); if (workerExec != null) { context.addCloseHook(workerExec); try { verticle.init(vertx, context); Future<Void> startFuture = Future.future(); verticle.start(startFuture); startFuture.setHandler(ar -> { if (ar.succeeded()) { if (parent != null) { if (parent.addChild(deployment)) { deployment.rollback(callingContext, completionHandler, context, ar.cause());
@Override public void start(Future<Void> startFuture) throws Exception { HttpServer server = vertx.createHttpServer(new HttpServerOptions().setPort(8080)); server.requestHandler(req -> req.response().end()); server.listen(res -> { if (res.succeeded()) { startFuture.complete(); } else { startFuture.fail(res.cause()); } }); } }
JsonObject conf = getConfiguration(); if (conf == null) { conf = new JsonObject(); ((VertxInternal) vertx).addCloseHook(completionHandler -> { try { beforeStoppingVertx(vertx); completionHandler.handle(Future.succeededFuture()); } catch (Exception e) { completionHandler.handle(Future.failedFuture(e));
@Override public void start() throws Exception { Future<String> future = anAsyncAction(); future.compose(this::anotherAsyncAction) .setHandler(ar -> { if (ar.failed()) { System.out.println("Something bad happened"); ar.cause().printStackTrace(); } else { System.out.println("Result: " + ar.result()); } }); }