private void addCallback() { if (workerFuture != null) { Futures.addCallback(workerFuture, this); } }
Futures.addCallback(this, callback, executor);
@Override public FluentFuture<V> addCallback(FutureCallback<V> callback) { Futures.addCallback(this, callback, executor); return this; }
@Override public void onSuccess(@Nullable I result) { final ListenableFuture<O> transformFuture = transform.apply(result); Futures.addCallback(transformFuture, new FutureCallback<O>() { @Override public void onSuccess(@Nullable O result) { finalFuture.set(result); } @Override public void onFailure(Throwable t) { finalFuture.setException(t); } }); }
@Override public void writeRecord(OUT record) throws IOException { if (exception != null) { throw new IOException("write record failed", exception); } ListenableFuture<Void> result = mapper.saveAsync(record); Futures.addCallback(result, callback); }
public void testWildcardFuture() { SettableFuture<String> settable = SettableFuture.create(); ListenableFuture<?> f = settable; FutureCallback<Object> callback = new FutureCallback<Object>() { @Override public void onSuccess(Object result) {} @Override public void onFailure(Throwable t) {} }; addCallback(f, callback, directExecutor()); }
@Override public void startScheduling() { for (ChainingCallback chainingCallback : chainingCallbacks) { ListenableScheduledFuture<CeWorker.Result> future = executorService.schedule(chainingCallback.worker, delayBetweenEnabledTasks, timeUnit); addCallback(future, chainingCallback); } }
private synchronized void submitQuery() { if (querySubmissionFuture != null) { return; } querySubmissionFuture = queryManager.createQuery(queryId, sessionContext, this.query); Futures.addCallback(querySubmissionFuture, new FutureCallback<Object>() { @Override public void onSuccess(Object result) { set(null); } @Override public void onFailure(Throwable t) { setException(t); } }, directExecutor()); }
public void testSameThreadExecutionException() { SettableFuture<String> f = SettableFuture.create(); Exception e = new IllegalArgumentException("foo not found"); MockCallback callback = new MockCallback(e); addCallback(f, callback, directExecutor()); f.setException(e); }
public void testSameThreadSuccess() { SettableFuture<String> f = SettableFuture.create(); MockCallback callback = new MockCallback("foo"); addCallback(f, callback, directExecutor()); f.set("foo"); }
@VisibleForTesting <T extends Message , U extends Message> void submitToExecutor( CallableRequest<T, U> request, LlapNodeId nodeId) { ListenableFuture<U> future = executor.submit(request); Futures.addCallback(future, new ResponseCallback<U>( request.getCallback(), nodeId, this)); }
private void addRunningTask(final Task task, final ListenableFuture<TaskStatus> future) { runningTasks.put(task.getId(), new TaskDetails(task)); Futures.addCallback( future, new FutureCallback<TaskStatus>() { @Override public void onSuccess(TaskStatus result) { submitNoticeToExec(new StatusNotice(task, result)); } @Override public void onFailure(Throwable t) { submitNoticeToExec(new StatusNotice(task, TaskStatus.failure(task.getId()))); } } ); }
@Override public void writeRecord(OUT record) throws IOException { if (exception != null) { throw new IOException("write record failed", exception); } Object[] fields = extractFields(record); ResultSetFuture result = session.executeAsync(prepared.bind(fields)); Futures.addCallback(result, callback); }
public void testCancel() { SettableFuture<String> f = SettableFuture.create(); FutureCallback<String> callback = new FutureCallback<String>() { private boolean called = false; @Override public void onSuccess(String result) { fail("Was not expecting onSuccess() to be called."); } @Override public synchronized void onFailure(Throwable t) { assertFalse(called); assertThat(t).isInstanceOf(CancellationException.class); called = true; } }; addCallback(f, callback, directExecutor()); f.cancel(true); }
public void testThrowErrorFromGet() { Error error = new AssertionError("ASSERT!"); ListenableFuture<String> f = UncheckedThrowingFuture.throwingError(error); MockCallback callback = new MockCallback(error); addCallback(f, callback, directExecutor()); }
public void testRuntimeExeceptionFromGet() { RuntimeException e = new IllegalArgumentException("foo not found"); ListenableFuture<String> f = UncheckedThrowingFuture.throwingRuntimeException(e); MockCallback callback = new MockCallback(e); addCallback(f, callback, directExecutor()); }
@Override public void invoke(IN value) throws Exception { checkAsyncErrors(); tryAcquire(); final ListenableFuture<V> result = send(value); Futures.addCallback(result, callback); }
@GwtIncompatible // Mockito public void testOnSuccessThrowsRuntimeException() throws Exception { RuntimeException exception = new RuntimeException(); String result = "result"; SettableFuture<String> future = SettableFuture.create(); @SuppressWarnings("unchecked") // Safe for a mock FutureCallback<String> callback = Mockito.mock(FutureCallback.class); addCallback(future, callback, directExecutor()); Mockito.doThrow(exception).when(callback).onSuccess(result); future.set(result); assertEquals(result, future.get()); Mockito.verify(callback).onSuccess(result); Mockito.verifyNoMoreInteractions(callback); }
public void testExecutorSuccess() { CountingSameThreadExecutor ex = new CountingSameThreadExecutor(); SettableFuture<String> f = SettableFuture.create(); MockCallback callback = new MockCallback("foo"); Futures.addCallback(f, callback, ex); f.set("foo"); assertEquals(1, ex.runCount); }
@GwtIncompatible // Mockito public void testOnSuccessThrowsError() throws Exception { class TestError extends Error {} TestError error = new TestError(); String result = "result"; SettableFuture<String> future = SettableFuture.create(); @SuppressWarnings("unchecked") // Safe for a mock FutureCallback<String> callback = Mockito.mock(FutureCallback.class); addCallback(future, callback, directExecutor()); Mockito.doThrow(error).when(callback).onSuccess(result); try { future.set(result); fail("Should have thrown"); } catch (TestError e) { assertSame(error, e); } assertEquals(result, future.get()); Mockito.verify(callback).onSuccess(result); Mockito.verifyNoMoreInteractions(callback); }