Set up options and track changes in management SDK.

build/dependencies.props

@@ -46,6 +46,7 @@
     <MicrosoftConfigurationUserSecretVersion>2.2.0</MicrosoftConfigurationUserSecretVersion>
     <MicrosoftConfigurationEnvironmentVariablesVersion>2.2.0</MicrosoftConfigurationEnvironmentVariablesVersion>
     <MicrosoftAspNetCoreSignalRProtocolsMessagePackPackageVersion>1.0.11</MicrosoftAspNetCoreSignalRProtocolsMessagePackPackageVersion>
+    <MicrosoftExtensionsOptionsConfigurationExtensionsVersion>2.1.0</MicrosoftExtensionsOptionsConfigurationExtensionsVersion>
 
     <!-- Signing -->
     <MicroBuildCorePackageVersion>0.3.0</MicroBuildCorePackageVersion>

src/Microsoft.Azure.SignalR.Common/Constants.cs

@@ -9,6 +9,7 @@ internal static class Constants
     {
         public static class Keys
         {
+            public const string AzureSignalRSectionKey = "Azure:SignalR";
             public const string ServerStickyModeDefaultKey = "Azure:SignalR:ServerStickyMode";
             public const string ConnectionStringDefaultKey = "Azure:SignalR:ConnectionString";
             public const string ApplicationNameDefaultKey = "Azure:SignalR:ApplicationName";
@@ -85,4 +86,4 @@ public static class Protocol
             public const string BlazorPack = "blazorpack";
         }
     }
-}
+}

src/Microsoft.Azure.SignalR.Management/Configuration/CascadeOptionsSetup.cs

@@ -0,0 +1,49 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Threading;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Azure.SignalR.Management.Configuration
+{
+    /// <summary>
+    /// Sets up TargetOptions from SourceOptions and tracks changes .
+    /// </summary>
+    internal abstract class CascadeOptionsSetup<TargetOptions, SourceOptions> : IConfigureOptions<TargetOptions>, IOptionsChangeTokenSource<TargetOptions>, IDisposable
+        where SourceOptions : class
+        where TargetOptions : class
+    {
+        private readonly IDisposable _registration;
+        private readonly IOptionsMonitor<SourceOptions> _sourceMonitor;
+        private ConfigurationReloadToken _changeToken;
+
+        public CascadeOptionsSetup(IOptionsMonitor<SourceOptions> sourceMonitor)
+        {
+            _registration = sourceMonitor.OnChange(RaiseChange);
+            _changeToken = new ConfigurationReloadToken();
+            _sourceMonitor = sourceMonitor;
+        }
+
+        public string Name => Options.DefaultName;
+
+        public void Configure(TargetOptions target) => Convert(target, _sourceMonitor.CurrentValue);
+
+        protected abstract void Convert(TargetOptions target, SourceOptions source);
+
+        public IChangeToken GetChangeToken() => _changeToken;
+
+        private void RaiseChange(SourceOptions sourceOptions)
+        {
+            var previousToken = Interlocked.Exchange(ref _changeToken, new ConfigurationReloadToken());
+            previousToken.OnReload();
+        }
+
+        public void Dispose()
+        {
+            _registration.Dispose();
+        }
+    }
+}

src/Microsoft.Azure.SignalR.Management/ServiceManagerContext.cs → src/Microsoft.Azure.SignalR.Management/Configuration/ServiceManagerContext.cs

@@ -19,15 +19,6 @@ internal class ServiceManagerContext
 
         public ServiceTransportType ServiceTransportType { get; set; } = ServiceTransportType.Transient;
 
-        public void SetValueFromOptions(ServiceManagerOptions options)
-        {
-            ServiceEndpoints = options.ServiceEndpoints ?? (options.ServiceEndpoint != null
-                    ? (new ServiceEndpoint[] { options.ServiceEndpoint })
-                    : (new ServiceEndpoint[] { new ServiceEndpoint(options.ConnectionString) }));
-            ApplicationName = options.ApplicationName;
-            ConnectionCount = options.ConnectionCount;
-            Proxy = options.Proxy;
-            ServiceTransportType = options.ServiceTransportType;
-        }
+        public bool DisposeServiceProvider { get; set; } = false;
     }
-}
+}

src/Microsoft.Azure.SignalR.Management/Configuration/ServiceManagerContextSetup.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Azure.SignalR.Management.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Azure.SignalR.Management
+{
+    internal class ServiceManagerContextSetup : CascadeOptionsSetup<ServiceManagerContext, ServiceManagerOptions>
+    {
+        public ServiceManagerContextSetup(IOptionsMonitor<ServiceManagerOptions> sourceMonitor) : base(sourceMonitor)
+        {
+        }
+
+        protected override void Convert(ServiceManagerContext target, ServiceManagerOptions source)
+        {
+            target.ServiceEndpoints = source.ServiceEndpoints ?? (source.ServiceEndpoint != null
+                    ? (new ServiceEndpoint[] { source.ServiceEndpoint })
+                    : (new ServiceEndpoint[] { new ServiceEndpoint(source.ConnectionString) }));
+            target.ApplicationName = source.ApplicationName;
+            target.ConnectionCount = source.ConnectionCount;
+            target.Proxy = source.Proxy;
+            target.ServiceTransportType = source.ServiceTransportType;
+        }
+    }
+}

src/Microsoft.Azure.SignalR.Management/Configuration/ServiceManagerOptionsSetup.cs

@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.FileProviders;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Primitives;
+
+namespace Microsoft.Azure.SignalR.Management.Configuration
+{
+    internal class ServiceManagerOptionsSetup : IConfigureOptions<ServiceManagerOptions>, IOptionsChangeTokenSource<ServiceManagerOptions>
+    {
+        private readonly IConfiguration _configuration;
+
+        public ServiceManagerOptionsSetup(IConfiguration configuration = null)
+        {
+            _configuration = configuration;
+        }
+
+        public string Name => Options.DefaultName;
+
+        public void Configure(ServiceManagerOptions options)
+        {
+            if (_configuration != null)
+            {
+                _configuration.GetSection(Constants.Keys.AzureSignalRSectionKey).Bind(options);
+            }
+        }
+
+        public IChangeToken GetChangeToken()
+        {
+            return _configuration?.GetReloadToken() ?? NullChangeToken.Singleton;
+        }
+    }
+}

src/Microsoft.Azure.SignalR.Management/Configuration/ServiceOptionsSetup.cs

@@ -0,0 +1,23 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using Microsoft.Azure.SignalR.Management.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Azure.SignalR.Management
+{
+    internal class ServiceOptionsSetup : CascadeOptionsSetup<ServiceOptions, ServiceManagerContext>
+    {
+        public ServiceOptionsSetup(IOptionsMonitor<ServiceManagerContext> sourceMonitor) : base(sourceMonitor)
+        {
+        }
+
+        protected override void Convert(ServiceOptions target, ServiceManagerContext source)
+        {
+            target.ApplicationName = source.ApplicationName;
+            target.Endpoints = source.ServiceEndpoints;
+            target.Proxy = source.Proxy;
+            target.ConnectionCount = source.ConnectionCount;
+        }
+    }
+}

src/Microsoft.Azure.SignalR.Management/DependencyInjectionExtensions.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+using System;
+using System.ComponentModel;
+using System.Reflection;
+using Microsoft.Azure.SignalR.Management.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+
+namespace Microsoft.Azure.SignalR.Management
+{
+    internal static class DependencyInjectionExtensions //TODO: not ready for public use
+    {
+        /// <summary>
+        /// Adds the essential SignalR Service Manager services to the specified services collection and configures <see cref="ServiceManagerOptions"/> with configuration instance registered in service collection.
+        /// </summary>
+        public static IServiceCollection AddSignalRServiceManager(this IServiceCollection services)
+        {
+            services.AddSingleton<ServiceManagerOptionsSetup>()
+                    .AddSingleton<IConfigureOptions<ServiceManagerOptions>>(sp => sp.GetService<ServiceManagerOptionsSetup>())
+                    .AddSingleton<IOptionsChangeTokenSource<ServiceManagerOptions>>(sp => sp.GetService<ServiceManagerOptionsSetup>());
+            services.PostConfigure<ServiceManagerOptions>(o => o.ValidateOptions());
+            services.AddSingleton<ServiceManagerContextSetup>()
+                    .AddSingleton<IConfigureOptions<ServiceManagerContext>>(sp => sp.GetService<ServiceManagerContextSetup>())
+                    .AddSingleton<IOptionsChangeTokenSource<ServiceManagerContext>>(sp => sp.GetService<ServiceManagerContextSetup>());
+            services.AddSingleton<ServiceOptionsSetup>()
+                    .AddSingleton<IConfigureOptions<ServiceOptions>>(sp => sp.GetService<ServiceOptionsSetup>())
+                    .AddSingleton<IOptionsChangeTokenSource<ServiceOptions>>(sp => sp.GetService<ServiceOptionsSetup>());
+            return services.TrySetProductInfo();
+        }
+
+        /// <summary>
+        /// Adds the essential SignalR Service Manager services to the specified services collection and registers an action used to configure <see cref="ServiceManagerOptions"/>
+        /// </summary>
+        public static IServiceCollection AddSignalRServiceManager(this IServiceCollection services, Action<ServiceManagerOptions> configure)
+        {
+            services.Configure(configure);
+            return services.AddSignalRServiceManager();
+        }
+
+        /// <summary>
+        /// Adds product info to <see cref="ServiceManagerContext"/>
+        /// </summary>
+        /// <returns></returns>
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public static IServiceCollection WithAssembly(this IServiceCollection services, Assembly assembly)
+        {
+            var productInfo = ProductInfo.GetProductInfo(assembly);
+            return services.Configure<ServiceManagerContext>(o => o.ProductInfo = productInfo);
+        }
+
+        private static IServiceCollection TrySetProductInfo(this IServiceCollection services)
+        {
+            var assembly = Assembly.GetExecutingAssembly();
+            var productInfo = ProductInfo.GetProductInfo(assembly);
+            return services.Configure<ServiceManagerContext>(o => o.ProductInfo = o.ProductInfo ?? productInfo);
+        }
+    }
+}

src/Microsoft.Azure.SignalR.Management/IServiceManager.cs

@@ -13,7 +13,7 @@ namespace Microsoft.Azure.SignalR.Management
     /// <summary>
     /// A manager abstraction for managing Azure SignalR Service.
     /// </summary>
-    public interface IServiceManager
+    public interface IServiceManager : IDisposable
     {
         /// <summary>
         /// Creates an instance of <see cref="IServiceHubContext"/> asynchronously.

src/Microsoft.Azure.SignalR.Management/Microsoft.Azure.SignalR.Management.csproj

@@ -32,7 +32,8 @@
   </ItemGroup>
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="$(MicrosoftExtensionsDependencyInjectionPackageVersion)" />
-	<PackageReference Include="Microsoft.Extensions.Http" Version="$(MicrosoftExtensionHttpVersion)" />
+    <PackageReference Include="Microsoft.Extensions.Http" Version="$(MicrosoftExtensionHttpVersion)" />
     <PackageReference Include="Microsoft.AspNetCore.SignalR" Version="$(MicrosoftAspNetCoreSignalRPackageVersion)" />
+    <PackageReference Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="$(MicrosoftExtensionsOptionsConfigurationExtensionsVersion)" />
   </ItemGroup>
 </Project>

src/Microsoft.Azure.SignalR.Management/ServiceManager.cs

@@ -28,8 +28,9 @@ internal class ServiceManager : IServiceManager
         private readonly string _productInfo;
         private readonly ServiceManagerContext _context;
         private readonly RestClientFactory _restClientFactory;
+        private readonly IServiceProvider _serviceProvider;
 
-        internal ServiceManager(ServiceManagerContext context, RestClientFactory restClientFactory)
+        internal ServiceManager(ServiceManagerContext context, RestClientFactory restClientFactory, IServiceProvider serviceProvider)
         {
             _endpoint = context.ServiceEndpoints.Single();//temp solution
 
@@ -46,6 +47,7 @@ internal ServiceManager(ServiceManagerContext context, RestClientFactory restCli
             _productInfo = context.ProductInfo;
             _context = context;
             _restClientFactory = restClientFactory;
+            _serviceProvider = serviceProvider;
         }
 
         public async Task<IServiceHubContext> CreateHubContextAsync(string hubName, ILoggerFactory loggerFactory = null, CancellationToken cancellationToken = default)
@@ -141,6 +143,14 @@ public async Task<IServiceHubContext> CreateHubContextAsync(string hubName, ILog
             }
         }
 
+        public void Dispose()
+        {
+            if (_context.DisposeServiceProvider)
+            {
+                (_serviceProvider as IDisposable).Dispose();
+            }
+        }
+
         public string GenerateClientAccessToken(string hubName, string userId = null, IList<Claim> claims = null, TimeSpan? lifeTime = null)
         {
             var claimsWithUserId = new List<Claim>();

src/Microsoft.Azure.SignalR.Management/ServiceManagerBuilder.cs

@@ -4,6 +4,9 @@
 using System;
 using System.ComponentModel;
 using System.Reflection;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.Azure.SignalR.Management
 {
@@ -12,24 +15,36 @@ namespace Microsoft.Azure.SignalR.Management
     /// </summary>
     public class ServiceManagerBuilder : IServiceManagerBuilder
     {
-        private readonly ServiceManagerOptions _options = new ServiceManagerOptions();
+        private readonly IServiceCollection _services = new ServiceCollection();
         private Assembly _assembly;
 
         /// <summary>
-        /// Configures the <see cref="IServiceManager"/> instances.
+        /// Registers an action used to configure <see cref="IServiceManager"/>.
         /// </summary>
         /// <param name="configure">A callback to configure the <see cref="IServiceManager"/>.</param>
         /// <returns>The same instance of the <see cref="ServiceManagerBuilder"/> for chaining.</returns>
         public ServiceManagerBuilder WithOptions(Action<ServiceManagerOptions> configure)
         {
-            configure?.Invoke(_options);
+            _services.Configure(configure);
+            return this;
+        }
+
+        /// <summary>
+        /// Registers a configuration instance to configure <see cref="IServiceManager"/>
+        /// </summary>
+        /// <param name="config">The configuration instance.</param>
+        /// <returns>The same instance of the <see cref="ServiceManagerBuilder"/> for chaining.</returns>
+        internal ServiceManagerBuilder WithConfiguration(IConfiguration config)
+        {
+            _services.AddSingleton(config);
             return this;
         }
 
         [EditorBrowsable(EditorBrowsableState.Never)]
         public ServiceManagerBuilder WithCallingAssembly()
         {
             _assembly = Assembly.GetCallingAssembly();
+            _services.WithAssembly(_assembly);
             return this;
         }
 
@@ -39,16 +54,13 @@ public ServiceManagerBuilder WithCallingAssembly()
         /// <returns>The instance of the <see cref="IServiceManager"/>.</returns>
         public IServiceManager Build()
         {
-            _options.ValidateOptions();
-
+            _services.AddSignalRServiceManager();
+            _services.Configure<ServiceManagerContext>(c => c.DisposeServiceProvider = true);
+            var serviceProvider = _services.BuildServiceProvider();
+            var context = serviceProvider.GetRequiredService<IOptions<ServiceManagerContext>>().Value;
             var productInfo = ProductInfo.GetProductInfo(_assembly);
-            var context = new ServiceManagerContext()
-            {
-                ProductInfo = productInfo
-            };
-            context.SetValueFromOptions(_options);
             var restClientBuilder = new RestClientFactory(productInfo);
-            return new ServiceManager(context, restClientBuilder);
+            return new ServiceManager(context, restClientBuilder, serviceProvider);
         }
     }
 }