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) {
@Override protected void onHttpContentEncoded(final HttpContent content, final FilterChainContext ctx) { final HttpTransactionContext context = HttpTransactionContext.currentTransaction(content.getHttpHeader()); final AsyncHandler handler = context.getAsyncHandler(); if (handler instanceof TransferCompletionHandler) { final int written = content.getContent().remaining(); context.totalBodyWritten += written; final long total = context.totalBodyWritten; ((TransferCompletionHandler) handler).onContentWriteProgress( written, total, content.getHttpHeader().getContentLength()); } }
if (httpHeader.isSkipRemainder()) { return false; httpHeader.setExpectContent(false); return false; httpHeader.setSkipRemainder(true); (HttpResponsePacket) httpHeader, context, ctx); if (!result) { httpHeader.setSkipRemainder(true); return false; httpHeader.setChunked(false); ws.onConnect(); WebSocketHolder.set(ctx.getConnection(), context.protocolHandler, ws); ((WebSocketUpgradeHandler) context.getAsyncHandler()).onSuccess(context.webSocket); final int wsTimeout = provider.getClientConfig().getWebSocketTimeout(); IdleTimeoutFilter.setCustomTimeout(ctx.getConnection(), (wsTimeout <= 0) ? IdleTimeoutFilter.FOREVER : wsTimeout, TimeUnit.MILLISECONDS); context.done(handler.onCompleted()); } else { httpHeader.setSkipRemainder(true); ((WebSocketUpgradeHandler) context.getAsyncHandler()).onClose( context.webSocket, 1002, httpHeader.setSkipRemainder(true); context.abort(e);
if (httpHeader.isSkipRemainder()) { return; final HttpTransactionContext context = HttpTransactionContext.currentTransaction(httpHeader); final int status = responsePacket.getStatus(); if (context.establishingTunnel && HttpStatus.OK_200.statusMatches(status)) { return; ctx.notifyUpstream(new ContinueEvent(context)); return; httpHeader.setSkipRemainder(true); context.abort(new MaxRedirectException()); context.currentState = handler.onStatusReceived(responseStatus); if (context.isWSRequest && context.currentState == AsyncHandler.STATE.ABORT) { httpHeader.setSkipRemainder(true); try { context.done(handler.onCompleted()); httpHeader.setSkipRemainder(true); context.abort(e);
final boolean wasHeaderParsed) throws IOException { remainderBuffer.hasRemaining(); boolean isLast = !httpHeader.isExpectContent(); if (httpContent.isLast()) { isLast = true; httpHeader.setExpectContent(false); if (httpHeader.isSkipRemainder()) { if (isLast) { onHttpPacketParsed(httpHeader, ctx); if (!httpHeader.getProcessingState().isStayAlive()) { httpHeader.getProcessingState().getHttpContext().close(); return ctx.getStopAction(); } else if (remainderBuffer != null) { ctx.setMessage(remainderBuffer); return ctx.getRerunFilterAction(); httpContent.getContent().remaining())) { httpHeader.getProcessingState().getHttpContext().close(); } else if (remainderBuffer != null) {
return ctx.getInvokeAction(); final Connection connection = ctx.getConnection(); Http2State http2State = Http2State.get(connection); return ctx.getInvokeAction(); final HttpContent httpContent = ctx.getMessage(); final HttpHeader httpHeader = httpContent.getHttpHeader(); assert !httpHeader.isRequest(); final HttpRequestPacket httpRequest = httpResponse.getRequest(); obtainHttp2Session(http2State, ctx, true); final Buffer framePayload = httpContent.getContent(); httpContent.recycle();
public void initialize(final HttpHeader outputHeader, final boolean sendfileEnabled, final FilterChainContext ctx) { this.outputHeader = outputHeader; if (builder == null) { this.builder = outputHeader.httpContentBuilder(); } else { builder.httpHeader(outputHeader); } this.sendfileEnabled = sendfileEnabled; this.ctx = ctx; httpContext = outputHeader.getProcessingState().getHttpContext(); connection = ctx.getConnection(); memoryManager = ctx.getMemoryManager(); }
@Override public NextAction handleWrite(FilterChainContext ctx) throws IOException { final Connection c = ctx.getConnection(); final Object message = ctx.getMessage(); if (HttpPacket.isHttp(message)) { assert message instanceof HttpPacket; final HttpHeader header = ((HttpPacket) message).getHttpHeader(); if (!header.isCommitted() && header.isRequest()) { assert header instanceof HttpRequestPacket; getRequestQueue(c).offer((HttpRequestPacket) header); } } return super.handleWrite(ctx); }
public HttpHeader build() { HttpHeader httpHeader = create(); if (protocol != null) { httpHeader.setProtocol(protocol); } if (protocolString != null) { httpHeader.protocolC.setString(protocolString); } if (chunked != null) { httpHeader.setChunked(chunked); } if (contentLength != null) { httpHeader.setContentLengthLong(contentLength); } if (contentType != null) { httpHeader.setContentType(contentType); } if (upgrade != null) { httpHeader.setUpgrade(upgrade); } if (mimeHeaders != null && mimeHeaders.size() > 0) { httpHeader.getHeaders().copyFrom(mimeHeaders); } return httpHeader; }
/** * Check if passed {@link HttpContent} is {@link HttpTrailer}, which represents * trailer chunk (when chunked Transfer-Encoding is used), if it is a trailer * chunk - then copy all the available trailer headers to request headers map. */ private static void checkHttpTrailer(final HttpContent httpContent) { if (HttpTrailer.isTrailer(httpContent)) { final HttpTrailer httpTrailer = (HttpTrailer) httpContent; final HttpHeader httpHeader = httpContent.getHttpHeader(); httpHeader.getHeaders().mark(); final MimeHeaders trailerHeaders = httpTrailer.getHeaders(); final int size = trailerHeaders.size(); for (int i = 0; i < size; i++) { httpHeader.addHeader( trailerHeaders.getName(i).toString(), trailerHeaders.getValue(i).toString()); } } }
void sendMessageUpstreamWithParseNotify(final Http2Stream stream, final HttpContent httpContent) { final FilterChainContext upstreamContext = http2StreamChain.obtainFilterChainContext(connection, stream); final HttpContext httpContext = httpContent.getHttpHeader() .getProcessingState().getHttpContext(); httpContext.attach(upstreamContext); handlerFilter.onHttpContentParsed(httpContent, upstreamContext); final HttpHeader header = httpContent.getHttpHeader(); if (httpContent.isLast()) { handlerFilter.onHttpPacketParsed(header, upstreamContext); } if (header.isSkipRemainder()) { return; } sendMessageUpstream(stream, httpContent, upstreamContext); }
@Override public HttpContent composeHeaders() { HttpContent content = super.composeHeaders(); final HttpHeader header = content.getHttpHeader(); header.addHeader(Constants.SEC_WS_KEY_HEADER, secKey.toString()); header.addHeader(Constants.SEC_WS_ORIGIN_HEADER, getOrigin()); header.addHeader(Constants.SEC_WS_VERSION, getVersion() + ""); if (!getExtensions().isEmpty()) { header.addHeader(Constants.SEC_WS_EXTENSIONS_HEADER, joinExtensions(getExtensions())); } final String headerValue = header.getHeaders().getHeader(SEC_WS_ORIGIN_HEADER); header.getHeaders().removeHeader(SEC_WS_ORIGIN_HEADER); header.addHeader(ORIGIN_HEADER, headerValue); return content; }
private static void processNormalHeader(final HttpHeader httpHeader, final String name, final String value) { if (name.equals(Header.Host.getLowerCase())) { return; } final MimeHeaders mimeHeaders = httpHeader.getHeaders(); final DataChunk valueChunk = mimeHeaders.addValue(name); validateHeaderCharacters(name, value); valueChunk.setString(value); finalizeKnownHeader(httpHeader, name, value); }
@Override public void markUnderlyingConnectionAsToBeClosed() { content.getHttpHeader().getProcessingState().setKeepAlive(false); }
@Override protected void onInitialLineEncoded(HttpHeader header, FilterChainContext ctx) { super.onInitialLineEncoded(header, ctx); if (!header.isCommitted()) { final HttpResponsePacket response = (HttpResponsePacket) header; if (response.getStatus() == Response.Status.NO_CONTENT.getStatusCode()) { response.getHeaders().setValue("Content-Length").setString("0"); response.getHeaders().setValue("Content-Type").setString(MediaType.TEXT_PLAIN); } } } }
/** * Builds {@link HttpContent} based on passed payload {@link Buffer}. * If the payload size is <tt>0</tt> and the input buffer has been terminated - * return {@link HttpBrokenContent}. */ private HttpContent buildHttpContent(final Buffer payload) { final Termination localTermination = closeFlag; final boolean isFin = localTermination == IN_FIN_TERMINATION; final HttpContent httpContent; // if payload size is not 0 or this is FIN payload if (payload.hasRemaining() || localTermination == null || isFin) { final HttpHeader inputHttpHeader = stream.getInputHttpHeader(); inputHttpHeader.setExpectContent(!isFin); httpContent = HttpContent.builder(inputHttpHeader) .content(payload) .last(isFin) .build(); } else { // create broken HttpContent httpContent = buildBrokenHttpContent( new EOFException(localTermination.getDescription())); } return httpContent; }
@Override public boolean isUnderlyingConnectionToBeClosed() { return content.getHttpHeader().getProcessingState().isStayAlive(); }
private String getValueBasedOnHeader(final Header header) { if (Header.ContentType.equals(header)) { final String value = getContentType(); if (value != null) { return value; } } else if (Header.ContentLength.equals(header)) { final long value = getContentLength(); if (value >= 0) { return Long.toString(value); } } else if (Header.Upgrade.equals(header)) { return getUpgrade(); } return null; }
private boolean isResponseToHeadRequest(HttpHeader header) { if (header.isRequest()) { return false; } else { HttpRequestPacket request = ((HttpResponsePacket) header).getRequest(); return request.isHeadRequest(); } }
static HttpTransactionContext currentTransaction( final HttpHeader httpHeader) { return currentTransaction(httpHeader.getProcessingState().getHttpContext()); }