scope.route, scope.originalRequest, new ComplexFuture<>(null), HttpClientContext.create(), scope.execRuntime.fork());
@Override public void cancelled() { future.cancel(); }
@Override public void completed(final T result) { future.completed(result); }
@Test public void testCancelled() throws Exception { final ComplexFuture<Object> future = new ComplexFuture<>(null); final Future<Object> dependency1 = new BasicFuture<>(null); future.setDependency(dependency1); Assert.assertFalse(future.isDone()); future.cancel(); Assert.assertThat(future.isCancelled(), CoreMatchers.is(true)); Assert.assertThat(dependency1.isCancelled(), CoreMatchers.is(true)); final Future<Object> dependency2 = new BasicFuture<>(null); future.setDependency(dependency2); Assert.assertThat(dependency2.isCancelled(), CoreMatchers.is(true)); }
@Override public final <T> Future<T> execute( final AsyncRequestProducer requestProducer, final AsyncResponseConsumer<T> responseConsumer, final HandlerFactory<AsyncPushConsumer> pushHandlerFactory, final HttpContext context, final FutureCallback<T> callback) { final ComplexFuture<T> future = new ComplexFuture<>(callback); future.setDependency(execute(new BasicClientExchangeHandler<>( requestProducer, responseConsumer, new FutureCallback<T>() { @Override public void completed(final T result) { future.completed(result); } @Override public void failed(final Exception ex) { future.failed(ex); } @Override public void cancelled() { future.cancel(); } }), pushHandlerFactory, context)); return future; }
@Test public void testCompleted() throws Exception { final ComplexFuture<Object> future = new ComplexFuture<>(null); final Future<Object> dependency1 = new BasicFuture<>(null); future.setDependency(dependency1); Assert.assertFalse(future.isDone()); future.completed(Boolean.TRUE); Assert.assertThat(future.isCancelled(), CoreMatchers.is(false)); Assert.assertThat(dependency1.isCancelled(), CoreMatchers.is(false)); final Future<Object> dependency2 = new BasicFuture<>(null); future.setDependency(dependency2); Assert.assertThat(dependency2.isCancelled(), CoreMatchers.is(true)); }
Args.notNull(timeout, "Timeout"); final InternalConnectionEndpoint internalEndpoint = cast(endpoint); final ComplexFuture<AsyncConnectionEndpoint> resultFuture = new ComplexFuture<>(callback); if (internalEndpoint.isConnected()) { resultFuture.completed(endpoint); return resultFuture; resultFuture.setDependency(connectFuture); return resultFuture;
return connectionInitiator.connect(remoteEndpoint, remoteAddress, localAddress, connectTimeout, attachment, callback); final ComplexFuture<IOSession> future = new ComplexFuture<>(callback); final InetAddress[] remoteAddresses; try { remoteAddresses = dnsResolver.resolve(remoteEndpoint.getHostName()); } catch (final UnknownHostException ex) { future.failed(ex); return future;
@Override public void failed(final Exception ex) { resultFuture.failed(ex); }
@Override public void completed(final AsyncConnectionEndpoint connectionEndpoint) { if (connectionEndpoint.isConnected()) { resultFuture.completed(connectionEndpoint); } else { final Future<AsyncConnectionEndpoint> connectFuture = connmgr.connect( connectionEndpoint, getConnectionInitiator(), connectTimeout, versionPolicy, clientContext, new FutureCallback<AsyncConnectionEndpoint>() { @Override public void completed(final AsyncConnectionEndpoint result) { resultFuture.completed(result); } @Override public void failed(final Exception ex) { resultFuture.failed(ex); } @Override public void cancelled() { resultFuture.cancel(true); } }); resultFuture.setDependency(connectFuture); } }
@Override public void completed(final ManagedAsyncClientConnection connection) { try { if (log.isDebugEnabled()) { log.debug(ConnPoolSupport.getId(internalEndpoint) + ": connected " + ConnPoolSupport.getId(connection)); } poolEntry.assignConnection(connection); resultFuture.completed(internalEndpoint); } catch (final RuntimeException ex) { resultFuture.failed(ex); } }
public void setDependency(final Future<?> dependency) { Args.notNull(dependency, "dependency"); if (dependency instanceof Cancellable) { setDependency((Cancellable) dependency); } else { setDependency(new Cancellable() { @Override public boolean cancel() { return dependency.cancel(true); } }); } }
@Override public void setDependency(final Cancellable dependency) { Args.notNull(dependency, "dependency"); if (isDone()) { dependency.cancel(); } else { dependencyRef.set(dependency); } }
@Test public void testCancelledWithCallback() throws Exception { final ComplexFuture<Object> future = new ComplexFuture<>(null); final Future<Object> dependency1 = new BasicFuture<>(new FutureCallback<Object>() { @Override public void completed(final Object result) { } @Override public void failed(final Exception ex) { future.failed(ex); } @Override public void cancelled() { future.cancel(); } }); future.setDependency(dependency1); Assert.assertFalse(future.isDone()); future.cancel(); Assert.assertThat(future.isCancelled(), CoreMatchers.is(true)); Assert.assertThat(dependency1.isCancelled(), CoreMatchers.is(true)); final Future<Object> dependency2 = new BasicFuture<>(null); future.setDependency(dependency2); Assert.assertThat(dependency2.isCancelled(), CoreMatchers.is(true)); }
log.debug("Connection request: " + ConnPoolSupport.formatStats(null, route, state, pool)); final ComplexFuture<AsyncConnectionEndpoint> resultFuture = new ComplexFuture<>(callback); final Future<PoolEntry<HttpRoute, ManagedAsyncClientConnection>> leaseFuture = pool.lease( route, state, requestTimeout, new FutureCallback<PoolEntry<HttpRoute, ManagedAsyncClientConnection>>() { resultFuture.setDependency(leaseFuture); return resultFuture;
final FutureCallback<T> callback) { ensureRunning(); final ComplexFuture<T> future = new ComplexFuture<>(callback); try { final HttpClientContext clientContext = HttpClientContext.adapt(context); future.failed(ex);
@Override public void failed(final Exception ex) { future.failed(ex); }
resultFuture.completed(endpoint); } else { final Future<IOSession> futute = requestSession(host, timeout, attachment, new FutureCallback<IOSession>() { resultFuture.setDependency(futute);
public void setDependency(final Future<?> dependency) { Args.notNull(dependency, "dependency"); if (dependency instanceof Cancellable) { setDependency((Cancellable) dependency); } else { setDependency(new Cancellable() { @Override public boolean cancel() { return dependency.cancel(true); } }); } }
@Override public void setDependency(final Cancellable dependency) { Args.notNull(dependency, "dependency"); if (isDone()) { dependency.cancel(); } else { dependencyRef.set(dependency); } }