Package io.vertx.mutiny.core

Class Vertx

java.lang.Object
io.vertx.mutiny.core.Vertx
All Implemented Interfaces:
MutinyDelegate, Measured
public class Vertx extends Object implements Measured, MutinyDelegate
The entry point into the Vert.x Core API.

You use an instance of this class for functionality including:

  • Creating TCP clients and servers
  • Creating HTTP clients and servers
  • Creating DNS clients
  • Creating Datagram sockets
  • Setting and cancelling periodic and one-shot timers
  • Getting a reference to the event bus API
  • Getting a reference to the file system API
  • Getting a reference to the shared data API
  • Deploying and undeploying verticles

Most functionality in Vert.x core is fairly low level.

To create an instance of this class you can use the static factory methods: vertx(), vertx(io.vertx.core.VertxOptions) and clusteredVertx(io.vertx.core.VertxOptions).

Please see the user manual for more detailed usage information.

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

Author:
Tim Fox, Julien Viet
See Also:
  • Vertx

  • Field Details

    • __TYPE_ARG

      public static final TypeArg<Vertx> __TYPE_ARG

  • Constructor Details

    • Vertx

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

    • Vertx

      public Vertx(Object delegate)

  • Method Details

    • getDelegate

      public io.vertx.core.Vertx 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 Measured
      Specified by:
      getDelegate in interface MutinyDelegate
      Returns:
      the delegate instance

    • clusteredVertx

      @CheckReturnValue public static io.smallrye.mutiny.Uni<Vertx> clusteredVertx(io.vertx.core.VertxOptions options)
      Creates a clustered instance using the specified options.

      The instance is created asynchronously and the returned uni is completed with the result when it is ready.

      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:
      options - the options to use
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.clusteredVertx(VertxOptions)

    • clusteredVertxAndAwait

      public static Vertx clusteredVertxAndAwait(io.vertx.core.VertxOptions options)
      Creates a clustered instance using the specified options.

      The instance is created asynchronously and the returned underlying uni is completed with the result when it is ready.

      Unlike the bare Vert.x variant, this method returns a Vertx. 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:
      options - the options to use
      Returns:
      The operation result
      See Also:
      • Vertx.clusteredVertx(VertxOptions)

    • clusteredVertxAndForget

      public static void clusteredVertxAndForget(io.vertx.core.VertxOptions options)
      Creates a clustered instance using the specified options.

      The instance is created asynchronously and the returned underlying uni is completed with the result when it is ready.

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

      Parameters:
      options - the options to use
      See Also:
      • Vertx.clusteredVertx(VertxOptions)

    • close

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> close()
      Stop the Vertx instance and release any resources held by it.

      The instance cannot be used after it has been closed.

      The actual close is asynchronous and may not complete until after the call has returned.

      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:
      • Vertx.close()

    • closeAndAwait

      public void closeAndAwait()
      Stop the Vertx instance and release any resources held by it.

      The instance cannot be used after it has been closed.

      The actual close is asynchronous and may not complete until after the call has returned.

      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:
      • Vertx.close()

    • closeAndForget

      public Vertx closeAndForget()
      Stop the Vertx instance and release any resources held by it.

      The instance cannot be used after it has been closed.

      The actual close is asynchronous and may not complete until after the call has returned.

      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:
      • Vertx.close()

    • deployVerticle

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> deployVerticle(io.vertx.core.Deployable verticle)
      Deploy a verticle instance that you have created yourself.

      Vert.x will assign the verticle a context and start the verticle.

      The actual deploy happens asynchronously and may not complete until after the call has returned.

      If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      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:
      verticle - the verticle instance to deploy.
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.deployVerticle(Deployable)

    • deployVerticleAndAwait

      public String deployVerticleAndAwait(io.vertx.core.Deployable verticle)
      Deploy a verticle instance that you have created yourself.

      Vert.x will assign the verticle a context and start the verticle.

      The actual deploy happens asynchronously and may not complete until after the call has returned.

      If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Unlike the bare Vert.x variant, this method returns a String. 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:
      verticle - the verticle instance to deploy.
      Returns:
      The operation result
      See Also:
      • Vertx.deployVerticle(Deployable)

    • deployVerticleAndForget

      public Vertx deployVerticleAndForget(io.vertx.core.Deployable verticle)
      Deploy a verticle instance that you have created yourself.

      Vert.x will assign the verticle a context and start the verticle.

      The actual deploy happens asynchronously and may not complete until after the call has returned.

      If the deployment is successful the result will contain a string representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

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

      Parameters:
      verticle - the verticle instance to deploy.
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.deployVerticle(Deployable)

    • deployVerticle

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> deployVerticle(io.vertx.core.Deployable verticle, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.

      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:
      verticle - the verticle instance to deploy
      options - the deployment options.
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.deployVerticle(Deployable, DeploymentOptions)

    • deployVerticleAndAwait

      public String deployVerticleAndAwait(io.vertx.core.Deployable verticle, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.

      Unlike the bare Vert.x variant, this method returns a String. 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:
      verticle - the verticle instance to deploy
      options - the deployment options.
      Returns:
      The operation result
      See Also:
      • Vertx.deployVerticle(Deployable, DeploymentOptions)

    • deployVerticleAndForget

      public Vertx deployVerticleAndForget(io.vertx.core.Deployable verticle, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.

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

      Parameters:
      verticle - the verticle instance to deploy
      options - the deployment options.
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.deployVerticle(Deployable, DeploymentOptions)

    • deployVerticle

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> deployVerticle(Supplier<? extends io.vertx.core.Deployable> supplier, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable, DeploymentOptions) but Deployable instance is created by invoking the verticleSupplier.

      The supplier will be invoked as many times as DeploymentOptions.getInstances(). It must not return the same instance twice.

      Note that the supplier will be invoked on the caller thread.

      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:
      • Vertx.deployVerticle(Supplier, DeploymentOptions)

    • deployVerticleAndAwait

      public String deployVerticleAndAwait(Supplier<? extends io.vertx.core.Deployable> supplier, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable, DeploymentOptions) but Deployable instance is created by invoking the verticleSupplier.

      The supplier will be invoked as many times as DeploymentOptions.getInstances(). It must not return the same instance twice.

      Note that the supplier will be invoked on the caller thread.

      Unlike the bare Vert.x variant, this method returns a String. 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:
      • Vertx.deployVerticle(Supplier, DeploymentOptions)

    • deployVerticleAndForget

      public Vertx deployVerticleAndForget(Supplier<? extends io.vertx.core.Deployable> supplier, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable, DeploymentOptions) but Deployable instance is created by invoking the verticleSupplier.

      The supplier will be invoked as many times as DeploymentOptions.getInstances(). It must not return the same instance twice.

      Note that the supplier will be invoked on the caller thread.

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

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.deployVerticle(Supplier, DeploymentOptions)

    • deployVerticle

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> deployVerticle(String name)
      Deploy a verticle instance given a name.

      Given the name, Vert.x selects a VerticleFactory instance to use to instantiate the verticle.

      For the rules on how factories are selected please consult the user manual.

      If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      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:
      name - the name.
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.deployVerticle(String)

    • deployVerticleAndAwait

      public String deployVerticleAndAwait(String name)
      Deploy a verticle instance given a name.

      Given the name, Vert.x selects a VerticleFactory instance to use to instantiate the verticle.

      For the rules on how factories are selected please consult the user manual.

      If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

      Unlike the bare Vert.x variant, this method returns a String. 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:
      name - the name.
      Returns:
      The operation result
      See Also:
      • Vertx.deployVerticle(String)

    • deployVerticleAndForget

      public Vertx deployVerticleAndForget(String name)
      Deploy a verticle instance given a name.

      Given the name, Vert.x selects a VerticleFactory instance to use to instantiate the verticle.

      For the rules on how factories are selected please consult the user manual.

      If the deployment is successful the result will contain a String representing the unique deployment ID of the deployment.

      This deployment ID can subsequently be used to undeploy the verticle.

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

      Parameters:
      name - the name.
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.deployVerticle(String)

    • deployVerticle

      @CheckReturnValue public io.smallrye.mutiny.Uni<String> deployVerticle(String name, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.

      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:
      name - the name
      options - the deployment options.
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.deployVerticle(String, DeploymentOptions)

    • deployVerticleAndAwait

      public String deployVerticleAndAwait(String name, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.

      Unlike the bare Vert.x variant, this method returns a String. 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:
      name - the name
      options - the deployment options.
      Returns:
      The operation result
      See Also:
      • Vertx.deployVerticle(String, DeploymentOptions)

    • deployVerticleAndForget

      public Vertx deployVerticleAndForget(String name, io.vertx.core.DeploymentOptions options)
      Like deployVerticle(Deployable) but DeploymentOptions are provided to configure the deployment.

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

      Parameters:
      name - the name
      options - the deployment options.
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.deployVerticle(String, DeploymentOptions)

    • undeploy

      @CheckReturnValue public io.smallrye.mutiny.Uni<Void> undeploy(String deploymentID)
      Undeploy a verticle deployment.

      The actual undeployment happens asynchronously and may not complete until after the method has returned.

      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:
      deploymentID - the deployment ID
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.undeploy(String)

    • undeployAndAwait

      public void undeployAndAwait(String deploymentID)
      Undeploy a verticle deployment.

      The actual undeployment happens asynchronously and may not complete until after the method has returned.

      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:
      deploymentID - the deployment ID
      See Also:
      • Vertx.undeploy(String)

    • undeployAndForget

      public Vertx undeployAndForget(String deploymentID)
      Undeploy a verticle deployment.

      The actual undeployment happens asynchronously and may not complete until after the method has returned.

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

      Parameters:
      deploymentID - the deployment ID
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.undeploy(String)

    • executeBlocking

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<T> executeBlocking(Callable<T> blockingCodeHandler, boolean ordered)
      Safely execute some blocking code.

      Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.

      The returned uni will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.

      In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on this context and not on the worker thread.

      The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

      When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

      Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context#runOnContext(Handler)

      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.

      Type Parameters:
      T - the type of the result
      Parameters:
      blockingCodeHandler - handler representing the blocking code to run
      ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
      Returns:
      A Uni representing the asynchronous result of this operation.
      See Also:
      • Vertx.executeBlocking(Callable, boolean)

    • executeBlockingAndAwait

      public <T> T executeBlockingAndAwait(Callable<T> blockingCodeHandler, boolean ordered)
      Safely execute some blocking code.

      Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.

      The returned underlying uni will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.

      In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on this context and not on the worker thread.

      The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

      When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

      Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context#runOnContext(Handler)

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

      Type Parameters:
      T - the type of the result
      Parameters:
      blockingCodeHandler - handler representing the blocking code to run
      ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
      Returns:
      The operation result
      See Also:
      • Vertx.executeBlocking(Callable, boolean)

    • executeBlockingAndForget

      public <T> Vertx executeBlockingAndForget(Callable<T> blockingCodeHandler, boolean ordered)
      Safely execute some blocking code.

      Executes the blocking code in the handler blockingCodeHandler using a thread from the worker pool.

      The returned underlying uni will be completed with the result on the original context (i.e. on the original event loop of the caller) or failed when the handler throws an exception.

      In the blockingCodeHandler the current context remains the original context and therefore any task scheduled in the blockingCodeHandler will be executed on this context and not on the worker thread.

      The blocking code should block for a reasonable amount of time (i.e no more than a few seconds). Long blocking operations or polling operations (i.e a thread that spin in a loop polling events in a blocking fashion) are precluded.

      When the blocking operation lasts more than the 10 seconds, a message will be printed on the console by the blocked thread checker.

      Long blocking operations should use a dedicated thread managed by the application, which can interact with verticles using the event-bus or Context#runOnContext(Handler)

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

      Type Parameters:
      T - the type of the result
      Parameters:
      blockingCodeHandler - handler representing the blocking code to run
      ordered - if true then if executeBlocking is called several times on the same context, the executions for that context will be executed serially, not in parallel. if false then they will be no ordering guarantees
      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.executeBlocking(Callable, boolean)

    • executeBlocking

      @CheckReturnValue public <T> io.smallrye.mutiny.Uni<T> executeBlocking(Callable<T> blockingCodeHandler)
      Like executeBlocking(Callable, boolean) called with ordered = true.

      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:
      • Vertx.executeBlocking(Callable)

    • executeBlockingAndAwait

      public <T> T executeBlockingAndAwait(Callable<T> blockingCodeHandler)
      Like executeBlocking(Callable, boolean) called with ordered = true.

      Unlike the bare Vert.x variant, this method returns a Vertx. 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:
      • Vertx.executeBlocking(Callable)

    • executeBlockingAndForget

      public <T> Vertx executeBlockingAndForget(Callable<T> blockingCodeHandler)
      Like executeBlocking(Callable, boolean) called with ordered = true.

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

      Returns:
      The current instance to chain operations if needed.
      See Also:
      • Vertx.executeBlocking(Callable)

    • builder

      public static VertxBuilder builder()
      Return a builder for Vert.x instances which allows to specify SPI such as cluster manager, metrics or tracing.
      Returns:
      a Vert.x instance builder

    • vertx

      public static Vertx vertx()
      Creates a non clustered instance using default options.
      Returns:
      the instance

    • vertx

      public static Vertx vertx(io.vertx.core.VertxOptions options)
      Creates a non clustered instance using the specified options
      Parameters:
      options - the options to use
      Returns:
      the instance

    • currentContext

      public static Context currentContext()
      Gets the current context
      Returns:
      The current context or null if there is no current context

    • getOrCreateContext

      public Context getOrCreateContext()
      Gets the current context, or creates one if there isn't one
      Returns:
      The current context (created if didn't exist)

    • createNetServer

      public NetServer createNetServer(io.vertx.core.net.TcpServerConfig config)
      Create a TCP/SSL server using the specified config
      Parameters:
      config - the config to use
      Returns:
      the server

    • createNetServer

      public NetServer createNetServer(io.vertx.core.net.TcpServerConfig config, io.vertx.core.net.ServerSSLOptions sslOptions)
      Create a TCP/SSL server using the specified config and the specified ssl options
      Parameters:
      config - the config to use
      sslOptions - the server SSL options
      Returns:
      the server

    • createNetServer

      public NetServer createNetServer(io.vertx.core.net.NetServerOptions options)
      Create a TCP/SSL server using the specified options
      Parameters:
      options - the options to use
      Returns:
      the server

    • createNetServer

      public NetServer createNetServer()
      Create a TCP/SSL server using default options
      Returns:
      the server

    • createNetClient

      public NetClient createNetClient(io.vertx.core.net.TcpClientConfig config)
      Create a TCP/SSL client using the specified config
      Parameters:
      config - the config to use
      Returns:
      the client

    • createNetClient

      public NetClient createNetClient(io.vertx.core.net.TcpClientConfig config, io.vertx.core.net.ClientSSLOptions sslOptions)
      Create a TCP/SSL client using the specified config and the specified ssl options
      Parameters:
      config - the config to use
      sslOptions - the default client SSL options
      Returns:
      the client

    • createNetClient

      public NetClient createNetClient(io.vertx.core.net.NetClientOptions options)
      Create a TCP/SSL client using the specified options
      Parameters:
      options - the options to use
      Returns:
      the client

    • createNetClient

      public NetClient createNetClient()
      Create a TCP/SSL client using default options
      Returns:
      the client

    • createQuicServer

      public QuicServer createQuicServer(io.vertx.core.net.QuicServerConfig config, io.vertx.core.net.ServerSSLOptions sslOptions)

      Create a configured Quic server.

      The returned server can be bound, after setting a connection handler

      Parameters:
      config - the server configuration
      sslOptions - the server SSL options
      Returns:
      the server

    • createQuicServer

      public QuicServer createQuicServer(io.vertx.core.net.ServerSSLOptions sslOptions)
      Like createQuicServer(QuicServerConfig, ServerSSLOptions), with the default server configuration.

    • createQuicClient

      public QuicClient createQuicClient(io.vertx.core.net.QuicClientConfig config, io.vertx.core.net.ClientSSLOptions sslOptions)

      Create a configured Quic client.

      Parameters:
      config - the client configuration
      sslOptions - the default client SSL options
      Returns:
      the client

    • createQuicClient

      public QuicClient createQuicClient(io.vertx.core.net.ClientSSLOptions defaultSslOptions)
      Like createQuicClient(QuicClientConfig, ClientSSLOptions), with the default client configuration.

    • createQuicClient

      public QuicClient createQuicClient(io.vertx.core.net.QuicClientConfig config)

      Create a configured Quic client.

      Parameters:
      config - the client configuration
      Returns:
      the client

    • createHttpServer

      public HttpServer createHttpServer(io.vertx.core.http.HttpServerOptions options)
      Create an HTTP/HTTPS server using the specified options
      Parameters:
      options - the options to use
      Returns:
      the server

    • createHttpServer

      public HttpServer createHttpServer(io.vertx.core.http.HttpServerConfig config)
      Create an HTTP server using the specified config.
      Parameters:
      config - the config to use
      Returns:
      the server

    • createHttpServer

      public HttpServer createHttpServer(io.vertx.core.http.HttpServerConfig config, io.vertx.core.net.ServerSSLOptions sslOptions)
      Create an HTTP server using the specified config and the specified sslOptions
      Parameters:
      config - the config to use
      sslOptions - the ssl options to use
      Returns:
      the server

    • createHttpServer

      public HttpServer createHttpServer(io.vertx.core.net.ServerSSLOptions sslOptions)
      Create an HTTP server using default config and the specified sslOptions.
      Parameters:
      sslOptions - the ssl options to use
      Returns:
      the server

    • createHttpServer

      public HttpServer createHttpServer()
      Create an HTTP/HTTPS server using default config.
      Returns:
      the server

    • httpServerBuilder

      public HttpServerBuilder httpServerBuilder()
      Provide a builder for HttpServer, it can be used to configure advanced HTTP servre settings like a connection handler.

      Example usage: HttpServer server = vertx.httpServerBuilder().with(options).withConnectHandler(conn -> ...).build()

    • createWebSocketClient

      public WebSocketClient createWebSocketClient()
      Create a WebSocket client using default options
      Returns:
      the client

    • createWebSocketClient

      public WebSocketClient createWebSocketClient(io.vertx.core.http.WebSocketClientOptions options)
      Create a WebSocket client using the specified options
      Parameters:
      options - the options to use
      Returns:
      the client

    • httpClientBuilder

      public HttpClientBuilder httpClientBuilder()
      Provide a builder for HttpClient, it can be used to configure advanced HTTP client settings like a redirect handler or a connection handler.

      Example usage: HttpClient client = vertx.httpClientBuilder().with(options).withConnectHandler(conn -> ...).build()

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.HttpClientConfig clientConfig, io.vertx.core.http.PoolOptions poolOptions)
      Create a HTTP/HTTPS client using the specified client and pool options
      Parameters:
      clientConfig - the client config to use
      poolOptions - the pool options to use
      Returns:
      the client

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.HttpClientConfig clientConfig, io.vertx.core.net.ClientSSLOptions sslOptions, io.vertx.core.http.PoolOptions poolOptions)
      Create a HTTP/HTTPS client using the specified client, ssl options and pool options
      Parameters:
      clientConfig - the client config to use
      sslOptions - the ssl options to use
      poolOptions - the pool options to use
      Returns:
      the client

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.HttpClientConfig clientConfig, io.vertx.core.net.ClientSSLOptions sslOptions)
      Create a HTTP/HTTPS client using the specified client and ssl options
      Parameters:
      clientConfig - the client config to use
      sslOptions - the ssl options to use
      Returns:
      the client

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.HttpClientOptions clientOptions, io.vertx.core.http.PoolOptions poolOptions)
      Create a HTTP/HTTPS client using the specified client and pool options
      Parameters:
      clientOptions - the client options to use
      poolOptions - the pool options to use
      Returns:
      the client

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.HttpClientConfig config)
      Create an HTTP/HTTPS client using the specified config
      Parameters:
      config - the config to use
      Returns:
      the server

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.HttpClientOptions clientOptions)
      Create a HTTP/HTTPS client using the specified client options
      Parameters:
      clientOptions - the options to use
      Returns:
      the client

    • createHttpClient

      public HttpClientAgent createHttpClient(io.vertx.core.http.PoolOptions poolOptions)
      Create a HTTP/HTTPS client using the specified pool options
      Parameters:
      poolOptions - the pool options to use
      Returns:
      the client

    • createHttpClient

      public HttpClientAgent createHttpClient()
      Create a HTTP/HTTPS client using default options
      Returns:
      the client

    • createDatagramSocket

      public DatagramSocket createDatagramSocket(io.vertx.core.datagram.DatagramSocketOptions options)
      Create a datagram socket using the specified options
      Parameters:
      options - the options to use
      Returns:
      the socket

    • createDatagramSocket

      public DatagramSocket createDatagramSocket()
      Create a datagram socket using default options
      Returns:
      the socket

    • fileSystem

      public FileSystem fileSystem()
      Get the filesystem object. There is a single instance of FileSystem per Vertx instance.
      Returns:
      the filesystem object

    • eventBus

      public EventBus eventBus()
      Get the event bus object. There is a single instance of EventBus per Vertx instance.
      Returns:
      the event bus object

    • createDnsClient

      public DnsClient createDnsClient(int port, String host)
      Create a DNS client to connect to a DNS server at the specified host and port, with the default query timeout (5 seconds)

      Parameters:
      port - the port
      host - the host
      Returns:
      the DNS client

    • createDnsClient

      public DnsClient createDnsClient()
      Create a DNS client to connect to the DNS server configured by VertxOptions.getAddressResolverOptions()

      DNS client takes the first configured resolver address provided by DnsAddressResolverProvider#nameServerAddresses()}

      Returns:
      the DNS client

    • createDnsClient

      public DnsClient createDnsClient(io.vertx.core.dns.DnsClientOptions options)
      Create a DNS client to connect to a DNS server
      Parameters:
      options - the client options
      Returns:
      the DNS client

    • sharedData

      public SharedData sharedData()
      Get the shared data object. There is a single instance of SharedData per Vertx instance.
      Returns:
      the shared data object

    • timer

      public Timer timer(long delay)
      Like timer(long, TimeUnit) with a unit in millis.

    • timer

      public Timer timer(long delay, TimeUnit unit)
      Create a timer task configured with the specified delay, when the timeout fires the timer future is succeeded, when the timeout is cancelled the timer future is failed with a CancellationException instance.
      Parameters:
      delay - the delay
      unit - the delay unit
      Returns:
      the timer object

    • setTimer

      public long setTimer(long delay, Consumer<Long> handler)
      Set a one-shot timer to fire after delay milliseconds, at which point handler will be called with the id of the timer.
      Parameters:
      delay - the delay in milliseconds, after which the timer will fire
      handler - the handler that will be called with the timer ID when the timer fires
      Returns:
      the unique ID of the timer

    • setPeriodic

      public long setPeriodic(long delay, Consumer<Long> handler)
      Set a periodic timer to fire every delay milliseconds, at which point handler will be called with the id of the timer.
      Parameters:
      delay - the delay in milliseconds, after which the timer will fire
      handler - the handler that will be called with the timer ID when the timer fires
      Returns:
      the unique ID of the timer

    • setPeriodic

      public long setPeriodic(long initialDelay, long delay, Consumer<Long> handler)
      Set a periodic timer to fire every delay milliseconds with initial delay, at which point handler will be called with the id of the timer.
      Parameters:
      initialDelay - the initial delay in milliseconds
      delay - the delay in milliseconds, after which the timer will fire
      handler - the handler that will be called with the timer ID when the timer fires
      Returns:
      the unique ID of the timer

    • cancelTimer

      public boolean cancelTimer(long id)
      Cancels the timer with the specified id.
      Parameters:
      id - The id of the timer to cancel
      Returns:
      true if the timer was successfully cancelled, or false if the timer does not exist.

    • runOnContext

      public void runOnContext(Runnable action)
      Puts the handler on the event queue for the current context so it will be run asynchronously ASAP after all preceeding events have been handled.
      Parameters:
      action - - a handler representing the action to execute

    • deploymentIDs

      public Set<String> deploymentIDs()
      Return a Set of deployment IDs for the currently deployed deploymentIDs.
      Returns:
      Set of deployment IDs

    • registerVerticleFactory

      public void registerVerticleFactory(io.vertx.core.spi.VerticleFactory factory)
      Register a VerticleFactory that can be used for deploying Verticles based on an identifier.
      Parameters:
      factory - the factory to register

    • unregisterVerticleFactory

      public void unregisterVerticleFactory(io.vertx.core.spi.VerticleFactory factory)
      Unregister a VerticleFactory
      Parameters:
      factory - the factory to unregister

    • verticleFactories

      public Set<io.vertx.core.spi.VerticleFactory> verticleFactories()
      Return the Set of currently registered verticle factories.
      Returns:
      the set of verticle factories

    • isClustered

      public boolean isClustered()
      Is this Vert.x instance clustered?
      Returns:
      true if clustered

    • createSharedWorkerExecutor

      public WorkerExecutor createSharedWorkerExecutor(String name)
      Like createSharedWorkerExecutor(String, int) but with the VertxOptions.setWorkerPoolSize(int) poolSize.

    • createSharedWorkerExecutor

      public WorkerExecutor createSharedWorkerExecutor(String name, int poolSize)
      Like createSharedWorkerExecutor(String, int, long) but with the VertxOptions.setMaxWorkerExecuteTime(long) maxExecuteTime.

    • createSharedWorkerExecutor

      public WorkerExecutor createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime)
      Like createSharedWorkerExecutor(String, int, long, TimeUnit) but with the VertxOptions.setMaxWorkerExecuteTimeUnit(TimeUnit) maxExecuteTimeUnit.

    • createSharedWorkerExecutor

      public WorkerExecutor createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime, TimeUnit maxExecuteTimeUnit)
      Create a named worker executor, the executor should be closed when it's not needed anymore to release resources.

      This method can be called mutiple times with the same name. Executors with the same name will share the same worker pool. The worker pool size , max execute time and unit of max execute time are set when the worker pool is created and won't change after.

      The worker pool is released when all the WorkerExecutor sharing the same name are closed.

      Parameters:
      name - the name of the worker executor
      poolSize - the size of the pool
      maxExecuteTime - the value of max worker execute time
      maxExecuteTimeUnit - the value of unit of max worker execute time
      Returns:
      the named worker executor

    • isNativeTransportEnabled

      public boolean isNativeTransportEnabled()
      Returns:
      whether the native transport is used

    • unavailableNativeTransportCause

      public Throwable unavailableNativeTransportCause()
      Returns:
      the error (if any) that cause the unavailability of native transport when isNativeTransportEnabled() returns false.

    • exceptionHandler

      public Vertx exceptionHandler(Consumer<Throwable> handler)
      Set a default exception handler for Context, set on Context#exceptionHandler(Handler) at creation.
      Parameters:
      handler - the exception handler. Can be null.
      Returns:
      a reference to this, so the API can be used fluently

    • isMetricsEnabled

      public boolean isMetricsEnabled()
      Whether the metrics are enabled for this measured object
      Specified by:
      isMetricsEnabled in interface Measured
      Returns:
      true if metrics are enabled

    • newInstance

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

    • 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