Add Akka packaging
[controller.git] / akka / repackaged-akka-jar / src / main / resources / actor_reference.conf
1 ####################################
2 # Akka Actor Reference Config File #
3 ####################################
4
5 # This is the reference config file that contains all the default settings.
6 # Make your edits/overrides in your application.conf.
7
8 # Akka version, checked against the runtime version of Akka. Loaded from generated conf file.
9 include "version"
10
11 akka {
12   # Home directory of Akka, modules in the deploy directory will be loaded
13   home = ""
14
15   # Loggers to register at boot time (akka.event.Logging$DefaultLogger logs
16   # to STDOUT)
17   loggers = ["akka.event.Logging$DefaultLogger"]
18
19   # Filter of log events that is used by the LoggingAdapter before
20   # publishing log events to the eventStream. It can perform
21   # fine grained filtering based on the log source. The default
22   # implementation filters on the `loglevel`.
23   # FQCN of the LoggingFilter. The Class of the FQCN must implement
24   # akka.event.LoggingFilter and have a public constructor with
25   # (akka.actor.ActorSystem.Settings, akka.event.EventStream) parameters.
26   logging-filter = "akka.event.DefaultLoggingFilter"
27
28   # Specifies the default loggers dispatcher
29   loggers-dispatcher = "akka.actor.default-dispatcher"
30
31   # Loggers are created and registered synchronously during ActorSystem
32   # start-up, and since they are actors, this timeout is used to bound the
33   # waiting time
34   logger-startup-timeout = 5s
35
36   # Log level used by the configured loggers (see "loggers") as soon
37   # as they have been started; before that, see "stdout-loglevel"
38   # Options: OFF, ERROR, WARNING, INFO, DEBUG
39   loglevel = "INFO"
40
41   # Log level for the very basic logger activated during ActorSystem startup.
42   # This logger prints the log messages to stdout (System.out).
43   # Options: OFF, ERROR, WARNING, INFO, DEBUG
44   stdout-loglevel = "WARNING"
45
46   # Log the complete configuration at INFO level when the actor system is started.
47   # This is useful when you are uncertain of what configuration is used.
48   log-config-on-start = off
49
50   # Log at info level when messages are sent to dead letters.
51   # Possible values:
52   # on: all dead letters are logged
53   # off: no logging of dead letters
54   # n: positive integer, number of dead letters that will be logged
55   log-dead-letters = 10
56
57   # Possibility to turn off logging of dead letters while the actor system
58   # is shutting down. Logging is only done when enabled by 'log-dead-letters'
59   # setting.
60   log-dead-letters-during-shutdown = on
61
62   # List FQCN of extensions which shall be loaded at actor system startup.
63   # Library extensions are regular extensions that are loaded at startup and are
64   # available for third party library authors to enable auto-loading of extensions when
65   # present on the classpath. This is done by appending entries:
66   # 'library-extensions += "Extension"' in the library `reference.conf`.
67   #
68   # Should not be set by end user applications in 'application.conf', use the extensions property for that
69   #
70   library-extensions = ${?akka.library-extensions} ["akka.serialization.SerializationExtension"]
71
72   # List FQCN of extensions which shall be loaded at actor system startup.
73   # Should be on the format: 'extensions = ["foo", "bar"]' etc.
74   # See the Akka Documentation for more info about Extensions
75   extensions = []
76
77   # Toggles whether threads created by this ActorSystem should be daemons or not
78   daemonic = off
79
80   # JVM shutdown, System.exit(-1), in case of a fatal error,
81   # such as OutOfMemoryError
82   jvm-exit-on-fatal-error = on
83
84   # Akka installs JVM shutdown hooks by default, e.g. in CoordinatedShutdown and Artery. This property will
85   # not disable user-provided hooks registered using `CoordinatedShutdown#addCancellableJvmShutdownHook`.
86   # This property is related to `akka.coordinated-shutdown.run-by-jvm-shutdown-hook` below.
87   # This property makes it possible to disable all such hooks if the application itself
88   # or a higher level framework such as Play prefers to install the JVM shutdown hook and
89   # terminate the ActorSystem itself, with or without using CoordinatedShutdown.
90   jvm-shutdown-hooks = on
91
92   actor {
93
94     # Either one of "local", "remote" or "cluster" or the
95     # FQCN of the ActorRefProvider to be used; the below is the built-in default,
96     # note that "remote" and "cluster" requires the akka-remote and akka-cluster
97     # artifacts to be on the classpath.
98     provider = "local"
99
100     # The guardian "/user" will use this class to obtain its supervisorStrategy.
101     # It needs to be a subclass of akka.actor.SupervisorStrategyConfigurator.
102     # In addition to the default there is akka.actor.StoppingSupervisorStrategy.
103     guardian-supervisor-strategy = "akka.actor.DefaultSupervisorStrategy"
104
105     # Timeout for ActorSystem.actorOf
106     creation-timeout = 20s
107
108     # Serializes and deserializes (non-primitive) messages to ensure immutability,
109     # this is only intended for testing.
110     serialize-messages = off
111
112     # Additional serialization bindings which are enabled automatically when allow-java-serialization is disabled.
113     # settings are provided
114     java-serialization-disabled-additional-serialization-bindings = {}
115
116     # Serializes and deserializes creators (in Props) to ensure that they can be
117     # sent over the network, this is only intended for testing. Purely local deployments
118     # as marked with deploy.scope == LocalScope are exempt from verification.
119     serialize-creators = off
120
121     # Timeout for send operations to top-level actors which are in the process
122     # of being started. This is only relevant if using a bounded mailbox or the
123     # CallingThreadDispatcher for a top-level actor.
124     unstarted-push-timeout = 10s
125
126     typed {
127       # Default timeout for typed actor methods with non-void return type
128       timeout = 5s
129     }
130
131     # Mapping between ´deployment.router' short names to fully qualified class names
132     router.type-mapping {
133       from-code = "akka.routing.NoRouter"
134       round-robin-pool = "akka.routing.RoundRobinPool"
135       round-robin-group = "akka.routing.RoundRobinGroup"
136       random-pool = "akka.routing.RandomPool"
137       random-group = "akka.routing.RandomGroup"
138       balancing-pool = "akka.routing.BalancingPool"
139       smallest-mailbox-pool = "akka.routing.SmallestMailboxPool"
140       broadcast-pool = "akka.routing.BroadcastPool"
141       broadcast-group = "akka.routing.BroadcastGroup"
142       scatter-gather-pool = "akka.routing.ScatterGatherFirstCompletedPool"
143       scatter-gather-group = "akka.routing.ScatterGatherFirstCompletedGroup"
144       tail-chopping-pool = "akka.routing.TailChoppingPool"
145       tail-chopping-group = "akka.routing.TailChoppingGroup"
146       consistent-hashing-pool = "akka.routing.ConsistentHashingPool"
147       consistent-hashing-group = "akka.routing.ConsistentHashingGroup"
148     }
149
150     deployment {
151
152       # deployment id pattern - on the format: /parent/child etc.
153       default {
154
155         # The id of the dispatcher to use for this actor.
156         # If undefined or empty the dispatcher specified in code
157         # (Props.withDispatcher) is used, or default-dispatcher if not
158         # specified at all.
159         dispatcher = ""
160
161         # The id of the mailbox to use for this actor.
162         # If undefined or empty the default mailbox of the configured dispatcher
163         # is used or if there is no mailbox configuration the mailbox specified
164         # in code (Props.withMailbox) is used.
165         # If there is a mailbox defined in the configured dispatcher then that
166         # overrides this setting.
167         mailbox = ""
168
169         # routing (load-balance) scheme to use
170         # - available: "from-code", "round-robin", "random", "smallest-mailbox",
171         #              "scatter-gather", "broadcast"
172         # - or:        Fully qualified class name of the router class.
173         #              The class must extend akka.routing.CustomRouterConfig and
174         #              have a public constructor with com.typesafe.config.Config
175         #              and optional akka.actor.DynamicAccess parameter.
176         # - default is "from-code";
177         # Whether or not an actor is transformed to a Router is decided in code
178         # only (Props.withRouter). The type of router can be overridden in the
179         # configuration; specifying "from-code" means that the values specified
180         # in the code shall be used.
181         # In case of routing, the actors to be routed to can be specified
182         # in several ways:
183         # - nr-of-instances: will create that many children
184         # - routees.paths: will route messages to these paths using ActorSelection,
185         #   i.e. will not create children
186         # - resizer: dynamically resizable number of routees as specified in
187         #   resizer below
188         router = "from-code"
189
190         # number of children to create in case of a router;
191         # this setting is ignored if routees.paths is given
192         nr-of-instances = 1
193
194         # within is the timeout used for routers containing future calls
195         within = 5 seconds
196
197         # number of virtual nodes per node for consistent-hashing router
198         virtual-nodes-factor = 10
199
200         tail-chopping-router {
201           # interval is duration between sending message to next routee
202           interval = 10 milliseconds
203         }
204
205         routees {
206           # Alternatively to giving nr-of-instances you can specify the full
207           # paths of those actors which should be routed to. This setting takes
208           # precedence over nr-of-instances
209           paths = []
210         }
211
212         # To use a dedicated dispatcher for the routees of the pool you can
213         # define the dispatcher configuration inline with the property name
214         # 'pool-dispatcher' in the deployment section of the router.
215         # For example:
216         # pool-dispatcher {
217         #   fork-join-executor.parallelism-min = 5
218         #   fork-join-executor.parallelism-max = 5
219         # }
220
221         # Routers with dynamically resizable number of routees; this feature is
222         # enabled by including (parts of) this section in the deployment
223         resizer {
224
225           enabled = off
226
227           # The fewest number of routees the router should ever have.
228           lower-bound = 1
229
230           # The most number of routees the router should ever have.
231           # Must be greater than or equal to lower-bound.
232           upper-bound = 10
233
234           # Threshold used to evaluate if a routee is considered to be busy
235           # (under pressure). Implementation depends on this value (default is 1).
236           # 0:   number of routees currently processing a message.
237           # 1:   number of routees currently processing a message has
238           #      some messages in mailbox.
239           # > 1: number of routees with at least the configured pressure-threshold
240           #      messages in their mailbox. Note that estimating mailbox size of
241           #      default UnboundedMailbox is O(N) operation.
242           pressure-threshold = 1
243
244           # Percentage to increase capacity whenever all routees are busy.
245           # For example, 0.2 would increase 20% (rounded up), i.e. if current
246           # capacity is 6 it will request an increase of 2 more routees.
247           rampup-rate = 0.2
248
249           # Minimum fraction of busy routees before backing off.
250           # For example, if this is 0.3, then we'll remove some routees only when
251           # less than 30% of routees are busy, i.e. if current capacity is 10 and
252           # 3 are busy then the capacity is unchanged, but if 2 or less are busy
253           # the capacity is decreased.
254           # Use 0.0 or negative to avoid removal of routees.
255           backoff-threshold = 0.3
256
257           # Fraction of routees to be removed when the resizer reaches the
258           # backoffThreshold.
259           # For example, 0.1 would decrease 10% (rounded up), i.e. if current
260           # capacity is 9 it will request an decrease of 1 routee.
261           backoff-rate = 0.1
262
263           # Number of messages between resize operation.
264           # Use 1 to resize before each message.
265           messages-per-resize = 10
266         }
267
268         # Routers with dynamically resizable number of routees based on
269         # performance metrics.
270         # This feature is enabled by including (parts of) this section in
271         # the deployment, cannot be enabled together with default resizer.
272         optimal-size-exploring-resizer {
273
274           enabled = off
275
276           # The fewest number of routees the router should ever have.
277           lower-bound = 1
278
279           # The most number of routees the router should ever have.
280           # Must be greater than or equal to lower-bound.
281           upper-bound = 10
282
283           # probability of doing a ramping down when all routees are busy
284           # during exploration.
285           chance-of-ramping-down-when-full = 0.2
286
287           # Interval between each resize attempt
288           action-interval = 5s
289
290           # If the routees have not been fully utilized (i.e. all routees busy)
291           # for such length, the resizer will downsize the pool.
292           downsize-after-underutilized-for = 72h
293
294           # Duration exploration, the ratio between the largest step size and
295           # current pool size. E.g. if the current pool size is 50, and the
296           # explore-step-size is 0.1, the maximum pool size change during
297           # exploration will be +- 5
298           explore-step-size = 0.1
299
300           # Probability of doing an exploration v.s. optmization.
301           chance-of-exploration = 0.4
302
303           # When downsizing after a long streak of underutilization, the resizer
304           # will downsize the pool to the highest utiliziation multiplied by a
305           # a downsize ratio. This downsize ratio determines the new pools size
306           # in comparison to the highest utilization.
307           # E.g. if the highest utilization is 10, and the down size ratio
308           # is 0.8, the pool will be downsized to 8
309           downsize-ratio = 0.8
310
311           # When optimizing, the resizer only considers the sizes adjacent to the
312           # current size. This number indicates how many adjacent sizes to consider.
313           optimization-range = 16
314
315           # The weight of the latest metric over old metrics when collecting
316           # performance metrics.
317           # E.g. if the last processing speed is 10 millis per message at pool
318           # size 5, and if the new processing speed collected is 6 millis per
319           # message at pool size 5. Given a weight of 0.3, the metrics
320           # representing pool size 5 will be 6 * 0.3 + 10 * 0.7, i.e. 8.8 millis
321           # Obviously, this number should be between 0 and 1.
322           weight-of-latest-metric = 0.5
323         }
324       }
325
326       "/IO-DNS/inet-address" {
327         mailbox = "unbounded"
328         router = "consistent-hashing-pool"
329         nr-of-instances = 4
330       }
331
332       "/IO-DNS/inet-address/*" {
333         dispatcher = "akka.actor.default-blocking-io-dispatcher"
334       }
335
336       "/IO-DNS/async-dns" {
337         mailbox = "unbounded"
338         router = "round-robin-pool"
339         nr-of-instances = 1
340       }
341     }
342
343     default-dispatcher {
344       # Must be one of the following
345       # Dispatcher, PinnedDispatcher, or a FQCN to a class inheriting
346       # MessageDispatcherConfigurator with a public constructor with
347       # both com.typesafe.config.Config parameter and
348       # akka.dispatch.DispatcherPrerequisites parameters.
349       # PinnedDispatcher must be used together with executor=thread-pool-executor.
350       type = "Dispatcher"
351
352       # Which kind of ExecutorService to use for this dispatcher
353       # Valid options:
354       #  - "default-executor" requires a "default-executor" section
355       #  - "fork-join-executor" requires a "fork-join-executor" section
356       #  - "thread-pool-executor" requires a "thread-pool-executor" section
357       #  - "affinity-pool-executor" requires an "affinity-pool-executor" section
358       #  - A FQCN of a class extending ExecutorServiceConfigurator
359       executor = "default-executor"
360
361       # This will be used if you have set "executor = "default-executor"".
362       # If an ActorSystem is created with a given ExecutionContext, this
363       # ExecutionContext will be used as the default executor for all
364       # dispatchers in the ActorSystem configured with
365       # executor = "default-executor". Note that "default-executor"
366       # is the default value for executor, and therefore used if not
367       # specified otherwise. If no ExecutionContext is given,
368       # the executor configured in "fallback" will be used.
369       default-executor {
370         fallback = "fork-join-executor"
371       }
372
373       # This will be used if you have set "executor = "affinity-pool-executor""
374       # Underlying thread pool implementation is akka.dispatch.affinity.AffinityPool.
375       # This executor is classified as "ApiMayChange".
376       affinity-pool-executor {
377         # Min number of threads to cap factor-based parallelism number to
378         parallelism-min = 4
379
380         # The parallelism factor is used to determine thread pool size using the
381         # following formula: ceil(available processors * factor). Resulting size
382         # is then bounded by the parallelism-min and parallelism-max values.
383         parallelism-factor = 0.8
384
385         # Max number of threads to cap factor-based parallelism number to.
386         parallelism-max = 64
387
388         # Each worker in the pool uses a separate bounded MPSC queue. This value
389         # indicates the upper bound of the queue. Whenever an attempt to enqueue
390         # a task is made and the queue does not have capacity to accommodate
391         # the task, the rejection handler created by the rejection handler specified
392         # in "rejection-handler" is invoked.
393         task-queue-size = 512
394
395         # FQCN of the Rejection handler used in the pool.
396         # Must have an empty public constructor and must
397         # implement akka.actor.affinity.RejectionHandlerFactory.
398         rejection-handler = "akka.dispatch.affinity.ThrowOnOverflowRejectionHandler"
399
400         # Level of CPU time used, on a scale between 1 and 10, during backoff/idle.
401         # The tradeoff is that to have low latency more CPU time must be used to be
402         # able to react quickly on incoming messages or send as fast as possible after
403         # backoff backpressure.
404         # Level 1 strongly prefer low CPU consumption over low latency.
405         # Level 10 strongly prefer low latency over low CPU consumption.
406         idle-cpu-level = 5
407
408         # FQCN of the akka.dispatch.affinity.QueueSelectorFactory.
409         # The Class of the FQCN must have a public constructor with a
410         # (com.typesafe.config.Config) parameter.
411         # A QueueSelectorFactory create instances of akka.dispatch.affinity.QueueSelector,
412         # that is responsible for determining which task queue a Runnable should be enqueued in.
413         queue-selector = "akka.dispatch.affinity.FairDistributionHashCache"
414
415         # When using the "akka.dispatch.affinity.FairDistributionHashCache" queue selector
416         # internally the AffinityPool uses two methods to determine which task
417         # queue to allocate a Runnable to:
418         # - map based - maintains a round robin counter and a map of Runnable
419         # hashcodes to queues that they have been associated with. This ensures
420         # maximum fairness in terms of work distribution, meaning that each worker
421         # will get approximately equal amount of mailboxes to execute. This is suitable
422         # in cases where we have a small number of actors that will be scheduled on
423         # the pool and we want to ensure the maximum possible utilization of the
424         # available threads.
425         # - hash based - the task - queue in which the runnable should go is determined
426         # by using an uniformly distributed int to int hash function which uses the
427         # hash code of the Runnable as an input. This is preferred in situations where we
428         # have enough number of distinct actors to ensure statistically uniform
429         # distribution of work across threads or we are ready to sacrifice the
430         # former for the added benefit of avoiding map look-ups.
431         fair-work-distribution {
432           # The value serves as a threshold which determines the point at which the
433           # pool switches from the first to the second work distribution schemes.
434           # For example, if the value is set to 128, the pool can observe up to
435           # 128 unique actors and schedule their mailboxes using the map based
436           # approach. Once this number is reached the pool switches to hash based
437           # task distribution mode. If the value is set to 0, the map based
438           # work distribution approach is disabled and only the hash based is
439           # used irrespective of the number of unique actors. Valid range is
440           # 0 to 2048 (inclusive)
441           threshold = 128
442         }
443       }
444
445       # This will be used if you have set "executor = "fork-join-executor""
446       # Underlying thread pool implementation is akka.dispatch.forkjoin.ForkJoinPool
447       fork-join-executor {
448         # Min number of threads to cap factor-based parallelism number to
449         parallelism-min = 8
450
451         # The parallelism factor is used to determine thread pool size using the
452         # following formula: ceil(available processors * factor). Resulting size
453         # is then bounded by the parallelism-min and parallelism-max values.
454         parallelism-factor = 3.0
455
456         # Max number of threads to cap factor-based parallelism number to
457         parallelism-max = 64
458
459         # Setting to "FIFO" to use queue like peeking mode which "poll" or "LIFO" to use stack
460         # like peeking mode which "pop".
461         task-peeking-mode = "FIFO"
462       }
463
464       # This will be used if you have set "executor = "thread-pool-executor""
465       # Underlying thread pool implementation is java.util.concurrent.ThreadPoolExecutor
466       thread-pool-executor {
467         # Keep alive time for threads
468         keep-alive-time = 60s
469
470         # Define a fixed thread pool size with this property. The corePoolSize
471         # and the maximumPoolSize of the ThreadPoolExecutor will be set to this
472         # value, if it is defined. Then the other pool-size properties will not
473         # be used.
474         #
475         # Valid values are: `off` or a positive integer.
476         fixed-pool-size = off
477
478         # Min number of threads to cap factor-based corePoolSize number to
479         core-pool-size-min = 8
480
481         # The core-pool-size-factor is used to determine corePoolSize of the
482         # ThreadPoolExecutor using the following formula:
483         # ceil(available processors * factor).
484         # Resulting size is then bounded by the core-pool-size-min and
485         # core-pool-size-max values.
486         core-pool-size-factor = 3.0
487
488         # Max number of threads to cap factor-based corePoolSize number to
489         core-pool-size-max = 64
490
491         # Minimum number of threads to cap factor-based maximumPoolSize number to
492         max-pool-size-min = 8
493
494         # The max-pool-size-factor is used to determine maximumPoolSize of the
495         # ThreadPoolExecutor using the following formula:
496         # ceil(available processors * factor)
497         # The maximumPoolSize will not be less than corePoolSize.
498         # It is only used if using a bounded task queue.
499         max-pool-size-factor  = 3.0
500
501         # Max number of threads to cap factor-based maximumPoolSize number to
502         max-pool-size-max = 64
503
504         # Specifies the bounded capacity of the task queue (< 1 == unbounded)
505         task-queue-size = -1
506
507         # Specifies which type of task queue will be used, can be "array" or
508         # "linked" (default)
509         task-queue-type = "linked"
510
511         # Allow core threads to time out
512         allow-core-timeout = on
513       }
514
515       # How long time the dispatcher will wait for new actors until it shuts down
516       shutdown-timeout = 1s
517
518       # Throughput defines the number of messages that are processed in a batch
519       # before the thread is returned to the pool. Set to 1 for as fair as possible.
520       throughput = 5
521
522       # Throughput deadline for Dispatcher, set to 0 or negative for no deadline
523       throughput-deadline-time = 0ms
524
525       # For BalancingDispatcher: If the balancing dispatcher should attempt to
526       # schedule idle actors using the same dispatcher when a message comes in,
527       # and the dispatchers ExecutorService is not fully busy already.
528       attempt-teamwork = on
529
530       # If this dispatcher requires a specific type of mailbox, specify the
531       # fully-qualified class name here; the actually created mailbox will
532       # be a subtype of this type. The empty string signifies no requirement.
533       mailbox-requirement = ""
534     }
535
536     default-blocking-io-dispatcher {
537       type = "Dispatcher"
538       executor = "thread-pool-executor"
539       throughput = 1
540
541       thread-pool-executor {
542         fixed-pool-size = 16
543       }
544     }
545
546     default-mailbox {
547       # FQCN of the MailboxType. The Class of the FQCN must have a public
548       # constructor with
549       # (akka.actor.ActorSystem.Settings, com.typesafe.config.Config) parameters.
550       mailbox-type = "akka.dispatch.UnboundedMailbox"
551
552       # If the mailbox is bounded then it uses this setting to determine its
553       # capacity. The provided value must be positive.
554       # NOTICE:
555       # Up to version 2.1 the mailbox type was determined based on this setting;
556       # this is no longer the case, the type must explicitly be a bounded mailbox.
557       mailbox-capacity = 1000
558
559       # If the mailbox is bounded then this is the timeout for enqueueing
560       # in case the mailbox is full. Negative values signify infinite
561       # timeout, which should be avoided as it bears the risk of dead-lock.
562       mailbox-push-timeout-time = 10s
563
564       # For Actor with Stash: The default capacity of the stash.
565       # If negative (or zero) then an unbounded stash is used (default)
566       # If positive then a bounded stash is used and the capacity is set using
567       # the property
568       stash-capacity = -1
569     }
570
571     mailbox {
572       # Mapping between message queue semantics and mailbox configurations.
573       # Used by akka.dispatch.RequiresMessageQueue[T] to enforce different
574       # mailbox types on actors.
575       # If your Actor implements RequiresMessageQueue[T], then when you create
576       # an instance of that actor its mailbox type will be decided by looking
577       # up a mailbox configuration via T in this mapping
578       requirements {
579         "akka.dispatch.UnboundedMessageQueueSemantics" =
580           akka.actor.mailbox.unbounded-queue-based
581         "akka.dispatch.BoundedMessageQueueSemantics" =
582           akka.actor.mailbox.bounded-queue-based
583         "akka.dispatch.DequeBasedMessageQueueSemantics" =
584           akka.actor.mailbox.unbounded-deque-based
585         "akka.dispatch.UnboundedDequeBasedMessageQueueSemantics" =
586           akka.actor.mailbox.unbounded-deque-based
587         "akka.dispatch.BoundedDequeBasedMessageQueueSemantics" =
588           akka.actor.mailbox.bounded-deque-based
589         "akka.dispatch.MultipleConsumerSemantics" =
590           akka.actor.mailbox.unbounded-queue-based
591         "akka.dispatch.ControlAwareMessageQueueSemantics" =
592           akka.actor.mailbox.unbounded-control-aware-queue-based
593         "akka.dispatch.UnboundedControlAwareMessageQueueSemantics" =
594           akka.actor.mailbox.unbounded-control-aware-queue-based
595         "akka.dispatch.BoundedControlAwareMessageQueueSemantics" =
596           akka.actor.mailbox.bounded-control-aware-queue-based
597         "akka.event.LoggerMessageQueueSemantics" =
598           akka.actor.mailbox.logger-queue
599       }
600
601       unbounded-queue-based {
602         # FQCN of the MailboxType, The Class of the FQCN must have a public
603         # constructor with (akka.actor.ActorSystem.Settings,
604         # com.typesafe.config.Config) parameters.
605         mailbox-type = "akka.dispatch.UnboundedMailbox"
606       }
607
608       bounded-queue-based {
609         # FQCN of the MailboxType, The Class of the FQCN must have a public
610         # constructor with (akka.actor.ActorSystem.Settings,
611         # com.typesafe.config.Config) parameters.
612         mailbox-type = "akka.dispatch.BoundedMailbox"
613       }
614
615       unbounded-deque-based {
616         # FQCN of the MailboxType, The Class of the FQCN must have a public
617         # constructor with (akka.actor.ActorSystem.Settings,
618         # com.typesafe.config.Config) parameters.
619         mailbox-type = "akka.dispatch.UnboundedDequeBasedMailbox"
620       }
621
622       bounded-deque-based {
623         # FQCN of the MailboxType, The Class of the FQCN must have a public
624         # constructor with (akka.actor.ActorSystem.Settings,
625         # com.typesafe.config.Config) parameters.
626         mailbox-type = "akka.dispatch.BoundedDequeBasedMailbox"
627       }
628
629       unbounded-control-aware-queue-based {
630         # FQCN of the MailboxType, The Class of the FQCN must have a public
631         # constructor with (akka.actor.ActorSystem.Settings,
632         # com.typesafe.config.Config) parameters.
633         mailbox-type = "akka.dispatch.UnboundedControlAwareMailbox"
634       }
635
636       bounded-control-aware-queue-based {
637         # FQCN of the MailboxType, The Class of the FQCN must have a public
638         # constructor with (akka.actor.ActorSystem.Settings,
639         # com.typesafe.config.Config) parameters.
640         mailbox-type = "akka.dispatch.BoundedControlAwareMailbox"
641       }
642
643       # The LoggerMailbox will drain all messages in the mailbox
644       # when the system is shutdown and deliver them to the StandardOutLogger.
645       # Do not change this unless you know what you are doing.
646       logger-queue {
647         mailbox-type = "akka.event.LoggerMailboxType"
648       }
649     }
650
651     debug {
652       # enable function of Actor.loggable(), which is to log any received message
653       # at DEBUG level, see the “Testing Actor Systems” section of the Akka
654       # Documentation at http://akka.io/docs
655       receive = off
656
657       # enable DEBUG logging of all AutoReceiveMessages (Kill, PoisonPill etc.)
658       autoreceive = off
659
660       # enable DEBUG logging of actor lifecycle changes
661       lifecycle = off
662
663       # enable DEBUG logging of all LoggingFSMs for events, transitions and timers
664       fsm = off
665
666       # enable DEBUG logging of subscription changes on the eventStream
667       event-stream = off
668
669       # enable DEBUG logging of unhandled messages
670       unhandled = off
671
672       # enable WARN logging of misconfigured routers
673       router-misconfiguration = off
674     }
675
676     # SECURITY BEST-PRACTICE is to disable java serialization for its multiple
677     # known attack surfaces.
678     #
679     # This setting is a short-cut to
680     # - using DisabledJavaSerializer instead of JavaSerializer
681     # - enable-additional-serialization-bindings = on
682     #
683     # Completely disable the use of `akka.serialization.JavaSerialization` by the
684     # Akka Serialization extension, instead DisabledJavaSerializer will
685     # be inserted which will fail explicitly if attempts to use java serialization are made.
686     #
687     # The log messages emitted by such serializer SHOULD be treated as potential
688     # attacks which the serializer prevented, as they MAY indicate an external operator
689     # attempting to send malicious messages intending to use java serialization as attack vector.
690     # The attempts are logged with the SECURITY marker.
691     #
692     # Please note that this option does not stop you from manually invoking java serialization
693     #
694     # The default value for this might be changed to off in future versions of Akka.
695     allow-java-serialization = on
696
697     # Entries for pluggable serializers and their bindings.
698     serializers {
699       java = "akka.serialization.JavaSerializer"
700       bytes = "akka.serialization.ByteArraySerializer"
701
702       primitive-boolean = "akka.serialization.BooleanSerializer"
703     }
704
705     # Class to Serializer binding. You only need to specify the name of an
706     # interface or abstract base class of the messages. In case of ambiguity it
707     # is using the most specific configured class, or giving a warning and
708     # choosing the “first” one.
709     #
710     # To disable one of the default serializers, assign its class to "none", like
711     # "java.io.Serializable" = none
712     serialization-bindings {
713       "[B" = bytes
714       "java.io.Serializable" = java
715
716       // TODO issue #27330: BooleanSerializer not enabled for serialization in 2.5.x yet
717       #"java.lang.Boolean" = primitive-boolean
718       #"scala.Boolean" = primitive-boolean
719     }
720
721     # Additional serialization-bindings that are replacing Java serialization are
722     # defined in this section for backwards compatibility reasons. They are included
723     # by default but can be excluded for backwards compatibility with Akka 2.4.x.
724     # They can be disabled with enable-additional-serialization-bindings=off.
725     #
726     # This should only be needed for backwards compatibility reasons.
727     enable-additional-serialization-bindings = on
728
729     # Additional serialization-bindings that are replacing Java serialization are
730     # defined in this section for backwards compatibility reasons. They are included
731     # by default but can be excluded for backwards compatibility with Akka 2.4.x.
732     # They can be disabled with enable-additional-serialization-bindings=off.
733     additional-serialization-bindings {
734     }
735
736     # Log warnings when the default Java serialization is used to serialize messages.
737     # The default serializer uses Java serialization which is not very performant and should not
738     # be used in production environments unless you don't care about performance. In that case
739     # you can turn this off.
740     warn-about-java-serializer-usage = on
741
742     # To be used with the above warn-about-java-serializer-usage
743     # When warn-about-java-serializer-usage = on, and this warn-on-no-serialization-verification = off,
744     # warnings are suppressed for classes extending NoSerializationVerificationNeeded
745     # to reduce noize.
746     warn-on-no-serialization-verification = on
747
748     # Configuration namespace of serialization identifiers.
749     # Each serializer implementation must have an entry in the following format:
750     # `akka.actor.serialization-identifiers."FQCN" = ID`
751     # where `FQCN` is fully qualified class name of the serializer implementation
752     # and `ID` is globally unique serializer identifier number.
753     # Identifier values from 0 to 40 are reserved for Akka internal usage.
754     serialization-identifiers {
755       "akka.serialization.JavaSerializer" = 1
756       "akka.serialization.ByteArraySerializer" = 4
757       "akka.serialization.BooleanSerializer" = 35
758     }
759
760     # Configuration items which are used by the akka.actor.ActorDSL._ methods
761     dsl {
762       # Maximum queue size of the actor created by newInbox(); this protects
763       # against faulty programs which use select() and consistently miss messages
764       inbox-size = 1000
765
766       # Default timeout to assume for operations like Inbox.receive et al
767       default-timeout = 5s
768     }
769
770   }
771
772   serialization.protobuf {
773
774     # Additional classes that are allowed even if they are not defined in `serialization-bindings`.
775     # It can be exact class name or name of super class or interfaces (one level).
776     # This is useful when a class is not used for serialization any more and therefore removed
777     # from `serialization-bindings`, but should still be possible to deserialize.
778     whitelist-class = [
779       "com.google.protobuf.GeneratedMessage",
780       "com.google.protobuf.GeneratedMessageV3",
781       "scalapb.GeneratedMessageCompanion",
782       "akka.protobuf.GeneratedMessage"
783     ]
784   }
785
786   # Used to set the behavior of the scheduler.
787   # Changing the default values may change the system behavior drastically so make
788   # sure you know what you're doing! See the Scheduler section of the Akka
789   # Documentation for more details.
790   scheduler {
791     # The LightArrayRevolverScheduler is used as the default scheduler in the
792     # system. It does not execute the scheduled tasks on exact time, but on every
793     # tick, it will run everything that is (over)due. You can increase or decrease
794     # the accuracy of the execution timing by specifying smaller or larger tick
795     # duration. If you are scheduling a lot of tasks you should consider increasing
796     # the ticks per wheel.
797     # Note that it might take up to 1 tick to stop the Timer, so setting the
798     # tick-duration to a high value will make shutting down the actor system
799     # take longer.
800     tick-duration = 10ms
801
802     # The timer uses a circular wheel of buckets to store the timer tasks.
803     # This should be set such that the majority of scheduled timeouts (for high
804     # scheduling frequency) will be shorter than one rotation of the wheel
805     # (ticks-per-wheel * ticks-duration)
806     # THIS MUST BE A POWER OF TWO!
807     ticks-per-wheel = 512
808
809     # This setting selects the timer implementation which shall be loaded at
810     # system start-up.
811     # The class given here must implement the akka.actor.Scheduler interface
812     # and offer a public constructor which takes three arguments:
813     #  1) com.typesafe.config.Config
814     #  2) akka.event.LoggingAdapter
815     #  3) java.util.concurrent.ThreadFactory
816     implementation = akka.actor.LightArrayRevolverScheduler
817
818     # When shutting down the scheduler, there will typically be a thread which
819     # needs to be stopped, and this timeout determines how long to wait for
820     # that to happen. In case of timeout the shutdown of the actor system will
821     # proceed without running possibly still enqueued tasks.
822     shutdown-timeout = 5s
823   }
824
825   io {
826
827     # By default the select loops run on dedicated threads, hence using a
828     # PinnedDispatcher
829     pinned-dispatcher {
830       type = "PinnedDispatcher"
831       executor = "thread-pool-executor"
832       thread-pool-executor.allow-core-timeout = off
833     }
834
835     tcp {
836
837       # The number of selectors to stripe the served channels over; each of
838       # these will use one select loop on the selector-dispatcher.
839       nr-of-selectors = 1
840
841       # Maximum number of open channels supported by this TCP module; there is
842       # no intrinsic general limit, this setting is meant to enable DoS
843       # protection by limiting the number of concurrently connected clients.
844       # Also note that this is a "soft" limit; in certain cases the implementation
845       # will accept a few connections more or a few less than the number configured
846       # here. Must be an integer > 0 or "unlimited".
847       max-channels = 256000
848
849       # When trying to assign a new connection to a selector and the chosen
850       # selector is at full capacity, retry selector choosing and assignment
851       # this many times before giving up
852       selector-association-retries = 10
853
854       # The maximum number of connection that are accepted in one go,
855       # higher numbers decrease latency, lower numbers increase fairness on
856       # the worker-dispatcher
857       batch-accept-limit = 10
858
859       # The number of bytes per direct buffer in the pool used to read or write
860       # network data from the kernel.
861       direct-buffer-size = 128 KiB
862
863       # The maximal number of direct buffers kept in the direct buffer pool for
864       # reuse.
865       direct-buffer-pool-limit = 1000
866
867       # The duration a connection actor waits for a `Register` message from
868       # its commander before aborting the connection.
869       register-timeout = 5s
870
871       # The maximum number of bytes delivered by a `Received` message. Before
872       # more data is read from the network the connection actor will try to
873       # do other work.
874       # The purpose of this setting is to impose a smaller limit than the
875       # configured receive buffer size. When using value 'unlimited' it will
876       # try to read all from the receive buffer.
877       max-received-message-size = unlimited
878
879       # Enable fine grained logging of what goes on inside the implementation.
880       # Be aware that this may log more than once per message sent to the actors
881       # of the tcp implementation.
882       trace-logging = off
883
884       # Fully qualified config path which holds the dispatcher configuration
885       # to be used for running the select() calls in the selectors
886       selector-dispatcher = "akka.io.pinned-dispatcher"
887
888       # Fully qualified config path which holds the dispatcher configuration
889       # for the read/write worker actors
890       worker-dispatcher = "akka.actor.default-dispatcher"
891
892       # Fully qualified config path which holds the dispatcher configuration
893       # for the selector management actors
894       management-dispatcher = "akka.actor.default-dispatcher"
895
896       # Fully qualified config path which holds the dispatcher configuration
897       # on which file IO tasks are scheduled
898       file-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
899
900       # The maximum number of bytes (or "unlimited") to transfer in one batch
901       # when using `WriteFile` command which uses `FileChannel.transferTo` to
902       # pipe files to a TCP socket. On some OS like Linux `FileChannel.transferTo`
903       # may block for a long time when network IO is faster than file IO.
904       # Decreasing the value may improve fairness while increasing may improve
905       # throughput.
906       file-io-transferTo-limit = 512 KiB
907
908       # The number of times to retry the `finishConnect` call after being notified about
909       # OP_CONNECT. Retries are needed if the OP_CONNECT notification doesn't imply that
910       # `finishConnect` will succeed, which is the case on Android.
911       finish-connect-retries = 5
912
913       # On Windows connection aborts are not reliably detected unless an OP_READ is
914       # registered on the selector _after_ the connection has been reset. This
915       # workaround enables an OP_CONNECT which forces the abort to be visible on Windows.
916       # Enabling this setting on other platforms than Windows will cause various failures
917       # and undefined behavior.
918       # Possible values of this key are on, off and auto where auto will enable the
919       # workaround if Windows is detected automatically.
920       windows-connection-abort-workaround-enabled = off
921     }
922
923     udp {
924
925       # The number of selectors to stripe the served channels over; each of
926       # these will use one select loop on the selector-dispatcher.
927       nr-of-selectors = 1
928
929       # Maximum number of open channels supported by this UDP module Generally
930       # UDP does not require a large number of channels, therefore it is
931       # recommended to keep this setting low.
932       max-channels = 4096
933
934       # The select loop can be used in two modes:
935       # - setting "infinite" will select without a timeout, hogging a thread
936       # - setting a positive timeout will do a bounded select call,
937       #   enabling sharing of a single thread between multiple selectors
938       #   (in this case you will have to use a different configuration for the
939       #   selector-dispatcher, e.g. using "type=Dispatcher" with size 1)
940       # - setting it to zero means polling, i.e. calling selectNow()
941       select-timeout = infinite
942
943       # When trying to assign a new connection to a selector and the chosen
944       # selector is at full capacity, retry selector choosing and assignment
945       # this many times before giving up
946       selector-association-retries = 10
947
948       # The maximum number of datagrams that are read in one go,
949       # higher numbers decrease latency, lower numbers increase fairness on
950       # the worker-dispatcher
951       receive-throughput = 3
952
953       # The number of bytes per direct buffer in the pool used to read or write
954       # network data from the kernel.
955       direct-buffer-size = 128 KiB
956
957       # The maximal number of direct buffers kept in the direct buffer pool for
958       # reuse.
959       direct-buffer-pool-limit = 1000
960
961       # Enable fine grained logging of what goes on inside the implementation.
962       # Be aware that this may log more than once per message sent to the actors
963       # of the tcp implementation.
964       trace-logging = off
965
966       # Fully qualified config path which holds the dispatcher configuration
967       # to be used for running the select() calls in the selectors
968       selector-dispatcher = "akka.io.pinned-dispatcher"
969
970       # Fully qualified config path which holds the dispatcher configuration
971       # for the read/write worker actors
972       worker-dispatcher = "akka.actor.default-dispatcher"
973
974       # Fully qualified config path which holds the dispatcher configuration
975       # for the selector management actors
976       management-dispatcher = "akka.actor.default-dispatcher"
977     }
978
979     udp-connected {
980
981       # The number of selectors to stripe the served channels over; each of
982       # these will use one select loop on the selector-dispatcher.
983       nr-of-selectors = 1
984
985       # Maximum number of open channels supported by this UDP module Generally
986       # UDP does not require a large number of channels, therefore it is
987       # recommended to keep this setting low.
988       max-channels = 4096
989
990       # The select loop can be used in two modes:
991       # - setting "infinite" will select without a timeout, hogging a thread
992       # - setting a positive timeout will do a bounded select call,
993       #   enabling sharing of a single thread between multiple selectors
994       #   (in this case you will have to use a different configuration for the
995       #   selector-dispatcher, e.g. using "type=Dispatcher" with size 1)
996       # - setting it to zero means polling, i.e. calling selectNow()
997       select-timeout = infinite
998
999       # When trying to assign a new connection to a selector and the chosen
1000       # selector is at full capacity, retry selector choosing and assignment
1001       # this many times before giving up
1002       selector-association-retries = 10
1003
1004       # The maximum number of datagrams that are read in one go,
1005       # higher numbers decrease latency, lower numbers increase fairness on
1006       # the worker-dispatcher
1007       receive-throughput = 3
1008
1009       # The number of bytes per direct buffer in the pool used to read or write
1010       # network data from the kernel.
1011       direct-buffer-size = 128 KiB
1012
1013       # The maximal number of direct buffers kept in the direct buffer pool for
1014       # reuse.
1015       direct-buffer-pool-limit = 1000
1016
1017       # Enable fine grained logging of what goes on inside the implementation.
1018       # Be aware that this may log more than once per message sent to the actors
1019       # of the tcp implementation.
1020       trace-logging = off
1021
1022       # Fully qualified config path which holds the dispatcher configuration
1023       # to be used for running the select() calls in the selectors
1024       selector-dispatcher = "akka.io.pinned-dispatcher"
1025
1026       # Fully qualified config path which holds the dispatcher configuration
1027       # for the read/write worker actors
1028       worker-dispatcher = "akka.actor.default-dispatcher"
1029
1030       # Fully qualified config path which holds the dispatcher configuration
1031       # for the selector management actors
1032       management-dispatcher = "akka.actor.default-dispatcher"
1033     }
1034
1035     dns {
1036       # Fully qualified config path which holds the dispatcher configuration
1037       # for the manager and resolver router actors.
1038       # For actual router configuration see akka.actor.deployment./IO-DNS/*
1039       dispatcher = "akka.actor.default-dispatcher"
1040
1041       # Name of the subconfig at path akka.io.dns, see inet-address below
1042       #
1043       # Change to `async-dns` to use the new "native" DNS resolver,
1044       # which is also capable of resolving SRV records.
1045       resolver = "inet-address"
1046
1047       # To-be-deprecated DNS resolver implementation which uses the Java InetAddress to resolve DNS records.
1048       # To be replaced by `akka.io.dns.async` which implements the DNS protocol natively and without blocking (which InetAddress does)
1049       inet-address {
1050         # Must implement akka.io.DnsProvider
1051         provider-object = "akka.io.InetAddressDnsProvider"
1052
1053         # To set the time to cache name resolutions
1054         # Possible values:
1055         # default: sun.net.InetAddressCachePolicy.get() and getNegative()
1056         # forever: cache forever
1057         # never: no caching
1058         # n [time unit]: positive timeout with unit, for example 30s
1059         positive-ttl = default
1060         negative-ttl = default
1061
1062         # How often to sweep out expired cache entries.
1063         # Note that this interval has nothing to do with TTLs
1064         cache-cleanup-interval = 120s
1065       }
1066
1067       async-dns {
1068         provider-object = "akka.io.dns.internal.AsyncDnsProvider"
1069
1070         # Set upper bound for caching successfully resolved dns entries
1071         # if the DNS record has a smaller TTL value than the setting that
1072         # will be used. Default is to use the record TTL with no cap.
1073         # Possible values:
1074         # forever: always use the minimum TTL from the found records
1075         # never: never cache
1076         # n [time unit] = cap the caching to this value
1077         positive-ttl = forever
1078
1079         # Set how long the fact that a DNS record could not be found is
1080         # cached. If a new resolution is done while the fact is cached it will
1081         # be failed and not result in an actual DNS resolution. Default is
1082         # to never cache.
1083         # Possible values:
1084         # never: never cache
1085         # forever: cache a missing DNS record forever (you probably will not want to do this)
1086         # n [time unit] = cache for this long
1087         negative-ttl = never
1088
1089         # Configures nameservers to query during DNS resolution.
1090         # Defaults to the nameservers that would be used by the JVM by default.
1091         # Set to a list of IPs to override the servers, e.g. [ "8.8.8.8", "8.8.4.4" ] for Google's servers
1092         # If multiple are defined then they are tried in order until one responds
1093         nameservers = default
1094
1095         # The time that a request is allowed to live before being discarded
1096         # given no reply. The lower bound of this should always be the amount
1097         # of time to reasonably expect a DNS server to reply within.
1098         # If multiple name servers are provided then each gets this long to response before trying
1099         # the next one
1100         resolve-timeout = 5s
1101
1102         # How often to sweep out expired cache entries.
1103         # Note that this interval has nothing to do with TTLs
1104         cache-cleanup-interval = 120s
1105
1106         # Configures the list of search domains.
1107         # Defaults to a system dependent lookup (on Unix like OSes, will attempt to parse /etc/resolv.conf, on
1108         # other platforms, will not make any attempt to lookup the search domains). Set to a single domain, or
1109         # a list of domains, eg, [ "example.com", "example.net" ].
1110         search-domains = default
1111
1112         # Any hosts that have a number of dots less than this will not be looked up directly, instead, a search on
1113         # the search domains will be tried first. This corresponds to the ndots option in /etc/resolv.conf, see
1114         # https://linux.die.net/man/5/resolver for more info.
1115         # Defaults to a system dependent lookup (on Unix like OSes, will attempt to parse /etc/resolv.conf, on
1116         # other platforms, will default to 1).
1117         ndots = default
1118       }
1119     }
1120   }
1121
1122
1123   # CoordinatedShutdown is an extension that will perform registered
1124   # tasks in the order that is defined by the phases. It is started
1125   # by calling CoordinatedShutdown(system).run(). This can be triggered
1126   # by different things, for example:
1127   # - JVM shutdown hook will by default run CoordinatedShutdown
1128   # - Cluster node will automatically run CoordinatedShutdown when it
1129   #   sees itself as Exiting
1130   # - A management console or other application specific command can
1131   #   run CoordinatedShutdown
1132   coordinated-shutdown {
1133     # The timeout that will be used for a phase if not specified with
1134     # 'timeout' in the phase
1135     default-phase-timeout = 5 s
1136
1137     # Terminate the ActorSystem in the last phase actor-system-terminate.
1138     terminate-actor-system = on
1139
1140     # Exit the JVM (System.exit(0)) in the last phase actor-system-terminate
1141     # if this is set to 'on'. It is done after termination of the
1142     # ActorSystem if terminate-actor-system=on, otherwise it is done
1143     # immediately when the last phase is reached.
1144     exit-jvm = off
1145
1146     # Exit status to use on System.exit(int) when 'exit-jvm' is 'on'.
1147     exit-code = 0
1148
1149     # Run the coordinated shutdown when the JVM process exits, e.g.
1150     # via kill SIGTERM signal (SIGINT ctrl-c doesn't work).
1151     # This property is related to `akka.jvm-shutdown-hooks` above.
1152     run-by-jvm-shutdown-hook = on
1153
1154     # When Coordinated Shutdown is triggered an instance of `Reason` is
1155     # required. That value can be used to override the default settings.
1156     # Only 'exit-jvm', 'exit-code' and 'terminate-actor-system' may be
1157     # overridden depending on the reason.
1158     reason-overrides {
1159       # Overrides are applied using the `reason.getClass.getName`.
1160       # Overrides the `exit-code` when the `Reason` is a cluster
1161       # Downing or a Cluster Join Unsuccessful event
1162       "akka.actor.CoordinatedShutdown$ClusterDowningReason$" {
1163         exit-code = -1
1164       }
1165       "akka.actor.CoordinatedShutdown$ClusterJoinUnsuccessfulReason$" {
1166         exit-code = -1
1167       }
1168     }
1169
1170     #//#coordinated-shutdown-phases
1171     # CoordinatedShutdown is enabled by default and will run the tasks that
1172     # are added to these phases by individual Akka modules and user logic.
1173     #
1174     # The phases are ordered as a DAG by defining the dependencies between the phases
1175     # to make sure shutdown tasks are run in the right order.
1176     #
1177     # In general user tasks belong in the first few phases, but there may be use
1178     # cases where you would want to hook in new phases or register tasks later in
1179     # the DAG.
1180     #
1181     # Each phase is defined as a named config section with the
1182     # following optional properties:
1183     # - timeout=15s: Override the default-phase-timeout for this phase.
1184     # - recover=off: If the phase fails the shutdown is aborted
1185     #                and depending phases will not be executed.
1186     # - enabled=off: Skip all tasks registered in this phase. DO NOT use
1187     #                this to disable phases unless you are absolutely sure what the
1188     #                consequences are. Many of the built in tasks depend on other tasks
1189     #                having been executed in earlier phases and may break if those are disabled.
1190     # depends-on=[]: Run the phase after the given phases
1191     phases {
1192
1193       # The first pre-defined phase that applications can add tasks to.
1194       # Note that more phases can be added in the application's
1195       # configuration by overriding this phase with an additional
1196       # depends-on.
1197       before-service-unbind {
1198       }
1199
1200       # Stop accepting new incoming connections.
1201       # This is where you can register tasks that makes a server stop accepting new connections. Already
1202       # established connections should be allowed to continue and complete if possible.
1203       service-unbind {
1204         depends-on = [before-service-unbind]
1205       }
1206
1207       # Wait for requests that are in progress to be completed.
1208       # This is where you register tasks that will wait for already established connections to complete, potentially
1209       # also first telling them that it is time to close down.
1210       service-requests-done {
1211         depends-on = [service-unbind]
1212       }
1213
1214       # Final shutdown of service endpoints.
1215       # This is where you would add tasks that forcefully kill connections that are still around.
1216       service-stop {
1217         depends-on = [service-requests-done]
1218       }
1219
1220       # Phase for custom application tasks that are to be run
1221       # after service shutdown and before cluster shutdown.
1222       before-cluster-shutdown {
1223         depends-on = [service-stop]
1224       }
1225
1226       # Graceful shutdown of the Cluster Sharding regions.
1227       # This phase is not meant for users to add tasks to.
1228       cluster-sharding-shutdown-region {
1229         timeout = 10 s
1230         depends-on = [before-cluster-shutdown]
1231       }
1232
1233       # Emit the leave command for the node that is shutting down.
1234       # This phase is not meant for users to add tasks to.
1235       cluster-leave {
1236         depends-on = [cluster-sharding-shutdown-region]
1237       }
1238
1239       # Shutdown cluster singletons
1240       # This is done as late as possible to allow the shard region shutdown triggered in
1241       # the "cluster-sharding-shutdown-region" phase to complete before the shard coordinator is shut down.
1242       # This phase is not meant for users to add tasks to.
1243       cluster-exiting {
1244         timeout = 10 s
1245         depends-on = [cluster-leave]
1246       }
1247
1248       # Wait until exiting has been completed
1249       # This phase is not meant for users to add tasks to.
1250       cluster-exiting-done {
1251         depends-on = [cluster-exiting]
1252       }
1253
1254       # Shutdown the cluster extension
1255       # This phase is not meant for users to add tasks to.
1256       cluster-shutdown {
1257         depends-on = [cluster-exiting-done]
1258       }
1259
1260       # Phase for custom application tasks that are to be run
1261       # after cluster shutdown and before ActorSystem termination.
1262       before-actor-system-terminate {
1263         depends-on = [cluster-shutdown]
1264       }
1265
1266       # Last phase. See terminate-actor-system and exit-jvm above.
1267       # Don't add phases that depends on this phase because the
1268       # dispatcher and scheduler of the ActorSystem have been shutdown.
1269       # This phase is not meant for users to add tasks to.
1270       actor-system-terminate {
1271         timeout = 10 s
1272         depends-on = [before-actor-system-terminate]
1273       }
1274     }
1275     #//#coordinated-shutdown-phases
1276   }
1277
1278 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.