--- /dev/null
+############################################
+# Akka Cluster Tools Reference Config File #
+############################################
+
+# This is the reference config file that contains all the default settings.
+# Make your edits/overrides in your application.conf.
+
+# //#pub-sub-ext-config
+# Settings for the DistributedPubSub extension
+akka.cluster.pub-sub {
+ # Actor name of the mediator actor, /system/distributedPubSubMediator
+ name = distributedPubSubMediator
+
+ # Start the mediator on members tagged with this role.
+ # All members are used if undefined or empty.
+ role = ""
+
+ # The routing logic to use for 'Send'
+ # Possible values: random, round-robin, broadcast
+ routing-logic = random
+
+ # How often the DistributedPubSubMediator should send out gossip information
+ gossip-interval = 1s
+
+ # Removed entries are pruned after this duration
+ removed-time-to-live = 120s
+
+ # Maximum number of elements to transfer in one message when synchronizing the registries.
+ # Next chunk will be transferred in next round of gossip.
+ max-delta-elements = 3000
+
+ # When a message is published to a topic with no subscribers send it to the dead letters.
+ send-to-dead-letters-when-no-subscribers = on
+
+ # The id of the dispatcher to use for DistributedPubSubMediator actors.
+ # If specified you need to define the settings of the actual dispatcher.
+ use-dispatcher = "akka.actor.internal-dispatcher"
+}
+# //#pub-sub-ext-config
+
+# Protobuf serializer for cluster DistributedPubSubMeditor messages
+akka.actor {
+ serializers {
+ akka-pubsub = "akka.cluster.pubsub.protobuf.DistributedPubSubMessageSerializer"
+ }
+ serialization-bindings {
+ "akka.cluster.pubsub.DistributedPubSubMessage" = akka-pubsub
+ "akka.cluster.pubsub.DistributedPubSubMediator$Internal$SendToOneSubscriber" = akka-pubsub
+ }
+ serialization-identifiers {
+ "akka.cluster.pubsub.protobuf.DistributedPubSubMessageSerializer" = 9
+ }
+}
+
+
+# //#receptionist-ext-config
+# Settings for the ClusterClientReceptionist extension
+akka.cluster.client.receptionist {
+ # Actor name of the ClusterReceptionist actor, /system/receptionist
+ name = receptionist
+
+ # Start the receptionist on members tagged with this role.
+ # All members are used if undefined or empty.
+ role = ""
+
+ # The receptionist will send this number of contact points to the client
+ number-of-contacts = 3
+
+ # The actor that tunnel response messages to the client will be stopped
+ # after this time of inactivity.
+ response-tunnel-receive-timeout = 30s
+
+ # The id of the dispatcher to use for ClusterReceptionist actors.
+ # If specified you need to define the settings of the actual dispatcher.
+ use-dispatcher = "akka.actor.internal-dispatcher"
+
+ # How often failure detection heartbeat messages should be received for
+ # each ClusterClient
+ heartbeat-interval = 2s
+
+ # Number of potentially lost/delayed heartbeats that will be
+ # accepted before considering it to be an anomaly.
+ # The ClusterReceptionist is using the akka.remote.DeadlineFailureDetector, which
+ # will trigger if there are no heartbeats within the duration
+ # heartbeat-interval + acceptable-heartbeat-pause, i.e. 15 seconds with
+ # the default settings.
+ acceptable-heartbeat-pause = 13s
+
+ # Failure detection checking interval for checking all ClusterClients
+ failure-detection-interval = 2s
+}
+# //#receptionist-ext-config
+
+# //#cluster-client-config
+# Settings for the ClusterClient
+akka.cluster.client {
+ # Actor paths of the ClusterReceptionist actors on the servers (cluster nodes)
+ # that the client will try to contact initially. It is mandatory to specify
+ # at least one initial contact.
+ # Comma separated full actor paths defined by a string on the form of
+ # "akka://system@hostname:port/system/receptionist"
+ initial-contacts = []
+
+ # Interval at which the client retries to establish contact with one of
+ # ClusterReceptionist on the servers (cluster nodes)
+ establishing-get-contacts-interval = 3s
+
+ # Interval at which the client will ask the ClusterReceptionist for
+ # new contact points to be used for next reconnect.
+ refresh-contacts-interval = 60s
+
+ # How often failure detection heartbeat messages should be sent
+ heartbeat-interval = 2s
+
+ # Number of potentially lost/delayed heartbeats that will be
+ # accepted before considering it to be an anomaly.
+ # The ClusterClient is using the akka.remote.DeadlineFailureDetector, which
+ # will trigger if there are no heartbeats within the duration
+ # heartbeat-interval + acceptable-heartbeat-pause, i.e. 15 seconds with
+ # the default settings.
+ acceptable-heartbeat-pause = 13s
+
+ # If connection to the receptionist is not established the client will buffer
+ # this number of messages and deliver them the connection is established.
+ # When the buffer is full old messages will be dropped when new messages are sent
+ # via the client. Use 0 to disable buffering, i.e. messages will be dropped
+ # immediately if the location of the singleton is unknown.
+ # Maximum allowed buffer size is 10000.
+ buffer-size = 1000
+
+ # If connection to the receiptionist is lost and the client has not been
+ # able to acquire a new connection for this long the client will stop itself.
+ # This duration makes it possible to watch the cluster client and react on a more permanent
+ # loss of connection with the cluster, for example by accessing some kind of
+ # service registry for an updated set of initial contacts to start a new cluster client with.
+ # If this is not wanted it can be set to "off" to disable the timeout and retry
+ # forever.
+ reconnect-timeout = off
+}
+# //#cluster-client-config
+
+# Protobuf serializer for ClusterClient messages
+akka.actor {
+ serializers {
+ akka-cluster-client = "akka.cluster.client.protobuf.ClusterClientMessageSerializer"
+ }
+ serialization-bindings {
+ "akka.cluster.client.ClusterClientMessage" = akka-cluster-client
+ }
+ serialization-identifiers {
+ "akka.cluster.client.protobuf.ClusterClientMessageSerializer" = 15
+ }
+}
+
+# //#singleton-config
+akka.cluster.singleton {
+ # The actor name of the child singleton actor.
+ singleton-name = "singleton"
+
+ # Singleton among the nodes tagged with specified role.
+ # If the role is not specified it's a singleton among all nodes in the cluster.
+ role = ""
+
+ # When a node is becoming oldest it sends hand-over request to previous oldest,
+ # that might be leaving the cluster. This is retried with this interval until
+ # the previous oldest confirms that the hand over has started or the previous
+ # oldest member is removed from the cluster (+ akka.cluster.down-removal-margin).
+ hand-over-retry-interval = 1s
+
+ # The number of retries are derived from hand-over-retry-interval and
+ # akka.cluster.down-removal-margin (or ClusterSingletonManagerSettings.removalMargin),
+ # but it will never be less than this property.
+ # After the hand over retries and it's still not able to exchange the hand over messages
+ # with the previous oldest it will restart itself by throwing ClusterSingletonManagerIsStuck,
+ # to start from a clean state. After that it will still not start the singleton instance
+ # until the previous oldest node has been removed from the cluster.
+ # On the other side, on the previous oldest node, the same number of retries - 3 are used
+ # and after that the singleton instance is stopped.
+ # For large clusters it might be necessary to increase this to avoid too early timeouts while
+ # gossip dissemination of the Leaving to Exiting phase occurs. For normal leaving scenarios
+ # it will not be a quicker hand over by reducing this value, but in extreme failure scenarios
+ # the recovery might be faster.
+ min-number-of-hand-over-retries = 15
+
+ # Config path of the lease to be taken before creating the singleton actor
+ # if the lease is lost then the actor is restarted and it will need to re-acquire the lease
+ # the default is no lease
+ use-lease = ""
+
+ # The interval between retries for acquiring the lease
+ lease-retry-interval = 5s
+}
+# //#singleton-config
+
+# //#singleton-proxy-config
+akka.cluster.singleton-proxy {
+ # The actor name of the singleton actor that is started by the ClusterSingletonManager
+ singleton-name = ${akka.cluster.singleton.singleton-name}
+
+ # The role of the cluster nodes where the singleton can be deployed.
+ # Corresponding to the role used by the `ClusterSingletonManager`. If the role is not
+ # specified it's a singleton among all nodes in the cluster, and the `ClusterSingletonManager`
+ # must then also be configured in same way.
+ role = ""
+
+ # Interval at which the proxy will try to resolve the singleton instance.
+ singleton-identification-interval = 1s
+
+ # If the location of the singleton is unknown the proxy will buffer this
+ # number of messages and deliver them when the singleton is identified.
+ # When the buffer is full old messages will be dropped when new messages are
+ # sent via the proxy.
+ # Use 0 to disable buffering, i.e. messages will be dropped immediately if
+ # the location of the singleton is unknown.
+ # Maximum allowed buffer size is 10000.
+ buffer-size = 1000
+}
+# //#singleton-proxy-config
+
+# Serializer for cluster ClusterSingleton messages
+akka.actor {
+ serializers {
+ akka-singleton = "akka.cluster.singleton.protobuf.ClusterSingletonMessageSerializer"
+ }
+ serialization-bindings {
+ "akka.cluster.singleton.ClusterSingletonMessage" = akka-singleton
+ }
+ serialization-identifiers {
+ "akka.cluster.singleton.protobuf.ClusterSingletonMessageSerializer" = 14
+ }
+}
\ No newline at end of file