@Override public synchronized HttpClientRequest handler(Handler<AsyncResult<HttpClientResponse>> handler) { respHandler.setHandler(handler); return this; }
@Override public synchronized HttpClientRequest handler(Handler<AsyncResult<HttpClientResponse>> handler) { if (handler != null) { checkComplete(); } respFut.setHandler(handler); return this; }
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); }
/** * Map the result of a future to a specific {@code value}.<p> * * When this future succeeds, this {@code value} will complete the future returned by this method call.<p> * * When this future fails, the failure will be propagated to the returned future. * * @param value the value that eventually completes the mapped future * @return the mapped future */ default <V> Future<V> map(V value) { Future<V> ret = Future.future(); setHandler(ar -> { if (ar.succeeded()) { ret.complete(value); } else { ret.fail(ar.cause()); } }); return ret; }
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); }
StreamImpl(Http1xClientConnection conn, int id, Handler<AsyncResult<HttpClientStream>> handler) { this.conn = conn; this.fut = Future.<HttpClientStream>future().setHandler(handler); this.id = id; this.queue = new InboundBuffer<>(conn.context, 5); }
/** * Map the failure of a future to a specific {@code value}.<p> * * When this future fails, this {@code value} will complete the future returned by this method call.<p> * * When this future succeeds, the result will be propagated to the returned future. * * @param value the value that eventually completes the mapped future * @return the mapped future */ default Future<T> otherwise(T value) { Future<T> ret = Future.future(); setHandler(ar -> { if (ar.succeeded()) { ret.complete(result()); } else { ret.complete(value); } }); return ret; }
Checker(Future<T> future) { future.setHandler(ar -> { count.incrementAndGet(); result.set(ar); }); this.future = future; }
@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()); } }); }
protected void doHandleResponse(HttpClientResponseImpl resp, long timeoutMs) { if (reset == null) { int statusCode = resp.statusCode(); if (followRedirects > 0 && statusCode >= 300 && statusCode < 400) { Future<HttpClientRequest> next = client.redirectHandler().apply(resp); if (next != null) { next.setHandler(ar -> { if (ar.succeeded()) { handleNextRequest((HttpClientRequestImpl) ar.result(), timeoutMs); } else { handleException(ar.cause()); } }); return; } } if (statusCode == 100) { if (continueHandler != null) { continueHandler.handle(null); } } else { respFut.complete(resp); } } }
@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); } }
public Query(String name, DnsRecordType[] types, Handler<AsyncResult<List<T>>> handler) { this.msg = new DatagramDnsQuery(null, dnsServer, ThreadLocalRandom.current().nextInt()).setRecursionDesired(options.isRecursionDesired()); for (DnsRecordType type: types) { msg.addRecord(DnsSection.QUESTION, new DefaultDnsQuestion(name, type, DnsRecord.CLASS_IN)); } this.fut = Future.<List<T>>future().setHandler(handler); this.types = types; this.name = name; }
private static CompositeFuture join(Function<CompositeFuture, Throwable> pred, Future<?>... results) { CompositeFutureImpl composite = new CompositeFutureImpl(results); int len = results.length; for (int i = 0; i < len; i++) { results[i].setHandler(ar -> { Handler<AsyncResult<CompositeFuture>> handler = null; synchronized (composite) { composite.count++; if (!composite.isComplete() && composite.count == len) { // Take decision here Throwable failure = pred.apply(composite); handler = composite.setCompleted(failure); } } if (handler != null) { handler.handle(composite); } }); } if (len == 0) { composite.setCompleted(null); } return composite; }
@Override public void start(Future<Void> future) { startTransactionService(); startHttpServer().setHandler(future.completer()); }
@Override public void connect(ConnectionListener<FakeConnection> listener, ContextInternal context, Handler<AsyncResult<ConnectResult<FakeConnection>>> handler) { pendingRequests.add(new FakeConnection(context, listener, Future.<ConnectResult<FakeConnection>>future().setHandler(handler))); } }
@Test public void testReleaseHandlerAfterCompletion() throws Exception { Future<String> f = Future.future(); Field handlerField = f.getClass().getDeclaredField("handler"); handlerField.setAccessible(true); f.setHandler(ar -> {}); f.complete(); assertNull(handlerField.get(f)); f.setHandler(ar -> {}); assertNull(handlerField.get(f)); f = Future.future(); f.setHandler(ar -> {}); f.fail("abc"); assertNull(handlerField.get(f)); f.setHandler(ar -> {}); assertNull(handlerField.get(f)); }
@Override public void connect(ConnectionListener<FakeConnection> listener, ContextInternal context, Handler<AsyncResult<ConnectResult<FakeConnection>>> handler) { int i = ThreadLocalRandom.current().nextInt(100); FakeConnection conn = new FakeConnection(context, listener, Future.<ConnectResult<FakeConnection>>future().setHandler(handler)); if (i < 10) { conn.fail(new Exception("Could not connect")); } else { conn.connect(); } } };
@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); }
private void pausingServer(Consumer<Future<Void>> consumer) { Future<Void> resumeFuture = Future.future(); server.requestHandler(req -> { req.response().setChunked(true); req.pause(); Context ctx = vertx.getOrCreateContext(); resumeFuture.setHandler(v1 -> { ctx.runOnContext(v2 -> { req.resume(); }); }); req.handler(buff -> { req.response().write(buff); }); }); server.listen(onSuccess(s -> consumer.accept(resumeFuture))); }
@Test public void testServerDrainHandler() { drainingServer(resumeFuture -> { client.request(HttpMethod.GET, DEFAULT_HTTP_PORT, DEFAULT_HTTP_HOST, DEFAULT_TEST_URI, onSuccess(resp -> { resp.pause(); resumeFuture.setHandler(ar -> resp.resume()); })).end(); }); await(); }