Reduce use of statics in SiloProviderRuntime

src/Orleans/Providers/ClientProviderRuntime.cs

@@ -139,7 +139,7 @@ public async Task<Tuple<TExtension, TExtensionInterface>> BindExtension<TExtensi
                     var obj = ((GrainFactory)this.GrainFactory).CreateObjectReference<TExtensionInterface>(extension);
 
                     addressable = obj;
-
+                     
                     if (null == addressable)
                     {
                         throw new NullReferenceException("addressable");
@@ -174,12 +174,5 @@ public IConsistentRingProviderForGrains GetConsistentRingProvider(int mySubRange
         {
             throw new NotImplementedException("GetConsistentRingProvider");
         }
-
-        public bool InSilo { get { return false; } }
-
-        public object GetCurrentSchedulingContext()
-        {
-            return null;
-        }
     }
 }

src/Orleans/Streams/Providers/IStreamProviderRuntime.cs

@@ -14,12 +14,16 @@ internal interface IStreamProviderRuntime : IProviderRuntime
     {
         /// <summary>
         /// Retrieves the opaque identity of currently executing grain or client object. 
-        /// Just for logging purposes.
         /// </summary>
+        /// <remarks>Exposed for logging purposes.</remarks>
         string ExecutingEntityIdentity();
 
         SiloAddress ExecutingSiloAddress { get; }
 
+        /// <summary>
+        /// Returns the stream directory.
+        /// </summary>
+        /// <returns>The stream directory.</returns>
         StreamDirectory GetStreamDirectory();
 
         void RegisterSystemTarget(ISystemTarget target);
@@ -48,11 +52,6 @@ Task<Tuple<TExtension, TExtensionInterface>> BindExtension<TExtension, TExtensio
         /// <param name="numSubRanges">Total number of sub ranges within this silo range.</param>
         /// <returns></returns>
         IConsistentRingProviderForGrains GetConsistentRingProvider(int mySubRangeIndex, int numSubRanges);
-
-        /// <summary>Return true if this runtime executes inside silo, false otherwise (on the client).</summary>
-        bool InSilo { get; }
-
-        object GetCurrentSchedulingContext();
     }
 
         /// <summary>

src/Orleans/Streams/PubSub/ImplicitStreamSubscriberTable.cs

@@ -11,7 +11,7 @@ internal class ImplicitStreamSubscriberTable
     {
         private readonly Dictionary<string, HashSet<int>> table;
 
-        internal ImplicitStreamSubscriberTable()
+        public ImplicitStreamSubscriberTable()
         {
             table = new Dictionary<string, HashSet<int>>();
         }

src/OrleansRuntime/Cancellation/CancellationSourcesExtension.cs

@@ -45,7 +45,12 @@ public Task CancelRemoteToken(GrainCancellationToken token)
         /// <param name="target"></param>
         /// <param name="request"></param>
         /// <param name="logger"></param>
-        internal static void RegisterCancellationTokens(IAddressable target, InvokeMethodRequest request, Logger logger)
+        /// <param name="siloRuntimeClient"></param>
+        internal static void RegisterCancellationTokens(
+            IAddressable target,
+            InvokeMethodRequest request,
+            Logger logger,
+            ISiloRuntimeClient siloRuntimeClient)
         {
             for (var i = 0; i < request.Arguments.Length; i++)
             {
@@ -54,10 +59,10 @@ internal static void RegisterCancellationTokens(IAddressable target, InvokeMetho
                 var grainToken = ((GrainCancellationToken) request.Arguments[i]);
 
                 CancellationSourcesExtension cancellationExtension;
-                if (!SiloProviderRuntime.Instance.TryGetExtensionHandler(out cancellationExtension))
+                if (!siloRuntimeClient.TryGetExtensionHandler(out cancellationExtension))
                 {
                     cancellationExtension = new CancellationSourcesExtension();
-                    if (!SiloProviderRuntime.Instance.TryAddExtension(cancellationExtension))
+                    if (!siloRuntimeClient.TryAddExtension(cancellationExtension))
                     {
                         logger.Error(
                             ErrorCode.CancellationExtensionCreationFailed,

src/OrleansRuntime/Catalog/GrainCreator.cs

@@ -30,14 +30,7 @@ public GrainCreator(IServiceProvider services, Func<IGrainRuntime> getGrainRunti
         {
             this.services = services;
             this.grainRuntime = new Lazy<IGrainRuntime>(getGrainRuntime);
-            if (services != null)
-            {
-                this.createFactory = type => ActivatorUtilities.CreateFactory(type, Type.EmptyTypes);
-            }
-            else
-            {
-                this.createFactory = type => (sp, args) => Activator.CreateInstance(type);
-            }
+            this.createFactory = type => ActivatorUtilities.CreateFactory(type, Type.EmptyTypes);
         }
 
         /// <summary>

src/OrleansRuntime/Core/BootstrapProviderManager.cs

@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using Orleans.Providers;
 using Orleans.Runtime.Configuration;
-using Orleans.Runtime.Providers;
 
 namespace Orleans.Runtime
 {
@@ -29,9 +28,10 @@ public IList<IBootstrapProvider> GetProviders()
 
         // Explicitly typed, for backward compat
         public async Task LoadAppBootstrapProviders(
+            IProviderRuntime providerRuntime,
             IDictionary<string, ProviderCategoryConfiguration> configs)
         {
-            await pluginManager.LoadAndInitPluginProviders(configCategoryName, configs);
+            await pluginManager.LoadAndInitPluginProviders(providerRuntime, configCategoryName, configs);
         }
 
 
@@ -57,7 +57,7 @@ internal PluginManager(Logger logger)
 
             public IProvider GetProvider(string name)
             {
-                return providerLoader != null ? providerLoader.GetProvider(name) : null;
+                return providerLoader?.GetProvider(name);
             }
 
             public IList<T> GetProviders()
@@ -66,7 +66,9 @@ public IList<T> GetProviders()
             }
 
             internal async Task LoadAndInitPluginProviders(
-                string configCategoryName, IDictionary<string, ProviderCategoryConfiguration> configs)
+                IProviderRuntime providerRuntime,
+                string configCategoryName,
+                IDictionary<string, ProviderCategoryConfiguration> configs)
             {
                 ProviderCategoryConfiguration categoryConfig;
                 if (!configs.TryGetValue(configCategoryName, out categoryConfig)) return;
@@ -76,7 +78,7 @@ internal async Task LoadAndInitPluginProviders(
                 logger.Info(ErrorCode.SiloCallingProviderInit, "Calling Init for {0} classes", typeof(T).Name);
 
                 // Await here to force any errors to show this method name in stack trace, for better diagnostics
-                await providerLoader.InitProviders(SiloProviderRuntime.Instance);
+                await providerLoader.InitProviders(providerRuntime);
             }
         }
     }

src/OrleansRuntime/Core/Dispatcher.cs

@@ -579,7 +579,7 @@ private async Task AddressMessage(Message message)
             // message.
             var strategy = targetAddress.Grain.IsGrain ? catalog.GetGrainPlacementStrategy(targetAddress.Grain) : null;
             var placementResult = await this.placementDirectorsManager.SelectOrAddActivation(
-                message.SendingAddress, message.TargetGrain, InsideRuntimeClient.Current.Catalog, strategy);
+                message.SendingAddress, message.TargetGrain, this.catalog, strategy);
 
             if (placementResult.IsNewPlacement && targetAddress.Grain.IsClient)
             {

src/OrleansRuntime/Core/ISiloRuntimeClient.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Threading.Tasks;
+using Orleans.Streams;
+
+namespace Orleans.Runtime
+{
+    /// <summary>
+    /// Runtime client methods accessible on silos.
+    /// </summary>
+    internal interface ISiloRuntimeClient : IRuntimeClient
+    {
+        /// <summary>
+        /// Gets the stream directory.
+        /// </summary>
+        /// <returns>The stream directory.</returns>
+        StreamDirectory GetStreamDirectory();
+
+        /// <summary>
+        /// Retrieves the opaque identity of currently executing grain or client object. 
+        /// </summary>
+        /// <remarks>Exposed for logging purposes.</remarks>
+        string ExecutingEntityIdentity();
+
+        /// <summary>
+        /// Attempts to add the provided extension handler to the currently executing grain.
+        /// </summary>
+        /// <param name="handler">The extension handler.</param>
+        /// <returns><see langword="true"/> if the operation succeeded; <see langword="false" /> otherwise.</returns>
+        bool TryAddExtension(IGrainExtension handler);
+
+        /// <summary>
+        /// Attempts to retrieve the specified extension type from the currently executing grain.
+        /// </summary>
+        /// <typeparam name="TExtension">The type of the extension.</typeparam>
+        /// <param name="result">The extension, or <see langword="null" /> if it was not available.</param>
+        /// <returns><see langword="true"/> if the operation succeeded; <see langword="false" /> otherwise.</returns>
+        bool TryGetExtensionHandler<TExtension>(out TExtension result) where TExtension : IGrainExtension;
+
+        /// <summary>
+        /// Removes the provided extension handler from the currently executing grain.
+        /// </summary>
+        /// <param name="handler">The extension handler to remove.</param>
+        void RemoveExtension(IGrainExtension handler);
+
+        /// <summary>
+        /// Binds an extension to the currently executing grain if it does not already have an extension of the specified
+        /// <typeparamref name="TExtensionInterface"/>.
+        /// </summary>
+        /// <typeparam name="TExtension">The type of the extension (e.g. StreamConsumerExtension).</typeparam>
+        /// <typeparam name="TExtensionInterface">The public interface type of the implementation.</typeparam>
+        /// <param name="newExtensionFunc">A factory function that constructs a new extension object.</param>
+        /// <returns>A tuple, containing first the extension and second an addressable reference to the extension's interface.</returns>
+        Task<Tuple<TExtension, TExtensionInterface>> BindExtension<TExtension, TExtensionInterface>(Func<TExtension> newExtensionFunc)
+            where TExtension : IGrainExtension
+            where TExtensionInterface : IGrainExtension;
+    }
+}