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));
}
