raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 11

Merge pull request #26933 from akka/wip-ClusterSingletonProxySpec-patriknw

Browse source 
more classic remoting leftovers
This commit is contained in:
Patrik Nordwall 2019-05-17 11:07:29 +02:00 • committed by GitHub
commit a2658cc8a0
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
73 changed files with 284 additions and 322 deletions
Download patch file Download diff file Expand all files Collapse all files

2
akka-cluster/src/main/resources/reference.conf
View file

@ -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 = []

34
akka-cluster/src/main/scala/akka/cluster/ClusterJmx.scala
View file

@ -24,13 +24,13 @@ trait ClusterNodeMBean {
/**
* Comma separated addresses of member nodes, sorted in the cluster ring order.
* The address format is `akka.tcp://actor-system-name@hostname:port`
* The address format is `akka://actor-system-name@hostname:port`
*/
def getMembers: String
/**
* Comma separated addresses of unreachable member nodes.
* The address format is `akka.tcp://actor-system-name@hostname:port`
* The address format is `akka://actor-system-name@hostname:port`
*/
def getUnreachable: String
@ -38,31 +38,31 @@ trait ClusterNodeMBean {
* JSON format of the status of all nodes in the cluster as follows:
* {{{
* {
* "self-address": "akka.tcp://system@host1:2552",
* "self-address": "akka://system@host1:2552",
* "members": [
* {
* "address": "akka.tcp://system@host1:2552",
* "address": "akka://system@host1:2552",
* "status": "Up",
* "roles": [
* "frontend"
* ]
* },
* {
* "address": "akka.tcp://system@host2:2552",
* "address": "akka://system@host2:2552",
* "status": "Up",
* "roles": [
* "frontend"
* ]
* },
* {
* "address": "akka.tcp://system@host3:2552",
* "address": "akka://system@host3:2552",
* "status": "Down",
* "roles": [
* "backend"
* ]
* },
* {
* "address": "akka.tcp://system@host4:2552",
* "address": "akka://system@host4:2552",
* "status": "Joining",
* "roles": [
* "backend"
@ -71,17 +71,17 @@ trait ClusterNodeMBean {
* ],
* "unreachable": [
* {
* "node": "akka.tcp://system@host2:2552",
* "node": "akka://system@host2:2552",
* "observed-by": [
* "akka.tcp://system@host1:2552",
* "akka.tcp://system@host3:2552"
* "akka://system@host1:2552",
* "akka://system@host3:2552"
* ]
* },
* {
* "node": "akka.tcp://system@host3:2552",
* "node": "akka://system@host3:2552",
* "observed-by": [
* "akka.tcp://system@host1:2552",
* "akka.tcp://system@host2:2552"
* "akka://system@host1:2552",
* "akka://system@host2:2552"
* ]
* }
* ]
@ -92,7 +92,7 @@ trait ClusterNodeMBean {
/**
* Get the address of the current leader.
* The address format is `akka.tcp://actor-system-name@hostname:port`
* The address format is `akka://actor-system-name@hostname:port`
*/
def getLeader: String
@ -109,20 +109,20 @@ trait ClusterNodeMBean {
/**
* Try to join this cluster node with the node specified by 'address'.
* The address format is `akka.tcp://actor-system-name@hostname:port`.
* The address format is `akka://actor-system-name@hostname:port`.
* A 'Join(thisNodeAddress)' command is sent to the node to join.
*/
def join(address: String): Unit
/**
* Send command to issue state transition to LEAVING for the node specified by 'address'.
* The address format is `akka.tcp://actor-system-name@hostname:port`
* The address format is `akka://actor-system-name@hostname:port`
*/
def leave(address: String): Unit
/**
* Send command to DOWN the node specified by 'address'.
* The address format is `akka.tcp://actor-system-name@hostname:port`
* The address format is `akka://actor-system-name@hostname:port`
*/
def down(address: String): Unit
}

2
akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
View file

@ -24,7 +24,7 @@ object NodeChurnMultiJvmSpec extends MultiNodeConfig {
debugConfig(on = false).withFallback(ConfigFactory.parseString("""
akka.cluster.auto-down-unreachable-after = 1s
akka.cluster.prune-gossip-tombstones-after = 1s
akka.remote.log-frame-size-exceeding = 1200b
akka.remote.classic.log-frame-size-exceeding = 1200b
akka.remote.artery.advanced.aeron {
idle-cpu-level = 1
embedded-media-driver = off

2
akka-cluster/src/test/java/akka/cluster/ClusterJavaCompileTest.java
View file

@ -18,7 +18,7 @@ public class ClusterJavaCompileTest {
final Cluster cluster = null;
public void compileJoinSeedNodesInJava() {
final List<Address> addresses = Collections.singletonList(new Address("akka.tcp", "MySystem"));
final List<Address> addresses = Collections.singletonList(new Address("akka", "MySystem"));
cluster.joinSeedNodes(addresses);
}
}

44
akka-cluster/src/test/scala/akka/cluster/ClusterDomainEventSpec.scala
View file

@ -16,25 +16,25 @@ class ClusterDomainEventSpec extends WordSpec with Matchers {
import ClusterEvent._
val aRoles = Set("AA", "AB")
val aJoining = TestMember(Address("akka.tcp", "sys", "a", 2552), Joining, aRoles)
val aUp = TestMember(Address("akka.tcp", "sys", "a", 2552), Up, aRoles)
val aRemoved = TestMember(Address("akka.tcp", "sys", "a", 2552), Removed, aRoles)
val aJoining = TestMember(Address("akka", "sys", "a", 2552), Joining, aRoles)
val aUp = TestMember(Address("akka", "sys", "a", 2552), Up, aRoles)
val aRemoved = TestMember(Address("akka", "sys", "a", 2552), Removed, aRoles)
val bRoles = Set("AB", "BB")
val bUp = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, bRoles)
val bDown = TestMember(Address("akka.tcp", "sys", "b", 2552), Down, bRoles)
val bRemoved = TestMember(Address("akka.tcp", "sys", "b", 2552), Removed, bRoles)
val bUp = TestMember(Address("akka", "sys", "b", 2552), Up, bRoles)
val bDown = TestMember(Address("akka", "sys", "b", 2552), Down, bRoles)
val bRemoved = TestMember(Address("akka", "sys", "b", 2552), Removed, bRoles)
val cRoles = Set.empty[String]
val cUp = TestMember(Address("akka.tcp", "sys", "c", 2552), Up, cRoles)
val cLeaving = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving, cRoles)
val cUp = TestMember(Address("akka", "sys", "c", 2552), Up, cRoles)
val cLeaving = TestMember(Address("akka", "sys", "c", 2552), Leaving, cRoles)
val dRoles = Set("DD", "DE")
val dLeaving = TestMember(Address("akka.tcp", "sys", "d", 2552), Leaving, dRoles)
val dExiting = TestMember(Address("akka.tcp", "sys", "d", 2552), Exiting, dRoles)
val dRemoved = TestMember(Address("akka.tcp", "sys", "d", 2552), Removed, dRoles)
val dLeaving = TestMember(Address("akka", "sys", "d", 2552), Leaving, dRoles)
val dExiting = TestMember(Address("akka", "sys", "d", 2552), Exiting, dRoles)
val dRemoved = TestMember(Address("akka", "sys", "d", 2552), Removed, dRoles)
val eRoles = Set("EE", "DE")
val eJoining = TestMember(Address("akka.tcp", "sys", "e", 2552), Joining, eRoles)
val eUp = TestMember(Address("akka.tcp", "sys", "e", 2552), Up, eRoles)
val eDown = TestMember(Address("akka.tcp", "sys", "e", 2552), Down, eRoles)
val selfDummyAddress = UniqueAddress(Address("akka.tcp", "sys", "selfDummy", 2552), 17L)
val eJoining = TestMember(Address("akka", "sys", "e", 2552), Joining, eRoles)
val eUp = TestMember(Address("akka", "sys", "e", 2552), Up, eRoles)
val eDown = TestMember(Address("akka", "sys", "e", 2552), Down, eRoles)
val selfDummyAddress = UniqueAddress(Address("akka", "sys", "selfDummy", 2552), 17L)
private[cluster] def converge(gossip: Gossip): (Gossip, Set[UniqueAddress]) =
gossip.members.foldLeft((gossip, Set.empty[UniqueAddress])) {
@ -91,12 +91,12 @@ class ClusterDomainEventSpec extends WordSpec with Matchers {
}
"be produced for reachability observations between data centers" in {
val dc2AMemberUp = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
val dc2BMemberUp = TestMember(Address("akka.tcp", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberUp = TestMember(Address("akka", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("akka", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
val dc2BMemberUp = TestMember(Address("akka", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
val dc3AMemberUp = TestMember(Address("akka.tcp", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
val dc3BMemberUp = TestMember(Address("akka.tcp", "sys", "dc3B", 2552), Up, Set.empty[String], "dc3")
val dc3AMemberUp = TestMember(Address("akka", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
val dc3BMemberUp = TestMember(Address("akka", "sys", "dc3B", 2552), Up, Set.empty[String], "dc3")
val reachability1 = Reachability.empty
val g1 = Gossip(
@ -128,8 +128,8 @@ class ClusterDomainEventSpec extends WordSpec with Matchers {
}
"not be produced for same reachability observations between data centers" in {
val dc2AMemberUp = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
val dc2AMemberUp = TestMember(Address("akka", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("akka", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
val reachability1 = Reachability.empty
val g1 = Gossip(members = SortedSet(aUp, dc2AMemberUp), overview = GossipOverview(reachability = reachability1))

15
akka-cluster/src/test/scala/akka/cluster/ClusterHeartbeatSenderStateSpec.scala
View file

@ -40,11 +40,11 @@ object ClusterHeartbeatSenderStateSpec {
class ClusterHeartbeatSenderStateSpec extends WordSpec with Matchers {
import ClusterHeartbeatSenderStateSpec._
val aa = UniqueAddress(Address("akka.tcp", "sys", "aa", 2552), 1L)
val bb = UniqueAddress(Address("akka.tcp", "sys", "bb", 2552), 2L)
val cc = UniqueAddress(Address("akka.tcp", "sys", "cc", 2552), 3L)
val dd = UniqueAddress(Address("akka.tcp", "sys", "dd", 2552), 4L)
val ee = UniqueAddress(Address("akka.tcp", "sys", "ee", 2552), 5L)
val aa = UniqueAddress(Address("akka", "sys", "aa", 2552), 1L)
val bb = UniqueAddress(Address("akka", "sys", "bb", 2552), 2L)
val cc = UniqueAddress(Address("akka", "sys", "cc", 2552), 3L)
val dd = UniqueAddress(Address("akka", "sys", "dd", 2552), 4L)
val ee = UniqueAddress(Address("akka", "sys", "ee", 2552), 5L)
private def emptyState: ClusterHeartbeatSenderState = emptyState(aa)
@ -151,9 +151,8 @@ class ClusterHeartbeatSenderStateSpec extends WordSpec with Matchers {
"behave correctly for random operations" in {
val rnd = ThreadLocalRandom.current
val nodes = (1 to rnd.nextInt(10, 200))
.map(n => UniqueAddress(Address("akka.tcp", "sys", "n" + n, 2552), n.toLong))
.toVector
val nodes =
(1 to rnd.nextInt(10, 200)).map(n => UniqueAddress(Address("akka", "sys", "n" + n, 2552), n.toLong)).toVector
def rndNode() = nodes(rnd.nextInt(0, nodes.size))
val selfUniqueAddress = rndNode()
var state = emptyState(selfUniqueAddress)

2
akka-cluster/src/test/scala/akka/cluster/DowningProviderSpec.scala
View file

@ -39,7 +39,7 @@ class DowningProviderSpec extends WordSpec with Matchers {
loglevel = WARNING
actor.provider = "cluster"
remote {
netty.tcp {
classic.netty.tcp {
hostname = "127.0.0.1"
port = 0
}

20
akka-cluster/src/test/scala/akka/cluster/GossipSpec.scala
View file

@ -16,22 +16,22 @@ class GossipSpec extends WordSpec with Matchers {
import MemberStatus._
val a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Up)
val a1 = TestMember(Address("akka", "sys", "a", 2552), Up)
val a2 = TestMember(a1.address, Joining)
val b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up)
val b1 = TestMember(Address("akka", "sys", "b", 2552), Up)
val b2 = TestMember(b1.address, Removed)
val c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving)
val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving)
val c2 = TestMember(c1.address, Up)
val c3 = TestMember(c1.address, Exiting)
val d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Leaving)
val e1 = TestMember(Address("akka.tcp", "sys", "e", 2552), Joining)
val d1 = TestMember(Address("akka", "sys", "d", 2552), Leaving)
val e1 = TestMember(Address("akka", "sys", "e", 2552), Joining)
val e2 = TestMember(e1.address, Up)
val e3 = TestMember(e1.address, Down)
val dc1a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
val dc1b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
val dc2c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
val dc2d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Up, Set.empty, dataCenter = "dc2")
val dc1a1 = TestMember(Address("akka", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
val dc1b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
val dc2c1 = TestMember(Address("akka", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
val dc2d1 = TestMember(Address("akka", "sys", "d", 2552), Up, Set.empty, dataCenter = "dc2")
val dc2d2 = TestMember(dc2d1.address, status = Down, roles = Set.empty, dataCenter = dc2d1.dataCenter)
// restarted with another uid
val dc2d3 =
@ -487,7 +487,7 @@ class GossipSpec extends WordSpec with Matchers {
}
"update members" in {
val joining = TestMember(Address("akka.tcp", "sys", "d", 2552), Joining, Set.empty, dataCenter = "dc2")
val joining = TestMember(Address("akka", "sys", "d", 2552), Joining, Set.empty, dataCenter = "dc2")
val g = Gossip(members = SortedSet(dc1a1, joining))
g.member(joining.uniqueAddress).status should ===(Joining)

16
akka-cluster/src/test/scala/akka/cluster/GossipTargetSelectorSpec.scala
View file

@ -13,17 +13,17 @@ import scala.collection.immutable.SortedSet
class GossipTargetSelectorSpec extends WordSpec with Matchers {
val aDc1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
val bDc1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
val cDc1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc1")
val aDc1 = TestMember(Address("akka", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
val bDc1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
val cDc1 = TestMember(Address("akka", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc1")
val eDc2 = TestMember(Address("akka.tcp", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2")
val fDc2 = TestMember(Address("akka.tcp", "sys", "f", 2552), Up, Set.empty, dataCenter = "dc2")
val eDc2 = TestMember(Address("akka", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2")
val fDc2 = TestMember(Address("akka", "sys", "f", 2552), Up, Set.empty, dataCenter = "dc2")
val gDc3 = TestMember(Address("akka.tcp", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3")
val hDc3 = TestMember(Address("akka.tcp", "sys", "h", 2552), Up, Set.empty, dataCenter = "dc3")
val gDc3 = TestMember(Address("akka", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3")
val hDc3 = TestMember(Address("akka", "sys", "h", 2552), Up, Set.empty, dataCenter = "dc3")
val iDc4 = TestMember(Address("akka.tcp", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4")
val iDc4 = TestMember(Address("akka", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4")
val defaultSelector =
new GossipTargetSelector(reduceGossipDifferentViewProbability = 400, crossDcGossipProbability = 0.2)

2
akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingPerfSpec.scala
View file

@ -15,7 +15,7 @@ class HeartbeatNodeRingPerfSpec extends WordSpec with Matchers {
val iterations = sys.props.get("akka.cluster.HeartbeatNodeRingPerfSpec.iterations").getOrElse("1000").toInt
def createHeartbeatNodeRingOfSize(size: Int): HeartbeatNodeRing = {
val nodes = (1 to size).map(n => UniqueAddress(Address("akka.tcp", "sys", "node-" + n, 2552), n.toLong))
val nodes = (1 to size).map(n => UniqueAddress(Address("akka", "sys", "node-" + n, 2552), n.toLong))
val selfAddress = nodes(size / 2)
HeartbeatNodeRing(selfAddress, nodes.toSet, Set.empty, 5)
}

12
akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingSpec.scala
View file

@ -10,12 +10,12 @@ import akka.actor.Address
class HeartbeatNodeRingSpec extends WordSpec with Matchers {
val aa = UniqueAddress(Address("akka.tcp", "sys", "aa", 2552), 1L)
val bb = UniqueAddress(Address("akka.tcp", "sys", "bb", 2552), 2L)
val cc = UniqueAddress(Address("akka.tcp", "sys", "cc", 2552), 3L)
val dd = UniqueAddress(Address("akka.tcp", "sys", "dd", 2552), 4L)
val ee = UniqueAddress(Address("akka.tcp", "sys", "ee", 2552), 5L)
val ff = UniqueAddress(Address("akka.tcp", "sys", "ff", 2552), 6L)
val aa = UniqueAddress(Address("akka", "sys", "aa", 2552), 1L)
val bb = UniqueAddress(Address("akka", "sys", "bb", 2552), 2L)
val cc = UniqueAddress(Address("akka", "sys", "cc", 2552), 3L)
val dd = UniqueAddress(Address("akka", "sys", "dd", 2552), 4L)
val ee = UniqueAddress(Address("akka", "sys", "ee", 2552), 5L)
val ff = UniqueAddress(Address("akka", "sys", "ff", 2552), 6L)
val nodes = Set(aa, bb, cc, dd, ee, ff)

12
akka-cluster/src/test/scala/akka/cluster/MemberOrderingSpec.scala
View file

@ -35,8 +35,8 @@ class MemberOrderingSpec extends WordSpec with Matchers {
"be sorted by address correctly" in {
import Member.ordering
// sorting should be done on host and port, only
val m1 = m(Address("akka.tcp", "sys1", "host1", 9000), Up)
val m2 = m(Address("akka.tcp", "sys1", "host1", 10000), Up)
val m1 = m(Address("akka", "sys1", "host1", 9000), Up)
val m2 = m(Address("akka", "sys1", "host1", 10000), Up)
val m3 = m(Address("cluster", "sys2", "host2", 8000), Up)
val m4 = m(Address("cluster", "sys2", "host2", 9000), Up)
val m5 = m(Address("cluster", "sys1", "host2", 10000), Up)
@ -48,7 +48,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
}
"have stable equals and hashCode" in {
val address = Address("akka.tcp", "sys1", "host1", 9000)
val address = Address("akka", "sys1", "host1", 9000)
val m1 = m(address, Joining)
val m11 = Member(UniqueAddress(address, -3L), Set.empty)
val m2 = m1.copy(status = Up)
@ -70,7 +70,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
}
"have consistent ordering and equals" in {
val address1 = Address("akka.tcp", "sys1", "host1", 9001)
val address1 = Address("akka", "sys1", "host1", 9001)
val address2 = address1.copy(port = Some(9002))
val x = m(address1, Exiting)
@ -88,7 +88,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
}
"work with SortedSet" in {
val address1 = Address("akka.tcp", "sys1", "host1", 9001)
val address1 = Address("akka", "sys1", "host1", 9001)
val address2 = address1.copy(port = Some(9002))
val address3 = address1.copy(port = Some(9003))
@ -152,7 +152,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
"Leader status ordering" must {
"order members with status Joining, Exiting and Down last" in {
val address = Address("akka.tcp", "sys1", "host1", 5000)
val address = Address("akka", "sys1", "host1", 5000)
val m1 = m(address, Joining)
val m2 = m(address.copy(port = Some(7000)), Joining)
val m3 = m(address.copy(port = Some(3000)), Exiting)

30
akka-cluster/src/test/scala/akka/cluster/MembershipStateSpec.scala
View file

@ -12,18 +12,18 @@ import scala.collection.immutable.SortedSet
class MembershipStateSpec extends WordSpec with Matchers {
// DC-a is in reverse age order
val a1 = TestMember(Address("akka.tcp", "sys", "a4", 2552), Up, 1, "dc-a")
val a2 = TestMember(Address("akka.tcp", "sys", "a3", 2552), Up, 2, "dc-a")
val a3 = TestMember(Address("akka.tcp", "sys", "a2", 2552), Up, 3, "dc-a")
val a4 = TestMember(Address("akka.tcp", "sys", "a1", 2552), Up, 4, "dc-a")
val a1 = TestMember(Address("akka", "sys", "a4", 2552), Up, 1, "dc-a")
val a2 = TestMember(Address("akka", "sys", "a3", 2552), Up, 2, "dc-a")
val a3 = TestMember(Address("akka", "sys", "a2", 2552), Up, 3, "dc-a")
val a4 = TestMember(Address("akka", "sys", "a1", 2552), Up, 4, "dc-a")
// DC-b it is the first and the last that are the oldest
val b1 = TestMember(Address("akka.tcp", "sys", "b3", 2552), Up, 1, "dc-b")
val b3 = TestMember(Address("akka.tcp", "sys", "b2", 2552), Up, 3, "dc-b")
val b1 = TestMember(Address("akka", "sys", "b3", 2552), Up, 1, "dc-b")
val b3 = TestMember(Address("akka", "sys", "b2", 2552), Up, 3, "dc-b")
// Won't be replaced by b3
val b2 = TestMember(Address("akka.tcp", "sys", "b1", 2552), Up, 2, "dc-b")
val b2 = TestMember(Address("akka", "sys", "b1", 2552), Up, 2, "dc-b")
// for the case that we don't replace it ever
val bOldest = TestMember(Address("akka.tcp", "sys", "b0", 2552), Up, 0, "dc-b")
val bOldest = TestMember(Address("akka", "sys", "b0", 2552), Up, 0, "dc-b")
"Membership state" must {
"sort by upNumber for oldest top members" in {
@ -52,43 +52,43 @@ class MembershipStateSpec extends WordSpec with Matchers {
"find two oldest per role as targets for Exiting change" in {
val a5 = TestMember(
Address("akka.tcp", "sys", "a5", 2552),
Address("akka", "sys", "a5", 2552),
MemberStatus.Exiting,
roles = Set("role1", "role2"),
upNumber = 5,
dataCenter = "dc-a")
val a6 = TestMember(
Address("akka.tcp", "sys", "a6", 2552),
Address("akka", "sys", "a6", 2552),
MemberStatus.Exiting,
roles = Set("role1", "role3"),
upNumber = 6,
dataCenter = "dc-a")
val a7 = TestMember(
Address("akka.tcp", "sys", "a7", 2552),
Address("akka", "sys", "a7", 2552),
MemberStatus.Exiting,
roles = Set("role1"),
upNumber = 7,
dataCenter = "dc-a")
val a8 = TestMember(
Address("akka.tcp", "sys", "a8", 2552),
Address("akka", "sys", "a8", 2552),
MemberStatus.Exiting,
roles = Set("role1"),
upNumber = 8,
dataCenter = "dc-a")
val a9 = TestMember(
Address("akka.tcp", "sys", "a9", 2552),
Address("akka", "sys", "a9", 2552),
MemberStatus.Exiting,
roles = Set("role2"),
upNumber = 9,
dataCenter = "dc-a")
val b5 = TestMember(
Address("akka.tcp", "sys", "b5", 2552),
Address("akka", "sys", "b5", 2552),
MemberStatus.Exiting,
roles = Set("role1"),
upNumber = 5,
dataCenter = "dc-b")
val b6 = TestMember(
Address("akka.tcp", "sys", "b6", 2552),
Address("akka", "sys", "b6", 2552),
MemberStatus.Exiting,
roles = Set("role2"),
upNumber = 6,

4
akka-cluster/src/test/scala/akka/cluster/ReachabilityPerfSpec.scala
View file

@ -15,8 +15,8 @@ class ReachabilityPerfSpec extends WordSpec with Matchers {
// increase for serious measurements
val iterations = sys.props.get("akka.cluster.ReachabilityPerfSpec.iterations").getOrElse("100").toInt
val address = Address("akka.tcp", "sys", "a", 2552)
val node = Address("akka.tcp", "sys", "a", 2552)
val address = Address("akka", "sys", "a", 2552)
val node = Address("akka", "sys", "a", 2552)
private def createReachabilityOfSize(base: Reachability, size: Int): Reachability =
(1 to size).foldLeft(base) {

10
akka-cluster/src/test/scala/akka/cluster/ReachabilitySpec.scala
View file

@ -12,11 +12,11 @@ class ReachabilitySpec extends WordSpec with Matchers {
import Reachability.{ Reachable, Record, Terminated, Unreachable }
val nodeA = UniqueAddress(Address("akka.tcp", "sys", "a", 2552), 1L)
val nodeB = UniqueAddress(Address("akka.tcp", "sys", "b", 2552), 2L)
val nodeC = UniqueAddress(Address("akka.tcp", "sys", "c", 2552), 3L)
val nodeD = UniqueAddress(Address("akka.tcp", "sys", "d", 2552), 4L)
val nodeE = UniqueAddress(Address("akka.tcp", "sys", "e", 2552), 5L)
val nodeA = UniqueAddress(Address("akka", "sys", "a", 2552), 1L)
val nodeB = UniqueAddress(Address("akka", "sys", "b", 2552), 2L)
val nodeC = UniqueAddress(Address("akka", "sys", "c", 2552), 3L)
val nodeD = UniqueAddress(Address("akka", "sys", "d", 2552), 4L)
val nodeE = UniqueAddress(Address("akka", "sys", "e", 2552), 5L)
"Reachability table" must {

20
akka-cluster/src/test/scala/akka/cluster/protobuf/ClusterMessageSerializerSpec.scala
View file

@ -39,19 +39,19 @@ class ClusterMessageSerializerSpec extends AkkaSpec("akka.actor.provider = clust
import MemberStatus._
val a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Joining, Set.empty[String])
val b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set("r1"))
val c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving, Set.empty[String], "foo")
val d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Exiting, Set("r1"), "foo")
val e1 = TestMember(Address("akka.tcp", "sys", "e", 2552), Down, Set("r3"))
val f1 = TestMember(Address("akka.tcp", "sys", "f", 2552), Removed, Set("r3"), "foo")
val a1 = TestMember(Address("akka", "sys", "a", 2552), Joining, Set.empty[String])
val b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set("r1"))
val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving, Set.empty[String], "foo")
val d1 = TestMember(Address("akka", "sys", "d", 2552), Exiting, Set("r1"), "foo")
val e1 = TestMember(Address("akka", "sys", "e", 2552), Down, Set("r3"))
val f1 = TestMember(Address("akka", "sys", "f", 2552), Removed, Set("r3"), "foo")
"ClusterMessages" must {
"be serializable" in {
val address = Address("akka.tcp", "system", "some.host.org", 4711)
val address = Address("akka", "system", "some.host.org", 4711)
val uniqueAddress = UniqueAddress(address, 17L)
val address2 = Address("akka.tcp", "system", "other.host.org", 4711)
val address2 = Address("akka", "system", "other.host.org", 4711)
val uniqueAddress2 = UniqueAddress(address2, 18L)
checkSerialization(InternalClusterAction.Join(uniqueAddress, Set("foo", "bar", "dc-A")))
checkSerialization(ClusterUserAction.Leave(address))
@ -103,7 +103,7 @@ class ClusterMessageSerializerSpec extends AkkaSpec("akka.actor.provider = clust
// we must use the old singleton class name so that the other side will see an InitJoin
// but discard the config as it does not know about the config check
val initJoinAck = InternalClusterAction.InitJoinAck(
Address("akka.tcp", "cluster", "127.0.0.1", 2552),
Address("akka", "cluster", "127.0.0.1", 2552),
InternalClusterAction.UncheckedConfig)
val serializedInitJoinAckPre2510 = serializer.addressToProto(initJoinAck.address).build().toByteArray
@ -114,7 +114,7 @@ class ClusterMessageSerializerSpec extends AkkaSpec("akka.actor.provider = clust
"serialize to wire format of version 2.5.9 (using serialized address for InitJoinAck)" in {
val initJoinAck = InternalClusterAction.InitJoinAck(
Address("akka.tcp", "cluster", "127.0.0.1", 2552),
Address("akka", "cluster", "127.0.0.1", 2552),
InternalClusterAction.ConfigCheckUnsupportedByJoiningNode)
val bytes = serializer.toBinary(initJoinAck)