Package io.vertx.core

Class VertxOptions

  • public class VertxOptions
extends Object
    Instances of this class are used to configure Vertx instances.
    Author:
    Tim Fox

    • Field Detail

      • DEFAULT_EVENT_LOOP_POOL_SIZE

        public static final int DEFAULT_EVENT_LOOP_POOL_SIZE
        The default number of event loop threads to be used = 2 * number of cores on the machine

      • DEFAULT_WORKER_POOL_SIZE

        public static final int DEFAULT_WORKER_POOL_SIZE
        The default number of threads in the worker pool = 20
        See Also:
        Constant Field Values

      • DEFAULT_INTERNAL_BLOCKING_POOL_SIZE

        public static final int DEFAULT_INTERNAL_BLOCKING_POOL_SIZE
        The default number of threads in the internal blocking pool (used by some internal operations) = 20
        See Also:
        Constant Field Values

      • DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL

        public static final long DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL
        The default value of blocked thread check interval = 1000 ms.

      • DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT

        public static final TimeUnit DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL_UNIT
        The default value of blocked thread check interval unit = TimeUnit.MILLISECONDS

      • DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME

        public static final long DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME
        The default value of max event loop execute time = 2000000000 ns (2 seconds)

      • DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT

        public static final TimeUnit DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME_UNIT
        The default value of max event loop execute time unit = TimeUnit.NANOSECONDS

      • DEFAULT_MAX_WORKER_EXECUTE_TIME

        public static final long DEFAULT_MAX_WORKER_EXECUTE_TIME
        The default value of max worker execute time = 60000000000 ns (60 seconds)

      • DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT

        public static final TimeUnit DEFAULT_MAX_WORKER_EXECUTE_TIME_UNIT
        The default value of max worker execute time unit = TimeUnit.NANOSECONDS

      • DEFAULT_QUORUM_SIZE

        public static final int DEFAULT_QUORUM_SIZE
        The default value of quorum size = 1
        See Also:
        Constant Field Values

      • DEFAULT_HA_GROUP

        public static final String DEFAULT_HA_GROUP
        The default value of Ha group is "__DEFAULT__"
        See Also:
        Constant Field Values

      • DEFAULT_HA_ENABLED

        public static final boolean DEFAULT_HA_ENABLED
        The default value of HA enabled = false
        See Also:
        Constant Field Values

      • DEFAULT_PREFER_NATIVE_TRANSPORT

        public static final boolean DEFAULT_PREFER_NATIVE_TRANSPORT
        The default value for preferring native transport = false
        See Also:
        Constant Field Values

      • DEFAULT_WARNING_EXCEPTION_TIME_UNIT

        public static final TimeUnit DEFAULT_WARNING_EXCEPTION_TIME_UNIT
        The default value of warning exception time unit = TimeUnit.NANOSECONDS

      • DEFAULT_DISABLE_TCCL

        public static final boolean DEFAULT_DISABLE_TCCL
        The default value of thread context classloader disabling = false
        See Also:
        Constant Field Values

      • DEFAULT_USE_DAEMON_THREAD

        public static final boolean DEFAULT_USE_DAEMON_THREAD
        Set default value to false for aligning with the old behavior By default, Vert.x threads are NOT daemons - we want them to prevent JVM exit so embedded user doesn't have to explicitly prevent JVM from exiting.
        See Also:
        Constant Field Values

    • Constructor Detail

      • VertxOptions

        public VertxOptions()
        Default constructor

      • VertxOptions

        public VertxOptions​(VertxOptions other)
        Copy constructor
        Parameters:
        other - The other VertxOptions to copy when creating this

      • VertxOptions

        public VertxOptions​(JsonObject json)
        Create an instance from a JsonObject
        Parameters:
        json - the JsonObject to create it from

    • Method Detail

      • getEventLoopPoolSize

        public int getEventLoopPoolSize()
        Get the number of event loop threads to be used by the Vert.x instance.
        Returns:
        the number of threads

      • setEventLoopPoolSize

        public VertxOptions setEventLoopPoolSize​(int eventLoopPoolSize)
        Set the number of event loop threads to be used by the Vert.x instance.
        Parameters:
        eventLoopPoolSize - the number of threads
        Returns:
        a reference to this, so the API can be used fluently

      • getWorkerPoolSize

        public int getWorkerPoolSize()
        Get the maximum number of worker threads to be used by the Vert.x instance.

        Worker threads are used for running blocking code and worker verticles.

        Returns:
        the maximum number of worker threads

      • setWorkerPoolSize

        public VertxOptions setWorkerPoolSize​(int workerPoolSize)
        Set the maximum number of worker threads to be used by the Vert.x instance.
        Parameters:
        workerPoolSize - the number of threads
        Returns:
        a reference to this, so the API can be used fluently

      • getMaxEventLoopExecuteTime

        public long getMaxEventLoopExecuteTime()
        Get the value of max event loop execute time, in maxEventLoopExecuteTimeUnit.

        Vert.x will automatically log a warning if it detects that event loop threads haven't returned within this time.

        This can be used to detect where the user is blocking an event loop thread, contrary to the Golden Rule of the holy Event Loop.

        The default value of maxEventLoopExecuteTimeUnit is TimeUnit.NANOSECONDS

        Returns:
        the value of max event loop execute time, in maxEventLoopExecuteTimeUnit.

      • getMaxWorkerExecuteTime

        public long getMaxWorkerExecuteTime()
        Get the value of max worker execute time, in maxWorkerExecuteTimeUnit.

        Vert.x will automatically log a warning if it detects that worker threads haven't returned within this time.

        This can be used to detect where the user is blocking a worker thread for too long. Although worker threads can be blocked longer than event loop threads, they shouldn't be blocked for long periods of time.

        The default value of maxWorkerExecuteTimeUnit is TimeUnit.NANOSECONDS

        Returns:
        The value of max worker execute time, in maxWorkerExecuteTimeUnit.

      • getInternalBlockingPoolSize

        public int getInternalBlockingPoolSize()
        Get the value of internal blocking pool size.

        Vert.x maintains a pool for internal blocking operations

        Returns:
        the value of internal blocking pool size

      • setInternalBlockingPoolSize

        public VertxOptions setInternalBlockingPoolSize​(int internalBlockingPoolSize)
        Set the value of internal blocking pool size
        Parameters:
        internalBlockingPoolSize - the maximumn number of threads in the internal blocking pool
        Returns:
        a reference to this, so the API can be used fluently

      • isHAEnabled

        public boolean isHAEnabled()
        Will HA be enabled on the Vert.x instance?
        Returns:
        true if HA enabled, false otherwise

      • setHAEnabled

        public VertxOptions setHAEnabled​(boolean haEnabled)
        Set whether HA will be enabled on the Vert.x instance.
        Parameters:
        haEnabled - true if enabled, false if not.
        Returns:
        a reference to this, so the API can be used fluently

      • getQuorumSize

        public int getQuorumSize()
        Get the quorum size to be used when HA is enabled.
        Returns:
        the quorum size

      • setQuorumSize

        public VertxOptions setQuorumSize​(int quorumSize)
        Set the quorum size to be used when HA is enabled.
        Parameters:
        quorumSize - the quorum size
        Returns:
        a reference to this, so the API can be used fluently

      • getHAGroup

        public String getHAGroup()
        Get the HA group to be used when HA is enabled.
        Returns:
        the HA group

      • setHAGroup

        public VertxOptions setHAGroup​(String haGroup)
        Set the HA group to be used when HA is enabled.
        Parameters:
        haGroup - the HA group to use
        Returns:
        a reference to this, so the API can be used fluently

      • getMetricsOptions

        public MetricsOptions getMetricsOptions()
        Returns:
        the metrics options

      • getFileSystemOptions

        public FileSystemOptions getFileSystemOptions()
        Returns:
        the file system options

      • setMetricsOptions

        public VertxOptions setMetricsOptions​(MetricsOptions metrics)
        Set the metrics options
        Parameters:
        metrics - the options
        Returns:
        a reference to this, so the API can be used fluently

      • setFileSystemOptions

        public VertxOptions setFileSystemOptions​(FileSystemOptions fileSystemOptions)
        Set the file system options
        Parameters:
        fileSystemOptions - the options
        Returns:
        a reference to this, so the API can be used fluently

      • getEventBusOptions

        public EventBusOptions getEventBusOptions()
        Returns:
        the event bus option to configure the event bus communication (host, port, ssl...)

      • setEventBusOptions

        public VertxOptions setEventBusOptions​(EventBusOptions options)
        Sets the event bus configuration to configure the host, port, ssl...
        Parameters:
        options - the event bus options
        Returns:
        a reference to this, so the API can be used fluently

      • getAddressResolverOptions

        public AddressResolverOptions getAddressResolverOptions()
        Returns:
        the address resolver options to configure resolving DNS servers, cache TTL, etc...

      • setAddressResolverOptions

        public VertxOptions setAddressResolverOptions​(AddressResolverOptions addressResolverOptions)
        Sets the address resolver configuration to configure resolving DNS servers, cache TTL, etc...
        Parameters:
        addressResolverOptions - the address resolver options
        Returns:
        a reference to this, so the API can be used fluently

      • getPreferNativeTransport

        public boolean getPreferNativeTransport()
        Returns:
        whether to prefer the native transport to the NIO transport

      • setPreferNativeTransport

        public VertxOptions setPreferNativeTransport​(boolean preferNativeTransport)
        Set whether to prefer the native transport to the NIO transport.
        Parameters:
        preferNativeTransport - true to prefer the native transport
        Returns:
        a reference to this, so the API can be used fluently

      • getMaxEventLoopExecuteTimeUnit

        public TimeUnit getMaxEventLoopExecuteTimeUnit()
        Returns:
        the time unit of maxEventLoopExecuteTime

      • setMaxEventLoopExecuteTimeUnit

        public VertxOptions setMaxEventLoopExecuteTimeUnit​(TimeUnit maxEventLoopExecuteTimeUnit)
        Set the time unit of maxEventLoopExecuteTime.
        Parameters:
        maxEventLoopExecuteTimeUnit - the time unit of maxEventLoopExecuteTime
        Returns:
        a reference to this, so the API can be used fluently

      • getMaxWorkerExecuteTimeUnit

        public TimeUnit getMaxWorkerExecuteTimeUnit()
        Returns:
        the time unit of maxWorkerExecuteTime

      • setMaxWorkerExecuteTimeUnit

        public VertxOptions setMaxWorkerExecuteTimeUnit​(TimeUnit maxWorkerExecuteTimeUnit)
        Set the time unit of maxWorkerExecuteTime.
        Parameters:
        maxWorkerExecuteTimeUnit - the time unit of maxWorkerExecuteTime
        Returns:
        a reference to this, so the API can be used fluently

      • getWarningExceptionTimeUnit

        public TimeUnit getWarningExceptionTimeUnit()
        Returns:
        the time unit of warningExceptionTime

      • setWarningExceptionTimeUnit

        public VertxOptions setWarningExceptionTimeUnit​(TimeUnit warningExceptionTimeUnit)
        Set the time unit of warningExceptionTime.
        Parameters:
        warningExceptionTimeUnit - the time unit of warningExceptionTime
        Returns:
        a reference to this, so the API can be used fluently

      • getBlockedThreadCheckIntervalUnit

        public TimeUnit getBlockedThreadCheckIntervalUnit()
        Returns:
        the time unit of blockedThreadCheckInterval

      • setBlockedThreadCheckIntervalUnit

        public VertxOptions setBlockedThreadCheckIntervalUnit​(TimeUnit blockedThreadCheckIntervalUnit)
        Set the time unit of blockedThreadCheckInterval.
        Parameters:
        blockedThreadCheckIntervalUnit - the time unit of warningExceptionTime
        Returns:
        a reference to this, so the API can be used fluently

      • getTracingOptions

        public TracingOptions getTracingOptions()
        If tracing is disabled, the value will be null.
        Returns:
        the tracing options

      • setTracingOptions

        public VertxOptions setTracingOptions​(TracingOptions tracingOptions)
        Set the tracing options
        Parameters:
        tracingOptions - the options
        Returns:
        a reference to this, so the API can be used fluently

      • getDisableTCCL

        public boolean getDisableTCCL()
        Returns:
        whether Vert.x sets the Context classloader as the thread context classloader on actions executed on that Context

      • setDisableTCCL

        public VertxOptions setDisableTCCL​(boolean disableTCCL)
        Configures whether Vert.x sets the Context classloader as the thread context classloader on actions executed on that Context. When a Context is created the current thread classloader is captured and associated with this classloader. Likewise when a Verticle is created, the Verticle's Context classloader is set to the current thread classloader unless this classloader is overriden by DeploymentOptions.getClassLoader(). This setting overrides the (legacy) system property vertx.disableTCCL and provides control at the Vertx instance level.
        Parameters:
        disableTCCL - true to disable thread context classloader update by Vertx
        Returns:
        a reference to this, so the API can be used fluently

      • getUseDaemonThread

        public Boolean getUseDaemonThread()
        Returns whether we want to use daemon vertx thread.
        Returns:
        true means daemon, false means not daemon(user), null means do not change the daemon option of the created vertx thread.

      • setUseDaemonThread

        public VertxOptions setUseDaemonThread​(Boolean daemon)
        Mark the vertx thread as daemon thread or user thread.

        For keeping the old behavior, the default value is false instead of null.

        Parameters:
        daemon - true means daemon, false means not daemon(user), null means do not change the daemon option of the created vertx thread.