io.vertx.rxjava.core

Class Vertx

java.lang.Object

io.vertx.rxjava.core.Vertx

All Implemented Interfaces:

Measured

public class Vertx
extends Object
implements Measured

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() and clusteredVertx(io.vertx.core.VertxOptions, io.vertx.core.Handler<io.vertx.core.AsyncResult<io.vertx.rxjava.core.Vertx>>).

Please see the user manual for more detailed usage information.

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

Field Summary

Fields

Modifier and Type	Field and Description
static io.vertx.lang.rx.TypeArg<Vertx>	__TYPE_ARG

Constructor Summary

Constructors

Constructor and Description
Vertx(Object delegate)
Vertx(Vertx delegate)

Method Summary

Modifier and Type	Method and Description
boolean	cancelTimer(long id) Cancels the timer with the specified id.
void	close() Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete
void	close(Handler<AsyncResult<Void>> completionHandler) Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete
static void	clusteredVertx(VertxOptions options) Creates a clustered instance using the specified options.
static void	clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler) Creates a clustered instance using the specified options.
DatagramSocket	createDatagramSocket() Create a datagram socket using default options
DatagramSocket	createDatagramSocket(DatagramSocketOptions options) Create a datagram socket using the specified options
DnsClient	createDnsClient() Create a DNS client to connect to the DNS server configured by VertxOptions
DnsClient	createDnsClient(DnsClientOptions options) Create a DNS client to connect to a DNS server
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)
HttpClient	createHttpClient() Create a HTTP/HTTPS client using default options
HttpClient	createHttpClient(HttpClientOptions options) Create a HTTP/HTTPS client using the specified options
HttpServer	createHttpServer() Create an HTTP/HTTPS server using default options
HttpServer	createHttpServer(HttpServerOptions options) Create an HTTP/HTTPS server using the specified options
NetClient	createNetClient() Create a TCP/SSL client using default options
NetClient	createNetClient(NetClientOptions options) Create a TCP/SSL client using the specified options
NetServer	createNetServer() Create a TCP/SSL server using default options
NetServer	createNetServer(NetServerOptions options) Create a TCP/SSL server using the specified options
WorkerExecutor	createSharedWorkerExecutor(String name) Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions poolSize.
WorkerExecutor	createSharedWorkerExecutor(String name, int poolSize) Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions maxExecuteTime.
WorkerExecutor	createSharedWorkerExecutor(String name, int poolSize, long maxExecuteTime) Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions maxExecuteTimeUnit.
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.
static Context	currentContext() Gets the current context
Set<String>	deploymentIDs() Return a Set of deployment IDs for the currently deployed deploymentIDs.
void	deployVerticle(String name) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
void	deployVerticle(String name, DeploymentOptions options) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
void	deployVerticle(String name, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
void	deployVerticle(String name, Handler<AsyncResult<String>> completionHandler) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
void	deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.
void	deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.
void	deployVerticle(Verticle verticle) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
void	deployVerticle(Verticle verticle, DeploymentOptions options) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
void	deployVerticle(Verticle verticle, DeploymentOptions options, Handler<AsyncResult<String>> completionHandler) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
void	deployVerticle(Verticle verticle, Handler<AsyncResult<String>> completionHandler) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
boolean	equals(Object o)
EventBus	eventBus() Get the event bus object.
Vertx	exceptionHandler(Handler<Throwable> handler) Set a default exception handler for Context, set on Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>) at creation.
<T> Future<T>	executeBlocking(Callable<T> blockingCodeHandler) Like executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.
<T> Future<T>	executeBlocking(Callable<T> blockingCodeHandler, boolean ordered) Safely execute some blocking code.
<T> void	executeBlocking(Handler<Promise<T>> blockingCodeHandler) Deprecated.
<T> void	executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered) Deprecated.
<T> void	executeBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered, Handler<AsyncResult<T>> resultHandler) Deprecated.
<T> void	executeBlocking(Handler<Promise<T>> blockingCodeHandler, Handler<AsyncResult<T>> resultHandler) Deprecated.
FileSystem	fileSystem() Get the filesystem object.
Vertx	getDelegate()
Context	getOrCreateContext() Gets the current context, or creates one if there isn't one
int	hashCode()
boolean	isClustered() Is this Vert.x instance clustered?
boolean	isMetricsEnabled() Whether the metrics are enabled for this measured object
boolean	isNativeTransportEnabled()
EventLoopGroup	nettyEventLoopGroup() Deprecated.
static Vertx	newInstance(Vertx arg)
TimeoutStream	periodicStream(long delay) Deprecated.
TimeoutStream	periodicStream(long initialDelay, long delay) Deprecated.
void	registerVerticleFactory(VerticleFactory factory) Register a VerticleFactory that can be used for deploying Verticles based on an identifier.
void	runOnContext(Handler<Void> 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.
Single<Void>	rxClose() Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete
static Single<Vertx>	rxClusteredVertx(VertxOptions options) Creates a clustered instance using the specified options.
Single<String>	rxDeployVerticle(String name) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
Single<String>	rxDeployVerticle(String name, DeploymentOptions options) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
Single<String>	rxDeployVerticle(java.util.function.Supplier<Verticle> verticleSupplier, DeploymentOptions options) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.
Single<String>	rxDeployVerticle(Verticle verticle) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.
Single<String>	rxDeployVerticle(Verticle verticle, DeploymentOptions options) Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.
<T> Single<T>	rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler) Deprecated.
<T> Single<T>	rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler, boolean ordered) Deprecated.
Single<Void>	rxUndeploy(String deploymentID) Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.
long	setPeriodic(long delay, Handler<Long> handler) Set a periodic timer to fire every delay milliseconds, at which point handler will be called with the id of the timer.
long	setPeriodic(long initialDelay, long delay, Handler<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.
long	setTimer(long delay, Handler<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.
SharedData	sharedData() Get the shared data object.
TimeoutStream	timerStream(long delay) Deprecated.
String	toString()
Throwable	unavailableNativeTransportCause()
void	undeploy(String deploymentID) Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.
void	undeploy(String deploymentID, Handler<AsyncResult<Void>> completionHandler) Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.
void	unregisterVerticleFactory(VerticleFactory factory) Unregister a VerticleFactory
Set<VerticleFactory>	verticleFactories() Return the Set of currently registered verticle factories.
static Vertx	vertx() Creates a non clustered instance using default options.
static Vertx	vertx(VertxOptions options) Creates a non clustered instance using the specified options

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.vertx.rxjava.core.metrics.Measured

newInstance

Field Detail

__TYPE_ARG

public static final io.vertx.lang.rx.TypeArg<Vertx> __TYPE_ARG

Constructor Detail

Vertx

public Vertx(Vertx delegate)

Vertx

public Vertx(Object delegate)

Method Detail

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

getDelegate

public Vertx getDelegate()

Specified by:

getDelegate in interface Measured

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

vertx

public static Vertx vertx()

Creates a non clustered instance using default options.

Returns:

the instance

vertx

public static Vertx vertx(VertxOptions options)

Creates a non clustered instance using the specified options

Parameters:

options - the options to use

Returns:

the instance

clusteredVertx

public static void clusteredVertx(VertxOptions options,
                                  Handler<AsyncResult<Vertx>> resultHandler)

Creates a clustered instance using the specified options.

The instance is created asynchronously and the resultHandler is called with the result when it is ready.

Parameters:

options - the options to use

resultHandler - the result handler that will receive the result

clusteredVertx

public static void clusteredVertx(VertxOptions options)

Creates a clustered instance using the specified options.

The instance is created asynchronously and the resultHandler is called with the result when it is ready.

Parameters:

options - the options to use

rxClusteredVertx

public static Single<Vertx> rxClusteredVertx(VertxOptions options)

Creates a clustered instance using the specified options.

The instance is created asynchronously and the resultHandler is called with the result when it is ready.

Parameters:

options - the options to use

Returns:

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(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(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

createHttpServer

public HttpServer createHttpServer(HttpServerOptions options)

Create an HTTP/HTTPS server using the specified options

Parameters:

options - the options to use

Returns:

the server

createHttpServer

public HttpServer createHttpServer()

Create an HTTP/HTTPS server using default options

Returns:

the server

createHttpClient

public HttpClient createHttpClient(HttpClientOptions options)

Create a HTTP/HTTPS client using the specified options

Parameters:

options - the options to use

Returns:

the client

createHttpClient

public HttpClient createHttpClient()

Create a HTTP/HTTPS client using default options

Returns:

the client

createDatagramSocket

public DatagramSocket createDatagramSocket(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

DNS client takes the first configured resolver address provided by }

Returns:

the DNS client

createDnsClient

public DnsClient createDnsClient(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

setTimer

public long setTimer(long delay,
                     Handler<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

timerStream

@Deprecated
public TimeoutStream timerStream(long delay)

Deprecated.

Returns a one-shot timer as a read stream. The timer will be fired after delay milliseconds after the has been called.

Parameters:

delay - the delay in milliseconds, after which the timer will fire

Returns:

the timer stream

setPeriodic

public long setPeriodic(long delay,
                        Handler<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,
                        Handler<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

periodicStream

@Deprecated
public TimeoutStream periodicStream(long delay)

Deprecated.

Returns a periodic timer as a read stream. The timer will be fired every delay milliseconds after the has been called.

Parameters:

delay - the delay in milliseconds, after which the timer will fire

Returns:

the periodic stream

periodicStream

@Deprecated
public TimeoutStream periodicStream(long initialDelay,
                                                long delay)

Deprecated.

Returns a periodic timer as a read stream. The timer will be fired every delay milliseconds after the has been called.

Parameters:

initialDelay - the initial delay in milliseconds

delay - the delay in milliseconds, after which the timer will fire

Returns:

the periodic stream

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(Handler<Void> 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

close

public void close(Handler<AsyncResult<Void>> completionHandler)

Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete

Parameters:

completionHandler - The handler will be notified when the close is complete.

close

public void close()

Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete

rxClose

public Single<Void> rxClose()

Like close(io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.Void>>) but the completionHandler will be called when the close is complete

Returns:

deployVerticle

public void deployVerticle(String name,
                           Handler<AsyncResult<String>> completionHandler)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.

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.

Parameters:

name - The identifier

completionHandler - a handler which will be notified when the deployment is complete

deployVerticle

public void deployVerticle(String name)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.

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.

Parameters:

name - The identifier

rxDeployVerticle

public Single<String> rxDeployVerticle(String name)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.

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.

Parameters:

name - The identifier

Returns:

deployVerticle

public void deployVerticle(String name,
                           DeploymentOptions options,
                           Handler<AsyncResult<String>> completionHandler)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.

Parameters:

name - the name

options - the deployment options.

completionHandler - a handler which will be notified when the deployment is complete

deployVerticle

public void deployVerticle(String name,
                           DeploymentOptions options)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.

Parameters:

name - the name

options - the deployment options.

rxDeployVerticle

public Single<String> rxDeployVerticle(String name,
                                       DeploymentOptions options)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.

Parameters:

name - the name

options - the deployment options.

Returns:

undeploy

public void undeploy(String deploymentID,
                     Handler<AsyncResult<Void>> completionHandler)

Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.

Parameters:

deploymentID - the deployment ID

completionHandler - a handler which will be notified when the undeployment is complete

undeploy

public void undeploy(String deploymentID)

Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.

Parameters:

deploymentID - the deployment ID

rxUndeploy

public Single<Void> rxUndeploy(String deploymentID)

Like #undeploy(String) but the completionHandler will be notified when the undeployment is complete.

Parameters:

deploymentID - the deployment ID

Returns:

deploymentIDs

public Set<String> deploymentIDs()

Return a Set of deployment IDs for the currently deployed deploymentIDs.

Returns:

Set of deployment IDs

isClustered

public boolean isClustered()

Is this Vert.x instance clustered?

Returns:

true if clustered

executeBlocking

@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                            boolean ordered,
                                            Handler<AsyncResult<T>> resultHandler)

Deprecated.

Safely execute some blocking code.

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

The returned future 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.

A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(T) method, or the Promise.fail(java.lang.Throwable) method if it failed.

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(io.vertx.core.Handler<java.lang.Void>)

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

resultHandler - handler that will be called when the blocking code is complete

executeBlocking

@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                            boolean ordered)

Deprecated.

Safely execute some blocking code.

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

The returned future 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.

A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(T) method, or the Promise.fail(java.lang.Throwable) method if it failed.

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(io.vertx.core.Handler<java.lang.Void>)

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

rxExecuteBlocking

@Deprecated
public <T> Single<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler,
                                                   boolean ordered)

Deprecated.

Safely execute some blocking code.

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

The returned future 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.

A Future instance is passed into blockingCodeHandler. When the blocking code successfully completes, the handler should call the Promise.complete(T) or Promise.complete(T) method, or the Promise.fail(java.lang.Throwable) method if it failed.

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(io.vertx.core.Handler<java.lang.Void>)

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:

executeBlocking

@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler,
                                            Handler<AsyncResult<T>> resultHandler)

Deprecated.

Like executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.

Parameters:

blockingCodeHandler -

resultHandler -

executeBlocking

@Deprecated
public <T> void executeBlocking(Handler<Promise<T>> blockingCodeHandler)

Deprecated.

Like executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.

Parameters:

blockingCodeHandler -

rxExecuteBlocking

@Deprecated
public <T> Single<T> rxExecuteBlocking(Handler<Promise<T>> blockingCodeHandler)

Deprecated.

Like executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.

Parameters:

blockingCodeHandler -

Returns:

createSharedWorkerExecutor

public WorkerExecutor createSharedWorkerExecutor(String name)

Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions poolSize.

Parameters:

name -

Returns:

createSharedWorkerExecutor

public WorkerExecutor createSharedWorkerExecutor(String name,
                                                 int poolSize)

Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions maxExecuteTime.

Parameters:

name -

poolSize -

Returns:

createSharedWorkerExecutor

public WorkerExecutor createSharedWorkerExecutor(String name,
                                                 int poolSize,
                                                 long maxExecuteTime)

Like createSharedWorkerExecutor(java.lang.String) but with the VertxOptions maxExecuteTimeUnit.

Parameters:

name -

poolSize -

maxExecuteTime -

Returns:

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(Handler<Throwable> handler)

Set a default exception handler for Context, set on Context.exceptionHandler(io.vertx.core.Handler<java.lang.Throwable>) at creation.

Parameters:

handler - the exception handler

Returns:

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

deployVerticle

public void deployVerticle(Verticle verticle,
                           Handler<AsyncResult<String>> completionHandler)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.

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.

Parameters:

verticle - the verticle instance to deploy

completionHandler - a handler which will be notified when the deployment is complete

deployVerticle

public void deployVerticle(Verticle verticle)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.

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.

Parameters:

verticle - the verticle instance to deploy

rxDeployVerticle

public Single<String> rxDeployVerticle(Verticle verticle)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but the completionHandler will be notified when the deployment is complete.

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.

Parameters:

verticle - the verticle instance to deploy

Returns:

deployVerticle

public void deployVerticle(Verticle verticle,
                           DeploymentOptions options,
                           Handler<AsyncResult<String>> completionHandler)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.

Parameters:

verticle - the verticle instance to deploy

options - the deployment options.

completionHandler - a handler which will be notified when the deployment is complete

deployVerticle

public void deployVerticle(Verticle verticle,
                           DeploymentOptions options)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.

Parameters:

verticle - the verticle instance to deploy

options - the deployment options.

rxDeployVerticle

public Single<String> rxDeployVerticle(Verticle verticle,
                                       DeploymentOptions options)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but DeploymentOptions are provided to configure the deployment.

Parameters:

verticle - the verticle instance to deploy

options - the deployment options.

Returns:

deployVerticle

public void deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                           DeploymentOptions options,
                           Handler<AsyncResult<String>> completionHandler)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.

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

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

Parameters:

verticleSupplier -

options -

completionHandler -

deployVerticle

public void deployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                           DeploymentOptions options)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.

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

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

Parameters:

verticleSupplier -

options -

rxDeployVerticle

public Single<String> rxDeployVerticle(java.util.function.Supplier<Verticle> verticleSupplier,
                                       DeploymentOptions options)

Like deployVerticle(java.lang.String, io.vertx.core.Handler<io.vertx.core.AsyncResult<java.lang.String>>) but Verticle instance is created by invoking the verticleSupplier.

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

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

Parameters:

verticleSupplier -

options -

Returns:

registerVerticleFactory

public void registerVerticleFactory(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(VerticleFactory factory)

Unregister a VerticleFactory

Parameters:

factory - the factory to unregister

verticleFactories

public Set<VerticleFactory> verticleFactories()

Return the Set of currently registered verticle factories.

Returns:

the set of verticle factories

executeBlocking

public <T> Future<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 future 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(io.vertx.core.Handler<java.lang.Void>)

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 future completed when the blocking code is complete

executeBlocking

public <T> Future<T> executeBlocking(Callable<T> blockingCodeHandler)

Like executeBlocking(io.vertx.core.Handler<io.vertx.rxjava.core.Promise<T>>, boolean, io.vertx.core.Handler<io.vertx.core.AsyncResult<T>>) called with ordered = true.

Parameters:

blockingCodeHandler -

Returns:

nettyEventLoopGroup

@Deprecated
public EventLoopGroup nettyEventLoopGroup()

Deprecated.

Return the Netty EventLoopGroup used by Vert.x

Returns:

the EventLoopGroup

newInstance

public static Vertx newInstance(Vertx arg)