invocator instance resolve bug fix, header provider

Author: gencebay

src/NetCoreStack.WebSockets.ProxyClient/ProxyWebSocketsBuilder.cs

@@ -17,6 +17,7 @@ private void RegisterInternal<TInvocator>()
         {
             var invocatorType = typeof(TInvocator);
             InvocatorFactory.Invocators.Add(invocatorType);
+            _services.AddTransient(invocatorType);
             _services.AddSingleton<IWebSocketConnector<TInvocator>, ClientWebSocketConnectorOfT<TInvocator>>();
         }
 

src/NetCoreStack.WebSockets/ConnectionManager.cs

@@ -19,6 +19,7 @@ public class ConnectionManager : IConnectionManager
     {
         private readonly IServiceProvider _serviceProvider;
         private readonly IHandshakeStateTransport _initState;
+        private readonly IHeaderProvider _headerProvider;
         private readonly ILoggerFactory _loggerFactory;
         private readonly IStreamCompressor _compressor;
 
@@ -27,11 +28,13 @@ public class ConnectionManager : IConnectionManager
         public ConnectionManager(IServiceProvider serviceProvider,
             IStreamCompressor compressor,
             IHandshakeStateTransport initState,
+            IHeaderProvider headerProvider,
             ILoggerFactory loggerFactory)
         {
             _serviceProvider = serviceProvider;
             _compressor = compressor;
             _initState = initState;
+            _headerProvider = headerProvider;
             _loggerFactory = loggerFactory;            
             Connections = new ConcurrentDictionary<string, WebSocketTransport>(StringComparer.OrdinalIgnoreCase);
         }
@@ -60,6 +63,7 @@ private async Task<byte[]> PrepareFramesBytesAsync(byte[] body, IDictionary<stri
                 properties.Add(CompressedKey, compressed);
             }
 
+            _headerProvider.Invoke(properties);
             string props = JsonConvert.SerializeObject(properties);
             byte[] header = Encoding.UTF8.GetBytes($"{props}");
 
@@ -228,6 +232,7 @@ public Task SendAsync(string connectionId, WebSocketMessageContext context)
                 throw new ArgumentOutOfRangeException(nameof(transport));
             }
 
+            _headerProvider.Invoke(context.Header);
             var segments = context.ToSegment();
             var descriptor = new WebSocketMessageDescriptor
             {

src/NetCoreStack.WebSockets/DefaultHeaderProvider.cs

@@ -0,0 +1,21 @@
+using NetCoreStack.WebSockets.Internal;
+using System.Collections.Generic;
+
+namespace NetCoreStack.WebSockets
+{
+    public class DefaultHeaderProvider : IHeaderProvider
+    {
+        public void Invoke(IDictionary<string, object> header)
+        {
+            if (header == null)
+            {
+                return;
+            }
+
+            if (!header.TryGetValue(SocketsConstants.WSFQN, out object host))
+            {
+                header.Add(SocketsConstants.WSFQN, FQNHelper.Name);
+            }
+        }
+    }
+}

src/NetCoreStack.WebSockets/Extensions/SocketServiceCollectionExtensions.cs

@@ -16,13 +16,20 @@ public static void AddNativeWebSockets<TInvocator>(this IServiceCollection servi
             {
                 throw new ArgumentNullException(nameof(services));
             }
-            
+
             services.TryAdd(ServiceDescriptor.Singleton<ILoggerFactory, LoggerFactory>());
+            services.TryAdd(ServiceDescriptor.Singleton<IHeaderProvider, DefaultHeaderProvider>());
             services.TryAdd(ServiceDescriptor.Singleton<IStreamCompressor, GZipStreamCompressor>());
             services.TryAdd(ServiceDescriptor.Transient<IHandshakeStateTransport, DefaultHandshakeStateTransport>());
 
             services.AddSingleton<IConnectionManager, ConnectionManager>();
             services.AddTransient(typeof(IServerWebSocketCommandInvocator), typeof(TInvocator));
         }
+
+        public static void AddNativeWebSockets<TInvocator>(this IServiceCollection services, string hostname)
+            where TInvocator : IServerWebSocketCommandInvocator
+        {
+            AddNativeWebSockets<TInvocator>(services);
+        }
     }
-}
+}

src/NetCoreStack.WebSockets/Extensions/WebSocketExtensions.cs

@@ -102,15 +102,15 @@ public static ArraySegment<byte> ToSegment(this WebSocketMessageContext webSocke
             return new ArraySegment<byte>(content, 0, content.Length);
         }
 
-        public static string GetConnectionId(this WebSocketMessageContext webSocketContext)
+        public static string GetConnectionId(this WebSocketMessageContext context)
         {
-            if (webSocketContext == null)
+            if (context == null)
             {
-                throw new ArgumentNullException(nameof(webSocketContext));
+                throw new ArgumentNullException(nameof(context));
             }
 
             object connectionId = null;
-            if (webSocketContext.Header.TryGetValue(SocketsConstants.ConnectionId, out connectionId))
+            if (context.Header.TryGetValue(SocketsConstants.ConnectionId, out connectionId))
             {
                 return connectionId.ToString();
             }

src/NetCoreStack.WebSockets/Interfaces/IHeaderProvider.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace NetCoreStack.WebSockets
+{
+    public interface IHeaderProvider
+    {
+        void Invoke(IDictionary<string, object> header);
+    }
+}

src/NetCoreStack.WebSockets/Internal/FQNHelper.cs

@@ -0,0 +1,10 @@
+using System;
+using System.Text;
+
+namespace NetCoreStack.WebSockets.Internal
+{
+    internal static class FQNHelper
+    {
+        internal static readonly string Name = Environment.MachineName;
+    }
+}

src/NetCoreStack.WebSockets/Internal/SocketsConstants.cs

@@ -4,6 +4,7 @@ public static class SocketsConstants
     {
         public static byte[] Splitter = new byte[] { 0x1f };
         public const int ChunkSize = 1024 * 4;
+        public const string WSFQN = "X-NetCoreStack-WSHost";
         public const string CompressedKey = "Compressed";
         public const string ConnectorName = "ConnectorName";
         public const string ConnectionId = "ConnectionId";

src/NetCoreStack.WebSockets/Internal/WebSocketMessageDescriptor.cs

@@ -9,7 +9,6 @@ public class WebSocketMessageDescriptor
         public ArraySegment<byte> Segments { get; set; }
         public WebSocketMessageType MessageType { get; set; }
         public bool EndOfMessage { get; set; }
-        public bool IsQueue { get; set; }
         public CancellationToken CancellationToken { get; }
 
         public WebSocketMessageDescriptor()

test/ServerTestApp/Controllers/DiscoveryController.cs

@@ -1,15 +1,14 @@
-using Common.Libs;
-using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Caching.Distributed;
 using Microsoft.Extensions.Logging;
 using NetCoreStack.WebSockets;
 using NetCoreStack.WebSockets.Internal;
 using ServerTestApp.Models;
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Net.WebSockets;
+using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -62,20 +61,9 @@ public async Task<IActionResult> BroadcastBinaryAsync([FromBody]SimpleModel mode
         [HttpPost(nameof(SendBinaryAsync))]
         public async Task<IActionResult> SendBinaryAsync()
         {
-            try
-            {
-                foreach (KeyValuePair<string, CacheItemDescriptor> entry in CacheHelper.CacheKeys)
-                {
-                    var routeValueDictionary = new RouteValueDictionary(new { Key = entry.Key });
-                    var bytes = _distrubutedCache.Get(entry.Key);
-                    await _connectionManager.BroadcastBinaryAsync(bytes, routeValueDictionary);
-                }
-            }
-            catch (Exception ex)
-            {
-                throw ex;
-            }
-
+            var routeValueDictionary = new RouteValueDictionary(new { Key = "SomeKey" });
+            var bytes = Encoding.UTF8.GetBytes("Hello World");
+            await _connectionManager.BroadcastBinaryAsync(bytes, routeValueDictionary);
             return Ok();
         }