private static void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest req, FullHttpResponse res) { // Generate an error page if response getStatus code is not OK (200). if (res.status().code() != 200) { ByteBuf buf = Unpooled.copiedBuffer(res.status().toString(), CharsetUtil.UTF_8); res.content().writeBytes(buf); buf.release(); HttpUtil.setContentLength(res, res.content().readableBytes()); } // Send the response and close the connection if necessary. ChannelFuture f = ctx.channel().writeAndFlush(res); if (!HttpUtil.isKeepAlive(req) || res.status().code() != 200) { f.addListener(ChannelFutureListener.CLOSE); } }
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) { if (!(msg instanceof HttpRequest)) return; HttpRequest req = (HttpRequest) msg; if (HttpUtil.is100ContinueExpected(req)) { ctx.write(new DefaultFullHttpResponse(HTTP_1_1, CONTINUE)); } boolean keepAlive = HttpUtil.isKeepAlive(req); FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, OK, Unpooled.wrappedBuffer(HELLO_WORLD)); response.headers().set(CONTENT_TYPE, "text/plain"); response.headers().set(CONTENT_LENGTH, response.content().readableBytes()); if (!keepAlive) { ctx.write(response).addListener(ChannelFutureListener.CLOSE); } else { response.headers().set(CONNECTION, HttpHeaderValues.KEEP_ALIVE); ctx.write(response); } }
protected int sendHttp1Response(ChannelHandlerContext ctx, HttpResponseStatus status, String resultStr, boolean isKeepAlive) { ByteBuf content = Unpooled.copiedBuffer(resultStr, RpcConstants.DEFAULT_CHARSET); FullHttpResponse res = new DefaultFullHttpResponse(HTTP_1_1, status, content); res.headers().set(CONTENT_TYPE, "text/html; charset=" + RpcConstants.DEFAULT_CHARSET.displayName()); HttpUtil.setContentLength(res, content.readableBytes()); try { ChannelFuture f = ctx.channel().writeAndFlush(res); if (isKeepAlive) { HttpUtil.setKeepAlive(res, true); } else { HttpUtil.setKeepAlive(res, false); //set keepalive closed f.addListener(ChannelFutureListener.CLOSE); } } catch (Exception e2) { LOGGER.warn("Failed to send HTTP response to remote, cause by:", e2); } return content.readableBytes(); }
@Override protected boolean hasBody(HttpRequest request) { // Http requests don't have a body if they define 0 content length, or no content length and no transfer // encoding return HttpUtil.getContentLength(request, 0) != 0 || HttpUtil.isTransferEncodingChunked(request); }
private void setContentLengthForKeepAlive(final FullHttpResponse response) { if (!isContentLengthSet(response)) { setContentLength(response, response.content().writerIndex()); } }
private static void respond( final ChannelHandlerContext ctx, final HttpRequest request, final HttpResponse response) { final boolean keepAlive = HttpUtil.isKeepAlive(request); HttpUtil.setKeepAlive(response, keepAlive); final ChannelFuture future = ctx.writeAndFlush(response); if (!keepAlive) { future.addListener(ChannelFutureListener.CLOSE); } } }
public final void sendHttpResponse(HttpRequest req, ChannelHandlerContext ctx, HttpResponseStatus status) { FullHttpResponse resp = new DefaultFullHttpResponse(HTTP_1_1, status); resp.headers().add("Content-Length", "0"); final boolean closeConn = ((status != OK) || (! HttpUtil.isKeepAlive(req))); if (closeConn) { resp.headers().add(HttpHeaderNames.CONNECTION, "Close"); } final ChannelFuture cf = ctx.channel().writeAndFlush(resp); if (closeConn) { cf.addListener(ChannelFutureListener.CLOSE); } }
for (Map.Entry<String, String> entry : response.headers().entries()) { jerseyResponse.getHeaders().add(entry.getKey(), entry.getValue()); if ((response.headers().contains(HttpHeaderNames.CONTENT_LENGTH) && HttpUtil.getContentLength(response) > 0) || HttpUtil.isTransferEncodingChunked(response)) { ctx.channel().closeFuture().addListener(new GenericFutureListener<Future<? super Void>>() { @Override public void operationComplete(Future<? super Void> future) throws Exception { if (content.isReadable()) { byte[] bytes = new byte[content.readableBytes()]; content.getBytes(content.readerIndex(), bytes); isList.add(new ByteArrayInputStream(bytes));
httpRequestWithEntity.headers().setInt(Names.STREAM_ID, streamId); httpRequestWithEntity.headers().setInt(Names.ASSOCIATED_TO_STREAM_ID, associatedToStreamId); httpRequestWithEntity.headers().setInt(Names.PRIORITY, spdySynStreamFrame.priority()); httpResponseWithEntity.headers().setInt(Names.STREAM_ID, streamId); HttpUtil.setContentLength(httpResponseWithEntity, 0); out.add(httpResponseWithEntity); } else { HttpUtil.setContentLength(fullHttpMessage, 0); out.add(fullHttpMessage); } else { HttpUtil.setContentLength(fullHttpMessage, fullHttpMessage.content().readableBytes()); removeMessage(streamId); out.add(fullHttpMessage); if (content.readableBytes() > maxContentLength - spdyDataFrame.content().readableBytes()) { removeMessage(streamId); throw new TooLongFrameException( HttpUtil.setContentLength(fullHttpMessage, content.readableBytes()); removeMessage(streamId); out.add(fullHttpMessage);
HttpUtil.setContentLength(response, content.length()); response.headers().set(CONTENT_TYPE, "text/html"); if (HttpUtil.isKeepAlive(request)) { response.headers().set(CONNECTION, HttpHeaderValues.KEEP_ALIVE); ctx.write(response); ByteBuf buf = ctx.alloc().buffer(content.length()); buf.writeBytes(content.getBytes()); ctx.write(buf); lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT); if (!HttpUtil.isKeepAlive(request)) { lastContentFuture.addListener(ChannelFutureListener.CLOSE);
response.headers().add(e.getKey(), e.getValue()); HttpUtil.setTransferEncodingChunked(response, true); } else { response.headers().set(HttpHeaderNames.CONTENT_LENGTH, contentLength); if (HttpUtil.isKeepAlive(req)) { response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); ctx.writeAndFlush(response); JerseyChunkedInput jerseyChunkedInput = new JerseyChunkedInput(ctx.channel()); if (HttpUtil.isTransferEncodingChunked(response)) { ctx.write(new HttpChunkedInput(jerseyChunkedInput)).addListener(FLUSH_FUTURE); } else { ctx.write(new HttpChunkedInput(jerseyChunkedInput)).addListener(FLUSH_FUTURE);
private boolean writeResponse(HttpResponse response, ChannelHandlerContext ctx) { boolean keepAlive = HttpUtil.isKeepAlive(request); response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, fullHttpResponse.content().readableBytes()); if (keepAlive) { response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE); ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE); } else { ctx.writeAndFlush(response);
!HttpUtil.is100ContinueExpected(oversized) && !HttpUtil.isKeepAlive(oversized)) { ChannelFuture future = ctx.writeAndFlush(TOO_LARGE_CLOSE.retainedDuplicate()); future.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { ctx.writeAndFlush(TOO_LARGE.retainedDuplicate()).addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture future) throws Exception { HttpObjectDecoder decoder = ctx.pipeline().get(HttpObjectDecoder.class); if (decoder != null) { decoder.reset();
final Channel ch = b.connect(host, port).sync().channel(); nettyRequest.headers().add(e.getKey(), e.getValue()); HttpUtil.setTransferEncodingChunked(nettyRequest, true); } else { nettyRequest.headers().add(HttpHeaderNames.CONTENT_LENGTH, jerseyRequest.getLengthLong()); if (HttpUtil.isTransferEncodingChunked(nettyRequest)) { ch.write(new HttpChunkedInput(jerseyChunkedInput)); } else {
@Override public Mono<Void> then() { ByteBufAllocator alloc = parent.channel().alloc(); return Flux.from(source) .collect(alloc::heapBuffer, ByteBuf::writeBytes) .flatMap(agg -> { if (!HttpUtil.isTransferEncodingChunked(request) && !HttpUtil.isContentLengthSet(request)) { request.headers() .setInt(HttpHeaderNames.CONTENT_LENGTH, agg.readableBytes()); } return parent.then().thenEmpty(FutureMono.disposableWriteAndFlush(parent.channel(), Mono.just(agg))); }); }
response.headers().add(headerEntry.getKey(), headerEntry.getValue()); requestHeaders.names().stream() .filter(header -> header.startsWith(HTTP_2_HEADER_PREFIX)) .forEach(header -> response.headers().add(header, requestHeaders.get(header))); HttpUtil.setTransferEncodingChunked(response, true); ctx.writeAndFlush(response) .addListener(future -> { if (future.isSuccess()) { headersFuture.complete(this); .addListener(completeOnFailureListener("An exception occurred when writing headers.")) .addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
private void handleExpect100Continue(ChannelHandlerContext ctx, HttpRequest req) { if (HttpUtil.is100ContinueExpected(req)) { final ChannelFuture f = ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE)); f.addListener((s) -> { if (! s.isSuccess()) { throw new ZuulException( s.cause(), "Failed while writing 100-continue response", true); } }); // Remove the Expect: 100-Continue header from request as we don't want to proxy it downstream. req.headers().remove(HttpHeaderNames.EXPECT); zuulRequest.getHeaders().remove(HttpHeaderNames.EXPECT.toString()); } }
List<String> contentTypes = headers.getAll(HttpHeaderNames.CONTENT_TYPE); List<String> transferEncoding = headers.getAll(HttpHeaderNames.TRANSFER_ENCODING); if (contentTypes != null) { headers.remove(HttpHeaderNames.CONTENT_TYPE); for (String contentType : contentTypes) { HttpUtil.setTransferEncodingChunked(request, true); ByteBuf chunkContent = chunk.content(); if (fullRequest.content() != chunkContent) { fullRequest.content().clear().writeBytes(chunkContent); chunkContent.release();
static void sendError(Channel ch, HttpResponseStatus status, CharSequence err) { FullHttpResponse resp = new DefaultFullHttpResponse(HTTP_1_1, status); if (status.code() == METHOD_NOT_ALLOWED.code()) { // SockJS requires this resp.headers().set(io.vertx.core.http.HttpHeaders.ALLOW, io.vertx.core.http.HttpHeaders.GET); } if (err != null) { resp.content().writeBytes(err.toString().getBytes(CharsetUtil.UTF_8)); HttpUtil.setContentLength(resp, err.length()); } else { HttpUtil.setContentLength(resp, 0); } ch.writeAndFlush(resp); }
@Override public void channelRead0(final ChannelHandlerContext ctx, final Object msg) { if (msg instanceof HttpRequest) { ctx.channel().attr(NettyRequest.NEED_FLUSH).set(true); HttpRequest req = (HttpRequest) msg; ctx.channel().attr(PATH).set(req.method().name() + " " + req.uri()); if (HttpUtil.is100ContinueExpected(req)) { ctx.write(new DefaultFullHttpResponse(HTTP_1_1, HttpResponseStatus.CONTINUE)); } boolean keepAlive = HttpUtil.isKeepAlive(req); try { String streamId = req.headers().get(STREAM_ID); HttpHeaders headers = new DefaultHttpHeaders(); handler.handle( new NettyRequest(ctx, req, headers, tmpdir, wsMaxMessageSize), new NettyResponse(ctx, headers, bufferSize, keepAlive, streamId)); } catch (Throwable ex) { exceptionCaught(ctx, ex); } } else if (msg instanceof WebSocketFrame) { Attribute<NettyWebSocket> ws = ctx.channel().attr(NettyWebSocket.KEY); ws.get().handle(msg); } }