@Override public void endOfStream() { setClientStreamClosed(); if (!closeCalled) { if (!ctx.log().isAvailable(RequestLogAvailability.REQUEST_CONTENT)) { ctx.logBuilder().requestContent(GrpcLogUtil.rpcRequest(method), null); } if (useBlockingTaskExecutor) { ctx.blockingTaskExecutor().execute(this::invokeHalfClose); } else { invokeHalfClose(); } } }
connector.getHttpConfiguration(), new ArmeriaEndPoint(hostname, connector.getScheduler(), ctx.localAddress(), ctx.remoteAddress()), transport); ctx.blockingTaskExecutor().execute(() -> invoke(ctx, res, transport, httpChannel)); success = true; return null;
private void invokeOnComplete() { try (SafeCloseable ignored = ctx.push()) { listener.onComplete(); } catch (Throwable t) { // This should not be possible with normal generated stubs which do not implement // onComplete, but is conceivable for a completely manually constructed stub. logger.warn("Error in gRPC onComplete handler.", t); } }
@Override public O serve(ServiceRequestContext ctx, I req) throws Exception { if (sampler.isSampled()) { ctx.log().addListener(log -> logRequest(((ServiceRequestContext) log.context()).logger(), log, requestLogLevel, requestHeadersSanitizer, requestContentSanitizer), RequestLogAvailability.REQUEST_END); ctx.log().addListener(log -> logResponse(((ServiceRequestContext) log.context()).logger(), log, requestLogLevel, requestHeadersSanitizer, requestContentSanitizer, successfulResponseLogLevel, failedResponseLogLevel, responseHeadersSanitizer, responseContentSanitizer), RequestLogAvailability.COMPLETE); } return delegate().serve(ctx, req); } }
@Override @SuppressWarnings("unchecked") public HttpResponse convertResponse(ServiceRequestContext ctx, HttpHeaders headers, @Nullable Object result, HttpHeaders trailingHeaders) throws Exception { final CompletableFuture<?> f; if (result instanceof Publisher) { f = collectFrom((Publisher<Object>) result); } else if (result instanceof Stream) { f = collectFrom((Stream<Object>) result, ctx.blockingTaskExecutor()); } else { return ResponseConverterFunction.fallthrough(); } assert f != null; return HttpResponse.from(f.handle((aggregated, cause) -> { if (cause != null) { return exceptionHandler.handleException(ctx, ctx.request(), cause); } try { return responseConverter.convertResponse(ctx, headers, aggregated, trailingHeaders); } catch (Exception e) { return exceptionHandler.handleException(ctx, ctx.request(), e); } })); } }
ctx.logBuilder().serializationFormat(serializationFormat); ctx.logBuilder().deferRequestContent(); req.aggregateWithPooledObjects(ctx.eventLoop(), ctx.alloc()).handle((aReq, cause) -> { if (cause != null) { final HttpResponse errorRes; if (ctx.server().config().verboseResponses()) { errorRes = HttpResponse.of(HttpStatus.INTERNAL_SERVER_ERROR, MediaType.PLAIN_TEXT_UTF_8,
@Override public ExecutorService blockingTaskExecutor() { return delegate().blockingTaskExecutor(); }
appException = (TApplicationException) cause; } else { if (ctx.server().config().verboseResponses()) { appException = new TApplicationException( TApplicationException.INTERNAL_ERROR, final ByteBuf buf = ctx.alloc().buffer(128); boolean success = false; try { outProto.writeMessageEnd(); ctx.logBuilder().responseContent(reply, new ThriftReply(header, appException));
/** * Returns the address of the client who initiated this request. */ default InetAddress clientAddress() { final InetSocketAddress remoteAddress = remoteAddress(); return remoteAddress.getAddress(); }
@Nullable private Request convertRequest(ServiceRequestContext ctx, AggregatedHttpMessage req) throws Throwable { final String mappedPath = ctx.mappedPath(); final Request coyoteReq = new Request(); final InetSocketAddress remoteAddr = ctx.remoteAddress(); coyoteReq.remoteAddr().setString(remoteAddr.getAddress().getHostAddress()); coyoteReq.remoteHost().setString(remoteAddr.getHostString()); final InetSocketAddress localAddr = ctx.localAddress(); coyoteReq.localAddr().setString(localAddr.getAddress().getHostAddress()); coyoteReq.localName().setString(hostName()); if (ctx.query() != null) { coyoteReq.queryString().setString(ctx.query());
setClientStreamClosed(); messageFramer.close(); ctx.logBuilder().responseContent(GrpcLogUtil.rpcResponse(newStatus, firstResponse), null); if (newStatus.isOk()) { if (useBlockingTaskExecutor) { ctx.blockingTaskExecutor().execute(this::invokeOnComplete); } else { invokeOnComplete(); cancelled = true; if (useBlockingTaskExecutor) { ctx.blockingTaskExecutor().execute(this::invokeOnCancel); } else { invokeOnCancel();
@Override public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception { ctx.setRequestTimeoutMillis(((Number) req.params().get(0)).longValue() + ctx.requestTimeoutMillis()); return delegate().serve(ctx, req); } }
@Override public HttpService asService() { return (ctx, req) -> { final HttpMethod method = ctx.method(); if (method != HttpMethod.GET && method != HttpMethod.HEAD) { return HttpResponse.of(HttpStatus.METHOD_NOT_ALLOWED); switch (ctx.method()) { case HEAD: final HttpHeaders resHeaders = readHeaders(); final HttpResponse res = read(ctx.blockingTaskExecutor(), ctx.alloc()); if (res != null) { return res;
private static String getPath(ServiceRequestContext ctx) { // check the path param first final String path = ctx.pathParam("path"); if (!isNullOrEmpty(path)) { return path; } // then check HTTP query final String query = ctx.query(); if (query != null) { final List<String> params = new QueryStringDecoder(query, false).parameters().get("path"); if (params != null) { return params.get(0); } } // return empty string if there's no path return ""; }
ctx.logBuilder().deferRequestContent(); ctx.logBuilder().deferResponseContent(); req.aggregateWithPooledObjects(ctx.eventLoop(), ctx.alloc()).handle((clientRequest, t) -> { if (t != null) { responseFuture.completeExceptionally(t);
ctx.logBuilder().serializationFormat(serializationFormat); try { final long timeout = TimeoutHeaderUtil.fromHeaderValue(timeoutHeader); ctx.setRequestTimeout(Duration.ofNanos(timeout)); } catch (IllegalArgumentException e) { return HttpResponse.of(ArmeriaServerCall.statusToTrailers(ctx, Status.fromThrowable(e), false)); ctx.logBuilder().deferRequestContent(); ctx.logBuilder().deferResponseContent(); methodName, method, ctx, req.headers(), res, serializationFormat); if (call != null) { ctx.setRequestTimeoutHandler(() -> call.close(Status.DEADLINE_EXCEEDED, EMPTY_METADATA)); req.subscribe(call.messageReader(), ctx.eventLoop(), true); req.completionFuture().handleAsync(call.messageReader(), ctx.eventLoop());
try (SafeCloseable ignored = ctx.push()) { final RequestLogBuilder log = ctx.logBuilder(); log.endRequest(); log.endResponse();
private static HttpData encodeSuccess(ServiceRequestContext ctx, RpcResponse reply, SerializationFormat serializationFormat, String methodName, int seqId, TBase<?, ?> result) { final ByteBuf buf = ctx.alloc().buffer(128); boolean success = false; try { final TTransport transport = new TByteBufTransport(buf); final TProtocol outProto = ThriftProtocolFactories.get(serializationFormat).getProtocol(transport); final TMessage header = new TMessage(methodName, TMessageType.REPLY, seqId); outProto.writeMessageBegin(header); result.write(outProto); outProto.writeMessageEnd(); ctx.logBuilder().responseContent(reply, new ThriftReply(header, result)); final HttpData encoded = new ByteBufHttpData(buf, false); success = true; return encoded; } catch (TException e) { throw new Error(e); // Should never reach here. } finally { if (!success) { buf.release(); } } }
if (ctx instanceof ServiceRequestContext) { final ServiceRequestContext sCtx = (ServiceRequestContext) ctx; final int port = ((InetSocketAddress) sCtx.remoteAddress()).getPort(); final String hostname = sCtx.virtualHost().defaultHostname(); if (port == ctx.sessionProtocol().defaultPort()) { authority = hostname;
this, maxInboundMessageSizeBytes, ctx.alloc()) .decompressor(clientDecompressor(clientHeaders, decompressorRegistry)), this); messageFramer = new ArmeriaMessageFramer(ctx.alloc(), maxOutboundMessageSizeBytes); this.res = requireNonNull(res, "res"); this.compressorRegistry = requireNonNull(compressorRegistry, "compressorRegistry"); Strings.emptyToNull(clientHeaders.get(GrpcHeaderNames.GRPC_ACCEPT_ENCODING)); this.decompressorRegistry = requireNonNull(decompressorRegistry, "decompressorRegistry"); marshaller = new GrpcMessageMarshaller<>(ctx.alloc(), serializationFormat, method, jsonMarshaller, unsafeWrapRequestBuffers); this.unsafeWrapRequestBuffers = unsafeWrapRequestBuffers; try (SafeCloseable ignore = ctx.pushIfAbsent()) { close(Status.CANCELLED, EMPTY_METADATA); }, ctx.eventLoop());