Package io.vertx.mutiny.core.http

Class HttpServerRequest

  • All Implemented Interfaces:
    ReadStream<Buffer>, StreamBase
    public class HttpServerRequest
extends Object
implements ReadStream<Buffer>
    Represents a server-side HTTP request.

    Instances are created for each request and passed to the user via a handler.

    Each instance of this class is associated with a corresponding HttpServerResponse instance via response().

    It implements ReadStream so it can be used with Pipe to pipe data with flow control.

    NOTE: This class has been automatically generated from the original non Mutiny-ified interface using Vert.x codegen.

    • Constructor Detail

      • HttpServerRequest

        public HttpServerRequest​(io.vertx.core.http.HttpServerRequest delegate)

      • HttpServerRequest

        public HttpServerRequest​(Object delegate)

    • Method Detail

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • pipeTo

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> pipeTo​(WriteStream<Buffer> dst)
        Pipe this ReadStream to the WriteStream.

        Elements emitted by this stream will be written to the write stream until this stream ends or fails.

        Once this stream has ended or failed, the write stream will be ended and the handler will be called with the result.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Specified by:
        pipeTo in interface ReadStream<Buffer>
        Parameters:
        dst - the destination write stream
        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • version

        public io.vertx.core.http.HttpVersion version()
        Returns:
        the HTTP version of the request

      • method

        public io.vertx.core.http.HttpMethod method()
        Returns:
        the HTTP method for the request.

      • isSSL

        public boolean isSSL()
        Returns:
        true if this NetSocket is encrypted via SSL/TLS

      • scheme

        public String scheme()
        Returns:
        the scheme of the request

      • uri

        public String uri()
        Returns:
        the URI of the request. This is usually a relative URI

      • path

        public String path()
        Returns:
        The path part of the uri. For example /somepath/somemorepath/someresource.foo

      • query

        public String query()
        Returns:
        the query part of the uri. For example someparam=32&someotherparam=x

      • host

        public String host()
        Returns:
        the request host. For HTTP2 it returns the pseudo header otherwise it returns the header

      • bytesRead

        public long bytesRead()
        Returns:
        the total number of bytes read for the body of the request.

      • response

        public HttpServerResponse response()
        Returns:
        the response. Each instance of this class has an HttpServerResponse instance attached to it. This is used to send the response back to the client.

      • headers

        public MultiMap headers()
        Returns:
        the headers in the request.

      • getHeader

        public String getHeader​(String headerName)
        Parameters:
        headerName - the header name
        Returns:
        the header value

      • setParamsCharset

        public HttpServerRequest setParamsCharset​(String charset)
        Parameters:
        charset - the charset to use for decoding query params
        Returns:
        a reference to this, so the API can be used fluently

      • getParamsCharset

        public String getParamsCharset()
        Returns:
        the charset used for decoding query parameters

      • params

        public MultiMap params()
        Returns:
        the query parameters in the request

      • getParam

        public String getParam​(String paramName)
        Parameters:
        paramName - the param name
        Returns:
        the param value

      • getParam

        public String getParam​(String paramName,
                       String defaultValue)
        Parameters:
        paramName - the param name
        defaultValue - the default value, must be non-null
        Returns:
        the param value or defaultValue when not present

      • remoteAddress

        public SocketAddress remoteAddress()
        Returns:
        the remote address for this connection, possibly null (e.g a server bound on a domain socket). If useProxyProtocol is set to true, the address returned will be of the actual connecting client.

      • localAddress

        public SocketAddress localAddress()
        Returns:
        the local address for this connection, possibly null (e.g a server bound on a domain socket) If useProxyProtocol is set to true, the address returned will be of the proxy.

      • absoluteURI

        public String absoluteURI()
        Returns:
        the absolute URI corresponding to the HTTP request

      • bodyHandler

        public HttpServerRequest bodyHandler​(Consumer<Buffer> bodyHandler)
        Parameters:
        bodyHandler - This handler will be called after all the body has been received
        Returns:

      • body

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Buffer> body()
        Same as body() but with an handler called when the operation completes

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • bodyAndAwait

        public Buffer bodyAndAwait()
        Blocking variant of body().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Buffer instance produced by the operation.

      • bodyAndForget

        public void bodyAndForget()
        Variant of body() that ignores the result of the operation.

        This method subscribes on the result of body(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from body() but you don't need to compose it with other operations.

      • end

        @CheckReturnValue
public io.smallrye.mutiny.Uni<Void> end()
        Same as end() but with an handler called when the operation completes

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • endAndAwait

        public Void endAndAwait()
        Blocking variant of end().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the Void instance produced by the operation.

      • endAndForget

        public void endAndForget()
        Variant of end() that ignores the result of the operation.

        This method subscribes on the result of end(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from end() but you don't need to compose it with other operations.

      • toNetSocketAndAwait

        public NetSocket toNetSocketAndAwait()
        Blocking variant of toNetSocket().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the NetSocket instance produced by the operation.

      • toNetSocketAndForget

        public void toNetSocketAndForget()
        Variant of toNetSocket() that ignores the result of the operation.

        This method subscribes on the result of toNetSocket(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from toNetSocket() but you don't need to compose it with other operations.

      • setExpectMultipart

        public HttpServerRequest setExpectMultipart​(boolean expect)
        Parameters:
        expect - true - if you are expecting a multi-part body
        Returns:
        a reference to this, so the API can be used fluently

      • isExpectMultipart

        public boolean isExpectMultipart()
        Returns:
        true if we are expecting a multi-part body for this request. See setExpectMultipart(boolean).

      • formAttributes

        public MultiMap formAttributes()
        Returns:
        the form attributes

      • getFormAttribute

        public String getFormAttribute​(String attributeName)
        Parameters:
        attributeName - the attribute name
        Returns:
        the attribute value

      • streamId

        public int streamId()
        Returns:
        the id of the stream of this request, when it is not yet determined, i.e the request has not been yet sent or it is not supported HTTP/1.x

      • toWebSocket

        @CheckReturnValue
public io.smallrye.mutiny.Uni<ServerWebSocket> toWebSocket()
        Upgrade the connection of the current request to a WebSocket.

        This is an alternative way of handling WebSockets and can only be used if no WebSocket handler is set on the HttpServer, and can only be used during the upgrade request during the WebSocket handshake.

        Both handler(java.util.function.Consumer<io.vertx.mutiny.core.buffer.Buffer>) and endHandler(java.lang.Runnable) will be set to get the full body of the request that is necessary to perform the WebSocket handshake.

        If you need to do an asynchronous upgrade, i.e not performed immediately in your request handler, you need to pause() the request in order to not lose HTTP events necessary to upgrade the request.

        Unlike the bare Vert.x variant, this method returns a Uni. Don't forget to subscribe on it to trigger the operation.

        Returns:
        the uni firing the result of the operation when completed, or a failure if the operation failed.

      • toWebSocketAndAwait

        public ServerWebSocket toWebSocketAndAwait()
        Blocking variant of toWebSocket().

        This method waits for the completion of the underlying asynchronous operation. If the operation completes successfully, the result is returned, otherwise the failure is thrown (potentially wrapped in a RuntimeException).

        Returns:
        the ServerWebSocket instance produced by the operation.

      • toWebSocketAndForget

        public void toWebSocketAndForget()
        Variant of toWebSocket() that ignores the result of the operation.

        This method subscribes on the result of toWebSocket(), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from toWebSocket() but you don't need to compose it with other operations.

      • isEnded

        public boolean isEnded()
        Returns:
        true if ended

      • streamPriority

        public io.vertx.core.http.StreamPriority streamPriority()
        Returns:
        the priority of the associated HTTP/2 stream for HTTP/2 otherwise null

      • streamPriorityHandler

        public HttpServerRequest streamPriorityHandler​(Consumer<io.vertx.core.http.StreamPriority> handler)
        Parameters:
        handler - the handler to be called when stream priority changes
        Returns:

      • getCookie

        public Cookie getCookie​(String name)
        Parameters:
        name - the cookie name
        Returns:
        the cookie or null if not found.

      • getCookie

        public Cookie getCookie​(String name,
                        String domain,
                        String path)
        Parameters:
        name - the cookie name
        domain - the cookie domain
        path - the cookie path
        Returns:
        the cookie or null if not found.

      • cookieCount

        public int cookieCount()
        Returns:
        the number of cookies in the cookie jar.

      • cookieMap

        @Deprecated
public Map<String,​Cookie> cookieMap()
        Deprecated.
        the implementation made a wrong assumption that cookies could be identified only by their name. The RFC states that the tuple of <name, domain, path> is the unique identifier. When more than one cookie has the same name, the map will hold that lost one to be parsed and any previously parsed value will be silently overwritten.
        Returns:
        a map of all the cookies.

      • cookies

        public Set<Cookie> cookies​(String name)
        Parameters:
        name - the name to be matches
        Returns:
        the matching cookies or empty set

      • cookies

        public Set<Cookie> cookies()
        Returns:
        a set with all cookies in the cookie jar.

      • routed

        public HttpServerRequest routed​(String route)
        Parameters:
        route - The route this request has been routed to.
        Returns:
        the instance of HttpServerRequest to chain method calls.

      • getHeader

        public String getHeader​(CharSequence headerName)
        Parameters:
        headerName - the header name
        Returns:
        the header value

      • sslSession

        public SSLSession sslSession()
        Returns:
        SSLSession associated with the underlying socket. Returns null if connection is not SSL.

      • toBlockingStream

        public Stream<Buffer> toBlockingStream()

      • newInstance

        public static HttpServerRequest newInstance​(io.vertx.core.http.HttpServerRequest arg)