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; // } } }
requestPacket.setContentLengthLong(f.length()); final HttpTransactionContext context = HttpTransactionContext.currentTransaction(requestPacket); if (!SEND_FILE_SUPPORT || requestPacket.isSecure()) { final MemoryManager mm = ctx.getMemoryManager(); AtomicInteger written = new AtomicInteger(); boolean last = false; requestPacket.httpContentBuilder().content(b). last(last).build(); ctx.write(content, ((!requestPacket.isCommitted()) ? ctx.getTransportContext().getCompletionHandler() : null)); ctx.write(requestPacket, ((!requestPacket.isCommitted()) ? ctx.getTransportContext().getCompletionHandler() : null)); ctx.write(new FileTransfer(f), new EmptyCompletionHandler<WriteResult>() {
@Override public void service(Request request, Response response) throws Exception { response.setContentType("application/json"); String[] pathComponents = request.getPathInfo().split("/"); response.setStatus(HttpStatus.BAD_REQUEST_400); response.setDetailMessage("path should have at least one part"); if (request.getMethod() == Method.HEAD) { mapper.readTree(request.getInputStream()); response.setStatus(HttpStatus.OK_200); return; request.getRequest().getConnection() .addCloseListener((closeable, iCloseType) -> { broker.removeSuspendedResponse(graphAffinity, response); request.getRequest().getConnection() .addCloseListener((closeable, iCloseType) -> { broker.deletePriorityTask(task.taskId); request.getRequest().getConnection().addCloseListener((c, i) -> { broker.removeSinglePointChannel(graphAffinity, wr); });
final Connection connection = ctx.getConnection(); final HttpResponsePacket httpResponse = httpRequest.getResponse(); httpResponse.setStatus(HttpStatus.SWITCHING_PROTOCOLS_101); httpResponse.setHeader(Header.Connection, "Upgrade"); httpResponse.setHeader(Header.Upgrade, HTTP2_CLEAR); httpResponse.setIgnoreContentModifiers(true); ctx.write(httpResponse); httpResponse.setStatus(HttpStatus.OK_200); httpResponse.getHeaders().clear(); httpRequest.setProtocol(Protocol.HTTP_2_0); httpResponse.setProtocol(Protocol.HTTP_2_0); httpRequest.getUpgradeDC().recycle(); httpResponse.getProcessingState().setKeepAlive(true); httpRequest, 0, !httpRequest.isExpectContent()); httpRequest.getProcessingState().setHttpContext(httpContext); httpRequest.setAttribute(Http2Stream.HTTP2_STREAM_ATTRIBUTE, stream); httpContext.attach(ctx);
public static void writeTraceMessage(final Request request, final Response response) throws IOException { response.setStatus(HttpStatus.OK_200); response.setContentType("message/http"); final Writer writer = response.getWriter(); writer.append(request.getMethod().toString()).append(' ') .append(request.getRequest().getRequestURIRef().getOriginalRequestURIBC().toString()) .append(' ').append(request.getProtocol().getProtocolString()) .append("\r\n"); for (String headerName : request.getHeaderNames()) { for (String headerValue : request.getHeaders(headerName)) { writer.append(headerName).append(": ").append(headerValue).append("\r\n"); } } }
@Override public NextAction handleRead(final FilterChainContext ctx) throws IOException { final HttpContent requestContent = ctx.getMessage(); final HttpRequestPacket request = (HttpRequestPacket) requestContent.getHttpHeader(); if (fileCache.isEnabled() && Method.GET.equals(request.getMethod())) { final FileCacheEntry cacheEntry = fileCache.get(request); if (cacheEntry != null) { final HttpResponsePacket response = request.getResponse(); prepareResponse(cacheEntry, response); if (response.getStatus() != 200) { ctx.write(HttpContent.builder(response) .content(Buffers.EMPTY_BUFFER) .last(true) final Buffer buffer = Buffers.wrap(ctx.getMemoryManager(), cacheEntry.getByteBuffer(isServeCompressed).duplicate()); ctx.write(HttpContent.builder(response) .content(buffer) .last(true) return fileCache.isFileSendEnabled() && !request.isSecure() ? sendFileZeroCopy(ctx, response, cacheEntry, isServeCompressed)
HttpHeader httpHeader = content.getHttpHeader(); HttpRequestPacket requestPacket = (HttpRequestPacket) httpHeader.getHttpHeader(); if (!requestPacket.getMethod().matchesMethod("CONNECT")) { System.out.println("Received method is not CONNECT"); writeHttpResponse(ctx, 400); return ctx.getStopAction(); String destinationUri = requestPacket.getRequestURI(); System.out.println("Destination URI not in host:port format: " + destinationUri); writeHttpResponse(ctx, 400); return ctx.getStopAction(); System.out.println("Could not parse destination port: " + portStr); writeHttpResponse(ctx, 400); return ctx.getStopAction(); request.getResponse().getProcessingState().setKeepAlive(true); request.getResponse().setContentLength(0); request.setMethod("GET");
@Override public String resolve(final Request request) { try { final RequestURIRef uriRef = request.getRequest().getRequestURIRef(); uriRef.setDefaultURIEncoding(httpHandler.getRequestURIEncoding()); final DataChunk decodedURI = uriRef.getDecodedRequestURIBC( httpHandler.isAllowEncodedSlash()); final int pos = decodedURI.indexOf(';', 0); return pos < 0 ? decodedURI.toString() : decodedURI.toString(0, pos); } catch (CharConversionException e) { throw new IllegalStateException(e); } }
/** * {@inheritDoc} */ @Override public String toString() { final StringBuilder sb = new StringBuilder(256); sb.append("HttpRequestPacket (\n method=").append(getMethod()) .append("\n url=").append(getRequestURI()) .append("\n query=").append(getQueryString()) .append("\n protocol=").append(getProtocol().getProtocolString()) .append("\n content-length=").append(getContentLength()) .append("\n headers=["); final MimeHeaders headersLocal = getHeaders(); for (final String name : headersLocal.names()) { for (String value : headersLocal.values(name)) { sb.append("\n ").append(name).append('=').append(value); } } sb.append("]\n)"); return sb.toString(); }
@Override public void write(WebSocketResponse response) { if (ctx == null) { throw new UnsupportedOperationException("not supported on client side"); } final HttpResponsePacket responsePacket = ((HttpRequestPacket) httpContent.getHttpHeader()).getResponse(); responsePacket.setProtocol(Protocol.HTTP_1_1); responsePacket.setStatus(response.getStatus()); for (Map.Entry<String, String> entry : response.getHeaders().entrySet()) { responsePacket.setHeader(entry.getKey(), entry.getValue()); } ctx.write(HttpContent.builder(responsePacket).build()); }
private NextAction sendRequest(FilterChainContext ctx, UpgradeRequest upgradeRequest) { HttpRequestPacket.Builder builder = HttpRequestPacket.builder(); if (proxy && !PROXY_CONNECTED.get(ctx.getConnection())) { UPGRADE_REQUEST.set(ctx.getConnection(), upgradeRequest); URI requestURI = upgradeRequest.getRequestURI(); final int requestPort = Utils.getWsPort(requestURI); builder = builder.uri(String.format("%s:%d", requestURI.getHost(), requestPort)); builder = builder.protocol(Protocol.HTTP_1_1); builder = builder.method(Method.CONNECT); if (proxyHeaders != null && proxyHeaders.size() > 0) { for (Map.Entry<String, String> entry : proxyHeaders.entrySet()) { builder.header(entry.getKey(), entry.getValue()); } } builder = builder.header(Header.Host, requestURI.getHost()); builder = builder.header(Header.ProxyConnection, "keep-alive"); builder = builder.header(Header.Connection, "keep-alive"); ctx.write(HttpContent.builder(builder.build()).build()); ctx.flush(null); } else { ctx.write(getHttpContent(upgradeRequest)); } // call the next filter in the chain return ctx.getInvokeAction(); }
private static void prepareRequest(final HttpRequestPacket request) { String contentType = request.getContentType(); if (contentType != null) { request.getHeaders().setValue(Header.ContentType).setString(contentType); } }
if (!response.getRequest().getRequest().getConnection().isOpen()) { LOG.debug("Consumer connection was closed. It will be removed."); return false; response.setStatus(HttpStatus.OK_200); OutputStream out = response.getOutputStream(); mapper.writeValue(out, tasks); response.resume();
private void writeHttpResponse(FilterChainContext ctx, int status) { HttpResponsePacket responsePacket = getHttpRequest(ctx).getResponse(); responsePacket.setProtocol(Protocol.HTTP_1_1); responsePacket.setStatus(status); ctx.write(HttpContent.builder(responsePacket).build()); }
private static WebSocketRequest createWebSocketRequest(final FilterChainContext ctx, final HttpContent requestContent) { final HttpRequestPacket requestPacket = (HttpRequestPacket) requestContent.getHttpHeader(); final RequestContext requestContext = RequestContext.Builder.create() .requestURI(URI.create(requestPacket.getRequestURI())) .queryString(requestPacket.getQueryString()) .connection(getWebSocketConnection(ctx, requestContent)) .secure(requestPacket.isSecure()) .build(); for (String name : requestPacket.getHeaders().names()) { final List<String> values = requestContext.getHeaders().get(name); if(values == null) { requestContext.getHeaders().put(name, Utils.parseHeaderValue(requestPacket.getHeader(name).trim())); } else { values.addAll(Utils.parseHeaderValue(requestPacket.getHeader(name).trim())); } } return requestContext; } }
private boolean sendAsGrizzlyRequest(final HttpTransactionContext httpTxCtx, final FilterChainContext ctx) throws IOException { final Connection connection = ctx.getConnection(); final HttpRequestPacket.Builder builder = HttpRequestPacket.builder() .protocol(Protocol.HTTP_1_1) .method(method); httpTxCtx.protocolHandler = Version.RFC6455.createHandler(true); httpTxCtx.handshake = httpTxCtx.protocolHandler.createClientHandShake(wsURI); requestPacket = (HttpRequestPacket) httpTxCtx.handshake.composeHeaders().getHttpHeader(); } catch (URISyntaxException e) { throw new IllegalArgumentException("Invalid WS URI: " + httpTxCtx.wsRequestURI); requestPacket.setSecure(secure); setupKeepAlive(requestPacket, connection); ctx.notifyDownstream(new SSLSwitchingEvent(connection, secure, uri.getHost(), uri.getPort()));
private boolean establishConnectTunnel(final ProxyServer proxy, final HttpTransactionContext httpCtx, final Uri uri, final FilterChainContext ctx) throws IOException { final Connection connection = ctx.getConnection(); final HttpRequestPacket requestPacket = HttpRequestPacket.builder() .protocol(Protocol.HTTP_1_0) .method(Method.CONNECT) .uri(AsyncHttpProviderUtils.getAuthority(uri)) .build(); setupKeepAlive(requestPacket, connection); httpCtx.establishingTunnel = true; final Request request = httpCtx.getAhcRequest(); addHostHeaderIfNeeded(request, uri, requestPacket); addServiceHeaders(requestPacket); final Realm realm = getRealm(request); addAuthorizationHeader(request, requestPacket, realm, uri, proxy, false); addProxyHeaders(request, requestPacket, realm, proxy, false, true); // turn off SSL, because CONNECT will be sent in plain mode ctx.notifyDownstream(new SSLSwitchingEvent(connection, false)); return sendRequest(httpCtx, ctx, requestPacket, null); }
private void writeTraceHeaders(FilterChainContext ctx, UpgradeResponse upgradeResponse) { final HttpResponsePacket responsePacket = ((HttpRequestPacket) ((HttpContent) ctx.getMessage()).getHttpHeader()).getResponse(); for (Map.Entry<String, List<String>> entry : upgradeResponse.getHeaders().entrySet()) { if (entry.getKey().contains(UpgradeResponse.TRACING_HEADER_PREFIX)) { responsePacket.setHeader(entry.getKey(), Utils.getHeaderFromList(entry.getValue())); } } }
private void addAcceptHeaders(final HttpRequestPacket requestPacket) { final MimeHeaders headers = requestPacket.getHeaders(); if (config.isCompressionEnforced() && !headers.contains(Header.AcceptEncoding)) { headers.addValue(Header.AcceptEncoding).setString("gzip"); } if (!headers.contains(Header.Accept)) { headers.addValue(Header.Accept).setString("*/*"); } }
private void initialize() { isInitialized = true; host = request.getHeader(Header.Host); uri = request.getRequestURI(); }