@Test public void compressedClient_compressedEndpoint() throws Exception { assertThat(blockingClient.staticUnaryCallSetsMessageCompression(REQUEST_MESSAGE)) .isEqualTo(RESPONSE_MESSAGE); checkRequestLog((rpcReq, rpcRes, grpcStatus) -> { assertThat(rpcReq.method()).isEqualTo( "armeria.grpc.testing.UnitTestService/StaticUnaryCallSetsMessageCompression"); assertThat(rpcReq.params()).containsExactly(REQUEST_MESSAGE); assertThat(rpcRes.get()).isEqualTo(RESPONSE_MESSAGE); }); }
/** * 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 protected RpcResponse doExecute(ClientRequestContext ctx, RpcRequest req, CircuitBreaker circuitBreaker) throws Exception { final RpcResponse response; try { response = delegate().execute(ctx, req); } catch (Throwable cause) { reportSuccessOrFailure(circuitBreaker, strategyWithContent().shouldReportAsSuccess( ctx, RpcResponse.ofFailure(cause))); throw cause; } response.handle((unused1, unused2) -> { reportSuccessOrFailure(circuitBreaker, strategyWithContent().shouldReportAsSuccess(ctx, response)); return null; }); return response; } }
/** * Returns a {@link RpcResponse} corresponding to the given {@link Status} generated by the server. */ public static RpcResponse rpcResponse(Status status, @Nullable Object message) { if (status.isOk()) { return RpcResponse.of(message); } else { return RpcResponse.ofFailure(status.asException()); } }
@Override public void responseContent(@Nullable Object responseContent, @Nullable Object rawResponseContent) { if (isAvailabilityAlreadyUpdated(RESPONSE_CONTENT)) { return; } if (responseContent instanceof RpcResponse) { final RpcResponse rpcResponse = (RpcResponse) responseContent; if (!rpcResponse.isDone()) { throw new IllegalArgumentException("responseContent must be complete: " + responseContent); } if (rpcResponse.cause() != null) { responseCause = rpcResponse.cause(); } } this.responseContent = responseContent; this.rawResponseContent = rawResponseContent; updateAvailability(RESPONSE_CONTENT); }
private void exportRpcResponse(Map<String, String> out, RequestLog log) { if (!log.isAvailable(RequestLogAvailability.RESPONSE_CONTENT)) { return; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { final RpcResponse rpcRes = (RpcResponse) responseContent; if (builtIns.contains(RES_RPC_RESULT) && !rpcRes.isCompletedExceptionally()) { try { out.put(RES_RPC_RESULT.mdcKey, String.valueOf(rpcRes.get())); } catch (Exception e) { // Should never reach here because RpcResponse must be completed. throw new Error(e); } } } }
/** * Invoked when {@code req} is throttled. By default, this method responds with a * {@link HttpStatusException} with {@code 503 Service Unavailable}. */ @Override protected RpcResponse onFailure(ServiceRequestContext ctx, RpcRequest req, @Nullable Throwable cause) throws Exception { return RpcResponse.ofFailure(HttpStatusException.of(HttpStatus.SERVICE_UNAVAILABLE)); } }
private void doExecute0(ClientRequestContext ctx, RpcRequest req, RpcResponse returnedRes, CompletableFuture<RpcResponse> future) { if (returnedRes.isDone()) { final RpcResponse res = executeWithFallback(delegate(), derivedCtx, req, fallback); res.handle((unused1, unused2) -> { retryStrategyWithContent().shouldRetry(derivedCtx, res).handle((backoff, unused3) -> { if (backoff != null) {
@Override public void endResponse() { endResponse0(responseContent instanceof RpcResponse ? ((RpcResponse) responseContent).cause() : null); }
private static boolean isSuccess(RequestLog log) { if (log.responseCause() != null) { return false; } final int statusCode = log.statusCode(); if (statusCode < 100 || statusCode >= 400) { return false; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { return !((RpcResponse) responseContent).isCompletedExceptionally(); } return true; }
final RpcRequest rpcReq = RpcRequest.of(HelloService.Iface.class, "hello", "Armeria"); final HttpResponse res = HttpResponse.of(HttpStatus.OK); final RpcResponse rpcRes = RpcResponse.of("Hello, Armeria!"); final ClientRequestContext ctx = ClientRequestContextBuilder.of(req)
private void exportRpcResponse(Map<String, String> out, RequestLog log) { if (!log.isAvailable(RequestLogAvailability.RESPONSE_CONTENT)) { return; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { final RpcResponse rpcRes = (RpcResponse) responseContent; if (builtIns.contains(RES_RPC_RESULT) && !rpcRes.isCompletedExceptionally()) { try { out.put(RES_RPC_RESULT.mdcKey, String.valueOf(rpcRes.get())); } catch (Exception e) { // Should never reach here because RpcResponse must be completed. throw new Error(e); } } } }
private RpcResponse execute0( String path, Class<?> serviceType, @Nullable String serviceName, String method, Object[] args) { path = concatPaths(uri().getRawPath(), path); final PathAndQuery pathAndQuery = PathAndQuery.parse(path); if (pathAndQuery == null) { return RpcResponse.ofFailure(new IllegalArgumentException("invalid path: " + path)); } // A thrift path is always good to cache as it cannot have non-fixed parameters. pathAndQuery.storeInCache(path); final RpcRequest call = RpcRequest.of(serviceType, method, args); return execute(HttpMethod.POST, pathAndQuery.path(), null, serviceName, call, (ctx, cause) -> new DefaultRpcResponse(cause)); } }
/** * Returns a {@link RpcResponse} corresponding to the given {@link Status} generated by the server. */ public static RpcResponse rpcResponse(Status status, @Nullable Object message) { if (status.isOk()) { return RpcResponse.of(message); } else { return RpcResponse.ofFailure(status.asException()); } }
private static void checkRequestLogStatus(RequestLogStatusChecker checker) throws Exception { final RequestLog log = requestLogQueue.take(); assertThat(log.availabilities()).contains(RequestLogAvailability.COMPLETE); final RpcRequest rpcReq = (RpcRequest) log.requestContent(); final RpcResponse rpcRes = (RpcResponse) log.responseContent(); assertThat(rpcReq).isNull(); assertThat((Object) rpcRes).isNotNull(); assertThat(rpcRes.cause()).isNotNull(); checker.check(((StatusException) rpcRes.cause()).getStatus()); }
final RpcResponse rpcRes = RpcResponse.of("Hello, trustin!"); final RequestLogBuilder logBuilder = ctx.logBuilder(); logBuilder.requestContent(rpcReq, req);
@Test public void emptyUnary() throws Exception { assertThat(blockingStub.emptyCall(EMPTY)).isEqualTo(EMPTY); checkRequestLog((rpcReq, rpcRes, grpcStatus) -> { assertThat(rpcReq.params()).containsExactly(EMPTY); assertThat(rpcRes.get()).isEqualTo(EMPTY); }); }
private void invoke( ServiceRequestContext ctx, SerializationFormat serializationFormat, int seqId, ThriftFunction func, RpcRequest call, CompletableFuture<HttpResponse> res) { final RpcResponse reply; try (SafeCloseable ignored = ctx.push()) { reply = delegate.serve(ctx, call); } catch (Throwable cause) { handleException(ctx, new DefaultRpcResponse(cause), res, serializationFormat, seqId, func, cause); return; } reply.handle((result, cause) -> { if (func.isOneWay()) { handleOneWaySuccess(ctx, reply, res, serializationFormat); return null; } if (cause != null) { handleException(ctx, reply, res, serializationFormat, seqId, func, cause); return null; } try { handleSuccess(ctx, reply, res, serializationFormat, seqId, func, result); } catch (Throwable t) { handleException(ctx, new DefaultRpcResponse(t), res, serializationFormat, seqId, func, t); } return null; }).exceptionally(CompletionActions::log); }
private void exportRpcResponse(Map<String, String> out, RequestLog log) { if (!log.isAvailable(RequestLogAvailability.RESPONSE_CONTENT)) { return; } final Object responseContent = log.responseContent(); if (responseContent instanceof RpcResponse) { final RpcResponse rpcRes = (RpcResponse) responseContent; if (builtIns.contains(RES_RPC_RESULT) && !rpcRes.isCompletedExceptionally()) { try { out.put(RES_RPC_RESULT.mdcKey, String.valueOf(rpcRes.get())); } catch (Exception e) { // Should never reach here because RpcResponse must be completed. throw new Error(e); } } } }