Improve user experience in heterogeneous silos

src/Orleans.Core.Abstractions/IDs/GrainTypePrefix.cs

@@ -58,6 +58,16 @@ public static class GrainTypePrefix
         /// </summary>
         public static readonly ReadOnlyMemory<byte> LegacyGrainPrefixBytes = Encoding.UTF8.GetBytes(LegacyGrainPrefix);
 
+        /// <summary>
+        /// The prefix for stub grain (grain without definitive type).
+        /// </summary>
+        public const string StubGrainPrefix = SystemPrefix + "grain.stub.";
+
+        /// <summary>
+        /// A span representation of <see cref="StubGrainPrefix"/>
+        /// </summary>
+        public static readonly ReadOnlyMemory<byte> StubGrainPrefixBytes = Encoding.UTF8.GetBytes(StubGrainPrefix);
+
         /// <summary>
         /// Returns <see langword="true"/> if the type is a client, <see langword="false"/> if not.
         /// </summary>
@@ -99,5 +109,36 @@ public static class GrainTypePrefix
         /// <param name="id">The grain id.</param>
         /// <returns><see langword="true"/> if the type is a system target, <see langword="false"/> if not.</returns>
         public static bool IsSystemTarget(this in GrainId id) => id.Type.IsSystemTarget();
+
+        /// <summary>
+        /// Returns  <see langword="true"/> if the grain is a stub grain.
+        /// </summary>
+        /// <param name="type">The grain type.</param>
+        /// <returns><see langword="true"/> if the type is a stub type , <see langword="false"/> if not.</returns>
+        public static bool IsStubGrain(this in GrainType type) => type.AsSpan().StartsWith(StubGrainPrefixBytes.Span);
+
+        /// <summary>
+        /// Create a stub grain type.
+        /// </summary>
+        /// <param name="grainClassPrefix">The prefix of the class to be used.</param>
+        /// <returns>The grain type.</returns>
+        public static GrainType CreateStubGrainType(string grainClassPrefix)
+        {
+            return string.IsNullOrWhiteSpace(grainClassPrefix)
+                ? new GrainType(StubGrainPrefixBytes.ToArray())
+                : GrainType.Create(string.Concat(StubGrainPrefix, grainClassPrefix));
+        }
+
+        public static bool TryGetCrainClassPrefix(GrainType grainType, out string grainClassPrefix)
+        {
+            if (!IsStubGrain(grainType))
+            {
+                grainClassPrefix = default;
+                return false;
+            }
+
+            grainClassPrefix = Encoding.UTF8.GetString(grainType.AsSpan().Slice(StubGrainPrefixBytes.Length));
+            return true;
+        }
     }
 }

src/Orleans.Core.Abstractions/Runtime/GrainReference.cs

@@ -256,7 +256,7 @@ public class GrainReference : IAddressable, IEquatable<GrainReference>, ISpanFor
         /// The grain reference functionality which is shared by all grain references of a given type.
         /// </summary>
         [NonSerialized]
-        private readonly GrainReferenceShared _shared;
+        private GrainReferenceShared _shared;
 
         /// <summary>
         /// The underlying grain id key.
@@ -267,7 +267,11 @@ public class GrainReference : IAddressable, IEquatable<GrainReference>, ISpanFor
         /// <summary>
         /// Gets the grain reference functionality which is shared by all grain references of a given type.
         /// </summary>
-        internal GrainReferenceShared Shared => _shared ?? throw new GrainReferenceNotBoundException(this);
+        internal GrainReferenceShared Shared
+        {
+            get => _shared ?? throw new GrainReferenceNotBoundException(this);
+            set => _shared = value;
+        }
 
         /// <summary>
         /// Gets the grain reference runtime.

src/Orleans.Core/Core/DefaultClientServices.cs

@@ -19,6 +19,7 @@
 using Orleans.Serialization.Cloning;
 using Microsoft.Extensions.Hosting;
 using System.Runtime.InteropServices;
+using System;
 
 namespace Orleans
 {
@@ -42,6 +43,8 @@ public static void AddDefaultServices(IServiceCollection services)
 
             services.Add(ServiceDescriptor);
 
+            services.TryAddSingleton<TimeProvider>(TimeProvider.System);
+
             // Options logging
             services.TryAddSingleton(typeof(IOptionFormatter<>), typeof(DefaultOptionsFormatter<>));
             services.TryAddSingleton(typeof(IOptionFormatterResolver<>), typeof(DefaultOptionsFormatterResolver<>));
@@ -69,6 +72,7 @@ public static void AddDefaultServices(IServiceCollection services)
             services.TryAddSingleton<GrainFactory>();
             services.TryAddSingleton<GrainInterfaceTypeToGrainTypeResolver>();
             services.TryAddSingleton<GrainReferenceActivator>();
+            services.AddSingleton<IGrainReferenceActivatorProvider, StubGrainReferenceActivatorProvider>();
             services.AddSingleton<IGrainReferenceActivatorProvider, GrainReferenceActivatorProvider>();
             services.AddSingleton<IGrainReferenceActivatorProvider, UntypedGrainReferenceActivatorProvider>();
             services.TryAddSingleton<RpcProvider>();

src/Orleans.Core/Core/GrainFactory.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
 using Orleans.GrainReferences;
 using Orleans.Metadata;
 using Orleans.Runtime;
@@ -203,16 +206,24 @@ private IAddressable GetGrain(Type interfaceType, IdSpan grainKey, string grainC
         {
             var grainInterfaceType = this.interfaceTypeResolver.GetGrainInterfaceType(interfaceType);
 
-            GrainType grainType;
-            if (!string.IsNullOrWhiteSpace(grainClassNamePrefix))
+            bool success;
+            GrainType grainType = default;
+            try
             {
-                grainType = this.interfaceTypeToGrainTypeResolver.GetGrainType(grainInterfaceType, grainClassNamePrefix);
+                success = interfaceTypeToGrainTypeResolver.TryGetGrainType(grainInterfaceType, grainClassNamePrefix, out grainType);
             }
-            else
+            catch (ArgumentException)
             {
-                grainType = this.interfaceTypeToGrainTypeResolver.GetGrainType(grainInterfaceType);
+                success = false;
             }
 
+            if (!success)
+            {
+                // Not found in the type map. Maybe it's not available yet ? (heterogeneous case)
+                grainType = GrainTypePrefix.CreateStubGrainType(grainClassNamePrefix);
+            }
+
+            Debug.Assert(!grainType.IsDefault);
             var grainId = GrainId.Create(grainType, grainKey);
             var grain = this.referenceActivator.CreateReference(grainId, grainInterfaceType);
             return grain;

src/Orleans.Core/Core/GrainInterfaceTypeToGrainTypeResolver.cs

@@ -35,13 +35,34 @@ public GrainInterfaceTypeToGrainTypeResolver(IClusterManifestProvider clusterMan
         /// </summary>
         public GrainType GetGrainType(GrainInterfaceType interfaceType, string prefix)
         {
-            if (string.IsNullOrWhiteSpace(prefix))
+            if (string.IsNullOrEmpty(prefix))
             {
                 return GetGrainType(interfaceType);
             }
 
-            GrainType result = default;
+            if (!TryGetGrainType(interfaceType, prefix, out var grainType))
+            {
+                throw new ArgumentException($"Could not find an implementation matching prefix \"{prefix}\" for interface {interfaceType}");
+            }
 
+            return grainType;
+        }
+
+        /// <summary>
+        /// Resolves a <see cref="GrainType"/> which implements the provided <see cref="GrainInterfaceType"/>, returning <see langword="true"/> if an implementation was found; otherwise <see langword="false"/>.
+        /// </summary>
+        /// <param name="interfaceType">The grain interface type.</param>
+        /// <param name="prefix">A prefix of the grain implementation class name to search for.</param>
+        /// <param name="result">The resolved grain type.</param>
+        /// <returns><see langword="true"/> if an implementation was found; otherwise <see langword="false"/>.</returns>
+        public bool TryGetGrainType(GrainInterfaceType interfaceType, string prefix, out GrainType result)
+        {
+            if (string.IsNullOrEmpty(prefix))
+            {
+                return TryGetGrainType(interfaceType, out result);
+            }
+
+            result = default;
             GrainInterfaceType lookupType;
             if (GenericGrainInterfaceType.TryParse(interfaceType, out var genericInterface))
             {
@@ -79,17 +100,12 @@ public GrainType GetGrainType(GrainInterfaceType interfaceType, string prefix)
                 }
             }
 
-            if (result.IsDefault)
-            {
-                throw new ArgumentException($"Could not find an implementation matching prefix \"{prefix}\" for interface {interfaceType}");
-            }
-
-            if (GenericGrainType.TryParse(result, out var genericGrainType) && !genericGrainType.IsConstructed)
+            if (!result.IsDefault && GenericGrainType.TryParse(result, out var genericGrainType) && !genericGrainType.IsConstructed)
             {
                 result = genericGrainType.GetConstructed(genericInterface);
             }
 
-            return result;
+            return !result.IsDefault;
         }
 
         /// <summary>
@@ -108,33 +124,20 @@ public GrainType GetGrainType(GrainInterfaceType interfaceType)
         /// <summary>
         /// Resolves a <see cref="GrainType"/> which implements the provided <see cref="GrainInterfaceType"/>, returning <see langword="true"/> if an implementation was found; otherwise <see langword="false"/>.
         /// </summary>
+        /// <param name="interfaceType">The grain interface type.</param>
+        /// <param name="result">The resolved grain type.</param>
         /// <returns><see langword="true"/> if an implementation was found; otherwise <see langword="false"/>.</returns>
         public bool TryGetGrainType(GrainInterfaceType interfaceType, out GrainType result)
         {
             result = default;
             var cache = GetCache();
             if (cache.Map.TryGetValue(interfaceType, out var entry))
             {
-                if (!entry.PrimaryImplementation.IsDefault)
-                {
-                    result = entry.PrimaryImplementation;
-                }
-                else if (entry.Implementations.Count == 1)
-                {
-                    result = entry.Implementations[0].GrainType;
-                }
-                else if (entry.Implementations.Count > 1)
-                {
-                    var candidates = string.Join(", ", entry.Implementations.Select(i => $"{i.GrainType} ({i.Prefix})"));
-                    throw new ArgumentException($"Unable to identify a single appropriate grain type for interface {interfaceType}. Candidates: {candidates}");
-                }
-                else
-                {
-                    // No implementations
-                }
+                TryFind(interfaceType, entry, out result);
             }
             else if (_genericMapping.TryGetValue(interfaceType, out result))
             {
+                // Nothing needed here.
             }
             else if (GenericGrainInterfaceType.TryParse(interfaceType, out var genericInterface) && genericInterface.IsConstructed)
             {
@@ -164,6 +167,30 @@ public bool TryGetGrainType(GrainInterfaceType interfaceType, out GrainType resu
             return !result.IsDefault;
         }
 
+        private bool TryFind(GrainInterfaceType interfaceType, CacheEntry entry, out GrainType result)
+        {
+            if (!entry.PrimaryImplementation.IsDefault)
+            {
+                result = entry.PrimaryImplementation;
+            }
+            else if (entry.Implementations.Count == 1)
+            {
+                result = entry.Implementations[0].GrainType;
+            }
+            else if (entry.Implementations.Count > 1)
+            {
+                var candidates = string.Join(", ", entry.Implementations.Select(i => $"{i.GrainType} ({i.Prefix})"));
+                throw new ArgumentException($"Unable to identify a single appropriate grain type for interface {interfaceType}. Candidates: {candidates}");
+            }
+            else
+            {
+                // No implementations
+                result = default;
+            }
+
+            return !result.IsDefault;
+        }
+
         /// <summary>
         /// Returns the cache, rebuilding it if it is out of date.
         /// </summary>

src/Orleans.Core/Core/InterfaceToImplementationMappingCache.cs

@@ -28,7 +28,7 @@ public Entry(MethodInfo implementationMethod, MethodInfo interfaceMethod)
             }
 
             /// <summary>
-            /// Gets the grain implmentation <see cref="MethodInfo"/>.
+            /// Gets the grain implementation <see cref="MethodInfo"/>.
             /// </summary>
             public MethodInfo ImplementationMethod { get; }