@Override public HttpVersion protocolVersion() { return request.protocolVersion(); }
@Override public HttpVersion getProtocolVersion() { return request.protocolVersion(); }
@Override public HttpVersion getProtocolVersion() { return request.protocolVersion(); }
@Override public HttpVersion protocolVersion() { return request.protocolVersion(); }
@Override public void failure(Throwable error) { ctx.writeAndFlush(new DefaultFullHttpResponse(req.protocolVersion(), HttpResponseStatus.INTERNAL_SERVER_ERROR)) .addListener(ChannelFutureListener.CLOSE); }
@Override protected void bodyRequested(ChannelHandlerContext ctx) { if (continueExpected) { if (inFlight == 1) { ctx.writeAndFlush(new DefaultFullHttpResponse(lastRequest.protocolVersion(), HttpResponseStatus.CONTINUE)); continueExpected = false; } else { sendContinue = true; } } }
@Override protected void sentOutMessage(ChannelHandlerContext ctx) { inFlight--; if (inFlight == 1 && continueExpected && sendContinue) { ctx.writeAndFlush(new DefaultFullHttpResponse(lastRequest.protocolVersion(), HttpResponseStatus.CONTINUE)); sendContinue = false; continueExpected = false; } if (close) { ctx.close(); } }
@Override public String protocol() { return ctx.pipeline().get("h2") == null ? req.protocolVersion().text() : "HTTP/2.0"; }
private static void appendInitialLine(StringBuilder buf, HttpRequest req) { buf.append(req.method()); buf.append(' '); buf.append(req.uri()); buf.append(' '); buf.append(req.protocolVersion()); buf.append(StringUtil.NEWLINE); }
private static void forbidden(final ChannelHandlerContext ctx, final HttpRequest request) { HttpResponse response = new DefaultFullHttpResponse(request.protocolVersion(), FORBIDDEN); response.headers().set(HttpHeaderNames.CONTENT_LENGTH, HttpHeaderValues.ZERO); release(request); respond(ctx, request, response); }
@Override public Http.Version version() { return Http.Version.create(nettyRequest.protocolVersion().text()); }
@SuppressWarnings("unused") private HttpRequest copy(String uri, HttpRequest request) { HttpRequest nue = request; if (request instanceof DefaultFullHttpRequest) { DefaultFullHttpRequest dfr = (DefaultFullHttpRequest) request; FullHttpRequest rq; try { rq = dfr.copy(); } catch (IllegalReferenceCountException e) { // Empty byteBuf rq = dfr; } rq.setUri(uri); } else { DefaultHttpRequest dfr = new DefaultHttpRequest(request.protocolVersion(), request.method(), uri); dfr.headers().set(request.headers()); nue = dfr; } return nue; } }
private boolean handle100Continue(int id, HttpRequest nettyReq, HttpHeaders nettyHeaders) { if (nettyReq.protocolVersion().compareTo(HttpVersion.HTTP_1_1) < 0) { // Ignore HTTP/1.0 requests. return true; } final String expectValue = nettyHeaders.get(HttpHeaderNames.EXPECT); if (expectValue == null) { // No 'expect' header. return true; } // '100-continue' is the only allowed expectation. if (!Ascii.equalsIgnoreCase("100-continue", expectValue)) { return false; } // Send a '100 Continue' response. writer.writeHeaders(id, 1, CONTINUE_RESPONSE, false); // Remove the 'expect' header so that it's handled in a way invisible to a Service. nettyHeaders.remove(HttpHeaderNames.EXPECT); return true; }
@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 void handleError(HttpObject obj) { DecoderResult result = obj.decoderResult(); Throwable cause = result.cause(); if (cause instanceof TooLongFrameException) { String causeMsg = cause.getMessage(); HttpVersion version; if (obj instanceof HttpRequest) { version = ((HttpRequest) obj).protocolVersion(); } else if (requestInProgress != null) { version = requestInProgress.version() == io.vertx.core.http.HttpVersion.HTTP_1_0 ? HttpVersion.HTTP_1_0 : HttpVersion.HTTP_1_1; } else { version = HttpVersion.HTTP_1_1; } HttpResponseStatus status = causeMsg.startsWith("An HTTP line is larger than") ? HttpResponseStatus.REQUEST_URI_TOO_LONG : HttpResponseStatus.BAD_REQUEST; DefaultFullHttpResponse resp = new DefaultFullHttpResponse(version, status); ChannelPromise fut = chctx.newPromise(); writeToChannel(resp, fut); fut.addListener(res -> { fail(result.cause()); }); } else { fail(result.cause()); } }
private void handlePreflight(final ChannelHandlerContext ctx, final HttpRequest request) { final HttpResponse response = new DefaultFullHttpResponse(request.protocolVersion(), OK, true, true); if (setOrigin(response)) { setAllowMethods(response); setAllowHeaders(response); setAllowCredentials(response); setMaxAge(response); setPreflightHeaders(response); } if (!response.headers().contains(HttpHeaderNames.CONTENT_LENGTH)) { response.headers().set(HttpHeaderNames.CONTENT_LENGTH, HttpHeaderValues.ZERO); } release(request); respond(ctx, request, response); }
/** * Create a new object to contain the request data. * * @param streamId The stream associated with the request * @param http2Headers The initial set of HTTP/2 headers to create the request with * @param validateHttpHeaders <ul> * <li>{@code true} to validate HTTP headers in the http-codec</li> * <li>{@code false} not to validate HTTP headers in the http-codec</li> * </ul> * @return A new request object which represents headers for a chunked request * @throws Http2Exception see {@link #addHttp2ToHttpHeaders(int, Http2Headers, FullHttpMessage, boolean)} */ public static HttpRequest toHttpRequest(int streamId, Http2Headers http2Headers, boolean validateHttpHeaders) throws Http2Exception { // HTTP/2 does not define a way to carry the version identifier that is included in the HTTP/1.1 request line. final CharSequence method = checkNotNull(http2Headers.method(), "method header cannot be null in conversion to HTTP/1.x"); final CharSequence path = checkNotNull(http2Headers.path(), "path header cannot be null in conversion to HTTP/1.x"); HttpRequest msg = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.valueOf(method.toString()), path.toString(), validateHttpHeaders); try { addHttp2ToHttpHeaders(streamId, http2Headers, msg.headers(), msg.protocolVersion(), false, true); } catch (Http2Exception e) { throw e; } catch (Throwable t) { throw streamError(streamId, PROTOCOL_ERROR, t, "HTTP/2 to HTTP/1.x headers conversion error"); } return msg; }
this.protocol = nettyRequest.protocolVersion().text(); this.method = nettyRequest.method().name();
this.protocol = nettyRequest.protocolVersion().text(); this.method = nettyRequest.method().name();
@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)); } } }