@Override public NextAction handleEvent(final FilterChainContext ctx, final FilterChainEvent event) throws IOException { if (event.type() == GracefulCloseEvent.class) { // Connection was closed. // This event is fired only for responses, which don't have // associated transfer-encoding or content-length. // We have to complete such a request-response processing gracefully. final GracefulCloseEvent closeEvent = (GracefulCloseEvent) event; final HttpResponsePacket response = closeEvent.getHttpTxContext().responsePacket; response.getProcessingState().getHttpContext().attach(ctx); onHttpPacketParsed(response, ctx); return ctx.getStopAction(); } return ctx.getInvokeAction(); }
@Override public void markUnderlyingConnectionAsToBeClosed() { content.getHttpHeader().getProcessingState().setKeepAlive(false); }
HttpTransactionContext.bind(httpCtx, httpTxCtx); requestPacket.getProcessingState().setHttpContext(httpCtx); httpCtx.attach(ctx); requestPacket.setConnection(ctx.getConnection()); httpTxCtx.payloadGenerator = payloadGenerator; if (LOGGER.isDebugEnabled()) { LOGGER.debug("REQUEST: " + requestPacket.toString()); LOGGER.debug("REQUEST: " + requestPacket.toString()); ctx.write(requestPacket, ctx.getTransportContext().getCompletionHandler());
private NextAction processData(final FilterChainContext ctx, final Buffer messageContent) { final AjpHttpRequest httpRequestPacket = httpRequestInProcessAttr.get( ctx.getConnection()); httpRequestPacket.getProcessingState().getHttpContext().attach(ctx); final HttpContent content = HttpContent.builder(httpRequestPacket) .content(messageContent) .last(!httpRequestPacket.isExpectContent()) .build(); ctx.setMessage(content); return ctx.getInvokeAction(httpRequestPacket.isExpectContent() ? NEED_MORE_DATA_MESSAGE : null);
if (ctx.getConnection().isOpen()) { final HttpContext context = HttpContext.get(ctx); final HttpRequestPacket httpRequest = context.getRequest(); keepAliveContextAttr.get(context); httpRequest.getProcessingState().isKeepAlive(); return ctx.getStopAction(); return ctx.getInvokeAction();
final Connection connection = ctx.getConnection(); HttpResponsePacket httpResponse = httpResponseInProcessAttr.get(connection); httpResponseInProcessAttr.set(connection, httpResponse); final HttpRequestPacket request = httpResponse.getRequest(); httpCtx = request.getProcessingState().getHttpContext(); if (httpCtx == null) { httpCtx = HttpContext.newInstance(connection, connection, connection, request); request.getProcessingState().setHttpContext(httpCtx); httpCtx = HttpContext.newInstance(connection, connection, connection, null); httpCtx.attach(ctx); return handleRead(ctx, httpResponse);
@Override public NextAction handleEvent(final FilterChainContext ctx, final FilterChainEvent event) throws IOException { if (event.type() == HttpEvents.ChangePacketInProgressEvent.TYPE) { final HttpResponsePacket responsePacket = (HttpResponsePacket) ((HttpEvents.ChangePacketInProgressEvent) event).getPacket(); httpResponseInProcessAttr.set( responsePacket.getProcessingState().getHttpContext(), responsePacket); return ctx.getStopAction(); } else { return super.handleEvent(ctx, event); } }
private void commitAndCloseAsError(FilterChainContext ctx, HttpResponsePacket response) { final HttpContent errorHttpResponse = customizeErrorResponse(response); final Buffer resBuf = encodeHttpPacket(ctx, errorHttpResponse); ctx.write(resBuf); response.getProcessingState().getHttpContext().close(); }
final FilterChainContext ctx) { final List<String> proxyAuthHeaders = listOf(responsePacket.getHeaders() .values(Header.ProxyAuthenticate)); newRealm = ntlmProxyChallenge(ctx.getConnection(), ntlmAuthenticate, req, proxyServer); responsePacket.setSkipRemainder(true); // ignore the remainder of the response if (responsePacket.getProcessingState().isKeepAlive()) { c = ctx.getConnection(); httpTransactionContext.reuseConnection(); } else {
protected boolean onHttpPacketParsed(final HttpHeader httpHeader, final FilterChainContext ctx) { final Connection connection = ctx.getConnection(); if (httpHeader.isSkipRemainder()) { cleanup(httpHeader.getProcessingState().getHttpContext()); return result; HttpTransactionContext.currentTransaction(httpHeader); if (context.establishingTunnel && HttpStatus.OK_200.statusMatches( ((HttpResponsePacket) httpHeader).getStatus())) { context.establishingTunnel = false; context.tunnelEstablished(connection); cleanup(httpHeader.getProcessingState().getHttpContext()); final AsyncHandler handler = context.getAsyncHandler(); if (handler != null) {
boolean isGracefullyFinishResponseOnClose() { final HttpResponsePacket response = responsePacket; return response != null && !response.getProcessingState().isKeepAlive() && !response.isChunked() && response.getContentLength() == -1; }
final HttpTransactionContext httpTransactionContext, final FilterChainContext ctx) { final String redirectURL = responsePacket.getHeader(Header.Location); if (redirectURL == null) { throw new IllegalStateException("redirect received, but no location header was present"); responsePacket.setSkipRemainder(true); // ignore the remainder of the response if (responsePacket.getProcessingState().isKeepAlive() && isSameHostAndProtocol(origUri, redirectUri)) { c = ctx.getConnection(); httpTransactionContext.reuseConnection(); } else {
@Override public boolean isUnderlyingConnectionToBeClosed() { return content.getHttpHeader().getProcessingState().isStayAlive(); }
@Override public void completed(HttpTransactionContext context) { if (!context.isReuseConnection()) { final Connection c = (Connection) httpContext.getCloseable(); if (!httpContext.getRequest().getProcessingState().isStayAlive()) { if (notKeepAliveReason == null) { notKeepAliveReason = new IOException("HTTP keep-alive was disabled for this connection"); } c.closeWithReason(notKeepAliveReason); } else { final ConnectionManager cm = context.provider.getConnectionManager(); cm.returnConnection(c); } } } });
void sendMessageUpstream(final Http2Stream stream, final HttpPacket message) { final FilterChainContext upstreamContext = http2StreamChain.obtainFilterChainContext(connection, stream); final HttpContext httpContext = message.getHttpHeader() .getProcessingState().getHttpContext(); httpContext.attach(upstreamContext); sendMessageUpstream(stream, message, upstreamContext); }
void sendUpstream(final Http2Session http2Session, final Http2Stream stream, final HttpContent content) { final HttpRequestPacket request = stream.getRequest(); final HttpContext httpContext = HttpContext.newInstance(stream, stream, stream, request); request.getProcessingState().setHttpContext(httpContext); if (threadPool == null) { // mark this thread as a service to let filters upstream know, that // it must not be blocked, because otherwise entire HTTP2 connection // can stall Threads.setService(true); try { http2Session.sendMessageUpstream(stream, content); } finally { Threads.setService(false); } } else { threadPool.execute(new Runnable() { @Override public void run() { http2Session.sendMessageUpstream(stream, content); } }); } }
private void setKeepAliveForHeader(final Header header, final HttpRequestPacket requestPacket) { final MimeHeaders headers = requestPacket.getHeaders(); // Assign Connection: ... if needed if (!headers.contains(header)) { if (requestPacket.getProcessingState().isKeepAlive()) { headers.addValue(header).setBytes(KEEP_ALIVE_VALUE.getByteArray()); } else if (Protocol.HTTP_1_1.equals(requestPacket.getProtocol())) { headers.addValue(header).setBytes(CLOSE_VALUE.getByteArray()); } // switch (requestPacket.getProtocol()) { // case HTTP_0_9: // case HTTP_1_0: // if (requestPacket.getProcessingState().isKeepAlive()) { // headers.addValue(header).setBytes(KEEP_ALIVE_VALUE.getByteArray()); // } // break; // case HTTP_1_1: // if (!requestPacket.getProcessingState().isKeepAlive()) { // headers.addValue(header).setBytes(CLOSE_VALUE.getByteArray()); // } // break; // } } }
private void setupKeepAlive(final HttpRequestPacket request, final Connection connection) { request.getProcessingState().setKeepAlive( ConnectionManager.isKeepAlive(connection)); } } // END AsyncHttpClientFiler
static HttpTransactionContext currentTransaction( final HttpHeader httpHeader) { return currentTransaction(httpHeader.getProcessingState().getHttpContext()); }