Package io.vertx.mutiny.core.http

Class HttpServerRequest

java.lang.Object
io.vertx.mutiny.core.http.HttpServerRequest
All Implemented Interfaces:
MutinyDelegate, ReadStream<Buffer>, StreamBase
public class HttpServerRequest extends Object implements MutinyDelegate, 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.

  • Field Details

  • Constructor Details

    • HttpServerRequest

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

    • HttpServerRequest

      public HttpServerRequest(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.http.HttpServerRequest getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Specified by:
      getDelegate in interface ReadStream<Buffer>
      Specified by:
      getDelegate in interface StreamBase
      Returns:
      the delegate used by this Mutiny object of generated type

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • equals

      public boolean equals(Object o)
      Overrides:
      equals in class Object

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • pipe

      public Pipe<Buffer> pipe()
      Specified by:
      pipe in interface ReadStream<Buffer>
      Returns:
      a pipe

    • 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.

    • pipeToAndAwait

      public Void pipeToAndAwait(WriteStream<Buffer> dst)
      Blocking variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream).

      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).

      Specified by:
      pipeToAndAwait in interface ReadStream<Buffer>
      Parameters:
      dst - the destination write stream
      Returns:
      the Void instance produced by the operation.

    • pipeToAndForget

      public void pipeToAndForget(WriteStream<Buffer> dst)
      Variant of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) that ignores the result of the operation.

      This method subscribes on the result of ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream), but discards the outcome (item or failure). This method is useful to trigger the asynchronous operation from ReadStream.pipeTo(io.vertx.mutiny.core.streams.WriteStream) but you don't need to compose it with other operations.

      Specified by:
      pipeToAndForget in interface ReadStream<Buffer>
      Parameters:
      dst - the destination write stream

    • exceptionHandler

      public HttpServerRequest exceptionHandler(Consumer<Throwable> handler)
      Specified by:
      exceptionHandler in interface ReadStream<Buffer>
      Specified by:
      exceptionHandler in interface StreamBase
      Parameters:
      handler - the exception handler
      Returns:

    • handler

      public HttpServerRequest handler(Consumer<Buffer> handler)
      Specified by:
      handler in interface ReadStream<Buffer>
      Returns:

    • pause

      public HttpServerRequest pause()
      Specified by:
      pause in interface ReadStream<Buffer>
      Returns:
      a reference to this, so the API can be used fluently

    • resume

      public HttpServerRequest resume()
      Specified by:
      resume in interface ReadStream<Buffer>
      Returns:
      a reference to this, so the API can be used fluently

    • fetch

      public HttpServerRequest fetch(long amount)
      Specified by:
      fetch in interface ReadStream<Buffer>
      Returns:
      a reference to this, so the API can be used fluently

    • endHandler

      public HttpServerRequest endHandler(Runnable endHandler)
      Specified by:
      endHandler in interface ReadStream<Buffer>
      Returns:

    • 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

    • authority

      public HostAndPort authority()
      Returns:
      the request authority. For HTTP/2 the pseudo header is returned, for HTTP/1.x the header is returned or null when no such header is present. When the authority string does not carry a port, the returns -1 to indicate the scheme port is prevalent.

    • host

      @Deprecated public String host()
      Deprecated.
      instead use authority()
      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

    • params

      public MultiMap params(boolean semicolonIsNormalChar)
      Parameters:
      semicolonIsNormalChar - whether semicolon is treated as a normal character or a query parameter separator
      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.

    • toNetSocket

      @CheckReturnValue public io.smallrye.mutiny.Uni<NetSocket> toNetSocket()
      Establish a TCP tunnel with the client.

      This must be called only for CONNECT HTTP method or for HTTP connection upgrade, before any response is sent.

      Calling this sends a 200 response for a CONNECT or a 101 for a connection upgrade wit no content-length header set and then provides the NetSocket for handling the created tunnel. Any HTTP header set on the response before calling this method will be sent. 

       server.requestHandler(req -> {
   if (req.method() == HttpMethod.CONNECT) {
     // Send a 200 response to accept the connect
     NetSocket socket = req.netSocket();
     socket.handler(buff -> {
       socket.write(buff);
     });
   }
   ...
 });

      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.

    • 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).

    • uploadHandler

      public HttpServerRequest uploadHandler(Consumer<HttpServerFileUpload> uploadHandler)
      Parameters:
      uploadHandler -
      Returns:

    • 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

    • customFrameHandler

      public HttpServerRequest customFrameHandler(Consumer<HttpFrame> handler)
      Parameters:
      handler -
      Returns:

    • connection

      public HttpConnection connection()
      Returns:
      the HttpConnection associated with this request

    • 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.

    • toMulti

      @CheckReturnValue public io.smallrye.mutiny.Multi<Buffer> toMulti()
      Specified by:
      toMulti in interface ReadStream<Buffer>

    • toBlockingIterable

      public Iterable<Buffer> toBlockingIterable()

    • toBlockingStream

      public Stream<Buffer> toBlockingStream()

    • newInstance

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