@Override public ByteBuf body() { return request.body(); }
@VisibleForTesting Optional<ClientConfig> getClientConfig( IntObjectMap<Optional<ClientConfig>> cachedClientConfig, Request request) { int hashKey = request.streamId(); // we only do a fresh round robin if the request is a either a FULL HTTP REQUEST or the First Part of a Chunked Requets if (request.isFullMessage()) { return computationFunction.get(); } else if (request.startOfMessage()) { Optional<ClientConfig> newClientConfig = computationFunction.get(); cachedClientConfig.put(hashKey, newClientConfig); return newClientConfig; } else if (request.endOfMessage()) { return cachedClientConfig.remove(hashKey); } else { return cachedClientConfig.get(hashKey); } }
@Override public boolean hasBody() { return request.hasBody(); }
void onInboundRequest(Request request) { MessageMetaState initialRequest = streamIdRequests.get(request.streamId()); if (initialRequest == null) { if (request.startOfMessage()) { streamIdRequests.put( request.streamId(), new MessageMetaState(request, request.endOfMessage())); } else { log.error( "Received an h2 message segment without initial startOfMessage == true - request: {}", request); } } else { initialRequest.requestFinished = request.endOfMessage(); } }
@Test public void testFullRequest() throws Exception { outputReceived = new CountDownLatch(1); FullHttpRequest requestIn = new DefaultFullHttpRequest(HTTP_1_1, GET, "/"); channel.writeInbound(requestIn); channel.runPendingTasks(); // blocks Uninterruptibles.awaitUninterruptibly(outputReceived); Request requestOut = requests.remove(0); assertTrue(requestOut != null); assertTrue(requestOut instanceof FullRequest); assertEquals("HTTP/1.1", requestOut.version()); assertEquals(HttpMethod.GET, requestOut.method()); assertEquals("/", requestOut.path()); assertFalse(requestOut.hasBody()); assertFalse(requestOut.body() == null); assertEquals(0, requestOut.body().readableBytes()); }
public void onRequest(ChannelHandlerContext ctx, Request request) { String requestorIpAddress = remoteIp(ctx); if (request.headers().get("x-remote-ip") != null) { requestorIpAddress = request.headers().get("x-remote-ip"); request.headers().set("x-remote-ip", requestorIpAddress); String httpType = request.streamId() == Message.H1_STREAM_ID_NONE ? "http1.1" : "h2"; Tracer.SpanBuilder spanBuilder = tracer .buildSpan(name + ".client") .withTag(Tags.HTTP_METHOD.getKey(), request.method().toString()) .withTag(Tags.HTTP_URL.getKey(), request.path()) .withTag("http.request.type", httpType) .withTag("http.request.streamId", request.streamId()) .withTag("http.request.source-ip-address", localIp(ctx)) .withTag("http.request.originating-ip-address", requestorIpAddress); StreamSupport.stream(request.headers().spliterator(), false) .forEach( (entry) -> { Optional<Span> parentSpan = request.httpTraceInfo().getSpan(); parentSpan.ifPresent(spanBuilder::asChildOf); Format.Builtin.HTTP_HEADERS, new HttpHeadersInjectAdapter(request)); request.httpTraceInfo().setSpan(scope.span()); setSpan(ctx, request.streamId(), scope.span());
private void writeRequest(ChannelHandlerContext ctx, Request request, ChannelPromise promise) { /* // TOOD(CK): define ACCEPT? if (!response.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); } */ Http2Headers headers = request.headers().http2Headers(); headers.authority(request.host()).method(request.method().asciiName()).path(request.path()); int streamId = request.streamId(); if (request instanceof FullRequest) { if (request.body().readableBytes() > 0) { PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(Http2Request.build(streamId, headers, false), ctx.newPromise())); Http2DataFrame data = new DefaultHttp2DataFrame(request.body(), true); combiner.add(ctx.write(Http2Request.build(streamId, data, true), ctx.newPromise())); combiner.finish(promise); } else { ctx.write(Http2Request.build(streamId, headers, true), promise); } } else { ctx.write(Http2Request.build(streamId, headers, false), promise); } }
public Request buildRequest(Request request, String proxyHost, String path) { Request result; if (request instanceof FullRequest) { result = DefaultFullRequest.builder() .body(request.body()) .method(request.method()) .path(path) .streamId(request.streamId()) .headers(request.headers()) .httpTraceInfo(request.httpTraceInfo()) .host(proxyHost) .build(); } else if (request instanceof SegmentedRequest) { result = DefaultSegmentedRequest.builder() .method(request.method()) .path(path) .streamId(request.streamId()) .headers(request.headers()) .httpTraceInfo(request.httpTraceInfo()) .host(proxyHost) .build(); } else { // this should never happen! log.error("Unknown request type: {}", request); result = null; } return result; }
when(request1.isFullMessage()).thenReturn(true); when(request1.path()).thenReturn("dontcare"); when(request1.streamId()).thenReturn(Message.H1_STREAM_ID_NONE); when(request2.isFullMessage()).thenReturn(true); when(request2.path()).thenReturn("dontcare"); when(request2.streamId()).thenReturn(Message.H1_STREAM_ID_NONE); when(request3.isFullMessage()).thenReturn(true); when(request3.path()).thenReturn("dontcare"); when(request3.streamId()).thenReturn(Message.H1_STREAM_ID_NONE); when(request4.isFullMessage()).thenReturn(true); when(request4.path()).thenReturn("dontcare"); when(request4.streamId()).thenReturn(Message.H1_STREAM_ID_NONE);
buf.append("===================================\r\n"); buf.append("VERSION: ").append(request.version()).append("\r\n"); buf.append("HOSTNAME: ").append(request.host("unknown")).append("\r\n"); buf.append("REQUEST_URI: ").append(request.path()).append("\r\n\r\n"); Headers headers = request.headers(); if (!headers.isEmpty()) { for (Map.Entry<CharSequence, CharSequence> h : headers) { QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.path()); Map<String, List<String>> params = queryStringDecoder.parameters(); if (!params.isEmpty()) {
public static DefaultFullResponse.Builder newOk(Request request) { return defaultHeaders( DefaultFullResponse.builder() .streamId(request.streamId()) .httpTraceInfo(request.httpTraceInfo()) .status(HttpResponseStatus.OK)); } }
HttpRequest buildRequest(Request request) { if (!request.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { request.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); if (request.keepAlive()) { request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); request.method(), request.path(), request.headers().http1Headers(false, true));
@Override protected void channelRead0(ChannelHandlerContext ctx, Request msg) throws Exception { if (msg instanceof SegmentedRequestData && msg.endOfMessage()) { sendResponse(ctx, msg.httpTraceInfo(), msg.streamId()); return; } else if (msg instanceof FullRequest) { sendResponse(ctx, msg.httpTraceInfo(), msg.streamId()); } ctx.write(msg); }
actualBuffer = segmentedRequest.content(); } else { actualBuffer = request.body(); GrpcState state = session.get(request.streamId()); sendResponse( ctx, request.streamId(), Unpooled.EMPTY_BUFFER, Status.INTERNAL.withDescription(GRPC_MESSAGE_NO_METADATA)); sendResponse( ctx, request.streamId(), Unpooled.EMPTY_BUFFER, Status.UNIMPLEMENTED.withDescription(GRPC_MESSAGE_NO_COMPRESSION)); sendResponse( ctx, request.streamId(), Unpooled.EMPTY_BUFFER, Status.RESOURCE_EXHAUSTED.withDescription(GRPC_MESSAGE_LARGE_SIZE)); sendResponse( ctx, request.streamId(), Unpooled.EMPTY_BUFFER, Status.INTERNAL.withDescription(GRPC_MESSAGE_WRONG_SIZE));
@Override public Headers headers() { return request.headers(); }
@Override public String path() { return request.path(); }
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { super.channelRead(ctx, msg); if (msg instanceof Request) { Request request = (Request) msg; if (request.startOfMessage()) { requestsMeter.mark(); } } }
@Override public void channelRead0(ChannelHandlerContext ctx, Request request) throws Exception { ByteBuf content = Unpooled.copiedBuffer("Here is the default content that is returned", CharsetUtil.UTF_8); HttpResponseStatus status = OK; Tracer tracer = httpTracing.tracing().tracer(); if (request.endOfMessage()) { request .httpTraceInfo() .getSpan() .ifPresent( parent -> { if (parent instanceof brave.Span) { Span span = tracer.newChild(((brave.Span) parent).context()).name("child").start(); span.finish(); } }); val response = DefaultFullResponse.builder() .status(status) .headers(new DefaultHeaders()) .httpTraceInfo(request.httpTraceInfo()) .status(status) .body(content) .build(); ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } } }
@Override public String host() { return request.host(); }
private ChannelFuture rawWrite(Request request) { return request.endOfMessage() ? manager.currentChannel().writeAndFlush(request).addListener(this.writeListener) : manager.currentChannel().write(request).addListener(this.writeListener); }