TInvocator runtime factory context, tests, connector endpoint settings

Author: gencebay

NetCoreStack.WebSockets.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26730.12
+VisualStudioVersion = 15.0.27130.2027
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{52C54080-F48B-4DBA-A418-8057611CAF6D}"
 EndProject
@@ -27,6 +27,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleAppProxyClient", "te
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetCoreStack.WebSockets.ProxyClient", "src\NetCoreStack.WebSockets.ProxyClient\NetCoreStack.WebSockets.ProxyClient.csproj", "{1738B969-D294-4417-999C-A3AC3B04EFE4}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NetCoreStack.WebSockets.Tests", "test\NetCoreStack.WebSockets.Tests\NetCoreStack.WebSockets.Tests.csproj", "{8A756067-8C6F-475C-B2CF-97B582A4DB47}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -61,6 +63,10 @@ Global
 		{1738B969-D294-4417-999C-A3AC3B04EFE4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1738B969-D294-4417-999C-A3AC3B04EFE4}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1738B969-D294-4417-999C-A3AC3B04EFE4}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8A756067-8C6F-475C-B2CF-97B582A4DB47}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8A756067-8C6F-475C-B2CF-97B582A4DB47}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8A756067-8C6F-475C-B2CF-97B582A4DB47}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8A756067-8C6F-475C-B2CF-97B582A4DB47}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -73,6 +79,7 @@ Global
 		{7ACFEED0-C1D7-43DE-95D7-3D2CEFDF6F9F} = {A1704016-03C8-4917-9C50-AE9DDF55ECB7}
 		{1AAECD28-5C1D-4ED6-8CBC-6FCAA3804ABF} = {A1704016-03C8-4917-9C50-AE9DDF55ECB7}
 		{1738B969-D294-4417-999C-A3AC3B04EFE4} = {52C54080-F48B-4DBA-A418-8057611CAF6D}
+		{8A756067-8C6F-475C-B2CF-97B582A4DB47} = {A1704016-03C8-4917-9C50-AE9DDF55ECB7}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {F299AD98-9AB4-4C7B-B125-5E82EB9B8700}

src/NetCoreStack.WebSockets.ProxyClient/ApplicationBuilderExtensions.cs

@@ -24,6 +24,7 @@ public static IApplicationBuilder UseProxyWebSockets(this IApplicationBuilder ap
             IList<IWebSocketConnector> connectors = InvocatorFactory.GetConnectors(app.ApplicationServices);
             foreach (var connector in connectors)
             {
+                InvocatorsHelper.EnsureHostPair(connector.GetInvocatorContext());
                 appLifeTime.ApplicationStopping.Register(OnShutdown, connector);
                 Task.Factory.StartNew(async () => await connector.ConnectAsync(cancellationTokenSource), TaskCreationOptions.LongRunning);
             }

src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnector.cs

@@ -45,18 +45,17 @@ public ClientWebSocketConnector(IServiceProvider serviceProvider,
             _loggerFactory = loggerFactory;
         }
 
-        protected abstract InvocatorContext CreateInvocatorContext();
+        public abstract InvocatorContext GetInvocatorContext();
 
         private async Task<WebSocketReceiver> TryConnectAsync(CancellationTokenSource cancellationTokenSource = null)
         {
-            var invocatorContext = CreateInvocatorContext();
-            var uri = new Uri($"ws://{invocatorContext.HostAddress}");
+            var invocatorContext = GetInvocatorContext();
             _webSocket = new ClientWebSocket();
             _webSocket.Options.SetRequestHeader(SocketsConstants.ConnectorName, invocatorContext.ConnectorName);
             try
             {
                 CancellationToken token = cancellationTokenSource != null ? cancellationTokenSource.Token : CancellationToken.None;
-                await _webSocket.ConnectAsync(uri, token);
+                await _webSocket.ConnectAsync(invocatorContext.Uri, token);
             }
             catch (Exception ex)
             {

src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnectorOfInvocator.cs

@@ -0,0 +1,28 @@
+using Microsoft.Extensions.Logging;
+using NetCoreStack.WebSockets.Interfaces;
+using System;
+
+namespace NetCoreStack.WebSockets.ProxyClient
+{
+    public class ClientWebSocketConnectorOfT<TInvocator> : ClientWebSocketConnector,
+        IWebSocketConnector<TInvocator> where TInvocator : IClientWebSocketCommandInvocator
+    {
+        private readonly IClientInvocatorContextFactory<TInvocator> _invocatorContextFactory;
+
+        public ProxyOptions<TInvocator> Options { get; }
+
+        public override InvocatorContext GetInvocatorContext()
+        {
+            return _invocatorContextFactory.CreateInvocatorContext();
+        }
+
+        public ClientWebSocketConnectorOfT(IServiceProvider serviceProvider,
+            IClientInvocatorContextFactory<TInvocator> invocatorContextFactory,
+            IStreamCompressor compressor,
+            ILoggerFactory loggerFactory)
+            : base(serviceProvider, compressor, loggerFactory)
+        {
+            _invocatorContextFactory = invocatorContextFactory ?? throw new ArgumentNullException(nameof(invocatorContextFactory));
+        }
+    }
+}

src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnectorOfT.cs

@@ -0,0 +1,26 @@
+using Microsoft.Extensions.Options;
+using System;
+
+namespace NetCoreStack.WebSockets.ProxyClient
+{
+    internal class DefaultClientInvocatorContextFactory<TInvocator> : IClientInvocatorContextFactory<TInvocator>
+        where TInvocator : IClientWebSocketCommandInvocator
+    {
+        private readonly ProxyOptions<TInvocator> _proxyOptions;
+
+        public DefaultClientInvocatorContextFactory(IOptions<ProxyOptions<TInvocator>> options)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            _proxyOptions = options.Value;
+        }
+
+        public InvocatorContext CreateInvocatorContext()
+        {
+            return new InvocatorContext(_proxyOptions.Invocator, _proxyOptions.ConnectorName, _proxyOptions.WebSocketHostAddress);
+        }
+    }
+}

src/NetCoreStack.WebSockets.ProxyClient/DefaultClientInvocatorContextFactory.cs

@@ -0,0 +1,7 @@
+namespace NetCoreStack.WebSockets.ProxyClient
+{
+    public interface IClientInvocatorContextFactory<TInvocator> where TInvocator : IClientWebSocketCommandInvocator
+    {
+        InvocatorContext CreateInvocatorContext();
+    }
+}

src/NetCoreStack.WebSockets.ProxyClient/IClientInvocatorContextFactory.cs

@@ -11,10 +11,11 @@ public interface IWebSocketConnector
         Task ConnectAsync(CancellationTokenSource cancellationTokenSource);
         Task SendAsync(WebSocketMessageContext context);
         Task SendBinaryAsync(byte[] bytes);
+        InvocatorContext GetInvocatorContext();
     }
 
-    public interface IWebSocketConnector<THandler> : IWebSocketConnector where THandler : IClientWebSocketCommandInvocator
+    public interface IWebSocketConnector<TInvocator> : IWebSocketConnector where TInvocator : IClientWebSocketCommandInvocator
     {
-        ProxyOptions<THandler> Options { get; }
+        ProxyOptions<TInvocator> Options { get; }
     }
 }

src/NetCoreStack.WebSockets.ProxyClient/IWebSocketConnector.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace NetCoreStack.WebSockets.ProxyClient
+{
+    public static class InvocatorsHelper
+    {
+        private static readonly InvocatorTypes _invocators = new InvocatorTypes(StringComparer.OrdinalIgnoreCase);
+
+        private class InvocatorTypes : Dictionary<string, ConnectorHostPair>
+        {
+            public InvocatorTypes(IEqualityComparer<string> equalityComparer)
+                :base(equalityComparer)
+            {
+
+            }
+        }
+
+        public static void EnsureHostPair(Type invocator, string connectorName, string hostAddress)
+        {
+            var connectorHostPair = new ConnectorHostPair(connectorName, hostAddress, invocator);
+            var key = connectorHostPair.Key;
+
+            if (_invocators.TryGetValue(key, out ConnectorHostPair value))
+            {
+                // throw new InvalidOperationException($"\"{connectorName}\" is already registered with same Host and Invocator");
+                return;
+            }
+
+            _invocators.Add(key, connectorHostPair);
+        }
+
+        public static void EnsureHostPair(InvocatorContext context)
+        {
+            if (context == null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
+            var invocator = context.Invocator;
+            var connectorName = context.ConnectorName;
+            var hostAddress = context.HostAddress;
+
+            EnsureHostPair(invocator, connectorName, hostAddress);
+        }
+
+        public static List<Type> GetInvocators()
+        {
+            return _invocators.Select(p => p.Value.Invocator).ToList();
+        }
+    }
+}