HttpRequest buildRequest(Request request) { if (!request.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { request.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); request.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); content = Unpooled.EMPTY_BUFFER; if (!full.headers().contains(HttpHeaderNames.CONTENT_LENGTH)) { full.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes()); full.path(), content, full.headers().http1Headers(false, true), EmptyHttpHeaders.INSTANCE); } else { request.method(), request.path(), request.headers().http1Headers(false, true));
@Nullable default String get(String name) { CharSequence value = get((CharSequence) name); if (value != null) { return value.toString(); } else { return null; } }
private void appendXForwardedFor(ChannelHandlerContext ctx, Request request) { val remoteAddressAndPort = addressHelper.extractRemoteAddressAndPort(ctx.channel()); if (remoteAddressAndPort != null) { val rawXFF = request.headers().get(X_FORWARDED_FOR); if (rawXFF == null || rawXFF.toString().trim().isEmpty()) { request.headers().set(X_FORWARDED_FOR, remoteAddressAndPort); } else { val newXFF = rawXFF.toString().trim() + ", " + remoteAddressAndPort; request.headers().set(X_FORWARDED_FOR, newXFF); } } }
assertEquals("application/grpc+proto", response.headers().get(HttpHeaderNames.CONTENT_TYPE)); Objects.requireNonNull(segmentedData.trailingHeaders()).get("grpc-status")); assertFalse(Objects.requireNonNull(segmentedData.trailingHeaders()).contains("grpc-message")); assertEquals(streamId, segmentedData.streamId()); assertTrue(segmentedData.endOfMessage());
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); .withTag("http.request.originating-ip-address", requestorIpAddress); StreamSupport.stream(request.headers().spliterator(), false) .forEach( (entry) -> {
private void writeResponse(ChannelHandlerContext ctx, Response response, ChannelPromise promise) { if (!response.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); } Http2MessageSession messageSession = lazyCreateSession(ctx); int streamId = response.streamId(); Http2Headers headers = response.headers().http2Headers(); headers.status(response.status().codeAsText()); if (response instanceof FullResponse) { messageSession.onOutboundResponse(response); ByteBuf body = response.body(); if (body != null && body.readableBytes() > 0) { PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(Http2Response.build(streamId, headers, false), ctx.newPromise())); Http2DataFrame data = new DefaultHttp2DataFrame(body, true); combiner.add(ctx.write(Http2Response.build(streamId, data, true), ctx.newPromise())); combiner.finish(promise); } else { ctx.write(Http2Response.build(streamId, headers, true), promise); } } else { ctx.write(Http2Response.build(streamId, headers, false), promise); } messageSession.flush(streamId); }
private void writeContent(ChannelHandlerContext ctx, SegmentedData data, ChannelPromise promise) { Headers trailingHeaders = data.trailingHeaders(); boolean hasTrailing = trailingHeaders != null && trailingHeaders.size() > 0; boolean dataEos = data.endOfMessage() && !hasTrailing; int streamId = data.streamId(); Http2Request request = Http2Request.build(streamId, new DefaultHttp2DataFrame(data.content(), dataEos), dataEos); if (hasTrailing) { Http2Headers headers = trailingHeaders.http2Headers(); Http2Request last = Http2Request.build(streamId, headers, true); PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(request, ctx.newPromise())); combiner.add(ctx.write(last, ctx.newPromise())); combiner.finish(promise); } else { ctx.write(request, promise); } }
if (!headers.isEmpty()) { for (Map.Entry<CharSequence, CharSequence> h : headers) { CharSequence key = h.getKey(); buf.append("END OF CONTENT\r\n"); if (!data.trailingHeaders().isEmpty()) { buf.append("\r\n"); for (CharSequence name : data.trailingHeaders().names()) { for (CharSequence value : data.trailingHeaders().getAll(name)) { buf.append("TRAILING HEADER: "); buf.append(name).append(" = ").append(value).append("\r\n");
default Headers setLowerCase(CharSequence name, CharSequence value) { set(name.toString().toLowerCase(), value); return this; }
HttpContent buildContent(SegmentedData data) { if (data.endOfMessage()) { LastHttpContent last = new DefaultLastHttpContent(data.content()); if (data.trailingHeaders() != null) { last.trailingHeaders().add(data.trailingHeaders().http1Headers(true, true)); } // setChannelRequest(ctx, null); return last; } else { return new DefaultHttpContent(data.content()); } }
trailingHeaders.add( GRPC_TRAILING_HEADER_MESSAGE_KEY, grpcEncodedString(status.getDescription()));
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); } }
@Test public void testSimpleRequest() { HelloRequest grpcRequest = HelloRequest.newBuilder().setName("myName").build(); ByteBuf grpcRequestBuffer = bufferFor(grpcRequest); int streamId = 123; SegmentedRequestData segmentedRequest = fullGrpcRequest(grpcRequestBuffer, streamId, true); channel.writeInbound(segmentedRequest); Response response = channel.readOutbound(); SegmentedData segmentedData = channel.readOutbound(); assertEquals(HttpResponseStatus.OK, response.status()); assertEquals(streamId, response.streamId()); assertEquals("application/grpc+proto", response.headers().get(HttpHeaderNames.CONTENT_TYPE)); HelloReply actualReply = protoObjectFor(segmentedData.content(), HelloReply::parseFrom); HelloReply expectedReply = HelloReply.newBuilder().setMessage(responsePrefix + grpcRequest.getName()).build(); assertEquals(actualReply, expectedReply); assertEquals("0", Objects.requireNonNull(segmentedData.trailingHeaders()).get("grpc-status")); assertFalse(Objects.requireNonNull(segmentedData.trailingHeaders()).contains("grpc-message")); assertEquals(streamId, segmentedData.streamId()); assertTrue(segmentedData.endOfMessage()); }
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); .withTag("http.request.originating-ip-address", requestorIpAddress); StreamSupport.stream(request.headers().spliterator(), false) .forEach( (entry) -> {
void writeContent(ChannelHandlerContext ctx, SegmentedData data, ChannelPromise promise) { Http2MessageSession messageSession = lazyCreateSession(ctx); messageSession.onOutboundResponseData(data); boolean dataEos = data.endOfMessage() && data.trailingHeaders().size() == 0; Http2Response response = Http2Response.build( data.streamId(), new DefaultHttp2DataFrame(data.content(), dataEos), dataEos); Headers trailingHeaders = data.trailingHeaders(); if (trailingHeaders != null && trailingHeaders.size() != 0) { Http2Headers headers = trailingHeaders.http2Headers(); Http2Response last = Http2Response.build(data.streamId(), headers, true); PromiseCombiner combiner = new PromiseCombiner(); combiner.add(ctx.write(response, ctx.newPromise())); combiner.add(ctx.write(last, ctx.newPromise())); combiner.finish(promise); } else { ctx.write(response, promise); } }
@Override public void put(final String key, final String value) { httpRequest.headers().set(key.toLowerCase(), value); }
/** * Translate the SegmentedData object into a netty HttpContent and fire write on the next handler. */ private void buildContent(ChannelHandlerContext ctx, SegmentedData data, ChannelPromise promise) { Http1MessageSession session = setDefaultMessageSession(ctx); try { session.onResponseData(data); HttpObject obj; if (data.endOfMessage()) { LastHttpContent last = new DefaultLastHttpContent(data.content()); if (data.trailingHeaders() != null) { last.trailingHeaders().add(data.trailingHeaders().http1Headers(true, false)); } obj = last; } else { obj = new DefaultHttpContent(data.content()); } ChannelFuture future = ctx.write(obj, promise); if (session.closeConnection() && data.endOfMessage()) { future.addListener(ChannelFutureListener.CLOSE); } } finally { session.flush(); } }
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); if (!response.headers().contains(HttpHeaderNames.CONTENT_TYPE)) { response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); response.headers().set(HttpHeaderNames.CONNECTION, "close"); content = Unpooled.EMPTY_BUFFER; if (!full.headers().contains(HttpHeaderNames.CONTENT_LENGTH)) { full.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes()); full.status(), content, full.headers().http1Headers(false, false), EmptyHttpHeaders.INSTANCE); } else { HttpHeaders headers = response.headers().http1Headers(false, false); if (!response.headers().contains(HttpHeaderNames.TRANSFER_ENCODING)) { headers.set(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED); headers.remove(HttpHeaderNames.CONTENT_LENGTH);