##################################### # 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 { serializers { akka-containers = "akka.remote.serialization.MessageContainerSerializer" akka-misc = "akka.remote.serialization.MiscMessageSerializer" proto = "akka.remote.serialization.ProtobufSerializer" daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer" } serialization-bindings { "akka.actor.ActorSelectionMessage" = akka-containers # The classes akka.actor.Identify and akka.actor.ActorIdentity serialization/deserialization are required by # the cluster client to work. # For the purpose of preserving protocol backward compatibility, akka.actor.Identify and akka.actor.ActorIdentity # are stil using java serialization by default. # Should java serialization is disabled, uncomment the following lines # "akka.actor.Identify" = akka-misc # "akka.actor.ActorIdentity" = akka-misc "akka.remote.DaemonMsgCreate" = daemon-create # Since akka.protobuf.Message does not extend Serializable but # GeneratedMessage does, need to use the more specific one here in order # to avoid ambiguity. "akka.protobuf.GeneratedMessage" = proto # Since com.google.protobuf.Message does not extend Serializable but # GeneratedMessage does, need to use the more specific one here in order # to avoid ambiguity. # This com.google.protobuf serialization binding is only used if the class can be loaded, # i.e. com.google.protobuf dependency has been added in the application project. "com.google.protobuf.GeneratedMessage" = proto } serialization-identifiers { "akka.remote.serialization.ProtobufSerializer" = 2 "akka.remote.serialization.DaemonMsgCreateSerializer" = 3 "akka.remote.serialization.MessageContainerSerializer" = 6 "akka.remote.serialization.MiscMessageSerializer" = 16 } 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 { ### FIXME: Temporary switch for the PoC artery { enabled = off port = 20200 # The hostname or ip clients should connect to. # InetAddress.getLocalHost.getHostAddress is used if empty or # "" is specified. # InetAddress.getLocalHost.getHostName is used if # "" is specified. hostname = "" # Actor paths to use the large message stream for when a message # is sent to them over remoting. The large message stream dedicated # is separate from "normal" and system messages so that sending a # large message does not interfere with them. # Entries should be the full path to the actor. Wildcards in the form of "*" # can be supplied at any place and matches any name at that segment - # "/user/supervisor/actor/*" will match any direct child to actor, # while "/supervisor/*/child" will match any grandchild to "supervisor" that # has the name "child" # Messages sent to ActorSelections will not be passed through the large message # stream, to pass such messages through the large message stream the selections # but must be resolved to ActorRefs first. large-message-destinations = [] advanced { # Controls whether to start the Aeron media driver in the same JVM or use external # process. Set to 'off' when using external media driver, and then also set the # 'aeron-dir'. embedded-media-driver = on # Directory used by the Aeron media driver. It's mandatory to define the 'aeron-dir' # if using external media driver, i.e. when 'embedded-media-driver = off'. # Embedded media driver will use a this directory, or a temporary directory if this # property is not defined (empty). aeron-dir = "" } } ### 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 = 5 ms # 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.netty.tcp or akka.remote.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 = [] # Should the remote server require that its peers share the same # secure-cookie (defined in the 'remote' section)? Secure cookies are passed # between during the initial handshake. Connections are refused if the initial # message contains a mismatching cookie or the cookie is missing. require-cookie = off # Deprecated since 2.4-M1 secure-cookie = "" ### 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 # Settings for the failure detector to monitor connections. # 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 # with the default settings. 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" # 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. # A margin to the `heartbeat-interval` 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 = 16 s } # Settings for the Phi accrual failure detector (http://www.jaist.ac.jp/~defago/files/pdf/IS_RR_2004_010.pdf # [Hayashibara et al]) used for remote death watch. # The default PhiAccrualFailureDetector will trigger if there are no heartbeats within # the duration heartbeat-interval + acceptable-heartbeat-pause + threshold_adjustment, # i.e. around 12.5 seconds with default settings. 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" # 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 = 5 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.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.akka.remote.transport.TransportAdapterProvider # and have public constructor without parameters. adapters { gremlin = "akka.remote.transport.FailureInjectorProvider" trttl = "akka.remote.transport.ThrottlerProvider" } ### Default configuration for the Netty based transport drivers 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.netty.NettyTransport" # 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 # 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 # The hostname or ip clients should connect to. # InetAddress.getLocalHost.getHostAddress is used if empty hostname = "" # Use this setting to bind a network interface to a different port # than remoting protocol expects messages at. This may be used # when running akka nodes in a separated networks (under NATs or docker containers). # Use 0 if you want a random available port. Examples: # # akka.remote.netty.tcp.port = 2552 # akka.remote.netty.tcp.bind-port = 2553 # Network interface will be bound to the 2553 port, but remoting protocol will # expect messages sent to port 2552. # # akka.remote.netty.tcp.port = 0 # akka.remote.netty.tcp.bind-port = 0 # Network interface will be bound to a random port, and remoting protocol will # expect messages sent to the bound port. # # akka.remote.netty.tcp.port = 2552 # akka.remote.netty.tcp.bind-port = 0 # Network interface will be bound to a random port, but remoting protocol will # expect messages sent to port 2552. # # akka.remote.netty.tcp.port = 0 # akka.remote.netty.tcp.bind-port = 2553 # Network interface will be bound to the 2553 port, and remoting protocol will # expect messages sent to the bound port. # # akka.remote.netty.tcp.port = 2552 # akka.remote.netty.tcp.bind-port = "" # Network interface will be bound to the 2552 port, and remoting protocol will # expect messages sent to the bound port. # # akka.remote.netty.tcp.port if empty bind-port = "" # Use this setting to bind a network interface to a different hostname or ip # than remoting protocol expects messages at. # Use "0.0.0.0" to bind to all interfaces. # akka.remote.netty.tcp.hostname if empty bind-hostname = "" # Enables SSL support on this transport enable-ssl = 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 # If set to "" 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 Netty 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 } } netty.udp = ${akka.remote.netty.tcp} netty.udp { transport-protocol = udp } netty.ssl = ${akka.remote.netty.tcp} netty.ssl = { # Enable SSL/TLS encryption. # This must be enabled on both the client and server to work. enable-ssl = true security { # This is the Java Key Store used by the server connection key-store = "keystore" # This password is used for decrypting the key store key-store-password = "changeme" # This password is used for decrypting the key key-password = "changeme" # This is the Java Key Store used by the client connection trust-store = "truststore" # This password is used for decrypting the trust store trust-store-password = "changeme" # Protocol to use for SSL encryption, choose from: # TLS 1.2 is available since JDK7, and default since JDK8: # https://blogs.oracle.com/java-platform-group/entry/java_8_will_use_tls protocol = "TLSv1.2" # Example: ["TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_256_CBC_SHA"] # You need to install the JCE Unlimited Strength Jurisdiction Policy # Files to use AES 256. # More info here: # http://docs.oracle.com/javase/7/docs/technotes/guides/security/SunProviders.html#SunJCEProvider enabled-algorithms = ["TLS_RSA_WITH_AES_128_CBC_SHA"] # There are three options, in increasing order of security: # "" or SecureRandom => (default) # "SHA1PRNG" => Can be slow because of blocking issues on Linux # "AES128CounterSecureRNG" => fastest startup and based on AES encryption # algorithm # "AES256CounterSecureRNG" # # The following are deprecated in Akka 2.4. They use one of 3 possible # seed sources, depending on availability: /dev/random, random.org and # SecureRandom (provided by Java) # "AES128CounterInetRNG" # "AES256CounterInetRNG" (Install JCE Unlimited Strength Jurisdiction # Policy Files first) # Setting a value here may require you to supply the appropriate cipher # suite (see enabled-algorithms section above) random-number-generator = "" } } ### 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 { type = Dispatcher executor = "fork-join-executor" fork-join-executor { # Min number of threads to cap factor-based parallelism number to parallelism-min = 2 parallelism-max = 2 } } backoff-remote-dispatcher { type = Dispatcher executor = "fork-join-executor" fork-join-executor { # Min number of threads to cap factor-based parallelism number to parallelism-min = 2 parallelism-max = 2 } } } }