Add ServiceConnectionMigrationLevel option

Azure · Nov 28, 2019 · 0a9a648 · 0a9a648
1 parent 506b832
commit 0a9a648
Show file tree

Hide file tree

Showing 20 changed files with 169 additions and 46 deletions.
diff --git a/src/Microsoft.Azure.SignalR.AspNet/ServerConnections/ServiceConnection.cs b/src/Microsoft.Azure.SignalR.AspNet/ServerConnections/ServiceConnection.cs
@@ -41,9 +41,15 @@ public ServiceConnection(
             IClientConnectionManager clientConnectionManager,
             ILoggerFactory loggerFactory,
             IServiceMessageHandler serviceMessageHandler,
-            ServerConnectionType connectionType = ServerConnectionType.Default)
-            : base(serviceProtocol, connectionId, endpoint, serviceMessageHandler, connectionType,
-                loggerFactory?.CreateLogger<ServiceConnection>())
+            ServiceConnectionOptions options = null
+        )
+            : base(
+                  serviceProtocol,
+                  connectionId,
+                  endpoint,
+                  serviceMessageHandler,
+                  options,
+                  loggerFactory?.CreateLogger<ServiceConnection>())
         {
             _connectionFactory = connectionFactory;
             _clientConnectionManager = clientConnectionManager;

diff --git a/src/Microsoft.Azure.SignalR.AspNet/ServerConnections/ServiceConnectionFactory.cs b/src/Microsoft.Azure.SignalR.AspNet/ServerConnections/ServiceConnectionFactory.cs
@@ -10,6 +10,7 @@ class ServiceConnectionFactory : IServiceConnectionFactory
         private readonly IClientConnectionManager _clientConnectionManager;
         private readonly IConnectionFactory _connectionFactory;
         private readonly ILoggerFactory _logger;
+        private readonly ServiceConnectionOptions _options = ServiceConnectionOptions.Default;
 
         public ServiceConnectionFactory(IServiceProtocol serviceProtocol,
             IClientConnectionManager clientConnectionManager,
@@ -22,9 +23,15 @@ public ServiceConnectionFactory(IServiceProtocol serviceProtocol,
             _logger = logger;
         }
 
-        public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServerConnectionType type)
+        public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type)
         {
-            return new ServiceConnection(Guid.NewGuid().ToString(), endpoint, _serviceProtocol, _connectionFactory, _clientConnectionManager, _logger, serviceMessageHandler, type);
+            ServiceConnectionOptions options = _options;
+            if (type != _options.ConnectionType)
+            {
+                options = _options.Clone();
+                options.ConnectionType = type;
+            }
+            return new ServiceConnection(Guid.NewGuid().ToString(), endpoint, _serviceProtocol, _connectionFactory, _clientConnectionManager, _logger, serviceMessageHandler, options);
         }
     }
 }
diff --git a/src/Microsoft.Azure.SignalR.Common/Interfaces/IServiceConnectionFactory.cs b/src/Microsoft.Azure.SignalR.Common/Interfaces/IServiceConnectionFactory.cs
@@ -2,6 +2,6 @@
 {
     interface IServiceConnectionFactory
     {
-        IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServerConnectionType type);
+        IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type);
     }
 }
diff --git a/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionBase.cs b/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionBase.cs
@@ -34,7 +34,9 @@ internal abstract class ServiceConnectionBase : IServiceConnection
         private readonly TaskCompletionSource<bool> _serviceConnectionStartTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
         private readonly TaskCompletionSource<object> _serviceConnectionOfflineTcs = new TaskCompletionSource<object>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        private readonly ServerConnectionType _connectionType;
+        protected readonly ServiceConnectionOptions Options;
+
+        private ServiceConnectionType _connectionType { get => Options.ConnectionType; }
 
         private readonly IServiceMessageHandler _serviceMessageHandler;
         private readonly object _statusLock = new object();
@@ -87,19 +89,26 @@ protected set
 
         public Task ConnectionOfflineTask => _serviceConnectionOfflineTcs.Task;
 
-        protected ServiceConnectionBase(IServiceProtocol serviceProtocol, string connectionId,
-            HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServerConnectionType connectionType, ILogger logger)
+        protected ServiceConnectionBase(
+            IServiceProtocol serviceProtocol,
+            string connectionId,
+            HubServiceEndpoint endpoint,
+            IServiceMessageHandler serviceMessageHandler,
+            ServiceConnectionOptions options,
+            ILogger logger
+        )
         {
             ServiceProtocol = serviceProtocol;
             ConnectionId = connectionId;
 
-            _connectionType = connectionType;
+            Options = options ?? ServiceConnectionOptions.Default;
+
             HubEndpoint = endpoint;
 
             if (serviceProtocol != null)
             {
                 _cachedPingBytes = serviceProtocol.GetMessageBytes(PingMessage.Instance);
-                _handshakeRequest = new HandshakeRequestMessage(serviceProtocol.Version, (int)connectionType);
+                _handshakeRequest = new HandshakeRequestMessage(serviceProtocol.Version, (int)options.ConnectionType);
             }
 
             Logger = logger ?? throw new ArgumentNullException(nameof(logger));
@@ -385,7 +394,7 @@ private async Task<bool> ReceiveHandshakeResponseAsync(PipeReader input, Cancell
                             }
 
                             // Handshake error. Will stop reconnect.
-                            if (_connectionType == ServerConnectionType.OnDemand)
+                            if (_connectionType == ServiceConnectionType.OnDemand)
                             {
                                 // Handshake errors on on-demand connections are acceptable.
                                 Log.OnDemandConnectionHandshakeResponse(Logger, handshakeResponse.ErrorMessage);

diff --git a/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionContainerBase.cs b/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionContainerBase.cs
@@ -51,7 +51,7 @@ protected List<IServiceConnection> FixedServiceConnections
 
         protected int FixedConnectionCount { get; }
 
-        protected virtual ServerConnectionType InitialConnectionType { get; } = ServerConnectionType.Default;
+        protected virtual ServiceConnectionType InitialConnectionType { get; } = ServiceConnectionType.Default;
 
         public HubServiceEndpoint Endpoint { get; }
 
@@ -78,9 +78,13 @@ private set
             }
         }
 
-        protected ServiceConnectionContainerBase(IServiceConnectionFactory serviceConnectionFactory,
-            int minConnectionCount, HubServiceEndpoint endpoint,
-            IReadOnlyList<IServiceConnection> initialConnections = null, ILogger logger = null, AckHandler ackHandler = null)
+        protected ServiceConnectionContainerBase(
+            IServiceConnectionFactory serviceConnectionFactory,
+            int minConnectionCount,
+            HubServiceEndpoint endpoint,
+            IReadOnlyList<IServiceConnection> initialConnections = null,
+            ILogger logger = null,
+            AckHandler ackHandler = null)
         {
             Logger = logger ?? throw new ArgumentNullException(nameof(logger));
             ServiceConnectionFactory = serviceConnectionFactory;
@@ -155,7 +159,7 @@ public void HandleAck(AckMessage ackMessage)
         /// <summary>
         /// Create a connection for a specific service connection type
         /// </summary>
-        protected IServiceConnection CreateServiceConnectionCore(ServerConnectionType type)
+        protected IServiceConnection CreateServiceConnectionCore(ServiceConnectionType type)
         {
             var connection = ServiceConnectionFactory.Create(Endpoint, this, type);
 

diff --git a/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionMigrationLevel.cs b/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionMigrationLevel.cs
@@ -0,0 +1,21 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.Azure.SignalR
+{
+    internal enum ServiceConnectionMigrationLevel
+    {
+        /// <summary>
+        /// 0, Default, client-connection will not be migrated at any time.
+        /// </summary>
+        Off = 0,
+        /// <summary>
+        /// 1, ShutdownOnly, client-connection will be migrated to another available server if a graceful shutdown had performed.
+        /// </summary>
+        ShutdownOnly = 1,
+        /// <summary>
+        /// 2, All, migration will happen even if one or all service-connection had been dropped accidentally. (pending messages will be lost)
+        /// </summary>
+        All = 2,
+    }
+}
diff --git a/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionOptions.cs b/src/Microsoft.Azure.SignalR.Common/ServiceConnections/ServiceConnectionOptions.cs
@@ -0,0 +1,25 @@
+namespace Microsoft.Azure.SignalR
+{
+    class ServiceConnectionOptions
+    {
+        public ServiceConnectionType ConnectionType = ServiceConnectionType.Default;
+
+        public ServiceConnectionMigrationLevel MigrationLevel = ServiceConnectionMigrationLevel.Off;
+
+        public static ServiceConnectionOptions Default { get => new ServiceConnectionOptions(); }
+
+        internal ServiceConnectionOptions()
+        {
+
+        }
+
+        internal ServiceConnectionOptions Clone()
+        {
+            return new ServiceConnectionOptions
+            {
+                ConnectionType = ConnectionType,
+                MigrationLevel = MigrationLevel
+            };
+        }
+    }
+}
diff --git a/...erviceConnections/ServerConnectionType.cs → ...rviceConnections/ServiceConnectionType.cs b/...erviceConnections/ServerConnectionType.cs → ...rviceConnections/ServiceConnectionType.cs
@@ -3,7 +3,7 @@
 
 namespace Microsoft.Azure.SignalR
 {
-    internal enum ServerConnectionType
+    internal enum ServiceConnectionType
     {
         /// <summary>
         /// 0, Default, it can carry clients, service runtime should always accept this kind of connection

diff --git a/src/Microsoft.Azure.SignalR.Common/ServiceConnections/StrongServiceConnectionContainer.cs b/src/Microsoft.Azure.SignalR.Common/ServiceConnections/StrongServiceConnectionContainer.cs
@@ -115,7 +115,7 @@ private IServiceConnection CreateOnDemandServiceConnection()
 
             lock (_lock)
             {
-                newConnection = CreateServiceConnectionCore(ServerConnectionType.OnDemand);
+                newConnection = CreateServiceConnectionCore(ServiceConnectionType.OnDemand);
                 _onDemandServiceConnections.Add(newConnection);
             }
 

diff --git a/src/Microsoft.Azure.SignalR.Common/ServiceConnections/WeakServiceConnectionContainer.cs b/src/Microsoft.Azure.SignalR.Common/ServiceConnections/WeakServiceConnectionContainer.cs
@@ -27,7 +27,7 @@ internal class WeakServiceConnectionContainer : ServiceConnectionContainerBase
 
         private readonly TimerAwaitable _timer;
 
-        protected override ServerConnectionType InitialConnectionType => ServerConnectionType.Weak;
+        protected override ServiceConnectionType InitialConnectionType => ServiceConnectionType.Weak;
 
         public WeakServiceConnectionContainer(IServiceConnectionFactory serviceConnectionFactory,
             int fixedConnectionCount, HubServiceEndpoint endpoint, ILogger logger)

diff --git a/src/Microsoft.Azure.SignalR.Management/ServiceManager.cs b/src/Microsoft.Azure.SignalR.Management/ServiceManager.cs
@@ -50,12 +50,23 @@ public async Task<IServiceHubContext> CreateHubContextAsync(string hubName, ILog
                         var clientConnectionManager = new ClientConnectionManager();
                         var clientConnectionFactory = new ClientConnectionFactory();
                         ConnectionDelegate connectionDelegate = connectionContext => Task.CompletedTask;
-                        var serviceConnectionFactory = new ServiceConnectionFactory(serviceProtocol, clientConnectionManager, connectionFactory, loggerFactory, connectionDelegate, clientConnectionFactory);
+
+                        var serviceConnectionFactory = new ServiceConnectionFactory(
+                            serviceProtocol,
+                            clientConnectionManager,
+                            connectionFactory,
+                            loggerFactory,
+                            connectionDelegate,
+                            clientConnectionFactory,
+                            ServiceConnectionOptions.Default
+                        );
+
                         var weakConnectionContainer = new WeakServiceConnectionContainer(
                             serviceConnectionFactory,
                             _serviceManagerOptions.ConnectionCount,
                             new HubServiceEndpoint(hubName, _endpointProvider, _endpoint),
-                            loggerFactory?.CreateLogger(nameof(WeakServiceConnectionContainer)) ?? NullLogger.Instance);
+                            loggerFactory?.CreateLogger(nameof(WeakServiceConnectionContainer)) ?? NullLogger.Instance
+                        );
 
                         var serviceCollection = new ServiceCollection();
                         serviceCollection.AddSignalRCore();

diff --git a/src/Microsoft.Azure.SignalR/HubHost/ServiceHubDispatcher.cs b/src/Microsoft.Azure.SignalR/HubHost/ServiceHubDispatcher.cs
@@ -93,8 +93,21 @@ private async Task OfflineAndWaitForCompletedAsync()
         private IServiceConnectionContainer GetMultiEndpointServiceConnectionContainer(string hub, ConnectionDelegate connectionDelegate, Action<HttpContext> contextConfig = null)
         {
             var connectionFactory = new ConnectionFactory(_nameProvider, _loggerFactory);
-            var serviceConnectionFactory = new ServiceConnectionFactory(_serviceProtocol, _clientConnectionManager, connectionFactory, _loggerFactory, connectionDelegate, _clientConnectionFactory);
-            serviceConnectionFactory.ConfigureContext = contextConfig;
+            var connectionOptions = ServiceConnectionOptions.Default;
+
+            if (_options.ServerConnectionMigration == 1)
+            {
+                connectionOptions.MigrationLevel = ServiceConnectionMigrationLevel.ShutdownOnly;
+            }
+            else if (_options.ServerConnectionMigration == 2)
+            {
+                connectionOptions.MigrationLevel = ServiceConnectionMigrationLevel.All;
+            }
+
+            var serviceConnectionFactory = new ServiceConnectionFactory(_serviceProtocol, _clientConnectionManager, connectionFactory, _loggerFactory, connectionDelegate, _clientConnectionFactory, connectionOptions)
+            {
+                ConfigureContext = contextConfig
+            };
 
             var factory = new ServiceConnectionContainerFactory(
                 serviceConnectionFactory,

diff --git a/src/Microsoft.Azure.SignalR/ServerConnections/ServiceConnection.cs b/src/Microsoft.Azure.SignalR/ServerConnections/ServiceConnection.cs
@@ -46,8 +46,9 @@ public ServiceConnection(IServiceProtocol serviceProtocol,
                                  string connectionId,
                                  HubServiceEndpoint endpoint,
                                  IServiceMessageHandler serviceMessageHandler,
-                                 ServerConnectionType connectionType = ServerConnectionType.Default) :
-            base(serviceProtocol, connectionId, endpoint, serviceMessageHandler, connectionType, loggerFactory?.CreateLogger<ServiceConnection>())
+                                 ServiceConnectionOptions options = null
+            ) :
+            base(serviceProtocol, connectionId, endpoint, serviceMessageHandler, options, loggerFactory?.CreateLogger<ServiceConnection>())
         {
             _clientConnectionManager = clientConnectionManager;
             _connectionFactory = connectionFactory;

diff --git a/src/Microsoft.Azure.SignalR/ServerConnections/ServiceConnectionFactory.cs b/src/Microsoft.Azure.SignalR/ServerConnections/ServiceConnectionFactory.cs
@@ -1,6 +1,4 @@
 using System;
-using System.Collections.Generic;
-using System.Text;
 using Microsoft.AspNetCore.Connections;
 using Microsoft.AspNetCore.Http;
 using Microsoft.Azure.SignalR.Protocol;
@@ -17,30 +15,55 @@ internal class ServiceConnectionFactory : IServiceConnectionFactory
         private readonly ConnectionDelegate _connectionDelegate;
         private readonly IClientConnectionFactory _clientConnectionFactory;
 
+        private readonly ServiceConnectionOptions _options;
+
         public Action<HttpContext> ConfigureContext { get; set; }
 
         public ServiceConnectionFactory(IServiceProtocol serviceProtocol,
             IClientConnectionManager clientConnectionManager,
             IConnectionFactory connectionFactory,
             ILoggerFactory loggerFactory,
             ConnectionDelegate connectionDelegate,
-            IClientConnectionFactory clientConnectionFactory)
+            IClientConnectionFactory clientConnectionFactory,
+            ServiceConnectionOptions options
+        )
         {
             _serviceProtocol = serviceProtocol;
             _clientConnectionManager = clientConnectionManager;
             _connectionFactory = connectionFactory;
             _loggerFactory = loggerFactory;
             _connectionDelegate = connectionDelegate;
             _clientConnectionFactory = clientConnectionFactory;
+            _options = options;
         }
 
-        public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServerConnectionType type)
+        public IServiceConnection Create(
+            HubServiceEndpoint endpoint,
+            IServiceMessageHandler serviceMessageHandler,
+            ServiceConnectionType type
+        )
         {
-            var serviceConnection = new ServiceConnection(_serviceProtocol, _clientConnectionManager, _connectionFactory,
-                _loggerFactory, _connectionDelegate, _clientConnectionFactory,
-                Guid.NewGuid().ToString(), endpoint, serviceMessageHandler, type);
-            serviceConnection.ConfigureContext = ConfigureContext;
-            return serviceConnection;
+            ServiceConnectionOptions options = _options;
+            if (type != _options.ConnectionType)
+            {
+                options = _options.Clone();
+                options.ConnectionType = type;
+            }
+            return new ServiceConnection(
+                _serviceProtocol,
+                _clientConnectionManager,
+                _connectionFactory,
+                _loggerFactory,
+                _connectionDelegate,
+                _clientConnectionFactory,
+                Guid.NewGuid().ToString(),
+                endpoint,
+                serviceMessageHandler,
+                options
+            )
+            {
+                ConfigureContext = ConfigureContext
+            };
         }
     }
 }
diff --git a/src/Microsoft.Azure.SignalR/ServiceOptions.cs b/src/Microsoft.Azure.SignalR/ServiceOptions.cs
@@ -58,6 +58,14 @@ public class ServiceOptions : IServiceEndpointOptions
         /// </summary>
         internal bool EnableGracefulShutdown { get; set; } = false;
 
+        /// <summary>
+        /// Specifies if the client-connection assigned to this server can be migrated to another server.
+        /// Default value is 0.
+        /// 1: Only migrate client-connection if server was shutdown gracefully.
+        /// 2: Migrate client-connection even if server-connection was accidentally dropped. (Potential data losses)
+        /// </summary>
+        internal int ServerConnectionMigration { get; set; } = 0;
+
         /// <summary>
         /// Specifies the timeout of a graceful shutdown process (in seconds). 
         /// Default value is 30 seconds.

diff --git a/src/Microsoft.Azure.SignalR/ServiceOptionsSetup.cs b/src/Microsoft.Azure.SignalR/ServiceOptionsSetup.cs
@@ -16,9 +16,6 @@ internal class ServiceOptionsSetup : IConfigureOptions<ServiceOptions>
         private readonly string _connectionString;
         private readonly ServiceEndpoint[] _endpoints;
 
-        private readonly bool _gracefulShutdownEnabled = false;
-        private readonly TimeSpan _shutdownTimeout = TimeSpan.FromSeconds(Constants.DefaultShutdownTimeoutInSeconds);
-
         public ServiceOptionsSetup(IConfiguration configuration)
         {
             _appName = configuration[Constants.ApplicationNameDefaultKeyPrefix];
@@ -47,8 +44,6 @@ public void Configure(ServiceOptions options)
             options.Endpoints = _endpoints;
             options.ApplicationName = _appName;
             options.ServerStickyMode = _serverStickyMode;
-            options.EnableGracefulShutdown = _gracefulShutdownEnabled;
-            options.ServerShutdownTimeout = _shutdownTimeout;
         }
 
         private static (string, ServiceEndpoint[]) GetEndpoint(IConfiguration configuration, string key)

diff --git a/test/Microsoft.Azure.SignalR.Tests.Common/TestClasses/TestServiceConnection.cs b/test/Microsoft.Azure.SignalR.Tests.Common/TestClasses/TestServiceConnection.cs
@@ -30,7 +30,7 @@ public TestServiceConnection(ServiceConnectionStatus status = ServiceConnectionS
             Guid.NewGuid().ToString(),
             new HubServiceEndpoint(),
             null, // TODO replace it with a NullMessageHandler
-            ServerConnectionType.Default,
+            ServiceConnectionOptions.Default,
             NullLogger.Instance
         )
         {

diff --git a/test/Microsoft.Azure.SignalR.Tests.Common/TestClasses/TestServiceConnectionFactory.cs b/test/Microsoft.Azure.SignalR.Tests.Common/TestClasses/TestServiceConnectionFactory.cs
@@ -13,7 +13,7 @@ public TestServiceConnectionFactory(Func<ServiceEndpoint, IServiceConnection> ge
             _generator = generator;
         }
 
-        public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServerConnectionType type)
+        public IServiceConnection Create(HubServiceEndpoint endpoint, IServiceMessageHandler serviceMessageHandler, ServiceConnectionType type)
         {
             return _generator?.Invoke(endpoint) ?? new TestServiceConnection();
         }