Remote.conf

#####################################
# Akka Remote Reference Config File #
#####################################

# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.

# comments about akka.actor settings left out where they are already in akka-
# actor.jar, because otherwise they would be repeated in config rendering.

akka {
  actor {
	serialization-settings {
              primitive {
                # Resolves an edge-case issue introduced in Akka.NET v1.4.20
                # Described here: https://getakka.net/community/whats-new/akkadotnet-v1.4-upgrade-advisories.html#upgrading-to-akkanet-v1426-from-older-versions
                use-legacy-behavior = on
              }
	}

    # Remote's serializers, their bindings and their ids register from code (RemoteSerializers), not from this file.
    # An application can still override an alias or a binding in its own HOCON.

    deployment {

      default {

        # if this is set to a valid remote address, the named actor will be
        # deployed at that node e.g. "akka.tcp://sys@host:port"
        remote = ""

        target {

          # A list of hostnames and ports for instantiating the children of a
          # router
          #   The format should be on "akka.tcp://sys@host:port", where:
          #    - sys is the remote actor system name
          #    - hostname can be either hostname or IP address the remote actor
          #      should connect to
          #    - port should be the port for the remote server on the other node
          # The number of actor instances to be spawned is still taken from the
          # nr-of-instances setting as for local routers; the instances will be
          # distributed round-robin among the given nodes.
          nodes = []

        }
      }
    }
  }

  remote {

    ### General settings

    # Timeout after which the startup of the remoting subsystem is considered
    # to be failed. Increase this value if your transport drivers (see the
    # enabled-transports section) need longer time to be loaded.
    startup-timeout = 10 s

    # Timout after which the graceful shutdown of the remoting subsystem is
    # considered to be failed. After the timeout the remoting system is
    # forcefully shut down. Increase this value if your transport drivers
    # (see the enabled-transports section) need longer time to stop properly.
    shutdown-timeout = 10 s

    # Before shutting down the drivers, the remoting subsystem attempts to flush
    # all pending writes. This setting controls the maximum time the remoting is
    # willing to wait before moving on to shut down the drivers.
    flush-wait-on-shutdown = 2 s

    # Reuse inbound connections for outbound messages
    use-passive-connections = on

    # Controls the backoff interval after a refused write is reattempted.
    # (Transports may refuse writes if their internal buffer is full)
    backoff-interval = 0.05 s

    # Acknowledgment timeout of management commands sent to the transport stack.
    command-ack-timeout = 30 s

    # The timeout for outbound associations to perform the handshake.
    # If the transport is akka.remote.dot-netty.tcp or akka.remote.dot-netty.ssl
    # the configured connection-timeout for the transport will be used instead.
    handshake-timeout = 15 s

    # If set to a nonempty string remoting will use the given dispatcher for
    # its internal actors otherwise the default dispatcher is used. Please note
    # that since remoting can load arbitrary 3rd party drivers (see
    # "enabled-transport" and "adapters" entries) it is not guaranteed that
    # every module will respect this setting.
    use-dispatcher = "akka.remote.default-remote-dispatcher"

    # When enabled, system/address UIDs are generated across the full 64-bit range
    # (nonzero, may be negative) instead of the legacy [0, int.MaxValue] range.
    # DO NOT enable until EVERY node in the cluster and all remote peers run Akka.NET v1.6+:
    # pre-v1.6 nodes silently truncate UIDs above uint32.MaxValue in cluster gossip.
    use-64bit-system-uids = off

    ### Security settings

    # Enable untrusted mode for full security of server managed actors, prevents
    # system messages to be send by clients, e.g. messages like 'Create',
    # 'Suspend', 'Resume', 'Terminate', 'Supervise', 'Link' etc.
    untrusted-mode = off
    
    # When 'untrusted-mode=on' inbound actor selections are by default discarded.
    # Actors with paths defined in this white list are granted permission to receive actor
    # selections messages. 
    # E.g. trusted-selection-paths = ["/user/receptionist", "/user/namingService"]   
    trusted-selection-paths = []

    ### Logging

    # If this is "on", Akka will log all inbound messages at DEBUG level,
    # if off then they are not logged
    log-received-messages = off

    # If this is "on", Akka will log all outbound messages at DEBUG level,
    # if off then they are not logged
    log-sent-messages = off

    # Sets the log granularity level at which Akka logs remoting events. This setting
    # can take the values OFF, ERROR, WARNING, INFO, DEBUG, or ON. For compatibility
    # reasons the setting "on" will default to "debug" level. Please note that the effective
    # logging level is still determined by the global logging level of the actor system:
    # for example debug level remoting events will be only logged if the system
    # is running with debug level logging.
    # Failures to deserialize received messages also fall under this flag.
    log-remote-lifecycle-events = on

    # Logging of message types with payload size in bytes larger than
    # this value. Maximum detected size per message type is logged once,
    # with an increase threshold of 10%.
    # By default this feature is turned off. Activate it by setting the property to
    # a value in bytes, such as 1000b. Note that for all messages larger than this
    # limit there will be extra performance and scalability cost.
    log-frame-size-exceeding = off

	# Log warning if the number of messages in the backoff buffer in the endpoint
    # writer exceeds this limit. It can be disabled by setting the value to off.
    log-buffer-size-exceeding = 50000

    ### Failure detection and recovery

    # For TCP it is not important to have fast failure detection, since
    # most connection failures are captured by TCP itself.
    # The default DeadlineFailureDetector will trigger if there are no heartbeats within
    # the duration heartbeat-interval + acceptable-heartbeat-pause, i.e. 20 seconds
    # the duration heartbeat-interval + acceptable-heartbeat-pause, i.e. 124 seconds
    transport-failure-detector {

      # FQCN of the failure detector implementation.
      # It must implement akka.remote.FailureDetector and have
      # a public constructor with a com.typesafe.config.Config and
      # akka.actor.EventStream parameter.
      implementation-class = "Akka.Remote.DeadlineFailureDetector,Akka.Remote"

      # How often keep-alive heartbeat messages should be sent to each connection.
      heartbeat-interval = 4 s

      # Number of potentially lost/delayed heartbeats that will be
      # accepted before considering it to be an anomaly.
      # This margin is important to be able to survive sudden, occasional,
      # pauses in heartbeat arrivals, due to for example garbage collect or
      # network drop.
      acceptable-heartbeat-pause = 120 s
    }

    # Settings for the Phi accrual failure detector (http://ddg.jaist.ac.jp/pub/HDY+04.pdf
    # [Hayashibara et al]) used for remote death watch.
    watch-failure-detector {

      # FQCN of the failure detector implementation.
      # It must implement akka.remote.FailureDetector and have
      # a public constructor with a com.typesafe.config.Config and
      # akka.actor.EventStream parameter.
      implementation-class = "Akka.Remote.PhiAccrualFailureDetector,Akka.Remote"

      # How often keep-alive heartbeat messages should be sent to each connection.
      heartbeat-interval = 1 s

      # Defines the failure detector threshold.
      # A low threshold is prone to generate many wrong suspicions but ensures
      # a quick detection in the event of a real crash. Conversely, a high
      # threshold generates fewer mistakes but needs more time to detect
      # actual crashes.
      threshold = 10.0

      # Number of the samples of inter-heartbeat arrival times to adaptively
      # calculate the failure timeout for connections.
      max-sample-size = 200

      # Minimum standard deviation to use for the normal distribution in
      # AccrualFailureDetector. Too low standard deviation might result in
      # too much sensitivity for sudden, but normal, deviations in heartbeat
      # inter arrival times.
      min-std-deviation = 100 ms

      # Number of potentially lost/delayed heartbeats that will be
      # accepted before considering it to be an anomaly.
      # This margin is important to be able to survive sudden, occasional,
      # pauses in heartbeat arrivals, due to for example garbage collect or
      # network drop.
      acceptable-heartbeat-pause = 10 s


      # How often to check for nodes marked as unreachable by the failure
      # detector
      unreachable-nodes-reaper-interval = 1s

      # After the heartbeat request has been sent the first failure detection
      # will start after this period, even though no heartbeat mesage has
      # been received.
      expected-response-after = 1 s

    }

    # After failed to establish an outbound connection, the remoting will mark the
    # address as failed. This configuration option controls how much time should
    # be elapsed before reattempting a new connection. While the address is
    # gated, all messages sent to the address are delivered to dead-letters.
    # Since this setting limits the rate of reconnects setting it to a
    # very short interval (i.e. less than a second) may result in a storm of
    # reconnect attempts.
    retry-gate-closed-for = 5 s

    # After catastrophic communication failures that result in the loss of system
    # messages or after the remote DeathWatch triggers the remote system gets
    # quarantined to prevent inconsistent behavior.
    # This setting controls how long the Quarantine marker will be kept around
    # before being removed to avoid long-term memory leaks.
    # WARNING: DO NOT change this to a small value to re-enable communication with
    # quarantined nodes. Such feature is not supported and any behavior between
    # the affected systems after lifting the quarantine is undefined.
    prune-quarantine-marker-after = 5 d

	# If system messages have been exchanged between two systems (i.e. remote death
    # watch or remote deployment has been used) a remote system will be marked as
    # quarantined after the two system has no active association, and no
    # communication happens during the time configured here.
    # The only purpose of this setting is to avoid storing system message redelivery
    # data (sequence number state, etc.) for an undefined amount of time leading to long
    # term memory leak. Instead, if a system has been gone for this period,
    # or more exactly
    # - there is no association between the two systems (TCP connection, if TCP transport is used)
    # - neither side has been attempting to communicate with the other
    # - there are no pending system messages to deliver
    # for the amount of time configured here, the remote system will be quarantined and all state
    # associated with it will be dropped.
    quarantine-after-silence = 2 d

    # This setting defines the maximum number of unacknowledged system messages
    # allowed for a remote system. If this limit is reached the remote system is
    # declared to be dead and its UID marked as tainted.
    system-message-buffer-size = 20000

    # This setting defines the maximum idle time after an individual
    # acknowledgement for system messages is sent. System message delivery
    # is guaranteed by explicit acknowledgement messages. These acks are
    # piggybacked on ordinary traffic messages. If no traffic is detected
    # during the time period configured here, the remoting will send out
    # an individual ack.
    system-message-ack-piggyback-timeout = 0.3 s

    # This setting defines the time after internal management signals
    # between actors (used for DeathWatch and supervision) that have not been
    # explicitly acknowledged or negatively acknowledged are resent.
    # Messages that were negatively acknowledged are always immediately
    # resent.
    resend-interval = 2 s

	# Maximum number of unacknowledged system messages that will be resent
    # each 'resend-interval'. If you watch many (> 1000) remote actors you can
    # increase this value to for example 600, but a too large limit (e.g. 10000)
    # may flood the connection and might cause false failure detection to trigger.
    # Test such a configuration by watching all actors at the same time and stop
    # all watched actors at the same time.
    resend-limit = 200

    # WARNING: this setting should not be not changed unless all of its consequences
    # are properly understood which assumes experience with remoting internals
    # or expert advice.
    # This setting defines the time after redelivery attempts of internal management
    # signals are stopped to a remote system that has been not confirmed to be alive by
    # this system before.
    initial-system-message-delivery-timeout = 3 m

    ### Transports and adapters

    # List of the transport drivers that will be loaded by the remoting.
    # A list of fully qualified config paths must be provided where
    # the given configuration path contains a transport-class key
    # pointing to an implementation class of the Transport interface.
    # If multiple transports are provided, the address of the first
    # one will be used as a default address.
    enabled-transports = ["akka.remote.dot-netty.tcp"]

    # Transport drivers can be augmented with adapters by adding their
    # name to the applied-adapters setting in the configuration of a
    # transport. The available adapters should be configured in this
    # section by providing a name, and the fully qualified name of
    # their corresponding implementation. The class given here
    # must implement Akka.Remote.Transport.TransportAdapterProvider
    # and have public constructor without parameters.
    adapters {
      gremlin = "Akka.Remote.Transport.FailureInjectorProvider,Akka.Remote"
      trttl = "Akka.Remote.Transport.ThrottlerProvider,Akka.Remote"
    }

    ### Default configuration for the DotNetty based transport drivers

    dot-netty.tcp {
      # The class given here must implement the akka.remote.transport.Transport
      # interface and offer a public constructor which takes two arguments:
      #  1) akka.actor.ExtendedActorSystem
      #  2) com.typesafe.config.Config
      transport-class = "Akka.Remote.Transport.DotNetty.TcpTransport,Akka.Remote"

      # Transport drivers can be augmented with adapters by adding their
      # name to the applied-adapters list. The last adapter in the
      # list is the adapter immediately above the driver, while
      # the first one is the top of the stack below the standard
      # Akka protocol
      applied-adapters = []

      transport-protocol = tcp

	  # Byte order used for network communication. Event thou DotNetty is big-endian
	  # by default, we need to switch it back to little endian in order to support
	  # backward compatibility with Helios.
	  byte-order = "little-endian"

      # The default remote server port clients should connect to.
      # Default is 2552 (AKKA), use 0 if you want a random available port
      # This port needs to be unique for each actor system on the same machine.
      port = 2552

      # Similar in spirit to "public-hostname" setting, this allows Akka.Remote users
      # to alias the port they're listening on. The socket will actually listen on the
      # "port" setting, but when connecting to other ActorSystems this node will advertise
      # itself as being connected to the "public-port". This is helpful when working with 
      # hosting environments that rely on address translation and port-forwarding, such as Docker.
      #
      # Leave this setting to "0" if you don't intend to use it.
      public-port = 0

      # The hostname or ip to bind the remoting to,
      # InetAddress.getLocalHost.getHostAddress is used if empty
      hostname = ""

	  # If this value is set, this becomes the public address for the actor system on this
	  # transport, which might be different than the physical ip address (hostname)
	  # this is designed to make it easy to support private / public addressing schemes
	  public-hostname = ""

	  # If set to true, we will use IPV6 addresses upon DNS resolution for host names.
	  # Otherwise, we will use IPV4.
	  dns-use-ipv6 = false

	  # If set to true, we will enforce usage of IPV4 or IPV6 addresses upon DNS resolution for host names.
	  # If dns-use-ipv6 = true, we will use IPV6 enforcement
	  # Otherwise, we will use IPV4.
	  # Warning: when ip family is enforced, any connection between IPV4 and IPV6 is impossible
	  #
	  # enforce-ip-family setting is used only in some special cases, when default behaviour of 
	  # underlying sockets leads to errors. Typically this occurs when an environment doesn't support
	  # IPV6 or dual-mode sockets.
	  # As of 09/21/2016 there are two known cases: running under Mono and in Azure WebApp  
	  # for them we will need enforce-ip-family = true, and for Azure dns-use-ipv6 = false
	  # This property is always set to true if Mono runtime is detected.

	  enforce-ip-family = false

      # Enables SSL support on this transport
      enable-ssl = false

	  # Enables backwards compatibility with Akka.Remote clients running Helios 1.*
	  enable-backwards-compatibility = false

      # Sets the connectTimeoutMillis of all outbound connections,
      # i.e. how long a connect may take until it is timed out
      connection-timeout = 15 s

      # PERFORMANCE TUNING
      # 
      # The batching feature of DotNetty is designed to help batch together logical writes into a smaller
      # number of physical writes across the socket. This helps significantly reduce the number of system calls
      # and can improve performance by as much as 150% on some systems when enabled.
      batching{

        # Enables the batching system. When disabled, every write will be flushed immediately.
        # Disable this setting if you're working with a VERY low-traffic system that requires
        # fast (< 40ms) acknowledgement for all periodic messages.
        enabled = true

        # The maximum number of explicit flushes that will be allowed before being batched.
        # Batching normally happens when the channel switches from writes to reads and self-tunes automatically.
        max-pending-writes = 30
      }

      # If set to "<id.of.dispatcher>" then the specified dispatcher
      # will be used to accept inbound connections, and perform IO. If "" then
      # dedicated threads will be used.
      # Please note that the Helios driver only uses this configuration and does
      # not read the "akka.remote.use-dispatcher" entry. Instead it has to be
      # configured manually to point to the same dispatcher if needed.
      use-dispatcher-for-io = ""

      # Sets the high water mark for the in and outbound sockets,
      # set to 0b for platform default
      write-buffer-high-water-mark = 0b

      # Sets the low water mark for the in and outbound sockets,
      # set to 0b for platform default
      write-buffer-low-water-mark = 0b

      # Sets the send buffer size of the Sockets,
      # set to 0b for platform default
      send-buffer-size = 256000b

      # Sets the receive buffer size of the Sockets,
      # set to 0b for platform default
      receive-buffer-size = 256000b

      # Maximum message size the transport will accept, but at least
      # 32000 bytes.
      # Please note that UDP does not support arbitrary large datagrams,
      # so this setting has to be chosen carefully when using UDP.
      # Both send-buffer-size and receive-buffer-size settings has to
      # be adjusted to be able to buffer messages of maximum size.
      maximum-frame-size = 128000b

      # Sets the size of the connection backlog
      backlog = 4096

      # Enables the TCP_NODELAY flag, i.e. disables Nagle's algorithm
      tcp-nodelay = on

      # Enables TCP Keepalive, subject to the O/S kernel's configuration
      tcp-keepalive = on

      # Enables SO_REUSEADDR, which determines when an ActorSystem can open
      # the specified listen port (the meaning differs between *nix and Windows)
      # Valid values are "on", "off", and "off-for-windows"
      # due to the following Windows bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4476378
      # "off-for-windows" of course means that it's "on" for all other platforms
      tcp-reuse-addr = off-for-windows

      # Used to configure the number of I/O worker threads on server sockets
      server-socket-worker-pool {
        # Min number of threads to cap factor-based number to
        pool-size-min = 2

        # The pool size factor is used to determine thread pool size
        # using the following formula: ceil(available processors * factor).
        # Resulting size is then bounded by the pool-size-min and
        # pool-size-max values.
        pool-size-factor = 1.0

        # Max number of threads to cap factor-based number to
        pool-size-max = 2
      }

      # Used to configure the number of I/O worker threads on client sockets
      client-socket-worker-pool {
        # Min number of threads to cap factor-based number to
        pool-size-min = 2

        # The pool size factor is used to determine thread pool size
        # using the following formula: ceil(available processors * factor).
        # Resulting size is then bounded by the pool-size-min and
        # pool-size-max values.
        pool-size-factor = 1.0

        # Max number of threads to cap factor-based number to
        pool-size-max = 2
      }

      ssl {
        certificate {
          # Valid certificate path required
          path = ""
          # Valid certificate password required
          password = ""
          # Default key storage flag is "default-key-set"
          # Available flags include: 
          #     default-key-set | exportable | machine-key-set | persist-key-set | user-key-set | user-protected
          # flags = [ "default-key-set" ]
          
          # To use a Thumbprint instead of a file, set this to true
          # And specify a thumbprint and it's storage location below
          use-thumbprint-over-file = false
          
          # Valid Thumbprint required (if use-thumbprint-over-file is true)
          # A typical thumbprint is a format similar to: "45df32e258c92a7abf6c112e54912ab15bbb9eb0"
          # On Windows machines, The thumbprint for an installed certificate can be located
          # By using certlm.msc and opening the certificate under the 'Details' tab.
          thumbprint = ""
          
          # The Store name. Under windows The most common option is "My", which indicates the personal store.
          # See System.Security.Cryptography.X509Certificates.StoreName for other common values.
          store-name = ""
          
          # Valid options : local-machine or current-user
          # current-user indicates a certificate stored under the user's account
          # local-machine indicates a certificate stored at an operating system level (potentially shared by users)
          store-location = "current-user"
        }
        suppress-validation = false

        # When enabled, requires mutual TLS authentication where both client and server
        # must present valid certificates with accessible private keys during the TLS handshake.
        # This provides defense-in-depth security by ensuring symmetric authentication.
        #
        # When disabled, only server-side authentication is performed, which is
        # sufficient when combined with the startup certificate validation that prevents
        # servers from starting with inaccessible private keys.
        #
        # Set to false only if your environment cannot support client certificate authentication.
        # Default: true (secure by default)
        require-mutual-authentication = true

        # Enable or disable certificate hostname validation during TLS handshake.
        # When true: Traditional outbound TLS hostname validation is performed
        # (the server certificate CN/SAN must match the connection target hostname)
        # When false: Only validates certificate chain against CA, ignores hostname mismatches
        #
        # Set to false for scenarios such as:
        #   - Mutual TLS with per-node certificates in P2P clusters
        #   - IP-based connections where certificates use DNS names
        #   - Service discovery with dynamic addresses
        #
        # Default: false (disabled for backward compatibility and mutual TLS flexibility)
        #
        # This setting does not infer a hostname for inbound client certificates. Use a
        # DotNettySslSetup custom validator for application-specific inbound client authorization.
        validate-certificate-hostname = false
      }
    }

    dot-netty.udp = ${akka.remote.dot-netty.tcp}
    dot-netty.udp {
      transport-protocol = udp
    }

    ### Default configuration for the failure injector transport adapter

    gremlin {
      # Enable debug logging of the failure injector transport adapter
      debug = off
    }

    ### Default dispatcher for the remoting subsystem

    default-remote-dispatcher {
	    executor = default-executor
        fork-join-executor {
            parallelism-min = 2
            parallelism-factor = 0.5
            parallelism-max = 16
        }
        channel-executor.priority = "high"
    }
    
    backoff-remote-dispatcher {
	    executor = default-executor
        fork-join-executor {
            parallelism-min = 2
            parallelism-max = 2
        }
        channel-executor.priority = "low"
    }

    ### Artery TCP remoting (EXPERIMENTAL, under active development)
    #
    # Artery is a new remoting transport, built on Akka.Streams TCP, that runs beside classic
    # DotNetty remoting rather than replacing it. It is off by default; classic remoting is
    # unaffected either way. Two nodes in the same cluster must run the SAME transport
    # (classic `akka.tcp://` vs Artery `akka://` are not wire-compatible).
    #
    # These settings mirror Apache Pekko's `akka.remote.artery` keys; `canonical.port = 25520`
    # matches Pekko's Artery default port.
    artery {

      # Enables the Artery TCP remoting transport. When off (the default), classic DotNetty
      # remoting is used and every other setting in this section is ignored.
      enabled = off

      # The underlying transport substrate. Only "tcp" is supported for now; QUIC is a
      # future addition (not part of the 1.6 MVP).
      transport = tcp

      # The address other systems will use to associate with this system. This is the
      # "advertised" address, i.e. the one used to build this system's Artery `akka://` address;
      # it does not have to match the address the socket is physically bound to (e.g. behind NAT).
      canonical {

        # Hostname (or IP) other systems will use to connect to this system.
        hostname = "localhost"

        # Port other systems will use to connect to this system.
        port = 25520
      }

      # Actor paths to use the LARGE MESSAGE stream for when a message is sent to them over
      # remoting (task 10.2). The large message stream is a separate connection and outbound
      # queue from "ordinary" and control-stream traffic, so that a large payload does not
      # head-of-line-block them -- this is stream ISOLATION, not chunking: Artery TCP does not
      # fragment/reassemble oversized payloads.
      #
      # Entries are the full path to the actor. A single "*" segment matches any one name at
      # that position ("/user/supervisor/actor/*" matches any DIRECT CHILD of "actor", while
      # "/user/supervisor/*/child" matches any grandchild of "supervisor" named "child"); a
      # trailing "**" segment matches any actor AT OR BELOW that position. Entries must be
      # configured identically on both the sending and receiving side. Messages sent to an
      # ActorSelection are never routed onto the large message stream -- resolve the selection
      # to an ActorRef first if you need that; system/control messages (handshake, heartbeat,
      # DeathWatch, ...) never are either, regardless of whether their path happens to match.
      #
      # The large message stream (and its dedicated outbound connection) is only materialized
      # when this list is non-empty -- the default, an empty list, means Artery behaves exactly
      # as if this feature did not exist.
      #
      # NOTE: traffic routed onto the large message stream has NO ordering guarantee relative to
      # ordinary-stream traffic sent to the SAME actor -- they are two independent connections.
      large-message-destinations = []

      advanced {

        # Maximum serialized size, in bytes, of any Artery frame (envelope header + payload).
        # Hard-capped at 0x00FFFFFF (~16 MiB) because the envelope's literal-offset tag encoding
        # depends on offsets fitting in 24 bits; values above the cap are rejected at startup.
        maximum-frame-size = 256 KiB

        # Maximum serialized size, in bytes, of a frame sent on the LARGE MESSAGE stream (task
        # 10.2) -- only relevant when `large-message-destinations` (above) is non-empty. Same
        # 0x00FFFFFF (~16 MiB) hard cap as `maximum-frame-size`, for the same reason.
        maximum-large-frame-size = 2 MiB

        # Size of the dedicated buffer pool the large message stream's outbound encode path rents
        # from -- reused buffers are capped at `maximum-large-frame-size` each. Only relevant when
        # `large-message-destinations` is non-empty. Matches Pekko's `large-buffer-pool-size`
        # default.
        large-buffer-pool-size = 32

        # Number of inbound lanes ordinary-stream (user) messages are fanned out across, WITHIN
        # one accepted connection, for parallel payload deserialization + actor-ref resolution +
        # Tell. A message's lane is a stable hash of its recipient path (or, for an
        # ActorSelectionMessage, the selection's own target path elements -- see
        # ArteryInboundProcessingStage's remarks), so all traffic to the SAME recipient stays on
        # the SAME lane and is delivered in send order. Handshake/heartbeat/quarantine-notice/
        # reliable-system-message traffic (the CONTROL connection) is completely unaffected by
        # this setting regardless of its value -- only the ORDINARY connection's user messages are
        # ever lane-routed.
        #
        # Ships at 1 (single-lane, fused per-connection processing -- byte-identical to the
        # pre-lanes pipeline; the lane machinery is not even materialized at this value) until the
        # scaling gates pass. Raise this only after validating the improvement for your workload;
        # values > 1 need N dedicated lane-consumer background tasks per accepted ordinary
        # connection, each with its own bounded queue (see `inbound-lane-buffer-size` below).
        inbound-lanes = 1

        # Number of independent, bounded ordinary-outbound channels ("lanes") each association
        # fans ordinary-stream sends across. A message's recipient is hashed onto one lane, so the
        # SAME recipient always lands on the SAME lane (preserving per-recipient ordering) while
        # DIFFERENT recipients spread across every lane. All lanes still funnel into ONE TCP
        # connection per association -- lanes parallelize ENCODING/serialization work across CPU
        # cores, they do not add sockets. Only helps associations carrying traffic to MANY distinct
        # actors on the same remote host; a single hot recipient (or few) gets no benefit from
        # raising this, since its traffic is pinned to one lane regardless.
        #
        # `outbound-message-queue-size` (below) applies PER LANE, not divided across lanes --
        # raising outbound-lanes multiplies this association's total ordinary-outbound buffering by
        # the same factor (Pekko-faithful: each lane gets its own full-size queue).
        #
        # Defaults to 1, which is today's single-connection shape exactly -- no merge/fan-in
        # machinery is ever materialized at the default.
        #
        # Note: ActorSelection messages and recipients with an undefined UID always ride lane 0,
        # so high-volume ActorSelection traffic will not spread across lanes.
        outbound-lanes = 1

        # Capacity of the bounded, in-process queue (a System.Threading.Channels.Channel) feeding
        # EACH inbound lane's consumer, when `inbound-lanes` > 1. A full lane queue backpressures
        # the connection (the accepting stage stops reading/parking until room frees up) -- it
        # never drops a message or grows unbounded. Irrelevant at the `inbound-lanes = 1` default,
        # since no lane queues are created at that value.
        inbound-lane-buffer-size = 4096

        # For enabling testing features, such as blackhole in akka-remote-testkit
        # (the multi-node TestConductor's Blackhole/PassThrough commands over Artery). Off (the
        # default) materializes the exact same stream pipelines as if this setting did not exist
        # -- no failure-injection stages, no shared test state, no per-element checks -- and
        # `ManagementCommand` reports false for every command. Never enable in production.
        test-mode = off

        # How long an association will wait for a handshake to complete before failing and
        # retrying. See the `handshake-retry-interval` / `inject-handshake-interval` below.
        handshake-timeout = 20 s

        # How often a pending outbound handshake request is retried while awaiting a response.
        handshake-retry-interval = 1 s

        # How often the outbound handshake stage injects a `HandshakeReq` while user traffic is
        # queued behind an in-progress handshake.
        inject-handshake-interval = 1 s

        # How often the control stream sends a liveness heartbeat (`ArteryHeartbeat`) while
        # otherwise idle. The control stream is a separate connection/queue from ordinary
        # traffic (task group 6, "Control Stream") so this cadence is never delayed by ordinary
        # message volume.
        control-heartbeat-interval = 5 s

        # Capacity of every association's bounded ORDINARY outbound queue (task group 8, "Bounded
        # Queues And Backpressure"). Matches Pekko's `outbound-message-queue-size` default. Applies
        # PER LANE when `outbound-lanes` (above) is greater than 1 -- each lane gets its own
        # full-size queue, matching Pekko; the value here is not divided across lanes.
        outbound-message-queue-size = 3072

        # Capacity of every association's bounded CONTROL outbound queue -- carries handshake,
        # heartbeat, quarantine-notice, and reliable system-message (DeathWatch) traffic. Matches
        # Pekko's `outbound-control-queue-size` default. Deliberately large: a mass-termination
        # burst (e.g. a big `Terminate()`/CoordinatedShutdown fanning out thousands of `Unwatch`
        # system messages at once against a control queue this holds) must not overflow and
        # spuriously quarantine an otherwise healthy peer.
        outbound-control-queue-size = 20000

        # Capacity of every association's bounded LARGE MESSAGE outbound queue (task 10.2) --
        # only materialized when `large-message-destinations` (above) is non-empty. Overflow is a
        # soft drop (published as `Dropped` to the event stream, matching ordinary-queue overflow)
        # -- NOT a quarantine (unlike control-queue overflow). Matches Pekko's
        # `outbound-large-message-queue-size` default.
        outbound-large-message-queue-size = 256

        # Reliable system-message delivery (design.md gate G3). System messages -- the DeathWatch
        # triple (Watch/Unwatch/DeathWatchNotification) + Terminate -- are wrapped, seq-numbered,
        # and buffered here for possible resend until acknowledged by the peer.

        # Maximum number of unacknowledged system-message envelopes buffered for resend before
        # giving up (and quarantining the association). Matches Pekko's default.
        system-message-buffer-size = 20000

        # How often the whole unacknowledged system-message window is resent while any entry
        # remains unacked.
        system-message-resend-interval = 1 s

        # How long the OLDEST unacknowledged system-message envelope may wait for an ack before
        # giving up and quarantining the association.
        #
        # NOTE: this deliberately matches Pekko's Artery default (6 hours), NOT classic Akka.NET
        # remoting's much shorter (~3 minute) analogous retry-gate timeouts. System-message
        # delivery backs DeathWatch -- giving up (and losing the ability to ever observe this
        # association's remote terminations) after only a few minutes of transient network
        # trouble would be far too eager. See ArterySettings.GiveUpSystemMessageAfter for the
        # full rationale.
        give-up-system-message-after = 6 h

        # Association outbound-stream lifecycle: reconnect (design.md group 9). When an
        # association's outbound stream (ordinary OR control) terminates for ANY reason
        # (connection refused/reset, handshake timeout, write failure, or a graceful peer-side
        # close) -- other than THIS system's own transport Shutdown() -- re-materialization is
        # scheduled after this fixed backoff. Restarts are unlimited (no restart-count give-up:
        # the association's own reliability give-up, `give-up-system-message-after`, plus
        # quarantine gating at Send(), already provide termination where it matters). Applies
        # independently per stream.
        outbound-restart-backoff = 1 s

        # Before tearing the transport down, a graceful shutdown closes every association's
        # outbound queues (no new sends are accepted) and then gives the already-accepted
        # backlog a chance to reach the socket. This setting bounds that wait. Whatever has
        # still not been written when the bound expires is published as a `Dropped` event
        # exactly as before, so nothing is ever lost silently, and shutdown never takes longer
        # than this per transport.
        #
        # The wait costs nothing when there is nothing to flush: an association whose queues
        # are already empty completes immediately. Only a backlog that cannot reach its peer
        # (a dead or blackholed connection) burns the full bound.
        #
        # Mirrors classic remoting's `akka.remote.flush-wait-on-shutdown`, including its
        # default. Set to 0 to disable the flush and drain straight to `Dropped`.
        flush-wait-on-shutdown = 2 s

        # Only used when transport is tcp.
        tcp {

          # Resume-writer threshold, in bytes, for the input pipe (`System.IO.Pipelines.Pipe`) of
          # every Artery TCP connection; the pause-writer threshold applied is twice this value.
          # Defaults to 1 MiB, mirroring the 1 MiB OS socket buffers Artery already pins on every
          # connection (see ArteryRemoting.ArterySocketOptions) -- the much smaller Akka.IO-wide
          # default (derived from `akka.io.tcp.receive-buffer-size`, 8 KiB) throttles the read pump
          # well below what Artery's sockets can sustain under high-in-flight or one-way flood
          # traffic.
          pipe-buffer-size = 1m
        }
      }
    }
  }
}