Package io.vertx.mutiny.core.http

Class HttpClientRequest

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

Instances are created by an HttpClient instance, via one of the methods corresponding to the specific HTTP methods, or the generic request methods. On creation the request will not have been written to the wire.

Once a request has been obtained, headers can be set on it, and data can be written to its body if required. Once you are ready to send the request, one of the end(java.lang.String) methods should be called.

Nothing is actually sent until the request has been internally assigned an HTTP connection.

The HttpClient instance will return an instance of this class immediately, even if there are no HTTP connections available in the pool. Any requests sent before a connection is assigned will be queued internally and actually sent when an HTTP connection becomes available from the pool.

The headers of the request are queued for writing either when the end(java.lang.String) method is called, or, when the first part of the body is written, whichever occurs first.

This class supports both chunked and non-chunked HTTP.

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

An example of using this class is as follows:

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

  • Field Details

  • Constructor Details

    • HttpClientRequest

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

    • HttpClientRequest

      public HttpClientRequest(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.http.HttpClientRequest getDelegate()
      Specified by:
      getDelegate in interface MutinyDelegate
      Specified by:
      getDelegate in interface StreamBase
      Specified by:
      getDelegate in interface WriteStream<Buffer>
      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

    • toSubscriber

      @CheckReturnValue public WriteStreamSubscriber<Buffer> toSubscriber()

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(Buffer data)
      Same as 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.

      Specified by:
      write in interface WriteStream<Buffer>
      Parameters:
      data -
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • writeAndAwait

      public Void writeAndAwait(Buffer data)
      Blocking variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer).

      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:
      writeAndAwait in interface WriteStream<Buffer>
      Parameters:
      data -
      Returns:
      the Void instance produced by the operation.

    • writeAndForget

      public void writeAndForget(Buffer data)
      Variant of io.vertx.mutiny.core.streams.WriteStream#write(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

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

      Specified by:
      writeAndForget in interface WriteStream<Buffer>
      Parameters:
      data -

    • writeQueueFull

      public boolean writeQueueFull()
      Specified by:
      writeQueueFull in interface WriteStream<Buffer>
      Returns:
      true if write queue is full

    • exceptionHandler

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

    • setWriteQueueMaxSize

      public HttpClientRequest setWriteQueueMaxSize(int maxSize)
      Specified by:
      setWriteQueueMaxSize in interface WriteStream<Buffer>
      Parameters:
      maxSize - the max size of the write stream
      Returns:
      a reference to this, so the API can be used fluently

    • drainHandler

      public HttpClientRequest drainHandler(Runnable handler)
      Specified by:
      drainHandler in interface WriteStream<Buffer>
      Parameters:
      handler - the handler
      Returns:

    • authority

      public HttpClientRequest authority(HostAndPort authority)
      Parameters:
      authority - override the request authority
      Returns:
      a reference to this, so the API can be used fluently

    • setHost

      @Deprecated public HttpClientRequest setHost(String host)
      Deprecated.
      instead use authority(HostAndPort)
      Parameters:
      host - the host part of the HTTP/1.1 host header or HTTP/2 authority pseudo header
      Returns:
      a reference to this, so the API can be used fluently

    • getHost

      @Deprecated public String getHost()
      Deprecated.
      Returns:
      the host value of the HTTP/1.1 host header or HTTP/2 authority pseudo header

    • setPort

      @Deprecated public HttpClientRequest setPort(int port)
      Deprecated.
      instead use authority(HostAndPort)
      Parameters:
      port - the port part of the HTTP/1.1 host header or HTTP/2 authority pseudo header
      Returns:
      a reference to this, so the API can be used fluently

    • getPort

      @Deprecated public int getPort()
      Deprecated.
      Returns:
      the port value of the HTTP/1.1 host header or HTTP/2 authority pseudo header

    • setFollowRedirects

      public HttpClientRequest setFollowRedirects(boolean followRedirects)
      Parameters:
      followRedirects - true to follow HTTP redirects
      Returns:
      a reference to this, so the API can be used fluently

    • isFollowRedirects

      public boolean isFollowRedirects()
      Returns:
      whether HTTP redirections should be followed

    • setMaxRedirects

      public HttpClientRequest setMaxRedirects(int maxRedirects)
      Parameters:
      maxRedirects - the number of HTTP redirect to follow
      Returns:
      a reference to this, so the API can be used fluently

    • getMaxRedirects

      public int getMaxRedirects()
      Returns:
      the maximum number of HTTP redirections to follow

    • numberOfRedirections

      public int numberOfRedirections()
      Returns:
      the number of followed redirections for the current HTTP request

    • setChunked

      public HttpClientRequest setChunked(boolean chunked)
      Parameters:
      chunked - true if chunked encoding
      Returns:
      a reference to this, so the API can be used fluently

    • isChunked

      public boolean isChunked()
      Returns:
      Is the request chunked?

    • getMethod

      public io.vertx.core.http.HttpMethod getMethod()
      Returns:

    • setMethod

      public HttpClientRequest setMethod(io.vertx.core.http.HttpMethod method)
      Parameters:
      method - the HTTP method
      Returns:
      a reference to this, so the API can be used fluently

    • absoluteURI

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

    • getURI

      public String getURI()
      Returns:
      The URI of the request.

    • setURI

      public HttpClientRequest setURI(String uri)
      Parameters:
      uri - the request uri
      Returns:
      a reference to this, so the API can be used fluently

    • 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

    • headers

      public MultiMap headers()
      Returns:
      The HTTP headers

    • putHeader

      public HttpClientRequest putHeader(String name, String value)
      Parameters:
      name - The header name
      value - The header value
      Returns:
      a reference to this, so the API can be used fluently

    • traceOperation

      public HttpClientRequest traceOperation(String op)
      Parameters:
      op - the operation
      Returns:

    • traceOperation

      public String traceOperation()
      Returns:
      the trace operation of this request

    • version

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

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String chunk)
      Same as write(io.vertx.mutiny.core.buffer.Buffer) 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.

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

    • writeAndAwait

      public Void writeAndAwait(String chunk)
      Blocking variant of write(String).

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

      Parameters:
      chunk -
      Returns:
      the Void instance produced by the operation.

    • writeAndForget

      public void writeAndForget(String chunk)
      Variant of write(String) that ignores the result of the operation.

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

      Parameters:
      chunk -

    • write

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> write(String chunk, String enc)
      Same as write(io.vertx.mutiny.core.buffer.Buffer) 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.

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

    • writeAndAwait

      public Void writeAndAwait(String chunk, String enc)
      Blocking variant of write(String,String).

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

      Parameters:
      chunk -
      enc -
      Returns:
      the Void instance produced by the operation.

    • writeAndForget

      public void writeAndForget(String chunk, String enc)
      Variant of write(String,String) that ignores the result of the operation.

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

      Parameters:
      chunk -
      enc -

    • continueHandler

      public HttpClientRequest continueHandler(Runnable handler)
      Parameters:
      handler -
      Returns:

    • earlyHintsHandler

      public HttpClientRequest earlyHintsHandler(Consumer<MultiMap> handler)
      Parameters:
      handler -
      Returns:

    • redirectHandler

      public HttpClientRequest redirectHandler(Function<HttpClientResponse,io.smallrye.mutiny.Uni<HttpClientRequest>> handler)

    • sendHead

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> sendHead()
      Like sendHead() but with an handler after headers have been sent. The handler will be called with the HttpVersion if it can be determined or null otherwise.

      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.

    • sendHeadAndAwait

      public Void sendHeadAndAwait()
      Blocking variant of sendHead().

      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.

    • sendHeadAndForget

      public HttpClientRequest sendHeadAndForget()
      Variant of sendHead() that ignores the result of the operation.

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

      Returns:
      the instance of HttpClientRequest to chain method calls.

    • connect

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> connect()
      Create an HTTP tunnel to the server.

      Send HTTP request headers to the server, then configures the transport to exchange raw buffers when the server replies with an appropriate response:

      • 200 for HTTP CONNECT method
      • 101 for HTTP/1.1 GET with Upgrade connection header

      The handler is called after response headers are received.

      Use HttpClientResponse.netSocket() to get a for interacting more conveniently with the server.

      HTTP/1.1 pipe-lined requests are not supported.f

      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.

    • connectAndAwait

      public HttpClientResponse connectAndAwait()
      Blocking variant of connect().

      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 HttpClientResponse instance produced by the operation.

    • connectAndForget

      public void connectAndForget()
      Variant of connect() that ignores the result of the operation.

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

    • response

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpClientResponse> response()
      Set a callback for the associated HttpClientResponse.

      This method does not modify the current request being sent.

      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.

    • responseAndAwait

      public HttpClientResponse responseAndAwait()
      Blocking variant of response().

      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 HttpClientResponse instance produced by the operation.

    • responseAndForget

      public HttpClientRequest responseAndForget()
      Variant of response() that ignores the result of the operation.

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

      Returns:
      the instance of HttpClientRequest to chain method calls.

    • send

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

      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.

    • sendAndAwait

      public HttpClientResponse sendAndAwait()
      Blocking variant of send().

      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 HttpClientResponse instance produced by the operation.

    • sendAndForget

      public void sendAndForget()
      Variant of send() that ignores the result of the operation.

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

    • send

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

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

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

    • sendAndAwait

      public HttpClientResponse sendAndAwait(String body)
      Blocking variant of send(String).

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

      Parameters:
      body -
      Returns:
      the HttpClientResponse instance produced by the operation.

    • sendAndForget

      public void sendAndForget(String body)
      Variant of send(String) that ignores the result of the operation.

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

      Parameters:
      body -

    • send

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

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

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

    • sendAndAwait

      public HttpClientResponse sendAndAwait(Buffer body)
      Blocking variant of send(io.vertx.mutiny.core.buffer.Buffer).

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

      Parameters:
      body -
      Returns:
      the HttpClientResponse instance produced by the operation.

    • sendAndForget

      public void sendAndForget(Buffer body)
      Variant of send(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

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

      Parameters:
      body -

    • send

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

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

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

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

    • sendAndAwait

      public HttpClientResponse sendAndAwait(ReadStream<Buffer> body)
      Blocking variant of send(io.vertx.mutiny.core.streams.ReadStream).

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

      Parameters:
      body -
      Returns:
      the HttpClientResponse instance produced by the operation.

    • sendAndForget

      public void sendAndForget(ReadStream<Buffer> body)
      Variant of send(io.vertx.mutiny.core.streams.ReadStream) that ignores the result of the operation.

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

      Parameters:
      body -

    • send

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

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

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

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

    • sendAndAwait

      public HttpClientResponse sendAndAwait(Flow.Publisher<Buffer> body)
      Blocking variant of send(Flow$Publisher).

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

      Parameters:
      body -
      Returns:
      the HttpClientResponse instance produced by the operation.

    • sendAndForget

      public void sendAndForget(Flow.Publisher<Buffer> body)
      Variant of send(Flow$Publisher) that ignores the result of the operation.

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

      Parameters:
      body -

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(String chunk)
      Same as end(java.lang.String) 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.

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

    • endAndAwait

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

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

      Parameters:
      chunk -
      Returns:
      the Void instance produced by the operation.

    • endAndForget

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

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

      Parameters:
      chunk -

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(String chunk, String enc)
      Same as end(java.lang.String) 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.

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

    • endAndAwait

      public Void endAndAwait(String chunk, String enc)
      Blocking variant of end(String,String).

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

      Parameters:
      chunk -
      enc -
      Returns:
      the Void instance produced by the operation.

    • endAndForget

      public void endAndForget(String chunk, String enc)
      Variant of end(String,String) that ignores the result of the operation.

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

      Parameters:
      chunk -
      enc -

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end(Buffer chunk)
      Same as end(java.lang.String) 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.

      Specified by:
      end in interface WriteStream<Buffer>
      Parameters:
      chunk -
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • endAndAwait

      public Void endAndAwait(Buffer chunk)
      Blocking variant of end(io.vertx.mutiny.core.buffer.Buffer).

      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:
      endAndAwait in interface WriteStream<Buffer>
      Parameters:
      chunk -
      Returns:
      the Void instance produced by the operation.

    • endAndForget

      public void endAndForget(Buffer chunk)
      Variant of end(io.vertx.mutiny.core.buffer.Buffer) that ignores the result of the operation.

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

      Specified by:
      endAndForget in interface WriteStream<Buffer>
      Parameters:
      chunk -

    • end

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> end()
      Same as end(java.lang.String) 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.

      Specified by:
      end in interface WriteStream<Buffer>
      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(java.lang.String).

      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:
      endAndAwait in interface WriteStream<Buffer>
      Returns:
      the Void instance produced by the operation.

    • endAndForget

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

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

      Specified by:
      endAndForget in interface WriteStream<Buffer>

    • setTimeout

      @Deprecated public HttpClientRequest setTimeout(long timeout)
      Deprecated.
      instead use idleTimeout(long)
      Parameters:
      timeout -
      Returns:
      the instance of HttpClientRequest to chain method calls.

    • idleTimeout

      public HttpClientRequest idleTimeout(long timeout)
      Parameters:
      timeout - the amount of time in milliseconds.
      Returns:
      a reference to this, so the API can be used fluently

    • pushHandler

      public HttpClientRequest pushHandler(Consumer<HttpClientRequest> handler)
      Parameters:
      handler - the handler
      Returns:

    • reset

      public boolean reset()
      Returns:

    • reset

      public boolean reset(long code)
      Parameters:
      code - the error code
      Returns:
      true when reset has been performed

    • reset

      public boolean reset(long code, Throwable cause)
      Parameters:
      code - the error code
      cause - an optional cause that can be attached to the error code
      Returns:
      true when reset has been performed

    • connection

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

    • writeCustomFrame

      public HttpClientRequest writeCustomFrame(int type, int flags, Buffer payload)
      Parameters:
      type - the 8-bit frame type
      flags - the 8-bit frame flags
      payload - the frame payload
      Returns:
      a reference to this, so the API can be used fluently

    • streamId

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

    • writeCustomFrame

      public HttpClientRequest writeCustomFrame(HttpFrame frame)
      Parameters:
      frame - the frame to write
      Returns:
      the instance of HttpClientRequest to chain method calls.

    • setStreamPriority

      public HttpClientRequest setStreamPriority(io.vertx.core.http.StreamPriority streamPriority)
      Parameters:
      streamPriority - the priority of this request's stream
      Returns:
      the instance of HttpClientRequest to chain method calls.

    • getStreamPriority

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

    • putHeader

      public HttpClientRequest putHeader(CharSequence name, CharSequence value)
      Parameters:
      name -
      value -
      Returns:
      the instance of HttpClientRequest to chain method calls.

    • putHeader

      public HttpClientRequest putHeader(String name, Iterable<String> values)
      Parameters:
      name - The header name
      values - The header values
      Returns:

    • putHeader

      public HttpClientRequest putHeader(CharSequence name, Iterable<CharSequence> values)
      Parameters:
      name -
      values -
      Returns:
      the instance of HttpClientRequest to chain method calls.

    • newInstance

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