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

    serializers {
      akka-containers = "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote"
      akka-misc = "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote"
      primitive = "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote"
      proto = "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote"
      daemon-create = "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote"
      akka-system-msg = "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote"
    }

    serialization-bindings {
      "Akka.Actor.ActorSelectionMessage, Akka" = akka-containers
      "Akka.Remote.DaemonMsgCreate, Akka.Remote" = daemon-create

      "Google.Protobuf.IMessage, Google.Protobuf" = proto

      "Akka.Actor.Identify, Akka" = akka-misc
      "Akka.Actor.ActorIdentity, Akka" = akka-misc
      "Akka.Actor.IActorRef, Akka" = akka-misc
      "Akka.Actor.PoisonPill, Akka" = akka-misc
      "Akka.Actor.IntentionalRestart, Akka" = akka-misc
      "Akka.Actor.Kill, Akka" = akka-misc
      "Akka.Actor.PoisonPill, Akka" = akka-misc
      "Akka.Actor.Status+Failure, Akka" = akka-misc
      "Akka.Actor.Status+Success, Akka" = akka-misc
      #"Akka.Actor.LocalScope, Akka" = akka-misc
      "Akka.Actor.RemoteScope, Akka" = akka-misc
      "Akka.Routing.FromConfig, Akka" = akka-misc
      "Akka.Routing.DefaultResizer, Akka" = akka-misc
      "Akka.Routing.RoundRobinPool, Akka" = akka-misc
      "Akka.Routing.BroadcastPool, Akka" = akka-misc
      "Akka.Routing.RandomPool, Akka" = akka-misc
      "Akka.Routing.ScatterGatherFirstCompletedPool, Akka" = akka-misc
      "Akka.Routing.TailChoppingPool, Akka" = akka-misc
      "Akka.Routing.ConsistentHashingPool, Akka" = akka-misc
      "Akka.Configuration.Config, Akka" = akka-misc
      "Akka.Remote.RemoteWatcher+Heartbeat, Akka.Remote" = akka-misc
      "Akka.Remote.RemoteWatcher+HeartbeatRsp, Akka.Remote" = akka-misc
      "Akka.Remote.Routing.RemoteRouterConfig, Akka.Remote" = akka-misc

      "Akka.Dispatch.SysMsg.SystemMessage, Akka" = akka-system-msg

      "System.String" = primitive
      "System.Int32" = primitive
      "System.Int64" = primitive
    }

    serialization-identifiers {
      "Akka.Remote.Serialization.ProtobufSerializer, Akka.Remote" = 2
      "Akka.Remote.Serialization.DaemonMsgCreateSerializer, Akka.Remote" = 3
      "Akka.Remote.Serialization.MessageContainerSerializer, Akka.Remote" = 6
      "Akka.Remote.Serialization.MiscMessageSerializer, Akka.Remote" = 16
      "Akka.Remote.Serialization.PrimitiveSerializers, Akka.Remote" = 17
      "Akka.Remote.Serialization.SystemMessageSerializer, Akka.Remote" = 22
    }

    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"

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

    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"
    }
  }
}