From 71e9bdc262fb0be3de00b4d03d678a53ec7e0b0f Mon Sep 17 00:00:00 2001
From: Patrik Nordwall <patrik.nordwall@gmail.com>
Date: Wed, 15 May 2019 18:01:34 +0200
Subject: [PATCH] more classic remoting leftovers

* fix several tests that were using akka.remote.netty.tcp config
* replace akka.tcp with akka in more places
* some doc cross references to remoting.md
---
 .../src/test/java/akka/actor/JavaAPI.java     |  2 +-
 .../test/scala/akka/actor/ActorPathSpec.scala | 44 +++++++++----------
 .../cluster/ddata/ORSetMergeBenchmark.scala   | 10 ++---
 .../ddata/ORSetSerializationBenchmark.scala   |  2 +-
 .../ddata/VersionVectorBenchmark.scala        | 10 ++---
 .../metrics/ClusterMetricsRoutingSpec.scala   |  8 ++--
 .../akka/cluster/metrics/MetricSpec.scala     | 32 +++++++-------
 .../protobuf/MessageSerializerSpec.scala      | 12 ++---
 .../src/main/resources/reference.conf         |  2 +-
 .../akka/cluster/client/ClusterClient.scala   |  2 +-
 .../cluster/client/ClusterClientSpec.scala    |  4 +-
 .../cluster/client/ClusterClientTest.java     |  4 +-
 .../ClusterClientMessageSerializerSpec.scala  |  6 +--
 ...stributedPubSubMessageSerializerSpec.scala |  6 +--
 .../ClusterSingletonLeavingSpeedSpec.scala    |  2 +-
 .../singleton/ClusterSingletonProxySpec.scala |  4 +-
 .../ClusterSingletonRestart2Spec.scala        |  2 +-
 .../ClusterSingletonRestartSpec.scala         |  2 +-
 .../typed/BasicClusterExampleTest.java        |  4 +-
 .../typed/BasicClusterExampleSpec.scala       | 14 +++---
 .../src/main/resources/reference.conf         |  2 +-
 .../main/scala/akka/cluster/ClusterJmx.scala  | 34 +++++++-------
 .../scala/akka/cluster/NodeChurnSpec.scala    |  2 +-
 .../akka/cluster/ClusterJavaCompileTest.java  |  2 +-
 .../akka/cluster/ClusterDomainEventSpec.scala | 44 +++++++++----------
 .../ClusterHeartbeatSenderStateSpec.scala     | 15 +++----
 .../akka/cluster/DowningProviderSpec.scala    |  2 +-
 .../test/scala/akka/cluster/GossipSpec.scala  | 20 ++++-----
 .../cluster/GossipTargetSelectorSpec.scala    | 16 +++----
 .../cluster/HeartbeatNodeRingPerfSpec.scala   |  2 +-
 .../akka/cluster/HeartbeatNodeRingSpec.scala  | 12 ++---
 .../akka/cluster/MemberOrderingSpec.scala     | 12 ++---
 .../akka/cluster/MembershipStateSpec.scala    | 30 ++++++-------
 .../akka/cluster/ReachabilityPerfSpec.scala   |  4 +-
 .../scala/akka/cluster/ReachabilitySpec.scala | 10 ++---
 .../ClusterMessageSerializerSpec.scala        | 20 ++++-----
 .../akka/cluster/ddata/PerformanceSpec.scala  |  4 +-
 .../akka/cluster/ddata/DataEnvelopeSpec.scala |  2 +-
 .../akka/cluster/ddata/GCounterSpec.scala     |  2 +-
 .../scala/akka/cluster/ddata/LWWMapSpec.scala |  2 +-
 .../akka/cluster/ddata/LWWRegisterSpec.scala  |  2 +-
 .../akka/cluster/ddata/LotsOfDataBot.scala    | 11 ++---
 .../scala/akka/cluster/ddata/ORMapSpec.scala  |  2 +-
 .../akka/cluster/ddata/ORMultiMapSpec.scala   |  2 +-
 .../scala/akka/cluster/ddata/ORSetSpec.scala  |  4 +-
 .../akka/cluster/ddata/PNCounterMapSpec.scala |  2 +-
 .../akka/cluster/ddata/PNCounterSpec.scala    |  2 +-
 .../akka/cluster/ddata/PruningStateSpec.scala |  2 +-
 .../cluster/ddata/VersionVectorSpec.scala     |  2 +-
 akka-docs/src/main/paradox/actors.md          |  2 +-
 .../src/main/paradox/additional/deploy.md     |  2 +-
 akka-docs/src/main/paradox/additional/faq.md  | 12 ++---
 akka-docs/src/main/paradox/cluster-usage.md   | 31 +++++--------
 .../src/main/paradox/general/addressing.md    |  8 ++--
 .../src/main/paradox/general/configuration.md |  6 +--
 .../src/main/paradox/general/remoting.md      |  4 +-
 akka-docs/src/main/paradox/index-cluster.md   |  5 ++-
 akka-docs/src/main/paradox/logging.md         | 37 ++++------------
 akka-docs/src/main/paradox/security/index.md  |  4 +-
 akka-docs/src/main/paradox/serialization.md   |  2 +-
 .../test/java/jdocs/actor/ActorDocTest.java   |  2 +-
 .../LambdaPersistencePluginDocTest.java       |  2 +-
 .../remoting/RemoteDeploymentDocTest.java     |  4 +-
 .../java/jdocs/routing/RouterDocTest.java     |  4 +-
 .../test/scala/docs/actor/ActorDocSpec.scala  |  2 +-
 .../scala/docs/config/ConfigDocSpec.scala     |  2 +-
 .../PersistencePluginDocSpec.scala            |  2 +-
 .../remoting/RemoteDeploymentDocSpec.scala    |  6 +--
 .../scala/docs/routing/RouterDocSpec.scala    | 13 +++---
 akka-remote/src/main/resources/reference.conf |  4 +-
 .../akka/remote/RemoteActorRefProvider.scala  |  8 ++--
 .../test/scala/akka/remote/DaemonicSpec.scala |  4 +-
 .../akka/stream/scaladsl/StreamRefsSpec.scala |  2 +-
 73 files changed, 284 insertions(+), 322 deletions(-)

diff --git a/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java b/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java
index d605959b3e..4cf46b6956 100644
--- a/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java
+++ b/akka-actor-tests/src/test/java/akka/actor/JavaAPI.java
@@ -51,7 +51,7 @@ public class JavaAPI extends JUnitSuite {
     final NoRouter nr = NoRouter.getInstance();
     final FromConfig fc = FromConfig.getInstance();
 
-    final ActorPath p = ActorPaths.fromString("akka.tcp://Sys@localhost:1234/user/abc");
+    final ActorPath p = ActorPaths.fromString("akka://Sys@localhost:1234/user/abc");
   }
 
   @Test
diff --git a/akka-actor-tests/src/test/scala/akka/actor/ActorPathSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/ActorPathSpec.scala
index 31b391f863..b00c5edd35 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/ActorPathSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/ActorPathSpec.scala
@@ -13,7 +13,7 @@ class ActorPathSpec extends WordSpec with Matchers {
   "An ActorPath" must {
 
     "support parsing its String rep" in {
-      val path = RootActorPath(Address("akka.tcp", "mysys")) / "user"
+      val path = RootActorPath(Address("akka", "mysys")) / "user"
       ActorPath.fromString(path.toString) should ===(path)
     }
 
@@ -31,20 +31,20 @@ class ActorPathSpec extends WordSpec with Matchers {
     }
 
     "create correct toString" in {
-      val a = Address("akka.tcp", "mysys")
-      RootActorPath(a).toString should ===("akka.tcp://mysys/")
-      (RootActorPath(a) / "user").toString should ===("akka.tcp://mysys/user")
-      (RootActorPath(a) / "user" / "foo").toString should ===("akka.tcp://mysys/user/foo")
-      (RootActorPath(a) / "user" / "foo" / "bar").toString should ===("akka.tcp://mysys/user/foo/bar")
+      val a = Address("akka", "mysys")
+      RootActorPath(a).toString should ===("akka://mysys/")
+      (RootActorPath(a) / "user").toString should ===("akka://mysys/user")
+      (RootActorPath(a) / "user" / "foo").toString should ===("akka://mysys/user/foo")
+      (RootActorPath(a) / "user" / "foo" / "bar").toString should ===("akka://mysys/user/foo/bar")
     }
 
     "have correct path elements" in {
-      (RootActorPath(Address("akka.tcp", "mysys")) / "user" / "foo" / "bar").elements.toSeq should ===(
+      (RootActorPath(Address("akka", "mysys")) / "user" / "foo" / "bar").elements.toSeq should ===(
         Seq("user", "foo", "bar"))
     }
 
     "create correct toStringWithoutAddress" in {
-      val a = Address("akka.tcp", "mysys")
+      val a = Address("akka", "mysys")
       RootActorPath(a).toStringWithoutAddress should ===("/")
       (RootActorPath(a) / "user").toStringWithoutAddress should ===("/user")
       (RootActorPath(a) / "user" / "foo").toStringWithoutAddress should ===("/user/foo")
@@ -57,32 +57,32 @@ class ActorPathSpec extends WordSpec with Matchers {
     }
 
     "create correct toStringWithAddress" in {
-      val local = Address("akka.tcp", "mysys")
+      val local = Address("akka", "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.tcp://mysys@aaa:2552/")
-      (root / "user").toStringWithAddress(a) should ===("akka.tcp://mysys@aaa:2552/user")
-      (root / "user" / "foo").toStringWithAddress(a) should ===("akka.tcp://mysys@aaa:2552/user/foo")
+      root.toStringWithAddress(a) should ===("akka://mysys@aaa:2552/")
+      (root / "user").toStringWithAddress(a) should ===("akka://mysys@aaa:2552/user")
+      (root / "user" / "foo").toStringWithAddress(a) should ===("akka://mysys@aaa:2552/user/foo")
 
-      //      root.toStringWithAddress(b) should ===("akka.tcp://mysys@bb:2552/")
-      (root / "user").toStringWithAddress(b) should ===("akka.tcp://mysys@bb:2552/user")
-      (root / "user" / "foo").toStringWithAddress(b) should ===("akka.tcp://mysys@bb:2552/user/foo")
+      //      root.toStringWithAddress(b) should ===("akka://mysys@bb:2552/")
+      (root / "user").toStringWithAddress(b) should ===("akka://mysys@bb:2552/user")
+      (root / "user" / "foo").toStringWithAddress(b) should ===("akka://mysys@bb:2552/user/foo")
 
-      root.toStringWithAddress(c) should ===("akka.tcp://mysys@cccc:2552/")
-      (root / "user").toStringWithAddress(c) should ===("akka.tcp://mysys@cccc:2552/user")
-      (root / "user" / "foo").toStringWithAddress(c) should ===("akka.tcp://mysys@cccc:2552/user/foo")
+      root.toStringWithAddress(c) should ===("akka://mysys@cccc:2552/")
+      (root / "user").toStringWithAddress(c) should ===("akka://mysys@cccc:2552/user")
+      (root / "user" / "foo").toStringWithAddress(c) should ===("akka://mysys@cccc:2552/user/foo")
 
       val rootA = RootActorPath(a)
-      rootA.toStringWithAddress(b) should ===("akka.tcp://mysys@aaa:2552/")
-      (rootA / "user").toStringWithAddress(b) should ===("akka.tcp://mysys@aaa:2552/user")
-      (rootA / "user" / "foo").toStringWithAddress(b) should ===("akka.tcp://mysys@aaa:2552/user/foo")
+      rootA.toStringWithAddress(b) should ===("akka://mysys@aaa:2552/")
+      (rootA / "user").toStringWithAddress(b) should ===("akka://mysys@aaa:2552/user")
+      (rootA / "user" / "foo").toStringWithAddress(b) should ===("akka://mysys@aaa:2552/user/foo")
     }
 
     "not allow path separators in RootActorPath's name" in {
       intercept[IllegalArgumentException] {
-        RootActorPath(Address("akka.tcp", "mysys"), "/user/boom/*") // illegally pass in a path where name is expected
+        RootActorPath(Address("akka", "mysys"), "/user/boom/*") // illegally pass in a path where name is expected
       }.getMessage should include("is a path separator")
 
       // sanity check that creating such path still works
diff --git a/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetMergeBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetMergeBenchmark.scala
index 447dff70cb..50bd41172f 100644
--- a/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetMergeBenchmark.scala
+++ b/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetMergeBenchmark.scala
@@ -31,11 +31,11 @@ class ORSetMergeBenchmark {
   @Param(Array("1", "10", "20", "100"))
   var set1Size = 0
 
-  val nodeA = UniqueAddress(Address("akka.tcp", "Sys", "aaaa", 2552), 1)
-  val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2)
-  val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3)
-  val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4)
-  val nodeE = UniqueAddress(nodeA.address.copy(host = Some("eeee")), 5)
+  val nodeA = UniqueAddress(Address("akka", "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)
+  val nodeE = UniqueAddress(nodeA.address.copy(host = Some("eeee")), 5L)
   val nodes = Vector(nodeA, nodeB, nodeC, nodeD, nodeE)
   val nodesIndex = Iterator.from(0)
   def nextNode(): UniqueAddress = nodes(nodesIndex.next() % nodes.size)
diff --git a/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetSerializationBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetSerializationBenchmark.scala
index d9fb57a9f0..37fa2d2f06 100644
--- a/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetSerializationBenchmark.scala
+++ b/akka-bench-jmh/src/main/scala/akka/cluster/ddata/ORSetSerializationBenchmark.scala
@@ -37,7 +37,7 @@ class ORSetSerializationBenchmark {
 
   private val config = ConfigFactory.parseString("""
     akka.actor.provider=cluster
-    akka.remote.netty.tcp.port=0
+    akka.remote.classic.netty.tcp.port=0
     akka.remote.artery.canonical.port = 0
     akka.actor {
       serialize-messages = off
diff --git a/akka-bench-jmh/src/main/scala/akka/cluster/ddata/VersionVectorBenchmark.scala b/akka-bench-jmh/src/main/scala/akka/cluster/ddata/VersionVectorBenchmark.scala
index 4aefd4bfbe..aba04cdaaa 100644
--- a/akka-bench-jmh/src/main/scala/akka/cluster/ddata/VersionVectorBenchmark.scala
+++ b/akka-bench-jmh/src/main/scala/akka/cluster/ddata/VersionVectorBenchmark.scala
@@ -31,11 +31,11 @@ class VersionVectorBenchmark {
   @Param(Array("1", "2", "5"))
   var size = 0
 
-  val nodeA = UniqueAddress(Address("akka.tcp", "Sys", "aaaa", 2552), 1)
-  val nodeB = UniqueAddress(nodeA.address.copy(host = Some("bbbb")), 2)
-  val nodeC = UniqueAddress(nodeA.address.copy(host = Some("cccc")), 3)
-  val nodeD = UniqueAddress(nodeA.address.copy(host = Some("dddd")), 4)
-  val nodeE = UniqueAddress(nodeA.address.copy(host = Some("eeee")), 5)
+  val nodeA = UniqueAddress(Address("akka", "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)
+  val nodeE = UniqueAddress(nodeA.address.copy(host = Some("eeee")), 5L)
   val nodes = Vector(nodeA, nodeB, nodeC, nodeD, nodeE)
   val nodesIndex = Iterator.from(0)
   def nextNode(): UniqueAddress = nodes(nodesIndex.next() % nodes.size)
diff --git a/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/ClusterMetricsRoutingSpec.scala b/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/ClusterMetricsRoutingSpec.scala
index 955c36e825..712ec4bb1e 100644
--- a/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/ClusterMetricsRoutingSpec.scala
+++ b/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/ClusterMetricsRoutingSpec.scala
@@ -18,10 +18,10 @@ class MetricsSelectorSpec extends WordSpec with Matchers {
     override def capacity(nodeMetrics: Set[NodeMetrics]): Map[Address, Double] = Map.empty
   }
 
-  val a1 = Address("akka.tcp", "sys", "a1", 2551)
-  val b1 = Address("akka.tcp", "sys", "b1", 2551)
-  val c1 = Address("akka.tcp", "sys", "c1", 2551)
-  val d1 = Address("akka.tcp", "sys", "d1", 2551)
+  val a1 = Address("akka", "sys", "a1", 2551)
+  val b1 = Address("akka", "sys", "b1", 2551)
+  val c1 = Address("akka", "sys", "c1", 2551)
+  val d1 = Address("akka", "sys", "d1", 2551)
 
   val decayFactor = Some(0.18)
 
diff --git a/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/MetricSpec.scala b/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/MetricSpec.scala
index 1584114299..28643b97d2 100644
--- a/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/MetricSpec.scala
+++ b/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/MetricSpec.scala
@@ -58,8 +58,8 @@ class MetricNumericConverterSpec extends WordSpec with Matchers with MetricNumer
 @silent
 class NodeMetricsSpec extends WordSpec with Matchers {
 
-  val node1 = Address("akka.tcp", "sys", "a", 2554)
-  val node2 = Address("akka.tcp", "sys", "a", 2555)
+  val node1 = Address("akka", "sys", "a", 2554)
+  val node2 = Address("akka", "sys", "a", 2555)
 
   "NodeMetrics must" must {
 
@@ -151,8 +151,8 @@ class MetricsGossipSpec
 
   "A MetricsGossip" must {
     "add new NodeMetrics" in {
-      val m1 = NodeMetrics(Address("akka.tcp", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
-      val m2 = NodeMetrics(Address("akka.tcp", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
+      val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
+      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
 
       m1.metrics.size should be > 3
       m2.metrics.size should be > 3
@@ -168,8 +168,8 @@ class MetricsGossipSpec
     }
 
     "merge peer metrics" in {
-      val m1 = NodeMetrics(Address("akka.tcp", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
-      val m2 = NodeMetrics(Address("akka.tcp", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
+      val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
+      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
 
       val g1 = MetricsGossip.empty :+ m1 :+ m2
       g1.nodes.size should ===(2)
@@ -183,9 +183,9 @@ class MetricsGossipSpec
     }
 
     "merge an existing metric set for a node and update node ring" in {
-      val m1 = NodeMetrics(Address("akka.tcp", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
-      val m2 = NodeMetrics(Address("akka.tcp", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
-      val m3 = NodeMetrics(Address("akka.tcp", "sys", "a", 2556), newTimestamp, collector.sample.metrics)
+      val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
+      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
+      val m3 = NodeMetrics(Address("akka", "sys", "a", 2556), newTimestamp, collector.sample.metrics)
       val m2Updated = m2.copy(metrics = newSample(m2.metrics), timestamp = m2.timestamp + 1000)
 
       val g1 = MetricsGossip.empty :+ m1 :+ m2
@@ -204,14 +204,14 @@ class MetricsGossipSpec
     }
 
     "get the current NodeMetrics if it exists in the local nodes" in {
-      val m1 = NodeMetrics(Address("akka.tcp", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
+      val m1 = NodeMetrics(Address("akka", "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.tcp", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
-      val m2 = NodeMetrics(Address("akka.tcp", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
+      val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
+      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
 
       val g1 = MetricsGossip.empty :+ m1 :+ m2
       g1.nodes.size should ===(2)
@@ -223,8 +223,8 @@ class MetricsGossipSpec
     }
 
     "filter nodes" in {
-      val m1 = NodeMetrics(Address("akka.tcp", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
-      val m2 = NodeMetrics(Address("akka.tcp", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
+      val m1 = NodeMetrics(Address("akka", "sys", "a", 2554), newTimestamp, collector.sample.metrics)
+      val m2 = NodeMetrics(Address("akka", "sys", "a", 2555), newTimestamp, collector.sample.metrics)
 
       val g1 = MetricsGossip.empty :+ m1 :+ m2
       g1.nodes.size should ===(2)
@@ -243,8 +243,8 @@ class MetricValuesSpec extends AkkaSpec(MetricsConfig.defaultEnabled) with Metri
 
   val collector = createMetricsCollector
 
-  val node1 = NodeMetrics(Address("akka.tcp", "sys", "a", 2554), 1, collector.sample.metrics)
-  val node2 = NodeMetrics(Address("akka.tcp", "sys", "a", 2555), 1, collector.sample.metrics)
+  val node1 = NodeMetrics(Address("akka", "sys", "a", 2554), 1, collector.sample.metrics)
+  val node2 = NodeMetrics(Address("akka", "sys", "a", 2555), 1, collector.sample.metrics)
 
   val nodes: Seq[NodeMetrics] = {
     (1 to 100).foldLeft(List(node1, node2)) { (nodes, _) =>
diff --git a/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/protobuf/MessageSerializerSpec.scala b/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/protobuf/MessageSerializerSpec.scala
index c2668662d4..019798639f 100644
--- a/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/protobuf/MessageSerializerSpec.scala
+++ b/akka-cluster-metrics/src/test/scala/akka/cluster/metrics/protobuf/MessageSerializerSpec.scala
@@ -31,12 +31,12 @@ class MessageSerializerSpec extends AkkaSpec("""
 
   import MemberStatus._
 
-  val a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Joining, Set.empty)
-  val b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set("r1"))
-  val c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving, Set("r2"))
-  val d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Exiting, Set("r1", "r2"))
-  val e1 = TestMember(Address("akka.tcp", "sys", "e", 2552), Down, Set("r3"))
-  val f1 = TestMember(Address("akka.tcp", "sys", "f", 2552), Removed, Set("r2", "r3"))
+  val a1 = TestMember(Address("akka", "sys", "a", 2552), Joining, Set.empty)
+  val b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set("r1"))
+  val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving, Set("r2"))
+  val d1 = TestMember(Address("akka", "sys", "d", 2552), Exiting, Set("r1", "r2"))
+  val e1 = TestMember(Address("akka", "sys", "e", 2552), Down, Set("r3"))
+  val f1 = TestMember(Address("akka", "sys", "f", 2552), Removed, Set("r2", "r3"))
 
   "ClusterMessages" must {
 
diff --git a/akka-cluster-tools/src/main/resources/reference.conf b/akka-cluster-tools/src/main/resources/reference.conf
index dee5c314e5..196e5d2dcb 100644
--- a/akka-cluster-tools/src/main/resources/reference.conf
+++ b/akka-cluster-tools/src/main/resources/reference.conf
@@ -101,7 +101,7 @@ akka.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.tcp://system@hostname:port/system/receptionist"
+  # "akka://system@hostname:port/system/receptionist"
   initial-contacts = []
   
   # Interval at which the client retries to establish contact with one of 
diff --git a/akka-cluster-tools/src/main/scala/akka/cluster/client/ClusterClient.scala b/akka-cluster-tools/src/main/scala/akka/cluster/client/ClusterClient.scala
index c06cf90b76..3f515dc8e8 100644
--- a/akka-cluster-tools/src/main/scala/akka/cluster/client/ClusterClient.scala
+++ b/akka-cluster-tools/src/main/scala/akka/cluster/client/ClusterClient.scala
@@ -88,7 +88,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.tcp://system@hostname:port/system/receptionist"
+ *   "akka://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
diff --git a/akka-cluster-tools/src/multi-jvm/scala/akka/cluster/client/ClusterClientSpec.scala b/akka-cluster-tools/src/multi-jvm/scala/akka/cluster/client/ClusterClientSpec.scala
index 43d2fd7b09..453af0a75d 100644
--- a/akka-cluster-tools/src/multi-jvm/scala/akka/cluster/client/ClusterClientSpec.scala
+++ b/akka-cluster-tools/src/multi-jvm/scala/akka/cluster/client/ClusterClientSpec.scala
@@ -194,8 +194,8 @@ class ClusterClientSpec extends MultiNodeSpec(ClusterClientSpec) with STMultiNod
   def docOnly = { //not used, only demo
     //#initialContacts
     val initialContacts = Set(
-      ActorPath.fromString("akka.tcp://OtherSys@host1:2552/system/receptionist"),
-      ActorPath.fromString("akka.tcp://OtherSys@host2:2552/system/receptionist"))
+      ActorPath.fromString("akka://OtherSys@host1:2552/system/receptionist"),
+      ActorPath.fromString("akka://OtherSys@host2:2552/system/receptionist"))
     val settings = ClusterClientSettings(system).withInitialContacts(initialContacts)
     //#initialContacts
 
diff --git a/akka-cluster-tools/src/test/java/akka/cluster/client/ClusterClientTest.java b/akka-cluster-tools/src/test/java/akka/cluster/client/ClusterClientTest.java
index 06ea64abd9..732c050c4d 100644
--- a/akka-cluster-tools/src/test/java/akka/cluster/client/ClusterClientTest.java
+++ b/akka-cluster-tools/src/test/java/akka/cluster/client/ClusterClientTest.java
@@ -32,8 +32,8 @@ public class ClusterClientTest extends JUnitSuite {
   Set<ActorPath> initialContacts() {
     return new HashSet<ActorPath>(
         Arrays.asList(
-            ActorPaths.fromString("akka.tcp://OtherSys@host1:2552/system/receptionist"),
-            ActorPaths.fromString("akka.tcp://OtherSys@host2:2552/system/receptionist")));
+            ActorPaths.fromString("akka://OtherSys@host1:2552/system/receptionist"),
+            ActorPaths.fromString("akka://OtherSys@host2:2552/system/receptionist")));
   }
   // #initialContacts
 
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/client/protobuf/ClusterClientMessageSerializerSpec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/client/protobuf/ClusterClientMessageSerializerSpec.scala
index a7289399a2..1e6f34f9cd 100644
--- a/akka-cluster-tools/src/test/scala/akka/cluster/client/protobuf/ClusterClientMessageSerializerSpec.scala
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/client/protobuf/ClusterClientMessageSerializerSpec.scala
@@ -22,9 +22,9 @@ class ClusterClientMessageSerializerSpec extends AkkaSpec {
 
     "be serializable" in {
       val contactPoints = Vector(
-        "akka.tcp://system@node-1:2552/system/receptionist",
-        "akka.tcp://system@node-2:2552/system/receptionist",
-        "akka.tcp://system@node-3:2552/system/receptionist")
+        "akka://system@node-1:2552/system/receptionist",
+        "akka://system@node-2:2552/system/receptionist",
+        "akka://system@node-3:2552/system/receptionist")
       checkSerialization(Contacts(contactPoints))
       checkSerialization(GetContacts)
       checkSerialization(Heartbeat)
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/pubsub/protobuf/DistributedPubSubMessageSerializerSpec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/pubsub/protobuf/DistributedPubSubMessageSerializerSpec.scala
index 741789cda7..03b4286939 100644
--- a/akka-cluster-tools/src/test/scala/akka/cluster/pubsub/protobuf/DistributedPubSubMessageSerializerSpec.scala
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/pubsub/protobuf/DistributedPubSubMessageSerializerSpec.scala
@@ -24,9 +24,9 @@ class DistributedPubSubMessageSerializerSpec extends AkkaSpec {
   " DistributedPubSubMessages" must {
 
     "be serializable" in {
-      val address1 = Address("akka.tcp", "system", "some.host.org", 4711)
-      val address2 = Address("akka.tcp", "system", "other.host.org", 4711)
-      val address3 = Address("akka.tcp", "system", "some.host.org", 4712)
+      val address1 = Address("akka", "system", "some.host.org", 4711)
+      val address2 = Address("akka", "system", "other.host.org", 4711)
+      val address3 = Address("akka", "system", "some.host.org", 4712)
       val u1 = system.actorOf(Props.empty, "u1")
       val u2 = system.actorOf(Props.empty, "u2")
       val u3 = system.actorOf(Props.empty, "u3")
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonLeavingSpeedSpec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonLeavingSpeedSpec.scala
index f5dae7d938..0d0234308e 100644
--- a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonLeavingSpeedSpec.scala
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonLeavingSpeedSpec.scala
@@ -52,7 +52,7 @@ class ClusterSingletonLeavingSpeedSpec
   # akka.cluster.gossip-interval = 2s
 
   akka.remote {
-    netty.tcp {
+    classic.netty.tcp {
       hostname = "127.0.0.1"
       port = 0
     }
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonProxySpec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonProxySpec.scala
index fe4304ba7f..e9137c63d4 100644
--- a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonProxySpec.scala
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonProxySpec.scala
@@ -69,8 +69,8 @@ object ClusterSingletonProxySpec {
       cluster.jmx.enabled = off
       actor.provider = "cluster"
       remote {
-        log-remote-lifecycle-events = off
-        netty.tcp {
+        classic.log-remote-lifecycle-events = off
+        classic.netty.tcp {
           hostname = "127.0.0.1"
           port = 0
         }
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestart2Spec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestart2Spec.scala
index 5a78eef507..5a23c02d72 100644
--- a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestart2Spec.scala
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestart2Spec.scala
@@ -33,7 +33,7 @@ class ClusterSingletonRestart2Spec extends AkkaSpec("""
   akka.cluster.auto-down-unreachable-after = 2s
   akka.cluster.singleton.min-number-of-hand-over-retries = 5
   akka.remote {
-    netty.tcp {
+    classic.netty.tcp {
       hostname = "127.0.0.1"
       port = 0
     }
diff --git a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala
index 6b65409315..d9c1c7a3e7 100644
--- a/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala
+++ b/akka-cluster-tools/src/test/scala/akka/cluster/singleton/ClusterSingletonRestartSpec.scala
@@ -19,7 +19,7 @@ class ClusterSingletonRestartSpec extends AkkaSpec("""
   akka.actor.provider = akka.cluster.ClusterActorRefProvider
   akka.cluster.auto-down-unreachable-after = 2s
   akka.remote {
-    netty.tcp {
+    classic.netty.tcp {
       hostname = "127.0.0.1"
       port = 0
     }
diff --git a/akka-cluster-typed/src/test/java/jdocs/akka/cluster/typed/BasicClusterExampleTest.java b/akka-cluster-typed/src/test/java/jdocs/akka/cluster/typed/BasicClusterExampleTest.java
index eeea72eae1..cf7a5d587c 100644
--- a/akka-cluster-typed/src/test/java/jdocs/akka/cluster/typed/BasicClusterExampleTest.java
+++ b/akka-cluster-typed/src/test/java/jdocs/akka/cluster/typed/BasicClusterExampleTest.java
@@ -21,8 +21,8 @@ public class BasicClusterExampleTest { // extends JUnitSuite {
       ConfigFactory.parseString(
           "akka { \n"
               + "  actor.provider = cluster \n"
-              + "  remote { \n"
-              + "    netty.tcp { \n"
+              + "  remote.artery { \n"
+              + "    canonical { \n"
               + "      hostname = \"127.0.0.1\" \n"
               + "      port = 2551 \n"
               + "    } \n"
diff --git a/akka-cluster-typed/src/test/scala/docs/akka/cluster/typed/BasicClusterExampleSpec.scala b/akka-cluster-typed/src/test/scala/docs/akka/cluster/typed/BasicClusterExampleSpec.scala
index 66bbb095fa..ed751f24a2 100644
--- a/akka-cluster-typed/src/test/scala/docs/akka/cluster/typed/BasicClusterExampleSpec.scala
+++ b/akka-cluster-typed/src/test/scala/docs/akka/cluster/typed/BasicClusterExampleSpec.scala
@@ -27,8 +27,8 @@ akka {
   actor {
     provider = "cluster"
   }
-  remote {
-    netty.tcp {
+  remote.artery {
+    canonical {
       hostname = "127.0.0.1"
       port = 2551
     }
@@ -36,8 +36,8 @@ akka {
 
   cluster {
     seed-nodes = [
-      "akka.tcp://ClusterSystem@127.0.0.1:2551",
-      "akka.tcp://ClusterSystem@127.0.0.1:2552"]
+      "akka://ClusterSystem@127.0.0.1:2551",
+      "akka://ClusterSystem@127.0.0.1:2552"]
   }
 }
 #config-seeds
@@ -62,7 +62,7 @@ class BasicClusterConfigSpec extends WordSpec with ScalaFutures with Eventually
       val sys2Port = SocketUtil.temporaryLocalPort()
       def config(port: Int) = ConfigFactory.parseString(s"""
           akka.remote.classic.netty.tcp.port = $port
-          akka.cluster.seed-nodes = [ "akka.tcp://ClusterSystem@127.0.0.1:$sys1Port", "akka.tcp://ClusterSystem@127.0.0.1:$sys2Port" ]
+          akka.cluster.seed-nodes = [ "akka://ClusterSystem@127.0.0.1:$sys1Port", "akka://ClusterSystem@127.0.0.1:$sys2Port" ]
         """)
 
       val system1 = ActorSystem[Nothing](Behaviors.empty, "ClusterSystem", config(sys1Port).withFallback(configSystem1))
@@ -86,8 +86,8 @@ object BasicClusterManualSpec {
 #config
 akka {
   actor.provider = "cluster"
-  remote {
-    netty.tcp {
+  remote.artery {
+    canonical {
       hostname = "127.0.0.1"
       port = 2551
     }
diff --git a/akka-cluster/src/main/resources/reference.conf b/akka-cluster/src/main/resources/reference.conf
index d937ebaa64..37b8771751 100644
--- a/akka-cluster/src/main/resources/reference.conf
+++ b/akka-cluster/src/main/resources/reference.conf
@@ -11,7 +11,7 @@ akka {
     # Initial contact points of the cluster.
     # The nodes to join automatically at startup.
     # Comma separated full URIs defined by a string on the form of
-    # "akka.tcp://system@hostname:port"
+    # "akka://system@hostname:port"
     # Leave as empty if the node is supposed to be joined manually.
     seed-nodes = []
 
diff --git a/akka-cluster/src/main/scala/akka/cluster/ClusterJmx.scala b/akka-cluster/src/main/scala/akka/cluster/ClusterJmx.scala
index 47166a2484..4246cb59ba 100644
--- a/akka-cluster/src/main/scala/akka/cluster/ClusterJmx.scala
+++ b/akka-cluster/src/main/scala/akka/cluster/ClusterJmx.scala
@@ -24,13 +24,13 @@ trait ClusterNodeMBean {
 
   /**
    * Comma separated addresses of member nodes, sorted in the cluster ring order.
-   * The address format is `akka.tcp://actor-system-name@hostname:port`
+   * The address format is `akka://actor-system-name@hostname:port`
    */
   def getMembers: String
 
   /**
    * Comma separated addresses of unreachable member nodes.
-   * The address format is `akka.tcp://actor-system-name@hostname:port`
+   * The address format is `akka://actor-system-name@hostname:port`
    */
   def getUnreachable: String
 
@@ -38,31 +38,31 @@ trait ClusterNodeMBean {
    * JSON format of the status of all nodes in the cluster as follows:
    * {{{
    * {
-   *   "self-address": "akka.tcp://system@host1:2552",
+   *   "self-address": "akka://system@host1:2552",
    *   "members": [
    *     {
-   *       "address": "akka.tcp://system@host1:2552",
+   *       "address": "akka://system@host1:2552",
    *       "status": "Up",
    *       "roles": [
    *         "frontend"
    *       ]
    *     },
    *     {
-   *       "address": "akka.tcp://system@host2:2552",
+   *       "address": "akka://system@host2:2552",
    *       "status": "Up",
    *       "roles": [
    *         "frontend"
    *       ]
    *     },
    *     {
-   *       "address": "akka.tcp://system@host3:2552",
+   *       "address": "akka://system@host3:2552",
    *       "status": "Down",
    *       "roles": [
    *         "backend"
    *       ]
    *     },
    *     {
-   *       "address": "akka.tcp://system@host4:2552",
+   *       "address": "akka://system@host4:2552",
    *       "status": "Joining",
    *       "roles": [
    *         "backend"
@@ -71,17 +71,17 @@ trait ClusterNodeMBean {
    *   ],
    *   "unreachable": [
    *     {
-   *       "node": "akka.tcp://system@host2:2552",
+   *       "node": "akka://system@host2:2552",
    *       "observed-by": [
-   *         "akka.tcp://system@host1:2552",
-   *         "akka.tcp://system@host3:2552"
+   *         "akka://system@host1:2552",
+   *         "akka://system@host3:2552"
    *       ]
    *     },
    *     {
-   *       "node": "akka.tcp://system@host3:2552",
+   *       "node": "akka://system@host3:2552",
    *       "observed-by": [
-   *         "akka.tcp://system@host1:2552",
-   *         "akka.tcp://system@host2:2552"
+   *         "akka://system@host1:2552",
+   *         "akka://system@host2:2552"
    *       ]
    *     }
    *   ]
@@ -92,7 +92,7 @@ trait ClusterNodeMBean {
 
   /**
    * Get the address of the current leader.
-   * The address format is `akka.tcp://actor-system-name@hostname:port`
+   * The address format is `akka://actor-system-name@hostname:port`
    */
   def getLeader: String
 
@@ -109,20 +109,20 @@ trait ClusterNodeMBean {
 
   /**
    * Try to join this cluster node with the node specified by 'address'.
-   * The address format is `akka.tcp://actor-system-name@hostname:port`.
+   * The address format is `akka://actor-system-name@hostname:port`.
    * A 'Join(thisNodeAddress)' command is sent to the node to join.
    */
   def join(address: String): Unit
 
   /**
    * Send command to issue state transition to LEAVING for the node specified by 'address'.
-   * The address format is `akka.tcp://actor-system-name@hostname:port`
+   * The address format is `akka://actor-system-name@hostname:port`
    */
   def leave(address: String): Unit
 
   /**
    * Send command to DOWN the node specified by 'address'.
-   * The address format is `akka.tcp://actor-system-name@hostname:port`
+   * The address format is `akka://actor-system-name@hostname:port`
    */
   def down(address: String): Unit
 }
diff --git a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
index 3cac1e099b..4ecb414532 100644
--- a/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
+++ b/akka-cluster/src/multi-jvm/scala/akka/cluster/NodeChurnSpec.scala
@@ -24,7 +24,7 @@ object NodeChurnMultiJvmSpec extends MultiNodeConfig {
     debugConfig(on = false).withFallback(ConfigFactory.parseString("""
       akka.cluster.auto-down-unreachable-after = 1s
       akka.cluster.prune-gossip-tombstones-after = 1s
-      akka.remote.log-frame-size-exceeding = 1200b
+      akka.remote.classic.log-frame-size-exceeding = 1200b
       akka.remote.artery.advanced.aeron {
         idle-cpu-level = 1
         embedded-media-driver = off
diff --git a/akka-cluster/src/test/java/akka/cluster/ClusterJavaCompileTest.java b/akka-cluster/src/test/java/akka/cluster/ClusterJavaCompileTest.java
index 899b6f2c60..0fba820019 100644
--- a/akka-cluster/src/test/java/akka/cluster/ClusterJavaCompileTest.java
+++ b/akka-cluster/src/test/java/akka/cluster/ClusterJavaCompileTest.java
@@ -18,7 +18,7 @@ public class ClusterJavaCompileTest {
   final Cluster cluster = null;
 
   public void compileJoinSeedNodesInJava() {
-    final List<Address> addresses = Collections.singletonList(new Address("akka.tcp", "MySystem"));
+    final List<Address> addresses = Collections.singletonList(new Address("akka", "MySystem"));
     cluster.joinSeedNodes(addresses);
   }
 }
diff --git a/akka-cluster/src/test/scala/akka/cluster/ClusterDomainEventSpec.scala b/akka-cluster/src/test/scala/akka/cluster/ClusterDomainEventSpec.scala
index 49bf0eb751..58a3d563a8 100644
--- a/akka-cluster/src/test/scala/akka/cluster/ClusterDomainEventSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/ClusterDomainEventSpec.scala
@@ -16,25 +16,25 @@ class ClusterDomainEventSpec extends WordSpec with Matchers {
   import ClusterEvent._
 
   val aRoles = Set("AA", "AB")
-  val aJoining = TestMember(Address("akka.tcp", "sys", "a", 2552), Joining, aRoles)
-  val aUp = TestMember(Address("akka.tcp", "sys", "a", 2552), Up, aRoles)
-  val aRemoved = TestMember(Address("akka.tcp", "sys", "a", 2552), Removed, aRoles)
+  val aJoining = TestMember(Address("akka", "sys", "a", 2552), Joining, aRoles)
+  val aUp = TestMember(Address("akka", "sys", "a", 2552), Up, aRoles)
+  val aRemoved = TestMember(Address("akka", "sys", "a", 2552), Removed, aRoles)
   val bRoles = Set("AB", "BB")
-  val bUp = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, bRoles)
-  val bDown = TestMember(Address("akka.tcp", "sys", "b", 2552), Down, bRoles)
-  val bRemoved = TestMember(Address("akka.tcp", "sys", "b", 2552), Removed, bRoles)
+  val bUp = TestMember(Address("akka", "sys", "b", 2552), Up, bRoles)
+  val bDown = TestMember(Address("akka", "sys", "b", 2552), Down, bRoles)
+  val bRemoved = TestMember(Address("akka", "sys", "b", 2552), Removed, bRoles)
   val cRoles = Set.empty[String]
-  val cUp = TestMember(Address("akka.tcp", "sys", "c", 2552), Up, cRoles)
-  val cLeaving = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving, cRoles)
+  val cUp = TestMember(Address("akka", "sys", "c", 2552), Up, cRoles)
+  val cLeaving = TestMember(Address("akka", "sys", "c", 2552), Leaving, cRoles)
   val dRoles = Set("DD", "DE")
-  val dLeaving = TestMember(Address("akka.tcp", "sys", "d", 2552), Leaving, dRoles)
-  val dExiting = TestMember(Address("akka.tcp", "sys", "d", 2552), Exiting, dRoles)
-  val dRemoved = TestMember(Address("akka.tcp", "sys", "d", 2552), Removed, dRoles)
+  val dLeaving = TestMember(Address("akka", "sys", "d", 2552), Leaving, dRoles)
+  val dExiting = TestMember(Address("akka", "sys", "d", 2552), Exiting, dRoles)
+  val dRemoved = TestMember(Address("akka", "sys", "d", 2552), Removed, dRoles)
   val eRoles = Set("EE", "DE")
-  val eJoining = TestMember(Address("akka.tcp", "sys", "e", 2552), Joining, eRoles)
-  val eUp = TestMember(Address("akka.tcp", "sys", "e", 2552), Up, eRoles)
-  val eDown = TestMember(Address("akka.tcp", "sys", "e", 2552), Down, eRoles)
-  val selfDummyAddress = UniqueAddress(Address("akka.tcp", "sys", "selfDummy", 2552), 17L)
+  val eJoining = TestMember(Address("akka", "sys", "e", 2552), Joining, eRoles)
+  val eUp = TestMember(Address("akka", "sys", "e", 2552), Up, eRoles)
+  val eDown = TestMember(Address("akka", "sys", "e", 2552), Down, eRoles)
+  val selfDummyAddress = UniqueAddress(Address("akka", "sys", "selfDummy", 2552), 17L)
 
   private[cluster] def converge(gossip: Gossip): (Gossip, Set[UniqueAddress]) =
     gossip.members.foldLeft((gossip, Set.empty[UniqueAddress])) {
@@ -91,12 +91,12 @@ class ClusterDomainEventSpec extends WordSpec with Matchers {
     }
 
     "be produced for reachability observations between data centers" in {
-      val dc2AMemberUp = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
-      val dc2AMemberDown = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
-      val dc2BMemberUp = TestMember(Address("akka.tcp", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
+      val dc2AMemberUp = TestMember(Address("akka", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
+      val dc2AMemberDown = TestMember(Address("akka", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
+      val dc2BMemberUp = TestMember(Address("akka", "sys", "dc2B", 2552), Up, Set.empty[String], "dc2")
 
-      val dc3AMemberUp = TestMember(Address("akka.tcp", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
-      val dc3BMemberUp = TestMember(Address("akka.tcp", "sys", "dc3B", 2552), Up, Set.empty[String], "dc3")
+      val dc3AMemberUp = TestMember(Address("akka", "sys", "dc3A", 2552), Up, Set.empty[String], "dc3")
+      val dc3BMemberUp = TestMember(Address("akka", "sys", "dc3B", 2552), Up, Set.empty[String], "dc3")
 
       val reachability1 = Reachability.empty
       val g1 = Gossip(
@@ -128,8 +128,8 @@ class ClusterDomainEventSpec extends WordSpec with Matchers {
     }
 
     "not be produced for same reachability observations between data centers" in {
-      val dc2AMemberUp = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
-      val dc2AMemberDown = TestMember(Address("akka.tcp", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
+      val dc2AMemberUp = TestMember(Address("akka", "sys", "dc2A", 2552), Up, Set.empty[String], "dc2")
+      val dc2AMemberDown = TestMember(Address("akka", "sys", "dc2A", 2552), Down, Set.empty[String], "dc2")
 
       val reachability1 = Reachability.empty
       val g1 = Gossip(members = SortedSet(aUp, dc2AMemberUp), overview = GossipOverview(reachability = reachability1))
diff --git a/akka-cluster/src/test/scala/akka/cluster/ClusterHeartbeatSenderStateSpec.scala b/akka-cluster/src/test/scala/akka/cluster/ClusterHeartbeatSenderStateSpec.scala
index 3ecb315bb0..0afa9d4056 100644
--- a/akka-cluster/src/test/scala/akka/cluster/ClusterHeartbeatSenderStateSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/ClusterHeartbeatSenderStateSpec.scala
@@ -40,11 +40,11 @@ object ClusterHeartbeatSenderStateSpec {
 class ClusterHeartbeatSenderStateSpec extends WordSpec with Matchers {
   import ClusterHeartbeatSenderStateSpec._
 
-  val aa = UniqueAddress(Address("akka.tcp", "sys", "aa", 2552), 1L)
-  val bb = UniqueAddress(Address("akka.tcp", "sys", "bb", 2552), 2L)
-  val cc = UniqueAddress(Address("akka.tcp", "sys", "cc", 2552), 3L)
-  val dd = UniqueAddress(Address("akka.tcp", "sys", "dd", 2552), 4L)
-  val ee = UniqueAddress(Address("akka.tcp", "sys", "ee", 2552), 5L)
+  val aa = UniqueAddress(Address("akka", "sys", "aa", 2552), 1L)
+  val bb = UniqueAddress(Address("akka", "sys", "bb", 2552), 2L)
+  val cc = UniqueAddress(Address("akka", "sys", "cc", 2552), 3L)
+  val dd = UniqueAddress(Address("akka", "sys", "dd", 2552), 4L)
+  val ee = UniqueAddress(Address("akka", "sys", "ee", 2552), 5L)
 
   private def emptyState: ClusterHeartbeatSenderState = emptyState(aa)
 
@@ -151,9 +151,8 @@ class ClusterHeartbeatSenderStateSpec extends WordSpec with Matchers {
 
     "behave correctly for random operations" in {
       val rnd = ThreadLocalRandom.current
-      val nodes = (1 to rnd.nextInt(10, 200))
-        .map(n => UniqueAddress(Address("akka.tcp", "sys", "n" + n, 2552), n.toLong))
-        .toVector
+      val nodes =
+        (1 to rnd.nextInt(10, 200)).map(n => UniqueAddress(Address("akka", "sys", "n" + n, 2552), n.toLong)).toVector
       def rndNode() = nodes(rnd.nextInt(0, nodes.size))
       val selfUniqueAddress = rndNode()
       var state = emptyState(selfUniqueAddress)
diff --git a/akka-cluster/src/test/scala/akka/cluster/DowningProviderSpec.scala b/akka-cluster/src/test/scala/akka/cluster/DowningProviderSpec.scala
index 59db80ced8..bcf3b6c79e 100644
--- a/akka-cluster/src/test/scala/akka/cluster/DowningProviderSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/DowningProviderSpec.scala
@@ -39,7 +39,7 @@ class DowningProviderSpec extends WordSpec with Matchers {
         loglevel = WARNING
         actor.provider = "cluster"
         remote {
-          netty.tcp {
+          classic.netty.tcp {
             hostname = "127.0.0.1"
             port = 0
           }
diff --git a/akka-cluster/src/test/scala/akka/cluster/GossipSpec.scala b/akka-cluster/src/test/scala/akka/cluster/GossipSpec.scala
index 1d843e8d48..d1cc0c2e32 100644
--- a/akka-cluster/src/test/scala/akka/cluster/GossipSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/GossipSpec.scala
@@ -16,22 +16,22 @@ class GossipSpec extends WordSpec with Matchers {
 
   import MemberStatus._
 
-  val a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Up)
+  val a1 = TestMember(Address("akka", "sys", "a", 2552), Up)
   val a2 = TestMember(a1.address, Joining)
-  val b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up)
+  val b1 = TestMember(Address("akka", "sys", "b", 2552), Up)
   val b2 = TestMember(b1.address, Removed)
-  val c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving)
+  val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving)
   val c2 = TestMember(c1.address, Up)
   val c3 = TestMember(c1.address, Exiting)
-  val d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Leaving)
-  val e1 = TestMember(Address("akka.tcp", "sys", "e", 2552), Joining)
+  val d1 = TestMember(Address("akka", "sys", "d", 2552), Leaving)
+  val e1 = TestMember(Address("akka", "sys", "e", 2552), Joining)
   val e2 = TestMember(e1.address, Up)
   val e3 = TestMember(e1.address, Down)
 
-  val dc1a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
-  val dc1b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
-  val dc2c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
-  val dc2d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Up, Set.empty, dataCenter = "dc2")
+  val dc1a1 = TestMember(Address("akka", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
+  val dc1b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
+  val dc2c1 = TestMember(Address("akka", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc2")
+  val dc2d1 = TestMember(Address("akka", "sys", "d", 2552), Up, Set.empty, dataCenter = "dc2")
   val dc2d2 = TestMember(dc2d1.address, status = Down, roles = Set.empty, dataCenter = dc2d1.dataCenter)
   // restarted with another uid
   val dc2d3 =
@@ -487,7 +487,7 @@ class GossipSpec extends WordSpec with Matchers {
     }
 
     "update members" in {
-      val joining = TestMember(Address("akka.tcp", "sys", "d", 2552), Joining, Set.empty, dataCenter = "dc2")
+      val joining = TestMember(Address("akka", "sys", "d", 2552), Joining, Set.empty, dataCenter = "dc2")
       val g = Gossip(members = SortedSet(dc1a1, joining))
 
       g.member(joining.uniqueAddress).status should ===(Joining)
diff --git a/akka-cluster/src/test/scala/akka/cluster/GossipTargetSelectorSpec.scala b/akka-cluster/src/test/scala/akka/cluster/GossipTargetSelectorSpec.scala
index 0c7995c307..c27fc63cfc 100644
--- a/akka-cluster/src/test/scala/akka/cluster/GossipTargetSelectorSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/GossipTargetSelectorSpec.scala
@@ -13,17 +13,17 @@ import scala.collection.immutable.SortedSet
 
 class GossipTargetSelectorSpec extends WordSpec with Matchers {
 
-  val aDc1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
-  val bDc1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
-  val cDc1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc1")
+  val aDc1 = TestMember(Address("akka", "sys", "a", 2552), Up, Set.empty, dataCenter = "dc1")
+  val bDc1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set.empty, dataCenter = "dc1")
+  val cDc1 = TestMember(Address("akka", "sys", "c", 2552), Up, Set.empty, dataCenter = "dc1")
 
-  val eDc2 = TestMember(Address("akka.tcp", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2")
-  val fDc2 = TestMember(Address("akka.tcp", "sys", "f", 2552), Up, Set.empty, dataCenter = "dc2")
+  val eDc2 = TestMember(Address("akka", "sys", "e", 2552), Up, Set.empty, dataCenter = "dc2")
+  val fDc2 = TestMember(Address("akka", "sys", "f", 2552), Up, Set.empty, dataCenter = "dc2")
 
-  val gDc3 = TestMember(Address("akka.tcp", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3")
-  val hDc3 = TestMember(Address("akka.tcp", "sys", "h", 2552), Up, Set.empty, dataCenter = "dc3")
+  val gDc3 = TestMember(Address("akka", "sys", "g", 2552), Up, Set.empty, dataCenter = "dc3")
+  val hDc3 = TestMember(Address("akka", "sys", "h", 2552), Up, Set.empty, dataCenter = "dc3")
 
-  val iDc4 = TestMember(Address("akka.tcp", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4")
+  val iDc4 = TestMember(Address("akka", "sys", "i", 2552), Up, Set.empty, dataCenter = "dc4")
 
   val defaultSelector =
     new GossipTargetSelector(reduceGossipDifferentViewProbability = 400, crossDcGossipProbability = 0.2)
diff --git a/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingPerfSpec.scala b/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingPerfSpec.scala
index 51c34137c1..c17c8c2297 100644
--- a/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingPerfSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingPerfSpec.scala
@@ -15,7 +15,7 @@ class HeartbeatNodeRingPerfSpec extends WordSpec with Matchers {
   val iterations = sys.props.get("akka.cluster.HeartbeatNodeRingPerfSpec.iterations").getOrElse("1000").toInt
 
   def createHeartbeatNodeRingOfSize(size: Int): HeartbeatNodeRing = {
-    val nodes = (1 to size).map(n => UniqueAddress(Address("akka.tcp", "sys", "node-" + n, 2552), n.toLong))
+    val nodes = (1 to size).map(n => UniqueAddress(Address("akka", "sys", "node-" + n, 2552), n.toLong))
     val selfAddress = nodes(size / 2)
     HeartbeatNodeRing(selfAddress, nodes.toSet, Set.empty, 5)
   }
diff --git a/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingSpec.scala b/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingSpec.scala
index 39764df1d1..f6e63ce4e2 100644
--- a/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/HeartbeatNodeRingSpec.scala
@@ -10,12 +10,12 @@ import akka.actor.Address
 
 class HeartbeatNodeRingSpec extends WordSpec with Matchers {
 
-  val aa = UniqueAddress(Address("akka.tcp", "sys", "aa", 2552), 1L)
-  val bb = UniqueAddress(Address("akka.tcp", "sys", "bb", 2552), 2L)
-  val cc = UniqueAddress(Address("akka.tcp", "sys", "cc", 2552), 3L)
-  val dd = UniqueAddress(Address("akka.tcp", "sys", "dd", 2552), 4L)
-  val ee = UniqueAddress(Address("akka.tcp", "sys", "ee", 2552), 5L)
-  val ff = UniqueAddress(Address("akka.tcp", "sys", "ff", 2552), 6L)
+  val aa = UniqueAddress(Address("akka", "sys", "aa", 2552), 1L)
+  val bb = UniqueAddress(Address("akka", "sys", "bb", 2552), 2L)
+  val cc = UniqueAddress(Address("akka", "sys", "cc", 2552), 3L)
+  val dd = UniqueAddress(Address("akka", "sys", "dd", 2552), 4L)
+  val ee = UniqueAddress(Address("akka", "sys", "ee", 2552), 5L)
+  val ff = UniqueAddress(Address("akka", "sys", "ff", 2552), 6L)
 
   val nodes = Set(aa, bb, cc, dd, ee, ff)
 
diff --git a/akka-cluster/src/test/scala/akka/cluster/MemberOrderingSpec.scala b/akka-cluster/src/test/scala/akka/cluster/MemberOrderingSpec.scala
index 5c3c475616..5950976ec7 100644
--- a/akka-cluster/src/test/scala/akka/cluster/MemberOrderingSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/MemberOrderingSpec.scala
@@ -35,8 +35,8 @@ class MemberOrderingSpec extends WordSpec with Matchers {
     "be sorted by address correctly" in {
       import Member.ordering
       // sorting should be done on host and port, only
-      val m1 = m(Address("akka.tcp", "sys1", "host1", 9000), Up)
-      val m2 = m(Address("akka.tcp", "sys1", "host1", 10000), Up)
+      val m1 = m(Address("akka", "sys1", "host1", 9000), Up)
+      val m2 = m(Address("akka", "sys1", "host1", 10000), Up)
       val m3 = m(Address("cluster", "sys2", "host2", 8000), Up)
       val m4 = m(Address("cluster", "sys2", "host2", 9000), Up)
       val m5 = m(Address("cluster", "sys1", "host2", 10000), Up)
@@ -48,7 +48,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
     }
 
     "have stable equals and hashCode" in {
-      val address = Address("akka.tcp", "sys1", "host1", 9000)
+      val address = Address("akka", "sys1", "host1", 9000)
       val m1 = m(address, Joining)
       val m11 = Member(UniqueAddress(address, -3L), Set.empty)
       val m2 = m1.copy(status = Up)
@@ -70,7 +70,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
     }
 
     "have consistent ordering and equals" in {
-      val address1 = Address("akka.tcp", "sys1", "host1", 9001)
+      val address1 = Address("akka", "sys1", "host1", 9001)
       val address2 = address1.copy(port = Some(9002))
 
       val x = m(address1, Exiting)
@@ -88,7 +88,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
     }
 
     "work with SortedSet" in {
-      val address1 = Address("akka.tcp", "sys1", "host1", 9001)
+      val address1 = Address("akka", "sys1", "host1", 9001)
       val address2 = address1.copy(port = Some(9002))
       val address3 = address1.copy(port = Some(9003))
 
@@ -152,7 +152,7 @@ class MemberOrderingSpec extends WordSpec with Matchers {
   "Leader status ordering" must {
 
     "order members with status Joining, Exiting and Down last" in {
-      val address = Address("akka.tcp", "sys1", "host1", 5000)
+      val address = Address("akka", "sys1", "host1", 5000)
       val m1 = m(address, Joining)
       val m2 = m(address.copy(port = Some(7000)), Joining)
       val m3 = m(address.copy(port = Some(3000)), Exiting)
diff --git a/akka-cluster/src/test/scala/akka/cluster/MembershipStateSpec.scala b/akka-cluster/src/test/scala/akka/cluster/MembershipStateSpec.scala
index 6ae5ffe0a0..cc30e272bc 100644
--- a/akka-cluster/src/test/scala/akka/cluster/MembershipStateSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/MembershipStateSpec.scala
@@ -12,18 +12,18 @@ import scala.collection.immutable.SortedSet
 
 class MembershipStateSpec extends WordSpec with Matchers {
   // DC-a is in reverse age order
-  val a1 = TestMember(Address("akka.tcp", "sys", "a4", 2552), Up, 1, "dc-a")
-  val a2 = TestMember(Address("akka.tcp", "sys", "a3", 2552), Up, 2, "dc-a")
-  val a3 = TestMember(Address("akka.tcp", "sys", "a2", 2552), Up, 3, "dc-a")
-  val a4 = TestMember(Address("akka.tcp", "sys", "a1", 2552), Up, 4, "dc-a")
+  val a1 = TestMember(Address("akka", "sys", "a4", 2552), Up, 1, "dc-a")
+  val a2 = TestMember(Address("akka", "sys", "a3", 2552), Up, 2, "dc-a")
+  val a3 = TestMember(Address("akka", "sys", "a2", 2552), Up, 3, "dc-a")
+  val a4 = TestMember(Address("akka", "sys", "a1", 2552), Up, 4, "dc-a")
 
   // DC-b it is the first and the last that are the oldest
-  val b1 = TestMember(Address("akka.tcp", "sys", "b3", 2552), Up, 1, "dc-b")
-  val b3 = TestMember(Address("akka.tcp", "sys", "b2", 2552), Up, 3, "dc-b")
+  val b1 = TestMember(Address("akka", "sys", "b3", 2552), Up, 1, "dc-b")
+  val b3 = TestMember(Address("akka", "sys", "b2", 2552), Up, 3, "dc-b")
   // Won't be replaced by b3
-  val b2 = TestMember(Address("akka.tcp", "sys", "b1", 2552), Up, 2, "dc-b")
+  val b2 = TestMember(Address("akka", "sys", "b1", 2552), Up, 2, "dc-b")
   // for the case that we don't replace it ever
-  val bOldest = TestMember(Address("akka.tcp", "sys", "b0", 2552), Up, 0, "dc-b")
+  val bOldest = TestMember(Address("akka", "sys", "b0", 2552), Up, 0, "dc-b")
 
   "Membership state" must {
     "sort by upNumber for oldest top members" in {
@@ -52,43 +52,43 @@ class MembershipStateSpec extends WordSpec with Matchers {
 
     "find two oldest per role as targets for Exiting change" in {
       val a5 = TestMember(
-        Address("akka.tcp", "sys", "a5", 2552),
+        Address("akka", "sys", "a5", 2552),
         MemberStatus.Exiting,
         roles = Set("role1", "role2"),
         upNumber = 5,
         dataCenter = "dc-a")
       val a6 = TestMember(
-        Address("akka.tcp", "sys", "a6", 2552),
+        Address("akka", "sys", "a6", 2552),
         MemberStatus.Exiting,
         roles = Set("role1", "role3"),
         upNumber = 6,
         dataCenter = "dc-a")
       val a7 = TestMember(
-        Address("akka.tcp", "sys", "a7", 2552),
+        Address("akka", "sys", "a7", 2552),
         MemberStatus.Exiting,
         roles = Set("role1"),
         upNumber = 7,
         dataCenter = "dc-a")
       val a8 = TestMember(
-        Address("akka.tcp", "sys", "a8", 2552),
+        Address("akka", "sys", "a8", 2552),
         MemberStatus.Exiting,
         roles = Set("role1"),
         upNumber = 8,
         dataCenter = "dc-a")
       val a9 = TestMember(
-        Address("akka.tcp", "sys", "a9", 2552),
+        Address("akka", "sys", "a9", 2552),
         MemberStatus.Exiting,
         roles = Set("role2"),
         upNumber = 9,
         dataCenter = "dc-a")
       val b5 = TestMember(
-        Address("akka.tcp", "sys", "b5", 2552),
+        Address("akka", "sys", "b5", 2552),
         MemberStatus.Exiting,
         roles = Set("role1"),
         upNumber = 5,
         dataCenter = "dc-b")
       val b6 = TestMember(
-        Address("akka.tcp", "sys", "b6", 2552),
+        Address("akka", "sys", "b6", 2552),
         MemberStatus.Exiting,
         roles = Set("role2"),
         upNumber = 6,
diff --git a/akka-cluster/src/test/scala/akka/cluster/ReachabilityPerfSpec.scala b/akka-cluster/src/test/scala/akka/cluster/ReachabilityPerfSpec.scala
index ea57848116..2ac2c76acd 100644
--- a/akka-cluster/src/test/scala/akka/cluster/ReachabilityPerfSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/ReachabilityPerfSpec.scala
@@ -15,8 +15,8 @@ class ReachabilityPerfSpec extends WordSpec with Matchers {
   // increase for serious measurements
   val iterations = sys.props.get("akka.cluster.ReachabilityPerfSpec.iterations").getOrElse("100").toInt
 
-  val address = Address("akka.tcp", "sys", "a", 2552)
-  val node = Address("akka.tcp", "sys", "a", 2552)
+  val address = Address("akka", "sys", "a", 2552)
+  val node = Address("akka", "sys", "a", 2552)
 
   private def createReachabilityOfSize(base: Reachability, size: Int): Reachability =
     (1 to size).foldLeft(base) {
diff --git a/akka-cluster/src/test/scala/akka/cluster/ReachabilitySpec.scala b/akka-cluster/src/test/scala/akka/cluster/ReachabilitySpec.scala
index 7271bae31f..17a065c741 100644
--- a/akka-cluster/src/test/scala/akka/cluster/ReachabilitySpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/ReachabilitySpec.scala
@@ -12,11 +12,11 @@ class ReachabilitySpec extends WordSpec with Matchers {
 
   import Reachability.{ Reachable, Record, Terminated, Unreachable }
 
-  val nodeA = UniqueAddress(Address("akka.tcp", "sys", "a", 2552), 1L)
-  val nodeB = UniqueAddress(Address("akka.tcp", "sys", "b", 2552), 2L)
-  val nodeC = UniqueAddress(Address("akka.tcp", "sys", "c", 2552), 3L)
-  val nodeD = UniqueAddress(Address("akka.tcp", "sys", "d", 2552), 4L)
-  val nodeE = UniqueAddress(Address("akka.tcp", "sys", "e", 2552), 5L)
+  val nodeA = UniqueAddress(Address("akka", "sys", "a", 2552), 1L)
+  val nodeB = UniqueAddress(Address("akka", "sys", "b", 2552), 2L)
+  val nodeC = UniqueAddress(Address("akka", "sys", "c", 2552), 3L)
+  val nodeD = UniqueAddress(Address("akka", "sys", "d", 2552), 4L)
+  val nodeE = UniqueAddress(Address("akka", "sys", "e", 2552), 5L)
 
   "Reachability table" must {
 
diff --git a/akka-cluster/src/test/scala/akka/cluster/protobuf/ClusterMessageSerializerSpec.scala b/akka-cluster/src/test/scala/akka/cluster/protobuf/ClusterMessageSerializerSpec.scala
index f1e99ff6d0..479612d4fe 100644
--- a/akka-cluster/src/test/scala/akka/cluster/protobuf/ClusterMessageSerializerSpec.scala
+++ b/akka-cluster/src/test/scala/akka/cluster/protobuf/ClusterMessageSerializerSpec.scala
@@ -39,19 +39,19 @@ class ClusterMessageSerializerSpec extends AkkaSpec("akka.actor.provider = clust
 
   import MemberStatus._
 
-  val a1 = TestMember(Address("akka.tcp", "sys", "a", 2552), Joining, Set.empty[String])
-  val b1 = TestMember(Address("akka.tcp", "sys", "b", 2552), Up, Set("r1"))
-  val c1 = TestMember(Address("akka.tcp", "sys", "c", 2552), Leaving, Set.empty[String], "foo")
-  val d1 = TestMember(Address("akka.tcp", "sys", "d", 2552), Exiting, Set("r1"), "foo")
-  val e1 = TestMember(Address("akka.tcp", "sys", "e", 2552), Down, Set("r3"))
-  val f1 = TestMember(Address("akka.tcp", "sys", "f", 2552), Removed, Set("r3"), "foo")
+  val a1 = TestMember(Address("akka", "sys", "a", 2552), Joining, Set.empty[String])
+  val b1 = TestMember(Address("akka", "sys", "b", 2552), Up, Set("r1"))
+  val c1 = TestMember(Address("akka", "sys", "c", 2552), Leaving, Set.empty[String], "foo")
+  val d1 = TestMember(Address("akka", "sys", "d", 2552), Exiting, Set("r1"), "foo")
+  val e1 = TestMember(Address("akka", "sys", "e", 2552), Down, Set("r3"))
+  val f1 = TestMember(Address("akka", "sys", "f", 2552), Removed, Set("r3"), "foo")
 
   "ClusterMessages" must {
 
     "be serializable" in {
-      val address = Address("akka.tcp", "system", "some.host.org", 4711)
+      val address = Address("akka", "system", "some.host.org", 4711)
       val uniqueAddress = UniqueAddress(address, 17L)
-      val address2 = Address("akka.tcp", "system", "other.host.org", 4711)
+      val address2 = Address("akka", "system", "other.host.org", 4711)
       val uniqueAddress2 = UniqueAddress(address2, 18L)
       checkSerialization(InternalClusterAction.Join(uniqueAddress, Set("foo", "bar", "dc-A")))
       checkSerialization(ClusterUserAction.Leave(address))
@@ -103,7 +103,7 @@ class ClusterMessageSerializerSpec extends AkkaSpec("akka.actor.provider = clust
       // we must use the old singleton class name so that the other side will see an InitJoin
       // but discard the config as it does not know about the config check
       val initJoinAck = InternalClusterAction.InitJoinAck(
-        Address("akka.tcp", "cluster", "127.0.0.1", 2552),
+        Address("akka", "cluster", "127.0.0.1", 2552),
         InternalClusterAction.UncheckedConfig)
       val serializedInitJoinAckPre2510 = serializer.addressToProto(initJoinAck.address).build().toByteArray
 
@@ -114,7 +114,7 @@ class ClusterMessageSerializerSpec extends AkkaSpec("akka.actor.provider = clust
 
     "serialize to wire format of version 2.5.9 (using serialized address for InitJoinAck)" in {
       val initJoinAck = InternalClusterAction.InitJoinAck(
-        Address("akka.tcp", "cluster", "127.0.0.1", 2552),
+        Address("akka", "cluster", "127.0.0.1", 2552),
         InternalClusterAction.ConfigCheckUnsupportedByJoiningNode)
       val bytes = serializer.toBinary(initJoinAck)
 
diff --git a/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/PerformanceSpec.scala b/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/PerformanceSpec.scala
index ee83f1ddd1..925b1e10bb 100644
--- a/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/PerformanceSpec.scala
+++ b/akka-distributed-data/src/multi-jvm/scala/akka/cluster/ddata/PerformanceSpec.scala
@@ -31,8 +31,8 @@ object PerformanceSpec extends MultiNodeConfig {
     akka.actor.provider = "cluster"
     akka.log-dead-letters = off
     akka.log-dead-letters-during-shutdown = off
-    akka.remote.log-remote-lifecycle-events = ERROR
-    akka.remote.log-frame-size-exceeding=1000b
+    akka.remote.classic.log-remote-lifecycle-events = ERROR
+    akka.remote.classic.log-frame-size-exceeding=1000b
     akka.testconductor.barrier-timeout = 60 s
     akka.cluster.distributed-data.gossip-interval = 1 s
     akka.actor.serialize-messages = off
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/DataEnvelopeSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/DataEnvelopeSpec.scala
index 6a594ab615..304b21da10 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/DataEnvelopeSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/DataEnvelopeSpec.scala
@@ -13,7 +13,7 @@ import akka.cluster.ddata.Replicator.Internal.DataEnvelope
 class DataEnvelopeSpec extends WordSpec with Matchers {
   import PruningState._
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "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)
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/GCounterSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/GCounterSpec.scala
index aeea896af4..fa6034e5a5 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/GCounterSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/GCounterSpec.scala
@@ -11,7 +11,7 @@ import org.scalatest.Matchers
 import org.scalatest.WordSpec
 
 class GCounterSpec extends WordSpec with Matchers {
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
   val node3 = UniqueAddress(node1.address.copy(port = Some(2553)), 3L)
 
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWMapSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWMapSpec.scala
index 9a223eef46..80e151d374 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWMapSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWMapSpec.scala
@@ -13,7 +13,7 @@ import org.scalatest.WordSpec
 class LWWMapSpec extends WordSpec with Matchers {
   import LWWRegister.defaultClock
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
 
   "A LWWMap" must {
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWRegisterSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWRegisterSpec.scala
index 251cdac31f..2e5963ae80 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWRegisterSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/LWWRegisterSpec.scala
@@ -13,7 +13,7 @@ import org.scalatest.WordSpec
 class LWWRegisterSpec extends WordSpec with Matchers {
   import LWWRegister.defaultClock
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
 
   "A LWWRegister" must {
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/LotsOfDataBot.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/LotsOfDataBot.scala
index 8130aaa6a5..6b34abeed5 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/LotsOfDataBot.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/LotsOfDataBot.scala
@@ -32,13 +32,12 @@ object LotsOfDataBot {
       // Override the configuration of the port
       val config = ConfigFactory
         .parseString("akka.remote.classic.netty.tcp.port=" + port)
-        .withFallback(
-          ConfigFactory.load(ConfigFactory.parseString("""
+        .withFallback(ConfigFactory.load(ConfigFactory.parseString("""
             passive = off
             max-entries = 100000
             akka.actor.provider = "cluster"
             akka.remote {
-              netty.tcp {
+              artery.canonical {
                 hostname = "127.0.0.1"
                 port = 0
               }
@@ -46,13 +45,11 @@ object LotsOfDataBot {
 
             akka.cluster {
               seed-nodes = [
-                "akka.tcp://ClusterSystem@127.0.0.1:2551",
-                "akka.tcp://ClusterSystem@127.0.0.1:2552"]
+                "akka://ClusterSystem@127.0.0.1:2551",
+                "akka://ClusterSystem@127.0.0.1:2552"]
 
               auto-down-unreachable-after = 10s
             }
-            akka.cluster.distributed-data.use-offheap-memory = off
-            akka.remote.log-frame-size-exceeding = 10000b
             """)))
 
       // Create an Akka system
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMapSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMapSpec.scala
index b9bb18dc64..a0314a6cca 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMapSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMapSpec.scala
@@ -13,7 +13,7 @@ import org.scalatest.WordSpec
 
 class ORMapSpec extends WordSpec with Matchers {
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
 
   "A ORMap" must {
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMultiMapSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMultiMapSpec.scala
index 908db3eb1a..f6a572dfc8 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMultiMapSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORMultiMapSpec.scala
@@ -11,7 +11,7 @@ import org.scalatest.{ Matchers, WordSpec }
 
 class ORMultiMapSpec extends WordSpec with Matchers {
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
 
   "A ORMultiMap" must {
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORSetSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORSetSpec.scala
index 15b0bed584..37da3e69c4 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORSetSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/ORSetSpec.scala
@@ -14,11 +14,11 @@ import org.scalatest.WordSpec
 
 class ORSetSpec extends WordSpec with Matchers {
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "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.tcp", "Sys", "a", 2552), 1L)
+  val nodeA = UniqueAddress(Address("akka", "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)
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterMapSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterMapSpec.scala
index e35881f319..8dce1142ee 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterMapSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterMapSpec.scala
@@ -12,7 +12,7 @@ import org.scalatest.WordSpec
 
 class PNCounterMapSpec extends WordSpec with Matchers {
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
 
   "A PNCounterMap" must {
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterSpec.scala
index b120bfff29..9788ec4f65 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/PNCounterSpec.scala
@@ -11,7 +11,7 @@ import org.scalatest.Matchers
 import org.scalatest.WordSpec
 
 class PNCounterSpec extends WordSpec with Matchers {
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "Sys", "localhost", 2551), 1L)
   val node2 = UniqueAddress(node1.address.copy(port = Some(2552)), 2L)
 
   "A PNCounter" must {
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/PruningStateSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/PruningStateSpec.scala
index 35ce33fce3..1581427cb2 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/PruningStateSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/PruningStateSpec.scala
@@ -12,7 +12,7 @@ import org.scalatest.WordSpec
 class PruningStateSpec extends WordSpec with Matchers {
   import PruningState._
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "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)
diff --git a/akka-distributed-data/src/test/scala/akka/cluster/ddata/VersionVectorSpec.scala b/akka-distributed-data/src/test/scala/akka/cluster/ddata/VersionVectorSpec.scala
index d9c95db95e..e3c237a135 100644
--- a/akka-distributed-data/src/test/scala/akka/cluster/ddata/VersionVectorSpec.scala
+++ b/akka-distributed-data/src/test/scala/akka/cluster/ddata/VersionVectorSpec.scala
@@ -18,7 +18,7 @@ class VersionVectorSpec
     with Matchers
     with BeforeAndAfterAll {
 
-  val node1 = UniqueAddress(Address("akka.tcp", "Sys", "localhost", 2551), 1L)
+  val node1 = UniqueAddress(Address("akka", "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)
diff --git a/akka-docs/src/main/paradox/actors.md b/akka-docs/src/main/paradox/actors.md
index c5af084460..613e8c83f3 100644
--- a/akka-docs/src/main/paradox/actors.md
+++ b/akka-docs/src/main/paradox/actors.md
@@ -596,7 +596,7 @@ Scala
 Java
 :  @@snip [ActorDocTest.java](/akka-docs/src/test/java/jdocs/actor/ActorDocTest.java) { #selection-remote }
 
-An example demonstrating actor look-up is given in @ref:[Remoting Sample](remoting.md#remote-sample).
+An example demonstrating actor look-up is given in @ref:[Remoting Sample](remoting-artery.md#looking-up-remote-actors).
 
 ## Messages and immutability
 
diff --git a/akka-docs/src/main/paradox/additional/deploy.md b/akka-docs/src/main/paradox/additional/deploy.md
index 1109961d0b..dbd9735ae5 100644
--- a/akka-docs/src/main/paradox/additional/deploy.md
+++ b/akka-docs/src/main/paradox/additional/deploy.md
@@ -29,7 +29,7 @@ Follow the instructions for the `JavaAppPackaging` in the [sbt-native-packager p
 
 You can use both Akka remoting and Akka Cluster inside of Docker containers. But note
 that you will need to take special care with the network configuration when using Docker,
-described here: @ref:[Akka behind NAT or in a Docker container](../remoting.md#remote-configuration-nat)
+described here: @ref:[Akka behind NAT or in a Docker container](../remoting-artery.md#remote-configuration-nat-artery)
 
 You can look at the
 @java[@extref[Cluster with docker-compse example project](samples:akka-sample-cluster-docker-compose-java)]
diff --git a/akka-docs/src/main/paradox/additional/faq.md b/akka-docs/src/main/paradox/additional/faq.md
index 0ab6353d1b..5e3646f3b5 100644
--- a/akka-docs/src/main/paradox/additional/faq.md
+++ b/akka-docs/src/main/paradox/additional/faq.md
@@ -98,11 +98,7 @@ to see all sent and received messages (logged at DEBUG level).
 
 ### Which options shall I enable when debugging remoting issues?
 
-Have a look at the @ref:[Remote Configuration](../remoting.md#remote-configuration), the typical candidates are:
-
- * *akka.remote.log-sent-messages*
- * *akka.remote.log-received-messages*
- * *akka.remote.log-remote-lifecycle-events* (this also includes deserialization errors)
+Have a look at the @ref:[Remote Configuration](../logging.md#auxiliary-remote-logging-options).
 
 ### What is the name of a remote actor?
 
@@ -110,16 +106,14 @@ When you want to send messages to an actor on a remote host, you need to know
 its @ref:[full path](../general/addressing.md), which is of the form:
 
 ```
-akka.protocol://system@host:1234/user/my/actor/hierarchy/path
+akka://system@host:1234/user/my/actor/hierarchy/path
 ```
 
 Observe all the parts you need here:
 
- * `protocol` is the protocol to be used to communicate with the remote system.
- Most of the cases this is *tcp*.
  * `system` is the remote system’s name (must match exactly, case-sensitive!)
  * `host` is the remote system’s IP address or DNS name, and it must match that
-system’s configuration (i.e. *akka.remote.classic.netty.tcp.hostname*)
+system’s configuration (i.e. *akka.remote.artery.canonical.hostname*)
  * `1234` is the port number on which the remote system is listening for
 connections and receiving messages
  * `/user/my/actor/hierarchy/path` is the absolute path of the remote actor in
diff --git a/akka-docs/src/main/paradox/cluster-usage.md b/akka-docs/src/main/paradox/cluster-usage.md
index f645c6b7d8..76fd485372 100644
--- a/akka-docs/src/main/paradox/cluster-usage.md
+++ b/akka-docs/src/main/paradox/cluster-usage.md
@@ -108,18 +108,17 @@ akka {
   actor {
     provider = "cluster"
   }
-  remote {
-    log-remote-lifecycle-events = off
-    netty.tcp {
+  remote.artery {
+    canonical {
       hostname = "127.0.0.1"
-      port = 0
+      port = 2551
     }
   }
 
   cluster {
     seed-nodes = [
-      "akka.tcp://ClusterSystem@127.0.0.1:2551",
-      "akka.tcp://ClusterSystem@127.0.0.1:2552"]
+      "akka://ClusterSystem@127.0.0.1:2551",
+      "akka://ClusterSystem@127.0.0.1:2552"]
 
     # auto downing is NOT safe for production deployments.
     # you may want to use it during development, read more about it in the docs.
@@ -128,22 +127,16 @@ akka {
   }
 }
 
-# Enable metrics extension in akka-cluster-metrics.
-akka.extensions=["akka.cluster.metrics.ClusterMetricsExtension"]
-
-# Sigar native library extract location during tests.
-# Note: use per-jvm-instance folder when running multiple jvm on one host.
-akka.cluster.metrics.native-library-extract-folder=${user.dir}/target/native
 ```
 
-To enable cluster capabilities in your Akka project you should, at a minimum, add the @ref:[Remoting](remoting.md)
+To enable cluster capabilities in your Akka project you should, at a minimum, add the @ref:[Remoting](remoting-artery.md)
 settings, but with `cluster`.
 The `akka.cluster.seed-nodes` should normally also be added to your `application.conf` file.
 
 @@@ note
 
 If you are running Akka in a Docker container or the nodes for some other reason have separate internal and
-external ip addresses you must configure remoting according to @ref:[Akka behind NAT or in a Docker container](remoting.md#remote-configuration-nat)
+external ip addresses you must configure remoting according to @ref:[Akka behind NAT or in a Docker container](remoting-artery.md#remote-configuration-nat-artery)
 
 @@@
 
@@ -190,15 +183,15 @@ You define the seed nodes in the [configuration](#cluster-configuration) file (a
 
 ```
 akka.cluster.seed-nodes = [
-  "akka.tcp://ClusterSystem@host1:2552",
-  "akka.tcp://ClusterSystem@host2:2552"]
+  "akka://ClusterSystem@host1:2552",
+  "akka://ClusterSystem@host2:2552"]
 ```
 
 This can also be defined as Java system properties when starting the JVM using the following syntax:
 
 ```
--Dakka.cluster.seed-nodes.0=akka.tcp://ClusterSystem@host1:2552
--Dakka.cluster.seed-nodes.1=akka.tcp://ClusterSystem@host2:2552
+-Dakka.cluster.seed-nodes.0=akka://ClusterSystem@host1:2552
+-Dakka.cluster.seed-nodes.1=akka://ClusterSystem@host2:2552
 ```
 
 The seed nodes can be started in any order and it is not necessary to have all
@@ -846,7 +839,7 @@ Where the <node-url> should be on the format of
   'akka.<protocol>://<actor-system-name>@<hostname>:<port>'
 
 Examples: ./akka-cluster localhost 9999 is-available
-          ./akka-cluster localhost 9999 join akka.tcp://MySystem@darkstar:2552
+          ./akka-cluster localhost 9999 join akka://MySystem@darkstar:2552
           ./akka-cluster localhost 9999 cluster-status
 ```
 
diff --git a/akka-docs/src/main/paradox/general/addressing.md b/akka-docs/src/main/paradox/general/addressing.md
index b433706078..267a98b2b2 100644
--- a/akka-docs/src/main/paradox/general/addressing.md
+++ b/akka-docs/src/main/paradox/general/addressing.md
@@ -95,12 +95,10 @@ by which the corresponding actor is reachable, followed by the names of the
 actors in the hierarchy from the root up. Examples are:
 
 ```
-"akka://my-sys/user/service-a/worker1"                   // purely local
-"akka.tcp://my-sys@host.example.com:5678/user/service-b" // remote
+"akka://my-sys/user/service-a/worker1"               // purely local
+"akka://my-sys@host.example.com:5678/user/service-b" // remote
 ```
 
-Here, `akka.tcp` is the default remote transport for the 2.4 release; other transports
-are pluggable.
 The interpretation of the host and port part (i.e. `host.example.com:5678` in the example)
 depends on the transport mechanism used, but it must abide by the URI structural rules.
 
@@ -325,4 +323,4 @@ there are no quirks to remember, it makes the whole system more uniform and
 consistent.
 
 If you want to read more about the top-level structure of an actor system, have
-a look at @ref:[The Top-Level Supervisors](supervision.md#toplevel-supervisors).
\ No newline at end of file
+a look at @ref:[The Top-Level Supervisors](supervision.md#toplevel-supervisors).
diff --git a/akka-docs/src/main/paradox/general/configuration.md b/akka-docs/src/main/paradox/general/configuration.md
index 2bd14ec034..550675a5f0 100644
--- a/akka-docs/src/main/paradox/general/configuration.md
+++ b/akka-docs/src/main/paradox/general/configuration.md
@@ -155,9 +155,9 @@ akka {
     }
   }
 
-  remote {
-    # The port clients should connect to. Default is 2552.
-    netty.tcp.port = 4711
+  remote.artery {
+    # The port clients should connect to.
+    canonical.port = 4711
   }
 }
 ```
diff --git a/akka-docs/src/main/paradox/general/remoting.md b/akka-docs/src/main/paradox/general/remoting.md
index f6ee3d45c2..30ac482a4b 100644
--- a/akka-docs/src/main/paradox/general/remoting.md
+++ b/akka-docs/src/main/paradox/general/remoting.md
@@ -66,7 +66,7 @@ containers violates assumption 1, unless additional steps are taken in the
 network configuration to allow symmetric communication between involved systems.
 In such situations Akka can be configured to bind to a different network
 address than the one used for establishing connections between Akka nodes.
-See @ref:[Akka behind NAT or in a Docker container](../remoting.md#remote-configuration-nat).
+See @ref:[Akka behind NAT or in a Docker container](../remoting-artery.md#remote-configuration-nat-artery).
 
 ## Marking Points for Scaling Up with Routers
 
@@ -81,4 +81,4 @@ up a configurable number of children of the desired type and route to them in
 the configured fashion. Once such a router has been declared, its configuration
 can be freely overridden from the configuration file, including mixing it with
 the remote deployment of (some of) the children. Read more about
-this in @ref:[Routing](../routing.md).
\ No newline at end of file
+this in @ref:[Routing](../routing.md).
diff --git a/akka-docs/src/main/paradox/index-cluster.md b/akka-docs/src/main/paradox/index-cluster.md
index 53ea2f33f8..17a6f42193 100644
--- a/akka-docs/src/main/paradox/index-cluster.md
+++ b/akka-docs/src/main/paradox/index-cluster.md
@@ -14,10 +14,11 @@
 * [cluster-metrics](cluster-metrics.md)
 * [distributed-data](distributed-data.md)
 * [cluster-dc](cluster-dc.md)
+* [serialization](serialization.md)
 * [multi-jvm-testing](multi-jvm-testing.md)
 * [multi-node-testing](multi-node-testing.md)
-* [remoting](remoting.md)
 * [remoting-artery](remoting-artery.md)
-* [serialization](serialization.md)
+* [remoting](remoting.md)
+
 
 @@@
diff --git a/akka-docs/src/main/paradox/logging.md b/akka-docs/src/main/paradox/logging.md
index b7eb712797..2375016575 100644
--- a/akka-docs/src/main/paradox/logging.md
+++ b/akka-docs/src/main/paradox/logging.md
@@ -209,41 +209,20 @@ akka {
 If you want to see all messages that are sent through remoting at DEBUG log level, use the following config option. Note that this logs the messages as they are sent by the transport layer, not by an actor.
 
 ```ruby
-akka {
-  remote {
-    # If this is "on", Akka will log all outbound messages at DEBUG level,
-    # if off then they are not logged
-    log-sent-messages = on
-  }
+akka.remote.artery {
+  # If this is "on", Akka will log all outbound messages at DEBUG level,
+  # if off then they are not logged
+  log-sent-messages = on
 }
 ```
 
 If you want to see all messages that are received through remoting at DEBUG log level, use the following config option. Note that this logs the messages as they are received by the transport layer, not by an actor.
 
 ```ruby
-akka {
-  remote {
-    # If this is "on", Akka will log all inbound messages at DEBUG level,
-    # if off then they are not logged
-    log-received-messages = on
-  }
-}
-```
-
-If you want to see message types with payload size in bytes larger than
-a specified limit at INFO log level:
-
-```ruby
-akka {
-  remote {
-    # Logging of message types with payload size in bytes larger than
-    # this value. Maximum detected size per message type is logged once,
-    # with an increase threshold of 10%.
-    # By default this feature is turned off. Activate it by setting the property to
-    # a value in bytes, such as 1000b. Note that for all messages larger than this
-    # limit there will be extra performance and scalability cost.
-    log-frame-size-exceeding = 1000b
-  }
+akka.remote.artery {
+  # If this is "on", Akka will log all inbound messages at DEBUG level,
+  # if off then they are not logged
+  log-received-messages = on
 }
 ```
 
diff --git a/akka-docs/src/main/paradox/security/index.md b/akka-docs/src/main/paradox/security/index.md
index a293cec584..ba7e8dcd14 100644
--- a/akka-docs/src/main/paradox/security/index.md
+++ b/akka-docs/src/main/paradox/security/index.md
@@ -18,9 +18,9 @@ to ensure that a fix can be provided without delay.
 
 ## Security Related Documentation
 
- * @ref:[Disabling the Java Serializer](../remoting.md#disable-java-serializer)
+ * @ref:[Disabling the Java Serializer](../remoting-artery.md#disable-java-serializer)
  * @ref:[Remote deployment whitelist](../remoting.md#remote-deployment-whitelist)
- * @ref:[Remote Security](../remoting.md#remote-security)
+ * @ref:[Remote Security](../remoting-artery.md#remote-security)
 
 ## Fixed Security Vulnerabilities
 
diff --git a/akka-docs/src/main/paradox/serialization.md b/akka-docs/src/main/paradox/serialization.md
index b063be513f..4d41018059 100644
--- a/akka-docs/src/main/paradox/serialization.md
+++ b/akka-docs/src/main/paradox/serialization.md
@@ -53,7 +53,7 @@ depending on the akka-remote module), so normally you don't need to add
 configuration for that; since `com.google.protobuf.GeneratedMessage`
 implements `java.io.Serializable`, protobuf messages will always be
 serialized using the protobuf protocol unless specifically overridden. In order
-to disable a default serializer, see @ref:[Disabling the Java Serializer](remoting.md#disable-java-serializer)
+to disable a default serializer, see @ref:[Disabling the Java Serializer](remoting-artery.md#disable-java-serializer)
 
 ### Enable additional bindings
 
diff --git a/akka-docs/src/test/java/jdocs/actor/ActorDocTest.java b/akka-docs/src/test/java/jdocs/actor/ActorDocTest.java
index c4f2e3fa2b..2e1b2db412 100644
--- a/akka-docs/src/test/java/jdocs/actor/ActorDocTest.java
+++ b/akka-docs/src/test/java/jdocs/actor/ActorDocTest.java
@@ -337,7 +337,7 @@ public class ActorDocTest extends AbstractJavaTest {
       // #selection-wildcard
 
       // #selection-remote
-      getContext().actorSelection("akka.tcp://app@otherhost:1234/user/serviceB");
+      getContext().actorSelection("akka://app@otherhost:1234/user/serviceB");
       // #selection-remote
     }
   }
diff --git a/akka-docs/src/test/java/jdocs/persistence/LambdaPersistencePluginDocTest.java b/akka-docs/src/test/java/jdocs/persistence/LambdaPersistencePluginDocTest.java
index fa8bb6fbea..33ee38ffd7 100644
--- a/akka-docs/src/test/java/jdocs/persistence/LambdaPersistencePluginDocTest.java
+++ b/akka-docs/src/test/java/jdocs/persistence/LambdaPersistencePluginDocTest.java
@@ -44,7 +44,7 @@ public class LambdaPersistencePluginDocTest {
         class SharedStorageUsage extends AbstractActor {
           @Override
           public void preStart() throws Exception {
-            String path = "akka.tcp://example@127.0.0.1:2552/user/store";
+            String path = "akka://example@127.0.0.1:2552/user/store";
             ActorSelection selection = getContext().actorSelection(path);
             selection.tell(new Identify(1), getSelf());
           }
diff --git a/akka-docs/src/test/java/jdocs/remoting/RemoteDeploymentDocTest.java b/akka-docs/src/test/java/jdocs/remoting/RemoteDeploymentDocTest.java
index 88cc5bb4de..b6995b4394 100644
--- a/akka-docs/src/test/java/jdocs/remoting/RemoteDeploymentDocTest.java
+++ b/akka-docs/src/test/java/jdocs/remoting/RemoteDeploymentDocTest.java
@@ -49,8 +49,8 @@ public class RemoteDeploymentDocTest extends AbstractJavaTest {
   @Test
   public void demonstrateDeployment() {
     // #make-address
-    Address addr = new Address("akka.tcp", "sys", "host", 1234);
-    addr = AddressFromURIString.parse("akka.tcp://sys@host:1234"); // the same
+    Address addr = new Address("akka", "sys", "host", 1234);
+    addr = AddressFromURIString.parse("akka://sys@host:1234"); // the same
     // #make-address
     // #deploy
     ActorRef ref =
diff --git a/akka-docs/src/test/java/jdocs/routing/RouterDocTest.java b/akka-docs/src/test/java/jdocs/routing/RouterDocTest.java
index f79f30a5b8..64670bebd2 100644
--- a/akka-docs/src/test/java/jdocs/routing/RouterDocTest.java
+++ b/akka-docs/src/test/java/jdocs/routing/RouterDocTest.java
@@ -451,8 +451,8 @@ public class RouterDocTest extends AbstractJavaTest {
   public void demonstrateRemoteDeploy() {
     // #remoteRoutees
     Address[] addresses = {
-      new Address("akka.tcp", "remotesys", "otherhost", 1234),
-      AddressFromURIString.parse("akka.tcp://othersys@anotherhost:1234")
+      new Address("akka", "remotesys", "otherhost", 1234),
+      AddressFromURIString.parse("akka://othersys@anotherhost:1234")
     };
     ActorRef routerRemote =
         system.actorOf(
diff --git a/akka-docs/src/test/scala/docs/actor/ActorDocSpec.scala b/akka-docs/src/test/scala/docs/actor/ActorDocSpec.scala
index 910b4854d2..58643f90cf 100644
--- a/akka-docs/src/test/scala/docs/actor/ActorDocSpec.scala
+++ b/akka-docs/src/test/scala/docs/actor/ActorDocSpec.scala
@@ -623,7 +623,7 @@ class ActorDocSpec extends AkkaSpec("""
     context.actorSelection("../*")
     //#selection-wildcard
     //#selection-remote
-    context.actorSelection("akka.tcp://app@otherhost:1234/user/serviceB")
+    context.actorSelection("akka://app@otherhost:1234/user/serviceB")
     //#selection-remote
   }
 
diff --git a/akka-docs/src/test/scala/docs/config/ConfigDocSpec.scala b/akka-docs/src/test/scala/docs/config/ConfigDocSpec.scala
index 4d15615267..9a14ab3e3f 100644
--- a/akka-docs/src/test/scala/docs/config/ConfigDocSpec.scala
+++ b/akka-docs/src/test/scala/docs/config/ConfigDocSpec.scala
@@ -41,7 +41,7 @@ class ConfigDocSpec extends WordSpec with Matchers {
   
     # '/user/actorA/actorB' is a remote deployed actor
     /actorA/actorB {
-      remote = "akka.tcp://sampleActorSystem@127.0.0.1:2553"
+      remote = "akka://sampleActorSystem@127.0.0.1:2553"
     }
     
     # all direct children of '/user/actorC' have a dedicated dispatcher 
diff --git a/akka-docs/src/test/scala/docs/persistence/PersistencePluginDocSpec.scala b/akka-docs/src/test/scala/docs/persistence/PersistencePluginDocSpec.scala
index f588cc06c5..e8683a4ea1 100644
--- a/akka-docs/src/test/scala/docs/persistence/PersistencePluginDocSpec.scala
+++ b/akka-docs/src/test/scala/docs/persistence/PersistencePluginDocSpec.scala
@@ -129,7 +129,7 @@ object SharedLeveldbPluginDocSpec {
   //#shared-store-usage
   trait SharedStoreUsage extends Actor {
     override def preStart(): Unit = {
-      context.actorSelection("akka.tcp://example@127.0.0.1:2552/user/store") ! Identify(1)
+      context.actorSelection("akka://example@127.0.0.1:2552/user/store") ! Identify(1)
     }
 
     def receive = {
diff --git a/akka-docs/src/test/scala/docs/remoting/RemoteDeploymentDocSpec.scala b/akka-docs/src/test/scala/docs/remoting/RemoteDeploymentDocSpec.scala
index 49d97db280..1839c981e6 100644
--- a/akka-docs/src/test/scala/docs/remoting/RemoteDeploymentDocSpec.scala
+++ b/akka-docs/src/test/scala/docs/remoting/RemoteDeploymentDocSpec.scala
@@ -29,7 +29,7 @@ class RemoteDeploymentDocSpec extends AkkaSpec("""
 
   val other = ActorSystem("remote", system.settings.config)
   val address =
-    other.asInstanceOf[ExtendedActorSystem].provider.getExternalAddressFor(Address("akka.tcp", "s", "host", 1)).get
+    other.asInstanceOf[ExtendedActorSystem].provider.getExternalAddressFor(Address("akka", "s", "host", 1)).get
 
   override def afterTermination(): Unit = { shutdown(other) }
 
@@ -51,8 +51,8 @@ class RemoteDeploymentDocSpec extends AkkaSpec("""
 
   "demonstrate address extractor" in {
     //#make-address
-    val one = AddressFromURIString("akka.tcp://sys@host:1234")
-    val two = Address("akka.tcp", "sys", "host", 1234) // this gives the same
+    val one = AddressFromURIString("akka://sys@host:1234")
+    val two = Address("akka", "sys", "host", 1234) // this gives the same
     //#make-address
     one should be(two)
   }
diff --git a/akka-docs/src/test/scala/docs/routing/RouterDocSpec.scala b/akka-docs/src/test/scala/docs/routing/RouterDocSpec.scala
index 1781f39170..44d27eebcc 100644
--- a/akka-docs/src/test/scala/docs/routing/RouterDocSpec.scala
+++ b/akka-docs/src/test/scala/docs/routing/RouterDocSpec.scala
@@ -210,7 +210,7 @@ akka.actor.deployment {
   /parent/remotePool {
     router = round-robin-pool
     nr-of-instances = 10
-    target.nodes = ["akka.tcp://app@10.0.0.2:2552", "akka.tcp://app@10.0.0.3:2552"]
+    target.nodes = ["akka://app@10.0.0.2:2552", "akka://app@10.0.0.3:2552"]
   }
 }
 #//#config-remote-round-robin-pool
@@ -230,9 +230,9 @@ akka.actor.deployment {
   /parent/remoteGroup {
     router = round-robin-group
     routees.paths = [
-      "akka.tcp://app@10.0.0.1:2552/user/workers/w1",
-      "akka.tcp://app@10.0.0.2:2552/user/workers/w1",
-      "akka.tcp://app@10.0.0.3:2552/user/workers/w1"]
+      "akka://app@10.0.0.1:2552/user/workers/w1",
+      "akka://app@10.0.0.2:2552/user/workers/w1",
+      "akka://app@10.0.0.3:2552/user/workers/w1"]
   }
 }
 #//#config-remote-round-robin-group
@@ -596,9 +596,8 @@ class RouterDocSpec extends AkkaSpec(RouterDocSpec.config) with ImplicitSender {
     //#remoteRoutees
     import akka.actor.{ Address, AddressFromURIString }
     import akka.remote.routing.RemoteRouterConfig
-    val addresses = Seq(
-      Address("akka.tcp", "remotesys", "otherhost", 1234),
-      AddressFromURIString("akka.tcp://othersys@anotherhost:1234"))
+    val addresses =
+      Seq(Address("akka", "remotesys", "otherhost", 1234), AddressFromURIString("akka://othersys@anotherhost:1234"))
     val routerRemote = system.actorOf(RemoteRouterConfig(RoundRobinPool(5), addresses).props(Props[Echo]))
     //#remoteRoutees
   }
diff --git a/akka-remote/src/main/resources/reference.conf b/akka-remote/src/main/resources/reference.conf
index 988f3ab37e..8e2af332f6 100644
--- a/akka-remote/src/main/resources/reference.conf
+++ b/akka-remote/src/main/resources/reference.conf
@@ -153,14 +153,14 @@ akka {
       default {
 
         # if this is set to a valid remote address, the named actor will be
-        # deployed at that node e.g. "akka.tcp://sys@host:port"
+        # deployed at that node e.g. "akka://sys@host:port"
         remote = ""
 
         target {
 
           # A list of hostnames and ports for instantiating the children of a
           # router
-          #   The format should be on "akka.tcp://sys@host:port", where:
+          #   The format should be on "akka://sys@host:port", where:
           #    - sys is the remote actor system name
           #    - hostname can be either hostname or IP address the remote actor
           #      should connect to
diff --git a/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala b/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala
index 299a56f42c..5f3dd97bb9 100644
--- a/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala
+++ b/akka-remote/src/main/scala/akka/remote/RemoteActorRefProvider.scala
@@ -303,11 +303,11 @@ private[akka] class RemoteActorRefProvider(
        *
        * Example:
        *
-       * akka.tcp://sys@home:1234/remote/akka/sys@remote:6667/remote/akka/sys@other:3333/user/a/b/c
+       * akka://sys@home:1234/remote/akka/sys@remote:6667/remote/akka/sys@other:3333/user/a/b/c
        *
-       * means that the logical parent originates from “akka.tcp://sys@other:3333” with
-       * one child (may be “a” or “b”) being deployed on “akka.tcp://sys@remote:6667” and
-       * finally either “b” or “c” being created on “akka.tcp://sys@home:1234”, where
+       * means that the logical parent originates from “akka://sys@other:3333” with
+       * one child (may be “a” or “b”) being deployed on “akka://sys@remote:6667” and
+       * finally either “b” or “c” being created on “akka://sys@home:1234”, where
        * this whole thing actually resides. Thus, the logical path is
        * “/user/a/b/c” and the physical path contains all remote placement
        * information.
diff --git a/akka-remote/src/test/scala/akka/remote/DaemonicSpec.scala b/akka-remote/src/test/scala/akka/remote/DaemonicSpec.scala
index c95496ac07..81520eee10 100644
--- a/akka-remote/src/test/scala/akka/remote/DaemonicSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/DaemonicSpec.scala
@@ -30,14 +30,16 @@ class DaemonicSpec extends AkkaSpec {
         akka.actor.provider = remote
         akka.remote.classic.netty.tcp.transport-class = "akka.remote.transport.netty.NettyTransport"
         akka.remote.classic.netty.tcp.port = 0
+        akka.remote.artery.canonical.port = 0
         akka.log-dead-letters-during-shutdown = off
       """))
 
       try {
         val unusedPort = 86 // very unlikely to ever be used, "system port" range reserved for Micro Focus Cobol
 
+        val protocol = if (RARP(daemonicSystem).provider.remoteSettings.Artery.Enabled) "akka" else "akka.tcp"
         val unusedAddress =
-          RARP(daemonicSystem).provider.getExternalAddressFor(Address(s"akka.tcp", "", "", unusedPort)).get
+          RARP(daemonicSystem).provider.getExternalAddressFor(Address(protocol, "", "", unusedPort)).get
         val selection = daemonicSystem.actorSelection(s"$unusedAddress/user/SomeActor")
         selection ! "whatever"
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StreamRefsSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StreamRefsSpec.scala
index b4705bd297..7563829ea3 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StreamRefsSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/StreamRefsSpec.scala
@@ -155,7 +155,7 @@ object StreamRefsSpec {
       }
       remote {
         artery.canonical.port = 0
-        netty.tcp.port = 0
+        classic.netty.tcp.port = 0
       }
     }
   """).withFallback(ConfigFactory.load())