Package io.vertx.mutiny.core.http

Class HttpServerResponse

java.lang.Object
io.vertx.mutiny.core.http.HttpServerResponse
All Implemented Interfaces:
MutinyDelegate, StreamBase, WriteStream<io.vertx.core.buffer.Buffer>
public class HttpServerResponse extends Object implements WriteStream<io.vertx.core.buffer.Buffer>, MutinyDelegate
Represents a server-side HTTP response.

An instance of this is created and associated to every instance of HttpServerRequest that.

It allows the developer to control the HTTP response that is sent back to the client for a particular HTTP request.

It contains methods that allow HTTP headers and trailers to be set, and for a body to be written out to the response.

It also allows files to be streamed by the kernel directly from disk to the outgoing HTTP connection, bypassing user space altogether (where supported by the underlying operating system). This is a very efficient way of serving files from the server since buffers do not have to be read one by one from the file and written to the outgoing socket. If the developer wants to use directly a FileChannel and manage its lifecycle use sendFile(FileChannel). This is not yet supported in HTTP/2 for HttpServerResponseImpl.

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

Any response should end with a terminal action, which are end() or sendFile(String) for successful completion of the request, or reset() for erroneous completion of the request, so you can only call one of the three methods as the last step in dealing with your response, but you must call one of the three methods.

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

Author:
Tim Fox
See Also:
  • HttpServerResponse

  • Field Details

  • Constructor Details

    • HttpServerResponse

      public HttpServerResponse(io.vertx.core.http.HttpServerResponse delegate)
      Create a new instance of HttpServerResponse delegating to the given (non-null) instance of HttpServerResponse.

    • HttpServerResponse

      public HttpServerResponse(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.http.HttpServerResponse getDelegate()
      Get the delegate instance.

      This method returns the instance on which this shim is delegating the calls. And so, give you access to the bare API.

      Specified by:
      getDelegate in interface MutinyDelegate
      Specified by:
      getDelegate in interface StreamBase
      Specified by:
      getDelegate in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      the delegate instance

    • writeHead

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeHead()
      Send the response headers.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.writeHead()

    • writeHeadAndAwait

      public void writeHeadAndAwait()
      Send the response headers.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.writeHead()

    • writeHeadAndForget

      public HttpServerResponse writeHeadAndForget()
      Send the response headers.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.writeHead()

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String chunk, String enc)
      Write a String to the response body, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the string to write
      enc - the encoding to use
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.write(String, String)

    • writeAndAwait

      public void writeAndAwait(String chunk, String enc)
      Write a String to the response body, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      chunk - the string to write
      enc - the encoding to use
      See Also:
      • HttpServerResponse.write(String, String)

    • writeAndForget

      public HttpServerResponse writeAndForget(String chunk, String enc)
      Write a String to the response body, encoded using the encoding enc.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the string to write
      enc - the encoding to use
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.write(String, String)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String chunk)
      Write a String to the response body, encoded in UTF-8.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the string to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.write(String)

    • writeAndAwait

      public void writeAndAwait(String chunk)
      Write a String to the response body, encoded in UTF-8.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      chunk - the string to write
      See Also:
      • HttpServerResponse.write(String)

    • writeAndForget

      public HttpServerResponse writeAndForget(String chunk)
      Write a String to the response body, encoded in UTF-8.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the string to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.write(String)

    • writeContinue

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeContinue()
      Used to write an interim 100 Continue response to signify that the client should send the rest of the request. Must only be used if the request contains an "Expect:100-Continue" header

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.writeContinue()

    • writeContinueAndAwait

      public void writeContinueAndAwait()
      Used to write an interim 100 Continue response to signify that the client should send the rest of the request. Must only be used if the request contains an "Expect:100-Continue" header

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.writeContinue()

    • writeContinueAndForget

      public HttpServerResponse writeContinueAndForget()
      Used to write an interim 100 Continue response to signify that the client should send the rest of the request. Must only be used if the request contains an "Expect:100-Continue" header

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.writeContinue()

    • writeEarlyHints

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeEarlyHints(io.vertx.core.MultiMap headers)
      Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      headers - headers to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.writeEarlyHints(MultiMap)

    • writeEarlyHintsAndAwait

      public void writeEarlyHintsAndAwait(io.vertx.core.MultiMap headers)
      Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      headers - headers to write
      See Also:
      • HttpServerResponse.writeEarlyHints(MultiMap)

    • writeEarlyHintsAndForget

      public HttpServerResponse writeEarlyHintsAndForget(io.vertx.core.MultiMap headers)
      Used to write an interim 103 Early Hints response to return some HTTP headers before the final HTTP message.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      headers - headers to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.writeEarlyHints(MultiMap)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(String chunk)
      Same as end(Buffer) but writes a String in UTF-8 encoding before ending the response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the string to write before ending the response
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.end(String)

    • endAndAwait

      public void endAndAwait(String chunk)
      Same as end(Buffer) but writes a String in UTF-8 encoding before ending the response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      chunk - the string to write before ending the response
      See Also:
      • HttpServerResponse.end(String)

    • endAndForget

      public HttpServerResponse endAndForget(String chunk)
      Same as end(Buffer) but writes a String in UTF-8 encoding before ending the response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the string to write before ending the response
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.end(String)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(String chunk, String enc)
      Same as end(Buffer) but writes a String with the specified encoding before ending the response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      chunk - the string to write before ending the response
      enc - the encoding to use
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.end(String, String)

    • endAndAwait

      public void endAndAwait(String chunk, String enc)
      Same as end(Buffer) but writes a String with the specified encoding before ending the response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      chunk - the string to write before ending the response
      enc - the encoding to use
      See Also:
      • HttpServerResponse.end(String, String)

    • endAndForget

      public HttpServerResponse endAndForget(String chunk, String enc)
      Same as end(Buffer) but writes a String with the specified encoding before ending the response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the string to write before ending the response
      enc - the encoding to use
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.end(String, String)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(io.vertx.core.buffer.Buffer chunk)
      Same as end() but writes some data to the response body before ending. If the response is not chunked and no other data has been written then the @code{Content-Length} header will be automatically set.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      end in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      chunk - the buffer to write before ending the response
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.end(Buffer)

    • endAndAwait

      public void endAndAwait(io.vertx.core.buffer.Buffer chunk)
      Same as end() but writes some data to the response body before ending. If the response is not chunked and no other data has been written then the @code{Content-Length} header will be automatically set.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      chunk - the buffer to write before ending the response
      See Also:
      • HttpServerResponse.end(Buffer)

    • endAndForget

      public HttpServerResponse endAndForget(io.vertx.core.buffer.Buffer chunk)
      Same as end() but writes some data to the response body before ending. If the response is not chunked and no other data has been written then the @code{Content-Length} header will be automatically set.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      chunk - the buffer to write before ending the response
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.end(Buffer)

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end()
      Ends the response. If no data has been written to the response body, the actual response won't get written until this method gets called.

      Once the response has ended, it cannot be used any more.

      This is a terminal action, like sendFile(String) and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      end in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.end()

    • endAndAwait

      public void endAndAwait()
      Ends the response. If no data has been written to the response body, the actual response won't get written until this method gets called.

      Once the response has ended, it cannot be used any more.

      This is a terminal action, like sendFile(String) and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.end()

    • endAndForget

      public HttpServerResponse endAndForget()
      Ends the response. If no data has been written to the response body, the actual response won't get written until this method gets called.

      Once the response has ended, it cannot be used any more.

      This is a terminal action, like sendFile(String) and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.end()

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> send()
      Send the request with an empty body.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.send()

    • sendAndAwait

      public void sendAndAwait()
      Send the request with an empty body.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.send()

    • sendAndForget

      public HttpServerResponse sendAndForget()
      Send the request with an empty body.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.send()

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> send(String body)
      Send the request with a string body.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.send(String)

    • sendAndAwait

      public void sendAndAwait(String body)
      Send the request with a string body.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.send(String)

    • sendAndForget

      public HttpServerResponse sendAndForget(String body)
      Send the request with a string body.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.send(String)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> send(io.vertx.core.buffer.Buffer body)
      Send the request with a buffer body.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.send(Buffer)

    • sendAndAwait

      public void sendAndAwait(io.vertx.core.buffer.Buffer body)
      Send the request with a buffer body.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.send(Buffer)

    • sendAndForget

      public HttpServerResponse sendAndForget(io.vertx.core.buffer.Buffer body)
      Send the request with a buffer body.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.send(Buffer)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> send(ReadStream<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.http.HttpServerResponse#send(ReadStream)

    • sendAndAwait

      public void sendAndAwait(ReadStream<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • io.vertx.core.http.HttpServerResponse#send(ReadStream)

    • sendAndForget

      public HttpServerResponse sendAndForget(ReadStream<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.http.HttpServerResponse#send(ReadStream)

    • send

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> send(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • io.vertx.core.http.HttpServerResponse#send(ReadStream)

    • sendAndAwait

      public void sendAndAwait(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • io.vertx.core.http.HttpServerResponse#send(ReadStream)

    • sendAndForget

      public HttpServerResponse sendAndForget(Flow.Publisher<io.vertx.core.buffer.Buffer> body)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • io.vertx.core.http.HttpServerResponse#send(ReadStream)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(String filename)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(String)

    • sendFileAndAwait

      public void sendFileAndAwait(String filename)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:
      • HttpServerResponse.sendFile(String)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(String filename)
      Send the request with a stream body.

      If the HttpHeaders.CONTENT_LENGTH is set then the request assumes this is the length of the {stream}, otherwise the request will set a chunked HttpHeaders.CONTENT_ENCODING.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(String)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(String filename, long offset)
      Same as sendFile(String, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      filename - path to the file to serve
      offset - offset to start serving from
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(String, long)

    • sendFileAndAwait

      public void sendFileAndAwait(String filename, long offset)
      Same as sendFile(String, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      filename - path to the file to serve
      offset - offset to start serving from
      See Also:
      • HttpServerResponse.sendFile(String, long)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(String filename, long offset)
      Same as sendFile(String, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      filename - path to the file to serve
      offset - offset to start serving from
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(String, long)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(String filename, long offset, long length)
      Ask the OS to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to serve files.

      The actual serve is asynchronous and may not complete until some time after this method has returned.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      filename - path to the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(String, long, long)

    • sendFileAndAwait

      public void sendFileAndAwait(String filename, long offset, long length)
      Ask the OS to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to serve files.

      The actual serve is asynchronous and may not complete until some time after this method has returned.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      filename - path to the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      See Also:
      • HttpServerResponse.sendFile(String, long, long)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(String filename, long offset, long length)
      Ask the OS to stream a file as specified by filename directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system. This is a very efficient way to serve files.

      The actual serve is asynchronous and may not complete until some time after this method has returned.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      filename - path to the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(String, long, long)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(FileChannel channel)
      Same as sendFile(FileChannel, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      channel - the file channel to the file to serve
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(FileChannel)

    • sendFileAndAwait

      public void sendFileAndAwait(FileChannel channel)
      Same as sendFile(FileChannel, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      channel - the file channel to the file to serve
      See Also:
      • HttpServerResponse.sendFile(FileChannel)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(FileChannel channel)
      Same as sendFile(FileChannel, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      channel - the file channel to the file to serve
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(FileChannel)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(FileChannel channel, long offset)
      Same as sendFile(FileChannel, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      channel - the file channel to the file to serve
      offset - offset to start serving from
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(FileChannel, long)

    • sendFileAndAwait

      public void sendFileAndAwait(FileChannel channel, long offset)
      Same as sendFile(FileChannel, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      channel - the file channel to the file to serve
      offset - offset to start serving from
      See Also:
      • HttpServerResponse.sendFile(FileChannel, long)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(FileChannel channel, long offset)
      Same as sendFile(FileChannel, long, long) using length @code{Long.MAX_VALUE} which means until the end of the file.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      channel - the file channel to the file to serve
      offset - offset to start serving from
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(FileChannel, long)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(FileChannel channel, long offset, long length)
      Ask the OS to stream a file as specified by channel directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system). Contrary to sendFile(String, long, long), the caller is responsible to close channel when no more needed. This is a very efficient way to serve files.

      The actual serve is asynchronous and may not complete until some time after this method has returned. The developer is responsible to set the adequate Content-Type with putHeader(String, String). If not application/octet-stream will be set as default Content-Type.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      channel - the file channel to the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(FileChannel, long, long)

    • sendFileAndAwait

      public void sendFileAndAwait(FileChannel channel, long offset, long length)
      Ask the OS to stream a file as specified by channel directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system). Contrary to sendFile(String, long, long), the caller is responsible to close channel when no more needed. This is a very efficient way to serve files.

      The actual serve is asynchronous and may not complete until some time after this method has returned. The developer is responsible to set the adequate Content-Type with putHeader(String, String). If not application/octet-stream will be set as default Content-Type.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      channel - the file channel to the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      See Also:
      • HttpServerResponse.sendFile(FileChannel, long, long)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(FileChannel channel, long offset, long length)
      Ask the OS to stream a file as specified by channel directly from disk to the outgoing connection, bypassing userspace altogether (where supported by the underlying operating system). Contrary to sendFile(String, long, long), the caller is responsible to close channel when no more needed. This is a very efficient way to serve files.

      The actual serve is asynchronous and may not complete until some time after this method has returned. The developer is responsible to set the adequate Content-Type with putHeader(String, String). If not application/octet-stream will be set as default Content-Type.

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      channel - the file channel to the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(FileChannel, long, long)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(RandomAccessFile file)
      Same as sendFile(FileChannel) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      file - the file to serve
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile)

    • sendFileAndAwait

      public void sendFileAndAwait(RandomAccessFile file)
      Same as sendFile(FileChannel) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      file - the file to serve
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(RandomAccessFile file)
      Same as sendFile(FileChannel) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      file - the file to serve
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(RandomAccessFile file, long offset)
      Same as sendFile(FileChannel, long) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      file - the file to serve
      offset - offset to start serving from
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile, long)

    • sendFileAndAwait

      public void sendFileAndAwait(RandomAccessFile file, long offset)
      Same as sendFile(FileChannel, long) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      file - the file to serve
      offset - offset to start serving from
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile, long)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(RandomAccessFile file, long offset)
      Same as sendFile(FileChannel, long) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      file - the file to serve
      offset - offset to start serving from
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile, long)

    • sendFile

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendFile(RandomAccessFile file, long offset, long length)
      Same as sendFile(FileChannel, long, long) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      file - the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile, long, long)

    • sendFileAndAwait

      public void sendFileAndAwait(RandomAccessFile file, long offset, long length)
      Same as sendFile(FileChannel, long, long) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      file - the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile, long, long)

    • sendFileAndForget

      public HttpServerResponse sendFileAndForget(RandomAccessFile file, long offset, long length)
      Same as sendFile(FileChannel, long, long) with RandomAccessFile

      This is a terminal action, like end() and reset(), so you can only call one of the three methods as the last step in dealing with your response.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      file - the file to serve
      offset - offset to start serving from
      length - the number of bytes to send
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.sendFile(RandomAccessFile, long, long)

    • push

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method, io.vertx.core.net.HostAndPort authority, String path)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with no headers.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.push(HttpMethod, HostAndPort, String)

    • pushAndAwait

      public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method, io.vertx.core.net.HostAndPort authority, String path)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with no headers.

      Unlike the bare Vert.x variant, this method returns a HttpServerResponse. This method awaits indefinitely 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 operation result
      See Also:
      • HttpServerResponse.push(HttpMethod, HostAndPort, String)

    • pushAndForget

      public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method, io.vertx.core.net.HostAndPort authority, String path)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with no headers.

      Unlike the bare Vert.x variant, this method ignores the HttpServerResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.push(HttpMethod, HostAndPort, String)

    • push

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method, String path, io.vertx.core.MultiMap headers)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.push(HttpMethod, String, MultiMap)

    • pushAndAwait

      public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method, String path, io.vertx.core.MultiMap headers)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.

      Unlike the bare Vert.x variant, this method returns a HttpServerResponse. This method awaits indefinitely 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 operation result
      See Also:
      • HttpServerResponse.push(HttpMethod, String, MultiMap)

    • pushAndForget

      public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method, String path, io.vertx.core.MultiMap headers)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.

      Unlike the bare Vert.x variant, this method ignores the HttpServerResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.push(HttpMethod, String, MultiMap)

    • push

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method, String path)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.push(HttpMethod, String)

    • pushAndAwait

      public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method, String path)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.

      Unlike the bare Vert.x variant, this method returns a HttpServerResponse. This method awaits indefinitely 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 operation result
      See Also:
      • HttpServerResponse.push(HttpMethod, String)

    • pushAndForget

      public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method, String path)
      Like push(HttpMethod, HostAndPort, String, MultiMap) with the host copied from the current request.

      Unlike the bare Vert.x variant, this method ignores the HttpServerResponse result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.push(HttpMethod, String)

    • push

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServerResponse> push(io.vertx.core.http.HttpMethod method, io.vertx.core.net.HostAndPort authority, String path, io.vertx.core.MultiMap headers)
      Push a response to the client.

      The handler will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent.

      The handler may be queued if the client has reduced the maximum number of streams the server can push concurrently.

      Push can be sent only for peer initiated streams and if the response is not ended.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      method - the method of the promised request
      authority - the authority of the promised request
      path - the path of the promised request
      headers - the headers of the promised request
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap)

    • pushAndAwait

      public HttpServerResponse pushAndAwait(io.vertx.core.http.HttpMethod method, io.vertx.core.net.HostAndPort authority, String path, io.vertx.core.MultiMap headers)
      Push a response to the client.

      The handler will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent.

      The handler may be queued if the client has reduced the maximum number of streams the server can push concurrently.

      Push can be sent only for peer initiated streams and if the response is not ended.

      Unlike the bare Vert.x variant, this method returns a HttpServerResponse. This method awaits indefinitely 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).

      Parameters:
      method - the method of the promised request
      authority - the authority of the promised request
      path - the path of the promised request
      headers - the headers of the promised request
      Returns:
      The operation result
      See Also:
      • HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap)

    • pushAndForget

      public HttpServerResponse pushAndForget(io.vertx.core.http.HttpMethod method, io.vertx.core.net.HostAndPort authority, String path, io.vertx.core.MultiMap headers)
      Push a response to the client.

      The handler will be notified with a success when the push can be sent and with a failure when the client has disabled push or reset the push before it has been sent.

      The handler may be queued if the client has reduced the maximum number of streams the server can push concurrently.

      Push can be sent only for peer initiated streams and if the response is not ended.

      Unlike the bare Vert.x variant, this method ignores the HttpServerResponse result or any failure.

      Parameters:
      method - the method of the promised request
      authority - the authority of the promised request
      path - the path of the promised request
      headers - the headers of the promised request
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.push(HttpMethod, HostAndPort, String, MultiMap)

    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> reset()
      Equivalent to calling reset(long) with 0.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:

    • resetAndAwait

      public void resetAndAwait()
      Equivalent to calling reset(long) with 0.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      See Also:

    • resetAndForget

      public HttpServerResponse resetAndForget()
      Equivalent to calling reset(long) with 0.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:

    • reset

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> reset(long code)
      Reset this response:

      • for HTTP/2, send an HTTP/2 reset frame with the specified error code
      • for HTTP/1.x, close the connection when the current response has not yet been sent

      When the response has already been sent nothing happens and false is returned as indicator.

      This is a terminal action, like end() and sendFile(String), so you can only call one of the three methods as the last step in dealing with your response.

      Stream reset should be avoided because the implementation works partially for HTTP/3 and reset error codes depends on the version of the protocol, cancel() should be used instead.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      code - the error code
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.reset(long)

    • resetAndAwait

      public void resetAndAwait(long code)
      Reset this response:

      • for HTTP/2, send an HTTP/2 reset frame with the specified error code
      • for HTTP/1.x, close the connection when the current response has not yet been sent

      When the response has already been sent nothing happens and false is returned as indicator.

      This is a terminal action, like end() and sendFile(String), so you can only call one of the three methods as the last step in dealing with your response.

      Stream reset should be avoided because the implementation works partially for HTTP/3 and reset error codes depends on the version of the protocol, cancel() should be used instead.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      code - the error code
      See Also:
      • HttpServerResponse.reset(long)

    • resetAndForget

      public HttpServerResponse resetAndForget(long code)
      Reset this response:

      • for HTTP/2, send an HTTP/2 reset frame with the specified error code
      • for HTTP/1.x, close the connection when the current response has not yet been sent

      When the response has already been sent nothing happens and false is returned as indicator.

      This is a terminal action, like end() and sendFile(String), so you can only call one of the three methods as the last step in dealing with your response.

      Stream reset should be avoided because the implementation works partially for HTTP/3 and reset error codes depends on the version of the protocol, cancel() should be used instead.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      code - the error code
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.reset(long)

    • cancel

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> cancel()
      Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the error 0x08
      • for HTTP/3, this resets or abort reading the underlying QUIC stream with code 0x10c

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.cancel()

    • cancelAndAwait

      public Boolean cancelAndAwait()
      Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the error 0x08
      • for HTTP/3, this resets or abort reading the underlying QUIC stream with code 0x10c

      Unlike the bare Vert.x variant, this method returns a Boolean. This method awaits indefinitely 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 operation result
      See Also:
      • HttpServerResponse.cancel()

    • cancelAndForget

      public HttpServerResponse cancelAndForget()
      Attempt to cancel the request according to the semantics of the underlying HTTP implementation.
      • for HTTP/1.x, this closes the connection when the current request is inflight
      • for HTTP/2, this performs send an HTTP/2 reset frame with the error 0x08
      • for HTTP/3, this resets or abort reading the underlying QUIC stream with code 0x10c

      Unlike the bare Vert.x variant, this method ignores the Boolean result or any failure.

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.cancel()

    • writeCustomFrame

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeCustomFrame(int type, int flags, io.vertx.core.buffer.Buffer payload)
      Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.

      The frame is sent immediatly and is not subject to flow control.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.writeCustomFrame(int, int, Buffer)

    • writeCustomFrameAndAwait

      public void writeCustomFrameAndAwait(int type, int flags, io.vertx.core.buffer.Buffer payload)
      Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.

      The frame is sent immediatly and is not subject to flow control.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      See Also:
      • HttpServerResponse.writeCustomFrame(int, int, Buffer)

    • writeCustomFrameAndForget

      public HttpServerResponse writeCustomFrameAndForget(int type, int flags, io.vertx.core.buffer.Buffer payload)
      Write an HTTP/2 frame to the response, allowing to extend the HTTP/2 protocol.

      The frame is sent immediatly and is not subject to flow control.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.writeCustomFrame(int, int, Buffer)

    • writeCustomFrame

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeCustomFrame(io.vertx.core.http.HttpFrame frame)
      Like writeCustomFrame(int, int, Buffer) but with an HttpFrame.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      frame - the frame to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.writeCustomFrame(HttpFrame)

    • writeCustomFrameAndAwait

      public void writeCustomFrameAndAwait(io.vertx.core.http.HttpFrame frame)
      Like writeCustomFrame(int, int, Buffer) but with an HttpFrame.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      frame - the frame to write
      See Also:
      • HttpServerResponse.writeCustomFrame(HttpFrame)

    • writeCustomFrameAndForget

      public HttpServerResponse writeCustomFrameAndForget(io.vertx.core.http.HttpFrame frame)
      Like writeCustomFrame(int, int, Buffer) but with an HttpFrame.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      frame - the frame to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.writeCustomFrame(HttpFrame)

    • writeAltSvc

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> writeAltSvc(String advertisement)

      Write an <a href="https://datatracker.ietf.org/doc/html/rfc7838"HTTP Alternative Services advertisement for the given request and its authority, according to the underlying protocol.

      For HTTP/1.x this sets an HttpHeaders.ALT_SVC header, otherwise it writes a custom frame.

      Example usage: response.writeAltSvc("h3=\":443\"")

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Parameters:
      advertisement - the advertisement
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.writeAltSvc(String)

    • writeAltSvcAndAwait

      public void writeAltSvcAndAwait(String advertisement)

      Write an <a href="https://datatracker.ietf.org/doc/html/rfc7838"HTTP Alternative Services advertisement for the given request and its authority, according to the underlying protocol.

      For HTTP/1.x this sets an HttpHeaders.ALT_SVC header, otherwise it writes a custom frame.

      Example usage: response.writeAltSvc("h3=\":443\"")

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      advertisement - the advertisement
      See Also:
      • HttpServerResponse.writeAltSvc(String)

    • writeAltSvcAndForget

      public HttpServerResponse writeAltSvcAndForget(String advertisement)

      Write an <a href="https://datatracker.ietf.org/doc/html/rfc7838"HTTP Alternative Services advertisement for the given request and its authority, according to the underlying protocol.

      For HTTP/1.x this sets an HttpHeaders.ALT_SVC header, otherwise it writes a custom frame.

      Example usage: response.writeAltSvc("h3=\":443\"")

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      advertisement - the advertisement
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.writeAltSvc(String)

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method returns a Uni. The uni emits the result of the operation as item. If the operation fails, the uni emits the failure.

      Don't forget to subscribe on it to trigger the operation.

      Specified by:
      write in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      data - the data to write
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • HttpServerResponse.write(T)

    • writeAndAwait

      public void writeAndAwait(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the underlying uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method returns a Void. This method awaits indefinitely 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).

      Parameters:
      data - the data to write
      See Also:
      • HttpServerResponse.write(T)

    • writeAndForget

      public HttpServerResponse writeAndForget(io.vertx.core.buffer.Buffer arg0)
      Write some data to the stream.

      The data is usually put on an internal write queue, and the write actually happens asynchronously. To avoid running out of memory by putting too much on the write queue, check the writeQueueFull() method before writing. This is done automatically if using a Pipe.

      When the data is moved from the queue to the actual medium, the returned Future will be completed with the write result, e.g the underlying uni is succeeded when a server HTTP response buffer is written to the socket and failed if the remote client has closed the socket while the data was still pending for write.

      Unlike the bare Vert.x variant, this method ignores the Void result or any failure.

      Parameters:
      data - the data to write
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • HttpServerResponse.write(T)

    • exceptionHandler

      public HttpServerResponse exceptionHandler(Consumer<Throwable> handler)
      Description copied from interface: WriteStream
      Set an exception handler on the write stream.
      Specified by:
      exceptionHandler in interface StreamBase
      Specified by:
      exceptionHandler in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      handler - the exception handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • setWriteQueueMaxSize

      public HttpServerResponse setWriteQueueMaxSize(int maxSize)
      Description copied from interface: WriteStream
      Set the maximum size of the write queue to maxSize. You will still be able to write to the stream even if there is more than maxSize items in the write queue. This is used as an indicator by classes such as Pipe to provide flow control.

      The value is defined by the implementation of the stream, e.g in bytes for a NetSocket, etc...

      Specified by:
      setWriteQueueMaxSize in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      maxSize - the max size of the write stream
      Returns:
      a reference to this, so the API can be used fluently

    • drainHandler

      public HttpServerResponse drainHandler(Runnable handler)
      Description copied from interface: WriteStream
      Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write queue is ready to accept buffers again. See Pipe for an example of this being used.

      The stream implementation defines when the drain handler, for example it could be when the queue size has been reduced to maxSize / 2.

      Specified by:
      drainHandler in interface WriteStream<io.vertx.core.buffer.Buffer>
      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • getStatusCode

      public int getStatusCode()
      Returns:
      the HTTP status code of the response. The default is 200 representing OK.

    • setStatusCode

      public HttpServerResponse setStatusCode(int statusCode)
      Set the status code. If the status message hasn't been explicitly set, a default status message corresponding to the code will be looked-up and used.
      Returns:
      a reference to this, so the API can be used fluently

    • getStatusMessage

      public String getStatusMessage()
      Returns:
      the HTTP status message of the response. If this is not specified a default value will be used depending on what setStatusCode(int) has been set to.

    • setStatusMessage

      public HttpServerResponse setStatusMessage(String statusMessage)
      Set the status message
      Returns:
      a reference to this, so the API can be used fluently

    • setChunked

      public HttpServerResponse setChunked(boolean chunked)
      If chunked is true, this response will use HTTP chunked encoding, and each call to write to the body will correspond to a new HTTP chunk sent on the wire.

      If chunked encoding is used the HTTP header Transfer-Encoding with a value of Chunked will be automatically inserted in the response.

      If chunked is false, this response will not use HTTP chunked encoding, and therefore the total size of any data that is written in the respone body must be set in the Content-Length header before any data is written out.

      An HTTP chunked response is typically used when you do not know the total size of the request body up front.

      Returns:
      a reference to this, so the API can be used fluently

    • isChunked

      public boolean isChunked()
      Returns:
      is the response chunked?

    • headers

      public io.vertx.core.MultiMap headers()
      Returns:
      The HTTP headers

    • putHeader

      public HttpServerResponse putHeader(String name, String value)
      Put an HTTP header
      Parameters:
      name - the header name
      value - the header value.
      Returns:
      a reference to this, so the API can be used fluently

    • putHeader

      public HttpServerResponse putHeader(CharSequence name, CharSequence value)
      Like putHeader(String, String) but using CharSequence

    • putHeader

      public HttpServerResponse putHeader(String name, Iterable<String> values)
      Like putHeader(String, String) but providing multiple values via a String Iterable

    • putHeader

      public HttpServerResponse putHeader(CharSequence name, Iterable<CharSequence> values)
      Like putHeader(String, Iterable) but with CharSequence Iterable

    • trailers

      public io.vertx.core.MultiMap trailers()
      Returns:
      The HTTP trailers

    • putTrailer

      public HttpServerResponse putTrailer(String name, String value)
      Put an HTTP trailer
      Parameters:
      name - the trailer name
      value - the trailer value
      Returns:
      a reference to this, so the API can be used fluently

    • putTrailer

      public HttpServerResponse putTrailer(CharSequence name, CharSequence value)
      Like putTrailer(String, String) but using CharSequence

    • putTrailer

      public HttpServerResponse putTrailer(String name, Iterable<String> values)
      Like putTrailer(String, String) but providing multiple values via a String Iterable

    • putTrailer

      public HttpServerResponse putTrailer(CharSequence name, Iterable<CharSequence> value)
      Like putTrailer(String, Iterable) but with CharSequence Iterable

    • closeHandler

      public HttpServerResponse closeHandler(Runnable handler)
      Set a close handler for the response, this is called when the underlying connection is closed and the response was still using the connection.

      For HTTP/1.x it is called when the connection is closed before end() is called, therefore it is not guaranteed to be called.

      For HTTP/2 it is called when the related stream is closed, and therefore it will be always be called.

      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • endHandler

      public HttpServerResponse endHandler(Runnable handler)
      Set an end handler for the response. This will be called when the response is disposed to allow consistent cleanup of the response.
      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • ended

      public boolean ended()
      Returns:
      has the response already ended?

    • closed

      public boolean closed()
      Returns:
      has the underlying TCP connection corresponding to the request already been closed?

    • headWritten

      public boolean headWritten()
      Returns:
      have the headers for the response already been written?

    • headersEndHandler

      public HttpServerResponse headersEndHandler(Runnable handler)
      Provide a handler that will be called just before the headers are written to the wire.

      This provides a hook allowing you to add any more headers or do any more operations before this occurs.

      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • bodyEndHandler

      public HttpServerResponse bodyEndHandler(Runnable handler)
      Provides a handler that will be called after the last part of the body is written to the wire. The handler is called asynchronously of when the response has been received by the client. This provides a hook allowing you to do more operations once the request has been sent over the wire such as resource cleanup.
      Parameters:
      handler - the handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • bytesWritten

      public long bytesWritten()
      Returns:
      the total number of bytes written for the body of the response.

    • streamId

      public long streamId()
      Returns:
      the id of the stream of this response, -1 for HTTP/1.x

    • setStreamPriority

      public HttpServerResponse setStreamPriority(io.vertx.core.http.StreamPriority streamPriority)
      Sets the priority of the associated stream

      This is not implemented for HTTP/1.x.

      Parameters:
      streamPriority - the priority for this request's stream

    • addCookie

      public HttpServerResponse addCookie(io.vertx.core.http.Cookie cookie)
      Add a cookie. This will be sent back to the client in the response.
      Parameters:
      cookie - the cookie
      Returns:
      a reference to this, so the API can be used fluently

    • removeCookie

      public io.vertx.core.http.Cookie removeCookie(String name)
      Expire a cookie, notifying a User Agent to remove it from its cookie jar. NOTE: This method will only remove the first occurrence of the given name. Users probably may want to use: removeCookies(String)
      Parameters:
      name - the name of the cookie
      Returns:
      the cookie, if it existed, or null

    • removeCookie

      public io.vertx.core.http.Cookie removeCookie(String name, boolean invalidate)
      Remove a cookie from the cookie set. If invalidate is true then it will expire a cookie, notifying a User Agent to remove it from its cookie jar. NOTE: This method will only expire the first occurrence of the given name. Users probably may want to use: removeCookies(String,boolean)
      Parameters:
      name - the name of the cookie
      Returns:
      the cookie, if it existed, or null

    • removeCookies

      public Set<io.vertx.core.http.Cookie> removeCookies(String name)
      Expire all cookies, notifying a User Agent to remove it from its cookie jar. NOTE: the returned Set is read-only. This means any attempt to modify (add or remove to the set), will throw UnsupportedOperationException.
      Parameters:
      name - the name of the cookie
      Returns:
      a read only set of affected cookies, if they existed, or an empty set.

    • removeCookies

      public Set<io.vertx.core.http.Cookie> removeCookies(String name, boolean invalidate)
      Remove all cookies from the cookie set. If invalidate is true then it will expire a cookie, notifying a User Agent to remove it from its cookie jar. NOTE: the returned Set is read-only. This means any attempt to modify (add or remove to the set), will throw UnsupportedOperationException.
      Parameters:
      name - the name of the cookie
      invalidate - invalidate from the user agent
      Returns:
      a read only set of affected cookies, if they existed, or an empty set.

    • removeCookie

      public io.vertx.core.http.Cookie removeCookie(String name, String domain, String path)
      Expires a cookie from the cookie set. This will notify a User Agent to remove it from its cookie jar.
      Parameters:
      name - the name of the cookie
      domain - the domain of the cookie
      path - the path of the cookie
      Returns:
      the cookie, if it existed, or null

    • removeCookie

      public io.vertx.core.http.Cookie removeCookie(String name, String domain, String path, boolean invalidate)
      Remove a cookie from the cookie set. If invalidate is true then it will expire a cookie, notifying a User Agent to remove it from its cookie jar.
      Parameters:
      name - the name of the cookie
      domain - the domain of the cookie
      path - the path of the cookie
      Returns:
      the cookie, if it existed, or null

    • writeQueueFull

      public boolean writeQueueFull()
      This will return true if there are more bytes in the write queue than the value set using setWriteQueueMaxSize(int)
      Specified by:
      writeQueueFull in interface WriteStream<io.vertx.core.buffer.Buffer>
      Returns:
      true if write queue is full

    • newInstance

      public static HttpServerResponse newInstance(io.vertx.core.http.HttpServerResponse delegate)
      Creates a new instance of the HttpServerResponse.

    • hashCode

      public int hashCode()
      Overrides:
      hashCode in class Object

    • equals

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

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • toSubscriber

      @CheckReturnValue public Flow.Subscriber<io.vertx.core.buffer.Buffer> toSubscriber()
      Converts the current write stream to a subscriber.