/** * Creates a new exceptionally complete {@link RpcResponse}. */ static RpcResponse ofFailure(Throwable cause) { return new DefaultRpcResponse(cause); }
private static void invokeSynchronously( ServiceRequestContext ctx, Object impl, ThriftFunction func, TBase<?, ?> args, DefaultRpcResponse reply) { final ProcessFunction<Object, TBase<?, ?>> f = func.syncFunc(); ctx.blockingTaskExecutor().execute(() -> { if (reply.isDone()) { // Closed already most likely due to timeout. return; } try { if (func.isOneWay()) { reply.complete(null); f.getResult(impl, args); } else { final TBase<?, ?> result = f.getResult(impl, args); reply.complete(func.getResult(result)); } } catch (Throwable t) { if (func.isOneWay()) { reply.complete(null); logOneWayFunctionFailure(ctx, t); } else { reply.completeExceptionally(t); } } }); }
@Override public String toString() { if (isDone()) { if (isCompletedExceptionally()) { return MoreObjects.toStringHelper(this) .add("cause", cause).toString(); } else { return MoreObjects.toStringHelper(this) .addValue(getNow(null)).toString(); } } final int count = getNumberOfDependents(); if (count == 0) { return MoreObjects.toStringHelper(this) .addValue("not completed").toString(); } else { return MoreObjects.toStringHelper(this) .addValue("not completed") .add("dependents", count).toString(); } } }
@Override public boolean cancel(boolean mayInterruptIfRunning) { final boolean updated = !isDone() && completeExceptionally(new CancellationException()); return updated || isCancelled(); }
/** * Creates a new {@link RpcResponse} that is completed successfully or exceptionally based on the * completion of the specified {@link CompletionStage}. */ static RpcResponse from(CompletionStage<?> stage) { requireNonNull(stage, "stage"); final DefaultRpcResponse res = new DefaultRpcResponse(); stage.handle((value, cause) -> { if (cause != null) { res.completeExceptionally(cause); } else if (value instanceof RpcResponse) { ((RpcResponse) value).handle((rpcResponseResult, rpcResponseCause) -> { if (rpcResponseCause != null) { res.completeExceptionally(Exceptions.peel(rpcResponseCause)); } else { res.complete(rpcResponseResult); } return null; }); } else { res.complete(value); } return null; }); return res; }
@Override public void onError(Exception e) { reply.completeExceptionally(e); } });
final String method = call.method(); final List<Object> args = call.params(); final DefaultRpcResponse reply = new DefaultRpcResponse(); reply.completeExceptionally(cause); return reply;
@Override public void onComplete(Object response) { reply.complete(response); }
@Override public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception { final DefaultRpcResponse newRes = new DefaultRpcResponse(); try { final RpcResponse oldRes = delegate().serve(ctx, req); oldRes.handle((res, cause) -> { if (cause != null) { handleException(req, newRes, cause); } else { newRes.complete(res); } return null; }); } catch (Throwable cause) { handleException(req, newRes, cause); } return newRes; }
/** * Creates a new exceptionally complete response. * * @param cause the cause of failure */ public DefaultRpcResponse(Throwable cause) { requireNonNull(cause, "cause"); completeExceptionally(cause); }
final String method = call.method(); final List<Object> args = call.params(); final DefaultRpcResponse reply = new DefaultRpcResponse(); reply.completeExceptionally(cause); return reply;
/** * Creates a new successfully complete response. * * @param result the result or an RPC call */ public DefaultRpcResponse(@Nullable Object result) { complete(result); }
@Override public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception { final DefaultRpcResponse newRes = new DefaultRpcResponse(); try { final RpcResponse oldRes = delegate().serve(ctx, req); oldRes.handle((res, cause) -> { if (cause != null) { handleException(req, newRes, cause); } else { newRes.complete(res); } return null; }); } catch (Throwable cause) { handleException(req, newRes, cause); } return newRes; }
private static void invokeSynchronously( ServiceRequestContext ctx, Object impl, ThriftFunction func, TBase<?, ?> args, DefaultRpcResponse reply) { final ProcessFunction<Object, TBase<?, ?>> f = func.syncFunc(); ctx.blockingTaskExecutor().execute(() -> { if (reply.isDone()) { // Closed already most likely due to timeout. return; } try { final TBase<?, ?> result = f.getResult(impl, args); if (func.isOneWay()) { reply.complete(null); } else { reply.complete(func.getResult(result)); } } catch (Throwable t) { reply.completeExceptionally(t); } }); } }
/** * Creates a new successfully complete {@link RpcResponse}. */ static RpcResponse of(@Nullable Object value) { return new DefaultRpcResponse(value); }
private static void handleException(ClientRequestContext ctx, DefaultRpcResponse reply, @Nullable ThriftReply rawResponseContent, Exception cause) { reply.completeExceptionally(cause); ctx.logBuilder().responseContent(reply, rawResponseContent); }
final String method = call.method(); final List<Object> args = call.params(); final DefaultRpcResponse reply = new DefaultRpcResponse(); reply.completeExceptionally(cause); return reply;
private static void handleSuccess(ClientRequestContext ctx, DefaultRpcResponse reply, @Nullable Object returnValue, @Nullable ThriftReply rawResponseContent) { reply.complete(returnValue); ctx.logBuilder().responseContent(reply, rawResponseContent); }
@Override public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception { final DefaultRpcResponse newRes = new DefaultRpcResponse(); try { final RpcResponse oldRes = delegate().serve(ctx, req); oldRes.handle((res, cause) -> { if (cause != null) { handleException(req, newRes, cause); } else { newRes.complete(res); } return null; }); } catch (Throwable cause) { handleException(req, newRes, cause); } return newRes; }
private static void invokeSynchronously( ServiceRequestContext ctx, Object impl, ThriftFunction func, TBase<?, ?> args, DefaultRpcResponse reply) { final ProcessFunction<Object, TBase<?, ?>> f = func.syncFunc(); ctx.blockingTaskExecutor().execute(() -> { if (reply.isDone()) { // Closed already most likely due to timeout. return; } try { if (func.isOneWay()) { reply.complete(null); f.getResult(impl, args); } else { final TBase<?, ?> result = f.getResult(impl, args); reply.complete(func.getResult(result)); } } catch (Throwable t) { if (func.isOneWay()) { reply.complete(null); logOneWayFunctionFailure(ctx, t); } else { reply.completeExceptionally(t); } } }); }