RemoteActorRefProvider address paring, caching and resolving improvements

src/core/Akka.API.Tests/CoreAPISpec.ApproveCore.approved.txt

@@ -177,18 +177,21 @@ namespace Akka.Actor
         protected ActorPath(Akka.Actor.Address address, string name) { }
         protected ActorPath(Akka.Actor.ActorPath parentPath, string name, long uid) { }
         public Akka.Actor.Address Address { get; }
-        public abstract System.Collections.Generic.IReadOnlyList<string> Elements { get; }
+        public int Depth { get; }
+        public System.Collections.Generic.IReadOnlyList<string> Elements { get; }
         public string Name { get; }
-        public abstract Akka.Actor.ActorPath Parent { get; }
-        public abstract Akka.Actor.ActorPath Root { get; }
+        public Akka.Actor.ActorPath Parent { get; }
+        [Newtonsoft.Json.JsonIgnoreAttribute()]
+        public Akka.Actor.ActorPath Root { get; }
         public long Uid { get; }
         public Akka.Actor.ActorPath Child(string childName) { }
-        public abstract int CompareTo(Akka.Actor.ActorPath other);
+        public int CompareTo(Akka.Actor.ActorPath other) { }
         public bool Equals(Akka.Actor.ActorPath other) { }
         public override bool Equals(object obj) { }
         public static string FormatPathElements(System.Collections.Generic.IEnumerable<string> pathElements) { }
         public override int GetHashCode() { }
         public static bool IsValidPathElement(string s) { }
+        public Akka.Actor.ActorPath ParentOf(int depth) { }
         public static Akka.Actor.ActorPath Parse(string path) { }
         public string ToSerializationFormat() { }
         public string ToSerializationFormatWithAddress(Akka.Actor.Address address) { }
@@ -199,13 +202,16 @@ namespace Akka.Actor
         public string ToStringWithoutAddress() { }
         public Akka.Util.ISurrogate ToSurrogate(Akka.Actor.ActorSystem system) { }
         public static bool TryParse(string path, out Akka.Actor.ActorPath actorPath) { }
+        public static bool TryParse(Akka.Actor.ActorPath basePath, System.ReadOnlySpan<char> absoluteUri, out Akka.Actor.ActorPath actorPath) { }
         public static bool TryParseAddress(string path, out Akka.Actor.Address address) { }
-        public abstract Akka.Actor.ActorPath WithUid(long uid);
+        public static bool TryParseAddress(string path, out Akka.Actor.Address address, out System.ReadOnlySpan<char> absoluteUri) { }
+        public static bool TryParseParts(System.ReadOnlySpan<char> path, out System.ReadOnlySpan<char> address, out System.ReadOnlySpan<char> absoluteUri) { }
+        public Akka.Actor.ActorPath WithUid(long uid) { }
         public static Akka.Actor.ActorPath /(Akka.Actor.ActorPath path, string name) { }
         public static Akka.Actor.ActorPath /(Akka.Actor.ActorPath path, System.Collections.Generic.IEnumerable<string> name) { }
         public static bool ==(Akka.Actor.ActorPath left, Akka.Actor.ActorPath right) { }
         public static bool !=(Akka.Actor.ActorPath left, Akka.Actor.ActorPath right) { }
-        public class Surrogate : Akka.Util.ISurrogate, System.IEquatable<Akka.Actor.ActorPath.Surrogate>, System.IEquatable<Akka.Actor.ActorPath>
+        public sealed class Surrogate : Akka.Util.ISurrogate, System.IEquatable<Akka.Actor.ActorPath.Surrogate>, System.IEquatable<Akka.Actor.ActorPath>
         {
             public Surrogate(string path) { }
             public string Path { get; }
@@ -408,13 +414,14 @@ namespace Akka.Actor
         public static Akka.Actor.Address Parse(string address) { }
         public override string ToString() { }
         public Akka.Util.ISurrogate ToSurrogate(Akka.Actor.ActorSystem system) { }
+        public static bool TryParse(System.ReadOnlySpan<char> span, out Akka.Actor.Address address) { }
         public Akka.Actor.Address WithHost(string host = null) { }
         public Akka.Actor.Address WithPort(System.Nullable<int> port = null) { }
         public Akka.Actor.Address WithProtocol(string protocol) { }
         public Akka.Actor.Address WithSystem(string system) { }
         public static bool ==(Akka.Actor.Address left, Akka.Actor.Address right) { }
         public static bool !=(Akka.Actor.Address left, Akka.Actor.Address right) { }
-        public class AddressSurrogate : Akka.Util.ISurrogate
+        public sealed class AddressSurrogate : Akka.Util.ISurrogate
         {
             public AddressSurrogate() { }
             public string Host { get; set; }
@@ -497,15 +504,9 @@ namespace Akka.Actor
     {
         public static void CancelIfNotNull(this Akka.Actor.ICancelable cancelable) { }
     }
-    public class ChildActorPath : Akka.Actor.ActorPath
+    public sealed class ChildActorPath : Akka.Actor.ActorPath
     {
         public ChildActorPath(Akka.Actor.ActorPath parentPath, string name, long uid) { }
-        public override System.Collections.Generic.IReadOnlyList<string> Elements { get; }
-        public override Akka.Actor.ActorPath Parent { get; }
-        public override Akka.Actor.ActorPath Root { get; }
-        public override int CompareTo(Akka.Actor.ActorPath other) { }
-        public override int GetHashCode() { }
-        public override Akka.Actor.ActorPath WithUid(long uid) { }
     }
     public sealed class CoordinatedShutdown : Akka.Actor.IExtension
     {
@@ -1546,15 +1547,9 @@ namespace Akka.Actor
         public void SwapUnderlying(Akka.Actor.ICell cell) { }
         protected override void TellInternal(object message, Akka.Actor.IActorRef sender) { }
     }
-    public class RootActorPath : Akka.Actor.ActorPath
+    public sealed class RootActorPath : Akka.Actor.ActorPath
     {
         public RootActorPath(Akka.Actor.Address address, string name = "") { }
-        public override System.Collections.Generic.IReadOnlyList<string> Elements { get; }
-        public override Akka.Actor.ActorPath Parent { get; }
-        [Newtonsoft.Json.JsonIgnoreAttribute()]
-        public override Akka.Actor.ActorPath Root { get; }
-        public override int CompareTo(Akka.Actor.ActorPath other) { }
-        public override Akka.Actor.ActorPath WithUid(long uid) { }
     }
     [Akka.Annotations.InternalApiAttribute()]
     public class RootGuardianActorRef : Akka.Actor.LocalActorRef

src/core/Akka.Remote.Tests/RemotingSpec.cs

@@ -23,6 +23,7 @@
 using Xunit.Abstractions;
 using Nito.AsyncEx;
 using ThreadLocalRandom = Akka.Util.ThreadLocalRandom;
+using Akka.Remote.Serialization;
 
 namespace Akka.Remote.Tests
 {
@@ -176,7 +177,7 @@ public async Task Remoting_must_support_Ask()
             Assert.Equal("pong", msg);
             Assert.IsType<FutureActorRef<(string, IActorRef)>>(actorRef);
         }
-
+        
         [Fact(Skip = "Racy")]
         public async Task Ask_does_not_deadlock()
         {

src/core/Akka.Remote.Tests/Serialization/LruBoundedCacheSpec.cs

@@ -5,6 +5,8 @@
 // </copyright>
 //-----------------------------------------------------------------------
 
+using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using Akka.Remote.Serialization;
@@ -14,22 +16,55 @@
 
 namespace Akka.Remote.Tests.Serialization
 {
+    sealed class FastHashTestComparer : IEqualityComparer<string>
+    {
+        private readonly string _hashSeed;
+
+        public FastHashTestComparer(string hashSeed = "")
+        {
+            _hashSeed = hashSeed;
+        }
+
+        public bool Equals(string x, string y)
+        {
+            return StringComparer.Ordinal.Equals(x, y);
+        }
+
+        public int GetHashCode(string k)
+        {
+            return  FastHash.OfStringFast(_hashSeed != string.Empty 
+                        ? _hashSeed + k + _hashSeed : k);
+        }
+    }
+
+    sealed class BrokenTestComparer : IEqualityComparer<string>
+    {
+        public bool Equals(string x, string y)
+        {
+            return StringComparer.Ordinal.Equals(x, y);
+        }
+
+        public int GetHashCode(string k)
+        {
+            return 0;
+        }
+    }
+
     public class LruBoundedCacheSpec
     {
         private class TestCache : LruBoundedCache<string, string> {
-            public TestCache(int capacity, int evictAgeThreshold, string hashSeed = "") : base(capacity, evictAgeThreshold)
+            public TestCache(int capacity, int evictAgeThreshold, IEqualityComparer<string> comparer) 
+                : base(capacity, evictAgeThreshold, comparer)
             {
-                _hashSeed = hashSeed;
             }
 
-            private readonly string _hashSeed;
-            private int _cntr = 0;
-
-            protected override int Hash(string k)
+            public TestCache(int capacity, int evictAgeThreshold, string hashSeed = "")
+                : base(capacity, evictAgeThreshold, new FastHashTestComparer(hashSeed))
             {
-                return FastHash.OfStringFast(_hashSeed + k + _hashSeed);
             }
 
+            private int _cntr = 0;
+
             protected override string Compute(string k)
             {
                 var id = _cntr;
@@ -71,20 +106,17 @@ public void ExpectComputedOnly(string key, string value)
 
         private sealed class BrokenHashFunctionTestCache : TestCache
         {
-            public BrokenHashFunctionTestCache(int capacity, int evictAgeThreshold, string hashSeed = "") : base(capacity, evictAgeThreshold, hashSeed)
+            public BrokenHashFunctionTestCache(int capacity, int evictAgeThreshold) : 
+                base(capacity, evictAgeThreshold, new BrokenTestComparer())
             {
             }
 
-            protected override int Hash(string k)
-            {
-                return 0;
-            }
         }
 
         [Fact]
         public void LruBoundedCache_must_work_in_the_happy_case()
         {
-            var cache = new TestCache(4,4);
+            var cache = new TestCache(4, 4);
 
             cache.ExpectComputed("A", "A:0");
             cache.ExpectComputed("B", "B:1");
@@ -97,6 +129,19 @@ public void LruBoundedCache_must_work_in_the_happy_case()
             cache.ExpectCached("D", "D:3");
         }
 
+        [Fact]
+        public void LruBoundedCache_must_handle_explict_set()
+        {
+            var cache = new TestCache(4, 4);
+
+            cache.ExpectComputed("A", "A:0");
+            cache.TrySet("A", "A:1").Should().Be(true);
+            cache.Get("A").Should().Be("A:1");
+
+            cache.TrySet("B", "B:X").Should().Be(true);
+            cache.Get("B").Should().Be("B:X");
+        }
+
         [Fact]
         public void LruBoundedCache_must_evict_oldest_when_full()
         {
@@ -237,6 +282,8 @@ public void LruBoundedCache_must_not_cache_noncacheable_values()
             cache.ExpectCached("C", "C:6");
             cache.ExpectCached("D", "D:7");
             cache.ExpectCached("E", "E:8");
+
+            cache.TrySet("#X", "#X:13").Should().BeFalse();
         }
 
         [Fact]