Add Akka packaging 80/92880/9
authorRobert Varga <robert.varga@pantheon.tech>
Fri, 2 Oct 2020 17:15:26 +0000 (19:15 +0200)
committerRobert Varga <robert.varga@pantheon.tech>
Wed, 7 Oct 2020 09:46:36 +0000 (11:46 +0200)
This adds an independent packaging of akka as a single uber-bundle,
so that split packages and missing OSGi headers are not a concern.

This duplicates odlparent packaging to an extent, but does not
switchover.

JIRA: CONTROLLER-1959
Change-Id: I48f33b348b63ca0ac48f21573e55e06719900eb0
Signed-off-by: Robert Varga <robert.varga@pantheon.tech>
18 files changed:
akka/pom.xml [new file with mode: 0644]
akka/repackaged-akka-jar/pom.xml [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/LICENSE [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/actor_reference.conf [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/reference.conf [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/remote_reference.conf [new file with mode: 0644]
akka/repackaged-akka-jar/src/main/resources/stream_reference.conf [new file with mode: 0644]
akka/repackaged-akka/pom.xml [new file with mode: 0644]
artifacts/pom.xml
features/features-controller/pom.xml
features/odl-controller-akka/pom.xml [new file with mode: 0644]
features/odl-controller-akka/src/main/history/dependencies.xml [new file with mode: 0644]
features/odl-controller-scala/pom.xml
features/odl-controller-scala/src/main/history/dependencies.xml
features/pom.xml
pom.xml

diff --git a/akka/pom.xml b/akka/pom.xml
new file mode 100644 (file)
index 0000000..d0461fa
--- /dev/null
@@ -0,0 +1,32 @@
+<?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>
diff --git a/akka/repackaged-akka-jar/pom.xml b/akka/repackaged-akka-jar/pom.xml
new file mode 100644 (file)
index 0000000..e0edc6a
--- /dev/null
@@ -0,0 +1,114 @@
+<?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>
diff --git a/akka/repackaged-akka-jar/src/main/resources/LICENSE b/akka/repackaged-akka-jar/src/main/resources/LICENSE
new file mode 100644 (file)
index 0000000..c7d5a56
--- /dev/null
@@ -0,0 +1,212 @@
+                                 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
diff --git a/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf b/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf
new file mode 100644 (file)
index 0000000..56256f9
--- /dev/null
@@ -0,0 +1,1278 @@
+####################################
+# 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
+  }
+
+}
diff --git a/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf b/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf
new file mode 100644 (file)
index 0000000..c384d6e
--- /dev/null
@@ -0,0 +1,378 @@
+######################################
+# 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
+    }
+    
+  }
+
+}
diff --git a/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf b/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf
new file mode 100644 (file)
index 0000000..25e6299
--- /dev/null
@@ -0,0 +1,328 @@
+###########################################################
+# 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>
diff --git a/akka/repackaged-akka-jar/src/main/resources/reference.conf b/akka/repackaged-akka-jar/src/main/resources/reference.conf
new file mode 100644 (file)
index 0000000..e096415
--- /dev/null
@@ -0,0 +1,5 @@
+include "actor_reference.conf"
+include "cluster_reference.conf"
+include "persistence_reference.conf"
+include "remote_reference.conf"
+include "stream_reference.conf"
diff --git a/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf b/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf
new file mode 100644 (file)
index 0000000..8d7ef60
--- /dev/null
@@ -0,0 +1,1193 @@
+#//#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
diff --git a/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf b/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf
new file mode 100644 (file)
index 0000000..a29e83a
--- /dev/null
@@ -0,0 +1,169 @@
+#####################################
+# 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"
+}
diff --git a/akka/repackaged-akka/pom.xml b/akka/repackaged-akka/pom.xml
new file mode 100644 (file)
index 0000000..92e09e4
--- /dev/null
@@ -0,0 +1,209 @@
+<?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>
index c5f7bc4..4d41bb0 100644 (file)
 
     <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>
index 178d0e6..b849f9a 100644 (file)
     </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>
diff --git a/features/odl-controller-akka/pom.xml b/features/odl-controller-akka/pom.xml
new file mode 100644 (file)
index 0000000..af6614f
--- /dev/null
@@ -0,0 +1,44 @@
+<?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>
diff --git a/features/odl-controller-akka/src/main/history/dependencies.xml b/features/odl-controller-akka/src/main/history/dependencies.xml
new file mode 100644 (file)
index 0000000..2a88165
--- /dev/null
@@ -0,0 +1,14 @@
+<?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>
index 1c474fe..18b8697 100644 (file)
@@ -42,5 +42,9 @@
             <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>
index 9f991cb..d0f6835 100644 (file)
@@ -2,6 +2,7 @@
 <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>
index bd87aab..a132713 100644 (file)
@@ -42,8 +42,9 @@
     <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>
diff --git a/pom.xml b/pom.xml
index b19b187..5521ae0 100644 (file)
--- a/pom.xml
+++ b/pom.xml
@@ -22,6 +22,7 @@
 
   <modules>
     <module>artifacts</module>
+    <module>akka</module>
 
     <!-- md-sal -->
     <module>opendaylight/md-sal</module>

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