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

use pekko: in urls and fix other branding issues (#184)

Browse source 
* use pekko: in urls and fix other branding issues

* update comments

* fix artery test

* test changes

* scalafmt

* try to fix some tests and fixing more akka refs

* more akka refs

* more changes

* more akka refs

* Update LeaseMajoritySpec.scala

* Update docs/src/main/paradox/testing.md

Co-authored-by: Johannes Rudolph <johannes.rudolph@gmail.com>

* Update docs/src/main/paradox/project/migration-guides.md

Co-authored-by: Johannes Rudolph <johannes.rudolph@gmail.com>

* Update actor/src/main/scala/org/apache/pekko/serialization/Serialization.scala

Co-authored-by: Johannes Rudolph <johannes.rudolph@gmail.com>

* Update scripts/release-train-issue-template.md

Co-authored-by: Johannes Rudolph <johannes.rudolph@gmail.com>

* revert link-validation change

* Update JacksonModule.scala

* revert key name changes to fix 2 tests

* fix one test

* more test trouble

* more test issues

* fix hashing test

* Update RouterTest.java

* update code comment

---------

Co-authored-by: Johannes Rudolph <johannes.rudolph@gmail.com>
This commit is contained in:
PJ Fanning 2023-02-22 12:48:15 +01:00 • committed by GitHub
parent 5691328e02
commit 7e653454a9
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
157 changed files with 606 additions and 601 deletions
Download patch file Download diff file Expand all files Collapse all files

2
actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/ActorSystemStub.scala
View file

@ -51,7 +51,7 @@ import pekko.annotation.InternalApi
with ActorRefImpl[Nothing]
with InternalRecipientRef[Nothing] {
private val rootPath: ActorPath = classic.RootActorPath(classic.Address("akka", name))
private val rootPath: ActorPath = classic.RootActorPath(classic.Address("pekko", name))
override val path: classic.ActorPath = rootPath / "user"

2
actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/scaladsl/TestInbox.scala
View file

@ -30,7 +30,7 @@ object TestInbox {
new TestInboxImpl((address / name).withUid(uid))
}
private[pekko] val address = RootActorPath(Address("akka.actor.typed.inbox", "anonymous"))
private[pekko] val address = RootActorPath(Address("pekko.actor.typed.inbox", "anonymous"))
}
/**

2
actor-testkit-typed/src/test/scala/org/apache/pekko/actor/testkit/typed/scaladsl/BehaviorTestKitSpec.scala
View file

@ -179,7 +179,7 @@ class BehaviorTestKitSpec extends AnyWordSpec with Matchers with LogCapturing {
private val props = Props.empty.withDispatcherFromConfig("cat")
private val testKitAddress = Address("akka", "StubbedActorContext")
private val testKitAddress = Address("pekko", "StubbedActorContext")
"BehaviorTestKit" must {

4
actor-testkit-typed/src/test/scala/org/apache/pekko/actor/testkit/typed/scaladsl/LoggingEventFilterSpec.scala
View file

@ -134,12 +134,12 @@ class LoggingTestKitSpec extends ScalaTestWithActorTestKit with AnyWordSpecLike
LoggingTestKit.warn("this is another warning").matches(warningWithCause(new AnError)) should ===(false)
}
"filter warning with matching source" in {
val source = "akka://Sys/user/foo"
val source = "pekko://Sys/user/foo"
LoggingTestKit.empty.withLogLevel(Level.WARN).withSource(source).matches(warningWithSource(source)) should ===(
true)
LoggingTestKit.empty
.withLogLevel(Level.WARN)
.withSource("akka://Sys/user/bar")
.withSource("pekko://Sys/user/bar")
.matches(warningWithSource(source)) should ===(false)
}

2
actor-tests/src/test/java/org/apache/pekko/actor/AddressTest.java
View file

@ -24,7 +24,7 @@ public class AddressTest extends JUnitSuite {
@Test
public void portAddressAccessible() {
Address address = new Address("akka", "MySystem", "localhost", 2525);
Address address = new Address("pekko", "MySystem", "localhost", 2525);
assertEquals(Optional.of(2525), address.getPort());
assertEquals(Optional.of("localhost"), address.getHost());
}

2
actor-tests/src/test/java/org/apache/pekko/actor/JavaAPI.java
View file

@ -60,7 +60,7 @@ public class JavaAPI extends JUnitSuite {
final NoRouter nr = NoRouter.getInstance();
final FromConfig fc = FromConfig.getInstance();
final ActorPath p = ActorPaths.fromString("akka://Sys@localhost:1234/user/abc");
final ActorPath p = ActorPaths.fromString("pekko://Sys@localhost:1234/user/abc");
}
@Test

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

@ -23,12 +23,12 @@ class ActorPathSpec extends AnyWordSpec with Matchers {
"An ActorPath" must {
"support parsing its String rep" in {
val path = RootActorPath(Address("akka", "mysys")) / "user"
val path = RootActorPath(Address("pekko", "mysys")) / "user"
ActorPath.fromString(path.toString) should ===(path)
}
"support parsing remote paths" in {
val remote = "akka://my_sys@host:1234/some/ref"
val remote = "pekko://my_sys@host:1234/some/ref"
ActorPath.fromString(remote).toString should ===(remote)
}
@ -41,20 +41,20 @@ class ActorPathSpec extends AnyWordSpec with Matchers {
}
"create correct toString" in {
val a = Address("akka", "mysys")
RootActorPath(a).toString should ===("akka://mysys/")
(RootActorPath(a) / "user").toString should ===("akka://mysys/user")
(RootActorPath(a) / "user" / "foo").toString should ===("akka://mysys/user/foo")
(RootActorPath(a) / "user" / "foo" / "bar").toString should ===("akka://mysys/user/foo/bar")
val a = Address("pekko", "mysys")
RootActorPath(a).toString should ===("pekko://mysys/")
(RootActorPath(a) / "user").toString should ===("pekko://mysys/user")
(RootActorPath(a) / "user" / "foo").toString should ===("pekko://mysys/user/foo")
(RootActorPath(a) / "user" / "foo" / "bar").toString should ===("pekko://mysys/user/foo/bar")
}
"have correct path elements" in {
(RootActorPath(Address("akka", "mysys")) / "user" / "foo" / "bar").elements.toSeq should ===(
(RootActorPath(Address("pekko", "mysys")) / "user" / "foo" / "bar").elements.toSeq should ===(
Seq("user", "foo", "bar"))
}
"create correct toStringWithoutAddress" in {
val a = Address("akka", "mysys")
val a = Address("pekko", "mysys")
RootActorPath(a).toStringWithoutAddress should ===("/")
(RootActorPath(a) / "user").toStringWithoutAddress should ===("/user")
(RootActorPath(a) / "user" / "foo").toStringWithoutAddress should ===("/user/foo")
@ -67,65 +67,65 @@ class ActorPathSpec extends AnyWordSpec with Matchers {
}
"create correct toStringWithAddress" in {
val local = Address("akka", "mysys")
val local = Address("pekko", "mysys")
val a = local.copy(host = Some("aaa"), port = Some(2552))
val b = a.copy(host = Some("bb"))
val c = a.copy(host = Some("cccc"))
val root = RootActorPath(local)
root.toStringWithAddress(a) should ===("akka://mysys@aaa:2552/")
(root / "user").toStringWithAddress(a) should ===("akka://mysys@aaa:2552/user")
(root / "user" / "foo").toStringWithAddress(a) should ===("akka://mysys@aaa:2552/user/foo")
root.toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/")
(root / "user").toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/user")
(root / "user" / "foo").toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/user/foo")
// root.toStringWithAddress(b) should ===("akka://mysys@bb:2552/")
(root / "user").toStringWithAddress(b) should ===("akka://mysys@bb:2552/user")
(root / "user" / "foo").toStringWithAddress(b) should ===("akka://mysys@bb:2552/user/foo")
// root.toStringWithAddress(b) should ===("pekko://mysys@bb:2552/")
(root / "user").toStringWithAddress(b) should ===("pekko://mysys@bb:2552/user")
(root / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@bb:2552/user/foo")
root.toStringWithAddress(c) should ===("akka://mysys@cccc:2552/")
(root / "user").toStringWithAddress(c) should ===("akka://mysys@cccc:2552/user")
(root / "user" / "foo").toStringWithAddress(c) should ===("akka://mysys@cccc:2552/user/foo")
root.toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/")
(root / "user").toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/user")
(root / "user" / "foo").toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/user/foo")
val rootA = RootActorPath(a)
rootA.toStringWithAddress(b) should ===("akka://mysys@aaa:2552/")
(rootA / "user").toStringWithAddress(b) should ===("akka://mysys@aaa:2552/user")
(rootA / "user" / "foo").toStringWithAddress(b) should ===("akka://mysys@aaa:2552/user/foo")
rootA.toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/")
(rootA / "user").toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/user")
(rootA / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/user/foo")
}
"not allow path separators in RootActorPath's name" in {
intercept[IllegalArgumentException] {
RootActorPath(Address("akka", "mysys"), "/user/boom/*") // illegally pass in a path where name is expected
RootActorPath(Address("pekko", "mysys"), "/user/boom/*") // illegally pass in a path where name is expected
}.getMessage should include("is a path separator")
// check that creating such path still works
ActorPath.fromString("akka://mysys/user/boom/*")
ActorPath.fromString("pekko://mysys/user/boom/*")
}
"detect valid and invalid chars in host names when not using AddressFromURIString, e.g. docker host given name" in {
Seq(
Address("akka", "sys", "valid", 0),
Address("akka", "sys", "is_valid.org", 0),
Address("akka", "sys", "fu.is_valid.org", 0)).forall(_.hasInvalidHostCharacters) shouldBe false
Address("pekko", "sys", "valid", 0),
Address("pekko", "sys", "is_valid.org", 0),
Address("pekko", "sys", "fu.is_valid.org", 0)).forall(_.hasInvalidHostCharacters) shouldBe false
Seq(Address("akka", "sys", "in_valid", 0), Address("akka", "sys", "invalid._org", 0))
Seq(Address("pekko", "sys", "in_valid", 0), Address("pekko", "sys", "invalid._org", 0))
.forall(_.hasInvalidHostCharacters) shouldBe true
intercept[MalformedURLException](AddressFromURIString("akka://sys@in_valid:5001"))
intercept[MalformedURLException](AddressFromURIString("pekko://sys@in_valid:5001"))
}
"not fail fast if the check is called on valid chars in host names" in {
Seq(
Address("akka", "sys", "localhost", 0),
Address("akka", "sys", "is_valid.org", 0),
Address("akka", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
Address("pekko", "sys", "localhost", 0),
Address("pekko", "sys", "is_valid.org", 0),
Address("pekko", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
}
"fail fast if the check is called when invalid chars are in host names" in {
Seq(
Address("akka", "sys", "localhost", 0),
Address("akka", "sys", "is_valid.org", 0),
Address("akka", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
Address("pekko", "sys", "localhost", 0),
Address("pekko", "sys", "is_valid.org", 0),
Address("pekko", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
intercept[IllegalArgumentException](Address("akka", "sys", "in_valid", 0).checkHostCharacters())
intercept[IllegalArgumentException](Address("akka", "sys", "invalid._org", 0).checkHostCharacters())
intercept[IllegalArgumentException](Address("pekko", "sys", "in_valid", 0).checkHostCharacters())
intercept[IllegalArgumentException](Address("pekko", "sys", "invalid._org", 0).checkHostCharacters())
}
}
}

19
actor-tests/src/test/scala/org/apache/pekko/actor/ActorSelectionSpec.scala
View file

@ -179,8 +179,8 @@ class ActorSelectionSpec extends PekkoSpec with DefaultTimeout {
"return ActorIdentity(None), respectively, for non-existing paths, and deadLetters" in {
identify("a/b/c") should ===(None)
identify("a/b/c") should ===(None)
identify("akka://all-systems/Nobody") should ===(None)
identify("akka://all-systems/user") should ===(None)
identify("pekko://all-systems/Nobody") should ===(None)
identify("pekko://all-systems/user") should ===(None)
identify(system / "hallo") should ===(None)
identify("foo://user") should ===(None)
identify("/deadLetters") should ===(None)
@ -265,7 +265,7 @@ class ActorSelectionSpec extends PekkoSpec with DefaultTimeout {
def check(looker: ActorRef): Unit = {
for ((l, r) <- Seq(
SelectString("a/b/c") -> None,
SelectString("akka://all-systems/Nobody") -> None,
SelectString("pekko://all-systems/Nobody") -> None,
SelectPath(system / "hallo") -> None,
SelectPath(looker.path.child("hallo")) -> None, // test Java API
SelectPath(looker.path.descendant(Seq("a", "b").asJava)) -> None) // test Java API
@ -345,16 +345,17 @@ class ActorSelectionSpec extends PekkoSpec with DefaultTimeout {
"print nicely" in {
ActorSelection(c21, "../*/hello").toString should ===(
s"ActorSelection[Anchor(akka://ActorSelectionSpec/user/c2/c21#${c21.path.uid}), Path(/../*/hello)]")
s"ActorSelection[Anchor(pekko://ActorSelectionSpec/user/c2/c21#${c21.path.uid}), Path(/../*/hello)]")
}
"have a stringly serializable path" in {
system.actorSelection(system / "c2").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2")
system.actorSelection(system / "c2").toSerializationFormat should ===("pekko://ActorSelectionSpec/user/c2")
system.actorSelection(system / "c2" / "c21").toSerializationFormat should ===(
"akka://ActorSelectionSpec/user/c2/c21")
ActorSelection(c2, "/").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2")
ActorSelection(c2, "../*/hello").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2/../*/hello")
ActorSelection(c2, "/../*/hello").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2/../*/hello")
"pekko://ActorSelectionSpec/user/c2/c21")
ActorSelection(c2, "/").toSerializationFormat should ===("pekko://ActorSelectionSpec/user/c2")
ActorSelection(c2, "../*/hello").toSerializationFormat should ===("pekko://ActorSelectionSpec/user/c2/../*/hello")
ActorSelection(c2, "/../*/hello").toSerializationFormat should ===(
"pekko://ActorSelectionSpec/user/c2/../*/hello")
}
"send ActorSelection targeted to missing actor to deadLetters" in {

4
actor-tests/src/test/scala/org/apache/pekko/actor/ActorSystemSpec.scala
View file

@ -159,11 +159,11 @@ class ActorSystemSpec extends PekkoSpec(ActorSystemSpec.config) with ImplicitSen
a.tell("run", probe.ref)
probe.expectTerminated(a)
EventFilter
.info(pattern = """from Actor\[akka://LogDeadLetters/system/testProbe.*not delivered""", occurrences = 1)
.info(pattern = """from Actor\[pekko://LogDeadLetters/system/testProbe.*not delivered""", occurrences = 1)
.intercept {
EventFilter
.warning(
pattern = """received dead letter from Actor\[akka://LogDeadLetters/system/testProbe""",
pattern = """received dead letter from Actor\[pekko://LogDeadLetters/system/testProbe""",
occurrences = 1)
.intercept {
a.tell("boom", probe.ref)

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 {
"find child actor with URL encoded name" in {
val childName = "akka%3A%2F%2FClusterSystem%40127.0.0.1%3A2552"
val childName = "pekko%3A%2F%2FClusterSystem%40127.0.0.1%3A2552"
val a = system.actorOf(Props(new Actor {
val child = context.actorOf(Props.empty, name = childName)
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"))
}
"match url encoded name" in {
val name = URLEncoder.encode("akka://ClusterSystem@127.0.0.1:2552", "UTF-8")
val name = URLEncoder.encode("pekko://ClusterSystem@127.0.0.1:2552", "UTF-8")
elements(name) should ===(List(name))
}
"match path with uid fragment" in {

14
actor-typed-tests/src/test/java/jdocs/org/apache/pekko/typed/RouterTest.java
View file

@ -228,16 +228,22 @@ public class RouterTest extends JUnitSuite {
Routers.group(proxy.registeringKey)
.withConsistentHashingRouting(10, command -> proxy.mapping(command)));
router.tell(new Proxy.Message("123", "Text1"));
router.tell(new Proxy.Message("123", "Text2"));
final String id1 = "123";
router.tell(new Proxy.Message(id1, "Text1"));
router.tell(new Proxy.Message(id1, "Text2"));
router.tell(new Proxy.Message("zh3", "Text3"));
router.tell(new Proxy.Message("zh3", "Text4"));
final String id2 = "abcdef";
router.tell(new Proxy.Message(id2, "Text3"));
router.tell(new Proxy.Message(id2, "Text4"));
// the hash is calculated over the Proxy.Message first parameter obtained through the
// Proxy.mapping function
// #consistent-hashing
// Then messages with equal Message.id reach the same actor
// so the first message in each probe queue is equal to its second
// NB: this test can start failing if you change the actor path (eg the URL scheme) due to
// these values being hashed (and depending on the resulting hash output its possible to
// change the distribution of actors in the ring which the test relies on)
// - to fix you will need to change id2 value until it starts passing again
probe1.expectMessage(probe1.receiveMessage());
probe2.expectMessage(probe2.receiveMessage());
}

4
actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/ActorRefResolverSpec.scala
View file

@ -33,7 +33,7 @@ class ActorRefResolverSpec extends AnyWordSpec with ScalaFutures with Matchers {
try {
val ref1 = system1.systemActorOf(Behaviors.empty, "ref1")
val serialized = ActorRefResolver(system1).toSerializationFormat(ref1)
serialized should startWith("akka://sys1/")
serialized should startWith("pekko://sys1/")
intercept[IllegalArgumentException] {
// wrong system
@ -49,7 +49,7 @@ class ActorRefResolverSpec extends AnyWordSpec with ScalaFutures with Matchers {
}
val minRef1Serialized = ActorRefResolver(system2).toSerializationFormat(minRef1)
minRef1Serialized should startWith("akka://sys2/")
minRef1Serialized should startWith("pekko://sys2/")
} finally {
system1.terminate()

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

@ -68,7 +68,7 @@ class LocalActorRefProviderLogMessagesSpec
val provider = system.asInstanceOf[ActorSystemAdapter[_]].provider
try {
LoggingTestKit
.debug("Resolve (deserialization) of foreign path [akka://otherSystem/user/foo]")
.debug("Resolve (deserialization) of foreign path [pekko://otherSystem/user/foo]")
.withLoggerName("org.apache.pekko.actor.LocalActorRefProvider.Deserialization")
.expect {
provider.resolveActorRef(invalidPath)

2
actor-typed-tests/src/test/scala/org/apache/pekko/actor/typed/internal/ActorSystemSpec.scala
View file

@ -181,7 +181,7 @@ class ActorSystemSpec
"return default address " in {
withSystem("address", Behaviors.empty[String]) { sys =>
sys.address shouldBe Address("akka", "adapter-address")
sys.address shouldBe Address("pekko", "adapter-address")
}
}

2
actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/ActorContextImpl.scala
View file

@ -60,7 +60,7 @@ import scala.util.Success
val pekkoAddress =
ctx.system match {
case adapter: ActorSystemAdapter[_] => adapter.provider.addressString
case _ => Address("akka", ctx.system.name).toString
case _ => Address("pekko", ctx.system.name).toString
}
val sourceActorSystem = ctx.system.name

2
actor-typed/src/main/scala/org/apache/pekko/actor/typed/internal/adapter/ActorSystemAdapter.scala
View file

@ -82,7 +82,7 @@ import pekko.annotation.InternalApi
def isTerminated: Boolean = whenTerminated.isCompleted
final override val path: classic.ActorPath =
classic.RootActorPath(classic.Address("akka", system.name)) / "user"
classic.RootActorPath(classic.Address("pekko", system.name)) / "user"
override def toString: String = system.toString

4
actor/src/main/scala/org/apache/pekko/actor/ActorRef.scala
View file

@ -325,7 +325,7 @@ private[pekko] abstract class ActorRefWithCell extends InternalActorRef { this:
* This is an internal look-up failure token, not useful for anything else.
*/
private[pekko] case object Nobody extends MinimalActorRef {
override val path: RootActorPath = new RootActorPath(Address("akka", "all-systems"), "/Nobody")
override val path: RootActorPath = new RootActorPath(Address("pekko", "all-systems"), "/Nobody")
override def provider = throw new UnsupportedOperationException("Nobody does not provide")
private val serialized = new SerializedNobody
@ -543,7 +543,7 @@ private[pekko] trait MinimalActorRef extends InternalActorRef with LocalRef {
private val fakeSystemName = "local"
val path: ActorPath =
RootActorPath(Address("akka", IgnoreActorRef.fakeSystemName)) / "ignore"
RootActorPath(Address("pekko", IgnoreActorRef.fakeSystemName)) / "ignore"
private val pathString = path.toString

2
actor/src/main/scala/org/apache/pekko/actor/ActorRefProvider.scala
View file

@ -399,7 +399,7 @@ private[pekko] class LocalActorRefProvider private[pekko] (
dynamicAccess: DynamicAccess) =
this(_systemName, settings, eventStream, dynamicAccess, new Deployer(settings, dynamicAccess), None)
override val rootPath: ActorPath = RootActorPath(Address("akka", _systemName))
override val rootPath: ActorPath = RootActorPath(Address("pekko", _systemName))
private[pekko] val log: MarkerLoggingAdapter =
Logging.withMarker(eventStream, classOf[LocalActorRefProvider])

2
actor/src/main/scala/org/apache/pekko/actor/ActorSystem.scala
View file

@ -395,7 +395,7 @@ object ActorSystem {
ConfigFactory
.defaultReference(classLoader)
.withoutPath(Dispatchers.InternalDispatcherId), // allow this to be both string and config object
"akka")
"pekko")
cfg
}

4
actor/src/main/scala/org/apache/pekko/actor/Address.scala
View file

@ -189,10 +189,10 @@ object AddressFromURIString {
def unapply(uri: URI): Option[Address] =
if (uri eq null) None
else if (uri.getScheme == null || (uri.getUserInfo == null && uri.getHost == null)) None
else if (uri.getUserInfo == null) { // case 1: “akka://system”
else if (uri.getUserInfo == null) { // case 1: “pekko://system”
if (uri.getPort != -1) None
else Some(Address(uri.getScheme, uri.getHost))
} else { // case 2: “akka://system@host:port”
} else { // case 2: “pekko://system@host:port”
if (uri.getHost == null || uri.getPort == -1) None
else
Some(

4
actor/src/main/scala/org/apache/pekko/event/Logging.scala
View file

@ -269,7 +269,7 @@ trait LoggingBus extends ActorEventBus {
*
* class MyClass extends MyType {
* val sys = ActorSystem("sys")
* val log = Logging(sys, this) // will use "hallo,akka://sys" as logSource
* val log = Logging(sys, this) // will use "hallo,pekko://sys" as logSource
* def name = "hallo"
* }
* }}}
@ -1113,7 +1113,7 @@ object Logging {
* <code>pekko.stdout-loglevel</code>.
*/
class StandardOutLogger extends MinimalActorRef with StdOutLogger {
val path: ActorPath = RootActorPath(Address("akka", "all-systems"), "/StandardOutLogger")
val path: ActorPath = RootActorPath(Address("pekko", "all-systems"), "/StandardOutLogger")
def provider: ActorRefProvider = throw new UnsupportedOperationException("StandardOutLogger does not provide")
override val toString = "StandardOutLogger"
override def !(message: Any)(implicit sender: ActorRef = Actor.noSender): Unit =

2
actor/src/main/scala/org/apache/pekko/io/InetAddressDnsResolver.scala
View file

@ -150,7 +150,7 @@ class InetAddressDnsResolver(cache: SimpleDnsCache, config: Config) extends Acto
}
sender() ! answer
case Dns.Resolve(name) =>
// no where in akka now sends this message, but supported until Dns.Resolve/Resolved have been removed
// no where in pekko now sends this message, but supported until Dns.Resolve/Resolved have been removed
val answer: Dns.Resolved = cache.cached(name) match {
case Some(a) => a
case None =>

2
actor/src/main/scala/org/apache/pekko/io/dns/internal/AsyncDnsManager.scala
View file

@ -109,7 +109,7 @@ private[io] final class AsyncDnsManager(
resolver.forward(r)
case Dns.Resolve(name) =>
// adapt legacy protocol to new protocol and back again, no where in akka
// adapt legacy protocol to new protocol and back again, no where in pekko
// sends this message but supported until the old messages are removed
log.debug("(deprecated) Resolution request for {} from {}", name, sender())
val adapted = DnsProtocol.Resolve(name)

2
actor/src/main/scala/org/apache/pekko/serialization/AsyncSerializer.scala
View file

@ -57,7 +57,7 @@ abstract class AsyncSerializerWithStringManifest(system: ExtendedActorSystem)
final override def toBinary(o: AnyRef): Array[Byte] = {
log.warning(
"Async serializer called synchronously. This will block. Async serializers should only be used for akka persistence plugins that support them. Class: {}",
"Async serializer called synchronously. This will block. Async serializers should only be used for pekko persistence plugins that support them. Class: {}",
o.getClass)
Await.result(toBinaryAsync(o), Duration.Inf)
}

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"))
var set1Size = 0
val nodeA = UniqueAddress(Address("akka", "Sys", "aaaa", 2552), 1L)
val nodeA = UniqueAddress(Address("pekko", "Sys", "aaaa", 2552), 1L)
val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2L)
val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3L)
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"))
var size = 0
val nodeA = UniqueAddress(Address("akka", "Sys", "aaaa", 2552), 1L)
val nodeA = UniqueAddress(Address("pekko", "Sys", "aaaa", 2552), 1L)
val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2L)
val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3L)
val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4L)

2
bench-jmh/src/main/scala/org/apache/pekko/remote/artery/LiteralEncodingBenchmark.scala
View file

@ -31,7 +31,7 @@ import org.apache.pekko.util.Unsafe
class LiteralEncodingBenchmark {
private val UsAscii = Charset.forName("US-ASCII")
private val str = "akka://SomeSystem@host12:1234/user/foo"
private val str = "pekko://SomeSystem@host12:1234/user/foo"
private val buffer = ByteBuffer.allocate(128).order(ByteOrder.LITTLE_ENDIAN)
private val literalChars = Array.ofDim[Char](64)
private val literalBytes = Array.ofDim[Byte](64)

8
cluster-metrics/src/test/scala/org/apache/pekko/cluster/metrics/ClusterMetricsRoutingSpec.scala
View file

@ -28,10 +28,10 @@ class MetricsSelectorSpec extends AnyWordSpec with Matchers {
override def capacity(nodeMetrics: Set[NodeMetrics]): Map[Address, Double] = Map.empty
}
val a1 = Address("akka", "sys", "a1", 2551)
val b1 = Address("akka", "sys", "b1", 2551)
val c1 = Address("akka", "sys", "c1", 2551)
val d1 = Address("akka", "sys", "d1", 2551)
val a1 = Address("pekko", "sys", "a1", 2551)
val b1 = Address("pekko", "sys", "b1", 2551)
val c1 = Address("pekko", "sys", "c1", 2551)
val d1 = Address("pekko", "sys", "d1", 2551)
val decayFactor = Some(0.18)

32
cluster-metrics/src/test/scala/org/apache/pekko/cluster/metrics/MetricSpec.scala
View file

@ -69,8 +69,8 @@ class MetricNumericConverterSpec extends AnyWordSpec with Matchers with MetricNu
@nowarn
class NodeMetricsSpec extends AnyWordSpec with Matchers {
val node1 = Address("akka", "sys", "a", 2554)
val node2 = Address("akka", "sys", "a", 2555)
val node1 = Address("pekko", "sys", "a", 2554)
val node2 = Address("pekko", "sys", "a", 2555)
"NodeMetrics must" must {
@ -162,8 +162,8 @@ class MetricsGossipSpec
"A MetricsGossip" must {
"add new NodeMetrics" in {
val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("pekko", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
m1.metrics.size should be > 3
m2.metrics.size should be > 3
@ -179,8 +179,8 @@ class MetricsGossipSpec
}
"merge peer metrics" in {
val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("pekko", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val g1 = MetricsGossip.empty :+ m1 :+ m2
g1.nodes.size should ===(2)
@ -194,9 +194,9 @@ class MetricsGossipSpec
}
"merge an existing metric set for a node and update node ring" in {
val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val m3 = NodeMetrics(Address("akka", "sys", "a", 2556), newTimestamp, collector.sample().metrics)
val m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("pekko", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val m3 = NodeMetrics(Address("pekko", "sys", "a", 2556), newTimestamp, collector.sample().metrics)
val m2Updated = m2.copy(metrics = newSample(m2.metrics), timestamp = m2.timestamp + 1000)
val g1 = MetricsGossip.empty :+ m1 :+ m2
@ -215,14 +215,14 @@ class MetricsGossipSpec
}
"get the current NodeMetrics if it exists in the local nodes" in {
val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val g1 = MetricsGossip.empty :+ m1
g1.nodeMetricsFor(m1.address).map(_.metrics) should ===(Some(m1.metrics))
}
"remove a node if it is no longer Up" in {
val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("pekko", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val g1 = MetricsGossip.empty :+ m1 :+ m2
g1.nodes.size should ===(2)
@ -234,8 +234,8 @@ class MetricsGossipSpec
}
"filter nodes" in {
val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
val m2 = NodeMetrics(Address("pekko", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
val g1 = MetricsGossip.empty :+ m1 :+ m2
g1.nodes.size should ===(2)
@ -254,8 +254,8 @@ class MetricValuesSpec extends PekkoSpec(MetricsConfig.defaultEnabled) with Metr
val collector = createMetricsCollector
val node1 = NodeMetrics(Address("akka", "sys", "a", 2554), 1, collector.sample().metrics)
val node2 = NodeMetrics(Address("akka", "sys", "a", 2555), 1, collector.sample().metrics)
val node1 = NodeMetrics(Address("pekko", "sys", "a", 2554), 1, collector.sample().metrics)
val node2 = NodeMetrics(Address("pekko", "sys", "a", 2555), 1, collector.sample().metrics)
val nodes: Seq[NodeMetrics] = {
(1 to 100).foldLeft(List(node1, node2)) { (nodes, _) =>

2
cluster-metrics/src/test/scala/org/apache/pekko/cluster/metrics/TestUtil.scala
View file

@ -147,7 +147,7 @@ trait MetricsCollectorFactory { this: PekkoSpec =>
*/
class MockitoSigarMetricsCollector(system: ActorSystem)
extends SigarMetricsCollector(
Address(if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka" else "akka.tcp", system.name),
Address(if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko" else "pekko.tcp", system.name),
MetricsConfig.defaultDecayFactor,
MockitoSigarProvider().createSigarInstance) {}

4
cluster-metrics/src/test/scala/org/apache/pekko/cluster/metrics/WeightedRouteesSpec.scala
View file

@ -32,8 +32,8 @@ class WeightedRouteesSpec extends PekkoSpec(ConfigFactory.parseString("""
""")) {
val protocol =
if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka"
else "akka.tcp"
if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko"
else "pekko.tcp"
val a1 = Address(protocol, "sys", "a1", 2551)
val b1 = Address(protocol, "sys", "b1", 2551)

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._
val a1 = TestMember(Address("akka", "sys", "a", 2552), Joining, Set.empty)
val b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set("r1"))
val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving, Set("r2"))
val d1 = TestMember(Address("akka", "sys", "d", 2552), Exiting, Set("r1", "r2"))
val e1 = TestMember(Address("akka", "sys", "e", 2552), Down, Set("r3"))
val f1 = TestMember(Address("akka", "sys", "f", 2552), Removed, Set("r2", "r3"))
val a1 = TestMember(Address("pekko", "sys", "a", 2552), Joining, Set.empty)
val b1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set("r1"))
val c1 = TestMember(Address("pekko", "sys", "c", 2552), Leaving, Set("r2"))
val d1 = TestMember(Address("pekko", "sys", "d", 2552), Exiting, Set("r1", "r2"))
val e1 = TestMember(Address("pekko", "sys", "e", 2552), Down, Set("r3"))
val f1 = TestMember(Address("pekko", "sys", "f", 2552), Removed, Set("r2", "r3"))
"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 =
ExternalShardAllocation.get(system).getClient(typeKey.name());
CompletionStage<Done> done =
client.setShardLocation("shard-id-1", new Address("akka", "system", "127.0.0.1", 2552));
client.setShardLocation("shard-id-1", new Address("pekko", "system", "127.0.0.1", 2552));
// #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
val client: ExternalShardAllocationClient = ExternalShardAllocation(system).clientFor(TypeKey.name)
val done: Future[Done] = client.updateShardLocation("shard-id-1", Address("akka", "system", "127.0.0.1", 2552))
val done: Future[Done] = client.updateShardLocation("shard-id-1", Address("pekko", "system", "127.0.0.1", 2552))
// #client
}

2
cluster-sharding/src/test/scala/org/apache/pekko/cluster/sharding/DeprecatedLeastShardAllocationStrategySpec.scala
View file

@ -259,7 +259,7 @@ class DeprecatedLeastShardAllocationStrategySpec extends PekkoSpec {
val member1 = newUpMember("127.0.0.1")
val member2 =
Member(
UniqueAddress(Address("akka", "myapp", "127.0.0.2", 252525), 1L),
UniqueAddress(Address("pekko", "myapp", "127.0.0.2", 252525), 1L),
Set(ClusterSettings.DcRolePrefix + ClusterSettings.DefaultDataCenter),
member1.appVersion)

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

@ -40,7 +40,7 @@ import scala.collection.immutable.SortedSet
object LeastShardAllocationStrategySpec {
private object DummyActorRef extends MinimalActorRef {
override val path: ActorPath = RootActorPath(Address("akka", "myapp")) / "system" / "fake"
override val path: ActorPath = RootActorPath(Address("pekko", "myapp")) / "system" / "fake"
override def provider: ActorRefProvider = ???
}
@ -81,7 +81,7 @@ object LeastShardAllocationStrategySpec {
def newUpMember(host: String, port: Int = 252525, version: Version = Version("1.0.0")) =
Member(
UniqueAddress(Address("akka", "myapp", host, port), 1L),
UniqueAddress(Address("pekko", "myapp", host, port), 1L),
Set(ClusterSettings.DcRolePrefix + ClusterSettings.DefaultDataCenter),
version).copy(MemberStatus.Up)
@ -314,7 +314,7 @@ class LeastShardAllocationStrategySpec extends PekkoSpec {
val member1 = newUpMember("127.0.0.1")
val member2 =
Member(
UniqueAddress(Address("akka", "myapp", "127.0.0.2", 252525), 1L),
UniqueAddress(Address("pekko", "myapp", "127.0.0.2", 252525), 1L),
Set(ClusterSettings.DcRolePrefix + ClusterSettings.DefaultDataCenter),
member1.appVersion)

4
cluster-sharding/src/test/scala/org/apache/pekko/cluster/sharding/ProxyShardingSpec.scala
View file

@ -60,7 +60,7 @@ class ProxyShardingSpec extends PekkoSpec(ProxyShardingSpec.config) with WithLog
"Proxy should be found" in {
val proxyActor: ActorRef = Await.result(
system
.actorSelection("akka://ProxyShardingSpec/system/sharding/myTypeProxy")
.actorSelection("pekko://ProxyShardingSpec/system/sharding/myTypeProxy")
.resolveOne(FiniteDuration(5, SECONDS)),
3.seconds)
@ -80,7 +80,7 @@ class ProxyShardingSpec extends PekkoSpec(ProxyShardingSpec.config) with WithLog
val shardCoordinator: ActorRef =
Await.result(
system
.actorSelection("akka://ProxyShardingSpec/system/sharding/myTypeCoordinator")
.actorSelection("pekko://ProxyShardingSpec/system/sharding/myTypeCoordinator")
.resolveOne(FiniteDuration(5, SECONDS)),
3.seconds)

4
cluster-sharding/src/test/scala/org/apache/pekko/cluster/sharding/RememberEntitiesShardIdExtractorChangeSpec.scala
View file

@ -124,8 +124,8 @@ class RememberEntitiesShardIdExtractorChangeSpec
withSystem("ThirdIncarnation", secondExtractShardId) { (system, region) =>
val probe = TestProbe()(system)
// Only way to verify that they were "normal"-remember-started here is to look at debug logs, will show
// [akka://ThirdIncarnation@127.0.0.1:51533/system/sharding/ShardIdExtractorChange/1/RememberEntitiesStore] Recovery completed for shard [1] with [0] entities
// [akka://ThirdIncarnation@127.0.0.1:51533/system/sharding/ShardIdExtractorChange/2/RememberEntitiesStore] Recovery completed for shard [2] with [3] entities
// [pekko://ThirdIncarnation@127.0.0.1:51533/system/sharding/ShardIdExtractorChange/1/RememberEntitiesStore] Recovery completed for shard [1] with [0] entities
// [pekko://ThirdIncarnation@127.0.0.1:51533/system/sharding/ShardIdExtractorChange/2/RememberEntitiesStore] Recovery completed for shard [2] with [3] entities
awaitAssert {
region.tell(ShardRegion.GetShardRegionState, probe.ref)
val state = probe.expectMsgType[ShardRegion.CurrentShardRegionState]

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 {
checkSerialization(ShardRegion.GetCurrentRegions)
checkSerialization(
ShardRegion.CurrentRegions(Set(Address("akka", "sys", "a", 2552), Address("akka", "sys", "b", 2552))))
ShardRegion.CurrentRegions(Set(Address("pekko", "sys", "a", 2552), Address("pekko", "sys", "b", 2552))))
}
"be able to serialize GetClusterShardingStats" in {
checkSerialization(ShardRegion.GetClusterShardingStats(3.seconds))
checkSerialization(
ShardRegion.ClusterShardingStats(Map(
Address("akka", "sys", "a", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")),
Address("akka", "sys", "b", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")))))
Address("pekko", "sys", "a", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")),
Address("pekko", "sys", "b", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")))))
}
}
}

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

@ -98,7 +98,7 @@ pekko.cluster.client {
# that the client will try to contact initially. It is mandatory to specify
# at least one initial contact.
# Comma separated full actor paths defined by a string on the form of
# "akka://system@hostname:port/system/receptionist"
# "pekko://system@hostname:port/system/receptionist"
initial-contacts = []
# Interval at which the client retries to establish contact with one of

2
cluster-tools/src/main/scala/org/apache/pekko/cluster/client/ClusterClient.scala
View file

@ -105,7 +105,7 @@ object ClusterClientSettings {
* the servers (cluster nodes) that the client will try to contact initially.
* It is mandatory to specify at least one initial contact. The path of the
* default receptionist is
* "akka://system@hostname:port/system/receptionist"
* "pekko://system@hostname:port/system/receptionist"
* @param establishingGetContactsInterval Interval at which the client retries
* to establish contact with one of ClusterReceptionist on the servers (cluster nodes)
* @param refreshContactsInterval Interval at which the client will ask the

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
// #initialContacts
val initialContacts = Set(
ActorPath.fromString("akka://OtherSys@host1:2552/system/receptionist"),
ActorPath.fromString("akka://OtherSys@host2:2552/system/receptionist"))
ActorPath.fromString("pekko://OtherSys@host1:2552/system/receptionist"),
ActorPath.fromString("pekko://OtherSys@host2:2552/system/receptionist"))
val settings = ClusterClientSettings(system).withInitialContacts(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() {
return new HashSet<ActorPath>(
Arrays.asList(
ActorPaths.fromString("akka://OtherSys@host1:2552/system/receptionist"),
ActorPaths.fromString("akka://OtherSys@host2:2552/system/receptionist")));
ActorPaths.fromString("pekko://OtherSys@host1:2552/system/receptionist"),
ActorPaths.fromString("pekko://OtherSys@host2:2552/system/receptionist")));
}
// #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 {
val contactPoints = Vector(
"akka://system@node-1:2552/system/receptionist",
"akka://system@node-2:2552/system/receptionist",
"akka://system@node-3:2552/system/receptionist")
"pekko://system@node-1:2552/system/receptionist",
"pekko://system@node-2:2552/system/receptionist",
"pekko://system@node-3:2552/system/receptionist")
checkSerialization(Contacts(contactPoints))
checkSerialization(GetContacts)
checkSerialization(Heartbeat)

6
cluster-tools/src/test/scala/org/apache/pekko/cluster/pubsub/protobuf/DistributedPubSubMessageSerializerSpec.scala
View file

@ -35,9 +35,9 @@ class DistributedPubSubMessageSerializerSpec extends PekkoSpec {
" DistributedPubSubMessages" must {
"be serializable" in {
val address1 = Address("akka", "system", "some.host.org", 4711)
val address2 = Address("akka", "system", "other.host.org", 4711)
val address3 = Address("akka", "system", "some.host.org", 4712)
val address1 = Address("pekko", "system", "some.host.org", 4711)
val address2 = Address("pekko", "system", "other.host.org", 4711)
val address3 = Address("pekko", "system", "some.host.org", 4712)
val u1 = system.actorOf(Props.empty, "u1")
val u2 = system.actorOf(Props.empty, "u2")
val u3 = system.actorOf(Props.empty, "u3")

2
cluster-tools/src/test/scala/org/apache/pekko/cluster/singleton/ClusterSingletonLeaseSpec.scala
View file

@ -88,7 +88,7 @@ class ClusterSingletonLeaseSpec extends PekkoSpec(ConfigFactory.parseString("""
def nextSettings() = ClusterSingletonManagerSettings(system).withSingletonName(nextName())
def leaseNameFor(settings: ClusterSingletonManagerSettings): String =
s"ClusterSingletonLeaseSpec-singleton-akka://ClusterSingletonLeaseSpec/user/${settings.singletonName}"
s"ClusterSingletonLeaseSpec-singleton-pekko://ClusterSingletonLeaseSpec/user/${settings.singletonName}"
"A singleton with lease" should {

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

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

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

@ -52,8 +52,8 @@ pekko {
cluster {
seed-nodes = [
"akka://ClusterSystem@127.0.0.1:2551",
"akka://ClusterSystem@127.0.0.1:2552"]
"pekko://ClusterSystem@127.0.0.1:2551",
"pekko://ClusterSystem@127.0.0.1:2552"]
downing-provider-class = "org.apache.pekko.cluster.sbr.SplitBrainResolverProvider"
}
@ -75,7 +75,8 @@ pekko {
import pekko.cluster.typed.JoinSeedNodes
val seedNodes: List[Address] =
List("akka://ClusterSystem@127.0.0.1:2551", "akka://ClusterSystem@127.0.0.1:2552").map(AddressFromURIString.parse)
List("pekko://ClusterSystem@127.0.0.1:2551", "pekko://ClusterSystem@127.0.0.1:2552").map(
AddressFromURIString.parse)
Cluster(system).manager ! JoinSeedNodes(seedNodes)
// #join-seed-nodes
}
@ -133,7 +134,7 @@ class BasicClusterConfigSpec extends AnyWordSpec with ScalaFutures with Eventual
pekko.remote.classic.netty.tcp.port = $port
pekko.remote.artery.canonical.port = $port
pekko.cluster.jmx.multi-mbeans-in-same-jvm = on
pekko.cluster.seed-nodes = [ "akka://ClusterSystem@127.0.0.1:$sys1Port", "akka://ClusterSystem@127.0.0.1:$sys2Port" ]
pekko.cluster.seed-nodes = [ "pekko://ClusterSystem@127.0.0.1:$sys1Port", "pekko://ClusterSystem@127.0.0.1:$sys2Port" ]
""")
val system1 =

2
cluster-typed/src/test/scala/org/apache/pekko/cluster/typed/ClusterApiSpec.scala
View file

@ -53,7 +53,7 @@ class ClusterApiSpec extends ScalaTestWithActorTestKit(ClusterApiSpec.config) wi
"A typed Cluster" must {
"fail fast in a join attempt if invalid chars are in host names, e.g. docker host given name" in {
val address = Address("akka", "sys", Some("in_valid"), Some(0))
val address = Address("pekko", "sys", Some("in_valid"), Some(0))
intercept[IllegalArgumentException](Join(address))
intercept[IllegalArgumentException](JoinSeedNodes(scala.collection.immutable.Seq(address)))
}

2
cluster-typed/src/test/scala/org/apache/pekko/cluster/typed/RemoteDeployNotAllowedSpec.scala
View file

@ -45,7 +45,7 @@ object RemoteDeployNotAllowedSpec {
def configWithRemoteDeployment(otherSystemPort: Int) = ConfigFactory.parseString(s"""
pekko.actor.deployment {
"/*" {
remote = "akka://sampleActorSystem@127.0.0.1:$otherSystemPort"
remote = "pekko://sampleActorSystem@127.0.0.1:$otherSystemPort"
}
}
""").withFallback(config)

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

@ -11,7 +11,7 @@ pekko {
# 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://system@hostname:port"
# "pekko://system@hostname:port"
# Leave as empty if the node is supposed to be joined manually.
seed-nodes = []

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

@ -35,13 +35,13 @@ trait ClusterNodeMBean {
/**
* Comma separated addresses of member nodes, sorted in the cluster ring order.
* The address format is `akka://actor-system-name@hostname:port`
* The address format is `pekko://actor-system-name@hostname:port`
*/
def getMembers: String
/**
* Comma separated addresses of unreachable member nodes.
* The address format is `akka://actor-system-name@hostname:port`
* The address format is `pekko://actor-system-name@hostname:port`
*/
def getUnreachable: String
@ -49,10 +49,10 @@ trait ClusterNodeMBean {
* JSON format of the status of all nodes in the cluster as follows:
* {{{
* {
* "self-address": "akka://system@host1:2552",
* "self-address": "pekko://system@host1:2552",
* "members": [
* {
* "address": "akka://system@host1:2552",
* "address": "pekko://system@host1:2552",
* "status": "Up",
* "app-version": "1.0.0",
* "roles": [
@ -60,7 +60,7 @@ trait ClusterNodeMBean {
* ]
* },
* {
* "address": "akka://system@host2:2552",
* "address": "pekko://system@host2:2552",
* "status": "Up",
* "app-version": "1.0.0",
* "roles": [
@ -68,7 +68,7 @@ trait ClusterNodeMBean {
* ]
* },
* {
* "address": "akka://system@host3:2552",
* "address": "pekko://system@host3:2552",
* "status": "Down",
* "app-version": "1.0.0",
* "roles": [
@ -76,7 +76,7 @@ trait ClusterNodeMBean {
* ]
* },
* {
* "address": "akka://system@host4:2552",
* "address": "pekko://system@host4:2552",
* "status": "Joining",
* "app-version": "1.1.0",
* "roles": [
@ -86,17 +86,17 @@ trait ClusterNodeMBean {
* ],
* "unreachable": [
* {
* "node": "akka://system@host2:2552",
* "node": "pekko://system@host2:2552",
* "observed-by": [
* "akka://system@host1:2552",
* "akka://system@host3:2552"
* "pekko://system@host1:2552",
* "pekko://system@host3:2552"
* ]
* },
* {
* "node": "akka://system@host3:2552",
* "node": "pekko://system@host3:2552",
* "observed-by": [
* "akka://system@host1:2552",
* "akka://system@host2:2552"
* "pekko://system@host1:2552",
* "pekko://system@host2:2552"
* ]
* }
* ]
@ -107,7 +107,7 @@ trait ClusterNodeMBean {
/**
* Get the address of the current leader.
* The address format is `akka://actor-system-name@hostname:port`
* The address format is `pekko://actor-system-name@hostname:port`
*/
def getLeader: String
@ -124,20 +124,20 @@ trait ClusterNodeMBean {
/**
* Try to join this cluster node with the node specified by 'address'.
* The address format is `akka://actor-system-name@hostname:port`.
* The address format is `pekko://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://actor-system-name@hostname:port`
* The address format is `pekko://actor-system-name@hostname:port`
*/
def leave(address: String): Unit
/**
* Send command to DOWN the node specified by 'address'.
* The address format is `akka://actor-system-name@hostname:port`
* The address format is `pekko://actor-system-name@hostname:port`
*/
def down(address: String): Unit
}
@ -150,9 +150,9 @@ private[pekko] class ClusterJmx(cluster: Cluster, log: LoggingAdapter) {
private val mBeanServer = ManagementFactory.getPlatformMBeanServer
private val clusterMBeanName =
if (cluster.settings.JmxMultiMbeansInSameEnabled)
new ObjectName("akka:type=Cluster,port=" + cluster.selfUniqueAddress.address.port.getOrElse(""))
new ObjectName("pekko:type=Cluster,port=" + cluster.selfUniqueAddress.address.port.getOrElse(""))
else
new ObjectName("akka:type=Cluster")
new ObjectName("pekko:type=Cluster")
private def clusterView = cluster.readView
import cluster.ClusterLogger._

2
cluster/src/multi-jvm/scala/org/apache/pekko/cluster/MBeanSpec.scala
View file

@ -49,7 +49,7 @@ abstract class MBeanSpec extends MultiNodeClusterSpec(MBeanMultiJvmSpec) {
import MBeanMultiJvmSpec._
val mbeanName = new ObjectName("akka:type=Cluster")
val mbeanName = new ObjectName("pekko:type=Cluster")
lazy val mbeanServer = ManagementFactory.getPlatformMBeanServer
"Cluster MBean" must {

2
cluster/src/multi-jvm/scala/org/apache/pekko/cluster/RemoteFeaturesWithClusterSpec.scala
View file

@ -124,7 +124,7 @@ abstract class ClusterRemoteFeaturesSpec(multiNodeConfig: ClusterRemoteFeaturesC
def assertIsLocalRef(): Unit = {
val actor = system.actorOf(Props[AddressPing](), "kattdjur")
actor.isInstanceOf[RepointableActorRef] shouldBe true
val localAddress = AddressFromURIString(s"akka://${system.name}")
val localAddress = AddressFromURIString(s"pekko://${system.name}")
actor.path.address shouldEqual localAddress
actor.path.address.hasLocalScope shouldBe true

2
cluster/src/multi-jvm/scala/org/apache/pekko/cluster/StressSpec.scala
View file

@ -66,7 +66,7 @@ import pekko.util.Helpers.Requiring
*
* By default it uses 13 nodes.
* Example of sbt command line parameters to double that:
* `-DMultiJvm.pekko.cluster.Stress.nrOfNodes=26 -Dmultinode.Dakka.test.cluster-stress-spec.nr-of-nodes-factor=2`
* `-DMultiJvm.pekko.cluster.Stress.nrOfNodes=26 -Dmultinode.pekko.test.cluster-stress-spec.nr-of-nodes-factor=2`
*/
private[cluster] object StressMultiJvmSpec extends MultiNodeConfig {

2
cluster/src/test/java/org/apache/pekko/cluster/ClusterJavaCompileTest.java
View file

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

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

@ -45,8 +45,8 @@ class ClusterDomainEventPublisherSpec
with ImplicitSender {
val protocol =
if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka"
else "akka.tcp"
if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko"
else "pekko.tcp"
var publisher: ActorRef = _

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._
val aRoles = Set("AA", "AB")
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 aJoining = TestMember(Address("pekko", "sys", "a", 2552), Joining, aRoles)
val aUp = TestMember(Address("pekko", "sys", "a", 2552), Up, aRoles)
val aRemoved = TestMember(Address("pekko", "sys", "a", 2552), Removed, aRoles)
val bRoles = Set("AB", "BB")
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 bUp = TestMember(Address("pekko", "sys", "b", 2552), Up, bRoles)
val bDown = TestMember(Address("pekko", "sys", "b", 2552), Down, bRoles)
val bRemoved = TestMember(Address("pekko", "sys", "b", 2552), Removed, bRoles)
val cRoles = Set.empty[String]
val cUp = TestMember(Address("akka", "sys", "c", 2552), Up, cRoles)
val cLeaving = TestMember(Address("akka", "sys", "c", 2552), Leaving, cRoles)
val cUp = TestMember(Address("pekko", "sys", "c", 2552), Up, cRoles)
val cLeaving = TestMember(Address("pekko", "sys", "c", 2552), Leaving, cRoles)
val dRoles = Set("DD", "DE")
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 dLeaving = TestMember(Address("pekko", "sys", "d", 2552), Leaving, dRoles)
val dExiting = TestMember(Address("pekko", "sys", "d", 2552), Exiting, dRoles)
val dRemoved = TestMember(Address("pekko", "sys", "d", 2552), Removed, dRoles)
val eRoles = Set("EE", "DE")
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)
val eJoining = TestMember(Address("pekko", "sys", "e", 2552), Joining, eRoles)
val eUp = TestMember(Address("pekko", "sys", "e", 2552), Up, eRoles)
val eDown = TestMember(Address("pekko", "sys", "e", 2552), Down, eRoles)
val selfDummyAddress = UniqueAddress(Address("pekko", "sys", "selfDummy", 2552), 17L)
private val originalClusterAssert = sys.props.get("pekko.cluster.assert").getOrElse("false")
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 {
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 dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
val dc2BMemberUp = TestMember(Address("pekko", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
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 dc3AMemberUp = TestMember(Address("pekko", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
val dc3BMemberUp = TestMember(Address("pekko", "sys", "dc3B", 2552), Up, Set.empty[String], "dc3")
val reachability1 = Reachability.empty
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 {
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 dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
val reachability1 = Reachability.empty
val g1 = Gossip(members = SortedSet(aUp, dc2AMemberUp), overview = GossipOverview(reachability = reachability1))
@ -181,9 +181,9 @@ class ClusterDomainEventSpec extends AnyWordSpec with Matchers with BeforeAndAft
// - empty
// - B --unreachable--> C
val dc1MemberA = TestMember(Address("akka", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc1MemberB = TestMember(Address("akka", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
val dc2MemberC = TestMember(Address("akka", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
val dc1MemberA = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
val dc1MemberB = TestMember(Address("pekko", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
val dc2MemberC = TestMember(Address("pekko", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
val members = SortedSet(dc1MemberA, dc1MemberB, dc2MemberC)

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

@ -45,7 +45,7 @@ class ClusterHeartbeatSenderSpec extends PekkoSpec("""
val underTest = system.actorOf(Props(new TestClusterHeartBeatSender(probe)))
underTest ! CurrentClusterState()
underTest ! MemberUp(
Member(UniqueAddress(Address("akka", system.name), 1L), Set("dc-default"), Version.Zero)
Member(UniqueAddress(Address("pekko", system.name), 1L), Set("dc-default"), Version.Zero)
.copy(status = MemberStatus.Up))
probe.expectMsgType[Heartbeat].sequenceNr shouldEqual 1

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 {
import ClusterHeartbeatSenderStateSpec._
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 aa = UniqueAddress(Address("pekko", "sys", "aa", 2552), 1L)
val bb = UniqueAddress(Address("pekko", "sys", "bb", 2552), 2L)
val cc = UniqueAddress(Address("pekko", "sys", "cc", 2552), 3L)
val dd = UniqueAddress(Address("pekko", "sys", "dd", 2552), 4L)
val ee = UniqueAddress(Address("pekko", "sys", "ee", 2552), 5L)
private def emptyState: ClusterHeartbeatSenderState = emptyState(aa)
@ -164,7 +164,7 @@ class ClusterHeartbeatSenderStateSpec extends AnyWordSpec 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", "sys", "n" + n, 2552), n.toLong)).toVector
(1 to rnd.nextInt(10, 200)).map(n => UniqueAddress(Address("pekko", "sys", "n" + n, 2552), n.toLong)).toVector
def rndNode() = nodes(rnd.nextInt(0, nodes.size))
val selfUniqueAddress = rndNode()
var state = emptyState(selfUniqueAddress)

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

@ -75,7 +75,7 @@ class ClusterSpec extends PekkoSpec(ClusterSpec.config) with ImplicitSender {
}
"register jmx mbean" in {
val name = new ObjectName("akka:type=Cluster")
val name = new ObjectName("pekko:type=Cluster")
val info = ManagementFactory.getPlatformMBeanServer.getMBeanInfo(name)
info.getAttributes.length should be > 0
info.getOperations.length should be > 0
@ -88,7 +88,7 @@ class ClusterSpec extends PekkoSpec(ClusterSpec.config) with ImplicitSender {
"fail fast in a join if invalid chars in host names, e.g. docker host given name" in {
val addresses = scala.collection.immutable
.Seq(Address("akka", "sys", Some("in_valid"), Some(0)), Address("akka", "sys", Some("invalid._org"), Some(0)))
.Seq(Address("pekko", "sys", Some("in_valid"), Some(0)), Address("pekko", "sys", Some("invalid._org"), Some(0)))
addresses.foreach(a => intercept[IllegalArgumentException](cluster.join(a)))
intercept[IllegalArgumentException](cluster.joinSeedNodes(addresses))
@ -96,10 +96,10 @@ class ClusterSpec extends PekkoSpec(ClusterSpec.config) with ImplicitSender {
"not fail fast to attempt a join with valid chars in host names" in {
val addresses = scala.collection.immutable.Seq(
Address("akka", "sys", Some("localhost"), Some(0)),
Address("akka", "sys", Some("is_valid.org"), Some(0)),
Address("akka", "sys", Some("fu.is_valid.org"), Some(0)),
Address("akka", "sys", Some("fu_.is_valid.org"), Some(0)))
Address("pekko", "sys", Some("localhost"), Some(0)),
Address("pekko", "sys", Some("is_valid.org"), Some(0)),
Address("pekko", "sys", Some("fu.is_valid.org"), Some(0)),
Address("pekko", "sys", Some("fu_.is_valid.org"), Some(0)))
addresses.foreach(cluster.join)
cluster.joinSeedNodes(addresses)
@ -364,12 +364,12 @@ class ClusterSpec extends PekkoSpec(ClusterSpec.config) with ImplicitSender {
Cluster(sys1)
Cluster(sys2)
val name1 = new ObjectName(s"akka:type=Cluster,port=2552")
val name1 = new ObjectName(s"pekko:type=Cluster,port=2552")
val info1 = ManagementFactory.getPlatformMBeanServer.getMBeanInfo(name1)
info1.getAttributes.length should be > 0
info1.getOperations.length should be > 0
val name2 = new ObjectName(s"akka:type=Cluster,port=2553")
val name2 = new ObjectName(s"pekko:type=Cluster,port=2553")
val info2 = ManagementFactory.getPlatformMBeanServer.getMBeanInfo(name2)
info2.getAttributes.length should be > 0
info2.getOperations.length should be > 0

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

@ -60,7 +60,7 @@ class CrossDcHeartbeatSenderSpec extends PekkoSpec("""
underTest ! CurrentClusterState(
members = SortedSet(
Cluster(system).selfMember,
Member(UniqueAddress(Address("akka", system.name), 2L), Set("dc-dc2"), Version.Zero)
Member(UniqueAddress(Address("pekko", system.name), 2L), Set("dc-dc2"), Version.Zero)
.copy(status = MemberStatus.Up)))
awaitAssert {

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._
val a1 = TestMember(Address("akka", "sys", "a", 2552), Up)
val a1 = TestMember(Address("pekko", "sys", "a", 2552), Up)
val a2 = TestMember(a1.address, Joining)
val b1 = TestMember(Address("akka", "sys", "b", 2552), Up)
val b1 = TestMember(Address("pekko", "sys", "b", 2552), Up)
val b2 = TestMember(b1.address, Removed)
val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving)
val c1 = TestMember(Address("pekko", "sys", "c", 2552), Leaving)
val c2 = TestMember(c1.address, Up)
val c3 = TestMember(c1.address, Exiting)
val d1 = TestMember(Address("akka", "sys", "d", 2552), Leaving)
val e1 = TestMember(Address("akka", "sys", "e", 2552), Joining)
val d1 = TestMember(Address("pekko", "sys", "d", 2552), Leaving)
val e1 = TestMember(Address("pekko", "sys", "e", 2552), Joining)
val e2 = TestMember(e1.address, Up)
val e3 = TestMember(e1.address, Down)
val f1 = TestMember(Address("akka", "sys", "f", 2552), Joining)
val f1 = TestMember(Address("pekko", "sys", "f", 2552), Joining)
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 dc1a1 = TestMember(Address("pekko", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
val dc1b1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
val dc2c1 = TestMember(Address("pekko", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
val dc2d1 = TestMember(Address("pekko", "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 =
@ -533,7 +533,7 @@ class GossipSpec extends AnyWordSpec with Matchers {
}
"update members" in {
val joining = TestMember(Address("akka", "sys", "d", 2552), Joining, Set.empty, dataCenter = "dc2")
val joining = TestMember(Address("pekko", "sys", "d", 2552), Joining, Set.empty, dataCenter = "dc2")
val g = Gossip(members = SortedSet(dc1a1, 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 {
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 aDc1 = TestMember(Address("pekko", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
val bDc1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
val cDc1 = TestMember(Address("pekko", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc1")
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 eDc2 = TestMember(Address("pekko", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2")
val fDc2 = TestMember(Address("pekko", "sys", "f", 2552), Up, Set.empty, dataCenter = "dc2")
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 gDc3 = TestMember(Address("pekko", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3")
val hDc3 = TestMember(Address("pekko", "sys", "h", 2552), Up, Set.empty, dataCenter = "dc3")
val iDc4 = TestMember(Address("akka", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4")
val iDc4 = TestMember(Address("pekko", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4")
val defaultSelector =
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
def createHeartbeatNodeRingOfSize(size: Int): HeartbeatNodeRing = {
val nodes = (1 to size).map(n => UniqueAddress(Address("akka", "sys", "node-" + n, 2552), n.toLong))
val nodes = (1 to size).map(n => UniqueAddress(Address("pekko", "sys", "node-" + n, 2552), n.toLong))
val selfAddress = nodes(size / 2)
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 {
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 aa = UniqueAddress(Address("pekko", "sys", "aa", 2552), 1L)
val bb = UniqueAddress(Address("pekko", "sys", "bb", 2552), 2L)
val cc = UniqueAddress(Address("pekko", "sys", "cc", 2552), 3L)
val dd = UniqueAddress(Address("pekko", "sys", "dd", 2552), 4L)
val ee = UniqueAddress(Address("pekko", "sys", "ee", 2552), 5L)
val ff = UniqueAddress(Address("pekko", "sys", "ff", 2552), 6L)
val nodes = Set(aa, bb, cc, dd, ee, ff)

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

@ -47,7 +47,7 @@ object JoinConfigCompatCheckerSpec {
pekko-cluster-test = "org.apache.pekko.cluster.JoinConfigCompatCheckerTest"
}
sensitive-config-paths {
akka = [ "pekko.cluster.sensitive.properties" ]
pekko = [ "pekko.cluster.sensitive.properties" ]
}
}
}
@ -586,7 +586,7 @@ class JoinConfigCompatCheckerSpec extends PekkoSpec with ClusterTestKit {
# this will allow the joining node to leak sensitive info and try
# get back these same properties from the cluster
sensitive-config-paths {
akka = []
pekko = []
}
}
}

72
cluster/src/test/scala/org/apache/pekko/cluster/MemberOrderingSpec.scala
View file

@ -35,22 +35,22 @@ class MemberOrderingSpec extends AnyWordSpec with Matchers {
"order members by host:port" in {
val members = SortedSet.empty[Member] +
m(AddressFromURIString("akka://sys@darkstar:1112"), Up) +
m(AddressFromURIString("akka://sys@darkstar:1113"), Joining) +
m(AddressFromURIString("akka://sys@darkstar:1111"), Up)
m(AddressFromURIString("pekko://sys@darkstar:1112"), Up) +
m(AddressFromURIString("pekko://sys@darkstar:1113"), Joining) +
m(AddressFromURIString("pekko://sys@darkstar:1111"), Up)
val seq = members.toSeq
seq.size should ===(3)
seq(0) should ===(m(AddressFromURIString("akka://sys@darkstar:1111"), Up))
seq(1) should ===(m(AddressFromURIString("akka://sys@darkstar:1112"), Up))
seq(2) should ===(m(AddressFromURIString("akka://sys@darkstar:1113"), Joining))
seq(0) should ===(m(AddressFromURIString("pekko://sys@darkstar:1111"), Up))
seq(1) should ===(m(AddressFromURIString("pekko://sys@darkstar:1112"), Up))
seq(2) should ===(m(AddressFromURIString("pekko://sys@darkstar:1113"), Joining))
}
"be sorted by address correctly" in {
import Member.ordering
// sorting should be done on host and port, only
val m1 = m(Address("akka", "sys1", "host1", 9000), Up)
val m2 = m(Address("akka", "sys1", "host1", 10000), Up)
val m1 = m(Address("pekko", "sys1", "host1", 9000), Up)
val m2 = m(Address("pekko", "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)
@ -62,7 +62,7 @@ class MemberOrderingSpec extends AnyWordSpec with Matchers {
}
"have stable equals and hashCode" in {
val address = Address("akka", "sys1", "host1", 9000)
val address = Address("pekko", "sys1", "host1", 9000)
val m1 = m(address, Joining)
val m11 = Member(UniqueAddress(address, -3L), Set.empty, Version.Zero)
val m2 = m1.copy(status = Up)
@ -84,7 +84,7 @@ class MemberOrderingSpec extends AnyWordSpec with Matchers {
}
"have consistent ordering and equals" in {
val address1 = Address("akka", "sys1", "host1", 9001)
val address1 = Address("pekko", "sys1", "host1", 9001)
val address2 = address1.copy(port = Some(9002))
val x = m(address1, Exiting)
@ -102,7 +102,7 @@ class MemberOrderingSpec extends AnyWordSpec with Matchers {
}
"work with SortedSet" in {
val address1 = Address("akka", "sys1", "host1", 9001)
val address1 = Address("pekko", "sys1", "host1", 9001)
val address2 = address1.copy(port = Some(9002))
val address3 = address1.copy(port = Some(9003))
@ -119,54 +119,54 @@ class MemberOrderingSpec extends AnyWordSpec with Matchers {
"order addresses by port" in {
val addresses = SortedSet.empty[Address] +
AddressFromURIString("akka://sys@darkstar:1112") +
AddressFromURIString("akka://sys@darkstar:1113") +
AddressFromURIString("akka://sys@darkstar:1110") +
AddressFromURIString("akka://sys@darkstar:1111")
AddressFromURIString("pekko://sys@darkstar:1112") +
AddressFromURIString("pekko://sys@darkstar:1113") +
AddressFromURIString("pekko://sys@darkstar:1110") +
AddressFromURIString("pekko://sys@darkstar:1111")
val seq = addresses.toSeq
seq.size should ===(4)
seq(0) should ===(AddressFromURIString("akka://sys@darkstar:1110"))
seq(1) should ===(AddressFromURIString("akka://sys@darkstar:1111"))
seq(2) should ===(AddressFromURIString("akka://sys@darkstar:1112"))
seq(3) should ===(AddressFromURIString("akka://sys@darkstar:1113"))
seq(0) should ===(AddressFromURIString("pekko://sys@darkstar:1110"))
seq(1) should ===(AddressFromURIString("pekko://sys@darkstar:1111"))
seq(2) should ===(AddressFromURIString("pekko://sys@darkstar:1112"))
seq(3) should ===(AddressFromURIString("pekko://sys@darkstar:1113"))
}
"order addresses by hostname" in {
val addresses = SortedSet.empty[Address] +
AddressFromURIString("akka://sys@darkstar2:1110") +
AddressFromURIString("akka://sys@darkstar1:1110") +
AddressFromURIString("akka://sys@darkstar3:1110") +
AddressFromURIString("akka://sys@darkstar0:1110")
AddressFromURIString("pekko://sys@darkstar2:1110") +
AddressFromURIString("pekko://sys@darkstar1:1110") +
AddressFromURIString("pekko://sys@darkstar3:1110") +
AddressFromURIString("pekko://sys@darkstar0:1110")
val seq = addresses.toSeq
seq.size should ===(4)
seq(0) should ===(AddressFromURIString("akka://sys@darkstar0:1110"))
seq(1) should ===(AddressFromURIString("akka://sys@darkstar1:1110"))
seq(2) should ===(AddressFromURIString("akka://sys@darkstar2:1110"))
seq(3) should ===(AddressFromURIString("akka://sys@darkstar3:1110"))
seq(0) should ===(AddressFromURIString("pekko://sys@darkstar0:1110"))
seq(1) should ===(AddressFromURIString("pekko://sys@darkstar1:1110"))
seq(2) should ===(AddressFromURIString("pekko://sys@darkstar2:1110"))
seq(3) should ===(AddressFromURIString("pekko://sys@darkstar3:1110"))
}
"order addresses by hostname and port" in {
val addresses = SortedSet.empty[Address] +
AddressFromURIString("akka://sys@darkstar2:1110") +
AddressFromURIString("akka://sys@darkstar0:1111") +
AddressFromURIString("akka://sys@darkstar2:1111") +
AddressFromURIString("akka://sys@darkstar0:1110")
AddressFromURIString("pekko://sys@darkstar2:1110") +
AddressFromURIString("pekko://sys@darkstar0:1111") +
AddressFromURIString("pekko://sys@darkstar2:1111") +
AddressFromURIString("pekko://sys@darkstar0:1110")
val seq = addresses.toSeq
seq.size should ===(4)
seq(0) should ===(AddressFromURIString("akka://sys@darkstar0:1110"))
seq(1) should ===(AddressFromURIString("akka://sys@darkstar0:1111"))
seq(2) should ===(AddressFromURIString("akka://sys@darkstar2:1110"))
seq(3) should ===(AddressFromURIString("akka://sys@darkstar2:1111"))
seq(0) should ===(AddressFromURIString("pekko://sys@darkstar0:1110"))
seq(1) should ===(AddressFromURIString("pekko://sys@darkstar0:1111"))
seq(2) should ===(AddressFromURIString("pekko://sys@darkstar2:1110"))
seq(3) should ===(AddressFromURIString("pekko://sys@darkstar2:1111"))
}
}
"Leader status ordering" must {
"order members with status Joining, Exiting and Down last" in {
val address = Address("akka", "sys1", "host1", 5000)
val address = Address("pekko", "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
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 {
// DC-a is in reverse age order
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")
val a1 = TestMember(Address("pekko", "sys", "a4", 2552), Up, 1, "dc-a")
val a2 = TestMember(Address("pekko", "sys", "a3", 2552), Up, 2, "dc-a")
val a3 = TestMember(Address("pekko", "sys", "a2", 2552), Up, 3, "dc-a")
val a4 = TestMember(Address("pekko", "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", "sys", "b3", 2552), Up, 1, "dc-b")
val b3 = TestMember(Address("akka", "sys", "b2", 2552), Up, 3, "dc-b")
val b1 = TestMember(Address("pekko", "sys", "b3", 2552), Up, 1, "dc-b")
val b3 = TestMember(Address("pekko", "sys", "b2", 2552), Up, 3, "dc-b")
// Won't be replaced by b3
val b2 = TestMember(Address("akka", "sys", "b1", 2552), Up, 2, "dc-b")
val b2 = TestMember(Address("pekko", "sys", "b1", 2552), Up, 2, "dc-b")
// for the case that we don't replace it ever
val bOldest = TestMember(Address("akka", "sys", "b0", 2552), Up, 0, "dc-b")
val bOldest = TestMember(Address("pekko", "sys", "b0", 2552), Up, 0, "dc-b")
"Membership state" must {
"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 {
val a5 = TestMember(
Address("akka", "sys", "a5", 2552),
Address("pekko", "sys", "a5", 2552),
MemberStatus.Exiting,
roles = Set("role1", "role2"),
upNumber = 5,
dataCenter = "dc-a")
val a6 = TestMember(
Address("akka", "sys", "a6", 2552),
Address("pekko", "sys", "a6", 2552),
MemberStatus.Exiting,
roles = Set("role1", "role3"),
upNumber = 6,
dataCenter = "dc-a")
val a7 = TestMember(
Address("akka", "sys", "a7", 2552),
Address("pekko", "sys", "a7", 2552),
MemberStatus.Exiting,
roles = Set("role1"),
upNumber = 7,
dataCenter = "dc-a")
val a8 = TestMember(
Address("akka", "sys", "a8", 2552),
Address("pekko", "sys", "a8", 2552),
MemberStatus.Exiting,
roles = Set("role1"),
upNumber = 8,
dataCenter = "dc-a")
val a9 = TestMember(
Address("akka", "sys", "a9", 2552),
Address("pekko", "sys", "a9", 2552),
MemberStatus.Exiting,
roles = Set("role2"),
upNumber = 9,
dataCenter = "dc-a")
val b5 = TestMember(
Address("akka", "sys", "b5", 2552),
Address("pekko", "sys", "b5", 2552),
MemberStatus.Exiting,
roles = Set("role1"),
upNumber = 5,
dataCenter = "dc-b")
val b6 = TestMember(
Address("akka", "sys", "b6", 2552),
Address("pekko", "sys", "b6", 2552),
MemberStatus.Exiting,
roles = Set("role2"),
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
val iterations = sys.props.get("org.apache.pekko.cluster.ReachabilityPerfSpec.iterations").getOrElse("100").toInt
val address = Address("akka", "sys", "a", 2552)
val node = Address("akka", "sys", "a", 2552)
val address = Address("pekko", "sys", "a", 2552)
val node = Address("pekko", "sys", "a", 2552)
private def createReachabilityOfSize(base: Reachability, size: Int): Reachability =
(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 }
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)
val nodeA = UniqueAddress(Address("pekko", "sys", "a", 2552), 1L)
val nodeB = UniqueAddress(Address("pekko", "sys", "b", 2552), 2L)
val nodeC = UniqueAddress(Address("pekko", "sys", "c", 2552), 3L)
val nodeD = UniqueAddress(Address("pekko", "sys", "d", 2552), 4L)
val nodeE = UniqueAddress(Address("pekko", "sys", "e", 2552), 5L)
"Reachability table" must {

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

@ -81,20 +81,20 @@ class ClusterMessageSerializerSpec extends PekkoSpec("pekko.actor.provider = clu
import MemberStatus._
val a1 =
TestMember(Address("akka", "sys", "a", 2552), Joining, Set.empty[String], appVersion = Version("1.0.0"))
val b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set("r1"), appVersion = Version("1.1.0"))
TestMember(Address("pekko", "sys", "a", 2552), 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 c1 =
TestMember(Address("akka", "sys", "c", 2552), Leaving, Set.empty[String], "foo", appVersion = Version("1.1.0"))
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")
TestMember(Address("pekko", "sys", "c", 2552), Leaving, Set.empty[String], "foo", appVersion = Version("1.1.0"))
val d1 = TestMember(Address("pekko", "sys", "d", 2552), Exiting, Set("r1"), "foo")
val e1 = TestMember(Address("pekko", "sys", "e", 2552), Down, Set("r3"))
val f1 = TestMember(Address("pekko", "sys", "f", 2552), Removed, Set("r3"), "foo")
"ClusterMessages" must {
"be serializable" in {
val address = Address("akka", "system", "some.host.org", 4711)
val address = Address("pekko", "system", "some.host.org", 4711)
val uniqueAddress = UniqueAddress(address, 17L)
val address2 = Address("akka", "system", "other.host.org", 4711)
val address2 = Address("pekko", "system", "other.host.org", 4711)
val uniqueAddress2 = UniqueAddress(address2, 18L)
checkSerialization(InternalClusterAction.Join(uniqueAddress, Set("foo", "bar", "dc-A"), Version.Zero))
checkSerialization(InternalClusterAction.Join(uniqueAddress, Set("dc-A"), Version("1.2.3")))
@ -133,9 +133,9 @@ class ClusterMessageSerializerSpec extends PekkoSpec("pekko.actor.provider = clu
// can be removed in 2.6.3 only checks deserialization with new not yet in effect manifests for 2.6.2
"be de-serializable with class manifests from 2.6.4 and earlier nodes" in {
val address = Address("akka", "system", "some.host.org", 4711)
val address = Address("pekko", "system", "some.host.org", 4711)
val uniqueAddress = UniqueAddress(address, 17L)
val address2 = Address("akka", "system", "other.host.org", 4711)
val address2 = Address("pekko", "system", "other.host.org", 4711)
val uniqueAddress2 = UniqueAddress(address2, 18L)
checkDeserializationWithManifest(
InternalClusterAction.Join(uniqueAddress, Set("foo", "bar", "dc-A"), Version.Zero),

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

@ -24,7 +24,7 @@ import pekko.cluster.UniqueAddress
import pekko.util.Version
/**
* Needed since the Member constructor is akka private
* Needed since the Member constructor is pekko private
*/
object TestAddresses {
private def dcRole(dc: ClusterSettings.DataCenter): String =
@ -32,7 +32,7 @@ object TestAddresses {
val defaultDataCenter = ClusterSettings.DefaultDataCenter
private def defaultDcRole = dcRole(defaultDataCenter)
val addressA = Address("akka.tcp", "sys", "a", 2552)
val addressA = Address("pekko.tcp", "sys", "a", 2552)
val memberA = new Member(UniqueAddress(addressA, 0L), 5, Up, Set("role3", defaultDcRole), Version.Zero)
val memberB =
new Member(

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

@ -55,8 +55,8 @@ class AutoDownSpec extends PekkoSpec("""
import AutoDownSpec._
val protocol =
if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka"
else "akka.tcp"
if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko"
else "pekko.tcp"
val memberA = TestMember(Address(protocol, "sys", "a", 2552), Up)
val memberB = TestMember(Address(protocol, "sys", "b", 2552), Up)

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

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

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

@ -45,8 +45,8 @@ object DeltaPropagationSelectorSpec {
class DeltaPropagationSelectorSpec extends AnyWordSpec with Matchers with TypeCheckedTripleEquals {
import DeltaPropagationSelectorSpec._
val selfUniqueAddress = UniqueAddress(Address("akka", "Sys", "localhost", 4999), 17L)
val nodes = (2500 until 2600).map(n => UniqueAddress(Address("akka", "Sys", "localhost", n), 17L)).toVector
val selfUniqueAddress = UniqueAddress(Address("pekko", "Sys", "localhost", 4999), 17L)
val nodes = (2500 until 2600).map(n => UniqueAddress(Address("pekko", "Sys", "localhost", n), 17L)).toVector
"DeltaPropagationSelector" must {
"collect none when no nodes" in {

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

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

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

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

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

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

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

@ -57,8 +57,8 @@ object LotsOfDataBot {
pekko.cluster {
seed-nodes = [
"akka://ClusterSystem@127.0.0.1:2551",
"akka://ClusterSystem@127.0.0.1:2552"]
"pekko://ClusterSystem@127.0.0.1:2551",
"pekko://ClusterSystem@127.0.0.1:2552"]
downing-provider-class = org.apache.pekko.cluster.testkit.AutoDowning
testkit.auto-down-unreachable-after = 10s

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

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

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

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

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

@ -25,11 +25,11 @@ import pekko.cluster.ddata.Replicator.Changed
class ORSetSpec extends AnyWordSpec with Matchers {
val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
val nodeA = UniqueAddress(Address("akka", "Sys", "a", 2552), 1L)
val nodeA = UniqueAddress(Address("pekko", "Sys", "a", 2552), 1L)
val nodeB = UniqueAddress(nodeA.address.copy(host = Some("b")), 2L)
val nodeC = UniqueAddress(nodeA.address.copy(host = Some("c")), 3L)
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

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

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

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

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

@ -23,7 +23,7 @@ import pekko.cluster.UniqueAddress
class PruningStateSpec extends AnyWordSpec with Matchers {
import PruningState._
val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
val node1 = UniqueAddress(Address("pekko", "Sys", "localhost", 2551), 1L)
val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
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

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

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

@ -150,8 +150,8 @@ class WriteAggregatorSpec extends PekkoSpec(s"""
import WriteAggregatorSpec._
val protocol =
if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka"
else "akka.tcp"
if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko"
else "pekko.tcp"
val nodeA = UniqueAddress(Address(protocol, "Sys", "a", 2552), 17L)
val nodeB = UniqueAddress(Address(protocol, "Sys", "b", 2552), 17L)

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

@ -51,7 +51,7 @@ class ReplicatedDataSerializerSpec
val serializer = new ReplicatedDataSerializer(system.asInstanceOf[ExtendedActorSystem])
val Protocol = if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka" else "akka.tcp"
val Protocol = if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko" else "pekko.tcp"
val address1 = UniqueAddress(Address(Protocol, system.name, "some.host.org", 4711), 1L)
val address2 = UniqueAddress(Address(Protocol, system.name, "other.host.org", 4711), 2L)

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

@ -56,7 +56,7 @@ class ReplicatorMessageSerializerSpec
val serializer = new ReplicatorMessageSerializer(system.asInstanceOf[ExtendedActorSystem])
val Protocol = if (RARP(system).provider.remoteSettings.Artery.Enabled) "akka" else "akka.tcp"
val Protocol = if (RARP(system).provider.remoteSettings.Artery.Enabled) "pekko" else "pekko.tcp"
val address1 = UniqueAddress(Address(Protocol, system.name, "some.host.org", 4711), 1L)
val address2 = UniqueAddress(Address(Protocol, system.name, "other.host.org", 4711), 2L)

2
docs/src/test/java/jdocs/actor/fsm/FSMDocTest.java
View file

@ -224,7 +224,7 @@ public class FSMDocTest extends AbstractJavaTest {
expectMsgEquals(Active);
expectMsgEquals(Data.Foo);
String msg = expectMsgClass(String.class);
assertTrue(msg.startsWith("LogEntry(SomeState,Foo,Actor[akka://FSMDocTest/system/"));
assertTrue(msg.startsWith("LogEntry(SomeState,Foo,Actor[pekko://FSMDocTest/system/"));
}
};
}

8
docs/src/test/java/jdocs/remoting/RemoteDeploymentDocTest.java
View file

@ -60,16 +60,16 @@ public class RemoteDeploymentDocTest extends AbstractJavaTest {
@SuppressWarnings("unused")
void makeAddress() {
// #make-address-artery
Address addr = new Address("akka", "sys", "host", 1234);
addr = AddressFromURIString.parse("akka://sys@host:1234"); // the same
Address addr = new Address("pekko", "sys", "host", 1234);
addr = AddressFromURIString.parse("pekko://sys@host:1234"); // the same
// #make-address-artery
}
@Test
public void demonstrateDeployment() {
// #make-address
Address addr = new Address("akka", "sys", "host", 1234);
addr = AddressFromURIString.parse("akka://sys@host:1234"); // the same
Address addr = new Address("pekko", "sys", "host", 1234);
addr = AddressFromURIString.parse("pekko://sys@host:1234"); // the same
// #make-address
// #deploy
Props props = Props.create(SampleActor.class).withDeploy(new Deploy(new RemoteScope(addr)));

2
docs/src/test/java/jdocs/testkit/TestKitDocTest.java
View file

@ -518,7 +518,7 @@ public class TestKitDocTest extends AbstractJavaTest {
final int result =
new EventFilter(ActorKilledException.class, system)
.from("akka://TestKitDocTest/user/victim")
.from("pekko://TestKitDocTest/user/victim")
.occurrences(1)
.intercept(
() -> {

2
multi-node-testkit/src/main/scala/org/apache/pekko/remote/testkit/MultiNodeSpec.scala
View file

@ -515,7 +515,7 @@ abstract class MultiNodeSpec(
// might happen if all test cases are ignored (excluded) and
// controller node is finished/exited before r.addr is run
// on the other nodes
val unresolved = "akka://unresolved-replacement-" + r.role.name
val unresolved = "pekko://unresolved-replacement-" + r.role.name
log.warning(unresolved + " due to: " + e.getMessage)
unresolved
}

2
persistence-shared/src/test/scala/org/apache/pekko/persistence/serialization/SerializerSpec.scala
View file

@ -313,7 +313,7 @@ class MessageSerializerPersistenceSpec extends PekkoSpec(customSerializers) {
object MessageSerializerRemotingSpec {
class LocalActor(port: Int) extends Actor {
def receive = {
case m => context.actorSelection(s"akka://remote@127.0.0.1:${port}/user/remote").tell(m, Actor.noSender)
case m => context.actorSelection(s"pekko://remote@127.0.0.1:${port}/user/remote").tell(m, Actor.noSender)
}
}

2
persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/internal/JournalFailureException.scala
View file

@ -20,7 +20,7 @@ import pekko.persistence.typed.PersistenceId
/**
* INTERNAL API
*
* Used for journal failures. Private to akka as only internal supervision strategies should use it.
* Used for journal failures. Private to pekko as only internal supervision strategies should use it.
*/
@InternalApi
final private[pekko] class JournalFailureException(msg: String, cause: Throwable) extends RuntimeException(msg, cause) {

2
persistence-typed/src/main/scala/org/apache/pekko/persistence/typed/state/internal/DurableStateStoreException.scala
View file

@ -20,7 +20,7 @@ import pekko.persistence.typed.PersistenceId
/**
* INTERNAL API
*
* Used for store failures. Private to akka as only internal supervision strategies should use it.
* Used for store failures. Private to pekko as only internal supervision strategies should use it.
*/
@InternalApi
final private[pekko] class DurableStateStoreException(msg: String, cause: Throwable)

3
persistence/src/main/resources/reference.conf
View file

@ -5,9 +5,6 @@
# This is the reference config file that contains all the default settings.
# Make your edits in your application.conf in order to override these settings.
# Directory of persistence journal and snapshot store plugins is available at the
# Pekko Community Projects page https://akka.io/community/
# Default persistence extension settings.
pekko.persistence {

2
project/Doc.scala
View file

@ -176,7 +176,7 @@ object UnidocRoot extends AutoPlugin {
.ifTrue(Seq(JavaUnidoc / unidocAllSources ~= { v =>
v.map(
_.filterNot(s =>
// akka.stream.scaladsl.GraphDSL.Implicits.ReversePortsOps
// org.apache.pekko.stream.scaladsl.GraphDSL.Implicits.ReversePortsOps
// contains code that genjavadoc turns into (probably
// incorrect) Java code that in turn confuses the javadoc
// tool.

Some files were not shown because too many files have changed in this diff Show more