@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { if (first.findFile(ctx, req) != null) { return first.serve(ctx, req); } else { return second.serve(ctx, req); } }
/** * Invoked when {@code req} is not throttled. By default, this method delegates the specified {@code req} to * the {@link #delegate()} of this service. */ protected O onSuccess(ServiceRequestContext ctx, I req) throws Exception { return delegate().serve(ctx, req); }
@Override public O serve(ServiceRequestContext ctx, I req) throws Exception { RequestMetricSupport.setup(ctx, meterIdPrefixFunction); return delegate().serve(ctx, req); } }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final HttpEncodingType encodingType = HttpEncoders.getWrapperForRequest(req); final HttpResponse delegateResponse = delegate().serve(ctx, req); if (encodingType == null || !encodableRequestHeadersPredicate.test(req.headers())) { return delegateResponse; } return new HttpEncodedResponse( delegateResponse, encodingType, encodableContentTypePredicate, minBytesToForceChunkedAndEncoding); }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { try { final HttpResponse response = delegate().serve(ctx, req); if (response instanceof ExceptionFilteredHttpResponse) { return response; } return new ExceptionFilteredHttpResponse(ctx, req, response, exceptionHandler); } catch (Exception cause) { return exceptionHandler.handleException(ctx, req, cause); } } }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { HttpResponse res = delegate().serve(ctx, req); return new FilteredHttpResponse(res) { private boolean headersReceived; @Override protected HttpObject filter(HttpObject obj) { if (obj instanceof HttpHeaders) { if (!headersReceived) { headersReceived = true; } else { HttpHeaders trailers = (HttpHeaders) obj; String extraHeader = req.headers().get(EXTRA_HEADER_NAME); if (extraHeader != null) { trailers.set(EXTRA_HEADER_NAME, extraHeader); } } } return obj; } }; } }
@Override public O serve(ServiceRequestContext ctx, I req) throws Exception { ctx.log().addListener(log -> { final L structuredLog = logBuilder.build(log); if (structuredLog != null) { writeLog(log, structuredLog); } }, RequestLogAvailability.COMPLETE); return delegate().serve(ctx, req); }
@Override public RpcResponse serve(ServiceRequestContext ctx, RpcRequest req) throws Exception { ctx.setRequestTimeoutMillis(0); return delegate().serve(ctx, req); } }
@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 O serve(ServiceRequestContext ctx, I req) throws Exception { final PathMappingContext mappingCtx = ctx.pathMappingContext(); final PathMapped<Service<I, O>> mapped = findService(mappingCtx.overridePath(ctx.mappedPath())); if (!mapped.isPresent()) { throw HttpStatusException.of(HttpStatus.NOT_FOUND); } final Optional<String> childPrefix = mapped.mapping().prefix(); if (childPrefix.isPresent()) { final PathMapping newMapping = PathMapping.ofPrefix(ctx.pathMapping().prefix().get() + childPrefix.get().substring(1)); final ServiceRequestContext newCtx = new CompositeServiceRequestContext( ctx, newMapping, mapped.mappingResult().path()); try (SafeCloseable ignored = newCtx.push(false)) { return mapped.value().serve(newCtx, req); } } else { return mapped.value().serve(ctx, req); } }
@Override protected void configure(ServerBuilder sb) throws Exception { sb.service( "/", THttpService.of(ImmutableMap.of("", (Iface) name -> "none:" + name, "foo", name -> "foo:" + name, "bar", name -> "bar:" + name)) .decorate((delegate, ctx, req) -> { ctx.log().addListener(log -> { final RpcRequest call = (RpcRequest) log.requestContent(); if (call != null) { methodNames.add(call.method()); } }, RequestLogAvailability.REQUEST_CONTENT); return delegate.serve(ctx, req); })); } };
@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); } }
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); }
@Override public HttpResponse serve(ServiceRequestContext ctx, HttpRequest req) throws Exception { final TraceContextOrSamplingFlags contextOrFlags = extractor.extract(req.headers()); final Span span = contextOrFlags.context() != null ? tracer.joinSpan(contextOrFlags.context()) : tracer.nextSpan(contextOrFlags); // For no-op spans, nothing special to do. if (span.isNoop()) { return delegate().serve(ctx, req); } final String method = ctx.method().name(); span.kind(Kind.SERVER).name(method); ctx.log().addListener(log -> SpanContextUtil.startSpan(span, log), RequestLogAvailability.REQUEST_START); // Ensure the trace context propagates to children ctx.onChild(RequestContextCurrentTraceContext::copy); ctx.log().addListener(log -> { SpanTags.logWireReceive(span, log.requestFirstBytesTransferredTimeNanos(), log); SpanTags.logWireSend(span, log.responseFirstBytesTransferredTimeNanos(), log); SpanContextUtil.closeSpan(span, log); }, RequestLogAvailability.COMPLETE); try (SpanInScope ignored = tracer.withSpanInScope(span)) { return delegate().serve(ctx, req); } } }
@Override protected void configure(ServerBuilder sb) throws Exception { ssc = new SelfSignedCertificate("example.com"); sb.serverListener(new ServerListenerAdapter() { @Override public void serverStopped(Server server) { executor.shutdown(); ssc.delete(); } }); sb.https(new InetSocketAddress("127.0.0.1", 0)); sb.tls(newSslContext()); sb.defaultMaxRequestLength(16 * 1024 * 1024); sb.serviceUnder("/", new GrpcServiceBuilder() .addService(ServerInterceptors.intercept( new TestServiceImpl(executor), TestServiceImpl.interceptors())) .build() .decorate((delegate, ctx, req) -> { ctxCapture.set(ctx); return delegate.serve(ctx, req); })); }
.decorate((client, ctx, req) -> { CLIENT_HEADERS_CAPTURE.set(req.headers()); final HttpResponse res = client.serve(ctx, req); return new FilteredHttpResponse(res) {
@Override protected void configure(ServerBuilder sb) throws Exception { sb.workerGroup(EventLoopGroups.newEventLoopGroup(1), true); sb.defaultMaxRequestLength(0); sb.serviceUnder("/", new GrpcServiceBuilder() .addService(new UnitTestServiceImpl()) .build() .decorate(LoggingService.newDecorator()) .decorate((delegate, ctx, req) -> { ctx.log().addListener(requestLogQueue::add, RequestLogAvailability.COMPLETE); return delegate.serve(ctx, req); })); } };
@Override protected void configure(ServerBuilder sb) throws Exception { sb.workerGroup(EventLoopGroups.newEventLoopGroup(1), true); sb.defaultMaxRequestLength(Long.MAX_VALUE); sb.serviceUnder("/", new GrpcServiceBuilder() .addService(new UnitTestServiceImpl()) .build() .decorate(LoggingService.newDecorator()) .decorate((delegate, ctx, req) -> { ctx.log().addListener(requestLogQueue::add, RequestLogAvailability.COMPLETE); return delegate.serve(ctx, req); })); } };
@Override protected void configure(ServerBuilder sb) throws Exception { sb.workerGroup(EventLoopGroups.newEventLoopGroup(1), true); sb.defaultMaxRequestLength(0); sb.serviceUnder("/", new GrpcServiceBuilder() .setMaxInboundMessageSizeBytes(MAX_MESSAGE_SIZE) .addService(new UnitTestServiceImpl()) .enableUnframedRequests(true) .supportedSerializationFormats(GrpcSerializationFormats.values()) .build() .decorate(LoggingService.newDecorator()) .decorate((delegate, ctx, req) -> { ctx.log().addListener(requestLogQueue::add, RequestLogAvailability.COMPLETE); return delegate.serve(ctx, req); })); } };