#2459: Grain Services by @jamescarter-le (#2531)

* Implement Grain Services which are a partitioned SystemTarget service.

Can invoke a Grain Service with a test.


Added Grain Service Configuration

Tests reporting:
Exception thrown: 'Orleans.CodeGenerator.CodeGenerationException' in OrleansCodeGenerator.dll

Additional information: (1,18913): error CS0122: 'ITestHooksSystemTarget' is inaccessible due to its protection level
Resolved GrainService GrainId, InsideRuntimeClient using ReminderRegistr


SystemTarget public, GrainServiceClient used

SystemTarget is now public, removed GrainService analog, now contains just GrainService logic
GrainServiceClient is used to locate the IReminderService
Cannot capture the correct Reminder GrainId (GrainClassData not available)?
SystemTarget public, GrainServiceClient used

Initial stab at implementing a partitioned system service.

From @sergeybykov comments, attempted the below:
---
I see at least two potential ways, likely complementary, to expose such functionality to application code.

1) Partitioned system service. Essentially a generalized version of the Reminder service, but with an application system target class instead of LocalReminderService, e.g. GrainService, and a corresponding equivalent to ReminderRegistry proxy class, e.g. GrainServiceClient. We only create a single LocalReminderService system target per silo today, but it shouldn't be too difficult to make that number configurable. In this approach, callers are completely oblivious to partitioning and routing, and it's the responsibility of the GrainService to react to repartitioning events and changes to the ring range it owns.

* Added an explicit method NewGrainServiceKey to UniqueKey instead of reusing the more general NewKey directly.

* Added type name to log statements and as the logger name.

* Reverted RegisterSystemTarget back to internal.

* Eliminated a warning about deprecated Consul method.

* Added XML commenst and tweaked a few methods to eliminate build warnings.

* Tweaks to make code .NET Core compatible.

* Support dependency injection in GrainServices (#6)

Author: sergeybykov

src/Orleans/Configuration/GlobalConfiguration.cs

@@ -412,6 +412,11 @@ internal void SetReminderServiceType(ReminderServiceProviderType reminderType)
         /// </summary>
         public IDictionary<string, ProviderCategoryConfiguration> ProviderConfigurations { get; set; }
 
+        /// <summary>
+        /// Configuration for grain services.
+        /// </summary>
+        public GrainServiceConfigurations GrainServiceConfigurations { get; set; }
+
         /// <summary>
         /// The time span between when we have added an entry for an activation to the grain directory and when we are allowed
         /// to conditionally remove that entry. 
@@ -568,6 +573,7 @@ internal GlobalConfiguration()
             MockReminderTableTimeout = DEFAULT_MOCK_REMINDER_TABLE_TIMEOUT;
 
             ProviderConfigurations = new Dictionary<string, ProviderCategoryConfiguration>();
+            GrainServiceConfigurations = new GrainServiceConfigurations();
         }
 
         public override string ToString()
@@ -976,6 +982,11 @@ internal override void Load(XmlElement root)
                         break;
 
                     default:
+                        if (child.LocalName.Equals("GrainServices", StringComparison.Ordinal))
+                        {
+                            GrainServiceConfigurations = GrainServiceConfigurations.Load(child);
+                        }
+
                         if (child.LocalName.EndsWith("Providers", StringComparison.Ordinal))
                         {
                             var providerCategory = ProviderCategoryConfiguration.Load(child);
@@ -1101,6 +1112,11 @@ public bool TryGetProviderConfiguration(string providerTypeFullName, string prov
         public IEnumerable<IProviderConfiguration> GetAllProviderConfigurations()
         {
             return ProviderConfigurationUtility.GetAllProviderConfigurations(ProviderConfigurations);
-        } 
+        }
+
+        public void RegisterGrainService(string serviceName, string clientType, string serviceType, IDictionary<string, string> properties = null)
+        {
+            GrainServiceConfigurationsUtility.RegisterGrainService(GrainServiceConfigurations, serviceName, clientType, serviceType, properties);
+        }
     }
 }

src/Orleans/Configuration/GrainServiceConfiguration.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Xml;
+
+namespace Orleans.Runtime.Configuration
+{
+    [Serializable]
+    public class GrainServiceConfigurations
+    {
+        public IDictionary<string, IGrainServiceConfiguration> GrainServices { get; set; }
+
+        public GrainServiceConfigurations()
+        {
+            GrainServices = new Dictionary<string, IGrainServiceConfiguration>();
+        }
+
+        internal static GrainServiceConfigurations Load(XmlElement child)
+        {
+            var container = new GrainServiceConfigurations();
+
+            var nsManager = new XmlNamespaceManager(new NameTable());
+            nsManager.AddNamespace("orleans", "urn:orleans");
+
+            GrainServiceConfiguration.LoadProviderConfigurations(
+                child, nsManager, container.GrainServices,
+                c => container.GrainServices.Add(c.Name, c));
+
+            return container;
+        }
+    }
+
+    internal static class GrainServiceConfigurationsUtility
+    {
+        internal static void RegisterGrainService(GrainServiceConfigurations grainServicesConfig, string serviceName, string clientType, string serviceType, IDictionary<string, string> properties = null)
+        {
+            if (grainServicesConfig.GrainServices.ContainsKey(serviceName))
+                throw new InvalidOperationException(
+                    string.Format("Grain service of with name '{0}' has been already registered", serviceName));
+
+            var config = new GrainServiceConfiguration(
+                properties ?? new Dictionary<string, string>(),
+                serviceName, clientType, serviceType);
+
+            grainServicesConfig.GrainServices.Add(config.Name, config);
+        }
+    }
+
+    public interface IGrainServiceConfiguration
+    {
+        string Name { get; set; }
+        string ClientType { get; set; }
+        string ServiceType { get; set; }
+    }
+
+    [Serializable]
+    public class GrainServiceConfiguration : IGrainServiceConfiguration
+    {
+        private IDictionary<string, string> properties;
+
+        public string Name { get; set; }
+        public string ClientType { get; set; }
+        public string ServiceType { get; set; }
+
+        public GrainServiceConfiguration() {}
+
+        public GrainServiceConfiguration(IDictionary<string, string> properties, string serviceName, string clientType, string serviceType)
+        {
+            this.properties = properties;
+            Name = serviceName;
+            ClientType = clientType;
+            ServiceType = serviceType;
+        }
+
+        internal void Load(XmlElement child, IDictionary<string, IGrainServiceConfiguration> alreadyLoaded, XmlNamespaceManager nsManager)
+        {
+            if (nsManager == null)
+            {
+                nsManager = new XmlNamespaceManager(new NameTable());
+                nsManager.AddNamespace("orleans", "urn:orleans");
+            }
+
+            if (child.HasAttribute("Name"))
+            {
+                Name = child.GetAttribute("Name");
+            }
+
+            if (alreadyLoaded != null && alreadyLoaded.ContainsKey(Name))
+            {
+                return;
+            }
+
+            if (child.HasAttribute("ClientType"))
+            {
+                ClientType = child.GetAttribute("ClientType");
+            }
+            else
+            {
+                throw new FormatException("Missing 'ClientType' attribute on 'GrainService' element");
+            }
+
+            if (child.HasAttribute("ServiceType"))
+            {
+                ServiceType = child.GetAttribute("ServiceType");
+            }
+            else
+            {
+                throw new FormatException("Missing 'ServiceType' attribute on 'GrainService' element");
+            }
+
+            if (String.IsNullOrEmpty(Name))
+            {
+                Name = ServiceType;
+            }
+
+            properties = new Dictionary<string, string>();
+            for (int i = 0; i < child.Attributes.Count; i++)
+            {
+                var key = child.Attributes[i].LocalName;
+                var val = child.Attributes[i].Value;
+                if ((key != "Type") && (key != "Name"))
+                {
+                    properties[key] = val;
+                }
+            }
+        }
+        
+        internal static void LoadProviderConfigurations(XmlElement root, XmlNamespaceManager nsManager,
+            IDictionary<string, IGrainServiceConfiguration> alreadyLoaded, Action<IGrainServiceConfiguration> add)
+        {
+            var nodes = root.SelectNodes("orleans:GrainService", nsManager);
+            foreach (var node in nodes)
+            {
+                var subElement = node as XmlElement;
+                if (subElement == null) continue;
+
+                var config = new GrainServiceConfiguration();
+                config.Load(subElement, alreadyLoaded, nsManager);
+                add(config);
+            }
+        }
+    }
+}

src/Orleans/IDs/GrainId.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
 using Orleans.Core;
 using Orleans.Serialization;
 
@@ -90,6 +92,11 @@ internal static GrainId GetGrainId(long typeCode, string primaryKey)
                 typeCode, primaryKey));
         }
 
+        internal static GrainId GetGrainServiceGrainId(short id, int typeData)
+        {
+            return FindOrCreateGrainId(UniqueKey.NewGrainServiceKey(id, typeData));
+        }
+
         public Guid PrimaryKey
         {
             get { return GetPrimaryKey(); }

src/Orleans/IDs/UniqueKey.cs

@@ -161,6 +161,12 @@ public static UniqueKey NewSystemTargetKey(short systemId)
             return NewKey(0, n1, Category.SystemTarget, 0, null);
         }
 
+        public static UniqueKey NewGrainServiceKey(short key, long typeData)
+        {
+            ulong n1 = unchecked((ulong)key);
+            return NewKey(0, n1, Category.SystemTarget, typeData, null);
+        }
+
         internal static UniqueKey NewKey(ulong n0, ulong n1, ulong typeCodeData, string keyExt)
         {
             ValidateKeyExt(keyExt, typeCodeData);

src/Orleans/Orleans.csproj

@@ -78,6 +78,7 @@
     <Compile Include="Async\UnobservedExceptionsHandlerClass.cs" />
     <Compile Include="Async\TaskExtensions.cs" />
     <Compile Include="CodeGeneration\GeneratedAssembly.cs" />
+    <Compile Include="Configuration\GrainServiceConfiguration.cs" />
     <Compile Include="Core\GrainCasterFactory.cs" />
     <Compile Include="Core\IInternalGrainFactory.cs" />
     <Compile Include="Logging\LoggerExtensions.cs" />
@@ -144,6 +145,8 @@
     <Compile Include="Serialization\ILDelegateBuilder.cs" />
     <Compile Include="Serialization\OrleansJsonSerializer.cs" />
     <Compile Include="Serialization\BinaryFormatterSerializer.cs" />
+    <Compile Include="Services\IGrainServiceClient.cs" />
+    <Compile Include="Services\IGrainService.cs" />
     <Compile Include="Utils\ReferenceEqualsComparer.cs" />
     <Compile Include="Serialization\ReflectedSerializationMethodInfo.cs" />
     <Compile Include="Serialization\SerializationTestEnvironment.cs" />
@@ -259,7 +262,6 @@
     <Compile Include="Streams\Core\StreamSequenceToken.cs" />
     <Compile Include="Streams\Core\StreamSubscriptionHandle.cs" />
     <Compile Include="Timers\AsyncTaskSafeTimer.cs" />
-    <Compile Include="Timers\ReminderRegistry.cs" />
     <Compile Include="Timers\TimerRegistry.cs" />
     <Compile Include="Utils\SetExtensions.cs" />
     <Compile Include="Placement\ActivationCountBasedPlacement.cs" />

src/Orleans/Runtime/Constants.cs

@@ -34,7 +34,6 @@ internal class Constants
         public static readonly GrainId ClientObserverRegistrarId = GrainId.GetSystemTargetGrainId(13);
         public static readonly GrainId CatalogId = GrainId.GetSystemTargetGrainId(14);
         public static readonly GrainId MembershipOracleId = GrainId.GetSystemTargetGrainId(15);
-        public static readonly GrainId ReminderServiceId = GrainId.GetSystemTargetGrainId(16);
         public static readonly GrainId TypeManagerId = GrainId.GetSystemTargetGrainId(17);
         public static readonly GrainId ProviderManagerSystemTargetId = GrainId.GetSystemTargetGrainId(19);
         public static readonly GrainId DeploymentLoadPublisherSystemTargetId = GrainId.GetSystemTargetGrainId(22);
@@ -82,7 +81,6 @@ internal class Constants
             {CatalogId,"Catalog"},
             {MembershipOracleId,"MembershipOracle"},
             {MultiClusterOracleId,"MultiClusterOracle"},
-            {ReminderServiceId,"ReminderService"},
             {TypeManagerId,"TypeManagerId"},
             {ProviderManagerSystemTargetId, "ProviderManagerSystemTarget"},
             {DeploymentLoadPublisherSystemTargetId, "DeploymentLoadPublisherSystemTarget"},

src/Orleans/Services/IGrainService.cs

@@ -0,0 +1,6 @@
+namespace Orleans.Services
+{
+    public interface IGrainService : ISystemTarget
+    {
+    }
+}

src/Orleans/Services/IGrainServiceClient.cs

@@ -0,0 +1,6 @@
+namespace Orleans.Services
+{
+    public interface IGrainServiceClient<TGrainService> where TGrainService : IGrainService
+    {
+    }
+}

src/Orleans/SystemTargetInterfaces/IReminderService.cs

@@ -2,11 +2,11 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using Orleans.Runtime;
-
+using Orleans.Services;
 
 namespace Orleans
 {
-    internal interface IReminderService : ISystemTarget
+    public interface IReminderService : IGrainService
     {
         Task Start();
         Task Stop();

src/Orleans/SystemTargetInterfaces/ISystemTarget.cs

@@ -10,7 +10,7 @@ namespace Orleans
     /// Proxy class is being generated for ISystemTarget, just like for IGrain
     /// System target are scheduled by the runtime scheduler and follow turn based concurrency.
     /// </summary> 
-    internal interface ISystemTarget : IAddressable
+    public interface ISystemTarget : IAddressable
     {
     }