@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()); } }
synchronized void initializeAsynchronousTransfer(final FilterChainContext context, final HttpRequestPacket requestPacket) throws IOException { if (asyncTransferInitiated) { throw new IllegalStateException("Async transfer has already been initiated."); } if (feeder == null) { throw new IllegalStateException("No feeder available to perform the transfer."); } assert (context != null); assert (requestPacket != null); this.requestPacket = requestPacket; this.contentBuilder = HttpContent.builder(requestPacket); final Connection c = context.getConnection(); origMaxPendingBytes = c.getMaxAsyncWriteQueueSize(); if (configuredMaxPendingBytes != DEFAULT) { c.setMaxAsyncWriteQueueSize(configuredMaxPendingBytes); } this.context = context; asyncTransferInitiated = true; if (requestPacket.isSecure() && (getSSLEngine(context.getConnection()) == null)) { flushOnSSLHandshakeComplete(); } else { feederFlush(context.getConnection()); } }
@Override public boolean isLast() { return content.isLast(); }
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();
ctx.getConnection()); httpRequestPacket.getProcessingState().getHttpContext().attach(ctx); if (messageContent.hasRemaining()) { messageContent.position(messageContent.position() + 2); 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);
private static NextAction handleClientHandShake(FilterChainContext ctx, HttpContent content) { final WebSocketHolder holder = WebSocketHolder.get(ctx.getConnection()); holder.handshake.validateServerResponse((HttpResponsePacket) content.getHttpHeader()); holder.webSocket.onConnect(); if (content.getContent().hasRemaining()) { return ctx.getRerunFilterAction(); } else { content.recycle(); return ctx.getStopAction(); } } }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { // Get the parsed HttpContent (we assume prev. filter was HTTP) HttpContent message = ctx.getMessage(); Socket tunnelSocket = tunnelSockets.get(ctx.getConnection()); if (tunnelSocket == null) { // handle connection procedure return GrizzlyModProxy.this.handleConnect(ctx, message); } if (message.getContent().hasRemaining()) { // relay the content to the tunnel connection Buffer buffer = message.getContent(); message.recycle(); tunnelSocket.getOutputStream().write(buffer.array(), buffer.arrayOffset(), buffer.remaining()); } return ctx.getStopAction(); } }
@Override public NextAction handleRead(final FilterChainContext ctx) throws IOException { final Object message = ctx.getMessage(); // If the input message is not HttpContent or it's last HttpContent message - // pass the message to a next filter if (!(message instanceof HttpContent) || ((HttpContent) message).isLast()) { return ctx.getInvokeAction(); } // if it's HttpContent chunk (not last) - save it and stop filter chain processing. return ctx.getStopAction(message); } }
@Override public NextAction handleRead(FilterChainContext ctx) throws IOException { HttpContent c = ctx.getMessage(); Buffer b = c.getContent(); if (b.hasRemaining()) { sb.append(b.toStringContent()); } // Last content from the server, set the future result so // the client can display the result and gracefully exit. if (c.isLast()) { future.result(sb.toString()); } return ctx.getStopAction(); // discontinue filter chain execution }
@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()); }
@Override public void prepareSerialize(FilterChainContext ctx, HttpHeader httpHeader, HttpContent httpContent) { final int defaultContentLength = httpContent != null ? httpContent.getContent().remaining() : -1; httpHeader.makeContentLengthHeader(defaultContentLength); }
public void respond(final FilterChainContext ctx, final WebSocketApplication application, final HttpResponsePacket response) { response.setProtocol(Protocol.HTTP_1_1); response.setStatus(HttpStatus.SWITCHING_PROTOCOLS_101); response.setHeader("Upgrade", "websocket"); response.setHeader("Connection", "Upgrade"); setHeaders(response); if (!getSubProtocol().isEmpty()) { response.setHeader(Constants.SEC_WS_PROTOCOL_HEADER, join(application.getSupportedProtocols(getSubProtocol()))); } if (!application.getSupportedExtensions().isEmpty() && !getExtensions().isEmpty()) { List<Extension> intersection = intersection(getExtensions(), application.getSupportedExtensions()); if (!intersection.isEmpty()) { application.onExtensionNegotiation(intersection); response.setHeader(Constants.SEC_WS_EXTENSIONS_HEADER, joinExtensions(intersection)); } } ctx.write(HttpContent.builder(response).build()); }
@Override public byte[] getBodyPartBytes() { byte[] bytes = contentBytes.get(); if (bytes != null) { return bytes; } final Buffer b = content.getContent(); final int origPos = b.position(); bytes = new byte[b.remaining()]; b.get(bytes); b.flip(); b.position(origPos); contentBytes.compareAndSet(null, bytes); return bytes; }
@SuppressWarnings({"unchecked"}) public boolean doHandle(final FilterChainContext ctx, final Request request, final HttpRequestPacket requestPacket) throws IOException { final MemoryManager mm = ctx.getMemoryManager(); final byte[] data = request.getByteData(); final Buffer gBuffer = Buffers.wrap(mm, data); if (requestPacket.getContentLength() == -1) { if (!clientConfig.isCompressionEnabled()) { requestPacket.setContentLengthLong(data.length); } } final HttpContent content = requestPacket.httpContentBuilder().content(gBuffer).build(); content.setLast(true); ctx.write(content, ((!requestPacket.isCommitted()) ? ctx.getTransportContext().getCompletionHandler() : null)); return true; }
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 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()));
@Override public void markUnderlyingConnectionAsToBeClosed() { content.getHttpHeader().getProcessingState().setKeepAlive(false); }
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())); } } }
@Override public boolean isUnderlyingConnectionToBeClosed() { return content.getHttpHeader().getProcessingState().isStayAlive(); }
@Override public int length() { return content.getContent().remaining(); } }