From c355a5b632433b9d2a54107d24e644e68610f270 Mon Sep 17 00:00:00 2001 From: Robert Varga Date: Fri, 2 Oct 2020 19:15:26 +0200 Subject: [PATCH] Add Akka packaging 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 --- akka/pom.xml | 32 + akka/repackaged-akka-jar/pom.xml | 114 ++ .../src/main/resources/LICENSE | 212 +++ .../src/main/resources/actor_reference.conf | 1278 +++++++++++++++++ .../src/main/resources/cluster_reference.conf | 378 +++++ .../main/resources/persistence_reference.conf | 328 +++++ .../src/main/resources/reference.conf | 5 + .../src/main/resources/remote_reference.conf | 1193 +++++++++++++++ .../src/main/resources/stream_reference.conf | 169 +++ akka/repackaged-akka/pom.xml | 209 +++ artifacts/pom.xml | 14 + features/features-controller/pom.xml | 6 + features/odl-controller-akka/pom.xml | 44 + .../src/main/history/dependencies.xml | 14 + features/odl-controller-scala/pom.xml | 4 + .../src/main/history/dependencies.xml | 1 + features/pom.xml | 3 +- pom.xml | 1 + 18 files changed, 4004 insertions(+), 1 deletion(-) create mode 100644 akka/pom.xml create mode 100644 akka/repackaged-akka-jar/pom.xml create mode 100644 akka/repackaged-akka-jar/src/main/resources/LICENSE create mode 100644 akka/repackaged-akka-jar/src/main/resources/actor_reference.conf create mode 100644 akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf create mode 100644 akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf create mode 100644 akka/repackaged-akka-jar/src/main/resources/reference.conf create mode 100644 akka/repackaged-akka-jar/src/main/resources/remote_reference.conf create mode 100644 akka/repackaged-akka-jar/src/main/resources/stream_reference.conf create mode 100644 akka/repackaged-akka/pom.xml create mode 100644 features/odl-controller-akka/pom.xml create mode 100644 features/odl-controller-akka/src/main/history/dependencies.xml diff --git a/akka/pom.xml b/akka/pom.xml new file mode 100644 index 0000000000..d0461fa946 --- /dev/null +++ b/akka/pom.xml @@ -0,0 +1,32 @@ + + + + 4.0.0 + + org.opendaylight.odlparent + odlparent-lite + 7.0.6 + + + + org.opendaylight.controller + akka-aggregator + 3.0.0-SNAPSHOT + pom + + + true + true + + + + repackaged-akka-jar + repackaged-akka + + diff --git a/akka/repackaged-akka-jar/pom.xml b/akka/repackaged-akka-jar/pom.xml new file mode 100644 index 0000000000..e0edc6a51a --- /dev/null +++ b/akka/repackaged-akka-jar/pom.xml @@ -0,0 +1,114 @@ + + + + + 4.0.0 + + + org.opendaylight.odlparent + odlparent + 7.0.6 + + + + org.opendaylight.controller + repackaged-akka-jar + jar + 3.0.0-SNAPSHOT + ${project.artifactId} + + + + true + + + + + + com.typesafe.akka + akka-actor_2.13 + + + com.typesafe.akka + akka-cluster_2.13 + + + com.typesafe.akka + akka-osgi_2.13 + + + com.typesafe.akka + akka-persistence_2.13 + + + com.typesafe.akka + akka-protobuf_2.13 + + + com.typesafe.akka + akka-remote_2.13 + + + com.typesafe.akka + akka-slf4j_2.13 + + + com.typesafe.akka + akka-stream_2.13 + + + + + + + maven-dependency-plugin + + + unpack-license + + + true + + + + + + maven-shade-plugin + + + package + + shade + + + false + true + true + true + + + com.typesafe.akka + + + + + com.typesafe.akka:* + + META-INF/MANIFEST.MF + reference.conf + + + + + + + + + + diff --git a/akka/repackaged-akka-jar/src/main/resources/LICENSE b/akka/repackaged-akka-jar/src/main/resources/LICENSE new file mode 100644 index 0000000000..c7d5a563cc --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/LICENSE @@ -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 index 0000000000..56256f9aca --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf @@ -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 index 0000000000..c384d6e1ea --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf @@ -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 + #.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 index 0000000000..25e629903d --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf @@ -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: +# +# org.iq80.leveldb +# leveldb +# 0.7 +# +# +# org.fusesource.leveldbjni +# leveldbjni-all +# 1.8 +# 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 index 0000000000..e096415d61 --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/reference.conf @@ -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 index 0000000000..8d7ef60d57 --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf @@ -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 "" 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: + # "" InetAddress.getLocalHost.getHostAddress + # "" InetAddress.getLocalHost.getHostName + # + hostname = "" + } + + # 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 + # "" InetAddress.getLocalHost.getHostAddress + # "" 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 index 0000000000..a29e83a9f7 --- /dev/null +++ b/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf @@ -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 index 0000000000..92e09e4f94 --- /dev/null +++ b/akka/repackaged-akka/pom.xml @@ -0,0 +1,209 @@ + + + + + 4.0.0 + + + org.opendaylight.odlparent + bundle-parent + 7.0.6 + + + + org.opendaylight.controller + repackaged-akka + bundle + 3.0.0-SNAPSHOT + ${project.artifactId} + + + + true + true + + + true + + + + + org.opendaylight.controller + repackaged-akka-jar + ${project.version} + provided + + + + com.typesafe + config + + + com.typesafe + ssl-config-core_2.13 + + + io.aeron + aeron-client + + + io.aeron + aeron-driver + + + io.netty + netty + 3.10.6.Final + + + org.agrona + agrona + + + org.reactivestreams + reactive-streams + + + org.scala-lang + scala-library + + + org.scala-lang + scala-reflect + + + org.scala-lang.modules + scala-java8-compat_2.13 + + + org.scala-lang.modules + scala-parser-combinators_2.13 + + + + + + + maven-dependency-plugin + + + unpack-license + + + true + + + + unpack + compile + + unpack + + + + + org.opendaylight.controller + repackaged-akka-jar + ${project.version} + + + false + true + ${project.build.directory}/classes + + + + unpack-sources + prepare-package + + unpack-dependencies + + + sources + repackaged-akka-jar + ${project.build.directory}/shaded-sources + + + + + + maven-antrun-plugin + + + move-resources + prepare-package + + run + + + + + + + + + + + + + + + org.codehaus.mojo + build-helper-maven-plugin + + + shaded-sources + prepare-package + + add-source + + + ${project.build.directory}/shaded-sources + + + + shaded-resources + prepare-package + + add-resource + + + + + ${project.build.directory}/resources + + + + + + + + org.apache.felix + maven-bundle-plugin + true + + + + akka.*, + com.typesafe.sslconfig.akka.*, + + + sun.misc;resolution:=optional, + sun.reflect;resolution:=optional, + org.fusesource.leveldbjni;resolution:=optional, + org.iq80.leveldb;resolution:=optional, + org.iq80.leveldb.impl;resolution:=optional, + * + + + + + + + diff --git a/artifacts/pom.xml b/artifacts/pom.xml index c5f7bc4e61..4d41bb08af 100644 --- a/artifacts/pom.xml +++ b/artifacts/pom.xml @@ -25,6 +25,13 @@ + + + ${project.groupId} + repackaged-akka + ${project.version} + + ${project.groupId} @@ -278,6 +285,13 @@ features xml + + ${project.groupId} + odl-controller-akka + ${project.version} + xml + features + ${project.groupId} odl-controller-scala diff --git a/features/features-controller/pom.xml b/features/features-controller/pom.xml index 178d0e6b18..b849f9afae 100644 --- a/features/features-controller/pom.xml +++ b/features/features-controller/pom.xml @@ -35,6 +35,12 @@ + + org.opendaylight.controller + odl-controller-akka + xml + features + org.opendaylight.controller odl-controller-scala diff --git a/features/odl-controller-akka/pom.xml b/features/odl-controller-akka/pom.xml new file mode 100644 index 0000000000..af6614f7d4 --- /dev/null +++ b/features/odl-controller-akka/pom.xml @@ -0,0 +1,44 @@ + + + + 4.0.0 + + + org.opendaylight.controller + single-feature-parent + 3.0.0-SNAPSHOT + ../single-feature-parent + + + org.opendaylight.controller + odl-controller-akka + feature + + Akka Runtime for OpenDaylight + + + true + true + + + + + org.opendaylight.controller + odl-controller-scala + xml + features + + + org.opendaylight.controller + repackaged-akka + + + 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 index 0000000000..2a88165f42 --- /dev/null +++ b/features/odl-controller-akka/src/main/history/dependencies.xml @@ -0,0 +1,14 @@ + + + + odl-controller-scala + mvn:com.typesafe/config/1.3.3 + mvn:com.typesafe/ssl-config-core_2.13/0.3.8 + mvn:io.aeron/aeron-client/1.15.3 + mvn:io.aeron/aeron-driver/1.15.3 + mvn:io.netty/netty/3.10.6.Final + mvn:org.agrona/agrona/0.9.33 + mvn:org.opendaylight.controller/repackaged-akka/3.0.0-SNAPSHOT + mvn:org.reactivestreams/reactive-streams/1.0.3 + + diff --git a/features/odl-controller-scala/pom.xml b/features/odl-controller-scala/pom.xml index 1c474fea62..18b86974c6 100644 --- a/features/odl-controller-scala/pom.xml +++ b/features/odl-controller-scala/pom.xml @@ -42,5 +42,9 @@ org.scala-lang.modules scala-java8-compat_2.13 + + org.scala-lang.modules + scala-parser-combinators_2.13 + diff --git a/features/odl-controller-scala/src/main/history/dependencies.xml b/features/odl-controller-scala/src/main/history/dependencies.xml index 9f991cb9c0..d0f6835c72 100644 --- a/features/odl-controller-scala/src/main/history/dependencies.xml +++ b/features/odl-controller-scala/src/main/history/dependencies.xml @@ -2,6 +2,7 @@ mvn:org.scala-lang.modules/scala-java8-compat_2.13/0.9.1 + mvn:org.scala-lang.modules/scala-parser-combinators_2.13/1.1.2 mvn:org.scala-lang/scala-library/2.13.3 mvn:org.scala-lang/scala-reflect/2.13.3 diff --git a/features/pom.xml b/features/pom.xml index bd87aab4f4..a132713f46 100644 --- a/features/pom.xml +++ b/features/pom.xml @@ -42,8 +42,9 @@ odl-clustering-test-app odl-mdsal-benchmark - + odl-controller-scala + odl-controller-akka odl-controller-blueprint diff --git a/pom.xml b/pom.xml index b19b1874ba..5521ae09b8 100644 --- a/pom.xml +++ b/pom.xml @@ -22,6 +22,7 @@ artifacts + akka opendaylight/md-sal -- 2.36.6