Refine search
nativeHeaders.add(entry.getKey(), entry.getValue()); nativeResponse.headers().add(HttpHeaderNames.TRANSFER_ENCODING, HttpHeaderValues.CHUNKED); } else { nativeResponse.headers().set("Connection", "close"); if (nativeReq.headers().contains(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text())) { String streamId = nativeReq.headers().get(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text()); nativeResponse.headers().set(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), streamId);
public NettyResponse(final ChannelHandlerContext ctx, final HttpHeaders headers, final int bufferSize, final boolean keepAlive, final String streamId) { this.ctx = ctx; this.bufferSize = bufferSize; this.keepAlive = keepAlive; this.headers = headers; if (streamId != null) { headers.set(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), streamId); } this.status = HttpResponseStatus.OK; }
static void handle(ChannelHandlerContext ctx, Http2Connection connection, Http2FrameListener listener, FullHttpMessage message) throws Http2Exception { try { int streamId = getStreamId(connection, message.headers()); Http2Stream stream = connection.stream(streamId); if (stream == null) { stream = connection.remote().createStream(streamId, false); } message.headers().set(HttpConversionUtil.ExtensionHeaderNames.SCHEME.text(), HttpScheme.HTTP.name()); Http2Headers messageHeaders = HttpConversionUtil.toHttp2Headers(message, true); boolean hasContent = message.content().isReadable(); boolean hasTrailers = !message.trailingHeaders().isEmpty(); listener.onHeadersRead( ctx, streamId, messageHeaders, 0, !(hasContent || hasTrailers)); if (hasContent) { listener.onDataRead(ctx, streamId, message.content(), 0, !hasTrailers); } if (hasTrailers) { Http2Headers headers = HttpConversionUtil.toHttp2Headers(message.trailingHeaders(), true); listener.onHeadersRead(ctx, streamId, headers, 0, true); } stream.closeRemoteSide(); } finally { message.release(); } } }
private static void setHttp2Scheme(io.netty.handler.codec.http.HttpHeaders in, URI uri, HttpHeaders out) { final String value = uri.getScheme(); if (value != null) { out.scheme(value); return; } // Consume the Scheme extension header if present final CharSequence cValue = in.get(ExtensionHeaderNames.SCHEME.text()); if (cValue != null) { out.scheme(cValue.toString()); } else { out.scheme("unknown"); } }
HttpVersion.HTTP_1_1, HttpMethod.POST, path, Unpooled.wrappedBuffer(out.getArray(), 0, out.length())); request.headers().add(HttpHeaderNames.HOST, host); request.headers().set(ExtensionHeaderNames.SCHEME.text(), uri.getScheme()); request.headers().add(defaultHeaders); ch.writeAndFlush(request).sync();
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { LOGGER.info("[Client ({})] => [Server ({})] : {}", connectionInfo.getClientAddr(), connectionInfo.getServerAddr(), msg); if (msg instanceof FullHttpRequest) { HttpMessage httpMessage = (HttpRequest) msg; httpMessage.headers().add(ExtensionHeaderNames.SCHEME.text(), "https"); } else if (msg instanceof HttpObject) { throw new IllegalStateException("Cannot handle message: " + msg.getClass()); } ctx.writeAndFlush(msg, promise); } }
@SuppressWarnings("unchecked") @Override public <T> T upgrade(final Class<T> type) { if (type == NativeWebSocket.class) { String protocol = ifSecure("wss", "ws"); String webSocketURL = protocol + "://" + req.headers().get(HttpHeaderNames.HOST) + path; WebSocketServerHandshakerFactory wsFactory = new WebSocketServerHandshakerFactory( webSocketURL, null, true, wsMaxMessageSize); WebSocketServerHandshaker handshaker = wsFactory.newHandshaker(req); NettyWebSocket result = new NettyWebSocket(ctx, handshaker, (ws) -> { handshaker.handshake(ctx.channel(), (FullHttpRequest) req) .addListener(FIRE_EXCEPTION_ON_FAILURE) .addListener(payload -> ws.connect()) .addListener(FIRE_EXCEPTION_ON_FAILURE); }); ctx.channel().attr(NettyWebSocket.KEY).set(result); return (T) result; } else if (type == Sse.class) { NettySse sse = new NettySse(ctx, responseHeaders); return (T) sse; } else if (type == NativePushPromise.class) { return (T) new NettyPush(ctx, req.headers().getInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text()), header("host").orElse(ip()), ifSecure("https", "http")); } throw new UnsupportedOperationException("Not Supported: " + type); }
private void parseResponseHeaders(Operation request, HttpResponse nettyResponse) { HttpHeaders headers = nettyResponse.headers(); if (headers.isEmpty()) { return; headers.remove(HttpHeaderNames.CONNECTION); headers.remove(HttpHeaderNames.CONTENT_LENGTH); headers.remove(HttpConversionUtil.ExtensionHeaderNames.STREAM_WEIGHT.text()); headers.remove(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text());
private void writeInternalServerError(ChannelHandlerContext ctx, Operation request, Integer streamId, String err, String originalPath, double startTime) { byte[] data; try { data = err.getBytes(Utils.CHARSET); } catch (UnsupportedEncodingException ueex) { this.exceptionCaught(ctx, ueex); return; } FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR, Unpooled.wrappedBuffer(data), false, false); if (streamId != null) { response.headers().setInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), streamId); } response.headers().set(HttpHeaderNames.CONTENT_TYPE, Operation.MEDIA_TYPE_TEXT_HTML); response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes()); writeResponse(ctx, request, response, streamId, originalPath, startTime); }
@Override public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception { LOGGER.info("[Client ({})] <= [Server ({})] : {}", connectionInfo.getClientAddr(), connectionInfo.getServerAddr(), msg); if (msg instanceof HttpResponse) { HttpResponse response = (HttpResponse) msg; if (!response.headers().contains(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text())) { if (streams.isEmpty()) { throw new IllegalStateException("No active streams"); } response.headers().add(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), streams.poll()); } } ctx.write(msg, promise); } }
@Override public void onHeadersRead(ChannelHandlerContext ctx, int streamId, Http2Headers headers, int streamDependency, short weight, boolean exclusive, int padding, boolean endOfStream) throws Http2Exception { Http2Stream stream = connection.stream(streamId); FullHttpMessage msg = processHeadersBegin(ctx, stream, headers, endOfStream, true, true); if (msg != null) { // Add headers for dependency and weight. // See https://github.com/netty/netty/issues/5866 if (streamDependency != Http2CodecUtil.CONNECTION_STREAM_ID) { msg.headers().setInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_DEPENDENCY_ID.text(), streamDependency); } msg.headers().setShort(HttpConversionUtil.ExtensionHeaderNames.STREAM_WEIGHT.text(), weight); processHeadersEnd(ctx, stream, msg, endOfStream); } }
try { onUpgradeEvent(ctx, upgrade.retain()); Http2Stream stream = connection().stream(HTTP_UPGRADE_STREAM_ID); if (stream.getProperty(streamKey) == null) { upgrade.upgradeRequest().headers().setInt( HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), HTTP_UPGRADE_STREAM_ID); stream.setProperty(upgradeKey, true); InboundHttpToHttp2Adapter.handle(
private void convert(int streamId, HttpHeaders inHeaders, io.netty.handler.codec.http.HttpHeaders outHeaders, boolean trailer, boolean isRequest) throws Http2Exception { ArmeriaHttpUtil.toNettyHttp1( streamId, inHeaders, outHeaders, HttpVersion.HTTP_1_1, trailer, isRequest); outHeaders.remove(ExtensionHeaderNames.STREAM_ID.text()); if (server) { outHeaders.remove(ExtensionHeaderNames.SCHEME.text()); } else { outHeaders.remove(ExtensionHeaderNames.PATH.text()); } }
/** * Get the next stream id either from the {@link HttpHeaders} object or HTTP/2 codec * * @param httpHeaders The HTTP/1.x headers object to look for the stream id * @return The stream id to use with this {@link HttpHeaders} object * @throws Exception If the {@code httpHeaders} object specifies an invalid stream id */ private int getStreamId(HttpHeaders httpHeaders) throws Exception { return httpHeaders.getInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text(), connection().local().incrementAndGetNextStreamId()); }
@Override protected void channelRead0(ChannelHandlerContext ctx, FullHttpResponse msg) throws Exception { HttpHeaders headers = msg.headers(); Integer streamId = headers.getInt(HttpConversionUtil.ExtensionHeaderNames.STREAM_ID.text()); if (streamId == null) { if (LOGGER.isWarnEnabled()) { LOGGER.warn("HttpResponseHandler unexpected message received: {}, data is {}", msg.toString(), NettyHelper.toString(msg.content())); } return; } Entry<ChannelFuture, AbstractHttpClientHandler> entry = removePromise(streamId); if (entry == null) { if (LOGGER.isWarnEnabled()) { LOGGER.warn("Message received for unknown stream id {}, msg is {}, data is {}", streamId, msg.toString(), NettyHelper.toString(msg.content())); } } else { final AbstractHttpClientHandler callback = entry.getValue(); callback.receiveHttpResponse(msg); } }