Package io.vertx.mutiny.core.http

Class HttpServer

java.lang.Object
io.vertx.mutiny.core.http.HttpServer
All Implemented Interfaces:
MutinyDelegate, Measured
public class HttpServer extends Object implements MutinyDelegate, Measured
An HTTP and WebSockets server.

You receive HTTP requests by providing a requestHandler(java.util.function.Consumer<io.vertx.mutiny.core.http.HttpServerRequest>). As requests arrive on the server the handler will be called with the requests.

You receive WebSockets by providing a webSocketHandler(java.util.function.Consumer<io.vertx.mutiny.core.http.ServerWebSocket>). As WebSocket connections arrive on the server, the WebSocket is passed to the handler.

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

  • Field Details

  • Constructor Details

    • HttpServer

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

    • HttpServer

      public HttpServer(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.http.HttpServer getDelegate()
      Specified by:
      getDelegate in interface Measured
      Specified by:
      getDelegate in interface MutinyDelegate
      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

    • isMetricsEnabled

      public boolean isMetricsEnabled()
      Specified by:
      isMetricsEnabled in interface Measured
      Returns:
      true if metrics are enabled

    • requestStream

      @Deprecated public ReadStream<HttpServerRequest> requestStream()
      Deprecated.
      instead use #requestHandler(Handler)
      Returns:
      the request stream

    • requestHandler

      public HttpServer requestHandler(Consumer<HttpServerRequest> handler)
      Parameters:
      handler -
      Returns:

    • invalidRequestHandler

      public HttpServer invalidRequestHandler(Consumer<HttpServerRequest> handler)
      Parameters:
      handler -
      Returns:

    • connectionHandler

      public HttpServer connectionHandler(Consumer<HttpConnection> handler)
      Parameters:
      handler -
      Returns:

    • exceptionHandler

      public HttpServer exceptionHandler(Consumer<Throwable> handler)
      Parameters:
      handler - the handler to set
      Returns:

    • webSocketStream

      @Deprecated public ReadStream<ServerWebSocket> webSocketStream()
      Deprecated.
      instead use #webSocketHandler(Handler)
      Returns:
      the WebSocket stream

    • webSocketHandler

      public HttpServer webSocketHandler(Consumer<ServerWebSocket> handler)
      Parameters:
      handler -
      Returns:

    • webSocketHandshakeHandler

      public HttpServer webSocketHandshakeHandler(Consumer<ServerWebSocketHandshake> handler)
      Parameters:
      handler -
      Returns:

    • updateSSLOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> updateSSLOptions(io.vertx.core.net.SSLOptions options)
      Like updateSSLOptions(io.vertx.core.net.SSLOptions) but supplying a handler that will be called when the update happened (or has failed).

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

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

    • updateSSLOptionsAndAwait

      public Boolean updateSSLOptionsAndAwait(io.vertx.core.net.SSLOptions options)
      Blocking variant of updateSSLOptions(SSLOptions).

      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:
      options - the new SSL options
      Returns:
      the Boolean instance produced by the operation.

    • updateSSLOptionsAndForget

      public void updateSSLOptionsAndForget(io.vertx.core.net.SSLOptions options)
      Variant of updateSSLOptions(SSLOptions) that ignores the result of the operation.

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

      Parameters:
      options - the new SSL options

    • updateSSLOptions

      @CheckReturnValue public io.smallrye.mutiny.Uni<Boolean> updateSSLOptions(io.vertx.core.net.SSLOptions options, boolean force)
      Like updateSSLOptions(io.vertx.core.net.SSLOptions) but supplying a handler that will be called when the update happened (or has failed).

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

      Parameters:
      options - the new SSL options
      force - force the update when options are equals
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • updateSSLOptionsAndAwait

      public Boolean updateSSLOptionsAndAwait(io.vertx.core.net.SSLOptions options, boolean force)
      Blocking variant of updateSSLOptions(SSLOptions,boolean).

      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:
      options - the new SSL options
      force - force the update when options are equals
      Returns:
      the Boolean instance produced by the operation.

    • updateSSLOptionsAndForget

      public void updateSSLOptionsAndForget(io.vertx.core.net.SSLOptions options, boolean force)
      Variant of updateSSLOptions(SSLOptions,boolean) that ignores the result of the operation.

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

      Parameters:
      options - the new SSL options
      force - force the update when options are equals

    • updateTrafficShapingOptions

      public void updateTrafficShapingOptions(io.vertx.core.net.TrafficShapingOptions options)
      Parameters:
      options - the new traffic shaping options

    • listen

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServer> listen(int port, String host)
      Like listen(int, java.lang.String) but supplying a handler that will be called when the server is actually listening (or has failed).

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

      Parameters:
      port - the port to listen on
      host - the host to listen on
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • listenAndAwait

      public HttpServer listenAndAwait(int port, String host)
      Blocking variant of listen(int,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:
      port - the port to listen on
      host - the host to listen on
      Returns:
      the HttpServer instance produced by the operation.

    • listenAndForget

      public HttpServer listenAndForget(int port, String host)
      Variant of listen(int,String) that ignores the result of the operation.

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

      Parameters:
      port - the port to listen on
      host - the host to listen on
      Returns:
      the instance of HttpServer to chain method calls.

    • listen

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServer> listen(SocketAddress address)
      Tell the server to start listening on the given address supplying a handler that will be called when the server is actually listening (or has failed).

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

      Parameters:
      address - the address to listen on
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • listenAndAwait

      public HttpServer listenAndAwait(SocketAddress address)
      Blocking variant of listen(io.vertx.mutiny.core.net.SocketAddress).

      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:
      address - the address to listen on
      Returns:
      the HttpServer instance produced by the operation.

    • listenAndForget

      public HttpServer listenAndForget(SocketAddress address)
      Variant of listen(io.vertx.mutiny.core.net.SocketAddress) that ignores the result of the operation.

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

      Parameters:
      address - the address to listen on
      Returns:
      the instance of HttpServer to chain method calls.

    • listen

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServer> listen(int port)
      Like listen(int, java.lang.String) but supplying a handler that will be called when the server is actually listening (or has failed).

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

      Parameters:
      port - the port to listen on
      Returns:
      the uni firing the result of the operation when completed, or a failure if the operation failed.

    • listenAndAwait

      public HttpServer listenAndAwait(int port)
      Blocking variant of listen(int).

      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:
      port - the port to listen on
      Returns:
      the HttpServer instance produced by the operation.

    • listenAndForget

      public HttpServer listenAndForget(int port)
      Variant of listen(int) that ignores the result of the operation.

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

      Parameters:
      port - the port to listen on
      Returns:
      the instance of HttpServer to chain method calls.

    • listen

      @CheckReturnValue public io.smallrye.mutiny.Uni<HttpServer> listen()
      Like listen(int, java.lang.String) but supplying a handler that will be called when the server is actually listening (or has failed).

      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.

    • listenAndAwait

      public HttpServer listenAndAwait()
      Blocking variant of listen(int, 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).

      Returns:
      the HttpServer instance produced by the operation.

    • listenAndForget

      public HttpServer listenAndForget()
      Variant of listen(int, java.lang.String) that ignores the result of the operation.

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

      Returns:
      the instance of HttpServer to chain method calls.

    • close

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> close()
      Like close() but supplying a handler that will be called when the server is actually closed (or has failed).

      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.

    • closeAndAwait

      public Void closeAndAwait()
      Blocking variant of close().

      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.

    • closeAndForget

      public void closeAndForget()
      Variant of close() that ignores the result of the operation.

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

    • actualPort

      public int actualPort()
      Returns:
      the actual port the server is listening on.

    • newInstance

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