invocatorcontext property, simple

gencebay · gencebay · commit 69e56fdc1a4e · 2018-02-21T16:55:17.000+03:00
diff --git a/src/NetCoreStack.WebSockets.ProxyClient/ApplicationBuilderExtensions.cs b/src/NetCoreStack.WebSockets.ProxyClient/ApplicationBuilderExtensions.cs
@@ -24,7 +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());
+                InvocatorsHelper.EnsureHostPair(connector.InvocatorContext);
                 appLifeTime.ApplicationStopping.Register(OnShutdown, connector);
                 Task.Factory.StartNew(async () => await connector.ConnectAsync(cancellationTokenSource), TaskCreationOptions.LongRunning);
             }
diff --git a/src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnector.cs b/src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnector.cs
@@ -45,28 +45,27 @@ public ClientWebSocketConnector(IServiceProvider serviceProvider,
             _loggerFactory = loggerFactory;
         }
 
-        public abstract InvocatorContext GetInvocatorContext();
+        public abstract InvocatorContext InvocatorContext { get; }
 
         private async Task<WebSocketReceiver> TryConnectAsync(CancellationTokenSource cancellationTokenSource = null)
         {
-            var invocatorContext = GetInvocatorContext();
             _webSocket = new ClientWebSocket();
-            _webSocket.Options.SetRequestHeader(SocketsConstants.ConnectorName, invocatorContext.ConnectorName);
+            _webSocket.Options.SetRequestHeader(SocketsConstants.ConnectorName, InvocatorContext.ConnectorName);
             try
             {
                 CancellationToken token = cancellationTokenSource != null ? cancellationTokenSource.Token : CancellationToken.None;
-                await _webSocket.ConnectAsync(invocatorContext.Uri, token);
+                await _webSocket.ConnectAsync(InvocatorContext.Uri, token);
             }
             catch (Exception ex)
             {
-                ProxyLogHelper.Log(_loggerFactory, invocatorContext, "Error", ex);
+                ProxyLogHelper.Log(_loggerFactory, InvocatorContext, "Error", ex);
                 return null;
             }
 
             var receiverContext = new WebSocketReceiverContext
             {
                 Compressor = _compressor,
-                InvocatorContext = invocatorContext,
+                InvocatorContext = InvocatorContext,
                 LoggerFactory = _loggerFactory,
                 WebSocket = _webSocket
             };
diff --git a/src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnectorOfT.cs b/src/NetCoreStack.WebSockets.ProxyClient/ClientWebSocketConnectorOfT.cs
@@ -9,12 +9,7 @@ public class ClientWebSocketConnectorOfT<TInvocator> : ClientWebSocketConnector,
     {
         private readonly IClientInvocatorContextFactory<TInvocator> _invocatorContextFactory;
 
-        public ProxyOptions<TInvocator> Options { get; }
-
-        public override InvocatorContext GetInvocatorContext()
-        {
-            return _invocatorContextFactory.CreateInvocatorContext();
-        }
+        public override InvocatorContext InvocatorContext { get; }
 
         public ClientWebSocketConnectorOfT(IServiceProvider serviceProvider,
             IClientInvocatorContextFactory<TInvocator> invocatorContextFactory,
@@ -23,6 +18,7 @@ public ClientWebSocketConnectorOfT(IServiceProvider serviceProvider,
             : base(serviceProvider, compressor, loggerFactory)
         {
             _invocatorContextFactory = invocatorContextFactory ?? throw new ArgumentNullException(nameof(invocatorContextFactory));
+            InvocatorContext = _invocatorContextFactory.CreateInvocatorContext();
         }
     }
-}
+}
diff --git a/src/NetCoreStack.WebSockets.ProxyClient/IWebSocketConnector.cs b/src/NetCoreStack.WebSockets.ProxyClient/IWebSocketConnector.cs
@@ -11,11 +11,10 @@ public interface IWebSocketConnector
         Task ConnectAsync(CancellationTokenSource cancellationTokenSource);
         Task SendAsync(WebSocketMessageContext context);
         Task SendBinaryAsync(byte[] bytes);
-        InvocatorContext GetInvocatorContext();
+        InvocatorContext InvocatorContext { get; }
     }
 
     public interface IWebSocketConnector<TInvocator> : IWebSocketConnector where TInvocator : IClientWebSocketCommandInvocator
     {
-        ProxyOptions<TInvocator> Options { get; }
     }
-}
+}
diff --git a/test/Common.Libs/CacheHelper.cs b/test/Common.Libs/CacheHelper.cs
@@ -29,7 +29,7 @@ public static CacheItemDescriptor GetDescriptor(string key)
                 return descriptor;
             }
 
-            throw new ArgumentOutOfRangeException($"Key could not be found: \"{key}\"");
+            return null;
         }
     }
 }
diff --git a/test/NetCoreStack.WebSockets.Tests/ProxyBuilderTests.cs b/test/NetCoreStack.WebSockets.Tests/ProxyBuilderTests.cs
@@ -63,7 +63,7 @@ public void CustomInvocatorRegistryTest()
             var customWebSocketCommandInvocator = Services.GetService<IWebSocketConnector<CustomWebSocketCommandInvocator>>();
             Assert.IsType<ClientWebSocketConnectorOfT<CustomWebSocketCommandInvocator>>(customWebSocketCommandInvocator);
 
-            var context = customWebSocketCommandInvocator.GetInvocatorContext();
+            var context = customWebSocketCommandInvocator.InvocatorContext;
             Assert.Equal($"TestWebApp-{Environment.MachineName}", context.ConnectorName);
             Assert.Equal("localhost:7803", context.HostAddress);
 
@@ -76,7 +76,7 @@ public void AnotherEndpointWebSocketCommandInvocator()
             var customWebSocketCommandInvocator = Services.GetService<IWebSocketConnector<AnotherEndpointWebSocketCommandInvocator>>();
             Assert.IsType<ClientWebSocketConnectorOfT<AnotherEndpointWebSocketCommandInvocator>>(customWebSocketCommandInvocator);
 
-            var context = customWebSocketCommandInvocator.GetInvocatorContext();
+            var context = customWebSocketCommandInvocator.InvocatorContext;
             Assert.Equal("TestMachineName", context.ConnectorName);
             Assert.Equal("localhost:5003", context.HostAddress);
 
diff --git a/test/WebClientTestApp/CustomWebSocketCommandInvocator.cs b/test/WebClientTestApp/CustomWebSocketCommandInvocator.cs
@@ -13,14 +13,17 @@ namespace WebClientTestApp
     public class CustomWebSocketCommandInvocator : IClientWebSocketCommandInvocator
     {
         private readonly IConnectionManager _connectionManager;
+        private readonly IWebSocketConnector<CustomWebSocketCommandInvocator> _webSocketConnector;
         private readonly ILogger _logger;
         private readonly InMemoryCacheProvider _cacheProvider;
 
-        public CustomWebSocketCommandInvocator(IConnectionManager connectionManager, 
+        public CustomWebSocketCommandInvocator(IConnectionManager connectionManager,
+            IWebSocketConnector<CustomWebSocketCommandInvocator> webSocketConnector,
             InMemoryCacheProvider cacheProvider, 
             ILogger<CustomWebSocketCommandInvocator> logger)
         {
             _connectionManager = connectionManager;
+            _webSocketConnector = webSocketConnector;
             _cacheProvider = cacheProvider;
             _logger = logger;
         }
@@ -50,6 +53,10 @@ public async Task InvokeAsync(WebSocketMessageContext context)
                     {
                         var keyStr = key.ToString();
                         var descriptor = CacheHelper.GetDescriptor(key.ToString());
+                        if (descriptor == null)
+                        {
+                            return;
+                        }
                         try
                         {
                             var genericList = descriptor.Type.CreateElementTypeAsGenericList();

Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public static IApplicationBuilder UseProxyWebSockets(this IApplicationBuilder ap`
`24`	`24`	`IList<IWebSocketConnector> connectors = InvocatorFactory.GetConnectors(app.ApplicationServices);`
`25`	`25`	`foreach (var connector in connectors)`
`26`	`26`	`{`
`27`		`- InvocatorsHelper.EnsureHostPair(connector.GetInvocatorContext());`
	`27`	`+ InvocatorsHelper.EnsureHostPair(connector.InvocatorContext);`
`28`	`28`	`appLifeTime.ApplicationStopping.Register(OnShutdown, connector);`
`29`	`29`	`Task.Factory.StartNew(async () => await connector.ConnectAsync(cancellationTokenSource), TaskCreationOptions.LongRunning);`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,28 +45,27 @@ public ClientWebSocketConnector(IServiceProvider serviceProvider,`
`45`	`45`	`_loggerFactory = loggerFactory;`
`46`	`46`	`}`
`47`	`47`
`48`		`- public abstract InvocatorContext GetInvocatorContext();`
	`48`	`+ public abstract InvocatorContext InvocatorContext { get; }`
`49`	`49`
`50`	`50`	`private async Task<WebSocketReceiver> TryConnectAsync(CancellationTokenSource cancellationTokenSource = null)`
`51`	`51`	`{`
`52`		`- var invocatorContext = GetInvocatorContext();`
`53`	`52`	`_webSocket = new ClientWebSocket();`
`54`		`- _webSocket.Options.SetRequestHeader(SocketsConstants.ConnectorName, invocatorContext.ConnectorName);`
	`53`	`+ _webSocket.Options.SetRequestHeader(SocketsConstants.ConnectorName, InvocatorContext.ConnectorName);`
`55`	`54`	`try`
`56`	`55`	`{`
`57`	`56`	`CancellationToken token = cancellationTokenSource != null ? cancellationTokenSource.Token : CancellationToken.None;`
`58`		`- await _webSocket.ConnectAsync(invocatorContext.Uri, token);`
	`57`	`+ await _webSocket.ConnectAsync(InvocatorContext.Uri, token);`
`59`	`58`	`}`
`60`	`59`	`catch (Exception ex)`
`61`	`60`	`{`
`62`		`- ProxyLogHelper.Log(_loggerFactory, invocatorContext, "Error", ex);`
	`61`	`+ ProxyLogHelper.Log(_loggerFactory, InvocatorContext, "Error", ex);`
`63`	`62`	`return null;`
`64`	`63`	`}`
`65`	`64`
`66`	`65`	`var receiverContext = new WebSocketReceiverContext`
`67`	`66`	`{`
`68`	`67`	`Compressor = _compressor,`
`69`		`- InvocatorContext = invocatorContext,`
	`68`	`+ InvocatorContext = InvocatorContext,`
`70`	`69`	`LoggerFactory = _loggerFactory,`
`71`	`70`	`WebSocket = _webSocket`
`72`	`71`	`};`
Original file line number	Diff line number	Diff line change
`@@ -9,12 +9,7 @@ public class ClientWebSocketConnectorOfT<TInvocator> : ClientWebSocketConnector,`
`9`	`9`	`{`
`10`	`10`	`private readonly IClientInvocatorContextFactory<TInvocator> _invocatorContextFactory;`
`11`	`11`
`12`		`- public ProxyOptions<TInvocator> Options { get; }`
`13`		`-`
`14`		`- public override InvocatorContext GetInvocatorContext()`
`15`		`- {`
`16`		`- return _invocatorContextFactory.CreateInvocatorContext();`
`17`		`- }`
	`12`	`+ public override InvocatorContext InvocatorContext { get; }`
`18`	`13`
`19`	`14`	`public ClientWebSocketConnectorOfT(IServiceProvider serviceProvider,`
`20`	`15`	`IClientInvocatorContextFactory<TInvocator> invocatorContextFactory,`
`@@ -23,6 +18,7 @@ public ClientWebSocketConnectorOfT(IServiceProvider serviceProvider,`
`23`	`18`	`: base(serviceProvider, compressor, loggerFactory)`
`24`	`19`	`{`
`25`	`20`	`_invocatorContextFactory = invocatorContextFactory ?? throw new ArgumentNullException(nameof(invocatorContextFactory));`
	`21`	`+ InvocatorContext = _invocatorContextFactory.CreateInvocatorContext();`
`26`	`22`	`}`
`27`	`23`	`}`
`28`		`-}`
	`24`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,10 @@ public interface IWebSocketConnector`
`11`	`11`	`Task ConnectAsync(CancellationTokenSource cancellationTokenSource);`
`12`	`12`	`Task SendAsync(WebSocketMessageContext context);`
`13`	`13`	`Task SendBinaryAsync(byte[] bytes);`
`14`		`- InvocatorContext GetInvocatorContext();`
	`14`	`+ InvocatorContext InvocatorContext { get; }`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`public interface IWebSocketConnector<TInvocator> : IWebSocketConnector where TInvocator : IClientWebSocketCommandInvocator`
`18`	`18`	`{`
`19`		`- ProxyOptions<TInvocator> Options { get; }`
`20`	`19`	`}`
`21`		`-}`
	`20`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public static CacheItemDescriptor GetDescriptor(string key)`
`29`	`29`	`return descriptor;`
`30`	`30`	`}`
`31`	`31`
`32`		`- throw new ArgumentOutOfRangeException($"Key could not be found: \"{key}\"");`
	`32`	`+ return null;`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,17 @@ namespace WebClientTestApp`
`13`	`13`	`public class CustomWebSocketCommandInvocator : IClientWebSocketCommandInvocator`
`14`	`14`	`{`
`15`	`15`	`private readonly IConnectionManager _connectionManager;`
	`16`	`+ private readonly IWebSocketConnector<CustomWebSocketCommandInvocator> _webSocketConnector;`
`16`	`17`	`private readonly ILogger _logger;`
`17`	`18`	`private readonly InMemoryCacheProvider _cacheProvider;`
`18`	`19`
`19`		`- public CustomWebSocketCommandInvocator(IConnectionManager connectionManager,`
	`20`	`+ public CustomWebSocketCommandInvocator(IConnectionManager connectionManager,`
	`21`	`+ IWebSocketConnector<CustomWebSocketCommandInvocator> webSocketConnector,`
`20`	`22`	`InMemoryCacheProvider cacheProvider,`
`21`	`23`	`ILogger<CustomWebSocketCommandInvocator> logger)`
`22`	`24`	`{`
`23`	`25`	`_connectionManager = connectionManager;`
	`26`	`+ _webSocketConnector = webSocketConnector;`
`24`	`27`	`_cacheProvider = cacheProvider;`
`25`	`28`	`_logger = logger;`
`26`	`29`	`}`
`@@ -50,6 +53,10 @@ public async Task InvokeAsync(WebSocketMessageContext context)`
`50`	`53`	`{`
`51`	`54`	`var keyStr = key.ToString();`
`52`	`55`	`var descriptor = CacheHelper.GetDescriptor(key.ToString());`
	`56`	`+ if (descriptor == null)`
	`57`	`+ {`
	`58`	`+ return;`
	`59`	`+ }`
`53`	`60`	`try`
`54`	`61`	`{`
`55`	`62`	`var genericList = descriptor.Type.CreateElementTypeAsGenericList();`