public async Task InvokeGroupAsync_WritesTo_AllConnections_InGroups_Output()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = new OrleansHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <OrleansHubLifetimeManager <MyHub> >(), _fixture.ClientProvider);
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1);
await manager.OnConnectedAsync(connection2);
await manager.AddToGroupAsync(connection1.ConnectionId, "gunit");
await manager.AddToGroupAsync(connection2.ConnectionId, "tupac");
await manager.SendGroupsAsync(new string[] { "gunit", "tupac" }, "Hello", new object[] { "World" });
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
public async Task DisconnectConnectionRemovesConnectionFromGroup()
{
using (var client = new TestClient())
{
var manager = BackplaneHarness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager.OnConnectedAsync(connection).OrTimeout();
await manager.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout();
await Task.Delay(2000);
await manager.OnDisconnectedAsync(connection).OrTimeout();
await Task.Delay(2000);
await manager.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout();
Assert.Null(client.TryRead());
}
}
public async Task InvokeAllAsync_DoesNotWriteTo_DisconnectedConnections_Output()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = new OrleansHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <OrleansHubLifetimeManager <MyHub> >(), _fixture.ClientProvider);
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1);
await manager.OnConnectedAsync(connection2);
await manager.OnDisconnectedAsync(connection2);
await manager.SendAllAsync("Hello", new object[] { "World" });
await AssertMessageAsync(client1);
Assert.Null(client2.TryRead());
}
}
public async Task InvokeUserSendsToAllConnectionsForUser()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
using (var client3 = new TestClient())
{
var manager = BackplaneHarness.HubLifetimeManager;
var connection1 = HubConnectionContextUtils.Create(client1.Connection, userIdentifier: "userA");
var connection2 = HubConnectionContextUtils.Create(client2.Connection, userIdentifier: "userA");
var connection3 = HubConnectionContextUtils.Create(client3.Connection, userIdentifier: "userB");
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.OnConnectedAsync(connection3).OrTimeout();
await manager.SendUserAsync("userA", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
public async Task AddGroupAsyncForLocalConnectionAlreadyInGroupDoesNothing()
{
var server = new TestRedisServer();
var manager = CreateLifetimeManager(server);
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager.OnConnectedAsync(connection).OrTimeout();
await manager.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout();
await manager.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout();
await manager.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client);
Assert.Null(client.TryRead());
}
}
public async Task InvokeConnectionAsyncForLocalConnectionDoesNotPublishToRedis()
{
var server = new TestRedisServer();
var manager1 = CreateLifetimeManager(server);
var manager2 = CreateLifetimeManager(server);
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
// Add connection to both "servers" to see if connection receives message twice
await manager1.OnConnectedAsync(connection).OrTimeout();
await manager2.OnConnectedAsync(connection).OrTimeout();
await manager1.SendConnectionAsync(connection.ConnectionId, "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client);
Assert.Null(client.TryRead());
}
}
public async Task AddGroupAsyncForConnectionOnDifferentServerAlreadyInGroupDoesNothing()
{
var backplane = CreateBackplane();
var manager1 = CreateNewHubLifetimeManager(backplane);
var manager2 = CreateNewHubLifetimeManager(backplane);
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout();
await manager1.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout();
await manager2.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout();
await manager2.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client);
Assert.Null(client.TryRead());
}
}
public async Task InvokeAllAsyncWithMultipleServersWritesToAllConnectionsOutput()
{
var server = new TestRedisServer();
var manager1 = CreateLifetimeManager(server);
var manager2 = CreateLifetimeManager(server);
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager1.OnConnectedAsync(connection1).OrTimeout();
await manager2.OnConnectedAsync(connection2).OrTimeout();
await manager1.SendAllAsync("Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
public async Task InvokeAllAsyncWithMultipleServersDoesNotWriteToDisconnectedConnectionsOutput()
{
using (var manager1 = CreateNewHubLifetimeManager <MyHub>())
using (var manager2 = CreateNewHubLifetimeManager <MyHub>())
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager1.OnConnectedAsync(connection1).OrTimeout();
await manager2.OnConnectedAsync(connection2).OrTimeout();
await manager2.OnDisconnectedAsync(connection2).OrTimeout();
await manager2.SendAllAsync("Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
Assert.Null(client2.TryRead());
}
}
public async Task RemoveGroupAsyncForConnectionOnDifferentServerWorks()
{
using (var manager1 = CreateNewHubLifetimeManager <MyHub>())
using (var manager2 = CreateNewHubLifetimeManager <MyHub>())
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout();
await manager1.AddToGroupAsync(connection.ConnectionId, "group").OrTimeout();
await manager2.SendGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client);
await manager2.RemoveFromGroupAsync(connection.ConnectionId, "group").OrTimeout();
await manager2.SendGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout();
Assert.Null(client.TryRead());
}
}
public async Task DisconnectConnectionRemovesConnectionFromGroup()
{
var manager = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(),
Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager.OnConnectedAsync(connection).OrTimeout();
await manager.AddGroupAsync(connection.ConnectionId, "name").OrTimeout();
await manager.OnDisconnectedAsync(connection).OrTimeout();
await manager.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout();
Assert.Null(client.TryRead());
}
}
public async Task InvokeAllAsyncWritesToAllConnectionsOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(),
Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.SendAllAsync("Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
public async Task SendGroupExceptAsyncDoesNotWriteToExcludedConnections(bool fromManager)
{
var hubProxy = new HubProxy <MyHub>(_fixture.TestCluster.Client);
using (var manager = CreateNewHubLifetimeManager <MyHub>())
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
if (fromManager)
{
await manager.AddToGroupAsync(connection1.ConnectionId, "group").OrTimeout();
await manager.AddToGroupAsync(connection2.ConnectionId, "group").OrTimeout();
await manager.SendGroupExceptAsync("group", "Hello", new object[] { "World" }, new[] { connection2.ConnectionId }).OrTimeout();
}
else
{
await hubProxy.AddToGroupAsync(connection1.ConnectionId, "group").OrTimeout();
await hubProxy.AddToGroupAsync(connection2.ConnectionId, "group").OrTimeout();
await hubProxy.SendGroupExceptAsync("group", "Hello", new[] { connection2.ConnectionId }, "World").OrTimeout();
}
await AssertMessageAsync(client1);
Assert.Null(client2.TryRead());
}
}
public async Task SendGroupAsyncWillCancelWithToken()
{
using (var client1 = new TestClient(pauseWriterThreshold: 2))
{
var manager = CreateNewHubLifetimeManager();
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
await manager.OnConnectedAsync(connection1).DefaultTimeout();
await manager.AddToGroupAsync(connection1.ConnectionId, "group").DefaultTimeout();
var cts = new CancellationTokenSource();
var sendTask = manager.SendGroupAsync("group", "Hello", new object[] { "World" }, cts.Token).DefaultTimeout();
Assert.False(sendTask.IsCompleted);
cts.Cancel();
await sendTask.DefaultTimeout();
var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
connection1.ConnectionAborted.Register(t =>
{
((TaskCompletionSource)t).SetResult();
}, tcs);
await tcs.Task.DefaultTimeout();
}
}
public async Task RemoveGroupAsync_ForConnection_OnDifferentServer_Works()
{
var manager1 = new OrleansHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <OrleansHubLifetimeManager <MyHub> >(), this._fixture.ClientProvider);
var manager2 = new OrleansHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <OrleansHubLifetimeManager <MyHub> >(), this._fixture.ClientProvider);
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection);
await manager1.AddToGroupAsync(connection.ConnectionId, "snoop");
await manager2.SendGroupAsync("snoop", "Hello", new object[] { "World" });
await AssertMessageAsync(client);
await manager2.RemoveFromGroupAsync(connection.ConnectionId, "snoop");
await manager2.SendGroupAsync("snoop", "Hello", new object[] { "World" });
Assert.Null(client.TryRead());
}
}
public async Task InvokeAsync_WhenNotConnectedAfterFailedAttemptsExceeds_ShouldForceDisconnect()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = new OrleansHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <OrleansHubLifetimeManager <MyHub> >(), _fixture.ClientProvider);
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1);
var groupName = "flex";
await manager.AddToGroupAsync(connection1.ConnectionId, groupName);
await manager.AddToGroupAsync(connection2.ConnectionId, groupName);
await manager.SendGroupAsync(groupName, "Hello", new object[] { "World" });
var grain = _fixture.ClientProvider.GetClient().GetGroupGrain("MyHub", groupName);
var connectionsCount = await grain.Count();
await AssertMessageAsync(client1);
Assert.Equal(2, connectionsCount);
await manager.SendGroupAsync(groupName, "Hello", new object[] { "World" });
await manager.SendGroupAsync(groupName, "Hello", new object[] { "World" });
await Task.Delay(1);
connectionsCount = await grain.Count();
Assert.Equal(1, connectionsCount);
}
}
public async Task InvocationsFromDifferentServersUseUniqueIDs()
{
var backplane = CreateBackplane();
var manager1 = CreateNewHubLifetimeManager(backplane);
var manager2 = CreateNewHubLifetimeManager(backplane);
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager1.OnConnectedAsync(connection1).DefaultTimeout();
await manager2.OnConnectedAsync(connection2).DefaultTimeout();
var invoke1 = manager1.InvokeConnectionAsync <int>(connection2.ConnectionId, "Result", new object[] { "test" });
var invocation2 = Assert.IsType <InvocationMessage>(await client2.ReadAsync().DefaultTimeout());
var invoke2 = manager2.InvokeConnectionAsync <int>(connection1.ConnectionId, "Result", new object[] { "test" });
var invocation1 = Assert.IsType <InvocationMessage>(await client1.ReadAsync().DefaultTimeout());
Assert.NotEqual(invocation1.InvocationId, invocation2.InvocationId);
await manager1.SetConnectionResultAsync(connection2.ConnectionId, CompletionMessage.WithResult(invocation2.InvocationId, 2)).DefaultTimeout();
await manager2.SetConnectionResultAsync(connection1.ConnectionId, CompletionMessage.WithResult(invocation1.InvocationId, 5)).DefaultTimeout();
var res = await invoke1.DefaultTimeout();
Assert.Equal(2, res);
res = await invoke2.DefaultTimeout();
Assert.Equal(5, res);
}
}
public async Task WritingToGroupWithOneConnectionFailingSecondConnectionStillReceivesMessage()
{
var manager = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(), Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
// Force an exception when writing to connection
var writer = new Mock <ChannelWriter <HubMessage> >();
writer.Setup(o => o.WaitToWriteAsync(It.IsAny <CancellationToken>())).Throws(new Exception());
var connection1 = HubConnectionContextUtils.Create(client1.Connection, new MockChannel(writer.Object));
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.AddGroupAsync(connection1.ConnectionId, "group");
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.AddGroupAsync(connection2.ConnectionId, "group");
await manager.InvokeGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout();
// connection1 will throw when receiving a group message, we are making sure other connections
// are not affected by another connection throwing
await AssertMessageAsync(client2);
// Repeat to check that group can still be sent to
await manager.InvokeGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client2);
}
}
public async Task ClientDisconnectsWithoutCompletingClientResultOnSecondServer()
{
var backplane = CreateBackplane();
var manager1 = CreateNewHubLifetimeManager(backplane);
var manager2 = CreateNewHubLifetimeManager(backplane);
using (var client1 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
await manager2.OnConnectedAsync(connection1).DefaultTimeout();
var invoke1 = manager1.InvokeConnectionAsync <int>(connection1.ConnectionId, "Result", new object[] { "test" });
var invocation = Assert.IsType <InvocationMessage>(await client1.ReadAsync().DefaultTimeout());
connection1.Abort();
await manager2.OnDisconnectedAsync(connection1).DefaultTimeout();
// Server should propogate connection closure so task isn't blocked
var ex = await Assert.ThrowsAsync <Exception>(() => invoke1).DefaultTimeout();
Assert.Equal("Connection disconnected.", ex.Message);
}
}
public async Task InvokeAllAsyncWithMultipleServersDoesNotWriteToDisconnectedConnectionsOutput()
{
var manager1 = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(),
Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
var manager2 = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(),
Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager1.OnConnectedAsync(connection1).OrTimeout();
await manager2.OnConnectedAsync(connection2).OrTimeout();
await manager2.OnDisconnectedAsync(connection2).OrTimeout();
await manager2.InvokeAllAsync("Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
await connection1.DisposeAsync().OrTimeout();
await connection2.DisposeAsync().OrTimeout();
Assert.Null(client2.TryRead());
}
}
public async Task InvokeConnectionAsyncOnServerWithoutConnectionWritesOutputToConnection()
{
var manager1 = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(),
Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
var manager2 = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(),
Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout();
await manager2.InvokeConnectionAsync(connection.ConnectionId, "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client);
}
}
public async Task InvokeConnectionAsyncForLocalConnectionDoesNotPublishToBackplane()
{
using (var client = new TestClient())
{
var manager1 = Backplane1Harness.HubLifetimeManager;
var manager2 = Backplane2Harness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
// Add connection to both "servers" to see if connection receives message twice
await manager1.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager2.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager1.SendConnectionAsync(connection.ConnectionId, "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsFalse(Backplane1Harness.Connection.Consumed.Select <Connection <MyHub> >().Any());
Assert.IsFalse(Backplane2Harness.Connection.Consumed.Select <Connection <MyHub> >().Any());
await AssertMessageAsync(client);
Assert.Null(client.TryRead());
}
}
public async Task AddGroupAsyncForConnectionOnDifferentServerWorks()
{
var manager1 = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(), Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
var manager2 = new RedisHubLifetimeManager <MyHub>(new LoggerFactory().CreateLogger <RedisHubLifetimeManager <MyHub> >(), Options.Create(new RedisOptions()
{
Factory = t => new TestConnectionMultiplexer()
}));
using (var client = new TestClient())
{
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout();
await manager2.AddGroupAsync(connection.ConnectionId, "name").OrTimeout();
await manager2.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client);
}
}
public async Task InvokeAllAsyncWithMultipleServersWritesToAllConnectionsOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager1 = Backplane1Harness.HubLifetimeManager;
var manager2 = Backplane2Harness.HubLifetimeManager;
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager1.OnConnectedAsync(connection1).OrTimeout(Harness.TestTimeout);
await manager2.OnConnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager1.SendAllAsync("Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(Backplane1Harness.All.Consumed.Select <All <MyHub> >().Any());
Assert.IsTrue(Backplane2Harness.All.Consumed.Select <All <MyHub> >().Any());
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
public async Task InvokeAllAsyncDoesNotWriteToDisconnectedConnectionsOutput()
{
var server = new TestRedisServer();
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = CreateLifetimeManager(server);
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.OnDisconnectedAsync(connection2).OrTimeout();
await manager.SendAllAsync("Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
Assert.Null(client2.TryRead());
}
}
public async Task InvokeGroupAsyncWritesToAllConnectionsInGroupOutput()
{
var server = new TestRedisServer();
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var manager = CreateLifetimeManager(server);
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
await manager.AddGroupAsync(connection1.ConnectionId, "gunit").OrTimeout();
await manager.SendGroupAsync("gunit", "Hello", new object[] { "World" }).OrTimeout();
await AssertMessageAsync(client1);
Assert.Null(client2.TryRead());
}
}
public async Task SendGroupAsyncWritesToAllConnectionsInGroupsOutput(bool fromManager)
{
var hubProxy = new HubProxy <MyHub>(_fixture.TestCluster.Client);
using (var manager = CreateNewHubLifetimeManager <MyHub>())
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout();
await manager.OnConnectedAsync(connection2).OrTimeout();
if (fromManager)
{
await manager.AddToGroupAsync(connection1.ConnectionId, "group").OrTimeout();
await manager.AddToGroupAsync(connection2.ConnectionId, "group2").OrTimeout();
await manager.SendGroupsAsync(new[] { "group", "group2" }, "Hello", new object[] { "World" }).OrTimeout();
}
else
{
await hubProxy.AddToGroupAsync(connection1.ConnectionId, "group").OrTimeout();
await hubProxy.AddToGroupAsync(connection2.ConnectionId, "group2").OrTimeout();
await hubProxy.SendGroupsAsync(new[] { "group", "group2" }, "Hello", "World").OrTimeout();
}
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
protected override Task ExecuteAsync(CancellationToken stoppingToken)
{
stoppingToken.Register(async() =>
{
foreach (var item in clientDisposables.Values)
{
item.Dispose();
}
foreach (var item in testClients.Values)
{
item.Abort();
}
foreach (var item in managers.Values)
{
item.Dispose();
}
await _testCluster.Client.Close();
_logger.LogInformation(2, "stopped.");
});
Observable.FromAsync(() => Console.In.ReadLineAsync())
.Repeat()
.Where(value => !string.IsNullOrEmpty(value))
.Select(value => value.Split(' '))
.SubscribeOn(TaskPoolScheduler.Default)
.Subscribe(async(string[] value) =>
{
await Task.CompletedTask;
try
{
switch (value[0])
{
case "m":
{
var managerId = value[1];
var groupPartitioner = new DefaultClientSetPartitioner <IGroupPartitionGrain>();
var userPartitioner = new DefaultClientSetPartitioner <IUserPartitionGrain>();
managers[managerId] = new OrleansHubLifetimeManager <SampleHub>(Options.Create(new OrleansOptions <SampleHub> {
ClusterClient = _testCluster.Client
}),
groupPartitioner,
userPartitioner,
new DefaultUserIdProvider(),
_loggerFactory.CreateLogger <OrleansHubLifetimeManager <SampleHub> >());
groupPartitioners[managerId] = groupPartitioner;
userPartitioners[managerId] = userPartitioner;
}
break;
case "dm":
{
var managerId = value[1];
managers[managerId].Dispose();
}
break;
case "sa":
{
var managerId = value[1];
await managers[managerId].SendAllAsync("Hello", new object[] { "World" });
}
break;
case "sg":
{
var managerId = value[1];
var groupName = value[2];
await managers[managerId].SendGroupAsync(groupName, "Hello", new object[] { "World" });
}
break;
case "atg":
{
var managerId = value[1];
var connectionId = value[2];
var groupName = value[3];
await managers[managerId].AddToGroupAsync(testClients[connectionId].ConnectionId, groupName);
}
break;
case "rfg":
{
var managerId = value[1];
var connectionId = value[2];
var groupName = value[3];
await managers[managerId].RemoveFromGroupAsync(testClients[connectionId].ConnectionId, groupName);
}
break;
case "c":
{
var managerId = value[1];
var connectionId = value[2];
var userId = value[3];
var client = new TestClient(userIdentifier: userId);
var connection = HubConnectionContextUtils.Create(client.Connection);
testClients[connectionId] = connection;
await managers[managerId].OnConnectedAsync(connection);
var disposable = Observable.Repeat(Observable.FromAsync(() => client.ReadAsync()))
.ObserveOn(TaskPoolScheduler.Default)
.Subscribe(message =>
{
var _message = message as InvocationMessage;
_logger.LogInformation($"Method {_message.Target}, Args {JsonConvert.SerializeObject(_message.Arguments)}");
});
clientDisposables[connectionId] = disposable;
}
break;
case "ga":
{
var managerId = value[1];
var result2 = await groupPartitioners[managerId].GetAllClientSetIdsAsync(_testCluster.Client, typeof(SampleHub).GUID);
var result3 = await userPartitioners[managerId].GetAllClientSetIdsAsync(_testCluster.Client, typeof(SampleHub).GUID);
_logger.LogInformation($"GroupNames: {JsonConvert.SerializeObject(result2)}, " +
$"UserIds: {JsonConvert.SerializeObject(result3)}");
}
break;
case "dc":
{
var managerId = value[1];
var connectionId = value[2];
await managers[managerId].OnDisconnectedAsync(testClients[connectionId]);
}
break;
//case "sr":
// {
// var range = RangeFactory.CreateRange(uint.Parse(value[1]), uint.Parse(value[2]));
// var subRanges = RangeFactory.GetSubRanges(range);
// _logger.LogInformation($"subRanges: {JsonConvert.SerializeObject(subRanges)}");
// //var id = Utils.CalculateIdHash(value[1]);
// //_logger.LogInformation($"id: {id}");
// }
// break;
//case "ifr":
// {
// var fullRange = RangeFactory.CreateFullRange();
// _logger.LogInformation($"{value[1]} in full range: {fullRange.InRange(uint.Parse(value[1]))}");
// }
// break;
//case "ir":
// {
// var range = RangeFactory.CreateRange(uint.Parse(value[1]), uint.Parse(value[2]));
// _logger.LogInformation($"{value[3]} in range: {range.InRange(uint.Parse(value[3]))}");
// }
// break;
default:
break;
}
}
catch (Exception e)
{
_logger.LogError(e, "Exception onNext.");
}
},
error => _logger.LogError(error, "OnError."),
() => _logger.LogInformation("OnCompleted."));
return(Task.CompletedTask);
}
public static HubConnectionContext CreateConnection(this TestClient testClient, IHubProtocol protocol = null, string userIdentifier = null)
{
return(HubConnectionContextUtils.Create(testClient.Connection, protocol, userIdentifier));
}
