@Override public void onFailure(RuntimeException e) { future.raise(e); } });
public void onFailure(RuntimeException e, RequestFuture<T> future) { future.raise(e); } }
@Override public void onFailure(RuntimeException e) { synchronized (listOffsetRequestsFuture) { if (!listOffsetRequestsFuture.isDone()) listOffsetRequestsFuture.raise(e); } } });
@Override public void onFailure(RuntimeException e, RequestFuture<T> future) { // mark the coordinator as dead if (e instanceof DisconnectException) { markCoordinatorUnknown(true); } future.raise(e); }
/** * Raise an error. The request will be marked as failed. * @param error corresponding error to be passed to caller */ public void raise(Errors error) { raise(error.exception()); }
public static <T> RequestFuture<T> failure(RuntimeException e) { RequestFuture<T> future = new RequestFuture<>(); future.raise(e); return future; }
@Override public void handle(LeaveGroupResponse leaveResponse, RequestFuture<Void> future) { Errors error = leaveResponse.error(); if (error == Errors.NONE) { log.debug("LeaveGroup request returned successfully"); future.complete(null); } else { log.debug("LeaveGroup request failed with error: {}", error.message()); future.raise(error); } } }
public void fireCompletion() { if (e != null) { future.raise(e); } else if (response.authenticationException() != null) { future.raise(response.authenticationException()); } else if (response.wasDisconnected()) { log.debug("Cancelled request with header {} due to node {} being disconnected", response.requestHeader(), response.destination()); future.raise(DisconnectException.INSTANCE); } else if (response.versionMismatch() != null) { future.raise(response.versionMismatch()); } else { future.complete(response); } }
@Override @SuppressWarnings("unchecked") public void onSuccess(ClientResponse clientResponse, RequestFuture<T> future) { try { this.response = clientResponse; R responseObj = (R) clientResponse.responseBody(); handle(responseObj, future); } catch (RuntimeException e) { if (!future.isDone()) future.raise(e); } }
@Override public void handle(SyncGroupResponse syncResponse, RequestFuture<ByteBuffer> future) { Errors error = syncResponse.error(); if (error == Errors.NONE) { sensors.syncLatency.record(response.requestLatencyMs()); future.complete(syncResponse.memberAssignment()); } else { requestRejoin(); if (error == Errors.GROUP_AUTHORIZATION_FAILED) { future.raise(new GroupAuthorizationException(groupId)); } else if (error == Errors.REBALANCE_IN_PROGRESS) { log.debug("SyncGroup failed because the group began another rebalance"); future.raise(error); } else if (error == Errors.UNKNOWN_MEMBER_ID || error == Errors.ILLEGAL_GENERATION) { log.debug("SyncGroup failed: {}", error.message()); resetGeneration(); future.raise(error); } else if (error == Errors.COORDINATOR_NOT_AVAILABLE || error == Errors.NOT_COORDINATOR) { log.debug("SyncGroup failed: {}", error.message()); markCoordinatorUnknown(); future.raise(error); } else { future.raise(new KafkaException("Unexpected error from SyncGroup: " + error.message())); } } } }
@Test(expected = IllegalStateException.class) public void invokeCompleteAfterAlreadyFailed() { RequestFuture<Void> future = new RequestFuture<>(); future.raise(new RuntimeException()); future.complete(null); }
@Test(expected = IllegalStateException.class) public void invokeRaiseAfterAlreadyCompleted() { RequestFuture<Void> future = new RequestFuture<>(); future.complete(null); future.raise(new RuntimeException()); }
@Test(expected = IllegalStateException.class) public void invokeValueAfterFailure() { RequestFuture<Void> future = new RequestFuture<>(); future.raise(new RuntimeException()); future.value(); }
@Override public void onSuccess(ClientResponse resp, RequestFuture<Void> future) { log.debug("Received FindCoordinator response {}", resp); clearFindCoordinatorFuture(); FindCoordinatorResponse findCoordinatorResponse = (FindCoordinatorResponse) resp.responseBody(); Errors error = findCoordinatorResponse.error(); if (error == Errors.NONE) { synchronized (AbstractCoordinator.this) { // use MAX_VALUE - node.id as the coordinator id to allow separate connections // for the coordinator in the underlying network client layer int coordinatorConnectionId = Integer.MAX_VALUE - findCoordinatorResponse.node().id(); AbstractCoordinator.this.coordinator = new Node( coordinatorConnectionId, findCoordinatorResponse.node().host(), findCoordinatorResponse.node().port()); log.info("Discovered group coordinator {}", coordinator); client.tryConnect(coordinator); heartbeat.resetSessionTimeout(); } future.complete(null); } else if (error == Errors.GROUP_AUTHORIZATION_FAILED) { future.raise(new GroupAuthorizationException(groupId)); } else { log.debug("Group coordinator lookup failed: {}", error.message()); future.raise(error); } }
@Test public void listenerInvokedIfAddedBeforeFutureFailure() { RequestFuture<Void> future = new RequestFuture<>(); MockRequestFutureListener<Void> listener = new MockRequestFutureListener<>(); future.addListener(listener); future.raise(new RuntimeException()); assertOnFailureInvoked(listener); }
@Test public void listenerInvokedIfAddedAfterFutureFailure() { RequestFuture<Void> future = new RequestFuture<>(); future.raise(new RuntimeException()); MockRequestFutureListener<Void> listener = new MockRequestFutureListener<>(); future.addListener(listener); assertOnFailureInvoked(listener); }
@Test public void testBasicFailure() { RequestFuture<String> future = new RequestFuture<>(); RuntimeException exception = new RuntimeException(); future.raise(exception); assertTrue(future.isDone()); assertEquals(exception, future.exception()); }
@Test public void listenersInvokedIfAddedBeforeAndAfterFailure() { RequestFuture<Void> future = new RequestFuture<>(); MockRequestFutureListener<Void> beforeListener = new MockRequestFutureListener<>(); future.addListener(beforeListener); future.raise(new RuntimeException()); MockRequestFutureListener<Void> afterListener = new MockRequestFutureListener<>(); future.addListener(afterListener); assertOnFailureInvoked(beforeListener); assertOnFailureInvoked(afterListener); }
@Test public void testComposeFailureCase() { RequestFuture<String> future = new RequestFuture<>(); RequestFuture<Integer> composed = future.compose(new RequestFutureAdapter<String, Integer>() { @Override public void onSuccess(String value, RequestFuture<Integer> future) { future.complete(value.length()); } }); RuntimeException e = new RuntimeException(); future.raise(e); assertTrue(composed.isDone()); assertTrue(composed.failed()); assertEquals(e, composed.exception()); }