--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <parent>
+ <groupId>org.opendaylight.odlparent</groupId>
+ <artifactId>odlparent-lite</artifactId>
+ <version>7.0.6</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>akka-aggregator</artifactId>
+ <version>3.0.0-SNAPSHOT</version>
+ <packaging>pom</packaging>
+
+ <properties>
+ <maven.deploy.skip>true</maven.deploy.skip>
+ <maven.install.skip>true</maven.install.skip>
+ </properties>
+
+ <modules>
+ <module>repackaged-akka-jar</module>
+ <module>repackaged-akka</module>
+ </modules>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.odlparent</groupId>
+ <artifactId>odlparent</artifactId>
+ <version>7.0.6</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>repackaged-akka-jar</artifactId>
+ <packaging>jar</packaging>
+ <version>3.0.0-SNAPSHOT</version>
+ <name>${project.artifactId}</name>
+
+ <properties>
+ <!-- We do not want to leak this artifact -->
+ <maven.deploy.skip>true</maven.deploy.skip>
+ </properties>
+
+ <dependencies>
+ <!-- Note: when bumping versions, make sure to update configurations in src/main/resources -->
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-actor_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-cluster_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-osgi_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-persistence_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-protobuf_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-remote_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-slf4j_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe.akka</groupId>
+ <artifactId>akka-stream_2.13</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>unpack-license</id>
+ <configuration>
+ <!-- Akka is Apache-2.0 licensed -->
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <artifactId>maven-shade-plugin</artifactId>
+ <executions>
+ <execution>
+ <phase>package</phase>
+ <goals>
+ <goal>shade</goal>
+ </goals>
+ <configuration>
+ <createDependencyReducedPom>false</createDependencyReducedPom>
+ <shadeSourcesContent>true</shadeSourcesContent>
+ <createSourcesJar>true</createSourcesJar>
+ <promoteTransitiveDependencies>true</promoteTransitiveDependencies>
+ <artifactSet>
+ <includes>
+ <include>com.typesafe.akka</include>
+ </includes>
+ </artifactSet>
+ <filters>
+ <filter>
+ <artifact>com.typesafe.akka:*</artifact>
+ <excludes>
+ <exclude>META-INF/MANIFEST.MF</exclude>
+ <exclude>reference.conf</exclude>
+ </excludes>
+ </filter>
+ </filters>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+</project>
--- /dev/null
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+---------------
+
+Licenses for dependency projects can be found here:
+[http://akka.io/docs/akka/snapshot/project/licenses.html]
+
+---------------
+
+akka-protobuf contains the sources of Google protobuf 2.5.0 runtime support,
+moved into the source package `akka.protobuf` so as to avoid version conflicts.
+For license information see COPYING.protobuf
--- /dev/null
+####################################
+# Akka Actor Reference Config File #
+####################################
+
+# This is the reference config file that contains all the default settings.
+# Make your edits/overrides in your application.conf.
+
+# Akka version, checked against the runtime version of Akka. Loaded from generated conf file.
+include "version"
+
+akka {
+ # Home directory of Akka, modules in the deploy directory will be loaded
+ home = ""
+
+ # Loggers to register at boot time (akka.event.Logging$DefaultLogger logs
+ # to STDOUT)
+ loggers = ["akka.event.Logging$DefaultLogger"]
+
+ # Filter of log events that is used by the LoggingAdapter before
+ # publishing log events to the eventStream. It can perform
+ # fine grained filtering based on the log source. The default
+ # implementation filters on the `loglevel`.
+ # FQCN of the LoggingFilter. The Class of the FQCN must implement
+ # akka.event.LoggingFilter and have a public constructor with
+ # (akka.actor.ActorSystem.Settings, akka.event.EventStream) parameters.
+ logging-filter = "akka.event.DefaultLoggingFilter"
+
+ # Specifies the default loggers dispatcher
+ loggers-dispatcher = "akka.actor.default-dispatcher"
+
+ # Loggers are created and registered synchronously during ActorSystem
+ # start-up, and since they are actors, this timeout is used to bound the
+ # waiting time
+ logger-startup-timeout = 5s
+
+ # Log level used by the configured loggers (see "loggers") as soon
+ # as they have been started; before that, see "stdout-loglevel"
+ # Options: OFF, ERROR, WARNING, INFO, DEBUG
+ loglevel = "INFO"
+
+ # Log level for the very basic logger activated during ActorSystem startup.
+ # This logger prints the log messages to stdout (System.out).
+ # Options: OFF, ERROR, WARNING, INFO, DEBUG
+ stdout-loglevel = "WARNING"
+
+ # Log the complete configuration at INFO level when the actor system is started.
+ # This is useful when you are uncertain of what configuration is used.
+ log-config-on-start = off
+
+ # Log at info level when messages are sent to dead letters.
+ # Possible values:
+ # on: all dead letters are logged
+ # off: no logging of dead letters
+ # n: positive integer, number of dead letters that will be logged
+ log-dead-letters = 10
+
+ # Possibility to turn off logging of dead letters while the actor system
+ # is shutting down. Logging is only done when enabled by 'log-dead-letters'
+ # setting.
+ log-dead-letters-during-shutdown = on
+
+ # List FQCN of extensions which shall be loaded at actor system startup.
+ # Library extensions are regular extensions that are loaded at startup and are
+ # available for third party library authors to enable auto-loading of extensions when
+ # present on the classpath. This is done by appending entries:
+ # 'library-extensions += "Extension"' in the library `reference.conf`.
+ #
+ # Should not be set by end user applications in 'application.conf', use the extensions property for that
+ #
+ library-extensions = ${?akka.library-extensions} ["akka.serialization.SerializationExtension"]
+
+ # List FQCN of extensions which shall be loaded at actor system startup.
+ # Should be on the format: 'extensions = ["foo", "bar"]' etc.
+ # See the Akka Documentation for more info about Extensions
+ extensions = []
+
+ # Toggles whether threads created by this ActorSystem should be daemons or not
+ daemonic = off
+
+ # JVM shutdown, System.exit(-1), in case of a fatal error,
+ # such as OutOfMemoryError
+ jvm-exit-on-fatal-error = on
+
+ # Akka installs JVM shutdown hooks by default, e.g. in CoordinatedShutdown and Artery. This property will
+ # not disable user-provided hooks registered using `CoordinatedShutdown#addCancellableJvmShutdownHook`.
+ # This property is related to `akka.coordinated-shutdown.run-by-jvm-shutdown-hook` below.
+ # This property makes it possible to disable all such hooks if the application itself
+ # or a higher level framework such as Play prefers to install the JVM shutdown hook and
+ # terminate the ActorSystem itself, with or without using CoordinatedShutdown.
+ jvm-shutdown-hooks = on
+
+ actor {
+
+ # Either one of "local", "remote" or "cluster" or the
+ # FQCN of the ActorRefProvider to be used; the below is the built-in default,
+ # note that "remote" and "cluster" requires the akka-remote and akka-cluster
+ # artifacts to be on the classpath.
+ provider = "local"
+
+ # The guardian "/user" will use this class to obtain its supervisorStrategy.
+ # It needs to be a subclass of akka.actor.SupervisorStrategyConfigurator.
+ # In addition to the default there is akka.actor.StoppingSupervisorStrategy.
+ guardian-supervisor-strategy = "akka.actor.DefaultSupervisorStrategy"
+
+ # Timeout for ActorSystem.actorOf
+ creation-timeout = 20s
+
+ # Serializes and deserializes (non-primitive) messages to ensure immutability,
+ # this is only intended for testing.
+ serialize-messages = off
+
+ # Additional serialization bindings which are enabled automatically when allow-java-serialization is disabled.
+ # settings are provided
+ java-serialization-disabled-additional-serialization-bindings = {}
+
+ # Serializes and deserializes creators (in Props) to ensure that they can be
+ # sent over the network, this is only intended for testing. Purely local deployments
+ # as marked with deploy.scope == LocalScope are exempt from verification.
+ serialize-creators = off
+
+ # Timeout for send operations to top-level actors which are in the process
+ # of being started. This is only relevant if using a bounded mailbox or the
+ # CallingThreadDispatcher for a top-level actor.
+ unstarted-push-timeout = 10s
+
+ typed {
+ # Default timeout for typed actor methods with non-void return type
+ timeout = 5s
+ }
+
+ # Mapping between ´deployment.router' short names to fully qualified class names
+ router.type-mapping {
+ from-code = "akka.routing.NoRouter"
+ round-robin-pool = "akka.routing.RoundRobinPool"
+ round-robin-group = "akka.routing.RoundRobinGroup"
+ random-pool = "akka.routing.RandomPool"
+ random-group = "akka.routing.RandomGroup"
+ balancing-pool = "akka.routing.BalancingPool"
+ smallest-mailbox-pool = "akka.routing.SmallestMailboxPool"
+ broadcast-pool = "akka.routing.BroadcastPool"
+ broadcast-group = "akka.routing.BroadcastGroup"
+ scatter-gather-pool = "akka.routing.ScatterGatherFirstCompletedPool"
+ scatter-gather-group = "akka.routing.ScatterGatherFirstCompletedGroup"
+ tail-chopping-pool = "akka.routing.TailChoppingPool"
+ tail-chopping-group = "akka.routing.TailChoppingGroup"
+ consistent-hashing-pool = "akka.routing.ConsistentHashingPool"
+ consistent-hashing-group = "akka.routing.ConsistentHashingGroup"
+ }
+
+ deployment {
+
+ # deployment id pattern - on the format: /parent/child etc.
+ default {
+
+ # The id of the dispatcher to use for this actor.
+ # If undefined or empty the dispatcher specified in code
+ # (Props.withDispatcher) is used, or default-dispatcher if not
+ # specified at all.
+ dispatcher = ""
+
+ # The id of the mailbox to use for this actor.
+ # If undefined or empty the default mailbox of the configured dispatcher
+ # is used or if there is no mailbox configuration the mailbox specified
+ # in code (Props.withMailbox) is used.
+ # If there is a mailbox defined in the configured dispatcher then that
+ # overrides this setting.
+ mailbox = ""
+
+ # routing (load-balance) scheme to use
+ # - available: "from-code", "round-robin", "random", "smallest-mailbox",
+ # "scatter-gather", "broadcast"
+ # - or: Fully qualified class name of the router class.
+ # The class must extend akka.routing.CustomRouterConfig and
+ # have a public constructor with com.typesafe.config.Config
+ # and optional akka.actor.DynamicAccess parameter.
+ # - default is "from-code";
+ # Whether or not an actor is transformed to a Router is decided in code
+ # only (Props.withRouter). The type of router can be overridden in the
+ # configuration; specifying "from-code" means that the values specified
+ # in the code shall be used.
+ # In case of routing, the actors to be routed to can be specified
+ # in several ways:
+ # - nr-of-instances: will create that many children
+ # - routees.paths: will route messages to these paths using ActorSelection,
+ # i.e. will not create children
+ # - resizer: dynamically resizable number of routees as specified in
+ # resizer below
+ router = "from-code"
+
+ # number of children to create in case of a router;
+ # this setting is ignored if routees.paths is given
+ nr-of-instances = 1
+
+ # within is the timeout used for routers containing future calls
+ within = 5 seconds
+
+ # number of virtual nodes per node for consistent-hashing router
+ virtual-nodes-factor = 10
+
+ tail-chopping-router {
+ # interval is duration between sending message to next routee
+ interval = 10 milliseconds
+ }
+
+ routees {
+ # Alternatively to giving nr-of-instances you can specify the full
+ # paths of those actors which should be routed to. This setting takes
+ # precedence over nr-of-instances
+ paths = []
+ }
+
+ # To use a dedicated dispatcher for the routees of the pool you can
+ # define the dispatcher configuration inline with the property name
+ # 'pool-dispatcher' in the deployment section of the router.
+ # For example:
+ # pool-dispatcher {
+ # fork-join-executor.parallelism-min = 5
+ # fork-join-executor.parallelism-max = 5
+ # }
+
+ # Routers with dynamically resizable number of routees; this feature is
+ # enabled by including (parts of) this section in the deployment
+ resizer {
+
+ enabled = off
+
+ # The fewest number of routees the router should ever have.
+ lower-bound = 1
+
+ # The most number of routees the router should ever have.
+ # Must be greater than or equal to lower-bound.
+ upper-bound = 10
+
+ # Threshold used to evaluate if a routee is considered to be busy
+ # (under pressure). Implementation depends on this value (default is 1).
+ # 0: number of routees currently processing a message.
+ # 1: number of routees currently processing a message has
+ # some messages in mailbox.
+ # > 1: number of routees with at least the configured pressure-threshold
+ # messages in their mailbox. Note that estimating mailbox size of
+ # default UnboundedMailbox is O(N) operation.
+ pressure-threshold = 1
+
+ # Percentage to increase capacity whenever all routees are busy.
+ # For example, 0.2 would increase 20% (rounded up), i.e. if current
+ # capacity is 6 it will request an increase of 2 more routees.
+ rampup-rate = 0.2
+
+ # Minimum fraction of busy routees before backing off.
+ # For example, if this is 0.3, then we'll remove some routees only when
+ # less than 30% of routees are busy, i.e. if current capacity is 10 and
+ # 3 are busy then the capacity is unchanged, but if 2 or less are busy
+ # the capacity is decreased.
+ # Use 0.0 or negative to avoid removal of routees.
+ backoff-threshold = 0.3
+
+ # Fraction of routees to be removed when the resizer reaches the
+ # backoffThreshold.
+ # For example, 0.1 would decrease 10% (rounded up), i.e. if current
+ # capacity is 9 it will request an decrease of 1 routee.
+ backoff-rate = 0.1
+
+ # Number of messages between resize operation.
+ # Use 1 to resize before each message.
+ messages-per-resize = 10
+ }
+
+ # Routers with dynamically resizable number of routees based on
+ # performance metrics.
+ # This feature is enabled by including (parts of) this section in
+ # the deployment, cannot be enabled together with default resizer.
+ optimal-size-exploring-resizer {
+
+ enabled = off
+
+ # The fewest number of routees the router should ever have.
+ lower-bound = 1
+
+ # The most number of routees the router should ever have.
+ # Must be greater than or equal to lower-bound.
+ upper-bound = 10
+
+ # probability of doing a ramping down when all routees are busy
+ # during exploration.
+ chance-of-ramping-down-when-full = 0.2
+
+ # Interval between each resize attempt
+ action-interval = 5s
+
+ # If the routees have not been fully utilized (i.e. all routees busy)
+ # for such length, the resizer will downsize the pool.
+ downsize-after-underutilized-for = 72h
+
+ # Duration exploration, the ratio between the largest step size and
+ # current pool size. E.g. if the current pool size is 50, and the
+ # explore-step-size is 0.1, the maximum pool size change during
+ # exploration will be +- 5
+ explore-step-size = 0.1
+
+ # Probability of doing an exploration v.s. optmization.
+ chance-of-exploration = 0.4
+
+ # When downsizing after a long streak of underutilization, the resizer
+ # will downsize the pool to the highest utiliziation multiplied by a
+ # a downsize ratio. This downsize ratio determines the new pools size
+ # in comparison to the highest utilization.
+ # E.g. if the highest utilization is 10, and the down size ratio
+ # is 0.8, the pool will be downsized to 8
+ downsize-ratio = 0.8
+
+ # When optimizing, the resizer only considers the sizes adjacent to the
+ # current size. This number indicates how many adjacent sizes to consider.
+ optimization-range = 16
+
+ # The weight of the latest metric over old metrics when collecting
+ # performance metrics.
+ # E.g. if the last processing speed is 10 millis per message at pool
+ # size 5, and if the new processing speed collected is 6 millis per
+ # message at pool size 5. Given a weight of 0.3, the metrics
+ # representing pool size 5 will be 6 * 0.3 + 10 * 0.7, i.e. 8.8 millis
+ # Obviously, this number should be between 0 and 1.
+ weight-of-latest-metric = 0.5
+ }
+ }
+
+ "/IO-DNS/inet-address" {
+ mailbox = "unbounded"
+ router = "consistent-hashing-pool"
+ nr-of-instances = 4
+ }
+
+ "/IO-DNS/inet-address/*" {
+ dispatcher = "akka.actor.default-blocking-io-dispatcher"
+ }
+
+ "/IO-DNS/async-dns" {
+ mailbox = "unbounded"
+ router = "round-robin-pool"
+ nr-of-instances = 1
+ }
+ }
+
+ default-dispatcher {
+ # Must be one of the following
+ # Dispatcher, PinnedDispatcher, or a FQCN to a class inheriting
+ # MessageDispatcherConfigurator with a public constructor with
+ # both com.typesafe.config.Config parameter and
+ # akka.dispatch.DispatcherPrerequisites parameters.
+ # PinnedDispatcher must be used together with executor=thread-pool-executor.
+ type = "Dispatcher"
+
+ # Which kind of ExecutorService to use for this dispatcher
+ # Valid options:
+ # - "default-executor" requires a "default-executor" section
+ # - "fork-join-executor" requires a "fork-join-executor" section
+ # - "thread-pool-executor" requires a "thread-pool-executor" section
+ # - "affinity-pool-executor" requires an "affinity-pool-executor" section
+ # - A FQCN of a class extending ExecutorServiceConfigurator
+ executor = "default-executor"
+
+ # This will be used if you have set "executor = "default-executor"".
+ # If an ActorSystem is created with a given ExecutionContext, this
+ # ExecutionContext will be used as the default executor for all
+ # dispatchers in the ActorSystem configured with
+ # executor = "default-executor". Note that "default-executor"
+ # is the default value for executor, and therefore used if not
+ # specified otherwise. If no ExecutionContext is given,
+ # the executor configured in "fallback" will be used.
+ default-executor {
+ fallback = "fork-join-executor"
+ }
+
+ # This will be used if you have set "executor = "affinity-pool-executor""
+ # Underlying thread pool implementation is akka.dispatch.affinity.AffinityPool.
+ # This executor is classified as "ApiMayChange".
+ affinity-pool-executor {
+ # Min number of threads to cap factor-based parallelism number to
+ parallelism-min = 4
+
+ # The parallelism factor is used to determine thread pool size using the
+ # following formula: ceil(available processors * factor). Resulting size
+ # is then bounded by the parallelism-min and parallelism-max values.
+ parallelism-factor = 0.8
+
+ # Max number of threads to cap factor-based parallelism number to.
+ parallelism-max = 64
+
+ # Each worker in the pool uses a separate bounded MPSC queue. This value
+ # indicates the upper bound of the queue. Whenever an attempt to enqueue
+ # a task is made and the queue does not have capacity to accommodate
+ # the task, the rejection handler created by the rejection handler specified
+ # in "rejection-handler" is invoked.
+ task-queue-size = 512
+
+ # FQCN of the Rejection handler used in the pool.
+ # Must have an empty public constructor and must
+ # implement akka.actor.affinity.RejectionHandlerFactory.
+ rejection-handler = "akka.dispatch.affinity.ThrowOnOverflowRejectionHandler"
+
+ # Level of CPU time used, on a scale between 1 and 10, during backoff/idle.
+ # The tradeoff is that to have low latency more CPU time must be used to be
+ # able to react quickly on incoming messages or send as fast as possible after
+ # backoff backpressure.
+ # Level 1 strongly prefer low CPU consumption over low latency.
+ # Level 10 strongly prefer low latency over low CPU consumption.
+ idle-cpu-level = 5
+
+ # FQCN of the akka.dispatch.affinity.QueueSelectorFactory.
+ # The Class of the FQCN must have a public constructor with a
+ # (com.typesafe.config.Config) parameter.
+ # A QueueSelectorFactory create instances of akka.dispatch.affinity.QueueSelector,
+ # that is responsible for determining which task queue a Runnable should be enqueued in.
+ queue-selector = "akka.dispatch.affinity.FairDistributionHashCache"
+
+ # When using the "akka.dispatch.affinity.FairDistributionHashCache" queue selector
+ # internally the AffinityPool uses two methods to determine which task
+ # queue to allocate a Runnable to:
+ # - map based - maintains a round robin counter and a map of Runnable
+ # hashcodes to queues that they have been associated with. This ensures
+ # maximum fairness in terms of work distribution, meaning that each worker
+ # will get approximately equal amount of mailboxes to execute. This is suitable
+ # in cases where we have a small number of actors that will be scheduled on
+ # the pool and we want to ensure the maximum possible utilization of the
+ # available threads.
+ # - hash based - the task - queue in which the runnable should go is determined
+ # by using an uniformly distributed int to int hash function which uses the
+ # hash code of the Runnable as an input. This is preferred in situations where we
+ # have enough number of distinct actors to ensure statistically uniform
+ # distribution of work across threads or we are ready to sacrifice the
+ # former for the added benefit of avoiding map look-ups.
+ fair-work-distribution {
+ # The value serves as a threshold which determines the point at which the
+ # pool switches from the first to the second work distribution schemes.
+ # For example, if the value is set to 128, the pool can observe up to
+ # 128 unique actors and schedule their mailboxes using the map based
+ # approach. Once this number is reached the pool switches to hash based
+ # task distribution mode. If the value is set to 0, the map based
+ # work distribution approach is disabled and only the hash based is
+ # used irrespective of the number of unique actors. Valid range is
+ # 0 to 2048 (inclusive)
+ threshold = 128
+ }
+ }
+
+ # This will be used if you have set "executor = "fork-join-executor""
+ # Underlying thread pool implementation is akka.dispatch.forkjoin.ForkJoinPool
+ fork-join-executor {
+ # Min number of threads to cap factor-based parallelism number to
+ parallelism-min = 8
+
+ # The parallelism factor is used to determine thread pool size using the
+ # following formula: ceil(available processors * factor). Resulting size
+ # is then bounded by the parallelism-min and parallelism-max values.
+ parallelism-factor = 3.0
+
+ # Max number of threads to cap factor-based parallelism number to
+ parallelism-max = 64
+
+ # Setting to "FIFO" to use queue like peeking mode which "poll" or "LIFO" to use stack
+ # like peeking mode which "pop".
+ task-peeking-mode = "FIFO"
+ }
+
+ # This will be used if you have set "executor = "thread-pool-executor""
+ # Underlying thread pool implementation is java.util.concurrent.ThreadPoolExecutor
+ thread-pool-executor {
+ # Keep alive time for threads
+ keep-alive-time = 60s
+
+ # Define a fixed thread pool size with this property. The corePoolSize
+ # and the maximumPoolSize of the ThreadPoolExecutor will be set to this
+ # value, if it is defined. Then the other pool-size properties will not
+ # be used.
+ #
+ # Valid values are: `off` or a positive integer.
+ fixed-pool-size = off
+
+ # Min number of threads to cap factor-based corePoolSize number to
+ core-pool-size-min = 8
+
+ # The core-pool-size-factor is used to determine corePoolSize of the
+ # ThreadPoolExecutor using the following formula:
+ # ceil(available processors * factor).
+ # Resulting size is then bounded by the core-pool-size-min and
+ # core-pool-size-max values.
+ core-pool-size-factor = 3.0
+
+ # Max number of threads to cap factor-based corePoolSize number to
+ core-pool-size-max = 64
+
+ # Minimum number of threads to cap factor-based maximumPoolSize number to
+ max-pool-size-min = 8
+
+ # The max-pool-size-factor is used to determine maximumPoolSize of the
+ # ThreadPoolExecutor using the following formula:
+ # ceil(available processors * factor)
+ # The maximumPoolSize will not be less than corePoolSize.
+ # It is only used if using a bounded task queue.
+ max-pool-size-factor = 3.0
+
+ # Max number of threads to cap factor-based maximumPoolSize number to
+ max-pool-size-max = 64
+
+ # Specifies the bounded capacity of the task queue (< 1 == unbounded)
+ task-queue-size = -1
+
+ # Specifies which type of task queue will be used, can be "array" or
+ # "linked" (default)
+ task-queue-type = "linked"
+
+ # Allow core threads to time out
+ allow-core-timeout = on
+ }
+
+ # How long time the dispatcher will wait for new actors until it shuts down
+ shutdown-timeout = 1s
+
+ # Throughput defines the number of messages that are processed in a batch
+ # before the thread is returned to the pool. Set to 1 for as fair as possible.
+ throughput = 5
+
+ # Throughput deadline for Dispatcher, set to 0 or negative for no deadline
+ throughput-deadline-time = 0ms
+
+ # For BalancingDispatcher: If the balancing dispatcher should attempt to
+ # schedule idle actors using the same dispatcher when a message comes in,
+ # and the dispatchers ExecutorService is not fully busy already.
+ attempt-teamwork = on
+
+ # If this dispatcher requires a specific type of mailbox, specify the
+ # fully-qualified class name here; the actually created mailbox will
+ # be a subtype of this type. The empty string signifies no requirement.
+ mailbox-requirement = ""
+ }
+
+ default-blocking-io-dispatcher {
+ type = "Dispatcher"
+ executor = "thread-pool-executor"
+ throughput = 1
+
+ thread-pool-executor {
+ fixed-pool-size = 16
+ }
+ }
+
+ default-mailbox {
+ # FQCN of the MailboxType. The Class of the FQCN must have a public
+ # constructor with
+ # (akka.actor.ActorSystem.Settings, com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.UnboundedMailbox"
+
+ # If the mailbox is bounded then it uses this setting to determine its
+ # capacity. The provided value must be positive.
+ # NOTICE:
+ # Up to version 2.1 the mailbox type was determined based on this setting;
+ # this is no longer the case, the type must explicitly be a bounded mailbox.
+ mailbox-capacity = 1000
+
+ # If the mailbox is bounded then this is the timeout for enqueueing
+ # in case the mailbox is full. Negative values signify infinite
+ # timeout, which should be avoided as it bears the risk of dead-lock.
+ mailbox-push-timeout-time = 10s
+
+ # For Actor with Stash: The default capacity of the stash.
+ # If negative (or zero) then an unbounded stash is used (default)
+ # If positive then a bounded stash is used and the capacity is set using
+ # the property
+ stash-capacity = -1
+ }
+
+ mailbox {
+ # Mapping between message queue semantics and mailbox configurations.
+ # Used by akka.dispatch.RequiresMessageQueue[T] to enforce different
+ # mailbox types on actors.
+ # If your Actor implements RequiresMessageQueue[T], then when you create
+ # an instance of that actor its mailbox type will be decided by looking
+ # up a mailbox configuration via T in this mapping
+ requirements {
+ "akka.dispatch.UnboundedMessageQueueSemantics" =
+ akka.actor.mailbox.unbounded-queue-based
+ "akka.dispatch.BoundedMessageQueueSemantics" =
+ akka.actor.mailbox.bounded-queue-based
+ "akka.dispatch.DequeBasedMessageQueueSemantics" =
+ akka.actor.mailbox.unbounded-deque-based
+ "akka.dispatch.UnboundedDequeBasedMessageQueueSemantics" =
+ akka.actor.mailbox.unbounded-deque-based
+ "akka.dispatch.BoundedDequeBasedMessageQueueSemantics" =
+ akka.actor.mailbox.bounded-deque-based
+ "akka.dispatch.MultipleConsumerSemantics" =
+ akka.actor.mailbox.unbounded-queue-based
+ "akka.dispatch.ControlAwareMessageQueueSemantics" =
+ akka.actor.mailbox.unbounded-control-aware-queue-based
+ "akka.dispatch.UnboundedControlAwareMessageQueueSemantics" =
+ akka.actor.mailbox.unbounded-control-aware-queue-based
+ "akka.dispatch.BoundedControlAwareMessageQueueSemantics" =
+ akka.actor.mailbox.bounded-control-aware-queue-based
+ "akka.event.LoggerMessageQueueSemantics" =
+ akka.actor.mailbox.logger-queue
+ }
+
+ unbounded-queue-based {
+ # FQCN of the MailboxType, The Class of the FQCN must have a public
+ # constructor with (akka.actor.ActorSystem.Settings,
+ # com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.UnboundedMailbox"
+ }
+
+ bounded-queue-based {
+ # FQCN of the MailboxType, The Class of the FQCN must have a public
+ # constructor with (akka.actor.ActorSystem.Settings,
+ # com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.BoundedMailbox"
+ }
+
+ unbounded-deque-based {
+ # FQCN of the MailboxType, The Class of the FQCN must have a public
+ # constructor with (akka.actor.ActorSystem.Settings,
+ # com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.UnboundedDequeBasedMailbox"
+ }
+
+ bounded-deque-based {
+ # FQCN of the MailboxType, The Class of the FQCN must have a public
+ # constructor with (akka.actor.ActorSystem.Settings,
+ # com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.BoundedDequeBasedMailbox"
+ }
+
+ unbounded-control-aware-queue-based {
+ # FQCN of the MailboxType, The Class of the FQCN must have a public
+ # constructor with (akka.actor.ActorSystem.Settings,
+ # com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.UnboundedControlAwareMailbox"
+ }
+
+ bounded-control-aware-queue-based {
+ # FQCN of the MailboxType, The Class of the FQCN must have a public
+ # constructor with (akka.actor.ActorSystem.Settings,
+ # com.typesafe.config.Config) parameters.
+ mailbox-type = "akka.dispatch.BoundedControlAwareMailbox"
+ }
+
+ # The LoggerMailbox will drain all messages in the mailbox
+ # when the system is shutdown and deliver them to the StandardOutLogger.
+ # Do not change this unless you know what you are doing.
+ logger-queue {
+ mailbox-type = "akka.event.LoggerMailboxType"
+ }
+ }
+
+ debug {
+ # enable function of Actor.loggable(), which is to log any received message
+ # at DEBUG level, see the “Testing Actor Systems” section of the Akka
+ # Documentation at http://akka.io/docs
+ receive = off
+
+ # enable DEBUG logging of all AutoReceiveMessages (Kill, PoisonPill etc.)
+ autoreceive = off
+
+ # enable DEBUG logging of actor lifecycle changes
+ lifecycle = off
+
+ # enable DEBUG logging of all LoggingFSMs for events, transitions and timers
+ fsm = off
+
+ # enable DEBUG logging of subscription changes on the eventStream
+ event-stream = off
+
+ # enable DEBUG logging of unhandled messages
+ unhandled = off
+
+ # enable WARN logging of misconfigured routers
+ router-misconfiguration = off
+ }
+
+ # SECURITY BEST-PRACTICE is to disable java serialization for its multiple
+ # known attack surfaces.
+ #
+ # This setting is a short-cut to
+ # - using DisabledJavaSerializer instead of JavaSerializer
+ # - enable-additional-serialization-bindings = on
+ #
+ # Completely disable the use of `akka.serialization.JavaSerialization` by the
+ # Akka Serialization extension, instead DisabledJavaSerializer will
+ # be inserted which will fail explicitly if attempts to use java serialization are made.
+ #
+ # The log messages emitted by such serializer SHOULD be treated as potential
+ # attacks which the serializer prevented, as they MAY indicate an external operator
+ # attempting to send malicious messages intending to use java serialization as attack vector.
+ # The attempts are logged with the SECURITY marker.
+ #
+ # Please note that this option does not stop you from manually invoking java serialization
+ #
+ # The default value for this might be changed to off in future versions of Akka.
+ allow-java-serialization = on
+
+ # Entries for pluggable serializers and their bindings.
+ serializers {
+ java = "akka.serialization.JavaSerializer"
+ bytes = "akka.serialization.ByteArraySerializer"
+
+ primitive-boolean = "akka.serialization.BooleanSerializer"
+ }
+
+ # Class to Serializer binding. You only need to specify the name of an
+ # interface or abstract base class of the messages. In case of ambiguity it
+ # is using the most specific configured class, or giving a warning and
+ # choosing the “first” one.
+ #
+ # To disable one of the default serializers, assign its class to "none", like
+ # "java.io.Serializable" = none
+ serialization-bindings {
+ "[B" = bytes
+ "java.io.Serializable" = java
+
+ // TODO issue #27330: BooleanSerializer not enabled for serialization in 2.5.x yet
+ #"java.lang.Boolean" = primitive-boolean
+ #"scala.Boolean" = primitive-boolean
+ }
+
+ # Additional serialization-bindings that are replacing Java serialization are
+ # defined in this section for backwards compatibility reasons. They are included
+ # by default but can be excluded for backwards compatibility with Akka 2.4.x.
+ # They can be disabled with enable-additional-serialization-bindings=off.
+ #
+ # This should only be needed for backwards compatibility reasons.
+ enable-additional-serialization-bindings = on
+
+ # Additional serialization-bindings that are replacing Java serialization are
+ # defined in this section for backwards compatibility reasons. They are included
+ # by default but can be excluded for backwards compatibility with Akka 2.4.x.
+ # They can be disabled with enable-additional-serialization-bindings=off.
+ additional-serialization-bindings {
+ }
+
+ # Log warnings when the default Java serialization is used to serialize messages.
+ # The default serializer uses Java serialization which is not very performant and should not
+ # be used in production environments unless you don't care about performance. In that case
+ # you can turn this off.
+ warn-about-java-serializer-usage = on
+
+ # To be used with the above warn-about-java-serializer-usage
+ # When warn-about-java-serializer-usage = on, and this warn-on-no-serialization-verification = off,
+ # warnings are suppressed for classes extending NoSerializationVerificationNeeded
+ # to reduce noize.
+ warn-on-no-serialization-verification = on
+
+ # Configuration namespace of serialization identifiers.
+ # Each serializer implementation must have an entry in the following format:
+ # `akka.actor.serialization-identifiers."FQCN" = ID`
+ # where `FQCN` is fully qualified class name of the serializer implementation
+ # and `ID` is globally unique serializer identifier number.
+ # Identifier values from 0 to 40 are reserved for Akka internal usage.
+ serialization-identifiers {
+ "akka.serialization.JavaSerializer" = 1
+ "akka.serialization.ByteArraySerializer" = 4
+ "akka.serialization.BooleanSerializer" = 35
+ }
+
+ # Configuration items which are used by the akka.actor.ActorDSL._ methods
+ dsl {
+ # Maximum queue size of the actor created by newInbox(); this protects
+ # against faulty programs which use select() and consistently miss messages
+ inbox-size = 1000
+
+ # Default timeout to assume for operations like Inbox.receive et al
+ default-timeout = 5s
+ }
+
+ }
+
+ serialization.protobuf {
+
+ # Additional classes that are allowed even if they are not defined in `serialization-bindings`.
+ # It can be exact class name or name of super class or interfaces (one level).
+ # This is useful when a class is not used for serialization any more and therefore removed
+ # from `serialization-bindings`, but should still be possible to deserialize.
+ whitelist-class = [
+ "com.google.protobuf.GeneratedMessage",
+ "com.google.protobuf.GeneratedMessageV3",
+ "scalapb.GeneratedMessageCompanion",
+ "akka.protobuf.GeneratedMessage"
+ ]
+ }
+
+ # Used to set the behavior of the scheduler.
+ # Changing the default values may change the system behavior drastically so make
+ # sure you know what you're doing! See the Scheduler section of the Akka
+ # Documentation for more details.
+ scheduler {
+ # The LightArrayRevolverScheduler is used as the default scheduler in the
+ # system. It does not execute the scheduled tasks on exact time, but on every
+ # tick, it will run everything that is (over)due. You can increase or decrease
+ # the accuracy of the execution timing by specifying smaller or larger tick
+ # duration. If you are scheduling a lot of tasks you should consider increasing
+ # the ticks per wheel.
+ # Note that it might take up to 1 tick to stop the Timer, so setting the
+ # tick-duration to a high value will make shutting down the actor system
+ # take longer.
+ tick-duration = 10ms
+
+ # The timer uses a circular wheel of buckets to store the timer tasks.
+ # This should be set such that the majority of scheduled timeouts (for high
+ # scheduling frequency) will be shorter than one rotation of the wheel
+ # (ticks-per-wheel * ticks-duration)
+ # THIS MUST BE A POWER OF TWO!
+ ticks-per-wheel = 512
+
+ # This setting selects the timer implementation which shall be loaded at
+ # system start-up.
+ # The class given here must implement the akka.actor.Scheduler interface
+ # and offer a public constructor which takes three arguments:
+ # 1) com.typesafe.config.Config
+ # 2) akka.event.LoggingAdapter
+ # 3) java.util.concurrent.ThreadFactory
+ implementation = akka.actor.LightArrayRevolverScheduler
+
+ # When shutting down the scheduler, there will typically be a thread which
+ # needs to be stopped, and this timeout determines how long to wait for
+ # that to happen. In case of timeout the shutdown of the actor system will
+ # proceed without running possibly still enqueued tasks.
+ shutdown-timeout = 5s
+ }
+
+ io {
+
+ # By default the select loops run on dedicated threads, hence using a
+ # PinnedDispatcher
+ pinned-dispatcher {
+ type = "PinnedDispatcher"
+ executor = "thread-pool-executor"
+ thread-pool-executor.allow-core-timeout = off
+ }
+
+ tcp {
+
+ # The number of selectors to stripe the served channels over; each of
+ # these will use one select loop on the selector-dispatcher.
+ nr-of-selectors = 1
+
+ # Maximum number of open channels supported by this TCP module; there is
+ # no intrinsic general limit, this setting is meant to enable DoS
+ # protection by limiting the number of concurrently connected clients.
+ # Also note that this is a "soft" limit; in certain cases the implementation
+ # will accept a few connections more or a few less than the number configured
+ # here. Must be an integer > 0 or "unlimited".
+ max-channels = 256000
+
+ # When trying to assign a new connection to a selector and the chosen
+ # selector is at full capacity, retry selector choosing and assignment
+ # this many times before giving up
+ selector-association-retries = 10
+
+ # The maximum number of connection that are accepted in one go,
+ # higher numbers decrease latency, lower numbers increase fairness on
+ # the worker-dispatcher
+ batch-accept-limit = 10
+
+ # The number of bytes per direct buffer in the pool used to read or write
+ # network data from the kernel.
+ direct-buffer-size = 128 KiB
+
+ # The maximal number of direct buffers kept in the direct buffer pool for
+ # reuse.
+ direct-buffer-pool-limit = 1000
+
+ # The duration a connection actor waits for a `Register` message from
+ # its commander before aborting the connection.
+ register-timeout = 5s
+
+ # The maximum number of bytes delivered by a `Received` message. Before
+ # more data is read from the network the connection actor will try to
+ # do other work.
+ # The purpose of this setting is to impose a smaller limit than the
+ # configured receive buffer size. When using value 'unlimited' it will
+ # try to read all from the receive buffer.
+ max-received-message-size = unlimited
+
+ # Enable fine grained logging of what goes on inside the implementation.
+ # Be aware that this may log more than once per message sent to the actors
+ # of the tcp implementation.
+ trace-logging = off
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # to be used for running the select() calls in the selectors
+ selector-dispatcher = "akka.io.pinned-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the read/write worker actors
+ worker-dispatcher = "akka.actor.default-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the selector management actors
+ management-dispatcher = "akka.actor.default-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # on which file IO tasks are scheduled
+ file-io-dispatcher = "akka.actor.default-blocking-io-dispatcher"
+
+ # The maximum number of bytes (or "unlimited") to transfer in one batch
+ # when using `WriteFile` command which uses `FileChannel.transferTo` to
+ # pipe files to a TCP socket. On some OS like Linux `FileChannel.transferTo`
+ # may block for a long time when network IO is faster than file IO.
+ # Decreasing the value may improve fairness while increasing may improve
+ # throughput.
+ file-io-transferTo-limit = 512 KiB
+
+ # The number of times to retry the `finishConnect` call after being notified about
+ # OP_CONNECT. Retries are needed if the OP_CONNECT notification doesn't imply that
+ # `finishConnect` will succeed, which is the case on Android.
+ finish-connect-retries = 5
+
+ # On Windows connection aborts are not reliably detected unless an OP_READ is
+ # registered on the selector _after_ the connection has been reset. This
+ # workaround enables an OP_CONNECT which forces the abort to be visible on Windows.
+ # Enabling this setting on other platforms than Windows will cause various failures
+ # and undefined behavior.
+ # Possible values of this key are on, off and auto where auto will enable the
+ # workaround if Windows is detected automatically.
+ windows-connection-abort-workaround-enabled = off
+ }
+
+ udp {
+
+ # The number of selectors to stripe the served channels over; each of
+ # these will use one select loop on the selector-dispatcher.
+ nr-of-selectors = 1
+
+ # Maximum number of open channels supported by this UDP module Generally
+ # UDP does not require a large number of channels, therefore it is
+ # recommended to keep this setting low.
+ max-channels = 4096
+
+ # The select loop can be used in two modes:
+ # - setting "infinite" will select without a timeout, hogging a thread
+ # - setting a positive timeout will do a bounded select call,
+ # enabling sharing of a single thread between multiple selectors
+ # (in this case you will have to use a different configuration for the
+ # selector-dispatcher, e.g. using "type=Dispatcher" with size 1)
+ # - setting it to zero means polling, i.e. calling selectNow()
+ select-timeout = infinite
+
+ # When trying to assign a new connection to a selector and the chosen
+ # selector is at full capacity, retry selector choosing and assignment
+ # this many times before giving up
+ selector-association-retries = 10
+
+ # The maximum number of datagrams that are read in one go,
+ # higher numbers decrease latency, lower numbers increase fairness on
+ # the worker-dispatcher
+ receive-throughput = 3
+
+ # The number of bytes per direct buffer in the pool used to read or write
+ # network data from the kernel.
+ direct-buffer-size = 128 KiB
+
+ # The maximal number of direct buffers kept in the direct buffer pool for
+ # reuse.
+ direct-buffer-pool-limit = 1000
+
+ # Enable fine grained logging of what goes on inside the implementation.
+ # Be aware that this may log more than once per message sent to the actors
+ # of the tcp implementation.
+ trace-logging = off
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # to be used for running the select() calls in the selectors
+ selector-dispatcher = "akka.io.pinned-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the read/write worker actors
+ worker-dispatcher = "akka.actor.default-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the selector management actors
+ management-dispatcher = "akka.actor.default-dispatcher"
+ }
+
+ udp-connected {
+
+ # The number of selectors to stripe the served channels over; each of
+ # these will use one select loop on the selector-dispatcher.
+ nr-of-selectors = 1
+
+ # Maximum number of open channels supported by this UDP module Generally
+ # UDP does not require a large number of channels, therefore it is
+ # recommended to keep this setting low.
+ max-channels = 4096
+
+ # The select loop can be used in two modes:
+ # - setting "infinite" will select without a timeout, hogging a thread
+ # - setting a positive timeout will do a bounded select call,
+ # enabling sharing of a single thread between multiple selectors
+ # (in this case you will have to use a different configuration for the
+ # selector-dispatcher, e.g. using "type=Dispatcher" with size 1)
+ # - setting it to zero means polling, i.e. calling selectNow()
+ select-timeout = infinite
+
+ # When trying to assign a new connection to a selector and the chosen
+ # selector is at full capacity, retry selector choosing and assignment
+ # this many times before giving up
+ selector-association-retries = 10
+
+ # The maximum number of datagrams that are read in one go,
+ # higher numbers decrease latency, lower numbers increase fairness on
+ # the worker-dispatcher
+ receive-throughput = 3
+
+ # The number of bytes per direct buffer in the pool used to read or write
+ # network data from the kernel.
+ direct-buffer-size = 128 KiB
+
+ # The maximal number of direct buffers kept in the direct buffer pool for
+ # reuse.
+ direct-buffer-pool-limit = 1000
+
+ # Enable fine grained logging of what goes on inside the implementation.
+ # Be aware that this may log more than once per message sent to the actors
+ # of the tcp implementation.
+ trace-logging = off
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # to be used for running the select() calls in the selectors
+ selector-dispatcher = "akka.io.pinned-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the read/write worker actors
+ worker-dispatcher = "akka.actor.default-dispatcher"
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the selector management actors
+ management-dispatcher = "akka.actor.default-dispatcher"
+ }
+
+ dns {
+ # Fully qualified config path which holds the dispatcher configuration
+ # for the manager and resolver router actors.
+ # For actual router configuration see akka.actor.deployment./IO-DNS/*
+ dispatcher = "akka.actor.default-dispatcher"
+
+ # Name of the subconfig at path akka.io.dns, see inet-address below
+ #
+ # Change to `async-dns` to use the new "native" DNS resolver,
+ # which is also capable of resolving SRV records.
+ resolver = "inet-address"
+
+ # To-be-deprecated DNS resolver implementation which uses the Java InetAddress to resolve DNS records.
+ # To be replaced by `akka.io.dns.async` which implements the DNS protocol natively and without blocking (which InetAddress does)
+ inet-address {
+ # Must implement akka.io.DnsProvider
+ provider-object = "akka.io.InetAddressDnsProvider"
+
+ # To set the time to cache name resolutions
+ # Possible values:
+ # default: sun.net.InetAddressCachePolicy.get() and getNegative()
+ # forever: cache forever
+ # never: no caching
+ # n [time unit]: positive timeout with unit, for example 30s
+ positive-ttl = default
+ negative-ttl = default
+
+ # How often to sweep out expired cache entries.
+ # Note that this interval has nothing to do with TTLs
+ cache-cleanup-interval = 120s
+ }
+
+ async-dns {
+ provider-object = "akka.io.dns.internal.AsyncDnsProvider"
+
+ # Set upper bound for caching successfully resolved dns entries
+ # if the DNS record has a smaller TTL value than the setting that
+ # will be used. Default is to use the record TTL with no cap.
+ # Possible values:
+ # forever: always use the minimum TTL from the found records
+ # never: never cache
+ # n [time unit] = cap the caching to this value
+ positive-ttl = forever
+
+ # Set how long the fact that a DNS record could not be found is
+ # cached. If a new resolution is done while the fact is cached it will
+ # be failed and not result in an actual DNS resolution. Default is
+ # to never cache.
+ # Possible values:
+ # never: never cache
+ # forever: cache a missing DNS record forever (you probably will not want to do this)
+ # n [time unit] = cache for this long
+ negative-ttl = never
+
+ # Configures nameservers to query during DNS resolution.
+ # Defaults to the nameservers that would be used by the JVM by default.
+ # Set to a list of IPs to override the servers, e.g. [ "8.8.8.8", "8.8.4.4" ] for Google's servers
+ # If multiple are defined then they are tried in order until one responds
+ nameservers = default
+
+ # The time that a request is allowed to live before being discarded
+ # given no reply. The lower bound of this should always be the amount
+ # of time to reasonably expect a DNS server to reply within.
+ # If multiple name servers are provided then each gets this long to response before trying
+ # the next one
+ resolve-timeout = 5s
+
+ # How often to sweep out expired cache entries.
+ # Note that this interval has nothing to do with TTLs
+ cache-cleanup-interval = 120s
+
+ # Configures the list of search domains.
+ # Defaults to a system dependent lookup (on Unix like OSes, will attempt to parse /etc/resolv.conf, on
+ # other platforms, will not make any attempt to lookup the search domains). Set to a single domain, or
+ # a list of domains, eg, [ "example.com", "example.net" ].
+ search-domains = default
+
+ # Any hosts that have a number of dots less than this will not be looked up directly, instead, a search on
+ # the search domains will be tried first. This corresponds to the ndots option in /etc/resolv.conf, see
+ # https://linux.die.net/man/5/resolver for more info.
+ # Defaults to a system dependent lookup (on Unix like OSes, will attempt to parse /etc/resolv.conf, on
+ # other platforms, will default to 1).
+ ndots = default
+ }
+ }
+ }
+
+
+ # CoordinatedShutdown is an extension that will perform registered
+ # tasks in the order that is defined by the phases. It is started
+ # by calling CoordinatedShutdown(system).run(). This can be triggered
+ # by different things, for example:
+ # - JVM shutdown hook will by default run CoordinatedShutdown
+ # - Cluster node will automatically run CoordinatedShutdown when it
+ # sees itself as Exiting
+ # - A management console or other application specific command can
+ # run CoordinatedShutdown
+ coordinated-shutdown {
+ # The timeout that will be used for a phase if not specified with
+ # 'timeout' in the phase
+ default-phase-timeout = 5 s
+
+ # Terminate the ActorSystem in the last phase actor-system-terminate.
+ terminate-actor-system = on
+
+ # Exit the JVM (System.exit(0)) in the last phase actor-system-terminate
+ # if this is set to 'on'. It is done after termination of the
+ # ActorSystem if terminate-actor-system=on, otherwise it is done
+ # immediately when the last phase is reached.
+ exit-jvm = off
+
+ # Exit status to use on System.exit(int) when 'exit-jvm' is 'on'.
+ exit-code = 0
+
+ # Run the coordinated shutdown when the JVM process exits, e.g.
+ # via kill SIGTERM signal (SIGINT ctrl-c doesn't work).
+ # This property is related to `akka.jvm-shutdown-hooks` above.
+ run-by-jvm-shutdown-hook = on
+
+ # When Coordinated Shutdown is triggered an instance of `Reason` is
+ # required. That value can be used to override the default settings.
+ # Only 'exit-jvm', 'exit-code' and 'terminate-actor-system' may be
+ # overridden depending on the reason.
+ reason-overrides {
+ # Overrides are applied using the `reason.getClass.getName`.
+ # Overrides the `exit-code` when the `Reason` is a cluster
+ # Downing or a Cluster Join Unsuccessful event
+ "akka.actor.CoordinatedShutdown$ClusterDowningReason$" {
+ exit-code = -1
+ }
+ "akka.actor.CoordinatedShutdown$ClusterJoinUnsuccessfulReason$" {
+ exit-code = -1
+ }
+ }
+
+ #//#coordinated-shutdown-phases
+ # CoordinatedShutdown is enabled by default and will run the tasks that
+ # are added to these phases by individual Akka modules and user logic.
+ #
+ # The phases are ordered as a DAG by defining the dependencies between the phases
+ # to make sure shutdown tasks are run in the right order.
+ #
+ # In general user tasks belong in the first few phases, but there may be use
+ # cases where you would want to hook in new phases or register tasks later in
+ # the DAG.
+ #
+ # Each phase is defined as a named config section with the
+ # following optional properties:
+ # - timeout=15s: Override the default-phase-timeout for this phase.
+ # - recover=off: If the phase fails the shutdown is aborted
+ # and depending phases will not be executed.
+ # - enabled=off: Skip all tasks registered in this phase. DO NOT use
+ # this to disable phases unless you are absolutely sure what the
+ # consequences are. Many of the built in tasks depend on other tasks
+ # having been executed in earlier phases and may break if those are disabled.
+ # depends-on=[]: Run the phase after the given phases
+ phases {
+
+ # The first pre-defined phase that applications can add tasks to.
+ # Note that more phases can be added in the application's
+ # configuration by overriding this phase with an additional
+ # depends-on.
+ before-service-unbind {
+ }
+
+ # Stop accepting new incoming connections.
+ # This is where you can register tasks that makes a server stop accepting new connections. Already
+ # established connections should be allowed to continue and complete if possible.
+ service-unbind {
+ depends-on = [before-service-unbind]
+ }
+
+ # Wait for requests that are in progress to be completed.
+ # This is where you register tasks that will wait for already established connections to complete, potentially
+ # also first telling them that it is time to close down.
+ service-requests-done {
+ depends-on = [service-unbind]
+ }
+
+ # Final shutdown of service endpoints.
+ # This is where you would add tasks that forcefully kill connections that are still around.
+ service-stop {
+ depends-on = [service-requests-done]
+ }
+
+ # Phase for custom application tasks that are to be run
+ # after service shutdown and before cluster shutdown.
+ before-cluster-shutdown {
+ depends-on = [service-stop]
+ }
+
+ # Graceful shutdown of the Cluster Sharding regions.
+ # This phase is not meant for users to add tasks to.
+ cluster-sharding-shutdown-region {
+ timeout = 10 s
+ depends-on = [before-cluster-shutdown]
+ }
+
+ # Emit the leave command for the node that is shutting down.
+ # This phase is not meant for users to add tasks to.
+ cluster-leave {
+ depends-on = [cluster-sharding-shutdown-region]
+ }
+
+ # Shutdown cluster singletons
+ # This is done as late as possible to allow the shard region shutdown triggered in
+ # the "cluster-sharding-shutdown-region" phase to complete before the shard coordinator is shut down.
+ # This phase is not meant for users to add tasks to.
+ cluster-exiting {
+ timeout = 10 s
+ depends-on = [cluster-leave]
+ }
+
+ # Wait until exiting has been completed
+ # This phase is not meant for users to add tasks to.
+ cluster-exiting-done {
+ depends-on = [cluster-exiting]
+ }
+
+ # Shutdown the cluster extension
+ # This phase is not meant for users to add tasks to.
+ cluster-shutdown {
+ depends-on = [cluster-exiting-done]
+ }
+
+ # Phase for custom application tasks that are to be run
+ # after cluster shutdown and before ActorSystem termination.
+ before-actor-system-terminate {
+ depends-on = [cluster-shutdown]
+ }
+
+ # Last phase. See terminate-actor-system and exit-jvm above.
+ # Don't add phases that depends on this phase because the
+ # dispatcher and scheduler of the ActorSystem have been shutdown.
+ # This phase is not meant for users to add tasks to.
+ actor-system-terminate {
+ timeout = 10 s
+ depends-on = [before-actor-system-terminate]
+ }
+ }
+ #//#coordinated-shutdown-phases
+ }
+
+}
--- /dev/null
+######################################
+# Akka Cluster Reference Config File #
+######################################
+
+# This is the reference config file that contains all the default settings.
+# Make your edits/overrides in your application.conf.
+
+akka {
+
+ cluster {
+ # Initial contact points of the cluster.
+ # The nodes to join automatically at startup.
+ # Comma separated full URIs defined by a string on the form of
+ # "akka.tcp://system@hostname:port"
+ # Leave as empty if the node is supposed to be joined manually.
+ seed-nodes = []
+
+ # How long to wait for one of the seed nodes to reply to initial join request.
+ # When this is the first seed node and there is no positive reply from the other
+ # seed nodes within this timeout it will join itself to bootstrap the cluster.
+ # When this is not the first seed node the join attempts will be performed with
+ # this interval.
+ seed-node-timeout = 5s
+
+ # If a join request fails it will be retried after this period.
+ # Disable join retry by specifying "off".
+ retry-unsuccessful-join-after = 10s
+
+ # The joining of given seed nodes will by default be retried indefinitely until
+ # a successful join. That process can be aborted if unsuccessful by defining this
+ # timeout. When aborted it will run CoordinatedShutdown, which by default will
+ # terminate the ActorSystem. CoordinatedShutdown can also be configured to exit
+ # the JVM. It is useful to define this timeout if the seed-nodes are assembled
+ # dynamically and a restart with new seed-nodes should be tried after unsuccessful
+ # attempts.
+ shutdown-after-unsuccessful-join-seed-nodes = off
+
+ # Should the 'leader' in the cluster be allowed to automatically mark
+ # unreachable nodes as DOWN after a configured time of unreachability?
+ # Using auto-down implies that two separate clusters will automatically be
+ # formed in case of network partition.
+ #
+ # Don't enable this in production, see 'Auto-downing (DO NOT USE)' section
+ # of Akka Cluster documentation.
+ #
+ # Disable with "off" or specify a duration to enable auto-down.
+ # If a downing-provider-class is configured this setting is ignored.
+ auto-down-unreachable-after = off
+
+ # Time margin after which shards or singletons that belonged to a downed/removed
+ # partition are created in surviving partition. The purpose of this margin is that
+ # in case of a network partition the persistent actors in the non-surviving partitions
+ # must be stopped before corresponding persistent actors are started somewhere else.
+ # This is useful if you implement downing strategies that handle network partitions,
+ # e.g. by keeping the larger side of the partition and shutting down the smaller side.
+ # It will not add any extra safety for auto-down-unreachable-after, since that is not
+ # handling network partitions.
+ # Disable with "off" or specify a duration to enable.
+ down-removal-margin = off
+
+ # Pluggable support for downing of nodes in the cluster.
+ # If this setting is left empty behavior will depend on 'auto-down-unreachable' in the following ways:
+ # * if it is 'off' the `NoDowning` provider is used and no automatic downing will be performed
+ # * if it is set to a duration the `AutoDowning` provider is with the configured downing duration
+ #
+ # If specified the value must be the fully qualified class name of a subclass of
+ # `akka.cluster.DowningProvider` having a public one argument constructor accepting an `ActorSystem`
+ downing-provider-class = ""
+
+ # Artery only setting
+ # When a node has been gracefully removed, let this time pass (to allow for example
+ # cluster singleton handover to complete) and then quarantine the removed node.
+ quarantine-removed-node-after = 5s
+
+ # If this is set to "off", the leader will not move 'Joining' members to 'Up' during a network
+ # split. This feature allows the leader to accept 'Joining' members to be 'WeaklyUp'
+ # so they become part of the cluster even during a network split. The leader will
+ # move `Joining` members to 'WeaklyUp' after 3 rounds of 'leader-actions-interval'
+ # without convergence.
+ # The leader will move 'WeaklyUp' members to 'Up' status once convergence has been reached.
+ allow-weakly-up-members = on
+
+ # The roles of this member. List of strings, e.g. roles = ["A", "B"].
+ # The roles are part of the membership information and can be used by
+ # routers or other services to distribute work to certain member types,
+ # e.g. front-end and back-end nodes.
+ # Roles are not allowed to start with "dc-" as that is reserved for the
+ # special role assigned from the data-center a node belongs to (see the
+ # multi-data-center section below)
+ roles = []
+
+ # Run the coordinated shutdown from phase 'cluster-shutdown' when the cluster
+ # is shutdown for other reasons than when leaving, e.g. when downing. This
+ # will terminate the ActorSystem when the cluster extension is shutdown.
+ run-coordinated-shutdown-when-down = on
+
+ role {
+ # Minimum required number of members of a certain role before the leader
+ # changes member status of 'Joining' members to 'Up'. Typically used together
+ # with 'Cluster.registerOnMemberUp' to defer some action, such as starting
+ # actors, until the cluster has reached a certain size.
+ # E.g. to require 2 nodes with role 'frontend' and 3 nodes with role 'backend':
+ # frontend.min-nr-of-members = 2
+ # backend.min-nr-of-members = 3
+ #<role-name>.min-nr-of-members = 1
+ }
+
+ # Minimum required number of members before the leader changes member status
+ # of 'Joining' members to 'Up'. Typically used together with
+ # 'Cluster.registerOnMemberUp' to defer some action, such as starting actors,
+ # until the cluster has reached a certain size.
+ min-nr-of-members = 1
+
+ # Enable/disable info level logging of cluster events
+ log-info = on
+
+ # Enable/disable verbose info-level logging of cluster events
+ # for temporary troubleshooting. Defaults to 'off'.
+ log-info-verbose = off
+
+ # Enable or disable JMX MBeans for management of the cluster
+ jmx.enabled = on
+
+ # Enable or disable multiple JMX MBeans in the same JVM
+ # If this is disabled, the MBean Object name is "akka:type=Cluster"
+ # If this is enabled, them MBean Object names become "akka:type=Cluster,port=$clusterPortNumber"
+ jmx.multi-mbeans-in-same-jvm = off
+
+ # how long should the node wait before starting the periodic tasks
+ # maintenance tasks?
+ periodic-tasks-initial-delay = 1s
+
+ # how often should the node send out gossip information?
+ gossip-interval = 1s
+
+ # discard incoming gossip messages if not handled within this duration
+ gossip-time-to-live = 2s
+
+ # how often should the leader perform maintenance tasks?
+ leader-actions-interval = 1s
+
+ # how often should the node move nodes, marked as unreachable by the failure
+ # detector, out of the membership ring?
+ unreachable-nodes-reaper-interval = 1s
+
+ # How often the current internal stats should be published.
+ # A value of 0s can be used to always publish the stats, when it happens.
+ # Disable with "off".
+ publish-stats-interval = off
+
+ # The id of the dispatcher to use for cluster actors. If not specified
+ # default dispatcher is used.
+ # If specified you need to define the settings of the actual dispatcher.
+ use-dispatcher = ""
+
+ # Gossip to random node with newer or older state information, if any with
+ # this probability. Otherwise Gossip to any random live node.
+ # Probability value is between 0.0 and 1.0. 0.0 means never, 1.0 means always.
+ gossip-different-view-probability = 0.8
+
+ # Reduced the above probability when the number of nodes in the cluster
+ # greater than this value.
+ reduce-gossip-different-view-probability = 400
+
+ # When a node is removed the removal is marked with a tombstone
+ # which is kept at least this long, after which it is pruned, if there is a partition
+ # longer than this it could lead to removed nodes being re-added to the cluster
+ prune-gossip-tombstones-after = 24h
+
+ # Settings for the Phi accrual failure detector (http://www.jaist.ac.jp/~defago/files/pdf/IS_RR_2004_010.pdf
+ # [Hayashibara et al]) used by the cluster subsystem to detect unreachable
+ # members.
+ # The default PhiAccrualFailureDetector will trigger if there are no heartbeats within
+ # the duration heartbeat-interval + acceptable-heartbeat-pause + threshold_adjustment,
+ # i.e. around 5.5 seconds with default settings.
+ 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 = 8.0
+
+ # Number of the samples of inter-heartbeat arrival times to adaptively
+ # calculate the failure timeout for connections.
+ max-sample-size = 1000
+
+ # 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 = 3 s
+
+ # Number of member nodes that each member will send heartbeat messages to,
+ # i.e. each node will be monitored by this number of other nodes.
+ monitored-by-nr-of-members = 5
+
+ # After the heartbeat request has been sent the first failure detection
+ # will start after this period, even though no heartbeat message has
+ # been received.
+ expected-response-after = 1 s
+
+ }
+
+ # Configures multi-dc specific heartbeating and other mechanisms,
+ # many of them have a direct counter-part in "one datacenter mode",
+ # in which case these settings would not be used at all - they only apply,
+ # if your cluster nodes are configured with at-least 2 different `akka.cluster.data-center` values.
+ multi-data-center {
+
+ # Defines which data center this node belongs to. It is typically used to make islands of the
+ # cluster that are colocated. This can be used to make the cluster aware that it is running
+ # across multiple availability zones or regions. It can also be used for other logical
+ # grouping of nodes.
+ self-data-center = "default"
+
+
+ # Try to limit the number of connections between data centers. Used for gossip and heartbeating.
+ # This will not limit connections created for the messaging of the application.
+ # If the cluster does not span multiple data centers, this value has no effect.
+ cross-data-center-connections = 5
+
+ # The n oldest nodes in a data center will choose to gossip to another data center with
+ # this probability. Must be a value between 0.0 and 1.0 where 0.0 means never, 1.0 means always.
+ # When a data center is first started (nodes < 5) a higher probability is used so other data
+ # centers find out about the new nodes more quickly
+ cross-data-center-gossip-probability = 0.2
+
+ 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"
+
+ # 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 keep-alive heartbeat messages should be sent to each connection.
+ heartbeat-interval = 3 s
+
+ # After the heartbeat request has been sent the first failure detection
+ # will start after this period, even though no heartbeat message has
+ # been received.
+ expected-response-after = 1 s
+ }
+ }
+
+ # If the tick-duration of the default scheduler is longer than the
+ # tick-duration configured here a dedicated scheduler will be used for
+ # periodic tasks of the cluster, otherwise the default scheduler is used.
+ # See akka.scheduler settings for more details.
+ scheduler {
+ tick-duration = 33ms
+ ticks-per-wheel = 512
+ }
+
+ debug {
+ # log heartbeat events (very verbose, useful mostly when debugging heartbeating issues)
+ verbose-heartbeat-logging = off
+
+ # log verbose details about gossip
+ verbose-gossip-logging = off
+ }
+
+ configuration-compatibility-check {
+
+ # Enforce configuration compatibility checks when joining a cluster.
+ # Set to off to allow joining nodes to join a cluster even when configuration incompatibilities are detected or
+ # when the cluster does not support this feature. Compatibility checks are always performed and warning and
+ # error messsages are logged.
+ #
+ # This is particularly useful for rolling updates on clusters that do not support that feature. Since the old
+ # cluster won't be able to send the compatibility confirmation to the joining node, the joining node won't be able
+ # to 'know' if its allowed to join.
+ enforce-on-join = on
+
+ # Add named entry to this section with fully qualified class name of the JoinConfigCompatChecker
+ # to enable.
+ # Checkers defined in reference.conf can be disabled by application by using empty string value
+ # for the named entry.
+ checkers {
+ akka-cluster = "akka.cluster.JoinConfigCompatCheckCluster"
+ }
+
+ # Some configuration properties might not be appropriate to transfer between nodes
+ # and such properties can be excluded from the configuration compatibility check by adding
+ # the paths of the properties to this list. Sensitive paths are grouped by key. Modules and third-party libraries
+ # can define their own set of sensitive paths without clashing with each other (as long they use unique keys).
+ #
+ # All properties starting with the paths defined here are excluded, i.e. you can add the path of a whole
+ # section here to skip everything inside that section.
+ sensitive-config-paths {
+ akka = [
+ "user.home", "user.name", "user.dir",
+ "socksNonProxyHosts", "http.nonProxyHosts", "ftp.nonProxyHosts",
+ "akka.remote.secure-cookie",
+ "akka.remote.netty.ssl.security",
+ "akka.remote.artery.ssl"
+ ]
+ }
+
+ }
+ }
+
+ actor.deployment.default.cluster {
+ # enable cluster aware router that deploys to nodes in the cluster
+ enabled = off
+
+ # Maximum number of routees that will be deployed on each cluster
+ # member node.
+ # Note that max-total-nr-of-instances defines total number of routees, but
+ # number of routees per node will not be exceeded, i.e. if you
+ # define max-total-nr-of-instances = 50 and max-nr-of-instances-per-node = 2
+ # it will deploy 2 routees per new member in the cluster, up to
+ # 25 members.
+ max-nr-of-instances-per-node = 1
+
+ # Maximum number of routees that will be deployed, in total
+ # on all nodes. See also description of max-nr-of-instances-per-node.
+ # For backwards compatibility reasons, nr-of-instances
+ # has the same purpose as max-total-nr-of-instances for cluster
+ # aware routers and nr-of-instances (if defined by user) takes
+ # precedence over max-total-nr-of-instances.
+ max-total-nr-of-instances = 10000
+
+ # Defines if routees are allowed to be located on the same node as
+ # the head router actor, or only on remote nodes.
+ # Useful for master-worker scenario where all routees are remote.
+ allow-local-routees = on
+
+ # Use members with all specified roles, or all members if undefined or empty.
+ use-roles = []
+
+ # Deprecated, since Akka 2.5.4, replaced by use-roles
+ # Use members with specified role, or all members if undefined or empty.
+ use-role = ""
+ }
+
+ # Protobuf serializer for cluster messages
+ actor {
+ serializers {
+ akka-cluster = "akka.cluster.protobuf.ClusterMessageSerializer"
+ }
+
+ serialization-bindings {
+ "akka.cluster.ClusterMessage" = akka-cluster
+ "akka.cluster.routing.ClusterRouterPool" = akka-cluster
+ }
+
+ serialization-identifiers {
+ "akka.cluster.protobuf.ClusterMessageSerializer" = 5
+ }
+
+ }
+
+}
--- /dev/null
+###########################################################
+# Akka Persistence Extension Reference Configuration File #
+###########################################################
+
+# This is the reference config file that contains all the default settings.
+# Make your edits in your application.conf in order to override these settings.
+
+# Directory of persistence journal and snapshot store plugins is available at the
+# Akka Community Projects page http://akka.io/community/
+
+# Default persistence extension settings.
+akka.persistence {
+
+ # When starting many persistent actors at the same time the journal
+ # and its data store is protected from being overloaded by limiting number
+ # of recoveries that can be in progress at the same time. When
+ # exceeding the limit the actors will wait until other recoveries have
+ # been completed.
+ max-concurrent-recoveries = 50
+
+ # Fully qualified class name providing a default internal stash overflow strategy.
+ # It needs to be a subclass of akka.persistence.StashOverflowStrategyConfigurator.
+ # The default strategy throws StashOverflowException.
+ internal-stash-overflow-strategy = "akka.persistence.ThrowExceptionConfigurator"
+ journal {
+ # Absolute path to the journal plugin configuration entry used by
+ # persistent actor by default.
+ # Persistent actor can override `journalPluginId` method
+ # in order to rely on a different journal plugin.
+ plugin = ""
+ # List of journal plugins to start automatically. Use "" for the default journal plugin.
+ auto-start-journals = []
+ }
+ snapshot-store {
+ # Absolute path to the snapshot plugin configuration entry used by
+ # persistent actor by default.
+ # Persistent actor can override `snapshotPluginId` method
+ # in order to rely on a different snapshot plugin.
+ # It is not mandatory to specify a snapshot store plugin.
+ # If you don't use snapshots you don't have to configure it.
+ # Note that Cluster Sharding is using snapshots, so if you
+ # use Cluster Sharding you need to define a snapshot store plugin.
+ plugin = ""
+ # List of snapshot stores to start automatically. Use "" for the default snapshot store.
+ auto-start-snapshot-stores = []
+ }
+ # used as default-snapshot store if no plugin configured
+ # (see `akka.persistence.snapshot-store`)
+ no-snapshot-store {
+ class = "akka.persistence.snapshot.NoSnapshotStore"
+ }
+ # Default reliable delivery settings.
+ at-least-once-delivery {
+ # Interval between re-delivery attempts.
+ redeliver-interval = 5s
+ # Maximum number of unconfirmed messages that will be sent in one
+ # re-delivery burst.
+ redelivery-burst-limit = 10000
+ # After this number of delivery attempts a
+ # `ReliableRedelivery.UnconfirmedWarning`, message will be sent to the actor.
+ warn-after-number-of-unconfirmed-attempts = 5
+ # Maximum number of unconfirmed messages that an actor with
+ # AtLeastOnceDelivery is allowed to hold in memory.
+ max-unconfirmed-messages = 100000
+ }
+ # Default persistent extension thread pools.
+ dispatchers {
+ # Dispatcher used by every plugin which does not declare explicit
+ # `plugin-dispatcher` field.
+ default-plugin-dispatcher {
+ type = PinnedDispatcher
+ executor = "thread-pool-executor"
+ }
+ # Default dispatcher for message replay.
+ default-replay-dispatcher {
+ type = Dispatcher
+ executor = "fork-join-executor"
+ fork-join-executor {
+ parallelism-min = 2
+ parallelism-max = 8
+ }
+ }
+ # Default dispatcher for streaming snapshot IO
+ default-stream-dispatcher {
+ type = Dispatcher
+ executor = "fork-join-executor"
+ fork-join-executor {
+ parallelism-min = 2
+ parallelism-max = 8
+ }
+ }
+ }
+
+ # Fallback settings for journal plugin configurations.
+ # These settings are used if they are not defined in plugin config section.
+ journal-plugin-fallback {
+
+ # Fully qualified class name providing journal plugin api implementation.
+ # It is mandatory to specify this property.
+ # The class must have a constructor without parameters or constructor with
+ # one `com.typesafe.config.Config` parameter.
+ class = ""
+
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
+
+ # Dispatcher for message replay.
+ replay-dispatcher = "akka.persistence.dispatchers.default-replay-dispatcher"
+
+ # Removed: used to be the Maximum size of a persistent message batch written to the journal.
+ # Now this setting is without function, PersistentActor will write as many messages
+ # as it has accumulated since the last write.
+ max-message-batch-size = 200
+
+ # If there is more time in between individual events gotten from the journal
+ # recovery than this the recovery will fail.
+ # Note that it also affects reading the snapshot before replaying events on
+ # top of it, even though it is configured for the journal.
+ recovery-event-timeout = 30s
+
+ circuit-breaker {
+ max-failures = 10
+ call-timeout = 10s
+ reset-timeout = 30s
+ }
+
+ # The replay filter can detect a corrupt event stream by inspecting
+ # sequence numbers and writerUuid when replaying events.
+ replay-filter {
+ # What the filter should do when detecting invalid events.
+ # Supported values:
+ # `repair-by-discard-old` : discard events from old writers,
+ # warning is logged
+ # `fail` : fail the replay, error is logged
+ # `warn` : log warning but emit events untouched
+ # `off` : disable this feature completely
+ mode = repair-by-discard-old
+
+ # It uses a look ahead buffer for analyzing the events.
+ # This defines the size (in number of events) of the buffer.
+ window-size = 100
+
+ # How many old writerUuid to remember
+ max-old-writers = 10
+
+ # Set this to `on` to enable detailed debug logging of each
+ # replayed event.
+ debug = off
+ }
+ }
+
+ # Fallback settings for snapshot store plugin configurations
+ # These settings are used if they are not defined in plugin config section.
+ snapshot-store-plugin-fallback {
+
+ # Fully qualified class name providing snapshot store plugin api
+ # implementation. It is mandatory to specify this property if
+ # snapshot store is enabled.
+ # The class must have a constructor without parameters or constructor with
+ # one `com.typesafe.config.Config` parameter.
+ class = ""
+
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
+
+ circuit-breaker {
+ max-failures = 5
+ call-timeout = 20s
+ reset-timeout = 60s
+ }
+ }
+
+ fsm {
+ # PersistentFSM saves snapshots after this number of persistent
+ # events. Snapshots are used to reduce recovery times.
+ # When you disable this feature, specify snapshot-after = off.
+ # To enable the feature, specify a number like snapshot-after = 1000
+ # which means a snapshot is taken after persisting every 1000 events.
+ snapshot-after = off
+ }
+}
+
+# Protobuf serialization for the persistent extension messages.
+akka.actor {
+ serializers {
+ akka-persistence-message = "akka.persistence.serialization.MessageSerializer"
+ akka-persistence-snapshot = "akka.persistence.serialization.SnapshotSerializer"
+ }
+ serialization-bindings {
+ "akka.persistence.serialization.Message" = akka-persistence-message
+ "akka.persistence.serialization.Snapshot" = akka-persistence-snapshot
+ }
+ serialization-identifiers {
+ "akka.persistence.serialization.MessageSerializer" = 7
+ "akka.persistence.serialization.SnapshotSerializer" = 8
+ }
+}
+
+
+###################################################
+# Persistence plugins included with the extension #
+###################################################
+
+# In-memory journal plugin.
+akka.persistence.journal.inmem {
+ # Class name of the plugin.
+ class = "akka.persistence.journal.inmem.InmemJournal"
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.actor.default-dispatcher"
+}
+
+# Local file system snapshot store plugin.
+akka.persistence.snapshot-store.local {
+ # Class name of the plugin.
+ class = "akka.persistence.snapshot.local.LocalSnapshotStore"
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
+ # Dispatcher for streaming snapshot IO.
+ stream-dispatcher = "akka.persistence.dispatchers.default-stream-dispatcher"
+ # Storage location of snapshot files.
+ dir = "snapshots"
+ # Number load attempts when recovering from the latest snapshot fails
+ # yet older snapshot files are available. Each recovery attempt will try
+ # to recover using an older than previously failed-on snapshot file
+ # (if any are present). If all attempts fail the recovery will fail and
+ # the persistent actor will be stopped.
+ max-load-attempts = 3
+}
+
+# LevelDB journal plugin.
+# Note: this plugin requires explicit LevelDB dependency, see below.
+akka.persistence.journal.leveldb {
+ # Class name of the plugin.
+ class = "akka.persistence.journal.leveldb.LeveldbJournal"
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
+ # Dispatcher for message replay.
+ replay-dispatcher = "akka.persistence.dispatchers.default-replay-dispatcher"
+ # Storage location of LevelDB files.
+ dir = "journal"
+ # Use fsync on write.
+ fsync = on
+ # Verify checksum on read.
+ checksum = off
+ # Native LevelDB (via JNI) or LevelDB Java port.
+ native = on
+ # Number of deleted messages per persistence id that will trigger journal compaction
+ compaction-intervals {
+ }
+}
+
+# Shared LevelDB journal plugin (for testing only).
+# Note: this plugin requires explicit LevelDB dependency, see below.
+akka.persistence.journal.leveldb-shared {
+ # Class name of the plugin.
+ class = "akka.persistence.journal.leveldb.SharedLeveldbJournal"
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.actor.default-dispatcher"
+ # Timeout for async journal operations.
+ timeout = 10s
+ store {
+ # Dispatcher for shared store actor.
+ store-dispatcher = "akka.persistence.dispatchers.default-plugin-dispatcher"
+ # Dispatcher for message replay.
+ replay-dispatcher = "akka.persistence.dispatchers.default-replay-dispatcher"
+ # Storage location of LevelDB files.
+ dir = "journal"
+ # Use fsync on write.
+ fsync = on
+ # Verify checksum on read.
+ checksum = off
+ # Native LevelDB (via JNI) or LevelDB Java port.
+ native = on
+ # Number of deleted messages per persistence id that will trigger journal compaction
+ compaction-intervals {
+ }
+ }
+}
+
+akka.persistence.journal.proxy {
+ # Class name of the plugin.
+ class = "akka.persistence.journal.PersistencePluginProxy"
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.actor.default-dispatcher"
+ # Set this to on in the configuration of the ActorSystem
+ # that will host the target journal
+ start-target-journal = off
+ # The journal plugin config path to use for the target journal
+ target-journal-plugin = ""
+ # The address of the proxy to connect to from other nodes. Optional setting.
+ target-journal-address = ""
+ # Initialization timeout of target lookup
+ init-timeout = 10s
+}
+
+akka.persistence.snapshot-store.proxy {
+ # Class name of the plugin.
+ class = "akka.persistence.journal.PersistencePluginProxy"
+ # Dispatcher for the plugin actor.
+ plugin-dispatcher = "akka.actor.default-dispatcher"
+ # Set this to on in the configuration of the ActorSystem
+ # that will host the target snapshot-store
+ start-target-snapshot-store = off
+ # The journal plugin config path to use for the target snapshot-store
+ target-snapshot-store-plugin = ""
+ # The address of the proxy to connect to from other nodes. Optional setting.
+ target-snapshot-store-address = ""
+ # Initialization timeout of target lookup
+ init-timeout = 10s
+}
+
+# LevelDB persistence requires the following dependency declarations:
+#
+# SBT:
+# "org.iq80.leveldb" % "leveldb" % "0.7"
+# "org.fusesource.leveldbjni" % "leveldbjni-all" % "1.8"
+#
+# Maven:
+# <dependency>
+# <groupId>org.iq80.leveldb</groupId>
+# <artifactId>leveldb</artifactId>
+# <version>0.7</version>
+# </dependency>
+# <dependency>
+# <groupId>org.fusesource.leveldbjni</groupId>
+# <artifactId>leveldbjni-all</artifactId>
+# <version>1.8</version>
+# </dependency>
--- /dev/null
+include "actor_reference.conf"
+include "cluster_reference.conf"
+include "persistence_reference.conf"
+include "remote_reference.conf"
+include "stream_reference.conf"
--- /dev/null
+#//#shared
+#####################################
+# 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.
+#
+# For the configuration of the new remoting implementation (Artery) please look
+# at the bottom section of this file as it is listed separately.
+
+akka {
+
+ actor {
+
+ serializers {
+ akka-containers = "akka.remote.serialization.MessageContainerSerializer"
+ akka-misc = "akka.remote.serialization.MiscMessageSerializer"
+ artery = "akka.remote.serialization.ArteryMessageSerializer"
+ proto = "akka.remote.serialization.ProtobufSerializer"
+ daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer"
+ primitive-long = "akka.remote.serialization.LongSerializer"
+ primitive-int = "akka.remote.serialization.IntSerializer"
+ primitive-string = "akka.remote.serialization.StringSerializer"
+ primitive-bytestring = "akka.remote.serialization.ByteStringSerializer"
+ akka-system-msg = "akka.remote.serialization.SystemMessageSerializer"
+ }
+
+ serialization-bindings {
+ "akka.actor.ActorSelectionMessage" = akka-containers
+
+ "akka.remote.DaemonMsgCreate" = daemon-create
+
+ "akka.remote.artery.ArteryMessage" = artery
+
+ # 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
+
+ "java.util.Optional" = akka-misc
+
+
+ # The following are handled by the MiscMessageSerializer, but they are not enabled for
+ # compatibility reasons (it was added in Akka 2.5.[8,9,12]). Enable them by adding:
+ # akka.actor.serialization-bindings {
+ # "akka.Done" = akka-misc
+ # "akka.NotUsed" = akka-misc
+ # "akka.actor.Address" = akka-misc
+ # "akka.remote.UniqueAddress" = akka-misc
+ # }
+ }
+
+ # Additional serialization-bindings that are replacing Java serialization are
+ # defined in this section for backwards compatibility reasons. They are included
+ # by default but can be excluded for backwards compatibility with Akka 2.4.x.
+ # They can be disabled with enable-additional-serialization-bindings=off.
+ additional-serialization-bindings {
+ "akka.actor.Identify" = akka-misc
+ "akka.actor.ActorIdentity" = akka-misc
+ "scala.Some" = akka-misc
+ "scala.None$" = akka-misc
+ "akka.actor.Status$Success" = akka-misc
+ "akka.actor.Status$Failure" = akka-misc
+ "akka.actor.ActorRef" = akka-misc
+ "akka.actor.PoisonPill$" = akka-misc
+ "akka.actor.Kill$" = akka-misc
+ "akka.remote.RemoteWatcher$Heartbeat$" = akka-misc
+ "akka.remote.RemoteWatcher$HeartbeatRsp" = akka-misc
+ "akka.actor.ActorInitializationException" = akka-misc
+
+ "akka.dispatch.sysmsg.SystemMessage" = akka-system-msg
+
+ "java.lang.String" = primitive-string
+ "akka.util.ByteString$ByteString1C" = primitive-bytestring
+ "akka.util.ByteString$ByteString1" = primitive-bytestring
+ "akka.util.ByteString$ByteStrings" = primitive-bytestring
+ "java.lang.Long" = primitive-long
+ "scala.Long" = primitive-long
+ "java.lang.Integer" = primitive-int
+ "scala.Int" = primitive-int
+
+ # Java Serializer is by default used for exceptions.
+ # It's recommended that you implement custom serializer for exceptions that are
+ # sent remotely, e.g. in akka.actor.Status.Failure for ask replies. You can add
+ # binding to akka-misc (MiscMessageSerializerSpec) for the exceptions that have
+ # a constructor with single message String or constructor with message String as
+ # first parameter and cause Throwable as second parameter. Note that it's not
+ # safe to add this binding for general exceptions such as IllegalArgumentException
+ # because it may have a subclass without required constructor.
+ "java.lang.Throwable" = java
+ "akka.actor.IllegalActorStateException" = akka-misc
+ "akka.actor.ActorKilledException" = akka-misc
+ "akka.actor.InvalidActorNameException" = akka-misc
+ "akka.actor.InvalidMessageException" = akka-misc
+
+ # TODO issue #27330: TimeoutException not enabled for serialization in 2.5.x yet
+ #"java.util.concurrent.TimeoutException" = akka-misc
+ # TODO issue #27330: ThrowableNotSerializableException not enabled for serialization in 2.5.x yet
+ #"akka.remote.serialization.ThrowableNotSerializableException" = akka-misc
+
+ "akka.actor.LocalScope$" = akka-misc
+ "akka.remote.RemoteScope" = akka-misc
+
+ "com.typesafe.config.impl.SimpleConfig" = akka-misc
+ "com.typesafe.config.Config" = akka-misc
+
+ "akka.routing.FromConfig" = akka-misc
+ "akka.routing.DefaultResizer" = akka-misc
+ "akka.routing.BalancingPool" = akka-misc
+ "akka.routing.BroadcastGroup" = akka-misc
+ "akka.routing.BroadcastPool" = akka-misc
+ "akka.routing.RandomGroup" = akka-misc
+ "akka.routing.RandomPool" = akka-misc
+ "akka.routing.RoundRobinGroup" = akka-misc
+ "akka.routing.RoundRobinPool" = akka-misc
+ "akka.routing.ScatterGatherFirstCompletedGroup" = akka-misc
+ "akka.routing.ScatterGatherFirstCompletedPool" = akka-misc
+ "akka.routing.SmallestMailboxPool" = akka-misc
+ "akka.routing.TailChoppingGroup" = akka-misc
+ "akka.routing.TailChoppingPool" = akka-misc
+ "akka.remote.routing.RemoteRouterConfig" = akka-misc
+ }
+
+ # Additional serialization bindings which are enabled automatically when allow-java-serialization is disabled.
+ java-serialization-disabled-additional-serialization-bindings = {
+ "akka.Done" = akka-misc
+ "akka.NotUsed" = akka-misc
+ "akka.actor.Address" = akka-misc
+ "akka.remote.UniqueAddress" = akka-misc
+ }
+
+ serialization-identifiers {
+ "akka.remote.serialization.ProtobufSerializer" = 2
+ "akka.remote.serialization.DaemonMsgCreateSerializer" = 3
+ "akka.remote.serialization.MessageContainerSerializer" = 6
+ "akka.remote.serialization.MiscMessageSerializer" = 16
+ "akka.remote.serialization.ArteryMessageSerializer" = 17
+ "akka.remote.serialization.LongSerializer" = 18
+ "akka.remote.serialization.IntSerializer" = 19
+ "akka.remote.serialization.StringSerializer" = 20
+ "akka.remote.serialization.ByteStringSerializer" = 21
+ "akka.remote.serialization.SystemMessageSerializer" = 22
+ }
+
+ deployment {
+
+ default {
+
+ # if this is set to a valid remote address, the named actor will be
+ # deployed at that node e.g. "akka.tcp://sys@host:port"
+ remote = ""
+
+ target {
+
+ # A list of hostnames and ports for instantiating the children of a
+ # router
+ # The format should be on "akka.tcp://sys@host:port", where:
+ # - sys is the remote actor system name
+ # - hostname can be either hostname or IP address the remote actor
+ # should connect to
+ # - port should be the port for the remote server on the other node
+ # The number of actor instances to be spawned is still taken from the
+ # nr-of-instances setting as for local routers; the instances will be
+ # distributed round-robin among the given nodes.
+ nodes = []
+
+ }
+ }
+ }
+ }
+
+ remote {
+ ### Settings shared by classic remoting and Artery (the new implementation of remoting)
+
+ # 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"
+
+ # 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. 124 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 = 120 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
+
+ }
+
+ # remote deployment configuration section
+ deployment {
+ # If true, will only allow specific classes to be instanciated on this system via remote deployment
+ enable-whitelist = off
+
+ whitelist = []
+ }
+#//#shared
+ }
+
+}
+
+akka {
+
+ remote {
+#//#classic
+
+ ### Configuration for classic remoting
+
+ # 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
+
+ ### 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
+
+ # 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.
+ #
+ # Maximum value depends on the scheduler's max limit (default 248 days) and if configured
+ # to a longer duration this feature will effectively be disabled. Setting the value to
+ # 'off' will also disable the feature. Note that if disabled there is a risk of a long
+ # term memory leak.
+ quarantine-after-silence = 2 d
+
+ # This setting defines the maximum number of unacknowledged system messages
+ # allowed for a remote system. If this limit is reached the remote system is
+ # declared to be dead and its UID marked as tainted.
+ system-message-buffer-size = 20000
+
+ # This setting defines the maximum idle time after an individual
+ # acknowledgement for system messages is sent. System message delivery
+ # is guaranteed by explicit acknowledgement messages. These acks are
+ # piggybacked on ordinary traffic messages. If no traffic is detected
+ # during the time period configured here, the remoting will send out
+ # an individual ack.
+ system-message-ack-piggyback-timeout = 0.3 s
+
+ # This setting defines the time after internal management signals
+ # between actors (used for DeathWatch and supervision) that have not been
+ # explicitly acknowledged or negatively acknowledged are resent.
+ # Messages that were negatively acknowledged are always immediately
+ # resent.
+ resend-interval = 2 s
+
+ # Maximum number of unacknowledged system messages that will be resent
+ # each 'resend-interval'. If you watch many (> 1000) remote actors you can
+ # increase this value to for example 600, but a too large limit (e.g. 10000)
+ # may flood the connection and might cause false failure detection to trigger.
+ # Test such a configuration by watching all actors at the same time and stop
+ # all watched actors at the same time.
+ resend-limit = 200
+
+ # WARNING: this setting should not be not changed unless all of its consequences
+ # are properly understood which assumes experience with remoting internals
+ # or expert advice.
+ # This setting defines the time after redelivery attempts of internal management
+ # signals are stopped to a remote system that has been not confirmed to be alive by
+ # this system before.
+ initial-system-message-delivery-timeout = 3 m
+
+ ### Transports and adapters
+
+ # List of the transport drivers that will be loaded by the remoting.
+ # A list of fully qualified config paths must be provided where
+ # the given configuration path contains a transport-class key
+ # pointing to an implementation class of the Transport interface.
+ # If multiple transports are provided, the address of the first
+ # one will be used as a default address.
+ enabled-transports = ["akka.remote.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 "<id.of.dispatcher>" then the specified dispatcher
+ # will be used to accept inbound connections, and perform IO. If "" then
+ # dedicated threads will be used.
+ # Please note that the 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
+ }
+
+
+ }
+
+ # DEPRECATED, since 2.5.0
+ # The netty.udp transport is deprecated, please use Artery instead.
+ # See: https://doc.akka.io/docs/akka/current/remoting-artery.html
+ 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
+
+ # Factory of SSLEngine.
+ # Must implement akka.remote.transport.netty.SSLEngineProvider and have a public
+ # constructor with an ActorSystem parameter.
+ # The default ConfigSSLEngineProvider is configured by properties in section
+ # akka.remote.netty.ssl.security
+ #
+ # The SSLEngineProvider can also be defined via ActorSystemSetup with
+ # SSLEngineProviderSetup when starting the ActorSystem. That is useful when
+ # the SSLEngineProvider implementation requires other external constructor
+ # parameters or is created before the ActorSystem is created.
+ # If such SSLEngineProviderSetup is defined this config property is not used.
+ ssl-engine-provider = akka.remote.transport.netty.ConfigSSLEngineProvider
+
+ 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 two options, and the default SecureRandom is recommended:
+ # "" or "SecureRandom" => (default)
+ # "SHA1PRNG" => Can be slow because of blocking issues on Linux
+ #
+ # Setting a value here may require you to supply the appropriate cipher
+ # suite (see enabled-algorithms section above)
+ random-number-generator = ""
+
+ # Require mutual authentication between TLS peers
+ #
+ # Without mutual authentication only the peer that actively establishes a connection (TLS client side)
+ # checks if the passive side (TLS server side) sends over a trusted certificate. With the flag turned on,
+ # the passive side will also request and verify a certificate from the connecting peer.
+ #
+ # To prevent man-in-the-middle attacks this setting is enabled by default.
+ #
+ # Note: Nodes that are configured with this setting to 'on' might not be able to receive messages from nodes that
+ # run on older versions of akka-remote. This is because in versions of Akka < 2.4.12 the active side of the remoting
+ # connection will not send over certificates even if asked.
+ #
+ # However, starting with Akka 2.4.12, even with this setting "off", the active side (TLS client side)
+ # will use the given key-store to send over a certificate if asked. A rolling upgrade from versions of
+ # Akka < 2.4.12 can therefore work like this:
+ # - upgrade all nodes to an Akka version >= 2.4.12, in the best case the latest version, but keep this setting at "off"
+ # - then switch this flag to "on" and do again a rolling upgrade of all nodes
+ # The first step ensures that all nodes will send over a certificate when asked to. The second
+ # step will ensure that all nodes finally enforce the secure checking of client certificates.
+ require-mutual-authentication = on
+ }
+ }
+
+ ### 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 {
+ parallelism-min = 2
+ parallelism-factor = 0.5
+ parallelism-max = 16
+ }
+ throughput = 10
+ }
+
+ 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
+ }
+ }
+ }
+}
+#//#classic
+
+akka {
+
+ remote {
+ #//#artery
+
+ ### Configuration for Artery, the new implementation of remoting
+ artery {
+
+ # Enable the new remoting with this flag
+ enabled = off
+
+ # Select the underlying transport implementation.
+ #
+ # Possible values: aeron-udp, tcp, tls-tcp
+ #
+ # The Aeron (UDP) transport is a high performance transport and should be used for systems
+ # that require high throughput and low latency. It is using more CPU than TCP when the
+ # system is idle or at low message rates. There is no encryption for Aeron.
+ # https://github.com/real-logic/aeron
+ #
+ # The TCP and TLS transport is implemented using Akka Streams TCP/TLS. This is the choice
+ # when encryption is needed, but it can also be used with plain TCP without TLS. It's also
+ # the obvious choice when UDP can't be used.
+ # It has very good performance (high throughput and low latency) but latency at high throughput
+ # might not be as good as the Aeron transport.
+ # It is using less CPU than Aeron when the system is idle or at low message rates.
+ transport = aeron-udp
+
+ # Canonical address is the address other clients should connect to.
+ # Artery transport will expect messages to this address.
+ canonical {
+
+ # The default remote server port clients should connect to.
+ # Default is 25520, use 0 if you want a random available port
+ # This port needs to be unique for each actor system on the same machine.
+ port = 25520
+
+ # Hostname clients should connect to. Can be set to an ip, hostname
+ # or one of the following special values:
+ # "<getHostAddress>" InetAddress.getLocalHost.getHostAddress
+ # "<getHostName>" InetAddress.getLocalHost.getHostName
+ #
+ hostname = "<getHostAddress>"
+ }
+
+ # Use these settings to bind a network interface to a different address
+ # than artery expects messages at. This may be used when running Akka
+ # nodes in a separated networks (under NATs or in containers). If canonical
+ # and bind addresses are different, then network configuration that relays
+ # communications from canonical to bind addresses is expected.
+ bind {
+
+ # Port to bind a network interface to. Can be set to a port number
+ # of one of the following special values:
+ # 0 random available port
+ # "" akka.remote.artery.canonical.port
+ #
+ port = ""
+
+ # Hostname to bind a network interface to. Can be set to an ip, hostname
+ # or one of the following special values:
+ # "0.0.0.0" all interfaces
+ # "" akka.remote.artery.canonical.hostname
+ # "<getHostAddress>" InetAddress.getLocalHost.getHostAddress
+ # "<getHostName>" InetAddress.getLocalHost.getHostName
+ #
+ hostname = ""
+
+ # Time to wait for Aeron/TCP to bind
+ bind-timeout = 3s
+ }
+
+ # Periodically log out all Aeron counters. See https://github.com/real-logic/aeron/wiki/Monitoring-and-Debugging#counters
+ # Only used when transport is aeron-udp.
+ log-aeron-counters = false
+
+ # 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"
+ # Entries have to be specified on both the sending and receiving side.
+ # 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 = []
+
+ # Enable untrusted mode, which discards inbound system messages, PossiblyHarmful and
+ # ActorSelection messages. E.g. remote watch and remote deployment will not work.
+ # ActorSelection messages can be enabled for specific paths with the trusted-selection-paths
+ 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 = []
+
+ # If this is "on", all inbound remote messages will be logged at DEBUG level,
+ # if off then they are not logged
+ log-received-messages = off
+
+ # If this is "on", all outbound remote messages will be logged at DEBUG level,
+ # if off then they are not logged
+ log-sent-messages = off
+
+ advanced {
+
+ # Maximum serialized message size, including header data.
+ maximum-frame-size = 256 KiB
+
+ # Direct byte buffers are reused in a pool with this maximum size.
+ # Each buffer has the size of 'maximum-frame-size'.
+ # This is not a hard upper limit on number of created buffers. Additional
+ # buffers will be created if needed, e.g. when using many outbound
+ # associations at the same time. Such additional buffers will be garbage
+ # collected, which is not as efficient as reusing buffers in the pool.
+ buffer-pool-size = 128
+
+ # Maximum serialized message size for the large messages, including header data.
+ # It is currently restricted to 1/8th the size of a term buffer that can be
+ # configured by setting the 'aeron.term.buffer.length' system property.
+ # See 'large-message-destinations'.
+ maximum-large-frame-size = 2 MiB
+
+ # Direct byte buffers for the large messages are reused in a pool with this maximum size.
+ # Each buffer has the size of 'maximum-large-frame-size'.
+ # See 'large-message-destinations'.
+ # This is not a hard upper limit on number of created buffers. Additional
+ # buffers will be created if needed, e.g. when using many outbound
+ # associations at the same time. Such additional buffers will be garbage
+ # collected, which is not as efficient as reusing buffers in the pool.
+ large-buffer-pool-size = 32
+
+ # For enabling testing features, such as blackhole in akka-remote-testkit.
+ test-mode = off
+
+ # Settings for the materializer that is used for the remote streams.
+ materializer = ${akka.stream.materializer}
+
+ # If set to a nonempty string artery will use the given dispatcher for
+ # the ordinary and large message streams, otherwise the default dispatcher is used.
+ use-dispatcher = "akka.remote.default-remote-dispatcher"
+
+ # If set to a nonempty string remoting will use the given dispatcher for
+ # the control stream, otherwise the default dispatcher is used.
+ # It can be good to not use the same dispatcher for the control stream as
+ # the dispatcher for the ordinary message stream so that heartbeat messages
+ # are not disturbed.
+ use-control-stream-dispatcher = ""
+
+ # 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'.
+ # Only used when transport is aeron-udp.
+ 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).
+ # Only used when transport is aeron-udp.
+ aeron-dir = ""
+
+ # Whether to delete aeron embedded driver directory upon driver stop.
+ # Only used when transport is aeron-udp.
+ delete-aeron-dir = yes
+
+ # Level of CPU time used, on a scale between 1 and 10, during backoff/idle.
+ # The tradeoff is that to have low latency more CPU time must be used to be
+ # able to react quickly on incoming messages or send as fast as possible after
+ # backoff backpressure.
+ # Level 1 strongly prefer low CPU consumption over low latency.
+ # Level 10 strongly prefer low latency over low CPU consumption.
+ # Only used when transport is aeron-udp.
+ idle-cpu-level = 5
+
+ # Total number of inbound lanes, shared among all inbound associations. A value
+ # greater than 1 means that deserialization can be performed in parallel for
+ # different destination actors. The selection of lane is based on consistent
+ # hashing of the recipient ActorRef to preserve message ordering per receiver.
+ # Lowest latency can be achieved with inbound-lanes=1 because of one less
+ # asynchronous boundary.
+ inbound-lanes = 4
+
+ # Number of outbound lanes for each outbound association. A value greater than 1
+ # means that serialization and other work can be performed in parallel for different
+ # destination actors. The selection of lane is based on consistent hashing of the
+ # recipient ActorRef to preserve message ordering per receiver. Note that messages
+ # for different destination systems (hosts) are handled by different streams also
+ # when outbound-lanes=1. Lowest latency can be achieved with outbound-lanes=1
+ # because of one less asynchronous boundary.
+ outbound-lanes = 1
+
+ # Size of the send queue for outgoing messages. Messages will be dropped if
+ # the queue becomes full. This may happen if you send a burst of many messages
+ # without end-to-end flow control. Note that there is one such queue per
+ # outbound association. The trade-off of using a larger queue size is that
+ # it consumes more memory, since the queue is based on preallocated array with
+ # fixed size.
+ outbound-message-queue-size = 3072
+
+ # Size of the send queue for outgoing control messages, such as system messages.
+ # If this limit is reached the remote system is declared to be dead and its UID
+ # marked as quarantined. Note that there is one such queue per outbound association.
+ # It is a linked queue so it will not use more memory than needed but by increasing
+ # too much you may risk OutOfMemoryError in the worst case.
+ outbound-control-queue-size = 20000
+
+ # Size of the send queue for outgoing large messages. Messages will be dropped if
+ # the queue becomes full. This may happen if you send a burst of many messages
+ # without end-to-end flow control. Note that there is one such queue per
+ # outbound association.
+ # It is a linked queue so it will not use more memory than needed but by increasing
+ # too much you may risk OutOfMemoryError, especially since the message payload
+ # of these messages may be large.
+ outbound-large-message-queue-size = 256
+
+ # 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 quarantined.
+ system-message-buffer-size = 20000
+
+ # unacknowledged system messages are re-delivered with this interval
+ system-message-resend-interval = 1 second
+
+ # Timeout of establishing outbound connections.
+ # Only used when transport is tcp or tls-tcp.
+ connection-timeout = 5 seconds
+
+ # The timeout for outbound associations to perform the initial handshake.
+ # This timeout must be greater than the 'image-liveness-timeout' when
+ # transport is aeron-udp.
+ handshake-timeout = 20 seconds
+
+ # incomplete initial handshake attempt is retried with this interval
+ handshake-retry-interval = 1 second
+
+ # Handshake requests are performed periodically with this interval,
+ # also after the handshake has been completed to be able to establish
+ # a new session with a restarted destination system.
+ inject-handshake-interval = 1 second
+
+ # messages that are not accepted by Aeron are dropped after retrying for this period
+ # Only used when transport is aeron-udp.
+ give-up-message-after = 60 seconds
+
+ # System messages that are not acknowledged after re-sending for this period are
+ # dropped and will trigger quarantine. The value should be longer than the length
+ # of a network partition that you need to survive.
+ give-up-system-message-after = 6 hours
+
+ # Outbound streams are stopped when they haven't been used for this duration.
+ # They are started again when new messages are sent.
+ stop-idle-outbound-after = 5 minutes
+
+ # Outbound streams are quarantined when they haven't been used for this duration
+ # to cleanup resources used by the association, such as compression tables.
+ # This will cleanup association to crashed systems that didn't announce their
+ # termination.
+ # The value should be longer than the length of a network partition that you
+ # need to survive.
+ # The value must also be greater than stop-idle-outbound-after.
+ # Once every 1/10 of this duration an extra handshake message will be sent.
+ # Therfore it's also recommended to use a value that is greater than 10 times
+ # the stop-idle-outbound-after, since otherwise the idle streams will not be
+ # stopped.
+ quarantine-idle-outbound-after = 6 hours
+
+ # Stop outbound stream of a quarantined association after this idle timeout, i.e.
+ # when not used any more.
+ stop-quarantined-after-idle = 3 seconds
+
+ # After catastrophic communication failures that could 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 quarantined association will be kept around
+ # before being removed to avoid long-term memory leaks. It must be quarantined
+ # and also unused for this duration before it's removed. When removed the historical
+ # information about which UIDs that were quarantined for that hostname:port is
+ # gone which could result in communication with a previously quarantined node
+ # if it wakes up again. Therfore this shouldn't be set too low.
+ remove-quarantined-association-after = 1 h
+
+ # during ActorSystem termination the remoting will wait this long for
+ # an acknowledgment by the destination system that flushing of outstanding
+ # remote messages has been completed
+ shutdown-flush-timeout = 1 second
+
+ # See 'inbound-max-restarts'
+ inbound-restart-timeout = 5 seconds
+
+ # Max number of restarts within 'inbound-restart-timeout' for the inbound streams.
+ # If more restarts occurs the ActorSystem will be terminated.
+ inbound-max-restarts = 5
+
+ # Retry outbound connection after this backoff.
+ # Only used when transport is tcp or tls-tcp.
+ outbound-restart-backoff = 1 second
+
+ # See 'outbound-max-restarts'
+ outbound-restart-timeout = 5 seconds
+
+ # Max number of restarts within 'outbound-restart-timeout' for the outbound streams.
+ # If more restarts occurs the ActorSystem will be terminated.
+ outbound-max-restarts = 5
+
+ # Timeout after which aeron driver has not had keepalive messages
+ # from a client before it considers the client dead.
+ # Only used when transport is aeron-udp.
+ client-liveness-timeout = 20 seconds
+
+ # Timeout for each the INACTIVE and LINGER stages an aeron image
+ # will be retained for when it is no longer referenced.
+ # This timeout must be less than the 'handshake-timeout'.
+ # Only used when transport is aeron-udp.
+ image-liveness-timeout = 10 seconds
+
+ # Timeout after which the aeron driver is considered dead
+ # if it does not update its C'n'C timestamp.
+ # Only used when transport is aeron-udp.
+ driver-timeout = 20 seconds
+
+ flight-recorder {
+ // FIXME it should be enabled by default when we have a good solution for naming the files
+ enabled = off
+ # Controls where the flight recorder file will be written. There are three options:
+ # 1. Empty: a file will be generated in the temporary directory of the OS
+ # 2. A relative or absolute path ending with ".afr": this file will be used
+ # 3. A relative or absolute path: this directory will be used, the file will get a random file name
+ destination = ""
+ }
+
+ # compression of common strings in remoting messages, like actor destinations, serializers etc
+ compression {
+
+ actor-refs {
+ # Max number of compressed actor-refs
+ # Note that compression tables are "rolling" (i.e. a new table replaces the old
+ # compression table once in a while), and this setting is only about the total number
+ # of compressions within a single such table.
+ # Must be a positive natural number.
+ max = 256
+
+ # interval between new table compression advertisements.
+ # this means the time during which we collect heavy-hitter data and then turn it into a compression table.
+ advertisement-interval = 1 minute
+ }
+ manifests {
+ # Max number of compressed manifests
+ # Note that compression tables are "rolling" (i.e. a new table replaces the old
+ # compression table once in a while), and this setting is only about the total number
+ # of compressions within a single such table.
+ # Must be a positive natural number.
+ max = 256
+
+ # interval between new table compression advertisements.
+ # this means the time during which we collect heavy-hitter data and then turn it into a compression table.
+ advertisement-interval = 1 minute
+ }
+ }
+
+ # List of fully qualified class names of remote instruments which should
+ # be initialized and used for monitoring of remote messages.
+ # The class must extend akka.remote.artery.RemoteInstrument and
+ # have a public constructor with empty parameters or one ExtendedActorSystem
+ # parameter.
+ # A new instance of RemoteInstrument will be created for each encoder and decoder.
+ # It's only called from the stage, so if it dosn't delegate to any shared instance
+ # it doesn't have to be thread-safe.
+ # Refer to `akka.remote.artery.RemoteInstrument` for more information.
+ instruments = ${?akka.remote.artery.advanced.instruments} []
+
+ }
+
+ # SSL configuration that is used when transport=tls-tcp.
+ ssl {
+ # Factory of SSLEngine.
+ # Must implement akka.remote.artery.tcp.SSLEngineProvider and have a public
+ # constructor with an ActorSystem parameter.
+ # The default ConfigSSLEngineProvider is configured by properties in section
+ # akka.remote.artery.ssl.config-ssl-engine
+ ssl-engine-provider = akka.remote.artery.tcp.ConfigSSLEngineProvider
+
+ # Config of akka.remote.artery.tcp.ConfigSSLEngineProvider
+ config-ssl-engine {
+
+ # This is the Java Key Store used by the server connection
+ key-store = "keystore"
+
+ # This password is used for decrypting the key store
+ # Use substitution from environment variables for passwords. Don't define
+ # real passwords in config files. key-store-password=${SSL_KEY_STORE_PASSWORD}
+ key-store-password = "changeme"
+
+ # This password is used for decrypting the key
+ # Use substitution from environment variables for passwords. Don't define
+ # real passwords in config files. key-password=${SSL_KEY_PASSWORD}
+ 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
+ # Use substitution from environment variables for passwords. Don't define
+ # real passwords in config files. trust-store-password=${SSL_TRUST_STORE_PASSWORD}
+ 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 two options, and the default SecureRandom is recommended:
+ # "" or "SecureRandom" => (default)
+ # "SHA1PRNG" => Can be slow because of blocking issues on Linux
+ #
+ # Setting a value here may require you to supply the appropriate cipher
+ # suite (see enabled-algorithms section above)
+ random-number-generator = ""
+
+ # Require mutual authentication between TLS peers
+ #
+ # Without mutual authentication only the peer that actively establishes a connection (TLS client side)
+ # checks if the passive side (TLS server side) sends over a trusted certificate. With the flag turned on,
+ # the passive side will also request and verify a certificate from the connecting peer.
+ #
+ # To prevent man-in-the-middle attacks this setting is enabled by default.
+ require-mutual-authentication = on
+
+ # Set this to `on` to verify hostnames with sun.security.util.HostnameChecker
+ hostname-verification = off
+ }
+
+ }
+ }
+ }
+
+}
+#//#artery
--- /dev/null
+#####################################
+# Akka Stream Reference Config File #
+#####################################
+
+akka {
+ stream {
+
+ # Default materializer settings
+ materializer {
+
+ # Initial size of buffers used in stream elements
+ initial-input-buffer-size = 4
+ # Maximum size of buffers used in stream elements
+ max-input-buffer-size = 16
+
+ # Fully qualified config path which holds the dispatcher configuration
+ # to be used by ActorMaterializer when creating Actors.
+ # When this value is left empty, the default-dispatcher will be used.
+ dispatcher = ""
+
+ blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher"
+
+ # Cleanup leaked publishers and subscribers when they are not used within a given
+ # deadline
+ subscription-timeout {
+ # when the subscription timeout is reached one of the following strategies on
+ # the "stale" publisher:
+ # cancel - cancel it (via `onError` or subscribing to the publisher and
+ # `cancel()`ing the subscription right away
+ # warn - log a warning statement about the stale element (then drop the
+ # reference to it)
+ # noop - do nothing (not recommended)
+ mode = cancel
+
+ # time after which a subscriber / publisher is considered stale and eligible
+ # for cancelation (see `akka.stream.subscription-timeout.mode`)
+ timeout = 5s
+ }
+
+ # Enable additional troubleshooting logging at DEBUG log level
+ debug-logging = off
+
+ # Maximum number of elements emitted in batch if downstream signals large demand
+ output-burst-limit = 1000
+
+ # Enable automatic fusing of all graphs that are run. For short-lived streams
+ # this may cause an initial runtime overhead, but most of the time fusing is
+ # desirable since it reduces the number of Actors that are created.
+ # Deprecated, since Akka 2.5.0, setting does not have any effect.
+ auto-fusing = on
+
+ # Those stream elements which have explicit buffers (like mapAsync, mapAsyncUnordered,
+ # buffer, flatMapMerge, Source.actorRef, Source.queue, etc.) will preallocate a fixed
+ # buffer upon stream materialization if the requested buffer size is less than this
+ # configuration parameter. The default is very high because failing early is better
+ # than failing under load.
+ #
+ # Buffers sized larger than this will dynamically grow/shrink and consume more memory
+ # per element than the fixed size buffers.
+ max-fixed-buffer-size = 1000000000
+
+ # Maximum number of sync messages that actor can process for stream to substream communication.
+ # Parameter allows to interrupt synchronous processing to get upstream/downstream messages.
+ # Allows to accelerate message processing that happening within same actor but keep system responsive.
+ sync-processing-limit = 1000
+
+ debug {
+ # Enables the fuzzing mode which increases the chance of race conditions
+ # by aggressively reordering events and making certain operations more
+ # concurrent than usual.
+ # This setting is for testing purposes, NEVER enable this in a production
+ # environment!
+ # To get the best results, try combining this setting with a throughput
+ # of 1 on the corresponding dispatchers.
+ fuzzing-mode = off
+ }
+
+ io.tcp {
+ # The outgoing bytes are accumulated in a buffer while waiting for acknoledgment
+ # of pending write. This improves throughput for small messages (frames) without
+ # sacrificing latency. While waiting for the ack the stage will eagerly pull
+ # from upstream until the buffer exceeds this size. That means that the buffer may hold
+ # slightly more bytes than this limit (at most one element more). It can be set to 0
+ # to disable the usage of the buffer.
+ write-buffer-size = 16 KiB
+ }
+
+ //#stream-ref
+ # configure defaults for SourceRef and SinkRef
+ stream-ref {
+ # Buffer of a SinkRef that is used to batch Request elements from the other side of the stream ref
+ #
+ # The buffer will be attempted to be filled eagerly even while the local stage did not request elements,
+ # because the delay of requesting over network boundaries is much higher.
+ buffer-capacity = 32
+
+ # Demand is signalled by sending a cumulative demand message ("requesting messages until the n-th sequence number)
+ # Using a cumulative demand model allows us to re-deliver the demand message in case of message loss (which should
+ # be very rare in any case, yet possible -- mostly under connection break-down and re-establishment).
+ #
+ # The semantics of handling and updating the demand however are in-line with what Reactive Streams dictates.
+ #
+ # In normal operation, demand is signalled in response to arriving elements, however if no new elements arrive
+ # within `demand-redelivery-interval` a re-delivery of the demand will be triggered, assuming that it may have gotten lost.
+ demand-redelivery-interval = 1 second
+
+ # Subscription timeout, during which the "remote side" MUST subscribe (materialize) the handed out stream ref.
+ # This timeout does not have to be very low in normal situations, since the remote side may also need to
+ # prepare things before it is ready to materialize the reference. However the timeout is needed to avoid leaking
+ # in-active streams which are never subscribed to.
+ subscription-timeout = 30 seconds
+
+ # In order to guard the receiving end of a stream ref from never terminating (since awaiting a Completion or Failed
+ # message) after / before a Terminated is seen, a special timeout is applied once Terminated is received by it.
+ # This allows us to terminate stream refs that have been targeted to other nodes which are Downed, and as such the
+ # other side of the stream ref would never send the "final" terminal message.
+ #
+ # The timeout specifically means the time between the Terminated signal being received and when the local SourceRef
+ # determines to fail itself, assuming there was message loss or a complete partition of the completion signal.
+ final-termination-signal-deadline = 2 seconds
+ }
+ //#stream-ref
+ }
+
+ # Deprecated, use akka.stream.materializer.blocking-io-dispatcher, this setting
+ # was never applied because of bug #24357
+ # It must still have a valid value because used from Akka HTTP.
+ blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher"
+
+ default-blocking-io-dispatcher {
+ type = "Dispatcher"
+ executor = "thread-pool-executor"
+ throughput = 1
+
+ thread-pool-executor {
+ fixed-pool-size = 16
+ }
+ }
+
+ }
+
+ # configure overrides to ssl-configuration here (to be used by akka-streams, and akka-http – i.e. when serving https connections)
+ ssl-config {
+ protocol = "TLSv1.2"
+ }
+
+ actor {
+
+ serializers {
+ akka-stream-ref = "akka.stream.serialization.StreamRefSerializer"
+ }
+
+ serialization-bindings {
+ "akka.stream.SinkRef" = akka-stream-ref
+ "akka.stream.SourceRef" = akka-stream-ref
+ "akka.stream.impl.streamref.StreamRefsProtocol" = akka-stream-ref
+ }
+
+ serialization-identifiers {
+ "akka.stream.serialization.StreamRefSerializer" = 30
+ }
+ }
+}
+
+# ssl configuration
+# folded in from former ssl-config-akka module
+ssl-config {
+ logger = "com.typesafe.sslconfig.akka.util.AkkaLoggerBridge"
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.odlparent</groupId>
+ <artifactId>bundle-parent</artifactId>
+ <version>7.0.6</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>repackaged-akka</artifactId>
+ <packaging>bundle</packaging>
+ <version>3.0.0-SNAPSHOT</version>
+ <name>${project.artifactId}</name>
+
+ <properties>
+ <!-- We are just juggling classes here -->
+ <odlparent.modernizer.skip>true</odlparent.modernizer.skip>
+ <odlparent.spotbugs.skip>true</odlparent.spotbugs.skip>
+
+ <!-- We do not want to generate javadoc -->
+ <maven.javadoc.skip>true</maven.javadoc.skip>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>repackaged-akka-jar</artifactId>
+ <version>${project.version}</version>
+ <scope>provided</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>com.typesafe</groupId>
+ <artifactId>config</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>com.typesafe</groupId>
+ <artifactId>ssl-config-core_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>io.aeron</groupId>
+ <artifactId>aeron-client</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>io.aeron</groupId>
+ <artifactId>aeron-driver</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>io.netty</groupId>
+ <artifactId>netty</artifactId>
+ <version>3.10.6.Final</version>
+ </dependency>
+ <dependency>
+ <groupId>org.agrona</groupId>
+ <artifactId>agrona</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.reactivestreams</groupId>
+ <artifactId>reactive-streams</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.scala-lang</groupId>
+ <artifactId>scala-library</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.scala-lang</groupId>
+ <artifactId>scala-reflect</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.scala-lang.modules</groupId>
+ <artifactId>scala-java8-compat_2.13</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.scala-lang.modules</groupId>
+ <artifactId>scala-parser-combinators_2.13</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>unpack-license</id>
+ <configuration>
+ <!-- Akka is Apache-2.0 licensed -->
+ <skip>true</skip>
+ </configuration>
+ </execution>
+ <execution>
+ <id>unpack</id>
+ <phase>compile</phase>
+ <goals>
+ <goal>unpack</goal>
+ </goals>
+ <configuration>
+ <artifactItems>
+ <artifactItem>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>repackaged-akka-jar</artifactId>
+ <version>${project.version}</version>
+ </artifactItem>
+ </artifactItems>
+ <overWriteReleases>false</overWriteReleases>
+ <overWriteSnapshots>true</overWriteSnapshots>
+ <outputDirectory>${project.build.directory}/classes</outputDirectory>
+ </configuration>
+ </execution>
+ <execution>
+ <id>unpack-sources</id>
+ <phase>prepare-package</phase>
+ <goals>
+ <goal>unpack-dependencies</goal>
+ </goals>
+ <configuration>
+ <classifier>sources</classifier>
+ <includeArtifactIds>repackaged-akka-jar</includeArtifactIds>
+ <outputDirectory>${project.build.directory}/shaded-sources</outputDirectory>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <artifactId>maven-antrun-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>move-resources</id>
+ <phase>prepare-package</phase>
+ <goals>
+ <goal>run</goal>
+ </goals>
+ <configuration>
+ <target>
+ <move todir="${project.build.directory}/resources">
+ <fileset dir="${project.build.directory}/classes">
+ <include name="*.conf"/>
+ </fileset>
+ </move>
+ </target>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>build-helper-maven-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>shaded-sources</id>
+ <phase>prepare-package</phase>
+ <goals>
+ <goal>add-source</goal>
+ </goals>
+ <configuration>
+ <sources>${project.build.directory}/shaded-sources</sources>
+ </configuration>
+ </execution>
+ <execution>
+ <id>shaded-resources</id>
+ <phase>prepare-package</phase>
+ <goals>
+ <goal>add-resource</goal>
+ </goals>
+ <configuration>
+ <resources>
+ <resource>
+ <directory>${project.build.directory}/resources</directory>
+ </resource>
+ </resources>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Export-Package>
+ akka.*,
+ com.typesafe.sslconfig.akka.*,
+ </Export-Package>
+ <Import-Package>
+ sun.misc;resolution:=optional,
+ sun.reflect;resolution:=optional,
+ org.fusesource.leveldbjni;resolution:=optional,
+ org.iq80.leveldb;resolution:=optional,
+ org.iq80.leveldb.impl;resolution:=optional,
+ *
+ </Import-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
<dependencyManagement>
<dependencies>
+ <!-- Repackaged Akka -->
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>repackaged-akka</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+
<!-- Core API/implementation -->
<dependency>
<groupId>${project.groupId}</groupId>
<classifier>features</classifier>
<type>xml</type>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>odl-controller-akka</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>odl-controller-scala</artifactId>
</dependencyManagement>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-controller-akka</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
<dependency>
<groupId>org.opendaylight.controller</groupId>
<artifactId>odl-controller-scala</artifactId>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright © 2020 PANTHEON.tech, s.r.o. and others. All rights reserved.
+
+ This program and the accompanying materials are made available under the
+ terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ and is available at http://www.eclipse.org/legal/epl-v10.html
+ -->
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>single-feature-parent</artifactId>
+ <version>3.0.0-SNAPSHOT</version>
+ <relativePath>../single-feature-parent</relativePath>
+ </parent>
+
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-controller-akka</artifactId>
+ <packaging>feature</packaging>
+
+ <name>Akka Runtime for OpenDaylight</name>
+
+ <properties>
+ <checkDependencyChange>true</checkDependencyChange>
+ <failOnDependencyChange>true</failOnDependencyChange>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>odl-controller-scala</artifactId>
+ <type>xml</type>
+ <classifier>features</classifier>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>repackaged-akka</artifactId>
+ </dependency>
+ </dependencies>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-controller-akka">
+ <feature version="0.0.0">
+ <feature>odl-controller-scala</feature>
+ <bundle>mvn:com.typesafe/config/1.3.3</bundle>
+ <bundle>mvn:com.typesafe/ssl-config-core_2.13/0.3.8</bundle>
+ <bundle>mvn:io.aeron/aeron-client/1.15.3</bundle>
+ <bundle>mvn:io.aeron/aeron-driver/1.15.3</bundle>
+ <bundle>mvn:io.netty/netty/3.10.6.Final</bundle>
+ <bundle>mvn:org.agrona/agrona/0.9.33</bundle>
+ <bundle>mvn:org.opendaylight.controller/repackaged-akka/3.0.0-SNAPSHOT</bundle>
+ <bundle>mvn:org.reactivestreams/reactive-streams/1.0.3</bundle>
+ </feature>
+</features>
<groupId>org.scala-lang.modules</groupId>
<artifactId>scala-java8-compat_2.13</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.scala-lang.modules</groupId>
+ <artifactId>scala-parser-combinators_2.13</artifactId>
+ </dependency>
</dependencies>
</project>
<features xmlns="http://karaf.apache.org/xmlns/features/v1.6.0" name="odl-controller-scala">
<feature version="0.0.0">
<bundle>mvn:org.scala-lang.modules/scala-java8-compat_2.13/0.9.1</bundle>
+ <bundle>mvn:org.scala-lang.modules/scala-parser-combinators_2.13/1.1.2</bundle>
<bundle>mvn:org.scala-lang/scala-library/2.13.3</bundle>
<bundle>mvn:org.scala-lang/scala-reflect/2.13.3</bundle>
</feature>
<module>odl-clustering-test-app</module>
<module>odl-mdsal-benchmark</module>
- <!-- Scala feature -->
+ <!-- Scala/Akka features -->
<module>odl-controller-scala</module>
+ <module>odl-controller-akka</module>
<!-- Single features, to be cleaned up -->
<module>odl-controller-blueprint</module>
<modules>
<module>artifacts</module>
+ <module>akka</module>
<!-- md-sal -->
<module>opendaylight/md-sal</module>
Code Review / controller.git / commitdiff