public ClientConnectionContext CreateConnection(OpenConnectionMessage message, Action <HttpContext> configureContext = null) { var context = new ClientConnectionContext(message, configureContext); Connections.Add(context); return(context); }
public void ServiceConnectionContextWithNullClaimsIsUnauthenticated() { var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", null)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.False(serviceConnectionContext.User.Identity.IsAuthenticated); }
public async void TestSendConnectionAsyncisOverwrittenWhenClientConnectionExisted() { var serviceConnectionManager = new TestServiceConnectionManager <TestHub>(); var clientConnectionManager = new ClientConnectionManager(); var context = new ClientConnectionContext(new OpenConnectionMessage("conn1", new Claim[] { })); var connection = new TestServiceConnectionPrivate(); context.ServiceConnection = connection; clientConnectionManager.AddClientConnection(context); var manager = MockLifetimeManager(serviceConnectionManager, clientConnectionManager); await manager.SendConnectionAsync("conn1", "foo", new object[] { 1, 2 }); Assert.NotNull(connection.LastMessage); if (connection.LastMessage is MultiConnectionDataMessage m) { Assert.Equal("conn1", m.ConnectionList[0]); Assert.Equal(1, m.Payloads.Count); Assert.True(m.Payloads.ContainsKey(MockProtocol)); return; } Assert.True(false); }
private ClientConnectionContext CreateConnectionContext <TRequest, TResponse>( Method <TRequest, TResponse> method, CallOptions callOptions, TRequest request) where TRequest : class where TResponse : class { var stream = ClientStreamFactory(); try { bool isServerUnary = method.Type == MethodType.Unary || method.Type == MethodType.ClientStreaming; var ctx = new ClientConnectionContext(stream, callOptions, isServerUnary, ConnectionTimeout); ctx.InitCall(method, request); Task.Run(new PipeReader(stream, ctx, ctx.Dispose).ReadLoop); return(ctx); } catch (Exception ex) { stream.Dispose(); if (ex is TimeoutException) { throw new RpcException(new Status(StatusCode.Unavailable, "failed to connect to all addresses")); } else { throw; } } }
private ClientConnectionContext CreateConnectionContext <TRequest, TResponse>( Method <TRequest, TResponse> method, CallOptions callOptions, TRequest request) where TRequest : class where TResponse : class { var pipeOptions = PipeOptions.Asynchronous; #if NETCOREAPP || NETSTANDARD2_1 if (_options.CurrentUserOnly) { pipeOptions |= PipeOptions.CurrentUserOnly; } #endif var stream = new NamedPipeClientStream(_serverName, _pipeName, PipeDirection.InOut, pipeOptions, _options.ImpersonationLevel, HandleInheritability.None); try { bool isServerUnary = method.Type == MethodType.Unary || method.Type == MethodType.ClientStreaming; var ctx = new ClientConnectionContext(stream, callOptions, isServerUnary); ctx.InitCall(method, request); Task.Run(new PipeReader(stream, ctx, ctx.Dispose).ReadLoop); return(ctx); } catch (Exception) { stream.Dispose(); throw; } }
public bool TryGetClientConnection(string connectionId, out ClientConnectionContext connection) { if (_serviceConnection != null) { connection = new ClientConnectionContext(_serviceConnection, connectionId); return(true); } return(_connections.TryGetValue(connectionId, out connection)); }
public void AddClientConnection(ClientConnectionContext clientConnection) { var tcs = _tcs.GetOrAdd(clientConnection.ConnectionId, s => new TaskCompletionSource <ClientConnectionContext>(TaskCreationOptions .RunContinuationsAsynchronously)); _ccm.AddClientConnection(clientConnection); tcs.SetResult(clientConnection); }
public void AddClientConnection(ClientConnectionContext clientConnection) { ClientConnectionManager.AddClientConnection(clientConnection); if (_waitForConnectionOpen.TryGetValue(clientConnection.ConnectionId, out var tcs)) { tcs.TrySetResult(clientConnection); } }
public void ServiceConnectionContextWithEmptyHttpContextByDefault() { var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", new Claim[0])); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.NotNull(serviceConnectionContext.HttpContext); Assert.Equal(serviceConnectionContext.User, serviceConnectionContext.HttpContext.User); Assert.Empty(serviceConnectionContext.HttpContext.Request.Headers); Assert.Empty(serviceConnectionContext.HttpContext.Request.Query); }
public bool TryAddClientConnection(ClientConnectionContext connection) { var tcs = _tcs.GetOrAdd(connection.ConnectionId, s => new TaskCompletionSource <ClientConnectionContext>(TaskCreationOptions .RunContinuationsAsynchronously)); var r = _ccm.TryAddClientConnection(connection); tcs.SetResult(connection); return(r); }
[InlineData("&arsa_lang=123", "en-US")] // invalid culture won't change default en-US public void ServiceConnectionContextCultureTest(string cultureQuery, string result) { var queryString = $"?{cultureQuery}"; Assert.Equal("en-US", CultureInfo.CurrentCulture.Name); var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", new Claim[0], EmptyHeaders, queryString)); Assert.Equal(result, CultureInfo.CurrentCulture.Name); }
public bool TryRemoveClientConnection(string connectionId, out ClientConnectionContext connection) { if (ClientConnectionManager.TryRemoveClientConnection(connectionId, out connection)) { if (_waitForConnectionClose.TryGetValue(connectionId, out var tcs)) { tcs.TrySetResult(null); } return(true); } return(false); }
public bool TryAddClientConnection(ClientConnectionContext connection) { if (ClientConnectionManager.TryAddClientConnection(connection)) { if (_waitForConnectionOpen.TryGetValue(connection.ConnectionId, out var tcs)) { tcs.TrySetResult(connection); } return(true); } return(false); }
public bool TryRemoveClientConnection(string connectionId, out ClientConnectionContext connection) { var tcs = _tcsForRemoval.GetOrAdd(connectionId, s => new TaskCompletionSource <ClientConnectionContext>(TaskCreationOptions .RunContinuationsAsynchronously)); _tcs.TryRemove(connectionId, out _); var r = _ccm.TryRemoveClientConnection(connectionId, out connection); tcs.TrySetResult(connection); return(r); }
public void ServiceConnectionShouldBeMigrated() { var open = new OpenConnectionMessage("foo", new Claim[0]); var context = new ClientConnectionContext(open); Assert.False(context.IsMigrated); open.Headers = new Dictionary <string, StringValues> { { Constants.AsrsMigrateIn, "another-server" } }; context = new ClientConnectionContext(open); Assert.True(context.IsMigrated); }
public void ServiceConnectionContextRemoteIpTest(string xff, bool canBeParsed, string remoteIP) { var headers = new HeaderDictionary(new Dictionary <string, StringValues> { ["X-Forwarded-For"] = new StringValues(xff) }); Assert.Equal(canBeParsed, ClientConnectionContext.TryGetRemoteIpAddress(headers, out var address)); if (canBeParsed) { Assert.Equal(remoteIP, address.ToString()); } }
public void ServiceConnectionContextWithSystemClaimsIsUnauthenticated() { var claims = new[] { new Claim("aud", "http://localhost"), new Claim("exp", "1234567890"), new Claim("iat", "1234567890"), new Claim("nbf", "1234567890"), new Claim(Constants.ClaimType.UserId, "customUserId"), }; var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", claims)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.False(serviceConnectionContext.User.Identity.IsAuthenticated); }
public void ServiceConnectionContextWithRequestPath() { const string path = "/this/is/user/path"; var queryString = $"?{Constants.QueryParameter.OriginalPath}={WebUtility.UrlEncode(path)}"; var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", null, EmptyHeaders, queryString)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.NotNull(serviceConnectionContext.HttpContext); Assert.Equal(serviceConnectionContext.User, serviceConnectionContext.HttpContext.User); var request = serviceConnectionContext.HttpContext.Request; Assert.Empty(request.Headers); Assert.Equal(1, request.Query.Count); Assert.Equal(path, request.Query[Constants.QueryParameter.OriginalPath]); Assert.Equal(path, request.Path); }
public void ServiceConnectionContextWithNonEmptyQueries() { const string queryString = "?query1=value1&query2=value2&query3=value3"; var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", new Claim[0], EmptyHeaders, queryString)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.NotNull(serviceConnectionContext.HttpContext); Assert.Equal(serviceConnectionContext.User, serviceConnectionContext.HttpContext.User); var request = serviceConnectionContext.HttpContext.Request; Assert.Empty(request.Headers); Assert.Equal(queryString, request.QueryString.Value); Assert.Equal(3, request.Query.Count); Assert.Equal("value1", request.Query["query1"]); Assert.Equal("value2", request.Query["query2"]); Assert.Equal("value3", request.Query["query3"]); Assert.Equal(string.Empty, request.Path); }
public void ServiceConnectionContextWithClaimsCreatesIdentityWithClaims() { var claims = new[] { new Claim("k1", "v1"), new Claim("k2", "v2") }; var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", claims)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.True(serviceConnectionContext.User.Identity.IsAuthenticated); var contextClaims = serviceConnectionContext.User.Claims.ToList(); Assert.Equal("k1", contextClaims[0].Type); Assert.Equal("v1", contextClaims[0].Value); Assert.Equal("k2", contextClaims[1].Type); Assert.Equal("v2", contextClaims[1].Value); }
public void TestAllClientConnectionsCompleted() { var manager = new ClientConnectionManager(); var c1 = new ClientConnectionContext(new Protocol.OpenConnectionMessage("foo", new Claim[0])); var c2 = new ClientConnectionContext(new Protocol.OpenConnectionMessage("bar", new Claim[0])); manager.TryAddClientConnection(c1); manager.TryAddClientConnection(c2); _ = RemoveConnection(manager, c1); _ = RemoveConnection(manager, c2); var expected = manager.WhenAllCompleted(); var actual = Task.WaitAny( expected, Task.Delay(TimeSpan.FromSeconds(1)) ); Assert.Equal(0, actual); }
public void ServiceConnectionContextWithCustomNameTypeIsAuthenticated() { var claims = new[] { new Claim("aud", "http://localhost"), new Claim("exp", "1234567890"), new Claim("iat", "1234567890"), new Claim("nbf", "1234567890"), new Claim("customNameType", "customUserName"), new Claim("customRoleType", "customRole"), new Claim(Constants.ClaimType.NameType, "customNameType"), new Claim(Constants.ClaimType.RoleType, "customRoleType"), }; var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", claims)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.False(serviceConnectionContext.User.IsInRole("Admin")); Assert.True(serviceConnectionContext.User.IsInRole("customRole")); Assert.Equal("customUserName", serviceConnectionContext.User.Identity.Name); Assert.True(serviceConnectionContext.User.Identity.IsAuthenticated); }
public void ServiceConnectionContextWithNonEmptyHeaders() { const string key1 = "header-key-1"; const string key2 = "header-key-2"; const string value1 = "header-value-1"; var value2 = new[] { "header-value-2a", "header-value-2b" }; var serviceConnectionContext = new ClientConnectionContext(new OpenConnectionMessage("1", new Claim[0], new Dictionary <string, StringValues> (StringComparer.OrdinalIgnoreCase) { { key1, value1 }, { key2, value2 } }, string.Empty)); Assert.NotNull(serviceConnectionContext.User.Identity); Assert.NotNull(serviceConnectionContext.HttpContext); Assert.Equal(serviceConnectionContext.User, serviceConnectionContext.HttpContext.User); var request = serviceConnectionContext.HttpContext.Request; Assert.Equal(2, request.Headers.Count); Assert.Equal(value1, request.Headers[key1]); Assert.Equal(value2, request.Headers[key2]); Assert.Empty(request.Query); Assert.Equal(string.Empty, request.Path); }
public bool TryAddClientConnection(ClientConnectionContext connection) { throw new NotImplementedException(); }
public void AddClientConnection(ClientConnectionContext clientConnection) { throw new NotImplementedException(); }
public bool TryRemoveClientConnection(string connectionId, out ClientConnectionContext connection) { throw new NotImplementedException(); }
private async Task RemoveConnection(IClientConnectionManager manager, ClientConnectionContext ctx) { await Task.Delay(100); ctx.OnCompleted(); }
public bool TryRemoveClientConnection(string connectionId, out ClientConnectionContext connection) { connection = null; return(CurrentTransports.TryRemove(connectionId, out _)); }
public bool TryAddClientConnection(ClientConnectionContext connection) { return(_connections.TryAdd(connection.ConnectionId, connection)); }