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

* 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>

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

@@ -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"
 

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

@@ -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"))
 }
 
 /**

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

@@ -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 {
 

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

@@ -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)
     }
 

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

@@ -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());
   }

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

@@ -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

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

@@ -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")
+      val a = Address("pekko", "mysys")
-      RootActorPath(a).toString should ===("akka://mysys/")
+      RootActorPath(a).toString should ===("pekko://mysys/")
-      (RootActorPath(a) / "user").toString should ===("akka://mysys/user")
+      (RootActorPath(a) / "user").toString should ===("pekko://mysys/user")
-      (RootActorPath(a) / "user" / "foo").toString should ===("akka://mysys/user/foo")
+      (RootActorPath(a) / "user" / "foo").toString should ===("pekko://mysys/user/foo")
-      (RootActorPath(a) / "user" / "foo" / "bar").toString should ===("akka://mysys/user/foo/bar")
+      (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.toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/")
-      (root / "user").toStringWithAddress(a) should ===("akka://mysys@aaa:2552/user")
+      (root / "user").toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/user")
-      (root / "user" / "foo").toStringWithAddress(a) should ===("akka://mysys@aaa:2552/user/foo")
+      (root / "user" / "foo").toStringWithAddress(a) should ===("pekko://mysys@aaa:2552/user/foo")
 
-      //      root.toStringWithAddress(b) should ===("akka://mysys@bb:2552/")
+      //      root.toStringWithAddress(b) should ===("pekko://mysys@bb:2552/")
-      (root / "user").toStringWithAddress(b) should ===("akka://mysys@bb:2552/user")
+      (root / "user").toStringWithAddress(b) should ===("pekko://mysys@bb:2552/user")
-      (root / "user" / "foo").toStringWithAddress(b) should ===("akka://mysys@bb:2552/user/foo")
+      (root / "user" / "foo").toStringWithAddress(b) should ===("pekko://mysys@bb:2552/user/foo")
 
-      root.toStringWithAddress(c) should ===("akka://mysys@cccc:2552/")
+      root.toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/")
-      (root / "user").toStringWithAddress(c) should ===("akka://mysys@cccc:2552/user")
+      (root / "user").toStringWithAddress(c) should ===("pekko://mysys@cccc:2552/user")
-      (root / "user" / "foo").toStringWithAddress(c) should ===("akka://mysys@cccc:2552/user/foo")
+      (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.toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/")
-      (rootA / "user").toStringWithAddress(b) should ===("akka://mysys@aaa:2552/user")
+      (rootA / "user").toStringWithAddress(b) should ===("pekko://mysys@aaa:2552/user")
-      (rootA / "user" / "foo").toStringWithAddress(b) should ===("akka://mysys@aaa:2552/user/foo")
+      (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("pekko", "sys", "valid", 0),
-        Address("akka", "sys", "is_valid.org", 0),
+        Address("pekko", "sys", "is_valid.org", 0),
-        Address("akka", "sys", "fu.is_valid.org", 0)).forall(_.hasInvalidHostCharacters) shouldBe false
+        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("pekko", "sys", "localhost", 0),
-        Address("akka", "sys", "is_valid.org", 0),
+        Address("pekko", "sys", "is_valid.org", 0),
-        Address("akka", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
+        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("pekko", "sys", "localhost", 0),
-        Address("akka", "sys", "is_valid.org", 0),
+        Address("pekko", "sys", "is_valid.org", 0),
-        Address("akka", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
+        Address("pekko", "sys", "fu.is_valid.org", 0)).foreach(_.checkHostCharacters())
 
-      intercept[IllegalArgumentException](Address("akka", "sys", "in_valid", 0).checkHostCharacters())
+      intercept[IllegalArgumentException](Address("pekko", "sys", "in_valid", 0).checkHostCharacters())
-      intercept[IllegalArgumentException](Address("akka", "sys", "invalid._org", 0).checkHostCharacters())
+      intercept[IllegalArgumentException](Address("pekko", "sys", "invalid._org", 0).checkHostCharacters())
     }
   }
 }

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

@@ -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("pekko://all-systems/Nobody") should ===(None)
-      identify("akka://all-systems/user") 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")
+        "pekko://ActorSelectionSpec/user/c2/c21")
-      ActorSelection(c2, "/").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2")
+      ActorSelection(c2, "/").toSerializationFormat should ===("pekko://ActorSelectionSpec/user/c2")
-      ActorSelection(c2, "../*/hello").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2/../*/hello")
+      ActorSelection(c2, "../*/hello").toSerializationFormat should ===("pekko://ActorSelectionSpec/user/c2/../*/hello")
-      ActorSelection(c2, "/../*/hello").toSerializationFormat should ===("akka://ActorSelectionSpec/user/c2/../*/hello")
+      ActorSelection(c2, "/../*/hello").toSerializationFormat should ===(
+        "pekko://ActorSelectionSpec/user/c2/../*/hello")
     }
 
     "send ActorSelection targeted to missing actor to deadLetters" in {

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

@@ -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)

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

@@ -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 = {

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

@@ -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 {

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

@@ -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"));
+    final String id1 = "123";
-    router.tell(new Proxy.Message("123", "Text2"));
+    router.tell(new Proxy.Message(id1, "Text1"));
+    router.tell(new Proxy.Message(id1, "Text2"));
 
-    router.tell(new Proxy.Message("zh3", "Text3"));
+    final String id2 = "abcdef";
-    router.tell(new Proxy.Message("zh3", "Text4"));
+    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());
   }

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

@@ -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()

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

@@ -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)

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

@@ -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")
       }
     }
 

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

@@ -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

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

@@ -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
 

actor/src/main/scala/org/apache/pekko/actor/ActorRef.scala

@@ -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
 

actor/src/main/scala/org/apache/pekko/actor/ActorRefProvider.scala

@@ -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])

actor/src/main/scala/org/apache/pekko/actor/ActorSystem.scala

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

actor/src/main/scala/org/apache/pekko/actor/Address.scala

@@ -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(

actor/src/main/scala/org/apache/pekko/event/Logging.scala

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

actor/src/main/scala/org/apache/pekko/io/InetAddressDnsResolver.scala

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

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

@@ -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)

actor/src/main/scala/org/apache/pekko/serialization/AsyncSerializer.scala

@@ -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)
   }

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

@@ -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)

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

@@ -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)

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

@@ -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)

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

@@ -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 a1 = Address("pekko", "sys", "a1", 2551)
-  val b1 = Address("akka", "sys", "b1", 2551)
+  val b1 = Address("pekko", "sys", "b1", 2551)
-  val c1 = Address("akka", "sys", "c1", 2551)
+  val c1 = Address("pekko", "sys", "c1", 2551)
-  val d1 = Address("akka", "sys", "d1", 2551)
+  val d1 = Address("pekko", "sys", "d1", 2551)
 
   val decayFactor = Some(0.18)
 

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

@@ -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 node1 = Address("pekko", "sys", "a", 2554)
-  val node2 = Address("akka", "sys", "a", 2555)
+  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 m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
-      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), 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 m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
-      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), 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 m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
-      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
+      val m2 = NodeMetrics(Address("pekko", "sys", "a", 2555), newTimestamp, collector.sample().metrics)
-      val m3 = NodeMetrics(Address("akka", "sys", "a", 2556), 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 m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
-      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), 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 m1 = NodeMetrics(Address("pekko", "sys", "a", 2554), newTimestamp, collector.sample().metrics)
-      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), 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 node1 = NodeMetrics(Address("pekko", "sys", "a", 2554), 1, collector.sample().metrics)
-  val node2 = NodeMetrics(Address("akka", "sys", "a", 2555), 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, _) =>

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

@@ -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) {}
 

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

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

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

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

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

@@ -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
 
   }

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

@@ -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
 
 }

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

@@ -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)
 

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

@@ -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)
 

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

@@ -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)
 

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

@@ -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
+        // [pekko://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/2/RememberEntitiesStore] Recovery completed for shard [2] with [3] entities
         awaitAssert {
           region.tell(ShardRegion.GetShardRegionState, probe.ref)
           val state = probe.expectMsgType[ShardRegion.CurrentShardRegionState]

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

@@ -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("pekko", "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", "b", 2552) -> ShardRegion.ShardRegionStats(Map[ShardId, Int]("a" -> 23), Set("b")))))
     }
   }
 }

cluster-tools/src/main/resources/reference.conf

@@ -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 

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

@@ -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

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

@@ -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("pekko://OtherSys@host1:2552/system/receptionist"),
-      ActorPath.fromString("akka://OtherSys@host2:2552/system/receptionist"))
+      ActorPath.fromString("pekko://OtherSys@host2:2552/system/receptionist"))
     val settings = ClusterClientSettings(system).withInitialContacts(initialContacts)
     // #initialContacts
 

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

@@ -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("pekko://OtherSys@host1:2552/system/receptionist"),
-            ActorPaths.fromString("akka://OtherSys@host2:2552/system/receptionist")));
+            ActorPaths.fromString("pekko://OtherSys@host2:2552/system/receptionist")));
   }
   // #initialContacts
 

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

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

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

@@ -35,9 +35,9 @@ class DistributedPubSubMessageSerializerSpec extends PekkoSpec {
   " DistributedPubSubMessages" must {
 
     "be serializable" in {
-      val address1 = Address("akka", "system", "some.host.org", 4711)
+      val address1 = Address("pekko", "system", "some.host.org", 4711)
-      val address2 = Address("akka", "system", "other.host.org", 4711)
+      val address2 = Address("pekko", "system", "other.host.org", 4711)
-      val address3 = Address("akka", "system", "some.host.org", 4712)
+      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")

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

@@ -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 {
 

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

@@ -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("pekko://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:2552"));
 
     Cluster.get(system).manager().tell(new JoinSeedNodes(seedNodes));
     // #join-seed-nodes

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

@@ -52,8 +52,8 @@ pekko {
 
   cluster {
     seed-nodes = [
-      "akka://ClusterSystem@127.0.0.1:2551",
+      "pekko://ClusterSystem@127.0.0.1:2551",
-      "akka://ClusterSystem@127.0.0.1:2552"]
+      "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 =

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

@@ -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)))
     }

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

@@ -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)

cluster/src/main/resources/reference.conf

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

cluster/src/main/scala/org/apache/pekko/cluster/ClusterJmx.scala

@@ -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",
+   *         "pekko://system@host1:2552",
-   *         "akka://system@host3:2552"
+   *         "pekko://system@host3:2552"
    *       ]
    *     },
    *     {
-   *       "node": "akka://system@host3:2552",
+   *       "node": "pekko://system@host3:2552",
    *       "observed-by": [
-   *         "akka://system@host1:2552",
+   *         "pekko://system@host1:2552",
-   *         "akka://system@host2: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._

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

@@ -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 {

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

@@ -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
 

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

@@ -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 {
 

cluster/src/test/java/org/apache/pekko/cluster/ClusterJavaCompileTest.java

@@ -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);
   }
 }

cluster/src/test/scala/org/apache/pekko/cluster/ClusterDomainEventPublisherSpec.scala

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

cluster/src/test/scala/org/apache/pekko/cluster/ClusterDomainEventSpec.scala

@@ -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 aJoining = TestMember(Address("pekko", "sys", "a", 2552), Joining, aRoles)
-  val aUp = TestMember(Address("akka", "sys", "a", 2552), Up, aRoles)
+  val aUp = TestMember(Address("pekko", "sys", "a", 2552), Up, aRoles)
-  val aRemoved = TestMember(Address("akka", "sys", "a", 2552), Removed, 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 bUp = TestMember(Address("pekko", "sys", "b", 2552), Up, bRoles)
-  val bDown = TestMember(Address("akka", "sys", "b", 2552), Down, bRoles)
+  val bDown = TestMember(Address("pekko", "sys", "b", 2552), Down, bRoles)
-  val bRemoved = TestMember(Address("akka", "sys", "b", 2552), Removed, 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 cUp = TestMember(Address("pekko", "sys", "c", 2552), Up, cRoles)
-  val cLeaving = TestMember(Address("akka", "sys", "c", 2552), Leaving, 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 dLeaving = TestMember(Address("pekko", "sys", "d", 2552), Leaving, dRoles)
-  val dExiting = TestMember(Address("akka", "sys", "d", 2552), Exiting, dRoles)
+  val dExiting = TestMember(Address("pekko", "sys", "d", 2552), Exiting, dRoles)
-  val dRemoved = TestMember(Address("akka", "sys", "d", 2552), Removed, 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 eJoining = TestMember(Address("pekko", "sys", "e", 2552), Joining, eRoles)
-  val eUp = TestMember(Address("akka", "sys", "e", 2552), Up, eRoles)
+  val eUp = TestMember(Address("pekko", "sys", "e", 2552), Up, eRoles)
-  val eDown = TestMember(Address("akka", "sys", "e", 2552), Down, eRoles)
+  val eDown = TestMember(Address("pekko", "sys", "e", 2552), Down, eRoles)
-  val selfDummyAddress = UniqueAddress(Address("akka", "sys", "selfDummy", 2552), 17L)
+  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 dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
-      val dc2AMemberDown = TestMember(Address("akka", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
+      val dc2AMemberDown = TestMember(Address("pekko", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
-      val dc2BMemberUp = TestMember(Address("akka", "sys", "dc2B", 2552), Up, 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 dc3AMemberUp = TestMember(Address("pekko", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
-      val dc3BMemberUp = TestMember(Address("akka", "sys", "dc3B", 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 dc2AMemberUp = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
-      val dc2AMemberDown = TestMember(Address("akka", "sys", "dc2A", 2552), Down, 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 dc1MemberA = TestMember(Address("pekko", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
-      val dc1MemberB = TestMember(Address("akka", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
+      val dc1MemberB = TestMember(Address("pekko", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
-      val dc2MemberC = TestMember(Address("akka", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
+      val dc2MemberC = TestMember(Address("pekko", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
 
       val members = SortedSet(dc1MemberA, dc1MemberB, dc2MemberC)
 

cluster/src/test/scala/org/apache/pekko/cluster/ClusterHeartbeatSenderSpec.scala

@@ -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

cluster/src/test/scala/org/apache/pekko/cluster/ClusterHeartbeatSenderStateSpec.scala

@@ -52,11 +52,11 @@ object ClusterHeartbeatSenderStateSpec {
 class ClusterHeartbeatSenderStateSpec extends AnyWordSpec with Matchers {
   import ClusterHeartbeatSenderStateSpec._
 
-  val aa = UniqueAddress(Address("akka", "sys", "aa", 2552), 1L)
+  val aa = UniqueAddress(Address("pekko", "sys", "aa", 2552), 1L)
-  val bb = UniqueAddress(Address("akka", "sys", "bb", 2552), 2L)
+  val bb = UniqueAddress(Address("pekko", "sys", "bb", 2552), 2L)
-  val cc = UniqueAddress(Address("akka", "sys", "cc", 2552), 3L)
+  val cc = UniqueAddress(Address("pekko", "sys", "cc", 2552), 3L)
-  val dd = UniqueAddress(Address("akka", "sys", "dd", 2552), 4L)
+  val dd = UniqueAddress(Address("pekko", "sys", "dd", 2552), 4L)
-  val ee = UniqueAddress(Address("akka", "sys", "ee", 2552), 5L)
+  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)

cluster/src/test/scala/org/apache/pekko/cluster/ClusterSpec.scala

@@ -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("pekko", "sys", Some("localhost"), Some(0)),
-        Address("akka", "sys", Some("is_valid.org"), Some(0)),
+        Address("pekko", "sys", Some("is_valid.org"), Some(0)),
-        Address("akka", "sys", Some("fu.is_valid.org"), Some(0)),
+        Address("pekko", "sys", Some("fu.is_valid.org"), Some(0)),
-        Address("akka", "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

cluster/src/test/scala/org/apache/pekko/cluster/CrossDcHeartbeatSenderSpec.scala

@@ -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 {

cluster/src/test/scala/org/apache/pekko/cluster/GossipSpec.scala

@@ -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 d1 = TestMember(Address("pekko", "sys", "d", 2552), Leaving)
-  val e1 = TestMember(Address("akka", "sys", "e", 2552), Joining)
+  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 dc1a1 = TestMember(Address("pekko", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
-  val dc1b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
+  val dc1b1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
-  val dc2c1 = TestMember(Address("akka", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
+  val dc2c1 = TestMember(Address("pekko", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
-  val dc2d1 = TestMember(Address("akka", "sys", "d", 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)

cluster/src/test/scala/org/apache/pekko/cluster/GossipTargetSelectorSpec.scala

@@ -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 aDc1 = TestMember(Address("pekko", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
-  val bDc1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
+  val bDc1 = TestMember(Address("pekko", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
-  val cDc1 = TestMember(Address("akka", "sys", "c", 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 eDc2 = TestMember(Address("pekko", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2")
-  val fDc2 = TestMember(Address("akka", "sys", "f", 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 gDc3 = TestMember(Address("pekko", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3")
-  val hDc3 = TestMember(Address("akka", "sys", "h", 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)

cluster/src/test/scala/org/apache/pekko/cluster/HeartbeatNodeRingPerfSpec.scala

@@ -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)
   }

cluster/src/test/scala/org/apache/pekko/cluster/HeartbeatNodeRingSpec.scala

@@ -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 aa = UniqueAddress(Address("pekko", "sys", "aa", 2552), 1L)
-  val bb = UniqueAddress(Address("akka", "sys", "bb", 2552), 2L)
+  val bb = UniqueAddress(Address("pekko", "sys", "bb", 2552), 2L)
-  val cc = UniqueAddress(Address("akka", "sys", "cc", 2552), 3L)
+  val cc = UniqueAddress(Address("pekko", "sys", "cc", 2552), 3L)
-  val dd = UniqueAddress(Address("akka", "sys", "dd", 2552), 4L)
+  val dd = UniqueAddress(Address("pekko", "sys", "dd", 2552), 4L)
-  val ee = UniqueAddress(Address("akka", "sys", "ee", 2552), 5L)
+  val ee = UniqueAddress(Address("pekko", "sys", "ee", 2552), 5L)
-  val ff = UniqueAddress(Address("akka", "sys", "ff", 2552), 6L)
+  val ff = UniqueAddress(Address("pekko", "sys", "ff", 2552), 6L)
 
   val nodes = Set(aa, bb, cc, dd, ee, ff)
 

cluster/src/test/scala/org/apache/pekko/cluster/JoinConfigCompatCheckerSpec.scala

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

cluster/src/test/scala/org/apache/pekko/cluster/MemberOrderingSpec.scala

@@ -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("pekko://sys@darkstar:1112"), Up) +
-        m(AddressFromURIString("akka://sys@darkstar:1113"), Joining) +
+        m(AddressFromURIString("pekko://sys@darkstar:1113"), Joining) +
-        m(AddressFromURIString("akka://sys@darkstar:1111"), Up)
+        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(0) should ===(m(AddressFromURIString("pekko://sys@darkstar:1111"), Up))
-      seq(1) should ===(m(AddressFromURIString("akka://sys@darkstar:1112"), Up))
+      seq(1) should ===(m(AddressFromURIString("pekko://sys@darkstar:1112"), Up))
-      seq(2) should ===(m(AddressFromURIString("akka://sys@darkstar:1113"), Joining))
+      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 m1 = m(Address("pekko", "sys1", "host1", 9000), Up)
-      val m2 = m(Address("akka", "sys1", "host1", 10000), 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("pekko://sys@darkstar:1112") +
-        AddressFromURIString("akka://sys@darkstar:1113") +
+        AddressFromURIString("pekko://sys@darkstar:1113") +
-        AddressFromURIString("akka://sys@darkstar:1110") +
+        AddressFromURIString("pekko://sys@darkstar:1110") +
-        AddressFromURIString("akka://sys@darkstar:1111")
+        AddressFromURIString("pekko://sys@darkstar:1111")
 
       val seq = addresses.toSeq
       seq.size should ===(4)
-      seq(0) should ===(AddressFromURIString("akka://sys@darkstar:1110"))
+      seq(0) should ===(AddressFromURIString("pekko://sys@darkstar:1110"))
-      seq(1) should ===(AddressFromURIString("akka://sys@darkstar:1111"))
+      seq(1) should ===(AddressFromURIString("pekko://sys@darkstar:1111"))
-      seq(2) should ===(AddressFromURIString("akka://sys@darkstar:1112"))
+      seq(2) should ===(AddressFromURIString("pekko://sys@darkstar:1112"))
-      seq(3) should ===(AddressFromURIString("akka://sys@darkstar:1113"))
+      seq(3) should ===(AddressFromURIString("pekko://sys@darkstar:1113"))
     }
 
     "order addresses by hostname" in {
       val addresses = SortedSet.empty[Address] +
-        AddressFromURIString("akka://sys@darkstar2:1110") +
+        AddressFromURIString("pekko://sys@darkstar2:1110") +
-        AddressFromURIString("akka://sys@darkstar1:1110") +
+        AddressFromURIString("pekko://sys@darkstar1:1110") +
-        AddressFromURIString("akka://sys@darkstar3:1110") +
+        AddressFromURIString("pekko://sys@darkstar3:1110") +
-        AddressFromURIString("akka://sys@darkstar0:1110")
+        AddressFromURIString("pekko://sys@darkstar0:1110")
 
       val seq = addresses.toSeq
       seq.size should ===(4)
-      seq(0) should ===(AddressFromURIString("akka://sys@darkstar0:1110"))
+      seq(0) should ===(AddressFromURIString("pekko://sys@darkstar0:1110"))
-      seq(1) should ===(AddressFromURIString("akka://sys@darkstar1:1110"))
+      seq(1) should ===(AddressFromURIString("pekko://sys@darkstar1:1110"))
-      seq(2) should ===(AddressFromURIString("akka://sys@darkstar2:1110"))
+      seq(2) should ===(AddressFromURIString("pekko://sys@darkstar2:1110"))
-      seq(3) should ===(AddressFromURIString("akka://sys@darkstar3: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("pekko://sys@darkstar2:1110") +
-        AddressFromURIString("akka://sys@darkstar0:1111") +
+        AddressFromURIString("pekko://sys@darkstar0:1111") +
-        AddressFromURIString("akka://sys@darkstar2:1111") +
+        AddressFromURIString("pekko://sys@darkstar2:1111") +
-        AddressFromURIString("akka://sys@darkstar0:1110")
+        AddressFromURIString("pekko://sys@darkstar0:1110")
 
       val seq = addresses.toSeq
       seq.size should ===(4)
-      seq(0) should ===(AddressFromURIString("akka://sys@darkstar0:1110"))
+      seq(0) should ===(AddressFromURIString("pekko://sys@darkstar0:1110"))
-      seq(1) should ===(AddressFromURIString("akka://sys@darkstar0:1111"))
+      seq(1) should ===(AddressFromURIString("pekko://sys@darkstar0:1111"))
-      seq(2) should ===(AddressFromURIString("akka://sys@darkstar2:1110"))
+      seq(2) should ===(AddressFromURIString("pekko://sys@darkstar2:1110"))
-      seq(3) should ===(AddressFromURIString("akka://sys@darkstar2:1111"))
+      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)

cluster/src/test/scala/org/apache/pekko/cluster/MembershipStateSpec.scala

@@ -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 a1 = TestMember(Address("pekko", "sys", "a4", 2552), Up, 1, "dc-a")
-  val a2 = TestMember(Address("akka", "sys", "a3", 2552), Up, 2, "dc-a")
+  val a2 = TestMember(Address("pekko", "sys", "a3", 2552), Up, 2, "dc-a")
-  val a3 = TestMember(Address("akka", "sys", "a2", 2552), Up, 3, "dc-a")
+  val a3 = TestMember(Address("pekko", "sys", "a2", 2552), Up, 3, "dc-a")
-  val a4 = TestMember(Address("akka", "sys", "a1", 2552), Up, 4, "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 b1 = TestMember(Address("pekko", "sys", "b3", 2552), Up, 1, "dc-b")
-  val b3 = TestMember(Address("akka", "sys", "b2", 2552), Up, 3, "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,

cluster/src/test/scala/org/apache/pekko/cluster/ReachabilityPerfSpec.scala

@@ -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 address = Address("pekko", "sys", "a", 2552)
-  val node = Address("akka", "sys", "a", 2552)
+  val node = Address("pekko", "sys", "a", 2552)
 
   private def createReachabilityOfSize(base: Reachability, size: Int): Reachability =
     (1 to size).foldLeft(base) {

cluster/src/test/scala/org/apache/pekko/cluster/ReachabilitySpec.scala

@@ -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 nodeA = UniqueAddress(Address("pekko", "sys", "a", 2552), 1L)
-  val nodeB = UniqueAddress(Address("akka", "sys", "b", 2552), 2L)
+  val nodeB = UniqueAddress(Address("pekko", "sys", "b", 2552), 2L)
-  val nodeC = UniqueAddress(Address("akka", "sys", "c", 2552), 3L)
+  val nodeC = UniqueAddress(Address("pekko", "sys", "c", 2552), 3L)
-  val nodeD = UniqueAddress(Address("akka", "sys", "d", 2552), 4L)
+  val nodeD = UniqueAddress(Address("pekko", "sys", "d", 2552), 4L)
-  val nodeE = UniqueAddress(Address("akka", "sys", "e", 2552), 5L)
+  val nodeE = UniqueAddress(Address("pekko", "sys", "e", 2552), 5L)
 
   "Reachability table" must {
 

cluster/src/test/scala/org/apache/pekko/cluster/protobuf/ClusterMessageSerializerSpec.scala

@@ -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"))
+    TestMember(Address("pekko", "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"))
+  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"))
+    TestMember(Address("pekko", "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 d1 = TestMember(Address("pekko", "sys", "d", 2552), Exiting, Set("r1"), "foo")
-  val e1 = TestMember(Address("akka", "sys", "e", 2552), Down, Set("r3"))
+  val e1 = TestMember(Address("pekko", "sys", "e", 2552), Down, Set("r3"))
-  val f1 = TestMember(Address("akka", "sys", "f", 2552), Removed, Set("r3"), "foo")
+  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),

cluster/src/test/scala/org/apache/pekko/cluster/sbr/TestAddresses.scala

@@ -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(

cluster/src/test/scala/org/apache/pekko/cluster/testkit/AutoDownSpec.scala

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

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

@@ -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)

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

@@ -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 selfUniqueAddress = UniqueAddress(Address("pekko", "Sys", "localhost", 4999), 17L)
-  val nodes = (2500 until 2600).map(n => UniqueAddress(Address("akka", "Sys", "localhost", n), 17L)).toVector
+  val nodes = (2500 until 2600).map(n => UniqueAddress(Address("pekko", "Sys", "localhost", n), 17L)).toVector
 
   "DeltaPropagationSelector" must {
     "collect none when no nodes" in {

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

@@ -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)
 

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

@@ -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 {

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

@@ -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 {

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

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

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

@@ -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 {

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

@@ -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 {

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

@@ -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)

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

@@ -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 {

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

@@ -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 {

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

@@ -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)

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

@@ -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)

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

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

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

@@ -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)

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

@@ -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)

docs/src/test/java/jdocs/actor/fsm/FSMDocTest.java

@@ -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/"));
       }
     };
   }

docs/src/test/java/jdocs/remoting/RemoteDeploymentDocTest.java

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

docs/src/test/java/jdocs/testkit/TestKitDocTest.java

@@ -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(
                     () -> {

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

@@ -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
                 }

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

@@ -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)
     }
   }
 

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

@@ -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) {

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

@@ -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)

persistence/src/main/resources/reference.conf

@@ -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 {
 

project/Doc.scala

@@ -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.