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]