public <T> Future<T> execute( final Request request, final HttpClientResponseHandler<T> handler, final FutureCallback<T> callback) { final BasicFuture<T> future = new BasicFuture<>(callback); final ExecRunnable<T> runnable = new ExecRunnable<>( future, request, this.executor != null ? this.executor : Executor.newInstance(), handler); if (this.concurrentExec != null) { this.concurrentExec.execute(runnable); } else { final Thread t = new Thread(runnable); t.setDaemon(true); t.start(); } return future; }
@Override public void completed(final T result) { future.completed(result); }
public void failed(final Exception cause) { if (future != null) { future.failed(cause); } }
@Test public void testCompletedWithTimeout() throws Exception { final BasicFutureCallback<Object> callback = new BasicFutureCallback<>(); final BasicFuture<Object> future = new BasicFuture<>(callback); Assert.assertFalse(future.isDone()); final Object result = new Object(); final Exception boom = new Exception(); future.completed(result); future.failed(boom); Assert.assertTrue(callback.isCompleted()); Assert.assertSame(result, callback.getResult()); Assert.assertFalse(callback.isFailed()); Assert.assertNull(callback.getException()); Assert.assertFalse(callback.isCancelled()); Assert.assertSame(result, future.get(1, TimeUnit.MILLISECONDS)); Assert.assertTrue(future.isDone()); Assert.assertFalse(future.isCancelled()); }
@Override public void cancelled() { future.cancel(); } });
@Override public void consumeResponse( final HttpResponse response, final EntityDetails entityDetails, final HttpContext httpContext, final FutureCallback<Void> resultCallback ) { this.entityDetails = entityDetails; this.responseCompletion = new BasicFuture<>(resultCallback); this.responseFuture.completed(new Message<HttpResponse, Publisher<ByteBuffer>>(response, reactiveDataConsumer)); }
@Test public void testAsyncFailed() throws Exception { final BasicFuture<Object> future = new BasicFuture<>(null); final Exception boom = new Exception(); final Thread t = new Thread() { @Override public void run() { try { Thread.sleep(100); future.failed(boom); } catch (final InterruptedException ex) { } } }; t.setDaemon(true); t.start(); try { future.get(60, TimeUnit.SECONDS); } catch (final ExecutionException ex) { Assert.assertSame(boom, ex.getCause()); } Assert.assertTrue(future.isDone()); Assert.assertFalse(future.isCancelled()); }
@Test(expected=TimeoutValueException.class) public void testAsyncNegativeTimeout() throws Exception { final BasicFuture<Object> future = new BasicFuture<>(null); future.get(-1, TimeUnit.MILLISECONDS); }
@Test public void testCancelled() throws Exception { final ComplexCancellable cancellable = new ComplexCancellable(); final BasicFuture<Object> dependency1 = new BasicFuture<>(null); cancellable.setDependency(dependency1); Assert.assertFalse(cancellable.isCancelled()); cancellable.cancel(); Assert.assertThat(cancellable.isCancelled(), CoreMatchers.is(true)); Assert.assertThat(dependency1.isCancelled(), CoreMatchers.is(true)); final BasicFuture<Object> dependency2 = new BasicFuture<>(null); cancellable.setDependency(dependency2); Assert.assertThat(dependency2.isCancelled(), CoreMatchers.is(true)); }
@Override public boolean isCancelled() { return future.isCancelled(); }
public boolean isDone() { return this.future.isDone(); }
@Override public IOSession get(final long timeout, final TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException { return future.get(timeout, unit); }
@Test public void testCompleted() throws Exception { final BasicFutureCallback<Object> callback = new BasicFutureCallback<>(); final BasicFuture<Object> future = new BasicFuture<>(callback); Assert.assertFalse(future.isDone()); final Object result = new Object(); final Exception boom = new Exception(); future.completed(result); future.failed(boom); Assert.assertTrue(callback.isCompleted()); Assert.assertSame(result, callback.getResult()); Assert.assertFalse(callback.isFailed()); Assert.assertNull(callback.getException()); Assert.assertFalse(callback.isCancelled()); Assert.assertSame(result, future.get()); Assert.assertTrue(future.isDone()); Assert.assertFalse(future.isCancelled()); }
@Override public void cancelled() { future.cancel(); } });
@Override public void consumeResponse( final HttpResponse response, final EntityDetails entityDetails, final HttpContext httpContext, final FutureCallback<Void> resultCallback ) { this.entityDetails = entityDetails; this.responseCompletion = new BasicFuture<>(resultCallback); this.responseFuture.completed(new Message<HttpResponse, Publisher<ByteBuffer>>(response, reactiveDataConsumer)); }
@Test public void testAsyncCompleted() throws Exception { final BasicFuture<Object> future = new BasicFuture<>(null); final Object result = new Object(); final Thread t = new Thread() { @Override public void run() { try { Thread.sleep(100); future.completed(result); } catch (final InterruptedException boom) { } } }; t.setDaemon(true); t.start(); Assert.assertSame(result, future.get(60, TimeUnit.SECONDS)); Assert.assertTrue(future.isDone()); Assert.assertFalse(future.isCancelled()); }
@Test(expected = CancellationException.class) public void testAsyncCancelled() throws Exception { final BasicFuture<Object> future = new BasicFuture<>(null); final Thread t = new Thread() { @Override public void run() { try { Thread.sleep(100); future.cancel(true); } catch (final InterruptedException ex) { } } }; t.setDaemon(true); t.start(); future.get(60, TimeUnit.SECONDS); }
@Override public boolean isCancelled() { return future.isCancelled(); }