@Override
public void read(
final PentoQuery query,
final Distribution distribution,
final PentoCallback handler,
final OperationContext operationContext) {
List<PentoStoreWorker> workers = readWorkerFactory.getWorkers(operationContext, distribution);
for (PentoStoreWorker worker : workers) {
Callable callable = worker.execute(query);
ListenableFuture future = ioExecutor.submit(callable);
Futures.addCallback(
future,
new FutureCallback() {
public void onSuccess(Object response) {
handler.callback(response);
}
public void onFailure(Throwable thrown) {
logger.error(thrown.getMessage());
handler.error(thrown);
}
});
}
}
// Error cases
public void testSameThreadExecutionException() {
SettableFuture<String> f = SettableFuture.create();
Exception e = new IllegalArgumentException("foo not found");
MockCallback callback = new MockCallback(e);
Futures.addCallback(f, callback);
f.setException(e);
}
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);
}
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) {}
};
Futures.addCallback(f, 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);
Futures.addCallback(future, callback);
Mockito.doThrow(exception).when(callback).onSuccess(result);
future.set(result);
assertEquals(result, future.get());
Mockito.verify(callback).onSuccess(result);
Mockito.verifyNoMoreInteractions(callback);
}
@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);
Futures.addCallback(future, callback);
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);
}
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;
}
};
Futures.addCallback(f, callback);
f.cancel(true);
}
public void testRuntimeExeceptionFromGet() {
RuntimeException e = new IllegalArgumentException("foo not found");
ListenableFuture<String> f = ThrowingFuture.throwingRuntimeException(e);
MockCallback callback = new MockCallback(e);
Futures.addCallback(f, callback);
}
public void testThrowErrorFromGet() {
Error error = new AssertionError("ASSERT!");
ListenableFuture<String> f = ThrowingFuture.throwingError(error);
MockCallback callback = new MockCallback(error);
Futures.addCallback(f, callback);
}
public void testSameThreadSuccess() {
SettableFuture<String> f = SettableFuture.create();
MockCallback callback = new MockCallback("foo");
Futures.addCallback(f, callback);
f.set("foo");
}
