private void closeIfNotKeepAlive(final FullHttpRequest request, final ChannelFuture future) { if (!isKeepAlive(request)) { future.addListener(ChannelFutureListener.CLOSE); } }
/** * @deprecated Use {@link HttpUtil#isKeepAlive(HttpMessage)} instead. * * Returns {@code true} if and only if the connection can remain open and * thus 'kept alive'. This methods respects the value of the * {@code "Connection"} header first and then the return value of * {@link HttpVersion#isKeepAliveDefault()}. */ @Deprecated public static boolean isKeepAlive(HttpMessage message) { return HttpUtil.isKeepAlive(message); }
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); } }
private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest request, HttpResponseStatus status, PushUserAuth userAuth) { final FullHttpResponse resp = new DefaultFullHttpResponse(HTTP_1_1, status); resp.headers().add("Content-Length", "0"); final ChannelFuture cf = ctx.channel().writeAndFlush(resp); if (!HttpUtil.isKeepAlive(request)) { cf.addListener(ChannelFutureListener.CLOSE); } logPushEvent(request, status, userAuth); }
/** * Implemented in accordance with RFC 7230 section 6.1 https://tools.ietf.org/html/rfc7230#section-6.1 */ @Override public boolean keepAlive(Request ahcRequest, HttpRequest request, HttpResponse response) { return HttpUtil.isKeepAlive(response) && HttpUtil.isKeepAlive(request) // support non standard Proxy-Connection && !response.headers().contains("Proxy-Connection", CLOSE, true); } }
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); } } }
private static void sendHttpResponse(ChannelHandlerContext ctx, HttpRequest req, HttpResponse res) { ChannelFuture f = ctx.channel().writeAndFlush(res); if (!isKeepAlive(req) || res.status().code() != 200) { f.addListener(ChannelFutureListener.CLOSE); } }
@Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { // read message and track if it was keepAlive if (msg instanceof HttpRequest) { final HttpRequest request = (HttpRequest) msg; if (persistentConnection) { pendingResponses += 1; persistentConnection = isKeepAlive(request); } } super.channelRead(ctx, msg); }
@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); } }
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); } }
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); } }
private void prepareForKeepAlive(final FullHttpRequest request, final FullHttpResponse response) { if (isKeepAlive(request)) { setKeepAlive(response, true); setContentLengthForKeepAlive(response); } }
private void sendHttpResponse(ChannelHandlerContext ctx, FullHttpRequest request, HttpResponseStatus status, PushUserAuth userAuth) { final FullHttpResponse resp = new DefaultFullHttpResponse(HTTP_1_1, status); resp.headers().add("Content-Length", "0"); final ChannelFuture cf = ctx.channel().writeAndFlush(resp); if (!HttpUtil.isKeepAlive(request)) { cf.addListener(ChannelFutureListener.CLOSE); } logPushEvent(request, status, userAuth); }
@Override protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception { FullHttpRequest httpRequest = (FullHttpRequest)msg; try { CommandRequest request = parseRequest(httpRequest); if (StringUtil.isBlank(HttpCommandUtils.getTarget(request))) { writeErrorResponse(BAD_REQUEST.code(), "Invalid command", ctx); return; } handleRequest(request, ctx, HttpUtil.isKeepAlive(httpRequest)); } catch (Exception ex) { writeErrorResponse(INTERNAL_SERVER_ERROR.code(), SERVER_ERROR_MESSAGE, ctx); CommandCenterLog.warn("Internal error", ex); } }
@Override protected void channelRead0(ChannelHandlerContext ctx, HttpRequest request) throws Exception { final Channel channel = ctx.channel(); final boolean keepAlive = HttpUtil.isKeepAlive(request); final HttpVersion httpRequestVersion = request.protocolVersion(); final String origin = request.headers().get(HttpHeaderNames.ORIGIN); // to allow for future changes, let's be at least a little strict in what we accept here. if (HttpMethod.OPTIONS.equals(request.method())) { writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.OK, origin); return; } else if (!HttpMethod.POST.equals(request.method())) { writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.METHOD_NOT_ALLOWED, origin); return; } final boolean correctPath = "/gelf".equals(request.uri()); if (correctPath && request instanceof FullHttpRequest) { final FullHttpRequest fullHttpRequest = (FullHttpRequest) request; final ByteBuf buffer = fullHttpRequest.content(); // send on to raw message handler writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.ACCEPTED, origin); ctx.fireChannelRead(buffer.retain()); } else { writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.NOT_FOUND, origin); } }
@SuppressWarnings("rawtypes") protected void processHttpRequest(ChannelHandlerContext ctx, FullHttpRequest httpRequest) { FullHttpResponse httpResponse = null; try { DefaultRequest rpcRequest = buildRpcRequest(httpRequest); String ip = NetUtils.getHostName(ctx.channel().remoteAddress()); if(ip != null){ rpcRequest.setAttachment(URLParamType.host.getName(), ip); } Provider provider = providerMap.get(rpcRequest.getInterfaceName()); if (provider == null) { httpResponse = buildErrorResponse("request service not exist. service:" + rpcRequest.getInterfaceName()); } else { Response response = provider.call(rpcRequest); httpResponse = buildHttpResponse(response, HttpUtil.isKeepAlive(httpRequest)); } } catch (Exception e) { LoggerUtil.error("NettyHttpHandler process http request fail.", e); httpResponse = buildErrorResponse(e.getMessage()); } finally { httpRequest.content().release(); } sendResponse(ctx, httpResponse); }
if (!closeConnection && HttpUtil.isKeepAlive(nativeReq)) { HttpUtil.setKeepAlive(nativeResponse, true); } else {
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { // modify message on way out to add headers if needed if (msg instanceof HttpResponse) { final HttpResponse response = (HttpResponse) msg; trackResponse(response); // Assume the response writer knows if they can persist or not and sets isKeepAlive on the response if (!isKeepAlive(response) || !isSelfDefinedMessageLength(response)) { // No longer keep alive as the client can't tell when the message is done unless we close connection pendingResponses = 0; persistentConnection = false; } // Server might think it can keep connection alive, but we should fix response header if we know better if (!shouldKeepAlive()) { setKeepAlive(response, false); } } if (msg instanceof LastHttpContent && !shouldKeepAlive()) { promise = promise.unvoid().addListener(ChannelFutureListener.CLOSE); } super.write(ctx, msg, promise); }
public HttpRequest decode(FullHttpRequest fullHttpRequest) { HttpRequest httpRequest = new HttpRequest(); if (fullHttpRequest != null) { setMethod(httpRequest, fullHttpRequest); setPath(httpRequest, fullHttpRequest); setQueryString(httpRequest, new QueryStringDecoder(fullHttpRequest.uri())); setHeaders(httpRequest, fullHttpRequest); setCookies(httpRequest, fullHttpRequest); setBody(httpRequest, fullHttpRequest); httpRequest.withKeepAlive(isKeepAlive(fullHttpRequest)); httpRequest.withSecure(isSecure); } return httpRequest; }
if (!closeConnection && HttpUtil.isKeepAlive(nativeReq)) { HttpUtil.setKeepAlive(nativeResponse, true); } else {