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

change default port number to 7355

Browse source
This commit is contained in:
PJ Fanning 2023-03-06 12:19:29 +01:00 • committed by kerr
parent defddc6af5
commit 785369030d
59 changed files with 215 additions and 215 deletions
Download patch file Download diff file Expand all files Collapse all files

26
actor-tests/src/test/scala/org/apache/pekko/actor/ActorPathSpec.scala
View file

@ -68,26 +68,26 @@ class ActorPathSpec extends AnyWordSpec with Matchers {
"create correct toStringWithAddress" in { "create correct toStringWithAddress" in {
val local = Address("pekko", "mysys") val local = Address("pekko", "mysys")
val a = local.copy(host = Some("aaa"), port = Some(2552)) val a = local.copy(host = Some("aaa"), port = Some(7355))
val b = a.copy(host = Some("bb")) val b = a.copy(host = Some("bb"))
val c = a.copy(host = Some("cccc")) val c = a.copy(host = Some("cccc"))
val root = RootActorPath(local) val root = RootActorPath(local)
root.toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/") root.toStringWithAddress(a) should ===("pekko://mysys@aaa:7355/")
(root / "user").toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/user") (root / "user").toStringWithAddress(a) should ===("pekko://mysys@aaa:7355/user")
(root / "user" / "foo").toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/user/foo") (root / "user" / "foo").toStringWithAddress(a) should ===("pekko://mysys@aaa:7355/user/foo")
// root.toStringWithAddress(b) should ===("pekko://mysys@bb:2552/") // root.toStringWithAddress(b) should ===("pekko://mysys@bb:7355/")
(root / "user").toStringWithAddress(b) should ===("pekko://mysys@bb:2552/user") (root / "user").toStringWithAddress(b) should ===("pekko://mysys@bb:7355/user")
(root / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@bb:2552/user/foo") (root / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@bb:7355/user/foo")
root.toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/") root.toStringWithAddress(c) should ===("pekko://mysys@cccc:7355/")
(root / "user").toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/user") (root / "user").toStringWithAddress(c) should ===("pekko://mysys@cccc:7355/user")
(root / "user" / "foo").toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/user/foo") (root / "user" / "foo").toStringWithAddress(c) should ===("pekko://mysys@cccc:7355/user/foo")
val rootA = RootActorPath(a) val rootA = RootActorPath(a)
rootA.toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/") rootA.toStringWithAddress(b) should ===("pekko://mysys@aaa:7355/")
(rootA / "user").toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/user") (rootA / "user").toStringWithAddress(b) should ===("pekko://mysys@aaa:7355/user")
(rootA / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/user/foo") (rootA / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@aaa:7355/user/foo")
} }
"not allow path separators in RootActorPath's name" in { "not allow path separators in RootActorPath's name" in {

2
actor-tests/src/test/scala/org/apache/pekko/actor/LocalActorRefProviderSpec.scala
View file

@ -48,7 +48,7 @@ class LocalActorRefProviderSpec extends PekkoSpec(LocalActorRefProviderSpec.conf
"An LocalActorRefProvider" must { "An LocalActorRefProvider" must {
"find child actor with URL encoded name" in { "find child actor with URL encoded name" in {
val childName = "pekko%3A%2F%2FClusterSystem%40127.0.0.1%3A2552" val childName = "pekko%3A%2F%2FClusterSystem%40127.0.0.1%3A7355"
val a = system.actorOf(Props(new Actor { val a = system.actorOf(Props(new Actor {
val child = context.actorOf(Props.empty, name = childName) val child = context.actorOf(Props.empty, name = childName)
def receive = { def receive = {

2
actor-tests/src/test/scala/org/apache/pekko/actor/RelativeActorPathSpec.scala
View file

@ -32,7 +32,7 @@ class RelativeActorPathSpec extends AnyWordSpec with Matchers {
elements("foo/bar/baz") should ===(List("foo", "bar", "baz")) elements("foo/bar/baz") should ===(List("foo", "bar", "baz"))
} }
"match url encoded name" in { "match url encoded name" in {
val name = URLEncoder.encode("pekko://ClusterSystem@127.0.0.1:2552", "UTF-8") val name = URLEncoder.encode("pekko://ClusterSystem@127.0.0.1:7355", "UTF-8")
elements(name) should ===(List(name)) elements(name) should ===(List(name))
} }
"match path with uid fragment" in { "match path with uid fragment" in {

2
bench-jmh/src/main/scala/org/apache/pekko/cluster/ddata/ORSetMergeBenchmark.scala
View file

@ -43,7 +43,7 @@ class ORSetMergeBenchmark {
@Param(Array("1", "10", "20", "100")) @Param(Array("1", "10", "20", "100"))
var set1Size = 0 var set1Size = 0
val nodeA = UniqueAddress(Address("pekko", "Sys", "aaaa", 2552), 1L) val nodeA = UniqueAddress(Address("pekko", "Sys", "aaaa", 7355), 1L)
val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2L) val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2L)
val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3L) val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3L)
val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4L) val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4L)

2
bench-jmh/src/main/scala/org/apache/pekko/cluster/ddata/VersionVectorBenchmark.scala
View file

@ -43,7 +43,7 @@ class VersionVectorBenchmark {
@Param(Array("1", "2", "5")) @Param(Array("1", "2", "5"))
var size = 0 var size = 0
val nodeA = UniqueAddress(Address("pekko", "Sys", "aaaa", 2552), 1L) val nodeA = UniqueAddress(Address("pekko", "Sys", "aaaa", 7355), 1L)
val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2L) val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2L)
val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3L) val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3L)
val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4L) val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4L)

12
cluster-metrics/src/test/scala/org/apache/pekko/cluster/metrics/protobuf/MessageSerializerSpec.scala
View file

@ -40,12 +40,12 @@ class MessageSerializerSpec extends PekkoSpec("""
import MemberStatus._ import MemberStatus._
val a1 = TestMember(Address("pekko", "sys", "a", 2552), Joining, Set.empty) val a1 = TestMember(Address("pekko", "sys", "a", 7355), Joining, Set.empty)
val b1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set("r1")) val b1 = TestMember(Address("pekko", "sys", "b", 7355), Up, Set("r1"))
val c1 = TestMember(Address("pekko", "sys", "c", 2552), Leaving, Set("r2")) val c1 = TestMember(Address("pekko", "sys", "c", 7355), Leaving, Set("r2"))
val d1 = TestMember(Address("pekko", "sys", "d", 2552), Exiting, Set("r1", "r2")) val d1 = TestMember(Address("pekko", "sys", "d", 7355), Exiting, Set("r1", "r2"))
val e1 = TestMember(Address("pekko", "sys", "e", 2552), Down, Set("r3")) val e1 = TestMember(Address("pekko", "sys", "e", 7355), Down, Set("r3"))
val f1 = TestMember(Address("pekko", "sys", "f", 2552), Removed, Set("r2", "r3")) val f1 = TestMember(Address("pekko", "sys", "f", 7355), Removed, Set("r2", "r3"))
"ClusterMessages" must { "ClusterMessages" must {

2
cluster-sharding-typed/src/test/java/jdocs/org/apache/pekko/cluster/sharding/typed/ExternalShardAllocationCompileOnlyTest.java
View file

@ -46,7 +46,7 @@ public class ExternalShardAllocationCompileOnlyTest {
ExternalShardAllocationClient client = ExternalShardAllocationClient client =
ExternalShardAllocation.get(system).getClient(typeKey.name()); ExternalShardAllocation.get(system).getClient(typeKey.name());
CompletionStage<Done> done = CompletionStage<Done> done =
client.setShardLocation("shard-id-1", new Address("pekko", "system", "127.0.0.1", 2552)); client.setShardLocation("shard-id-1", new Address("pekko", "system", "127.0.0.1", 7355));
// #client // #client
} }

2
cluster-sharding-typed/src/test/scala/docs/org/apache/pekko/cluster/sharding/typed/ExternalShardAllocationCompileOnlySpec.scala
View file

@ -46,7 +46,7 @@ class ExternalShardAllocationCompileOnlySpec {
// #client // #client
val client: ExternalShardAllocationClient = ExternalShardAllocation(system).clientFor(TypeKey.name) val client: ExternalShardAllocationClient = ExternalShardAllocation(system).clientFor(TypeKey.name)
val done: Future[Done] = client.updateShardLocation("shard-id-1", Address("pekko", "system", "127.0.0.1", 2552)) val done: Future[Done] = client.updateShardLocation("shard-id-1", Address("pekko", "system", "127.0.0.1", 7355))
// #client // #client
} }

6
cluster-sharding/src/test/scala/org/apache/pekko/cluster/sharding/protobuf/ClusterShardingMessageSerializerSpec.scala
View file

@ -121,15 +121,15 @@ class ClusterShardingMessageSerializerSpec extends PekkoSpec {
"be able to serialize GetCurrentRegions" in { "be able to serialize GetCurrentRegions" in {
checkSerialization(ShardRegion.GetCurrentRegions) checkSerialization(ShardRegion.GetCurrentRegions)
checkSerialization( checkSerialization(
ShardRegion.CurrentRegions(Set(Address("pekko", "sys", "a", 2552), Address("pekko", "sys", "b", 2552)))) ShardRegion.CurrentRegions(Set(Address("pekko", "sys", "a", 7355), Address("pekko", "sys", "b", 7355))))
} }
"be able to serialize GetClusterShardingStats" in { "be able to serialize GetClusterShardingStats" in {
checkSerialization(ShardRegion.GetClusterShardingStats(3.seconds)) checkSerialization(ShardRegion.GetClusterShardingStats(3.seconds))
checkSerialization( checkSerialization(
ShardRegion.ClusterShardingStats(Map( ShardRegion.ClusterShardingStats(Map(
Address("pekko", "sys", "a", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")), Address("pekko", "sys", "a", 7355) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")),
Address("pekko", "sys", "b", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b"))))) Address("pekko", "sys", "b", 7355) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")))))
} }
} }
} }

4
cluster-tools/src/multi-jvm/scala/org/apache/pekko/cluster/client/ClusterClientSpec.scala
View file

@ -205,8 +205,8 @@ class ClusterClientSpec extends MultiNodeSpec(ClusterClientSpec) with STMultiNod
def docOnly = { // not used, only demo def docOnly = { // not used, only demo
// #initialContacts // #initialContacts
val initialContacts = Set( val initialContacts = Set(
ActorPath.fromString("pekko://OtherSys@host1:2552/system/receptionist"), ActorPath.fromString("pekko://OtherSys@host1:7355/system/receptionist"),
ActorPath.fromString("pekko://OtherSys@host2:2552/system/receptionist")) ActorPath.fromString("pekko://OtherSys@host2:7355/system/receptionist"))
val settings = ClusterClientSettings(system).withInitialContacts(initialContacts) val settings = ClusterClientSettings(system).withInitialContacts(initialContacts)
// #initialContacts // #initialContacts

4
cluster-tools/src/test/java/org/apache/pekko/cluster/client/ClusterClientTest.java
View file

@ -41,8 +41,8 @@ public class ClusterClientTest extends JUnitSuite {
Set<ActorPath> initialContacts() { Set<ActorPath> initialContacts() {
return new HashSet<ActorPath>( return new HashSet<ActorPath>(
Arrays.asList( Arrays.asList(
ActorPaths.fromString("pekko://OtherSys@host1:2552/system/receptionist"), ActorPaths.fromString("pekko://OtherSys@host1:7355/system/receptionist"),
ActorPaths.fromString("pekko://OtherSys@host2:2552/system/receptionist"))); ActorPaths.fromString("pekko://OtherSys@host2:7355/system/receptionist")));
} }
// #initialContacts // #initialContacts

6
cluster-tools/src/test/scala/org/apache/pekko/cluster/client/protobuf/ClusterClientMessageSerializerSpec.scala
View file

@ -35,9 +35,9 @@ class ClusterClientMessageSerializerSpec extends PekkoSpec {
"be serializable" in { "be serializable" in {
val contactPoints = Vector( val contactPoints = Vector(
"pekko://system@node-1:2552/system/receptionist", "pekko://system@node-1:7355/system/receptionist",
"pekko://system@node-2:2552/system/receptionist", "pekko://system@node-2:7355/system/receptionist",
"pekko://system@node-3:2552/system/receptionist") "pekko://system@node-3:7355/system/receptionist")
checkSerialization(Contacts(contactPoints)) checkSerialization(Contacts(contactPoints))
checkSerialization(GetContacts) checkSerialization(GetContacts)
checkSerialization(Heartbeat) checkSerialization(Heartbeat)

2
cluster-typed/src/test/java/jdocs/org/apache/pekko/cluster/typed/BasicClusterExampleTest.java
View file

@ -132,7 +132,7 @@ public class BasicClusterExampleTest { // extends JUnitSuite {
// #join-seed-nodes // #join-seed-nodes
List<Address> seedNodes = new ArrayList<>(); List<Address> seedNodes = new ArrayList<>();
seedNodes.add(AddressFromURIString.parse("pekko://ClusterSystem@127.0.0.1:2551")); seedNodes.add(AddressFromURIString.parse("pekko://ClusterSystem@127.0.0.1:2551"));
seedNodes.add(AddressFromURIString.parse("pekko://ClusterSystem@127.0.0.1:2552")); seedNodes.add(AddressFromURIString.parse("pekko://ClusterSystem@127.0.0.1:7355"));
Cluster.get(system).manager().tell(new JoinSeedNodes(seedNodes)); Cluster.get(system).manager().tell(new JoinSeedNodes(seedNodes));
// #join-seed-nodes // #join-seed-nodes

4
cluster-typed/src/test/scala/docs/org/apache/pekko/cluster/typed/BasicClusterExampleSpec.scala
View file

@ -53,7 +53,7 @@ pekko {
cluster { cluster {
seed-nodes = [ seed-nodes = [
"pekko://ClusterSystem@127.0.0.1:2551", "pekko://ClusterSystem@127.0.0.1:2551",
"pekko://ClusterSystem@127.0.0.1:2552"] "pekko://ClusterSystem@127.0.0.1:7355"]
downing-provider-class = "org.apache.pekko.cluster.sbr.SplitBrainResolverProvider" downing-provider-class = "org.apache.pekko.cluster.sbr.SplitBrainResolverProvider"
} }
@ -75,7 +75,7 @@ pekko {
import pekko.cluster.typed.JoinSeedNodes import pekko.cluster.typed.JoinSeedNodes
val seedNodes: List[Address] = val seedNodes: List[Address] =
List("pekko://ClusterSystem@127.0.0.1:2551", "pekko://ClusterSystem@127.0.0.1:2552").map( List("pekko://ClusterSystem@127.0.0.1:2551", "pekko://ClusterSystem@127.0.0.1:7355").map(
AddressFromURIString.parse) AddressFromURIString.parse)
Cluster(system).manager ! JoinSeedNodes(seedNodes) Cluster(system).manager ! JoinSeedNodes(seedNodes)
// #join-seed-nodes // #join-seed-nodes

4
cluster/jmx-client/pekko-cluster
View file

@ -217,10 +217,10 @@ do
printf "Where the <node-url> should be on the format of 'pekko.tcp://actor-system-name@hostname:port'\n" printf "Where the <node-url> should be on the format of 'pekko.tcp://actor-system-name@hostname:port'\n"
printf "\n" printf "\n"
printf "Examples: $0 localhost 9999 is-available\n" printf "Examples: $0 localhost 9999 is-available\n"
printf " $0 localhost 9999 join pekko.tcp://MySystem@darkstar:2552\n" printf " $0 localhost 9999 join pekko.tcp://MySystem@darkstar:7355\n"
printf " $0 localhost 9999 cluster-status\n" printf " $0 localhost 9999 cluster-status\n"
printf " $0 localhost 9999 -p 2551 is-available\n" printf " $0 localhost 9999 -p 2551 is-available\n"
printf " $0 localhost 9999 -p 2551 join pekko.tcp://MySystem@darkstar:2552\n" printf " $0 localhost 9999 -p 2551 join pekko.tcp://MySystem@darkstar:7355\n"
printf " $0 localhost 9999 -p 2551 cluster-status\n" printf " $0 localhost 9999 -p 2551 cluster-status\n"
exit 1 exit 1
;; ;;

22
cluster/src/main/scala/org/apache/pekko/cluster/ClusterJmx.scala
View file

@ -49,10 +49,10 @@ trait ClusterNodeMBean {
* JSON format of the status of all nodes in the cluster as follows: * JSON format of the status of all nodes in the cluster as follows:
* {{{ * {{{
* { * {
* "self-address": "pekko://system@host1:2552", * "self-address": "pekko://system@host1:7355",
* "members": [ * "members": [
* { * {
* "address": "pekko://system@host1:2552", * "address": "pekko://system@host1:7355",
* "status": "Up", * "status": "Up",
* "app-version": "1.0.0", * "app-version": "1.0.0",
* "roles": [ * "roles": [
@ -60,7 +60,7 @@ trait ClusterNodeMBean {
* ] * ]
* }, * },
* { * {
* "address": "pekko://system@host2:2552", * "address": "pekko://system@host2:7355",
* "status": "Up", * "status": "Up",
* "app-version": "1.0.0", * "app-version": "1.0.0",
* "roles": [ * "roles": [
@ -68,7 +68,7 @@ trait ClusterNodeMBean {
* ] * ]
* }, * },
* { * {
* "address": "pekko://system@host3:2552", * "address": "pekko://system@host3:7355",
* "status": "Down", * "status": "Down",
* "app-version": "1.0.0", * "app-version": "1.0.0",
* "roles": [ * "roles": [
@ -76,7 +76,7 @@ trait ClusterNodeMBean {
* ] * ]
* }, * },
* { * {
* "address": "pekko://system@host4:2552", * "address": "pekko://system@host4:7355",
* "status": "Joining", * "status": "Joining",
* "app-version": "1.1.0", * "app-version": "1.1.0",
* "roles": [ * "roles": [
@ -86,17 +86,17 @@ trait ClusterNodeMBean {
* ], * ],
* "unreachable": [ * "unreachable": [
* { * {
* "node": "pekko://system@host2:2552", * "node": "pekko://system@host2:7355",
* "observed-by": [ * "observed-by": [
* "pekko://system@host1:2552", * "pekko://system@host1:7355",
* "pekko://system@host3:2552" * "pekko://system@host3:7355"
* ] * ]
* }, * },
* { * {
* "node": "pekko://system@host3:2552", * "node": "pekko://system@host3:7355",
* "observed-by": [ * "observed-by": [
* "pekko://system@host1:2552", * "pekko://system@host1:7355",
* "pekko://system@host2:2552" * "pekko://system@host2:7355"
* ] * ]
* } * }
* ] * ]

10
cluster/src/test/scala/org/apache/pekko/cluster/ClusterDomainEventPublisherSpec.scala
View file

@ -52,18 +52,18 @@ class ClusterDomainEventPublisherSpec
final val OtherDataCenter = "dc2" final val OtherDataCenter = "dc2"
val aUp = TestMember(Address(protocol, "sys", "a", 2552), Up) val aUp = TestMember(Address(protocol, "sys", "a", 7355), Up)
val aLeaving = aUp.copy(status = Leaving) val aLeaving = aUp.copy(status = Leaving)
val aExiting = aLeaving.copy(status = Exiting) val aExiting = aLeaving.copy(status = Exiting)
val aRemoved = aExiting.copy(status = Removed) val aRemoved = aExiting.copy(status = Removed)
val bExiting = TestMember(Address(protocol, "sys", "b", 2552), Exiting) val bExiting = TestMember(Address(protocol, "sys", "b", 7355), Exiting)
val bRemoved = bExiting.copy(status = Removed) val bRemoved = bExiting.copy(status = Removed)
val cJoining = TestMember(Address(protocol, "sys", "c", 2552), Joining, Set("GRP")) val cJoining = TestMember(Address(protocol, "sys", "c", 7355), Joining, Set("GRP"))
val cUp = cJoining.copy(status = Up) val cUp = cJoining.copy(status = Up)
val cRemoved = cUp.copy(status = Removed) val cRemoved = cUp.copy(status = Removed)
val a51Up = TestMember(Address(protocol, "sys", "a", 2551), Up) val a51Up = TestMember(Address(protocol, "sys", "a", 2551), Up)
val dUp = TestMember(Address(protocol, "sys", "d", 2552), Up, Set("GRP")) val dUp = TestMember(Address(protocol, "sys", "d", 7355), Up, Set("GRP"))
val eUp = TestMember(Address(protocol, "sys", "e", 2552), Up, Set("GRP"), OtherDataCenter) val eUp = TestMember(Address(protocol, "sys", "e", 7355), Up, Set("GRP"), OtherDataCenter)
private def state(gossip: Gossip, self: UniqueAddress) = private def state(gossip: Gossip, self: UniqueAddress) =
MembershipState(gossip, self, DefaultDataCenter, crossDcConnections = 5) MembershipState(gossip, self, DefaultDataCenter, crossDcConnections = 5)

50
cluster/src/test/scala/org/apache/pekko/cluster/ClusterDomainEventSpec.scala
View file

@ -25,25 +25,25 @@ class ClusterDomainEventSpec extends AnyWordSpec with Matchers with BeforeAndAft
import MemberStatus._ import MemberStatus._
val aRoles = Set("AA", "AB") val aRoles = Set("AA", "AB")
val aJoining = TestMember(Address("pekko", "sys", "a", 2552), Joining, aRoles) val aJoining = TestMember(Address("pekko", "sys", "a", 7355), Joining, aRoles)
val aUp = TestMember(Address("pekko", "sys", "a", 2552), Up, aRoles) val aUp = TestMember(Address("pekko", "sys", "a", 7355), Up, aRoles)
val aRemoved = TestMember(Address("pekko", "sys", "a", 2552), Removed, aRoles) val aRemoved = TestMember(Address("pekko", "sys", "a", 7355), Removed, aRoles)
val bRoles = Set("AB", "BB") val bRoles = Set("AB", "BB")
val bUp = TestMember(Address("pekko", "sys", "b", 2552), Up, bRoles) val bUp = TestMember(Address("pekko", "sys", "b", 7355), Up, bRoles)
val bDown = TestMember(Address("pekko", "sys", "b", 2552), Down, bRoles) val bDown = TestMember(Address("pekko", "sys", "b", 7355), Down, bRoles)
val bRemoved = TestMember(Address("pekko", "sys", "b", 2552), Removed, bRoles) val bRemoved = TestMember(Address("pekko", "sys", "b", 7355), Removed, bRoles)
val cRoles = Set.empty[String] val cRoles = Set.empty[String]
val cUp = TestMember(Address("pekko", "sys", "c", 2552), Up, cRoles) val cUp = TestMember(Address("pekko", "sys", "c", 7355), Up, cRoles)
val cLeaving = TestMember(Address("pekko", "sys", "c", 2552), Leaving, cRoles) val cLeaving = TestMember(Address("pekko", "sys", "c", 7355), Leaving, cRoles)
val dRoles = Set("DD", "DE") val dRoles = Set("DD", "DE")
val dLeaving = TestMember(Address("pekko", "sys", "d", 2552), Leaving, dRoles) val dLeaving = TestMember(Address("pekko", "sys", "d", 7355), Leaving, dRoles)
val dExiting = TestMember(Address("pekko", "sys", "d", 2552), Exiting, dRoles) val dExiting = TestMember(Address("pekko", "sys", "d", 7355), Exiting, dRoles)
val dRemoved = TestMember(Address("pekko", "sys", "d", 2552), Removed, dRoles) val dRemoved = TestMember(Address("pekko", "sys", "d", 7355), Removed, dRoles)
val eRoles = Set("EE", "DE") val eRoles = Set("EE", "DE")
val eJoining = TestMember(Address("pekko", "sys", "e", 2552), Joining, eRoles) val eJoining = TestMember(Address("pekko", "sys", "e", 7355), Joining, eRoles)
val eUp = TestMember(Address("pekko", "sys", "e", 2552), Up, eRoles) val eUp = TestMember(Address("pekko", "sys", "e", 7355), Up, eRoles)
val eDown = TestMember(Address("pekko", "sys", "e", 2552), Down, eRoles) val eDown = TestMember(Address("pekko", "sys", "e", 7355), Down, eRoles)
val selfDummyAddress = UniqueAddress(Address("pekko", "sys", "selfDummy", 2552), 17L) val selfDummyAddress = UniqueAddress(Address("pekko", "sys", "selfDummy", 7355), 17L)
private val originalClusterAssert = sys.props.get("pekko.cluster.assert").getOrElse("false") private val originalClusterAssert = sys.props.get("pekko.cluster.assert").getOrElse("false")
override protected def beforeAll(): Unit = { override protected def beforeAll(): Unit = {
@ -109,12 +109,12 @@ class ClusterDomainEventSpec extends AnyWordSpec with Matchers with BeforeAndAft
} }
"be produced for reachability observations between data centers" in { "be produced for reachability observations between data centers" in {
val dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2") val dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 7355), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2") val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 7355), Down, Set.empty[String], "dc2")
val dc2BMemberUp = TestMember(Address("pekko", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2") val dc2BMemberUp = TestMember(Address("pekko", "sys", "dc2B", 7355), Up, Set.empty[String], "dc2")
val dc3AMemberUp = TestMember(Address("pekko", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3") val dc3AMemberUp = TestMember(Address("pekko", "sys", "dc3A", 7355), Up, Set.empty[String], "dc3")
val dc3BMemberUp = TestMember(Address("pekko", "sys", "dc3B", 2552), Up, Set.empty[String], "dc3") val dc3BMemberUp = TestMember(Address("pekko", "sys", "dc3B", 7355), Up, Set.empty[String], "dc3")
val reachability1 = Reachability.empty val reachability1 = Reachability.empty
val g1 = Gossip( val g1 = Gossip(
@ -146,8 +146,8 @@ class ClusterDomainEventSpec extends AnyWordSpec with Matchers with BeforeAndAft
} }
"not be produced for same reachability observations between data centers" in { "not be produced for same reachability observations between data centers" in {
val dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2") val dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 7355), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2") val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 7355), Down, Set.empty[String], "dc2")
val reachability1 = Reachability.empty val reachability1 = Reachability.empty
val g1 = Gossip(members = SortedSet(aUp, dc2AMemberUp), overview = GossipOverview(reachability = reachability1)) val g1 = Gossip(members = SortedSet(aUp, dc2AMemberUp), overview = GossipOverview(reachability = reachability1))
@ -181,9 +181,9 @@ class ClusterDomainEventSpec extends AnyWordSpec with Matchers with BeforeAndAft
// - empty // - empty
// - B --unreachable--> C // - B --unreachable--> C
val dc1MemberA = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2") val dc1MemberA = TestMember(Address("pekko", "sys", "dc2A", 7355), Up, Set.empty[String], "dc2")
val dc1MemberB = TestMember(Address("pekko", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2") val dc1MemberB = TestMember(Address("pekko", "sys", "dc2B", 7355), Up, Set.empty[String], "dc2")
val dc2MemberC = TestMember(Address("pekko", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3") val dc2MemberC = TestMember(Address("pekko", "sys", "dc3A", 7355), Up, Set.empty[String], "dc3")
val members = SortedSet(dc1MemberA, dc1MemberB, dc2MemberC) val members = SortedSet(dc1MemberA, dc1MemberB, dc2MemberC)

12
cluster/src/test/scala/org/apache/pekko/cluster/ClusterHeartbeatSenderStateSpec.scala
View file

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

4
cluster/src/test/scala/org/apache/pekko/cluster/ClusterSpec.scala
View file

@ -357,14 +357,14 @@ class ClusterSpec extends PekkoSpec(ClusterSpec.config) with ImplicitSender {
pekko.remote.artery.canonical.port = ${port} pekko.remote.artery.canonical.port = ${port}
""").withFallback(ConfigFactory.parseString(ClusterSpec.config)) """).withFallback(ConfigFactory.parseString(ClusterSpec.config))
val sys1 = ActorSystem("ClusterSpec4", getConfig(2552)) val sys1 = ActorSystem("ClusterSpec4", getConfig(7355))
val sys2 = ActorSystem("ClusterSpec4", getConfig(2553)) val sys2 = ActorSystem("ClusterSpec4", getConfig(2553))
try { try {
Cluster(sys1) Cluster(sys1)
Cluster(sys2) Cluster(sys2)
val name1 = new ObjectName(s"pekko:type=Cluster,port=2552") val name1 = new ObjectName(s"pekko:type=Cluster,port=7355")
val info1 = ManagementFactory.getPlatformMBeanServer.getMBeanInfo(name1) val info1 = ManagementFactory.getPlatformMBeanServer.getMBeanInfo(name1)
info1.getAttributes.length should be > 0 info1.getAttributes.length should be > 0
info1.getOperations.length should be > 0 info1.getOperations.length should be > 0

22
cluster/src/test/scala/org/apache/pekko/cluster/GossipSpec.scala
View file

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

16
cluster/src/test/scala/org/apache/pekko/cluster/GossipTargetSelectorSpec.scala
View file

@ -25,17 +25,17 @@ import pekko.cluster.MemberStatus.Up
class GossipTargetSelectorSpec extends AnyWordSpec with Matchers { class GossipTargetSelectorSpec extends AnyWordSpec with Matchers {
val aDc1 = TestMember(Address("pekko", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1") val aDc1 = TestMember(Address("pekko", "sys", "a", 7355), Up, Set.empty, dataCenter = "dc1")
val bDc1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1") val bDc1 = TestMember(Address("pekko", "sys", "b", 7355), Up, Set.empty, dataCenter = "dc1")
val cDc1 = TestMember(Address("pekko", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc1") val cDc1 = TestMember(Address("pekko", "sys", "c", 7355), Up, Set.empty, dataCenter = "dc1")
val eDc2 = TestMember(Address("pekko", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2") val eDc2 = TestMember(Address("pekko", "sys", "e", 7355), Up, Set.empty, dataCenter = "dc2")
val fDc2 = TestMember(Address("pekko", "sys", "f", 2552), Up, Set.empty, dataCenter = "dc2") val fDc2 = TestMember(Address("pekko", "sys", "f", 7355), Up, Set.empty, dataCenter = "dc2")
val gDc3 = TestMember(Address("pekko", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3") val gDc3 = TestMember(Address("pekko", "sys", "g", 7355), Up, Set.empty, dataCenter = "dc3")
val hDc3 = TestMember(Address("pekko", "sys", "h", 2552), Up, Set.empty, dataCenter = "dc3") val hDc3 = TestMember(Address("pekko", "sys", "h", 7355), Up, Set.empty, dataCenter = "dc3")
val iDc4 = TestMember(Address("pekko", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4") val iDc4 = TestMember(Address("pekko", "sys", "i", 7355), Up, Set.empty, dataCenter = "dc4")
val defaultSelector = val defaultSelector =
new GossipTargetSelector(reduceGossipDifferentViewProbability = 400, crossDcGossipProbability = 0.2) new GossipTargetSelector(reduceGossipDifferentViewProbability = 400, crossDcGossipProbability = 0.2)

2
cluster/src/test/scala/org/apache/pekko/cluster/HeartbeatNodeRingPerfSpec.scala
View file

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

12
cluster/src/test/scala/org/apache/pekko/cluster/HeartbeatNodeRingSpec.scala
View file

@ -20,12 +20,12 @@ import org.apache.pekko.actor.Address
class HeartbeatNodeRingSpec extends AnyWordSpec with Matchers { class HeartbeatNodeRingSpec extends AnyWordSpec with Matchers {
val aa = UniqueAddress(Address("pekko", "sys", "aa", 2552), 1L) val aa = UniqueAddress(Address("pekko", "sys", "aa", 7355), 1L)
val bb = UniqueAddress(Address("pekko", "sys", "bb", 2552), 2L) val bb = UniqueAddress(Address("pekko", "sys", "bb", 7355), 2L)
val cc = UniqueAddress(Address("pekko", "sys", "cc", 2552), 3L) val cc = UniqueAddress(Address("pekko", "sys", "cc", 7355), 3L)
val dd = UniqueAddress(Address("pekko", "sys", "dd", 2552), 4L) val dd = UniqueAddress(Address("pekko", "sys", "dd", 7355), 4L)
val ee = UniqueAddress(Address("pekko", "sys", "ee", 2552), 5L) val ee = UniqueAddress(Address("pekko", "sys", "ee", 7355), 5L)
val ff = UniqueAddress(Address("pekko", "sys", "ff", 2552), 6L) val ff = UniqueAddress(Address("pekko", "sys", "ff", 7355), 6L)
val nodes = Set(aa, bb, cc, dd, ee, ff) val nodes = Set(aa, bb, cc, dd, ee, ff)

30
cluster/src/test/scala/org/apache/pekko/cluster/MembershipStateSpec.scala
View file

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

4
cluster/src/test/scala/org/apache/pekko/cluster/ReachabilityPerfSpec.scala
View file

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

10
cluster/src/test/scala/org/apache/pekko/cluster/ReachabilitySpec.scala
View file

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

12
cluster/src/test/scala/org/apache/pekko/cluster/protobuf/ClusterMessageSerializerSpec.scala
View file

@ -81,13 +81,13 @@ class ClusterMessageSerializerSpec extends PekkoSpec("pekko.actor.provider = clu
import MemberStatus._ import MemberStatus._
val a1 = val a1 =
TestMember(Address("pekko", "sys", "a", 2552), Joining, Set.empty[String], appVersion = Version("1.0.0")) TestMember(Address("pekko", "sys", "a", 7355), Joining, Set.empty[String], appVersion = Version("1.0.0"))
val b1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set("r1"), appVersion = Version("1.1.0")) val b1 = TestMember(Address("pekko", "sys", "b", 7355), Up, Set("r1"), appVersion = Version("1.1.0"))
val c1 = val c1 =
TestMember(Address("pekko", "sys", "c", 2552), Leaving, Set.empty[String], "foo", appVersion = Version("1.1.0")) TestMember(Address("pekko", "sys", "c", 7355), Leaving, Set.empty[String], "foo", appVersion = Version("1.1.0"))
val d1 = TestMember(Address("pekko", "sys", "d", 2552), Exiting, Set("r1"), "foo") val d1 = TestMember(Address("pekko", "sys", "d", 7355), Exiting, Set("r1"), "foo")
val e1 = TestMember(Address("pekko", "sys", "e", 2552), Down, Set("r3")) val e1 = TestMember(Address("pekko", "sys", "e", 7355), Down, Set("r3"))
val f1 = TestMember(Address("pekko", "sys", "f", 2552), Removed, Set("r3"), "foo") val f1 = TestMember(Address("pekko", "sys", "f", 7355), Removed, Set("r3"), "foo")
"ClusterMessages" must { "ClusterMessages" must {

2
cluster/src/test/scala/org/apache/pekko/cluster/sbr/TestAddresses.scala
View file

@ -32,7 +32,7 @@ object TestAddresses {
val defaultDataCenter = ClusterSettings.DefaultDataCenter val defaultDataCenter = ClusterSettings.DefaultDataCenter
private def defaultDcRole = dcRole(defaultDataCenter) private def defaultDcRole = dcRole(defaultDataCenter)
val addressA = Address("pekko.tcp", "sys", "a", 2552) val addressA = Address("pekko.tcp", "sys", "a", 7355)
val memberA = new Member(UniqueAddress(addressA, 0L), 5, Up, Set("role3", defaultDcRole), Version.Zero) val memberA = new Member(UniqueAddress(addressA, 0L), 5, Up, Set("role3", defaultDcRole), Version.Zero)
val memberB = val memberB =
new Member( new Member(

6
cluster/src/test/scala/org/apache/pekko/cluster/testkit/AutoDownSpec.scala
View file

@ -58,9 +58,9 @@ class AutoDownSpec extends PekkoSpec("""
if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko" if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko"
else "pekko.tcp" else "pekko.tcp"
val memberA = TestMember(Address(protocol, "sys", "a", 2552), Up) val memberA = TestMember(Address(protocol, "sys", "a", 7355), Up)
val memberB = TestMember(Address(protocol, "sys", "b", 2552), Up) val memberB = TestMember(Address(protocol, "sys", "b", 7355), Up)
val memberC = TestMember(Address(protocol, "sys", "c", 2552), Up) val memberC = TestMember(Address(protocol, "sys", "c", 7355), Up)
def autoDownActor(autoDownUnreachableAfter: FiniteDuration): ActorRef = def autoDownActor(autoDownUnreachableAfter: FiniteDuration): ActorRef =
system.actorOf(Props(classOf[AutoDownTestActor], memberA, autoDownUnreachableAfter, testActor)) system.actorOf(Props(classOf[AutoDownTestActor], memberA, autoDownUnreachableAfter, testActor))

2
distributed-data/src/main/scala/org/apache/pekko/cluster/ddata/protobuf/ReplicatorMessageSerializer.scala
View file

@ -175,7 +175,7 @@ class ReplicatorMessageSerializer(val system: ExtendedActorSystem)
}(system.dispatchers.internalDispatcher) }(system.dispatchers.internalDispatcher)
private val writeAckBytes = dm.Empty.getDefaultInstance.toByteArray private val writeAckBytes = dm.Empty.getDefaultInstance.toByteArray
private val dummyAddress = UniqueAddress(Address("a", "b", "c", 2552), 1L) private val dummyAddress = UniqueAddress(Address("a", "b", "c", 7355), 1L)
val GetManifest = "A" val GetManifest = "A"
val GetSuccessManifest = "B" val GetSuccessManifest = "B"

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/DataEnvelopeSpec.scala
View file

@ -25,7 +25,7 @@ class DataEnvelopeSpec extends AnyWordSpec with Matchers {
import PruningState._ import PruningState._
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L) val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
val node4 = UniqueAddress(node1.address.copy(port = Some(2554)), 4L) val node4 = UniqueAddress(node1.address.copy(port = Some(2554)), 4L)
val obsoleteTimeInFuture = System.currentTimeMillis() + 3600 * 1000 val obsoleteTimeInFuture = System.currentTimeMillis() + 3600 * 1000

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/GCounterSpec.scala
View file

@ -23,7 +23,7 @@ import pekko.cluster.ddata.Replicator.Changed
class GCounterSpec extends AnyWordSpec with Matchers { class GCounterSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L) val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
"A GCounter" must { "A GCounter" must {

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/LWWMapSpec.scala
View file

@ -25,7 +25,7 @@ class LWWMapSpec extends AnyWordSpec with Matchers {
import LWWRegister.defaultClock import LWWRegister.defaultClock
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
"A LWWMap" must { "A LWWMap" must {

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/LWWRegisterSpec.scala
View file

@ -25,7 +25,7 @@ class LWWRegisterSpec extends AnyWordSpec with Matchers {
import LWWRegister.defaultClock import LWWRegister.defaultClock
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
"A LWWRegister" must { "A LWWRegister" must {
"use latest of successive assignments" in { "use latest of successive assignments" in {

4
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/LotsOfDataBot.scala
View file

@ -33,7 +33,7 @@ object LotsOfDataBot {
def main(args: Array[String]): Unit = { def main(args: Array[String]): Unit = {
if (args.isEmpty) if (args.isEmpty)
startup(Seq("2551", "2552", "0")) startup(Seq("2551", "7355", "0"))
else else
startup(args.toIndexedSeq) startup(args.toIndexedSeq)
} }
@ -58,7 +58,7 @@ object LotsOfDataBot {
pekko.cluster { pekko.cluster {
seed-nodes = [ seed-nodes = [
"pekko://ClusterSystem@127.0.0.1:2551", "pekko://ClusterSystem@127.0.0.1:2551",
"pekko://ClusterSystem@127.0.0.1:2552"] "pekko://ClusterSystem@127.0.0.1:7355"]
downing-provider-class = org.apache.pekko.cluster.testkit.AutoDowning downing-provider-class = org.apache.pekko.cluster.testkit.AutoDowning
testkit.auto-down-unreachable-after = 10s testkit.auto-down-unreachable-after = 10s

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/ORMapSpec.scala
View file

@ -25,7 +25,7 @@ import pekko.cluster.ddata.Replicator.Changed
class ORMapSpec extends AnyWordSpec with Matchers { class ORMapSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
"A ORMap" must { "A ORMap" must {

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/ORMultiMapSpec.scala
View file

@ -24,7 +24,7 @@ import pekko.cluster.ddata.Replicator.Changed
class ORMultiMapSpec extends AnyWordSpec with Matchers { class ORMultiMapSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
"A ORMultiMap" must { "A ORMultiMap" must {

4
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/ORSetSpec.scala
View file

@ -26,10 +26,10 @@ import pekko.cluster.ddata.Replicator.Changed
class ORSetSpec extends AnyWordSpec with Matchers { class ORSetSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L) val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
val nodeA = UniqueAddress(Address("pekko", "Sys", "a", 2552), 1L) val nodeA = UniqueAddress(Address("pekko", "Sys", "a", 7355), 1L)
val nodeB = UniqueAddress(nodeA.address.copy(host = Some("b")), 2L) val nodeB = UniqueAddress(nodeA.address.copy(host = Some("b")), 2L)
val nodeC = UniqueAddress(nodeA.address.copy(host = Some("c")), 3L) val nodeC = UniqueAddress(nodeA.address.copy(host = Some("c")), 3L)
val nodeD = UniqueAddress(nodeA.address.copy(host = Some("d")), 4L) val nodeD = UniqueAddress(nodeA.address.copy(host = Some("d")), 4L)

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/PNCounterMapSpec.scala
View file

@ -24,7 +24,7 @@ import pekko.cluster.ddata.Replicator.Changed
class PNCounterMapSpec extends AnyWordSpec with Matchers { class PNCounterMapSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
"A PNCounterMap" must { "A PNCounterMap" must {

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/PNCounterSpec.scala
View file

@ -23,7 +23,7 @@ import pekko.cluster.ddata.Replicator.Changed
class PNCounterSpec extends AnyWordSpec with Matchers { class PNCounterSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
"A PNCounter" must { "A PNCounter" must {

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/PruningStateSpec.scala
View file

@ -24,7 +24,7 @@ class PruningStateSpec extends AnyWordSpec with Matchers {
import PruningState._ import PruningState._
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L) val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
val node4 = UniqueAddress(node1.address.copy(port = Some(2554)), 4L) val node4 = UniqueAddress(node1.address.copy(port = Some(2554)), 4L)

2
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/VersionVectorSpec.scala
View file

@ -30,7 +30,7 @@ class VersionVectorSpec
with BeforeAndAfterAll { with BeforeAndAfterAll {
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L) val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L) val node2 = UniqueAddress(node1.address.copy(port = Some(7355)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L) val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
val node4 = UniqueAddress(node1.address.copy(port = Some(2554)), 4L) val node4 = UniqueAddress(node1.address.copy(port = Some(2554)), 4L)

8
distributed-data/src/test/scala/org/apache/pekko/cluster/ddata/WriteAggregatorSpec.scala
View file

@ -153,10 +153,10 @@ class WriteAggregatorSpec extends PekkoSpec(s"""
if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko" if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko"
else "pekko.tcp" else "pekko.tcp"
val nodeA = UniqueAddress(Address(protocol, "Sys", "a", 2552), 17L) val nodeA = UniqueAddress(Address(protocol, "Sys", "a", 7355), 17L)
val nodeB = UniqueAddress(Address(protocol, "Sys", "b", 2552), 17L) val nodeB = UniqueAddress(Address(protocol, "Sys", "b", 7355), 17L)
val nodeC = UniqueAddress(Address(protocol, "Sys", "c", 2552), 17L) val nodeC = UniqueAddress(Address(protocol, "Sys", "c", 7355), 17L)
val nodeD = UniqueAddress(Address(protocol, "Sys", "d", 2552), 17L) val nodeD = UniqueAddress(Address(protocol, "Sys", "d", 7355), 17L)
// 4 replicas + the local => 5 // 4 replicas + the local => 5
val nodes = Vector(nodeA, nodeB, nodeC, nodeD) val nodes = Vector(nodeA, nodeB, nodeC, nodeD)

2
docs/src/main/paradox/cluster-usage.md
View file

@ -412,7 +412,7 @@ Where the <node-url> should be on the format of
'pekko.<protocol>://<actor-system-name>@<hostname>:<port>' 'pekko.<protocol>://<actor-system-name>@<hostname>:<port>'
Examples: ./pekko-cluster localhost 9999 is-available Examples: ./pekko-cluster localhost 9999 is-available
./pekko-cluster localhost 9999 join pekko://MySystem@darkstar:2552 ./pekko-cluster localhost 9999 join pekko://MySystem@darkstar:7355
./pekko-cluster localhost 9999 cluster-status ./pekko-cluster localhost 9999 cluster-status
``` ```

8
docs/src/main/paradox/remoting-artery.md
View file

@ -58,7 +58,7 @@ pekko {
artery { artery {
transport = tcp # See Selecting a transport below transport = tcp # See Selecting a transport below
canonical.hostname = "127.0.0.1" canonical.hostname = "127.0.0.1"
canonical.port = 25520 canonical.port = 73550
} }
} }
} }
@ -189,13 +189,13 @@ In the next sections the two alternatives are described in detail.
Scala Scala
: ``` : ```
val selection = val selection =
context.actorSelection("pekko://actorSystemName@10.0.0.1:25520/user/actorName") context.actorSelection("pekko://actorSystemName@10.0.0.1:73550/user/actorName")
``` ```
Java Java
: ``` : ```
ActorSelection selection = ActorSelection selection =
context.actorSelection("pekko://actorSystemName@10.0.0.1:25520/user/actorName"); context.actorSelection("pekko://actorSystemName@10.0.0.1:73550/user/actorName");
``` ```
@ -850,7 +850,7 @@ pekko {
canonical.port = 8000 # external (logical) port canonical.port = 8000 # external (logical) port
bind.hostname = local.address # internal (bind) hostname bind.hostname = local.address # internal (bind) hostname
bind.port = 25520 # internal (bind) port bind.port = 73550 # internal (bind) port
} }
} }
} }

8
docs/src/main/paradox/remoting.md
View file

@ -60,7 +60,7 @@ pekko {
enabled-transports = ["pekko.remote.classic.netty.tcp"] enabled-transports = ["pekko.remote.classic.netty.tcp"]
netty.tcp { netty.tcp {
hostname = "127.0.0.1" hostname = "127.0.0.1"
port = 2552 port = 7355
} }
} }
} }
@ -126,13 +126,13 @@ In the next sections the two alternatives are described in detail.
Scala Scala
: ``` : ```
val selection = val selection =
context.actorSelection("pekko.tcp://actorSystemName@10.0.0.1:2552/user/actorName") context.actorSelection("pekko.tcp://actorSystemName@10.0.0.1:7355/user/actorName")
``` ```
Java Java
: ``` : ```
ActorSelection selection = ActorSelection selection =
context.actorSelection("pekko.tcp://app@10.0.0.1:2552/user/serviceA/worker"); context.actorSelection("pekko.tcp://app@10.0.0.1:7355/user/serviceA/worker");
``` ```
As you can see from the example above the following pattern is used to find an actor on a remote node: As you can see from the example above the following pattern is used to find an actor on a remote node:
@ -609,7 +609,7 @@ pekko.remote.classic.netty.tcp {
port = 8000 # external (logical) port port = 8000 # external (logical) port
bind-hostname = local.address # internal (bind) hostname bind-hostname = local.address # internal (bind) hostname
bind-port = 2552 # internal (bind) port bind-port = 7355 # internal (bind) port
} }
``` ```

8
docs/src/main/paradox/typed/cluster.md
View file

@ -155,15 +155,15 @@ You can define the seed nodes in the @ref:[configuration](#configuration) file (
``` ```
pekko.cluster.seed-nodes = [ pekko.cluster.seed-nodes = [
"pekko://ClusterSystem@host1:2552", "pekko://ClusterSystem@host1:7355",
"pekko://ClusterSystem@host2:2552"] "pekko://ClusterSystem@host2:7355"]
``` ```
This can also be defined as Java system properties when starting the JVM using the following syntax: This can also be defined as Java system properties when starting the JVM using the following syntax:
``` ```
-Dpekko.cluster.seed-nodes.0=pekko://ClusterSystem@host1:2552 -Dpekko.cluster.seed-nodes.0=pekko://ClusterSystem@host1:7355
-Dpekko.cluster.seed-nodes.1=pekko://ClusterSystem@host2:2552 -Dpekko.cluster.seed-nodes.1=pekko://ClusterSystem@host2:7355
``` ```

2
docs/src/test/java/jdocs/cluster/StatsSampleOneMasterMain.java
View file

@ -28,7 +28,7 @@ public class StatsSampleOneMasterMain {
public static void main(String[] args) { public static void main(String[] args) {
if (args.length == 0) { if (args.length == 0) {
startup(new String[] {"2551", "2552", "0"}); startup(new String[] {"2551", "7355", "0"});
StatsSampleOneMasterClientMain.main(new String[0]); StatsSampleOneMasterClientMain.main(new String[0]);
} else { } else {
startup(args); startup(args);

2
docs/src/test/java/jdocs/persistence/LambdaPersistencePluginDocTest.java
View file

@ -53,7 +53,7 @@ public class LambdaPersistencePluginDocTest {
class SharedStorageUsage extends AbstractActor { class SharedStorageUsage extends AbstractActor {
@Override @Override
public void preStart() throws Exception { public void preStart() throws Exception {
String path = "pekko://example@127.0.0.1:2552/user/store"; String path = "pekko://example@127.0.0.1:7355/user/store";
ActorSelection selection = getContext().actorSelection(path); ActorSelection selection = getContext().actorSelection(path);
selection.tell(new Identify(1), getSelf()); selection.tell(new Identify(1), getSelf());
} }

2
docs/src/test/scala/docs/persistence/PersistencePluginDocSpec.scala
View file

@ -138,7 +138,7 @@ object SharedLeveldbPluginDocSpec {
// #shared-store-usage // #shared-store-usage
trait SharedStoreUsage extends Actor { trait SharedStoreUsage extends Actor {
override def preStart(): Unit = { override def preStart(): Unit = {
context.actorSelection("pekko://example@127.0.0.1:2552/user/store") ! Identify(1) context.actorSelection("pekko://example@127.0.0.1:7355/user/store") ! Identify(1)
} }
def receive = { def receive = {

16
docs/src/test/scala/docs/routing/RouterDocSpec.scala
View file

@ -219,7 +219,7 @@ pekko.actor.deployment {
/parent/remotePool { /parent/remotePool {
router = round-robin-pool router = round-robin-pool
nr-of-instances = 10 nr-of-instances = 10
target.nodes = ["pekko://app@10.0.0.2:2552", "pekko://app@10.0.0.3:2552"] target.nodes = ["pekko://app@10.0.0.2:7355", "pekko://app@10.0.0.3:7355"]
} }
} }
#//#config-remote-round-robin-pool #//#config-remote-round-robin-pool
@ -229,7 +229,7 @@ pekko.actor.deployment {
/parent/remotePool { /parent/remotePool {
router = round-robin-pool router = round-robin-pool
nr-of-instances = 10 nr-of-instances = 10
target.nodes = ["tcp://app@10.0.0.2:2552", "pekko://app@10.0.0.3:2552"] target.nodes = ["tcp://app@10.0.0.2:7355", "pekko://app@10.0.0.3:7355"]
} }
} }
#//#config-remote-round-robin-pool-artery #//#config-remote-round-robin-pool-artery
@ -239,9 +239,9 @@ pekko.actor.deployment {
/parent/remoteGroup { /parent/remoteGroup {
router = round-robin-group router = round-robin-group
routees.paths = [ routees.paths = [
"pekko://app@10.0.0.1:2552/user/workers/w1", "pekko://app@10.0.0.1:7355/user/workers/w1",
"pekko://app@10.0.0.2:2552/user/workers/w1", "pekko://app@10.0.0.2:7355/user/workers/w1",
"pekko://app@10.0.0.3:2552/user/workers/w1"] "pekko://app@10.0.0.3:7355/user/workers/w1"]
} }
} }
#//#config-remote-round-robin-group #//#config-remote-round-robin-group
@ -251,9 +251,9 @@ pekko.actor.deployment {
/parent/remoteGroup2 { /parent/remoteGroup2 {
router = round-robin-group router = round-robin-group
routees.paths = [ routees.paths = [
"pekko://app@10.0.0.1:2552/user/workers/w1", "pekko://app@10.0.0.1:7355/user/workers/w1",
"pekko://app@10.0.0.2:2552/user/workers/w1", "pekko://app@10.0.0.2:7355/user/workers/w1",
"pekko://app@10.0.0.3:2552/user/workers/w1"] "pekko://app@10.0.0.3:7355/user/workers/w1"]
} }
} }
#//#config-remote-round-robin-group-artery #//#config-remote-round-robin-group-artery

20
remote/src/main/resources/reference.conf
View file

@ -499,9 +499,9 @@ pekko {
applied-adapters = [] applied-adapters = []
# The default remote server port clients should connect to. # The default remote server port clients should connect to.
# Default is 2552 (AKKA), use 0 if you want a random available port # Default is 7355 (AKKA), use 0 if you want a random available port
# This port needs to be unique for each actor system on the same machine. # This port needs to be unique for each actor system on the same machine.
port = 2552 port = 7355
# The hostname or ip clients should connect to. # The hostname or ip clients should connect to.
# InetAddress.getLocalHost.getHostAddress is used if empty # InetAddress.getLocalHost.getHostAddress is used if empty
@ -512,29 +512,29 @@ pekko {
# when running pekko nodes in a separated networks (under NATs or docker containers). # when running pekko nodes in a separated networks (under NATs or docker containers).
# Use 0 if you want a random available port. Examples: # Use 0 if you want a random available port. Examples:
# #
# pekko.remote.classic.netty.tcp.port = 2552 # pekko.remote.classic.netty.tcp.port = 7355
# pekko.remote.classic.netty.tcp.bind-port = 2553 # pekko.remote.classic.netty.tcp.bind-port = 2553
# Network interface will be bound to the 2553 port, but remoting protocol will # Network interface will be bound to the 2553 port, but remoting protocol will
# expect messages sent to port 2552. # expect messages sent to port 7355.
# #
# pekko.remote.classic.netty.tcp.port = 0 # pekko.remote.classic.netty.tcp.port = 0
# pekko.remote.classic.netty.tcp.bind-port = 0 # pekko.remote.classic.netty.tcp.bind-port = 0
# Network interface will be bound to a random port, and remoting protocol will # Network interface will be bound to a random port, and remoting protocol will
# expect messages sent to the bound port. # expect messages sent to the bound port.
# #
# pekko.remote.classic.netty.tcp.port = 2552 # pekko.remote.classic.netty.tcp.port = 7355
# pekko.remote.classic.netty.tcp.bind-port = 0 # pekko.remote.classic.netty.tcp.bind-port = 0
# Network interface will be bound to a random port, but remoting protocol will # Network interface will be bound to a random port, but remoting protocol will
# expect messages sent to port 2552. # expect messages sent to port 7355.
# #
# pekko.remote.classic.netty.tcp.port = 0 # pekko.remote.classic.netty.tcp.port = 0
# pekko.remote.classic.netty.tcp.bind-port = 2553 # pekko.remote.classic.netty.tcp.bind-port = 2553
# Network interface will be bound to the 2553 port, and remoting protocol will # Network interface will be bound to the 2553 port, and remoting protocol will
# expect messages sent to the bound port. # expect messages sent to the bound port.
# #
# pekko.remote.classic.netty.tcp.port = 2552 # pekko.remote.classic.netty.tcp.port = 7355
# pekko.remote.classic.netty.tcp.bind-port = "" # pekko.remote.classic.netty.tcp.bind-port = ""
# Network interface will be bound to the 2552 port, and remoting protocol will # Network interface will be bound to the 7355 port, and remoting protocol will
# expect messages sent to the bound port. # expect messages sent to the bound port.
# #
# pekko.remote.classic.netty.tcp.port if empty # pekko.remote.classic.netty.tcp.port if empty
@ -760,9 +760,9 @@ pekko {
canonical { canonical {
# The default remote server port clients should connect to. # The default remote server port clients should connect to.
# Default is 25520, use 0 if you want a random available port # Default is 73550, use 0 if you want a random available port
# This port needs to be unique for each actor system on the same machine. # This port needs to be unique for each actor system on the same machine.
port = 25520 port = 73550
# Hostname clients should connect to. Can be set to an ip, hostname # Hostname clients should connect to. Can be set to an ip, hostname
# or one of the following special values: # or one of the following special values:

10
remote/src/test/scala/org/apache/pekko/remote/RemoteConsistentHashingRouterSpec.scala
View file

@ -29,11 +29,11 @@ class RemoteConsistentHashingRouterSpec
"use same hash ring independent of self address" in { "use same hash ring independent of self address" in {
// simulating running router on two different nodes (a1, a2) with target routees on 3 other nodes (s1, s2, s3) // simulating running router on two different nodes (a1, a2) with target routees on 3 other nodes (s1, s2, s3)
val a1 = Address("pekko", "Sys", "client1", 2552) val a1 = Address("pekko", "Sys", "client1", 7355)
val a2 = Address("pekko", "Sys", "client2", 2552) val a2 = Address("pekko", "Sys", "client2", 7355)
val s1 = ActorSelectionRoutee(system.actorSelection("pekko://Sys@server1:2552/user/a/b")) val s1 = ActorSelectionRoutee(system.actorSelection("pekko://Sys@server1:7355/user/a/b"))
val s2 = ActorSelectionRoutee(system.actorSelection("pekko://Sys@server2:2552/user/a/b")) val s2 = ActorSelectionRoutee(system.actorSelection("pekko://Sys@server2:7355/user/a/b"))
val s3 = ActorSelectionRoutee(system.actorSelection("pekko://Sys@server3:2552/user/a/b")) val s3 = ActorSelectionRoutee(system.actorSelection("pekko://Sys@server3:7355/user/a/b"))
val nodes1 = List(ConsistentRoutee(s1, a1), ConsistentRoutee(s2, a1), ConsistentRoutee(s3, a1)) val nodes1 = List(ConsistentRoutee(s1, a1), ConsistentRoutee(s2, a1), ConsistentRoutee(s3, a1))
val nodes2 = List(ConsistentRoutee(s1, a2), ConsistentRoutee(s2, a2), ConsistentRoutee(s3, a2)) val nodes2 = List(ConsistentRoutee(s1, a2), ConsistentRoutee(s2, a2), ConsistentRoutee(s3, a2))
val consistentHash1 = ConsistentHash(nodes1, 10) val consistentHash1 = ConsistentHash(nodes1, 10)

4
remote/src/test/scala/org/apache/pekko/remote/RemoteDeployerSpec.scala
View file

@ -29,7 +29,7 @@ object RemoteDeployerSpec {
/service2 { /service2 {
router = round-robin-pool router = round-robin-pool
nr-of-instances = 3 nr-of-instances = 3
remote = "pekko://sys@wallace:2552" remote = "pekko://sys@wallace:7355"
dispatcher = mydispatcher dispatcher = mydispatcher
} }
} }
@ -57,7 +57,7 @@ class RemoteDeployerSpec extends PekkoSpec(RemoteDeployerSpec.deployerConf) {
service, service,
deployment.get.config, deployment.get.config,
RoundRobinPool(3), RoundRobinPool(3),
RemoteScope(Address("pekko", "sys", "wallace", 2552)), RemoteScope(Address("pekko", "sys", "wallace", 7355)),
"mydispatcher"))) "mydispatcher")))
} }

4
remote/src/test/scala/org/apache/pekko/remote/artery/RemoteDeathWatchSpec.scala
View file

@ -94,7 +94,7 @@ class RemoteDeathWatchSpec
} }
"receive Terminated when watched node is unknown host" in { "receive Terminated when watched node is unknown host" in {
val path = RootActorPath(Address("pekko", system.name, "unknownhost", 2552)) / "user" / "subject" val path = RootActorPath(Address("pekko", system.name, "unknownhost", 7355)) / "user" / "subject"
system.actorOf(Props(new Actor { system.actorOf(Props(new Actor {
@nowarn @nowarn
@ -114,7 +114,7 @@ class RemoteDeathWatchSpec
// immediately in constructor from aeron.addPublication when UnknownHostException. That will trigger // immediately in constructor from aeron.addPublication when UnknownHostException. That will trigger
// this immediately. With TCP it will trigger after handshake timeout. Can we see the UnknownHostException // this immediately. With TCP it will trigger after handshake timeout. Can we see the UnknownHostException
// reason somehow and fail the stream immediately for that case? // reason somehow and fail the stream immediately for that case?
val path = RootActorPath(Address("pekko", system.name, "unknownhost2", 2552)) / "user" / "subject" val path = RootActorPath(Address("pekko", system.name, "unknownhost2", 7355)) / "user" / "subject"
system.actorSelection(path) ! Identify(path.toString) system.actorSelection(path) ! Identify(path.toString)
expectMsg(60.seconds, ActorIdentity(path.toString, None)) expectMsg(60.seconds, ActorIdentity(path.toString, None))
} }

4
remote/src/test/scala/org/apache/pekko/remote/artery/RemoteDeployerSpec.scala
View file

@ -28,7 +28,7 @@ object RemoteDeployerSpec {
/service2 { /service2 {
router = round-robin-pool router = round-robin-pool
nr-of-instances = 3 nr-of-instances = 3
remote = "pekko://sys@wallace:2552" remote = "pekko://sys@wallace:7355"
dispatcher = mydispatcher dispatcher = mydispatcher
} }
} }
@ -54,7 +54,7 @@ class RemoteDeployerSpec extends PekkoSpec(RemoteDeployerSpec.deployerConf) {
service, service,
deployment.get.config, deployment.get.config,
RoundRobinPool(3), RoundRobinPool(3),
RemoteScope(Address("pekko", "sys", "wallace", 2552)), RemoteScope(Address("pekko", "sys", "wallace", 7355)),
"mydispatcher"))) "mydispatcher")))
} }

4
remote/src/test/scala/org/apache/pekko/remote/classic/RemoteDeathWatchSpec.scala
View file

@ -101,7 +101,7 @@ pekko.actor.warn-about-java-serializer-usage = off
} }
"receive Terminated when watched node is unknown host" in { "receive Terminated when watched node is unknown host" in {
val path = RootActorPath(Address(protocol, system.name, "unknownhost", 2552)) / "user" / "subject" val path = RootActorPath(Address(protocol, system.name, "unknownhost", 7355)) / "user" / "subject"
system.actorOf(Props(new Actor { system.actorOf(Props(new Actor {
@nowarn @nowarn
@ -117,7 +117,7 @@ pekko.actor.warn-about-java-serializer-usage = off
} }
"receive ActorIdentity(None) when identified node is unknown host" in { "receive ActorIdentity(None) when identified node is unknown host" in {
val path = RootActorPath(Address(protocol, system.name, "unknownhost2", 2552)) / "user" / "subject" val path = RootActorPath(Address(protocol, system.name, "unknownhost2", 7355)) / "user" / "subject"
system.actorSelection(path) ! Identify(path) system.actorSelection(path) ! Identify(path)
expectMsg(60.seconds, ActorIdentity(path, None)) expectMsg(60.seconds, ActorIdentity(path, None))
} }

4
serialization-jackson/src/test/scala/org/apache/pekko/serialization/jackson/JacksonSerializerSpec.scala
View file

@ -856,7 +856,7 @@ abstract class JacksonSerializerSpec(serializerName: String)
} }
"serialize with Address" in { "serialize with Address" in {
val address = Address("pekko", "sys", "localhost", 2552) val address = Address("pekko", "sys", "localhost", 7355)
checkSerialization(new CommandWithAddress("echo", address)) checkSerialization(new CommandWithAddress("echo", address))
} }
@ -1082,7 +1082,7 @@ abstract class JacksonSerializerSpec(serializerName: String)
} }
"serialize with Address" in { "serialize with Address" in {
val address = Address("pekko", "sys", "localhost", 2552) val address = Address("pekko", "sys", "localhost", 7355)
checkSerialization(CommandWithAddress("echo", address)) checkSerialization(CommandWithAddress("echo", address))
} }