driver.template.conf

####################################################################################################
# Java Driver configuration for DSBulk.
#
# The settings below are just a subset of all the configurable options of the driver, and provide
# an optimal driver configuration for DSBulk for most use cases. See the Java Driver configuration
# reference for instructions on how to configure the driver properly:
# https://docs.datastax.com/en/developer/java-driver/latest/
# https://docs.datastax.com/en/developer/java-driver-dse/latest/
#
# This file is written in HOCON format; see
# https://github.com/typesafehub/config/blob/master/HOCON.md
# for more information on its syntax.
#
# This file is not meant as the main configuration file for DSBulk, but rather to be included from
# the main configuration file. We recommend that this file be named driver.conf and placed in the
# /conf directory, alongside with another configuration file for DSBulk itself, named
# application.conf. Also, for this setup to work, application.conf should include driver.conf, for
# example by using an import directive. For other ways to configure this tool, refer to DataStax
# Bulk Loader online documentation:
# https://docs.datastax.com/en/dsbulk/doc/dsbulk/dsbulkRef.html
####################################################################################################

datastax-java-driver {

    # Basic options.
    basic {

        # The driver session name. DSBulk simply calls it "driver". The session name is printed by
        # all driver log messages, between square brackets.
        # Type: string
        # Default value: "driver"
        #session-name = "driver"

        # The contact points to use for the initial connection to the cluster.
        # 
        # These are addresses of Cassandra nodes that the driver uses to discover the cluster
        # topology. Only one contact point is required (the driver will retrieve the address of the
        # other nodes automatically), but it is usually a good idea to provide more than one contact
        # point, because if that single contact point is unavailable, the driver cannot initialize
        # itself correctly.
        # 
        # This must be a list of strings with each contact point specified as "host" or "host:port".
        # If the specified host doesn't have a port, the default port specified in
        # `basic.default-port` will be used. Note that Cassandra 3 and below and DSE 6.7 and below
        # require all nodes in a cluster to share the same port (see CASSANDRA-7544).
        # 
        # Valid examples of contact points are:
        # - IPv4 addresses with ports: `[ "192.168.0.1:9042", "192.168.0.2:9042" ]`
        # - IPv4 addresses without ports: `[ "192.168.0.1", "192.168.0.2" ]`
        # - IPv6 addresses with ports: `[ "fe80:0:0:0:f861:3eff:fe1d:9d7b:9042",
        # "fe80:0:0:f861:3eff:fe1d:9d7b:9044:9042" ]`
        # - IPv6 addresses without ports: `[ "fe80:0:0:0:f861:3eff:fe1d:9d7b",
        # "fe80:0:0:f861:3eff:fe1d:9d7b:9044" ]`
        # - Host names with ports: `[ "host1.com:9042", "host2.com:9042" ]`
        # - Host names without ports: `[ "host1.com", "host2.com:" ]`
        # 
        # If the host is a DNS name that resolves to multiple A-records, all the corresponding
        # addresses will be used. Avoid using "localhost" as the host name (since it resolves to
        # both IPv4 and IPv6 addresses on some platforms).
        # 
        # The heuristic to determine whether or not a contact point is in the form "host" or
        # "host:port" is not 100% accurate for some IPv6 addresses; you should avoid ambiguous IPv6
        # addresses such as `fe80::f861:3eff:fe1d:1234`, because such a string can be seen either as
        # a combination of IP `fe80::f861:3eff:fe1d` with port 1234, or as IP
        # `fe80::f861:3eff:fe1d:1234` without port. In such cases, DSBulk will not change the
        # contact point. This issue can be avoided by providing IPv6 addresses in full form, e.g. if
        # instead of `fe80::f861:3eff:fe1d:1234` you provide `fe80:0:0:0:0:f861:3eff:fe1d:1234`,
        # then the string is unequivocally parsed as IP `fe80:0:0:0:0:f861:3eff:fe1d` with port
        # 1234.
        # 
        # Note: on Cloud deployments, DSBulk automatically sets this option to an empty list, as
        # contact points are not allowed to be explicitly provided when connecting to DataStax Astra
        # databases.
        # Type: list<string>
        # Default value: ["127.0.0.1:9042"]
        #contact-points = ["127.0.0.1:9042"]

        # The default port to use for `basic.contact-points`, when a host is specified without port.
        # Note that Cassandra 3 and below and DSE 6.7 and below require all nodes in a cluster to
        # share the same port (see CASSANDRA-7544). If this setting is not specified, the default
        # port will be 9042.
        # Type: number
        # Default value: 9042
        #default-port = 9042

        # Options for connection to a DataStax Astra database.
        cloud {

            # The location of the secure bundle used to connect to a Datastax Astra database. This
            # setting must be a path on the local filesystem or a valid URL.
            # 
            # Examples:
            # 
            # "/path/to/bundle.zip"          # path on *Nix systems
            # "./path/to/bundle.zip"         # path on *Nix systems, relative to workding directory
            # "~/path/to/bundle.zip"         # path on *Nix systems, relative to home directory
            # "C:\\path\\to\\bundle.zip"     # path on Windows systems,
            # # note that you need to escape backslashes in HOCON
            # "file:/a/path/to/bundle.zip"   # URL with file protocol
            # "http://host.com/bundle.zip"   # URL with HTTP protocol
            # 
            # Note: if you set this to a non-null value, DSBulk assumes that you are connecting to
            # an DataStax Astra database; in this case, you should not set any of the following
            # settings because they are not compatible with Cloud deployments:
            # 
            # - `datastax-java-driver.basic.contact-points`
            # - `datastax-java-driver.basic.request.consistency`
            # - `datastax-java-driver.advanced.ssl-engine-factory.*`
            # 
            # If you do so, a log will be emitted and the setting will be ignored.
            # Type: string
            # Default value: null
            #secure-connect-bundle = null

        }

        request {

            # How long the driver waits for a request to complete. This is a global limit on the
            # duration of a session.execute() call, including any internal retries the driver might
            # do. By default, this value is set very high because DSBulk is optimized for good
            # throughput, rather than good latencies.
            # Type: string
            # Default value: "5 minutes"
            #timeout = "5 minutes"

            # The consistency level to use for all queries. Note that stronger consistency levels
            # usually result in reduced throughput. In addition, any level higher than `ONE` will
            # automatically disable continuous paging, which can dramatically reduce read
            # throughput.
            # 
            # Valid values are: `ANY`, `LOCAL_ONE`, `ONE`, `TWO`, `THREE`, `LOCAL_QUORUM`, `QUORUM`,
            # `EACH_QUORUM`, `ALL`.
            # 
            # Note: on Cloud deployments, the only accepted consistency level when writing is
            # `LOCAL_QUORUM`. Therefore, the default value is `LOCAL_ONE`, except when loading in
            # Cloud deployments, in which case the default is automatically changed to
            # `LOCAL_QUORUM`.
            # Type: string
            # Default value: "LOCAL_ONE"
            #consistency = "LOCAL_ONE"

            # The serial consistency level. The allowed values are `SERIAL` and `LOCAL_SERIAL`.
            # Type: string
            # Default value: "LOCAL_SERIAL"
            #serial-consistency = "LOCAL_SERIAL"

            # The default idempotence for all queries executed in DSBulk. Setting this to false will
            # cause all write failures to not be retried.
            # Type: boolean
            # Default value: true
            #default-idempotence = true

            # The page size. This controls how many rows will be retrieved simultaneously in a
            # single network roundtrip (the goal being to avoid loading too many results in memory
            # at the same time). If there are more results, additional requests will be used to
            # retrieve them (either automatically if you iterate with the sync API, or explicitly
            # with the async API's `fetchNextPage` method). If the value is 0 or negative, it will
            # be ignored and the request will not be paged.
            # Type: number
            # Default value: 5000
            #page-size = 5000

        }

        # The load balancing policy decides the "query plan" for each query; that is, which nodes to
        # try as coordinators, and in which order.
        load-balancing-policy {

            # The load balancing policy class to use. If it is not qualified, the driver assumes
            # that it resides in the package `com.datastax.oss.driver.internal.core.loadbalancing`.
            # 
            # DSBulk uses a special policy that infers the local datacenter from the contact points.
            # You can also specify a custom class that implements `LoadBalancingPolicy` and has a
            # public constructor with two arguments: the `DriverContext` and a `String` representing
            # the profile name.
            # Type: string
            # Default value: "com.datastax.oss.driver.internal.core.loadbalancing.DcInferringLoadBalancingPolicy"
            #class = "com.datastax.oss.driver.internal.core.loadbalancing.DcInferringLoadBalancingPolicy"

            # The datacenter that is considered "local": the default load balancing policy will only
            # include nodes from this datacenter in its query plans. Set this to a non-null value if
            # you want to force the local datacenter; otherwise, the
            # `DcInferringLoadBalancingPolicy` used by default by DSBulk will infer the local
            # datacenter from the provided contact points.
            # Type: string
            # Default value: null
            #local-datacenter = null

            evaluator {

                # An optional custom filter to include/exclude nodes. If present, it must be the
                # fully-qualified name of a class that implements
                # `java.util.function.Predicate<Node>`, and has a public constructor taking two
                # arguments: a `DriverContext` instance and a String representing the current
                # execution profile name.
                # 
                # The predicate's `test(Node)` method will be invoked each time the policy processes
                # a topology or state change: if it returns false, the node will be set at distance
                # `IGNORED` (meaning the driver won't ever connect to it), and never included in any
                # query plan.
                # 
                # By default, DSBulk ships with a node filter implementation that honors the
                # following settings:
                # - `datastax-java-driver.basic.load-balancing-policy.evaluator.allow`: a list of
                # host names or host addresses that should be allowed.
                # - `datastax-java-driver.basic.load-balancing-policy.evaluator.deny`: a list of
                # host names or host addresses that should be denied.
                # 
                # See the description of the above settings for more details.
                # Type: string
                # Default value: "com.datastax.oss.dsbulk.workflow.commons.policies.lbp.SimpleNodeDistanceEvaluator"
                #class = "com.datastax.oss.dsbulk.workflow.commons.policies.lbp.SimpleNodeDistanceEvaluator"

                # An optional list of host names or host addresses that should be allowed to
                # connect. See `datastax-java-driver.basic.contact-points` for a full description of
                # accepted formats.
                # 
                # This option only has effect when the setting
                # `datastax-java-driver.basic.load-balancing-policy.evaluator.class` refers to
                # DSBulk's default node filter implementation:
                # `com.datastax.oss.dsbulk.workflow.commons.policies.lbp.SimpleNodeDistanceEvaluator`.
                # 
                # Note: this option is not compatible with DataStax Astra databases.
                # Type: list<string>
                # Default value: []
                #allow = []

                # An optional list of host names or host addresses that should be denied to connect.
                # See `datastax-java-driver.basic.contact-points` for a full description of accepted
                # formats.
                # 
                # This option only has effect when the setting
                # `datastax-java-driver.basic.load-balancing-policy.evaluator.class` refers to
                # DSBulk's default node filter implementation:
                # `com.datastax.oss.dsbulk.workflow.commons.policies.lbp.SimpleNodeDistanceEvaluator`.
                # 
                # Note: this option is not compatible with DataStax Astra databases.
                # Type: list<string>
                # Default value: []
                #deny = []

            }

        }

    }

    # Advanced options.
    advanced {

        protocol {

            # The native protocol version to use. If this option is absent, the driver looks up the
            # versions of the nodes at startup (by default in `system.peers.release_version`), and
            # chooses the highest common protocol version. For example, if you have a mixed cluster
            # with Apache Cassandra 2.1 nodes (protocol v3) and Apache Cassandra 3.0 nodes (protocol
            # v3 and v4), then protocol v3 is chosen. If the nodes don't have a common protocol
            # version, initialization fails. If this option is set, then the given version will be
            # used for all connections, without any negotiation or downgrading. If any of the
            # contact points doesn't support it, that contact point will be skipped. Once the
            # protocol version is set, it can't change for the rest of the driver's lifetime; if an
            # incompatible node joins the cluster later, connection will fail and the driver will
            # force it down (i.e. never try to connect to it again).
            # Type: string
            # Default value: null
            #version = null

            # The name of the algorithm used to compress protocol frames. The possible values are:
            # `lz4`, `snappy` or `none` to indicate no compression (this is functionally equivalent
            # to omitting the option).
            # Type: string
            # Default value: "none"
            #compression = "none"

        }

        connection {

            # The timeout to use when establishing driver connections. This timeout is for
            # controlling how long the driver will wait for the underlying channel to actually
            # connect to the server. This is not the time limit for completing protocol
            # negotiations, only the time limit for establishing a channel connection.
            # Type: string
            # Default value: "30 seconds"
            #connect-timeout = "30 seconds"

            # The timeout to use for internal queries that run as part of the initialization
            # process, just after we open a connection. If this timeout fires, the initialization of
            # the connection will fail. If this is the first connection ever, the driver will fail
            # to initialize as well, otherwise it will retry the connection later.
            # Type: string
            # Default value: "30 seconds"
            #init-query-timeout = "30 seconds"

            # The driver maintains a connection pool to each node, according to the distance
            # assigned to it by the load balancing policy. If the distance is IGNORED, no
            # connections are maintained.
            pool {

                local {

                    # The number of connections in the pool for nodes considered as local.
                    # Type: number
                    # Default value: 8
                    #size = 8

                }

                remote {

                    # The number of connections in the pool for nodes considered as remote. Note
                    # that the default load balancing policy used by DSBulk never considers remote
                    # nodes, so this setting has no effect when using the default load balancing
                    # policy.
                    # Type: number
                    # Default value: 8
                    #size = 8

                }

            }

            # The maximum number of requests that can be executed concurrently on a connection. This
            # must be between 1 and 32768.
            # Type: number
            # Default value: 32768
            #max-requests-per-connection = 32768

        }

        # The component that handles authentication on each new connection.
        auth-provider {

            # The class of the authentication provider. If it is not qualified, the driver assumes
            # that it resides in one of the following packages:
            # - `com.datastax.oss.driver.internal.core.auth`
            # - `com.datastax.dse.driver.internal.core.auth`
            # 
            # The DSE driver provides 3 implementations out of the box:
            # - `PlainTextAuthProvider`: uses plain-text credentials. It requires the `username` and
            # `password` options, and optionally, an `authorization-id` (for DSE clusters only).
            # - `DseGssApiAuthProvider`: provides GSSAPI authentication for DSE clusters secured
            # with `DseAuthenticator`. Read the javadocs of this authenticator for detailed
            # instructions.
            # 
            # You can also specify a custom class that implements `AuthProvider` and has a public
            # constructor with a `DriverContext` argument (to simplify this, the driver provides two
            # abstract classes that can be extended: `PlainTextAuthProviderBase` and
            # `DseGssApiAuthProviderBase`).
            # Type: arg
            # Default value: null
            #class = null

            # The username to use to authenticate against a cluster with authentication enabled.
            # Providers that accept this setting:
            # 
            # - `PlainTextAuthProvider`
            # 
            # Type: string
            # Default value: null
            #username = null

            # The password to use to authenticate against a cluster with authentication enabled.
            # Providers that accept this setting:
            # 
            # - `PlainTextAuthProvider`
            # 
            # Type: string
            # Default value: null
            #password = null

            # An authorization ID allows the currently authenticated user to act as a different user
            # (proxy authentication). Providers that accept this setting:
            # 
            # - `DsePlainTextAuthProvider`
            # - `DseGssApiAuthProvider`
            # 
            # Type: string
            # Default value: null
            #authorization-id = null

        }

        # The SSL engine factory that will initialize an SSL engine for each new connection to a
        # server.
        ssl-engine-factory {

            # The class of the SSL engine factory. If it is not qualified, the driver assumes that
            # it resides in the package `com.datastax.oss.driver.internal.core.ssl`. The driver
            # provides a single implementation out of the box: `DefaultSslEngineFactory`, that uses
            # the JDK's built-in SSL implementation.
            # 
            # You can also specify a custom class that implements `SslEngineFactory` and has a
            # public constructor with a `DriverContext` argument.
            # Type: string
            # Default value: null
            #class = null

            # The cipher suites to enable when creating an SSLEngine for a connection. This setting
            # is only required when using the default SSL factory. If it is not present, the driver
            # won't explicitly enable cipher suites on the engine, which according to the JDK
            # documentations results in "a minimum quality of service".
            # Type: list<string>
            # Default value: null
            #cipher-suites = null

            # Whether or not to require validation that the hostname of the server certificate's
            # common name matches the hostname of the server being connected to. This setting is
            # only required when using the default SSL factory. If not set, defaults to true.
            # Type: boolean
            # Default value: true
            #hostname-validation = true

            # The locations used to access truststore contents. If either truststore-path or
            # keystore-path are specified, the driver builds an SSLContext from these files. This
            # setting is only required when using the default SSL factory. This setting is only
            # required when using the default SSL factory. If neither option is specified, the
            # default SSLContext is used, which is based on system property configuration.
            # Type: string
            # Default value: null
            #truststore-path = null

            # The password used to access truststore contents. This setting is only required when
            # using the default SSL factory.
            # Type: string
            # Default value: null
            #truststore-password = null

            # The locations used to access keystore contents. If either truststore-path or
            # keystore-path are specified, the driver builds an SSLContext from these files. This
            # setting is only required when using the default SSL factory. If neither option is
            # specified, the default SSLContext is used, which is based on system property
            # configuration.
            # Type: string
            # Default value: null
            #keystore-path = null

            # The password used to access keystore contents. This setting is only required when
            # using the default SSL factory.
            # Type: string
            # Default value: null
            #keystore-password = null

        }

        # The policy that controls if the driver retries requests that have failed on one node.
        retry-policy {

            # The class of the retry policy. If it is not qualified, the driver assumes that it
            # resides in the package `com.datastax.oss.driver.internal.core.retry`. DSBulk uses by
            # default a special retry policy that opinionately retries most errors up to
            # `max-retries` times.
            # 
            # You can also specify a custom class that implements `RetryPolicy` and has a public
            # constructor with two arguments: the `DriverContext` and a `String` representing the
            # profile name.
            # Type: string
            # Default value: "com.datastax.oss.dsbulk.workflow.commons.policies.retry.MultipleRetryPolicy"
            #class = "com.datastax.oss.dsbulk.workflow.commons.policies.retry.MultipleRetryPolicy"

            # How many times to retry a failed query. Only valid for use with DSBulk's default retry
            # policy (`MultipleRetryPolicy`).
            # Type: number
            # Default value: 10
            #max-retries = 10

        }

        # Whether to resolve the addresses passed to `basic.contact-points`.
        # 
        # If this is true, addresses are created with `InetSocketAddress(String, int)`: the host
        # name will be resolved the first time, and the driver will use the resolved IP address for
        # all subsequent connection attempts. If this is false, addresses are created with
        # `InetSocketAddress.createUnresolved()`: the host name will be resolved again every time
        # the driver opens a new connection. This is useful for containerized environments where DNS
        # records are more likely to change over time (note that the JVM and OS have their own DNS
        # caching mechanisms, so you might need additional configuration beyond the driver).
        # 
        # This option only applies to the contact points specified in the configuration. It has no
        # effect on dynamically discovered peers: the driver relies on Cassandra system tables,
        # which expose raw IP addresses. Use a custom address translator (see
        # `advanced.address-translator`) to convert them to unresolved addresses (if you're in a
        # containerized environment, you probably already need address translation anyway).
        # Type: boolean
        # Default value: true
        #resolve-contact-points = true

        # The address translator to use to convert the addresses sent by Cassandra nodes into ones
        # that the driver uses to connect. This is only needed if the nodes are not directly
        # reachable from the driver (for example, the driver is in a different network region and
        # needs to use a public IP, or it connects through a proxy).
        address-translator {

            # The class of the translator. If it is not qualified, the driver assumes that it
            # resides in the package `com.datastax.oss.driver.internal.core.addresstranslation`.
            # 
            # The driver provides the following implementations out of the box:
            # - `PassThroughAddressTranslator`: returns all addresses unchanged
            # 
            # You can also specify a custom class that implements `AddressTranslator` and has a
            # public constructor with a `DriverContext` argument.
            # Type: string
            # Default value: "PassThroughAddressTranslator"
            #class = "PassThroughAddressTranslator"

        }

        # The generator that assigns a microsecond timestamp to each request.
        timestamp-generator {

            # The class of the microsecond timestamp generator. If it is not qualified, the driver
            # assumes that it resides in the package `com.datastax.oss.driver.internal.core.time`.
            # 
            # The driver provides the following implementations out of the box:
            # - `AtomicTimestampGenerator`: timestamps are guaranteed to be unique across all client
            # threads.
            # - `ThreadLocalTimestampGenerator`: timestamps that are guaranteed to be unique within
            # each
            # thread only.
            # - `ServerSideTimestampGenerator`: do not generate timestamps, let the server assign
            # them.
            # 
            # You can also specify a custom class that implements `TimestampGenerator` and has a
            # public constructor with two arguments: the `DriverContext` and a `String` representing
            # the profile name.
            # Type: string
            # Default value: "AtomicTimestampGenerator"
            #class = "AtomicTimestampGenerator"

        }

        # Options to control the execution of continuous paging requests. Only applicable for
        # unloads, and only if this feature is available in the remote cluster, ignored otherwise.
        # Also, you need to enable continuous paging at DSBulk level for this to work, see
        # `dsbulk.executor.continuousPaging.enabled` (it is enabled by default).
        continuous-paging {

            # The page size. The value specified here can be interpreted in number of rows or in
            # number of bytes, depending on the unit defined with page-unit (see below). It controls
            # how many rows (or how much data) will be retrieved simultaneously in a single network
            # roundtrip (the goal being to avoid loading too many results in memory at the same
            # time). If there are more results, additional requests will be used to retrieve them.
            # The default is the same as the driver's normal request page size, i.e., 5000 (rows).
            # Type: number
            # Default value: 5000
            #page-size = 5000

            # Whether the page-size option should be interpreted in number of rows or bytes. The
            # default is false, i.e., the page size will be interpreted in number of rows.
            # Type: boolean
            # Default value: false
            #page-size-in-bytes = false

            # The maximum number of pages to return. The default is zero, which means retrieve all
            # pages.
            # Type: number
            # Default value: 0
            #max-pages = 0

            # Returns the maximum number of pages per second. The default is zero, which means no
            # limit.
            # Type: number
            # Default value: 0
            #max-pages-per-second = 0

            # The maximum number of pages that can be stored in the local queue. This value must be
            # positive. The default is 4.
            # Type: number
            # Default value: 4
            #max-enqueued-pages = 4

            # Timeouts for continuous paging. Note that there is no global timeout for continuous
            # paging as there is for regular queries, because continuous paging queries can take an
            # arbitrarily long time to complete. Instead, timeouts are applied to each exchange
            # between the driver and the coordinator. In other words, if the driver decides to
            # retry, all timeouts are reset.
            timeout {

                # How long to wait for the coordinator to send the first page.
                # Type: string
                # Default value: "5 minutes"
                #first-page = "5 minutes"

                # How long to wait for the coordinator to send subsequent pages.
                # Type: string
                # Default value: "5 minutes"
                #other-pages = "5 minutes"

            }

        }

        heartbeat {

            # The heartbeat interval. If a connection stays idle for that duration (no reads), the
            # driver sends a dummy message on it to make sure it's still alive. If not, the
            # connection is trashed and replaced.
            # Type: string
            # Default value: "1 minute"
            #interval = "1 minute"

            # How long the driver waits for the response to a heartbeat. If this timeout fires, the
            # heartbeat is considered failed.
            # Type: string
            # Default value: "1 minute"
            #timeout = "1 minute"

        }

        # Metrics in DSBulk are primarily configured in DSBulk's own "monitoring" section. The
        # driver metrics section should only be customized to enable specific driver metrics. Other
        # settings should not be modified, and in particular, changing the metrics factory class
        # could lead to runtime errors. For more information, see
        # https://docs.datastax.com/en/developer/java-driver/latest/manual/core/metrics/.
        metrics {

            session {

                # The session-level metrics to enable. Available metrics are:
                # 
                # - bytes-sent
                # - bytes-received
                # - connected-nodes
                # - cql-requests
                # - cql-client-timeouts
                # Type: list
                # Default value: []
                #enabled = []

            }

            node {

                # The node-level metrics to enable. Available metrics are:
                # 
                # - pool.open-connections
                # - pool.in-flight
                # - bytes-sent
                # - bytes-received
                # - cql-messages
                # - errors.request.unsent
                # - errors.request.aborted
                # - errors.request.write-timeouts
                # - errors.request.read-timeouts
                # - errors.request.unavailables
                # - errors.request.others
                # - retries.total
                # - retries.aborted
                # - retries.read-timeout
                # - retries.write-timeout
                # - retries.unavailable
                # - retries.other
                # - ignores.total
                # - ignores.aborted
                # - ignores.read-timeout
                # - ignores.write-timeout
                # - ignores.unavailable
                # - ignores.other
                # - errors.connection.init
                # * errors.connection.auth
                # Type: list
                # Default value: []
                #enabled = []

            }

        }

    }

}