io.vertx.core

## Class VertxOptions

- java.lang.Object
- - io.vertx.core.VertxOptions

-     public class VertxOptions
      extends Object

  Instances of this class are used to configure `Vertx` instances.
  Author:
    Tim Fox

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static long` | `DEFAULT_BLOCKED_THREAD_CHECK_INTERVAL` The default value of blocked thread check interval = 1000 ms.
    `static String` | `DEFAULT_CLUSTER_HOST` The default hostname to use when clustering = "localhost"
    `static long` | `DEFAULT_CLUSTER_PING_INTERVAL` The default value of cluster ping interval = 20000 ms.
    `static long` | `DEFAULT_CLUSTER_PING_REPLY_INTERVAL` The default value of cluster ping reply interval = 20000 ms.
    `static int` | `DEFAULT_CLUSTER_PORT` The default port to use when clustering = 0 (meaning assign a random port)
    `static String` | `DEFAULT_CLUSTER_PUBLIC_HOST` The default cluster public host to use = null which means use the same as the cluster host
    `static int` | `DEFAULT_CLUSTER_PUBLIC_PORT` The default cluster public port to use = -1 which means use the same as the cluster port
    `static boolean` | `DEFAULT_CLUSTERED` The default value of whether Vert.x is clustered = false.
    `static int` | `DEFAULT_EVENT_LOOP_POOL_SIZE` The default number of event loop threads to be used = 2 * number of cores on the machine
    `static boolean` | `DEFAULT_FILE_CACHING_ENABLED` The default value for file resolver caching enabled = the value of the system property "vertx.disableFileCaching" or true
    `static boolean` | `DEFAULT_HA_ENABLED` The default value of HA enabled = false
    `static String` | `DEFAULT_HA_GROUP` The default value of Ha group is "__DEFAULT__"
    `static int` | `DEFAULT_INTERNAL_BLOCKING_POOL_SIZE` The default number of threads in the internal blocking pool (used by some internal operations) = 20
    `static long` | `DEFAULT_MAX_EVENT_LOOP_EXECUTE_TIME` The default value of max event loop execute time = 2000000000 ns (2 seconds)
    `static long` | `DEFAULT_MAX_WORKER_EXECUTE_TIME` The default value of max worker execute time = 60000000000 ns (60 seconds)
    `static int` | `DEFAULT_QUORUM_SIZE` The default value of quorum size = 1
    `static int` | `DEFAULT_WORKER_POOL_SIZE` The default number of threads in the worker pool = 20

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `VertxOptions()` Default constructor
    `VertxOptions(JsonObject json)` Create an instance from a `JsonObject`
    `VertxOptions(VertxOptions other)` Copy constructor

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(Object o)`
    `AddressResolverOptions` | `getAddressResolverOptions()`
    `long` | `getBlockedThreadCheckInterval()` Get the value of blocked thread check period, in ms.
    `String` | `getClusterHost()` Get the host name to be used for clustering.
    `ClusterManager` | `getClusterManager()` Get the cluster manager to be used when clustering.
    `long` | `getClusterPingInterval()` Get the value of cluster ping interval, in ms.
    `long` | `getClusterPingReplyInterval()` Get the value of cluster ping reply interval, in ms.
    `int` | `getClusterPort()` Get the port to be used for clustering
    `String` | `getClusterPublicHost()` Get the public facing hostname to be used when clustering.
    `int` | `getClusterPublicPort()` Get the public facing port to be used when clustering.
    `EventBusOptions` | `getEventBusOptions()`
    `int` | `getEventLoopPoolSize()` Get the number of event loop threads to be used by the Vert.x instance.
    `String` | `getHAGroup()` Get the HA group to be used when HA is enabled.
    `int` | `getInternalBlockingPoolSize()` Get the value of internal blocking pool size.
    `long` | `getMaxEventLoopExecuteTime()` Get the value of max event loop execute time, in ns.
    `long` | `getMaxWorkerExecuteTime()` Get the value of max worker execute time, in ns.
    `MetricsOptions` | `getMetricsOptions()`
    `int` | `getQuorumSize()` Get the quorum size to be used when HA is enabled.
    `long` | `getWarningExceptionTime()` Get the threshold value above this, the blocked warning contains a stack trace.
    `int` | `getWorkerPoolSize()` Get the maximum number of worker threads to be used by the Vert.x instance.
    `int` | `hashCode()`
    `boolean` | `isClustered()` Is the Vert.x instance clustered?
    `boolean` | `isFileResolverCachingEnabled()`
    `boolean` | `isHAEnabled()` Will HA be enabled on the Vert.x instance?
    `VertxOptions` | `setAddressResolverOptions(AddressResolverOptions addressResolverOptions)` Sets the address resolver configuration to configure resolving DNS servers, cache TTL, etc...
    `VertxOptions` | `setBlockedThreadCheckInterval(long blockedThreadCheckInterval)` Sets the value of blocked thread check period, in ms.
    `VertxOptions` | `setClustered(boolean clustered)` Set whether or not the Vert.x instance will be clustered.
    `VertxOptions` | `setClusterHost(String clusterHost)` Set the hostname to be used for clustering.
    `VertxOptions` | `setClusterManager(ClusterManager clusterManager)` Programmatically set the cluster manager to be used when clustering.
    `VertxOptions` | `setClusterPingInterval(long clusterPingInterval)` Set the value of cluster ping interval, in ms.
    `VertxOptions` | `setClusterPingReplyInterval(long clusterPingReplyInterval)` Set the value of cluster ping reply interval, in ms.
    `VertxOptions` | `setClusterPort(int clusterPort)` Set the port to be used for clustering.
    `VertxOptions` | `setClusterPublicHost(String clusterPublicHost)` Set the public facing hostname to be used for clustering.
    `VertxOptions` | `setClusterPublicPort(int clusterPublicPort)` See `setClusterPublicHost(String)` for an explanation.
    `VertxOptions` | `setEventBusOptions(EventBusOptions options)` Sets the event bus configuration to configure the host, port, ssl...
    `VertxOptions` | `setEventLoopPoolSize(int eventLoopPoolSize)` Set the number of event loop threads to be used by the Vert.x instance.
    `VertxOptions` | `setFileResolverCachingEnabled(boolean fileResolverCachingEnabled)` Set wether the Vert.x file resolver uses caching for classpath resources.
    `VertxOptions` | `setHAEnabled(boolean haEnabled)` Set whether HA will be enabled on the Vert.x instance.
    `VertxOptions` | `setHAGroup(String haGroup)` Set the HA group to be used when HA is enabled.
    `VertxOptions` | `setInternalBlockingPoolSize(int internalBlockingPoolSize)` Set the value of internal blocking pool size
    `VertxOptions` | `setMaxEventLoopExecuteTime(long maxEventLoopExecuteTime)` Sets the value of max event loop execute time, in ns.
    `VertxOptions` | `setMaxWorkerExecuteTime(long maxWorkerExecuteTime)` Sets the value of max worker execute time, in ns.
    `VertxOptions` | `setMetricsOptions(MetricsOptions metrics)` Set the metrics options
    `VertxOptions` | `setQuorumSize(int quorumSize)` Set the quorum size to be used when HA is enabled.
    `VertxOptions` | `setWarningExceptionTime(long warningExceptionTime)` Set the threshold value above this, the blocked warning contains a stack trace.
    `VertxOptions` | `setWorkerPoolSize(int workerPoolSize)` Set the maximum number of worker threads to be used by the Vert.x instance.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

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

- - ### 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_CLUSTERED

          public static final boolean DEFAULT_CLUSTERED

      The default value of whether Vert.x is clustered = false.
      See Also:
        Constant Field Values

    - #### DEFAULT_CLUSTER_HOST

          public static final String DEFAULT_CLUSTER_HOST

      The default hostname to use when clustering = "localhost"
      See Also:
        Constant Field Values

    - #### DEFAULT_CLUSTER_PORT

          public static final int DEFAULT_CLUSTER_PORT

      The default port to use when clustering = 0 (meaning assign a random port)
      See Also:
        Constant Field Values

    - #### DEFAULT_CLUSTER_PUBLIC_HOST

          public static final String DEFAULT_CLUSTER_PUBLIC_HOST

      The default cluster public host to use = null which means use the same as the cluster host

    - #### DEFAULT_CLUSTER_PUBLIC_PORT

          public static final int DEFAULT_CLUSTER_PUBLIC_PORT

      The default cluster public port to use = -1 which means use the same as the cluster port
      See Also:
        Constant Field Values

    - #### DEFAULT_CLUSTER_PING_INTERVAL

          public static final long DEFAULT_CLUSTER_PING_INTERVAL

      The default value of cluster ping interval = 20000 ms.
      See Also:
        Constant Field Values

    - #### DEFAULT_CLUSTER_PING_REPLY_INTERVAL

          public static final long DEFAULT_CLUSTER_PING_REPLY_INTERVAL

      The default value of cluster ping reply interval = 20000 ms.
      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.
      See Also:
        Constant Field Values

    - #### 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)
      See Also:
        Constant Field Values

    - #### 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)
      See Also:
        Constant Field Values

    - #### 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_FILE_CACHING_ENABLED

          public static final boolean DEFAULT_FILE_CACHING_ENABLED

      The default value for file resolver caching enabled = the value of the system property "vertx.disableFileCaching" or true

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

    - #### isClustered

          public boolean isClustered()

      Is the Vert.x instance clustered?
      Returns:
        true if clustered, false if not

    - #### setClustered

          public VertxOptions setClustered(boolean clustered)

      Set whether or not the Vert.x instance will be clustered.
      Parameters:
        `clustered` - if true, the Vert.x instance will be clustered, otherwise not
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterHost

          public String getClusterHost()

      Get the host name to be used for clustering.
      Returns:
        The host name

    - #### setClusterHost

          public VertxOptions setClusterHost(String clusterHost)

      Set the hostname to be used for clustering.
      Parameters:
        `clusterHost` - the host name to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterPublicHost

          public String getClusterPublicHost()

      Get the public facing hostname to be used when clustering.
      Returns:
        the public facing hostname

    - #### setClusterPublicHost

          public VertxOptions setClusterPublicHost(String clusterPublicHost)

      Set the public facing hostname to be used for clustering. Sometimes, e.g. when running on certain clouds, the local address the server listens on for clustering is not the same address that other nodes connect to it at, as the OS / cloud infrastructure does some kind of proxying. If this is the case you can specify a public hostname which is different from the hostname the server listens at. The default value is null which means use the same as the cluster hostname.
      Parameters:
        `clusterPublicHost` - the public host name to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterPort

          public int getClusterPort()

      Get the port to be used for clustering
      Returns:
        the port

    - #### setClusterPort

          public VertxOptions setClusterPort(int clusterPort)

      Set the port to be used for clustering.
      Parameters:
        `clusterPort` - the port
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterPublicPort

          public int getClusterPublicPort()

      Get the public facing port to be used when clustering.
      Returns:
        the public facing port

    - #### setClusterPublicPort

          public VertxOptions setClusterPublicPort(int clusterPublicPort)

      See `setClusterPublicHost(String)` for an explanation.
      Parameters:
        `clusterPublicPort` - the public port to use
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterPingInterval

          public long getClusterPingInterval()

      Get the value of cluster ping interval, in ms.

      Nodes in the cluster ping each other at this interval to determine whether they are still running.

      Returns:
        The value of cluster ping interval

    - #### setClusterPingInterval

          public VertxOptions setClusterPingInterval(long clusterPingInterval)

      Set the value of cluster ping interval, in ms.
      Parameters:
        `clusterPingInterval` - The value of cluster ping interval, in ms.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterPingReplyInterval

          public long getClusterPingReplyInterval()

      Get the value of cluster ping reply interval, in ms.

      After sending a ping, if a pong is not received in this time, the node will be considered dead.

      Returns:
        the value of cluster ping reply interval

    - #### setClusterPingReplyInterval

          public VertxOptions setClusterPingReplyInterval(long clusterPingReplyInterval)

      Set the value of cluster ping reply interval, in ms.
      Parameters:
        `clusterPingReplyInterval` - The value of cluster ping reply interval, in ms.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getBlockedThreadCheckInterval

          public long getBlockedThreadCheckInterval()

      Get the value of blocked thread check period, in ms.

      This setting determines how often Vert.x will check whether event loop threads are executing for too long.

      Returns:
        the value of blocked thread check period, in ms.

    - #### setBlockedThreadCheckInterval

          public VertxOptions setBlockedThreadCheckInterval(long blockedThreadCheckInterval)

      Sets the value of blocked thread check period, in ms.
      Parameters:
        `blockedThreadCheckInterval` - the value of blocked thread check period, in ms.
      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 ns.

      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.

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

    - #### setMaxEventLoopExecuteTime

          public VertxOptions setMaxEventLoopExecuteTime(long maxEventLoopExecuteTime)

      Sets the value of max event loop execute time, in ns.
      Parameters:
        `maxEventLoopExecuteTime` - the value of max event loop execute time, in ns.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getMaxWorkerExecuteTime

          public long getMaxWorkerExecuteTime()

      Get the value of max worker execute time, in ns.

      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.

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

    - #### setMaxWorkerExecuteTime

          public VertxOptions setMaxWorkerExecuteTime(long maxWorkerExecuteTime)

      Sets the value of max worker execute time, in ns.
      Parameters:
        `maxWorkerExecuteTime` - the value of max worker execute time, in ns.
      Returns:
        a reference to this, so the API can be used fluently

    - #### getClusterManager

          public ClusterManager getClusterManager()

      Get the cluster manager to be used when clustering.

      If the cluster manager has been programmatically set here, then that will be used when clustering.

      Otherwise Vert.x attempts to locate a cluster manager on the classpath.

      Returns:
        the cluster manager.

    - #### setClusterManager

          public VertxOptions setClusterManager(ClusterManager clusterManager)

      Programmatically set the cluster manager to be used when clustering.

      Only valid if clustered = true.

      Normally Vert.x will look on the classpath for a cluster manager, but if you want to set one programmatically you can use this method.

      Parameters:
        `clusterManager` - the cluster manager
      Returns:
        a reference to this, so the API can be used fluently

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

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

    - #### getWarningExceptionTime

          public long getWarningExceptionTime()

      Get the threshold value above this, the blocked warning contains a stack trace.
      Returns:
        the warning exception time threshold

    - #### setWarningExceptionTime

          public VertxOptions setWarningExceptionTime(long warningExceptionTime)

      Set the threshold value above this, the blocked warning contains a stack trace.
      Parameters:
        `warningExceptionTime` -
      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

    - #### isFileResolverCachingEnabled

          public boolean isFileResolverCachingEnabled()

      Returns:
        wether the file resolver uses caching

    - #### setFileResolverCachingEnabled

          public VertxOptions setFileResolverCachingEnabled(boolean fileResolverCachingEnabled)

      Set wether the Vert.x file resolver uses caching for classpath resources.
      Parameters:
        `fileResolverCachingEnabled` - true when the file resolver caches resources
      Returns:
        a reference to this, so the API can be used fluently

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

Copyright © 2017. All rights reserved.