@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 <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 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()); }
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)); } }
private void doFailed(Handler<AsyncResult<NetSocket>> connectHandler, Throwable th) { connectHandler.handle(Future.failedFuture(th)); }
@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())); } }
@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)); } }
void timeout() { if (status.compareAndSet(Status.WAITING, Status.TIMED_OUT)) { handler.handle(Future.failedFuture("Timed out waiting to get lock")); } }
private void testAnyLargeList(int size) { List<Future> list = new ArrayList<>(); for (int i = 0;i < size;i++) { list.add(Future.failedFuture(new Exception())); } CompositeFuture composite = CompositeFuture.any(list); Checker<CompositeFuture> checker = new Checker<>(composite); checker.assertFailed(); for (int i = 0;i < size;i++) { list.clear(); for (int j = 0;j < size;j++) { list.add(i == j ? Future.succeededFuture() : Future.failedFuture(new RuntimeException())); } composite = CompositeFuture.any(list); checker = new Checker<>(composite); checker.assertSucceeded(composite); for (int j = 0;j < size;j++) { if (i == j) { assertTrue(composite.succeeded(j)); } else { assertTrue(composite.failed(j)); } } } }
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 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; } }
@Override public void deployVerticle(Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) { boolean closed; synchronized (this) { closed = this.closed; } if (closed) { if (completionHandler != null) { completionHandler.handle(Future.failedFuture("Vert.x closed")); } } else { deploymentManager.deployVerticle(verticleSupplier, options, completionHandler); } }
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)); } } } }
private void startEventBus(Handler<AsyncResult<Vertx>> resultHandler) { eventBus.start(ar -> { if (ar.succeeded()) { initializeHaManager(resultHandler); } else { log.error("Failed to start event bus", ar.cause()); resultHandler.handle(Future.failedFuture(ar.cause())); } }); }
@Override public NetSocketInternal writeMessage(Object message, Handler<AsyncResult<Void>> handler) { ChannelPromise promise = chctx.newPromise(); super.writeToChannel(message, promise); promise.addListener((future) -> { if (future.isSuccess()) { handler.handle(Future.succeededFuture()); } else { handler.handle(Future.failedFuture(future.cause())); } } ); return this; }
private void notifyException(final Handler<AsyncResult<DatagramSocket>> handler, final Throwable cause) { context.executeFromIO(v -> handler.handle(Future.failedFuture(cause))); }
@Test public void testStateAfterCompletion() { Object foo = new Object(); Future<Object> future = Future.succeededFuture(foo); assertTrue(future.succeeded()); assertFalse(future.failed()); assertTrue(future.isComplete()); assertEquals(foo, future.result()); assertNull(future.cause()); Exception cause = new Exception(); future = Future.failedFuture(cause); assertFalse(future.succeeded()); assertTrue(future.failed()); assertTrue(future.isComplete()); assertNull(future.result()); assertEquals(cause, future.cause()); }