Package io.vertx.rxjava.core

Class 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 Detail

    • Constructor Detail

      • Vertx

        public Vertx​(Vertx delegate)

      • Vertx

        public Vertx​(Object delegate)

    • Method Detail

      • hashCode

        public int hashCode()
        Overrides:
        hashCode in class Object

      • 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 rx.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

        public TimeoutStream timerStream​(long delay)
        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

        public TimeoutStream periodicStream​(long delay)
        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

        public TimeoutStream periodicStream​(long initialDelay,
                                    long delay)
        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

      • 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 rx.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

        public <T> void executeBlocking​(Handler<Promise<T>> blockingCodeHandler,
                                boolean ordered,
                                Handler<AsyncResult<T>> resultHandler)
        Safely execute some blocking code.

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

        When the code is complete the handler resultHandler will be called with the result on the original context (e.g. on the original event loop of the caller).

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

        public <T> void executeBlocking​(Handler<Promise<T>> blockingCodeHandler,
                                boolean ordered)
        Safely execute some blocking code.

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

        When the code is complete the handler resultHandler will be called with the result on the original context (e.g. on the original event loop of the caller).

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

        public <T> rx.Single<T> rxExecuteBlocking​(Handler<Promise<T>> blockingCodeHandler,
                                          boolean ordered)
        Safely execute some blocking code.

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

        When the code is complete the handler resultHandler will be called with the result on the original context (e.g. on the original event loop of the caller).

        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 the 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:

      • 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

      • 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

      • nettyEventLoopGroup

        public io.netty.channel.EventLoopGroup nettyEventLoopGroup()
        Return the Netty EventLoopGroup used by Vert.x
        Returns:
        the EventLoopGroup

      • newInstance

        public static Vertx newInstance​(Vertx arg)