From: tadei.bilan Date: Tue, 6 Oct 2020 14:32:36 +0000 (+0200) Subject: Bump akka to 2.6.12 X-Git-Tag: v3.0.6~1 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=e66df4e9ae44728c178147fe2462b7138d74810a Bump akka to 2.6.12 Release notes: https://akka.io/blog/news/2019/11/06/akka-2.6.0-released https://akka.io/blog/news/2019/12/06/akka-2.6.1-released https://akka.io/blog/news/2020/01/27/akka-2.6.2-released https://akka.io/blog/news/2020/01/28/akka-2.6.3-released https://akka.io/blog/news/2020/03/13/akka-2.6.4-released https://akka.io/blog/news/2020/04/30/akka-2.6.5-released https://akka.io/blog/news/2020/06/08/akka-2.6.6-released-split-brain-resolver https://akka.io/blog/news/2020/07/10/akka-2.6.7-released https://akka.io/blog/news/2020/07/16/akka-2.6.8-released https://akka.io/blog/news/2020/09/09/akka-2.6.9-released https://akka.io/blog/news/2020/10/09/akka-2.6.10-released https://akka.io/blog/news/2021/01/15/akka-2.6.11-released https://akka.io/blog/news/2021/01/28/akka-2.6.12-released JIRA: CONTROLLER-1962 Change-Id: Ibbfc11a8ca27a8c09337bf49de910c38a9239886 Signed-off-by: tadei.bilan Signed-off-by: Robert Varga Signed-off-by: Oleksii Mozghovyi --- diff --git a/akka/repackaged-akka-jar/pom.xml b/akka/repackaged-akka-jar/pom.xml index 71433b1442..b549ff7b79 100644 --- a/akka/repackaged-akka-jar/pom.xml +++ b/akka/repackaged-akka-jar/pom.xml @@ -33,42 +33,42 @@ com.typesafe.akka akka-actor_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-cluster_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-osgi_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-persistence_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-protobuf_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-remote_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-slf4j_2.13 - 2.5.31 + 2.6.12 com.typesafe.akka akka-stream_2.13 - 2.5.31 + 2.6.12 diff --git a/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf b/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf index 56256f9aca..ee30ba86e1 100644 --- a/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf +++ b/akka/repackaged-akka-jar/src/main/resources/actor_reference.conf @@ -47,7 +47,8 @@ akka { # 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. + # Log at info level when messages are sent to dead letters, or published to + # eventStream as `DeadLetter`, `Dropped` or `UnhandledMessage`. # Possible values: # on: all dead letters are logged # off: no logging of dead letters @@ -57,7 +58,12 @@ akka { # 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 + log-dead-letters-during-shutdown = off + + # When log-dead-letters is enabled, this will re-enable the logging after configured duration. + # infinite: suspend the logging forever; + # or a duration (eg: 5 minutes), after which the logging will be re-enabled. + log-dead-letters-suspend-duration = 5 minutes # List FQCN of extensions which shall be loaded at actor system startup. # Library extensions are regular extensions that are loaded at startup and are @@ -67,7 +73,7 @@ akka { # # 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"] + 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. @@ -89,6 +95,18 @@ akka { # terminate the ActorSystem itself, with or without using CoordinatedShutdown. jvm-shutdown-hooks = on + # Version must be the same across all modules and if they are different the startup + # will fail. It's possible but not recommended, to disable this check, and only log a warning, + # by setting this property to `off`. + fail-mixed-versions = on + + # Some modules (remoting only right now) can emit custom events to the Java Flight Recorder if running + # on JDK 11 or later. If you for some reason do not want that, it can be disabled and switched to no-ops + # with this toggle. + java-flight-recorder { + enabled = true + } + actor { # Either one of "local", "remote" or "cluster" or the @@ -102,29 +120,32 @@ akka { # In addition to the default there is akka.actor.StoppingSupervisorStrategy. guardian-supervisor-strategy = "akka.actor.DefaultSupervisorStrategy" - # Timeout for ActorSystem.actorOf + # Timeout for Extension creation and a few other potentially blocking + # initialization tasks. 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 + # If serialize-messages or serialize-creators are enabled classes that starts with + # a prefix listed here are not verified. + no-serialization-verification-needed-class-prefix = ["akka."] + # 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 + # TypedActor deprecated since 2.6.0. typed { - # Default timeout for typed actor methods with non-void return type + # Default timeout for the deprecated TypedActor (not the new actor APIs in 2.6) + # methods with non-void return type. timeout = 5s } @@ -297,7 +318,7 @@ akka { # exploration will be +- 5 explore-step-size = 0.1 - # Probability of doing an exploration v.s. optmization. + # Probability of doing an exploration v.s. optimization. chance-of-exploration = 0.4 # When downsizing after a long streak of underutilization, the resizer @@ -443,7 +464,7 @@ akka { } # This will be used if you have set "executor = "fork-join-executor"" - # Underlying thread pool implementation is akka.dispatch.forkjoin.ForkJoinPool + # Underlying thread pool implementation is java.util.concurrent.ForkJoinPool fork-join-executor { # Min number of threads to cap factor-based parallelism number to parallelism-min = 8 @@ -451,7 +472,7 @@ akka { # 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 + parallelism-factor = 1.0 # Max number of threads to cap factor-based parallelism number to parallelism-max = 64 @@ -533,6 +554,20 @@ akka { mailbox-requirement = "" } + # Default separate internal dispatcher to run Akka internal tasks and actors on + # protecting them against starvation because of accidental blocking in user actors (which run on the + # default dispatcher) + internal-dispatcher { + type = "Dispatcher" + executor = "fork-join-executor" + throughput = 5 + fork-join-executor { + parallelism-min = 4 + parallelism-factor = 1.0 + parallelism-max = 64 + } + } + default-blocking-io-dispatcher { type = "Dispatcher" executor = "thread-pool-executor" @@ -678,7 +713,6 @@ akka { # # 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 @@ -691,14 +725,28 @@ akka { # # 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 + # Log warnings when the Java serialization is used to serialize messages. + # Java serialization is not very performant and should not be used in production + # environments unless you don't care about performance and security. 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 noise. + warn-on-no-serialization-verification = on + # Entries for pluggable serializers and their bindings. serializers { java = "akka.serialization.JavaSerializer" bytes = "akka.serialization.ByteArraySerializer" - + primitive-long = "akka.serialization.LongSerializer" + primitive-int = "akka.serialization.IntSerializer" + primitive-string = "akka.serialization.StringSerializer" + primitive-bytestring = "akka.serialization.ByteStringSerializer" primitive-boolean = "akka.serialization.BooleanSerializer" } @@ -713,38 +761,18 @@ akka { "[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 { + "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.lang.Boolean" = primitive-boolean + "scala.Boolean" = primitive-boolean } - # 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` @@ -754,33 +782,32 @@ akka { 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 + primitive-long = 18 + primitive-int = 19 + primitive-string = 20 + primitive-bytestring = 21 + primitive-boolean = 35 } } 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. + # deprecated, use `allowed-classes` instead whitelist-class = [ "com.google.protobuf.GeneratedMessage", "com.google.protobuf.GeneratedMessageV3", "scalapb.GeneratedMessageCompanion", - "akka.protobuf.GeneratedMessage" + "akka.protobuf.GeneratedMessage", + "akka.protobufv3.internal.GeneratedMessageV3" ] + + # 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. + allowed-classes = ${akka.serialization.protobuf.whitelist-class} + } # Used to set the behavior of the scheduler. @@ -887,11 +914,11 @@ akka { # Fully qualified config path which holds the dispatcher configuration # for the read/write worker actors - worker-dispatcher = "akka.actor.default-dispatcher" + worker-dispatcher = "akka.actor.internal-dispatcher" # Fully qualified config path which holds the dispatcher configuration # for the selector management actors - management-dispatcher = "akka.actor.default-dispatcher" + management-dispatcher = "akka.actor.internal-dispatcher" # Fully qualified config path which holds the dispatcher configuration # on which file IO tasks are scheduled @@ -969,11 +996,11 @@ akka { # Fully qualified config path which holds the dispatcher configuration # for the read/write worker actors - worker-dispatcher = "akka.actor.default-dispatcher" + worker-dispatcher = "akka.actor.internal-dispatcher" # Fully qualified config path which holds the dispatcher configuration # for the selector management actors - management-dispatcher = "akka.actor.default-dispatcher" + management-dispatcher = "akka.actor.internal-dispatcher" } udp-connected { @@ -1025,18 +1052,18 @@ akka { # Fully qualified config path which holds the dispatcher configuration # for the read/write worker actors - worker-dispatcher = "akka.actor.default-dispatcher" + worker-dispatcher = "akka.actor.internal-dispatcher" # Fully qualified config path which holds the dispatcher configuration # for the selector management actors - management-dispatcher = "akka.actor.default-dispatcher" + management-dispatcher = "akka.actor.internal-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" + dispatcher = "akka.actor.internal-dispatcher" # Name of the subconfig at path akka.io.dns, see inet-address below # @@ -1151,6 +1178,11 @@ akka { # This property is related to `akka.jvm-shutdown-hooks` above. run-by-jvm-shutdown-hook = on + # Run the coordinated shutdown when ActorSystem.terminate is called. + # Enabling this and disabling terminate-actor-system is not a supported + # combination (will throw ConfigurationException at startup). + run-by-actor-system-terminate = 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 diff --git a/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf b/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf index c384d6e1ea..723f91effc 100644 --- a/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf +++ b/akka/repackaged-akka-jar/src/main/resources/cluster_reference.conf @@ -11,7 +11,7 @@ akka { # 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" + # "akka://system@hostname:port" # Leave as empty if the node is supposed to be joined manually. seed-nodes = [] @@ -35,33 +35,21 @@ akka { # 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. + # + # When using the `akka.cluster.sbr.SplitBrainResolver` as downing provider it will use + # the akka.cluster.split-brain-resolver.stable-after as the default down-removal-margin + # if this down-removal-margin is undefined. 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 this setting is left empty the `NoDowning` provider is used and no automatic downing will be performed. # # 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` @@ -75,10 +63,9 @@ akka { # 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. + # move `Joining` members to 'WeaklyUp' after this configured duration without convergence. # The leader will move 'WeaklyUp' members to 'Up' status once convergence has been reached. - allow-weakly-up-members = on + allow-weakly-up-members = 7s # 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 @@ -105,17 +92,36 @@ akka { #.min-nr-of-members = 1 } + # Application version of the deployment. Used by rolling update features + # to distinguish between old and new nodes. The typical convention is to use + # 3 digit version numbers `major.minor.patch`, but 1 or two digits are also + # supported. + # + # If no `.` is used it is interpreted as a single digit version number or as + # plain alphanumeric if it couldn't be parsed as a number. + # + # It may also have a qualifier at the end for 2 or 3 digit version numbers such + # as "1.2-RC1". + # For 1 digit with qualifier, 1-RC1, it is interpreted as plain alphanumeric. + # + # It has support for https://github.com/dwijnand/sbt-dynver format with `+` or + # `-` separator. The number of commits from the tag is handled as a numeric part. + # For example `1.0.0+3-73475dce26` is less than `1.0.10+10-ed316bd024` (3 < 10). + app-version = "0.0.0" + # 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 + # Enable/disable info level logging of cluster events. + # These are logged with logger name `akka.cluster.Cluster`. log-info = on # Enable/disable verbose info-level logging of cluster events # for temporary troubleshooting. Defaults to 'off'. + # These are logged with logger name `akka.cluster.Cluster`. log-info-verbose = off # Enable or disable JMX MBeans for management of the cluster @@ -148,10 +154,9 @@ akka { # Disable with "off". publish-stats-interval = off - # The id of the dispatcher to use for cluster actors. If not specified - # default dispatcher is used. + # The id of the dispatcher to use for cluster actors. # If specified you need to define the settings of the actual dispatcher. - use-dispatcher = "" + use-dispatcher = "akka.actor.internal-dispatcher" # Gossip to random node with newer or older state information, if any with # this probability. Otherwise Gossip to any random live node. @@ -210,7 +215,7 @@ akka { # 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 + monitored-by-nr-of-members = 9 # After the heartbeat request has been sent the first failure detection # will start after this period, even though no heartbeat message has @@ -277,7 +282,8 @@ akka { } debug { - # log heartbeat events (very verbose, useful mostly when debugging heartbeating issues) + # Log heartbeat events (very verbose, useful mostly when debugging heartbeating issues). + # These are logged with logger name `akka.cluster.ClusterHeartbeat`. verbose-heartbeat-logging = off # log verbose details about gossip @@ -289,7 +295,7 @@ akka { # 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. + # error messages 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 @@ -316,6 +322,8 @@ akka { "user.home", "user.name", "user.dir", "socksNonProxyHosts", "http.nonProxyHosts", "ftp.nonProxyHosts", "akka.remote.secure-cookie", + "akka.remote.classic.netty.ssl.security", + # Pre 2.6 path, keep around to avoid sending things misconfigured with old paths "akka.remote.netty.ssl.security", "akka.remote.artery.ssl" ] @@ -376,3 +384,114 @@ akka { } } + +#//#split-brain-resolver + +# To enable the split brain resolver you first need to enable the provider in your application.conf: +# akka.cluster.downing-provider-class = "akka.cluster.sbr.SplitBrainResolverProvider" + +akka.cluster.split-brain-resolver { + # Select one of the available strategies (see descriptions below): + # static-quorum, keep-majority, keep-oldest, down-all, lease-majority + active-strategy = keep-majority + + #//#stable-after + # 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. + # Decision is taken by the strategy when there has been no membership or + # reachability changes for this duration, i.e. the cluster state is stable. + stable-after = 20s + #//#stable-after + + # When reachability observations by the failure detector are changed the SBR decisions + # are deferred until there are no changes within the 'stable-after' duration. + # If this continues for too long it might be an indication of an unstable system/network + # and it could result in delayed or conflicting decisions on separate sides of a network + # partition. + # As a precaution for that scenario all nodes are downed if no decision is made within + # `stable-after + down-all-when-unstable` from the first unreachability event. + # The measurement is reset if all unreachable have been healed, downed or removed, or + # if there are no changes within `stable-after * 2`. + # The value can be on, off, or a duration. + # By default it is 'on' and then it is derived to be 3/4 of stable-after, but not less than + # 4 seconds. + down-all-when-unstable = on + +} +#//#split-brain-resolver + +# Down the unreachable nodes if the number of remaining nodes are greater than or equal to +# the given 'quorum-size'. Otherwise down the reachable nodes, i.e. it will shut down that +# side of the partition. In other words, the 'size' defines the minimum number of nodes +# that the cluster must have to be operational. If there are unreachable nodes when starting +# up the cluster, before reaching this limit, the cluster may shutdown itself immediately. +# This is not an issue if you start all nodes at approximately the same time. +# +# Note that you must not add more members to the cluster than 'quorum-size * 2 - 1', because +# then both sides may down each other and thereby form two separate clusters. For example, +# quorum-size configured to 3 in a 6 node cluster may result in a split where each side +# consists of 3 nodes each, i.e. each side thinks it has enough nodes to continue by +# itself. A warning is logged if this recommendation is violated. +#//#static-quorum +akka.cluster.split-brain-resolver.static-quorum { + # minimum number of nodes that the cluster must have + quorum-size = undefined + + # if the 'role' is defined the decision is based only on members with that 'role' + role = "" +} +#//#static-quorum + +# Down the unreachable nodes if the current node is in the majority part based the last known +# membership information. Otherwise down the reachable nodes, i.e. the own part. If the +# the parts are of equal size the part containing the node with the lowest address is kept. +# Note that if there are more than two partitions and none is in majority each part +# will shutdown itself, terminating the whole cluster. +#//#keep-majority +akka.cluster.split-brain-resolver.keep-majority { + # if the 'role' is defined the decision is based only on members with that 'role' + role = "" +} +#//#keep-majority + +# Down the part that does not contain the oldest member (current singleton). +# +# There is one exception to this rule if 'down-if-alone' is defined to 'on'. +# Then, if the oldest node has partitioned from all other nodes the oldest +# will down itself and keep all other nodes running. The strategy will not +# down the single oldest node when it is the only remaining node in the cluster. +# +# Note that if the oldest node crashes the others will remove it from the cluster +# when 'down-if-alone' is 'on', otherwise they will down themselves if the +# oldest node crashes, i.e. shutdown the whole cluster together with the oldest node. +#//#keep-oldest +akka.cluster.split-brain-resolver.keep-oldest { + # Enable downing of the oldest node when it is partitioned from all other nodes + down-if-alone = on + + # if the 'role' is defined the decision is based only on members with that 'role', + # i.e. using the oldest member (singleton) within the nodes with that role + role = "" +} +#//#keep-oldest + +# Keep the part that can acquire the lease, and down the other part. +# Best effort is to keep the side that has most nodes, i.e. the majority side. +# This is achieved by adding a delay before trying to acquire the lease on the +# minority side. +#//#lease-majority +akka.cluster.split-brain-resolver.lease-majority { + lease-implementation = "" + + # This delay is used on the minority side before trying to acquire the lease, + # as an best effort to try to keep the majority side. + acquire-lease-delay-for-minority = 2s + + # If the 'role' is defined the majority/minority is based only on members with that 'role'. + role = "" +} +#//#lease-majority diff --git a/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf b/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf index 25e629903d..2e4c22d4de 100644 --- a/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf +++ b/akka/repackaged-akka-jar/src/main/resources/persistence_reference.conf @@ -207,6 +207,9 @@ akka.persistence.journal.inmem { class = "akka.persistence.journal.inmem.InmemJournal" # Dispatcher for the plugin actor. plugin-dispatcher = "akka.actor.default-dispatcher" + + # Turn this on to test serialization of the events + test-serialization = off } # Local file system snapshot store plugin. diff --git a/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf b/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf index 8d7ef60d57..4e465e31fe 100644 --- a/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf +++ b/akka/repackaged-akka-jar/src/main/resources/remote_reference.conf @@ -22,10 +22,6 @@ akka { 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" } @@ -39,37 +35,27 @@ akka { # Since akka.protobuf.Message does not extend Serializable but # GeneratedMessage does, need to use the more specific one here in order # to avoid ambiguity. + # This is only loaded if akka-protobuf is on the classpath + # It should not be used and users should migrate to using the protobuf classes + # directly + # Remove in 2.7 "akka.protobuf.GeneratedMessage" = proto + "akka.protobufv3.internal.GeneratedMessageV3" = 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 + "com.google.protobuf.GeneratedMessageV3" = 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 + "java.util.Optional" = akka-misc "akka.actor.Status$Success" = akka-misc "akka.actor.Status$Failure" = akka-misc "akka.actor.ActorRef" = akka-misc @@ -77,37 +63,18 @@ akka { "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 + "akka.Done" = akka-misc + "akka.NotUsed" = akka-misc + "akka.actor.Address" = akka-misc + "akka.remote.UniqueAddress" = akka-misc - # 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.ActorInitializationException" = akka-misc "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 + "java.util.concurrent.TimeoutException" = akka-misc + "akka.remote.serialization.ThrowableNotSerializableException" = akka-misc "akka.actor.LocalScope$" = akka-misc "akka.remote.RemoteScope" = akka-misc @@ -130,14 +97,25 @@ akka { "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 + "akka.pattern.StatusReply" = akka-misc + + "akka.dispatch.sysmsg.SystemMessage" = akka-system-msg + + # Java Serializer is by default used for exceptions and will by default + # not be allowed to be serialized, but in certain cases they are replaced + # by `akka.remote.serialization.ThrowableNotSerializableException` if + # no specific serializer has been defined: + # - when wrapped in `akka.actor.Status.Failure` for ask replies + # - when wrapped in system messages for exceptions from remote deployed child actors + # + # It's recommended that you implement custom serializer for exceptions that are + # sent remotely, You can add binding to akka-misc (MiscMessageSerializer) 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 } serialization-identifiers { @@ -146,11 +124,17 @@ akka { "akka.remote.serialization.MessageContainerSerializer" = 6 "akka.remote.serialization.MiscMessageSerializer" = 16 "akka.remote.serialization.ArteryMessageSerializer" = 17 + + "akka.remote.serialization.SystemMessageSerializer" = 22 + + # deprecated in 2.6.0, moved to akka-actor "akka.remote.serialization.LongSerializer" = 18 + # deprecated in 2.6.0, moved to akka-actor "akka.remote.serialization.IntSerializer" = 19 + # deprecated in 2.6.0, moved to akka-actor "akka.remote.serialization.StringSerializer" = 20 + # deprecated in 2.6.0, moved to akka-actor "akka.remote.serialization.ByteStringSerializer" = 21 - "akka.remote.serialization.SystemMessageSerializer" = 22 } deployment { @@ -158,14 +142,14 @@ akka { 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" + # deployed at that node e.g. "akka://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: + # The format should be on "akka://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 @@ -183,37 +167,20 @@ akka { 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 { + # Using remoting directly is typically not desirable, so a warning will + # be shown to make this clear. Set this setting to 'off' to suppress that + # warning. + warn-about-direct-use = on - # 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 + # If Cluster is not used, remote watch and deployment are disabled. + # To optionally use them while not using Cluster, set to 'on'. + use-unsafe-remote-features-outside-cluster = off - # 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 - } + # A warning will be logged on remote watch attempts if Cluster + # is not in use and 'use-unsafe-remote-features-outside-cluster' + # is 'off'. Set this to 'off' to suppress these. + warn-unsafe-watch-outside-cluster = on # 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. @@ -269,22 +236,76 @@ akka { # remote deployment configuration section deployment { - # If true, will only allow specific classes to be instanciated on this system via remote deployment + # deprecated, use `enable-allow-list` enable-whitelist = off + # If true, will only allow specific classes listed in `allowed-actor-classes` to be instanciated on this + # system via remote deployment + enable-allow-list = ${akka.remote.deployment.enable-whitelist} + + + # deprecated, use `allowed-actor-classes` whitelist = [] + + allowed-actor-classes = ${akka.remote.deployment.whitelist} } -#//#shared + + ### 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 + } + #//#shared } } akka { - remote { -#//#classic + remote.classic { + #//#classic + + ### Configuration for classic remoting. Classic remoting is deprecated, use artery. + + + # 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 + } - ### 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 @@ -313,7 +334,7 @@ akka { 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 + # If the transport is akka.remote.classic.netty.tcp or akka.remote.classic.netty.ssl # the configured connection-timeout for the transport will be used instead. handshake-timeout = 15 s @@ -325,20 +346,11 @@ akka { 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 + # Actors with paths defined in this 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, @@ -453,7 +465,7 @@ akka { # 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"] + enabled-transports = ["akka.remote.classic.netty.tcp"] # Transport drivers can be augmented with adapters by adding their # name to the applied-adapters setting in the configuration of a @@ -483,8 +495,6 @@ akka { # 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. @@ -499,38 +509,38 @@ akka { # 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 + # akka.remote.classic.netty.tcp.port = 2552 + # akka.remote.classic.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 + # akka.remote.classic.netty.tcp.port = 0 + # akka.remote.classic.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 + # akka.remote.classic.netty.tcp.port = 2552 + # akka.remote.classic.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 + # akka.remote.classic.netty.tcp.port = 0 + # akka.remote.classic.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 = "" + # akka.remote.classic.netty.tcp.port = 2552 + # akka.remote.classic.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 + # akka.remote.classic.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 + # akka.remote.classic.netty.tcp.hostname if empty bind-hostname = "" # Enables SSL support on this transport @@ -621,15 +631,7 @@ akka { } - # 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 = ${akka.remote.classic.netty.tcp} netty.ssl = { # Enable SSL/TLS encryption. # This must be enabled on both the client and server to work. @@ -639,7 +641,7 @@ akka { # 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 + # akka.remote.classic.netty.ssl.security # # The SSLEngineProvider can also be defined via ActorSystemSetup with # SSLEngineProviderSetup when starting the ActorSystem. That is useful when @@ -664,17 +666,21 @@ akka { # 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 to use for SSL encryption. 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. + # Example: ["TLS_DHE_RSA_WITH_AES_128_GCM_SHA256", + # "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", + # "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", + # "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"] + # When doing rolling upgrades, make sure to include both the algorithm used + # by old nodes and the preferred algorithm. + # If you use a JDK 8 prior to 8u161 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"] + # https://www.oracle.com/java/technologies/javase-jce-all-downloads.html + enabled-algorithms = ["TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", + "TLS_RSA_WITH_AES_128_CBC_SHA"] # There are two options, and the default SecureRandom is recommended: # "" or "SecureRandom" => (default) @@ -714,19 +720,6 @@ akka { 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" @@ -740,32 +733,22 @@ akka { } #//#classic +#//#artery akka { remote { - #//#artery ### Configuration for Artery, the new implementation of remoting artery { - # Enable the new remoting with this flag + # Disable artery 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. + # See https://doc.akka.io/docs/akka/current/remoting-artery.html#selecting-a-transport for the tradeoffs + # for each transport transport = aeron-udp # Canonical address is the address other clients should connect to. @@ -812,9 +795,6 @@ akka { 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 @@ -837,7 +817,7 @@ akka { 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 + # Actors with paths defined in this list are granted permission to receive actor # selections messages. # E.g. trusted-selection-paths = ["/user/receptionist", "/user/namingService"] trusted-selection-paths = [] @@ -850,6 +830,14 @@ akka { # if off then they are not logged log-sent-messages = off + # 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 + advanced { # Maximum serialized message size, including header data. @@ -884,42 +872,16 @@ akka { # 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. + # Remoting will use the given dispatcher for the ordinary and large message + # streams. 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. + # Remoting will use the given dispatcher for the control stream. # 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 + use-control-stream-dispatcher = "akka.actor.internal-dispatcher" + # Total number of inbound lanes, shared among all inbound associations. A value # greater than 1 means that deserialization can be performed in parallel for @@ -970,9 +932,7 @@ akka { # 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 @@ -987,9 +947,6 @@ akka { # 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 @@ -1033,6 +990,12 @@ akka { # remote messages has been completed shutdown-flush-timeout = 1 second + # Before sending notificaiton of terminated actor (DeathWatchNotification) other messages + # will be flushed to make sure that the Terminated message arrives after other messages. + # It will wait this long for the flush acknowledgement before continuing. + # The flushing can be disabled by setting this to `off`. + death-watch-notification-flush-timeout = 3 seconds + # See 'inbound-max-restarts' inbound-restart-timeout = 5 seconds @@ -1051,32 +1014,6 @@ akka { # 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 { @@ -1085,7 +1022,7 @@ akka { # 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. + # Must be a positive natural number. Can be disabled with "off". max = 256 # interval between new table compression advertisements. @@ -1097,7 +1034,7 @@ akka { # 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. + # Must be a positive natural number. Can be disabled with "off". max = 256 # interval between new table compression advertisements. @@ -1117,6 +1054,72 @@ akka { # Refer to `akka.remote.artery.RemoteInstrument` for more information. instruments = ${?akka.remote.artery.advanced.instruments} [] + # Only used when transport is aeron-udp + aeron { + # 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 + + # 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 + + # 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 + + # 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 + + # Timout after after which an uncommitted publication will be unblocked + # Only used when transport is aeron-udp. + publication-unblock-timeout = 40 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 + } + + # Only used when transport is tcp or tls-tcp. + tcp { + # Timeout of establishing outbound connections. + connection-timeout = 5 seconds + + # The local address that is used for the client side of the TCP connection. + outbound-client-hostname = "" + } + } # SSL configuration that is used when transport=tls-tcp. @@ -1152,17 +1155,21 @@ akka { # 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 to use for SSL encryption. 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. + # Example: ["TLS_DHE_RSA_WITH_AES_128_GCM_SHA256", + # "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", + # "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", + # "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"] + # When doing rolling upgrades, make sure to include both the algorithm used + # by old nodes and the preferred algorithm. + # If you use a JDK 8 prior to 8u161 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"] + # https://www.oracle.com/java/technologies/javase-jce-all-downloads.html + enabled-algorithms = ["TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", + "TLS_RSA_WITH_AES_128_CBC_SHA"] # There are two options, and the default SecureRandom is recommended: # "" or "SecureRandom" => (default) @@ -1182,9 +1189,67 @@ akka { require-mutual-authentication = on # Set this to `on` to verify hostnames with sun.security.util.HostnameChecker + # If possible it is recommended to have this enabled. Hostname verification is designed for + # situations where things locate each other by hostname, in scenarios where host names are dynamic + # and not known up front it can make sense to have this disabled. hostname-verification = off } + # Config of akka.remote.artery.tcp.ssl.RotatingKeysSSLEngineProvider + # This engine provider reads PEM files from a mount point shared with the secret + # manager. The constructed SSLContext is cached some time (configurable) so when + # the credentials rotate the new credentials are eventually picked up. + # By default mTLS is enabled. + # This provider also includes a verification phase that runs after the TLS handshake + # phase. In this verification, both peers run an authorization and verify they are + # part of the same akka cluster. The verification happens via comparing the subject + # names in the peer's certificate with the name on the own certificate so if you + # use this SSLEngineProvider you should make sure all nodes on the cluster include + # at least one common subject name (CN or SAN). + # The Key setup this implementation supports has some limitations: + # 1. the private key must be provided on a PKCS#1 or a non-encrypted PKCS#8 PEM-formatted file + # 2. the private key must be be of an algorythm supported by `akka-pki` tools (e.g. "RSA", not "EC") + # 3. the node certificate must be issued by a root CA (not an intermediate CA) + # 4. both the node and the CA certificates must be provided in PEM-formatted files + rotating-keys-engine { + + # This is a convention that people may follow if they wish to save themselves some configuration + secret-mount-point = /var/run/secrets/akka-tls/rotating-keys-engine + + # The absolute path the PEM file with the private key. + key-file = ${akka.remote.artery.ssl.rotating-keys-engine.secret-mount-point}/tls.key + # The absolute path to the PEM file of the certificate for the private key above. + cert-file = ${akka.remote.artery.ssl.rotating-keys-engine.secret-mount-point}/tls.crt + # The absolute path to the PEM file of the certificate of the CA that emited + # the node certificate above. + ca-cert-file = ${akka.remote.artery.ssl.rotating-keys-engine.secret-mount-point}/ca.crt + + # 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) + random-number-generator = "" + + # Example: ["TLS_DHE_RSA_WITH_AES_128_GCM_SHA256", + # "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256", + # "TLS_DHE_RSA_WITH_AES_256_GCM_SHA384", + # "TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"] + # If you use a JDK 8 prior to 8u161 you need to install + # the JCE Unlimited Strength Jurisdiction Policy Files to use AES 256. + # More info here: + # https://www.oracle.com/java/technologies/javase-jce-all-downloads.html + enabled-algorithms = ["TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384"] + + # Protocol to use for SSL encryption. + protocol = "TLSv1.2" + + # How long should an SSLContext instance be cached. When rotating keys and certificates, + # there must a time overlap between the old certificate/key and the new ones. The + # value of this setting should be lower than duration of that overlap. + ssl-context-cache-ttl = 5m + } } } } diff --git a/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf b/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf index a29e83a9f7..dd982714a1 100644 --- a/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf +++ b/akka/repackaged-akka-jar/src/main/resources/stream_reference.conf @@ -2,6 +2,8 @@ # Akka Stream Reference Config File # ##################################### +# eager creation of the system wide materializer +akka.library-extensions += "akka.stream.SystemMaterializer$" akka { stream { @@ -14,11 +16,13 @@ akka { 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 = "" + # or full dispatcher configuration to be used by ActorMaterializer when creating Actors. + dispatcher = "akka.actor.default-dispatcher" - blocking-io-dispatcher = "akka.stream.default-blocking-io-dispatcher" + # Fully qualified config path which holds the dispatcher configuration + # or full dispatcher configuration to be used by stream operators that + # perform blocking operations + blocking-io-dispatcher = "akka.actor.default-blocking-io-dispatcher" # Cleanup leaked publishers and subscribers when they are not used within a given # deadline @@ -76,7 +80,7 @@ akka { } io.tcp { - # The outgoing bytes are accumulated in a buffer while waiting for acknoledgment + # The outgoing bytes are accumulated in a buffer while waiting for acknowledgment # 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 @@ -85,6 +89,9 @@ akka { write-buffer-size = 16 KiB } + # Time to wait for async materializer creation before throwing an exception + creation-timeout = 20 seconds + //#stream-ref # configure defaults for SourceRef and SinkRef stream-ref { @@ -122,21 +129,12 @@ akka { //#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 - } - } + # Deprecated, left here to not break Akka HTTP which refers to it + blocking-io-dispatcher = "akka.actor.default-blocking-io-dispatcher" + # Deprecated, will not be used unless user code refer to it, use 'akka.stream.materializer.blocking-io-dispatcher' + # instead, or if from code, prefer the 'ActorAttributes.IODispatcher' attribute + default-blocking-io-dispatcher = "akka.actor.default-blocking-io-dispatcher" } # configure overrides to ssl-configuration here (to be used by akka-streams, and akka-http – i.e. when serving https connections) diff --git a/akka/repackaged-akka/pom.xml b/akka/repackaged-akka/pom.xml index bb11440b42..10617cf64f 100644 --- a/akka/repackaged-akka/pom.xml +++ b/akka/repackaged-akka/pom.xml @@ -110,6 +110,11 @@ repackaged-akka-jar ${project.version} + + com.hierynomus + asn-one + 0.4.0 + false true @@ -190,6 +195,7 @@ akka.*, com.typesafe.sslconfig.akka.*, + jdk.jfr, sun.misc;resolution:=optional, diff --git a/bundle-parent/pom.xml b/bundle-parent/pom.xml index ce314daa81..8015b6befe 100644 --- a/bundle-parent/pom.xml +++ b/bundle-parent/pom.xml @@ -51,25 +51,31 @@ scala-parser-combinators_2.13 1.1.2 + + org.scalatestplus + junit-4-13_2.13 + 3.1.4.0 + test + com.typesafe config - 1.3.3 + 1.4.0 com.typesafe ssl-config-core_2.13 - 0.3.8 + 0.4.2 com.typesafe.akka akka-testkit_2.13 - 2.5.31 + 2.6.12 test @@ -81,7 +87,7 @@ com.typesafe.akka akka-persistence-tck_2.13 - 2.5.31 + 2.6.12 test @@ -102,17 +108,17 @@ org.agrona agrona - 0.9.33 + 1.8.0 io.aeron aeron-client - 1.15.3 + 1.31.1 io.aeron aeron-driver - 1.15.3 + 1.31.1 diff --git a/docs/pom.xml b/docs/pom.xml index 5955ff4bd1..69eb0c7752 100644 --- a/docs/pom.xml +++ b/docs/pom.xml @@ -243,7 +243,7 @@ http://google.github.io/truth/api/1.0.1/ http://www.slf4j.org/apidocs/ https://google.github.io/guava/releases/29.0-jre/api/docs/ - http://doc.akka.io/japi/akka/2.5.31/ + http://doc.akka.io/japi/akka/2.6.12/ http://netty.io/4.1/api/ https://commons.apache.org/proper/commons-lang/javadocs/api-2.6/ https://commons.apache.org/proper/commons-lang/javadocs/api-3.9/ diff --git a/features/odl-controller-akka/src/main/history/dependencies.xml b/features/odl-controller-akka/src/main/history/dependencies.xml index 1b4670eb5a..eec1a763ba 100644 --- a/features/odl-controller-akka/src/main/history/dependencies.xml +++ b/features/odl-controller-akka/src/main/history/dependencies.xml @@ -2,12 +2,12 @@ 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:com.typesafe/config/1.4.0 + mvn:com.typesafe/ssl-config-core_2.13/0.4.2 + mvn:io.aeron/aeron-client/1.31.1 + mvn:io.aeron/aeron-driver/1.31.1 mvn:io.netty/netty/3.10.6.Final - mvn:org.agrona/agrona/0.9.33 + mvn:org.agrona/agrona/1.8.0 mvn:org.opendaylight.controller/repackaged-akka/${project.version} mvn:org.reactivestreams/reactive-streams/1.0.3 diff --git a/features/odl-mdsal-distributed-datastore/src/main/feature/feature.xml b/features/odl-mdsal-distributed-datastore/src/main/feature/feature.xml index 9f67ce24ee..9d1375b55f 100644 --- a/features/odl-mdsal-distributed-datastore/src/main/feature/feature.xml +++ b/features/odl-mdsal-distributed-datastore/src/main/feature/feature.xml @@ -29,4 +29,4 @@ mvn:org.opendaylight.controller/sal-clustering-config/${project.version}/cfg/datastore - + \ No newline at end of file diff --git a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/InMemoryJournal.java b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/InMemoryJournal.java index f3d4bc6b2a..a9eea07387 100644 --- a/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/InMemoryJournal.java +++ b/opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/InMemoryJournal.java @@ -27,6 +27,7 @@ import java.util.function.Consumer; import org.apache.commons.lang.SerializationUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import scala.Option; import scala.concurrent.Future; import scala.jdk.javaapi.CollectionConverters; @@ -169,7 +170,7 @@ public class InMemoryJournal extends AsyncWriteJournal { if (++count <= max && entry.getKey() >= fromSequenceNr && entry.getKey() <= toSequenceNr) { PersistentRepr persistentMessage = new PersistentImpl(deserialize(entry.getValue()), entry.getKey(), persistenceId, - null, false, null, null, 0); + null, false, null, null, 0, Option.empty()); replayCallback.accept(persistentMessage); } } diff --git a/opendaylight/md-sal/sal-akka-segmented-journal/pom.xml b/opendaylight/md-sal/sal-akka-segmented-journal/pom.xml index afb8ff9c6d..b04a443079 100644 --- a/opendaylight/md-sal/sal-akka-segmented-journal/pom.xml +++ b/opendaylight/md-sal/sal-akka-segmented-journal/pom.xml @@ -106,6 +106,11 @@ and is available at http://www.eclipse.org/legal/epl-v10.html commons-io test + + org.scalatestplus + junit-4-13_2.13 + test + diff --git a/opendaylight/md-sal/sal-clustering-commons/pom.xml b/opendaylight/md-sal/sal-clustering-commons/pom.xml index e15742a562..186a20f663 100644 --- a/opendaylight/md-sal/sal-clustering-commons/pom.xml +++ b/opendaylight/md-sal/sal-clustering-commons/pom.xml @@ -63,6 +63,11 @@ com.typesafe.akka akka-persistence-tck_2.13 + + org.scalatestplus + junit-4-13_2.13 + test + diff --git a/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/akka.conf b/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/akka.conf index 88443c00b3..79ac7b3d61 100644 --- a/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/akka.conf +++ b/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/akka.conf @@ -7,7 +7,7 @@ odl-cluster-data { canonical.hostname = "127.0.0.1" canonical.port = 2550 } - netty.tcp { + classic.netty.tcp { hostname = "127.0.0.1" port = 2550 } diff --git a/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/factory-akka.conf b/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/factory-akka.conf index 3296e0574c..97f8cce642 100644 --- a/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/factory-akka.conf +++ b/opendaylight/md-sal/sal-clustering-config/src/main/resources/initial/factory-akka.conf @@ -90,7 +90,7 @@ odl-cluster-data { # with read-only associations use-passive-connections = off - netty.tcp { + classic.netty.tcp { maximum-frame-size = 419430400 send-buffer-size = 52428800 receive-buffer-size = 52428800 @@ -113,8 +113,6 @@ odl-cluster-data { # This is crucial for correct behavior if you use Cluster Singleton or Cluster Sharding, # especially together with Akka Persistence. - #auto-down-unreachable-after = 30s - allow-weakly-up-members = on use-dispatcher = cluster-dispatcher diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreRemotingIntegrationTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreRemotingIntegrationTest.java index fbc7fa2ae8..7fa19bc95f 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreRemotingIntegrationTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/DistributedDataStoreRemotingIntegrationTest.java @@ -204,9 +204,9 @@ public class DistributedDataStoreRemotingIntegrationTest extends AbstractTest { leaderDistributedDataStore.close(); } - TestKit.shutdownActorSystem(leaderSystem); - TestKit.shutdownActorSystem(followerSystem); - TestKit.shutdownActorSystem(follower2System); + TestKit.shutdownActorSystem(leaderSystem, true); + TestKit.shutdownActorSystem(followerSystem, true); + TestKit.shutdownActorSystem(follower2System,true); InMemoryJournal.clear(); InMemorySnapshotStore.clear(); @@ -1286,10 +1286,11 @@ public class DistributedDataStoreRemotingIntegrationTest extends AbstractTest { followerTestKit.waitForMembersUp("member-1", "member-3"); follower2TestKit.waitForMembersUp("member-1", "member-2"); - TestKit.shutdownActorSystem(follower2System); + // behavior is controlled by akka.coordinated-shutdown.run-by-actor-system-terminate configuration option + TestKit.shutdownActorSystem(follower2System, true); ActorRef cars = leaderDistributedDataStore.getActorUtils().findLocalShard("cars").get(); - OnDemandRaftState initialState = (OnDemandRaftState) leaderDistributedDataStore.getActorUtils() + final OnDemandRaftState initialState = (OnDemandRaftState) leaderDistributedDataStore.getActorUtils() .executeOperation(cars, GetOnDemandRaftState.INSTANCE); Cluster leaderCluster = Cluster.get(leaderSystem); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/MemberNode.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/MemberNode.java index b3fff4c6d7..a7c702c6dc 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/MemberNode.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/MemberNode.java @@ -93,6 +93,7 @@ public class MemberNode { Stopwatch sw = Stopwatch.createStarted(); while (sw.elapsed(TimeUnit.SECONDS) <= 10) { CurrentClusterState state = Cluster.get(kit.getSystem()).state(); + for (Member m : state.getUnreachable()) { if (member.equals(m.getRoles().iterator().next())) { return; diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/RootDataTreeChangeListenerProxyTest.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/RootDataTreeChangeListenerProxyTest.java index 7fea757d39..789e922939 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/RootDataTreeChangeListenerProxyTest.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/RootDataTreeChangeListenerProxyTest.java @@ -14,7 +14,7 @@ import static org.mockito.Mockito.mock; import static org.mockito.Mockito.timeout; import static org.mockito.Mockito.verify; -import akka.actor.ActorRef; +import akka.actor.ActorSelection; import akka.testkit.javadsl.TestKit; import com.google.common.collect.ImmutableList; import java.time.Duration; @@ -77,7 +77,7 @@ public class RootDataTreeChangeListenerProxyTest extends AbstractActorTest { assertEquals(registerForShard1.getListenerActorPath(), registerForShard2.getListenerActorPath()); final TestKit kit2 = new TestKit(getSystem()); - final ActorRef rootListenerActor = getSystem().actorFor(registerForShard1.getListenerActorPath()); + final ActorSelection rootListenerActor = getSystem().actorSelection(registerForShard1.getListenerActorPath()); rootListenerActor.tell(new EnableNotification(true, "test"), kit.getRef()); final DataTreeCandidate peopleCandidate = DataTreeCandidates.fromNormalizedNode(YangInstanceIdentifier.empty(), PeopleModel.create()); diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockClusterWrapper.java b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockClusterWrapper.java index 78028b95bb..e644759256 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockClusterWrapper.java +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/java/org/opendaylight/controller/cluster/datastore/utils/MockClusterWrapper.java @@ -17,6 +17,7 @@ import akka.cluster.ClusterEvent.UnreachableMember; import akka.cluster.Member; import akka.cluster.MemberStatus; import akka.cluster.UniqueAddress; +import akka.util.Version; import org.opendaylight.controller.cluster.access.concepts.MemberName; import org.opendaylight.controller.cluster.datastore.ClusterWrapper; import scala.collection.immutable.Set.Set1; @@ -62,28 +63,28 @@ public class MockClusterWrapper implements ClusterWrapper { public static MemberRemoved createMemberRemoved(final String memberName, final String address) { UniqueAddress uniqueAddress = new UniqueAddress(AddressFromURIString.parse(address), 55L); - Member member = new Member(uniqueAddress, 1, MemberStatus.removed(), new Set1<>(memberName)); + Member member = new Member(uniqueAddress, 1, MemberStatus.removed(), new Set1<>(memberName), Version.Zero()); return new MemberRemoved(member, MemberStatus.up()); } public static MemberUp createMemberUp(final String memberName, final String address) { UniqueAddress uniqueAddress = new UniqueAddress(AddressFromURIString.parse(address), 55L); - Member member = new Member(uniqueAddress, 1, MemberStatus.up(), new Set1<>(memberName)); + Member member = new Member(uniqueAddress, 1, MemberStatus.up(), new Set1<>(memberName), Version.Zero()); return new MemberUp(member); } public static UnreachableMember createUnreachableMember(final String memberName, final String address) { UniqueAddress uniqueAddress = new UniqueAddress(AddressFromURIString.parse(address), 55L); - Member member = new Member(uniqueAddress, 1, MemberStatus.up(), new Set1<>(memberName)); + Member member = new Member(uniqueAddress, 1, MemberStatus.up(), new Set1<>(memberName), Version.Zero()); return new UnreachableMember(member); } public static ReachableMember createReachableMember(final String memberName, final String address) { UniqueAddress uniqueAddress = new UniqueAddress(AddressFromURIString.parse(address), 55L); - Member member = new Member(uniqueAddress, 1, MemberStatus.up(), new Set1<>(memberName)); + Member member = new Member(uniqueAddress, 1, MemberStatus.up(), new Set1<>(memberName), Version.Zero()); return new ReachableMember(member); } diff --git a/opendaylight/md-sal/sal-distributed-datastore/src/test/resources/application.conf b/opendaylight/md-sal/sal-distributed-datastore/src/test/resources/application.conf index 72d00a4cdd..a24085e134 100644 --- a/opendaylight/md-sal/sal-distributed-datastore/src/test/resources/application.conf +++ b/opendaylight/md-sal/sal-distributed-datastore/src/test/resources/application.conf @@ -1,6 +1,7 @@ akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" } @@ -54,6 +55,7 @@ test-config { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -74,11 +76,19 @@ test-config { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2565 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2565 + transport = tcp } netty.tcp { @@ -88,7 +98,6 @@ test-config { } cluster { - auto-down-unreachable-after = 100s retry-unsuccessful-join-after = 100ms roles = [ @@ -123,6 +132,7 @@ Member1 { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -144,11 +154,19 @@ Member1 { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2558 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2558 + transport = tcp } netty.tcp { @@ -192,6 +210,7 @@ Member2 { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -211,11 +230,19 @@ Member2 { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2559 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2559 + transport = tcp } netty.tcp { @@ -259,6 +286,7 @@ Member3 { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -280,11 +308,19 @@ Member3 { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2557 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2557 + transport = tcp } netty.tcp { @@ -328,6 +364,7 @@ Member4 { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -349,11 +386,19 @@ Member4 { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2560 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2560 + transport = tcp } netty.tcp { @@ -397,6 +442,7 @@ Member5 { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -418,11 +464,19 @@ Member5 { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2561 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2561 + transport = tcp } netty.tcp { @@ -466,6 +520,7 @@ Member256 { akka { persistence.snapshot-store.plugin = "in-memory-snapshot-store" persistence.journal.plugin = "in-memory-journal" + coordinated-shutdown.run-by-actor-system-terminate = off persistence.non-persistent.journal { class = "org.opendaylight.controller.cluster.raft.utils.InMemoryJournal" @@ -487,11 +542,19 @@ Member256 { warn-about-java-serializer-usage = false } remote { + classic { + netty.tcp { + hostname = "127.0.0.1" + port = 2562 + } + } + log-remote-lifecycle-events = off artery { enabled = on canonical.hostname = "127.0.0.1" canonical.port = 2562 + transport = tcp } netty.tcp { diff --git a/opendaylight/md-sal/sal-distributed-eos/src/test/java/org/opendaylight/controller/cluster/entityownership/DistributedEntityOwnershipIntegrationTest.java b/opendaylight/md-sal/sal-distributed-eos/src/test/java/org/opendaylight/controller/cluster/entityownership/DistributedEntityOwnershipIntegrationTest.java index a743d6db21..d8eb685435 100644 --- a/opendaylight/md-sal/sal-distributed-eos/src/test/java/org/opendaylight/controller/cluster/entityownership/DistributedEntityOwnershipIntegrationTest.java +++ b/opendaylight/md-sal/sal-distributed-eos/src/test/java/org/opendaylight/controller/cluster/entityownership/DistributedEntityOwnershipIntegrationTest.java @@ -359,27 +359,28 @@ public class DistributedEntityOwnershipIntegrationTest { String name = "testLeaderAndFollowerEntityOwnersReassignedAfterShutdown"; final MemberNode leaderNode = MemberNode.builder(memberNodes).akkaConfig("Member1") .useAkkaArtery(false).testName(name) - .moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) + .moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG) + .schemaContext(EOSTestUtils.SCHEMA_CONTEXT) .createOperDatastore(false).datastoreContextBuilder(leaderDatastoreContextBuilder).build(); final MemberNode follower1Node = MemberNode.builder(memberNodes).akkaConfig("Member2") - .useAkkaArtery(false).testName(name) - .moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) + .testName(name).moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG) + .useAkkaArtery(false).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) .createOperDatastore(false).datastoreContextBuilder(followerDatastoreContextBuilder).build(); final MemberNode follower2Node = MemberNode.builder(memberNodes).akkaConfig("Member3") - .useAkkaArtery(false).testName(name) - .moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) + .testName(name).moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG) + .useAkkaArtery(false).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) .createOperDatastore(false).datastoreContextBuilder(followerDatastoreContextBuilder).build(); final MemberNode follower3Node = MemberNode.builder(memberNodes).akkaConfig("Member4") - .useAkkaArtery(false).testName(name) - .moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) + .testName(name).moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG) + .useAkkaArtery(false).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) .createOperDatastore(false).datastoreContextBuilder(followerDatastoreContextBuilder).build(); final MemberNode follower4Node = MemberNode.builder(memberNodes).akkaConfig("Member5") - .useAkkaArtery(false).testName(name) - .moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) + .testName(name).moduleShardsConfig(MODULE_SHARDS_5_NODE_CONFIG) + .useAkkaArtery(false).schemaContext(EOSTestUtils.SCHEMA_CONTEXT) .createOperDatastore(false).datastoreContextBuilder(followerDatastoreContextBuilder).build(); AbstractDataStore leaderDistributedDataStore = leaderNode.configDataStore(); @@ -452,13 +453,15 @@ public class DistributedEntityOwnershipIntegrationTest { // Shutdown the leader and follower3 leaderNode.cleanup(); - follower3Node.cleanup(); follower1Node.waitForMemberDown("member-1"); - follower1Node.waitForMemberDown("member-4"); follower2Node.waitForMemberDown("member-1"); - follower2Node.waitForMemberDown("member-4"); follower4Node.waitForMemberDown("member-1"); + + follower3Node.cleanup(); + + follower1Node.waitForMemberDown("member-4"); + follower2Node.waitForMemberDown("member-4"); follower4Node.waitForMemberDown("member-4"); // Verify the prior leader's and follower3 entity owners are re-assigned. diff --git a/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-2.conf b/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-2.conf index 28a35ecb4c..76b4857241 100644 --- a/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-2.conf +++ b/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-2.conf @@ -36,8 +36,6 @@ odl-cluster-data { cluster { seed-nodes = ["akka://opendaylight-cluster-data@127.0.0.1:2550", "akka://opendaylight-cluster-data@127.0.0.1:2553"] - auto-down-unreachable-after = 10s - roles = [ "member-2" ] diff --git a/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-3.conf b/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-3.conf index f9afe04278..c425437801 100644 --- a/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-3.conf +++ b/opendaylight/md-sal/sal-dummy-distributed-datastore/src/main/resources/member-3.conf @@ -36,8 +36,6 @@ odl-cluster-data { cluster { seed-nodes = ["akka://opendaylight-cluster-data@127.0.0.1:2550", "akka://opendaylight-cluster-data@127.0.0.1:2554"] - auto-down-unreachable-after = 10s - roles = [ "member-3" ] diff --git a/opendaylight/md-sal/sal-remoterpc-connector/src/test/resources/application.conf b/opendaylight/md-sal/sal-remoterpc-connector/src/test/resources/application.conf index 11ad5eceb7..3324665c59 100644 --- a/opendaylight/md-sal/sal-remoterpc-connector/src/test/resources/application.conf +++ b/opendaylight/md-sal/sal-remoterpc-connector/src/test/resources/application.conf @@ -31,8 +31,6 @@ odl-cluster-rpc { cluster { seed-nodes = ["akka://opendaylight-rpc@127.0.0.1:2550"] - - auto-down-unreachable-after = 10s } } } @@ -94,8 +92,6 @@ memberA { cluster { seed-nodes = ["akka://opendaylight-rpc@127.0.0.1:2551"] - - auto-down-unreachable-after = 10s } } in-memory-journal { @@ -142,8 +138,6 @@ memberB { cluster { seed-nodes = ["akka://opendaylight-rpc@127.0.0.1:2551"] - - auto-down-unreachable-after = 10s } } in-memory-journal { @@ -190,8 +184,6 @@ memberC { cluster { seed-nodes = ["akka://opendaylight-rpc@127.0.0.1:2551"] - - auto-down-unreachable-after = 10s } } in-memory-journal {