/** * @param nettyRequest The Http netty request * @param conversionService The conversion service */ public AbstractNettyHttpRequest(io.netty.handler.codec.http.HttpRequest nettyRequest, ConversionService conversionService) { this.nettyRequest = nettyRequest; this.conversionService = conversionService; String fullUri = nettyRequest.uri(); this.uri = URI.create(fullUri); this.httpMethod = HttpMethod.valueOf(nettyRequest.method().name()); }
@Override protected void channelRead0(ChannelHandlerContext ctx, HttpRequest request) throws Exception { final Channel channel = ctx.channel(); final boolean keepAlive = HttpUtil.isKeepAlive(request); final HttpVersion httpRequestVersion = request.protocolVersion(); final String origin = request.headers().get(HttpHeaderNames.ORIGIN); // to allow for future changes, let's be at least a little strict in what we accept here. if (HttpMethod.OPTIONS.equals(request.method())) { writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.OK, origin); return; } else if (!HttpMethod.POST.equals(request.method())) { writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.METHOD_NOT_ALLOWED, origin); return; } final boolean correctPath = "/gelf".equals(request.uri()); if (correctPath && request instanceof FullHttpRequest) { final FullHttpRequest fullHttpRequest = (FullHttpRequest) request; final ByteBuf buffer = fullHttpRequest.content(); // send on to raw message handler writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.ACCEPTED, origin); ctx.fireChannelRead(buffer.retain()); } else { writeResponse(channel, keepAlive, httpRequestVersion, HttpResponseStatus.NOT_FOUND, origin); } }
private FullHttpRequest createFullHttpRequest(HttpHeaders headers) { io.netty.handler.codec.http.HttpMethod nettyMethod = io.netty.handler.codec.http.HttpMethod.valueOf(this.method.name()); String authority = this.uri.getRawAuthority(); String path = this.uri.toString().substring(this.uri.toString().indexOf(authority) + authority.length()); FullHttpRequest nettyRequest = new DefaultFullHttpRequest( HttpVersion.HTTP_1_1, nettyMethod, path, this.body.buffer()); nettyRequest.headers().set(HttpHeaders.HOST, this.uri.getHost() + ":" + getPort(this.uri)); nettyRequest.headers().set(HttpHeaders.CONNECTION, "close"); headers.forEach((headerName, headerValues) -> nettyRequest.headers().add(headerName, headerValues)); if (!nettyRequest.headers().contains(HttpHeaders.CONTENT_LENGTH) && this.body.buffer().readableBytes() > 0) { nettyRequest.headers().set(HttpHeaders.CONTENT_LENGTH, this.body.buffer().readableBytes()); } return nettyRequest; }
@Override public HttpResponse clientToProxyRequest(HttpObject httpObject) { if (httpObject instanceof HttpRequest) { HttpRequest httpRequest = (HttpRequest) httpObject; String url = getFullUrl(httpRequest); for (BlacklistEntry entry : blacklistedUrls) { if (HttpMethod.CONNECT.equals(httpRequest.getMethod()) && entry.getHttpMethodPattern() == null) { // do not allow CONNECTs to be blacklisted unless a method pattern is explicitly specified continue; } if (entry.matches(url, httpRequest.getMethod().name())) { HttpResponseStatus status = HttpResponseStatus.valueOf(entry.getStatusCode()); HttpResponse resp = new DefaultFullHttpResponse(httpRequest.getProtocolVersion(), status); HttpHeaders.setContentLength(resp, 0L); return resp; } } } return null; } }
public void createRequest(ByteBuf content) { this.request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method), uri.getPath().toString(), content); // setup the default headers request.headers().set("Connection", "keep-alive"); request.headers().set("Host", uri.getHost() + ":" + (uri.getPort() != -1 ? uri.getPort() : "http".equals(uri.getScheme()) ? 80 : 443)); }
public void interpretHttpRequest(HttpRequest nettyHttpRequest) { _httpMethod = nettyHttpRequest.getMethod().toString(); try { URI uri = new URI(nettyHttpRequest.getUri()); if (uri.isAbsolute()) { _uri = uri; } else { String hostName = nettyHttpRequest.headers().get(HttpHeaders.Names.HOST); if (!Strings.isNullOrEmpty(hostName)) { _uri = new URI(String.format("https://%s%s", hostName, uri)); } else { _path = uri.toString(); } } } catch (URISyntaxException e) { throw new IllegalStateException("Invalid URI in underlying request", e); } }
String host = requestUri.getHost(); int port = requestUri.getPort() != -1 ? requestUri.getPort() : "https".equals(requestUri.getScheme()) ? 443 : 80; HttpMethod.valueOf(jerseyRequest.getMethod()), requestUri.getRawPath()); } else { nettyRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(jerseyRequest.getMethod()), requestUri.getRawPath()); nettyRequest.headers().add(e.getKey(), e.getValue());
URI requestUrl = exchange.getRequiredAttribute(GATEWAY_REQUEST_URL_ATTR); String scheme = requestUrl.getScheme(); if (isAlreadyRouted(exchange) || (!"http".equals(scheme) && !"https".equals(scheme))) { return chain.filter(exchange); final HttpMethod method = HttpMethod.valueOf(request.getMethodValue()); final String url = requestUrl.toString(); res.responseHeaders().forEach(entry -> headers.add(entry.getKey(), entry.getValue()));
@Override public Mono<ClientHttpResponse> connect(HttpMethod method, URI uri, Function<? super ClientHttpRequest, Mono<Void>> requestCallback) { if (!uri.isAbsolute()) { return Mono.error(new IllegalArgumentException("URI is not absolute: " + uri)); } return this.httpClient .request(io.netty.handler.codec.http.HttpMethod.valueOf(method.name())) .uri(uri.toString()) .send((request, outbound) -> requestCallback.apply(adaptRequest(method, uri, request, outbound))) .responseConnection((res, con) -> Mono.just(adaptResponse(res, con.inbound(), con.outbound().alloc()))) .next(); }
private FullHttpRequest createFullHttpRequest(HttpHeaders headers) { io.netty.handler.codec.http.HttpMethod nettyMethod = io.netty.handler.codec.http.HttpMethod.valueOf(this.method.name()); FullHttpRequest nettyRequest = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, nettyMethod, this.uri.toString(), this.body.buffer()); io.netty.handler.codec.http.HttpHeaders nettyHeaders = nettyRequest.headers(); nettyHeaders.set(HttpHeaders.HOST, this.uri.getHost()); nettyHeaders.set(HttpHeaders.CONNECTION, "close"); for (Map.Entry<String, List<String>> entry : headers.entrySet()) { nettyHeaders.add(entry.getKey(), entry.getValue()); } return nettyRequest; }
String s = req.uri().startsWith("/") ? req.uri().substring(1) : req.uri(); URI requestUri = URI.create(baseUri + ContainerUtils.encodeUnsafeCharacters(s)); baseUri, requestUri, req.method().name(), getSecurityContext(), new PropertiesDelegate() { if ((req.headers().contains(HttpHeaderNames.CONTENT_LENGTH) && HttpUtil.getContentLength(req) > 0) || HttpUtil.isTransferEncodingChunked(req)) { for (String name : req.headers().names()) { requestContext.headers(name, req.headers().getAll(name));
final Http2Headers out = new DefaultHttp2Headers(validateHeaders, inHeaders.size()); if (in instanceof HttpRequest) { HttpRequest request = (HttpRequest) in; URI requestTargetUri = URI.create(request.uri()); out.path(toHttp2Path(requestTargetUri)); out.method(request.method().asciiName()); setHttp2Scheme(inHeaders, requestTargetUri, out); String host = inHeaders.getAsString(HttpHeaderNames.HOST); setHttp2Authority((host == null || host.isEmpty()) ? requestTargetUri.getAuthority() : host, out);
private DefaultHttpRequest createRequest(HttpRequest request) throws IOException { HttpMethod method = HttpMethod.valueOf(request.getMethod().name()); URI uri = request.getURI(); String url = StringUtil.isBlank(uri.getRawPath()) ? "/" : uri .getRawPath(); if (StringUtil.isNotBlank(uri.getRawQuery())) { url += "?" + uri.getRawQuery(); uriRequest.getUri(), byteBuf); if (entity.getContentType() != null) { uriRequest.headers().add(HttpHeaders.CONTENT_TYPE, entity.getContentType().toString()); uriRequest.headers().add(HttpHeaders.TRANSFER_ENCODING, io.netty.handler.codec.http.HttpHeaders.Values.CHUNKED); } else { uriRequest.headers().add(HttpHeaders.CONTENT_LENGTH, entity.getContentLength());
if (msg instanceof HttpRequest) { final HttpRequest nettyReq = (HttpRequest) msg; if (!nettyReq.decoderResult().isSuccess()) { fail(id, HttpResponseStatus.BAD_REQUEST); return; final HttpHeaders nettyHeaders = nettyReq.headers(); if (!HttpMethod.isSupported(nettyReq.method().name())) { fail(id, HttpResponseStatus.METHOD_NOT_ALLOWED); return; final String contentLengthStr = nettyHeaders.get(HttpHeaderNames.CONTENT_LENGTH); final boolean contentEmpty; if (contentLengthStr != null) { nettyHeaders.set(ExtensionHeaderNames.SCHEME.text(), scheme); final int dataLength = data.readableBytes(); if (dataLength != 0) { req.increaseTransferredBytes(dataLength); req.write(new ByteBufHttpData(data.retain(), false)); if (!trailingHeaders.isEmpty()) { req.write(ArmeriaHttpUtil.toArmeria(trailingHeaders));
HttpMethod method = HttpMethod.valueOf(headers.getAsString(METHOD)); String url = headers.getAsString(PATH); HttpVersion httpVersion = HttpVersion.valueOf(headers.getAsString(VERSION)); headers.remove(METHOD); headers.remove(PATH); req.headers().set(HttpHeaderNames.HOST, host); req.headers().add(e.getKey(), e.getValue()); req.headers().remove(HttpHeaderNames.TRANSFER_ENCODING); release = false; return req; } finally { if (release) { buffer.release();
if (msg instanceof HttpRequest) { HttpRequest request = (HttpRequest) msg; if (request.headers().contains(io.vertx.core.http.HttpHeaders.UPGRADE, Http2CodecUtil.HTTP_UPGRADE_PROTOCOL_NAME, true)) { String connection = request.headers().get(io.vertx.core.http.HttpHeaders.CONNECTION); int found = 0; if (connection != null && connection.length() > 0) { String settingsHeader = request.headers().get(Http2CodecUtil.HTTP_UPGRADE_SETTINGS_HEADER); if (settingsHeader != null) { Http2Settings settings = HttpUtils.decodeSettings(settingsHeader); handler.serverUpgrade(ctx, settings, request); DefaultHttp2Headers headers = new DefaultHttp2Headers(); headers.method(request.method().name()); headers.path(request.uri()); headers.authority(request.headers().get("host"));
@Override protected void encodeInitialLine(final ByteBuf buf, final HttpMessage message) throws Exception { if (message instanceof HttpRequest) { HttpRequest request = (HttpRequest) message; ByteBufUtil.copy(request.method().asciiName(), buf); buf.writeByte(SP); buf.writeCharSequence(request.uri(), CharsetUtil.UTF_8); buf.writeByte(SP); buf.writeCharSequence(request.protocolVersion().toString(), CharsetUtil.US_ASCII); ByteBufUtil.writeShortBE(buf, CRLF_SHORT); } else if (message instanceof HttpResponse) { HttpResponse response = (HttpResponse) message; buf.writeCharSequence(response.protocolVersion().toString(), CharsetUtil.US_ASCII); buf.writeByte(SP); ByteBufUtil.copy(response.status().codeAsText(), buf); buf.writeByte(SP); buf.writeCharSequence(response.status().reasonPhrase(), CharsetUtil.US_ASCII); ByteBufUtil.writeShortBE(buf, CRLF_SHORT); } else { throw new UnsupportedMessageTypeException("Unsupported type " + StringUtil.simpleClassName(message)); } } }
if (!HttpMethod.GET.equals(request.method())) { FullHttpResponse response = new DefaultFullHttpResponse( HttpVersion.HTTP_1_1, HttpResponseStatus.METHOD_NOT_ALLOWED, Unpooled.copiedBuffer("Only GET is supported", StandardCharsets.UTF_8)); HttpUtil.setContentLength(response, response.content().readableBytes()); response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain; charset=UTF-8"); writeAndClose(ctx.channel(), response); return; if (!PATH.equals(request.uri())) { response.headers().set(HttpHeaderNames.LOCATION, PATH); writeAndClose(ctx.channel(), response); return;
public FullHttpRequest toFullHttpRequest() { ByteBuf buffer = Unpooled.buffer(); MessageContent content = getContent(); if (content != null) { buffer.writeBytes(content.getContent()); } QueryStringEncoder encoder = new QueryStringEncoder(uri); for (Map.Entry<String, String[]> entry : queries.entrySet()) { String[] values = entry.getValue(); for (String value : values) { encoder.addParam(entry.getKey(), value); } } FullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.valueOf(getVersion().text()), io.netty.handler.codec.http.HttpMethod.valueOf(method.name()), encoder.toString(), buffer); for (Map.Entry<String, String[]> entry : getHeaders().entrySet()) { String key = entry.getKey(); for (String value : entry.getValue()) { request.headers().add(key, value); } } return request; }
final NettyHttpResponse response = new NettyHttpResponse(ctx, keepAlive, dispatcher.getProviderFactory(), request.method()); DecoderResult decoderResult = request.decoderResult(); if (decoderResult.isFailure()) NettyHttpRequest nettyRequest = new NettyHttpRequest(ctx, headers, uriInfo, request.method().name(), dispatcher, response, HttpUtil.is100ContinueExpected(request) ); if (request instanceof HttpContent) if(byteBuf.readableBytes() > 0) { ByteBuf buf = byteBuf.retain(); nettyRequest.setContentBuffer(buf);