public async Task SendGroupAsyncWritesToAllConnectionsInGroupOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager = BackplaneHarness.HubLifetimeManager;
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout(Harness.TestTimeout);
await manager.OnConnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager.AddToGroupAsync(connection1.ConnectionId, "group").OrTimeout(Harness.TestTimeout);
// Because connection is local, should not have any GroupManagement
//Assert.IsFalse(backplaneConsumers.GroupManagementConsumer.Consumed.Select<GroupManagement<MyHub>>().Any());
await manager.SendGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(BackplaneHarness.Group.Consumed.Select <Group <MyHub> >().Any());
var message = client1.TryRead() as InvocationMessage;
Assert.NotNull(message);
Assert.AreEqual("Hello", message.Target);
Assert.AreEqual(1, message.Arguments.Length);
Assert.AreEqual("World", (string)message.Arguments[0]);
Assert.Null(client2.TryRead());
}
}
public async Task AddGroupAsyncForConnectionOnDifferentServerAlreadyInGroupDoesNothing()
{
using (var client = new TestClient())
{
Task <ConsumeContext <Ack <MyHub> > > ackHandler =
Harness.SubscribeHandler <Ack <MyHub> >(); // Lets us verify that the ack was sent back to our bus endpoint
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> manager2 = Backplane2Harness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager1.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
await manager2.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
Assert.IsTrue(Backplane1Harness.GroupManagement.Consumed.Select <GroupManagement <MyHub> >().Any());
ConsumeContext <Ack <MyHub> > responseContext = await ackHandler;
Assert.AreEqual(manager1.ServerName, responseContext.Message.ServerName);
await manager2.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(Backplane1Harness.Group.Consumed.Select <Group <MyHub> >().Any());
await AssertMessageAsync(client);
Assert.Null(client.TryRead());
}
}
public async Task StillSubscribedToUserAfterOneOfMultipleConnectionsAssociatedWithUserDisconnects()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
using (var client3 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> 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(Harness.TestTimeout);
await manager.OnConnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager.OnConnectedAsync(connection3).OrTimeout(Harness.TestTimeout);
await manager.SendUserAsync("userA", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
// Disconnect one connection for the user
await manager.OnDisconnectedAsync(connection1).OrTimeout(Harness.TestTimeout);
await manager.SendUserAsync("userA", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await AssertMessageAsync(client2);
}
}
public async Task SendAllAsyncDoesNotWriteToDisconnectedConnectionsOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager = BackplaneHarness.HubLifetimeManager;
var connection1 = HubConnectionContextUtils.Create(client1.Connection);
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout(Harness.TestTimeout);
await manager.OnConnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager.OnDisconnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager.SendAllAsync("Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(BackplaneHarness.All.Consumed.Select <All <MyHub> >().Any());
var message = client1.TryRead() as InvocationMessage;
Assert.NotNull(message);
Assert.AreEqual("Hello", message.Target);
Assert.AreEqual(1, message.Arguments.Length);
Assert.AreEqual("World", (string)message.Arguments[0]);
Assert.Null(client2.TryRead());
}
}
public async Task WritingToGroupWithOneConnectionFailingSecondConnectionStillReceivesMessage()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager = BackplaneHarness.HubLifetimeManager;
// Force an exception when writing to connection
var connectionMock = HubConnectionContextUtils.CreateMock(client1.Connection);
var connection1 = connectionMock;
var connection2 = HubConnectionContextUtils.Create(client2.Connection);
await manager.OnConnectedAsync(connection1).OrTimeout(Harness.TestTimeout);
await manager.AddToGroupAsync(connection1.ConnectionId, "group").OrTimeout(Harness.TestTimeout);
await manager.OnConnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager.AddToGroupAsync(connection2.ConnectionId, "group").OrTimeout(Harness.TestTimeout);
await manager.SendGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
// 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.SendGroupAsync("group", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await AssertMessageAsync(client2);
}
}
public async Task DisconnectConnectionRemovesConnectionFromGroup()
{
using (var client = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager = BackplaneHarness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
await Task.Delay(2000);
await manager.OnDisconnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await Task.Delay(2000);
await manager.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await Task.Delay(2000);
Assert.Null(client.TryRead());
}
}
public void SetHubLifetimeManager(MassTransitHubLifetimeManager <THub> hubLifetimeManager)
{
foreach (var factory in _hubManagerConsumerFactories)
{
factory.HubLifetimeManager = hubLifetimeManager;
}
HubLifetimeManager = hubLifetimeManager;
}
public async Task CamelCasedJsonIsPreservedAcrossMassTransitBoundary()
{
Harness = new InMemoryTestHarness();
var messagePackOptions = new MessagePackHubProtocolOptions();
var jsonOptions = new JsonHubProtocolOptions();
jsonOptions.PayloadSerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();
SignalRBackplaneConsumersTestHarness <MyHub> backplane1Harness = RegisterBusEndpoint("receiveEndpoint1");
SignalRBackplaneConsumersTestHarness <MyHub> backplane2Harness = RegisterBusEndpoint("receiveEndpoint2");
await Harness.Start();
try
{
backplane1Harness.SetHubLifetimeManager(CreateLifetimeManager(messagePackOptions, jsonOptions));
backplane2Harness.SetHubLifetimeManager(CreateLifetimeManager());
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager1 = backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> 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[] { new TestObject {
TestProperty = "Foo"
} }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(backplane2Harness.All.Consumed.Select <All <MyHub> >().Any());
var message = await client2.ReadAsync().OrTimeout() as InvocationMessage;
Assert.NotNull(message);
Assert.AreEqual("Hello", message.Target);
CollectionAssert.AllItemsAreInstancesOfType(message.Arguments, typeof(JObject));
var jObject = message.Arguments[0] as JObject;
Assert.NotNull(jObject);
var firstProperty = jObject.Properties().First();
Assert.AreEqual("testProperty", firstProperty.Name);
Assert.AreEqual("Foo", firstProperty.Value.Value <string>());
}
}
finally
{
await Harness.Stop();
}
}
public async Task Setup()
{
Harness = new InMemoryTestHarness();
BackplaneHarness = RegisterBusEndpoint();
await Harness.Start();
// Need the bus to be started before we can set the manager for our Consumer Factory (so it can be injected into the consumers on creation);
MassTransitHubLifetimeManager <THub> hubLifetimeManager = CreateLifetimeManager();
BackplaneHarness.SetHubLifetimeManager(hubLifetimeManager);
}
public HubLifetimeManager <THub> CreateLifetimeManager(MessagePackHubProtocolOptions messagePackOptions = null, JsonHubProtocolOptions jsonOptions = null)
{
messagePackOptions = messagePackOptions ?? new MessagePackHubProtocolOptions();
jsonOptions = jsonOptions ?? new JsonHubProtocolOptions();
var manager = new MassTransitHubLifetimeManager <THub>(
Harness.Bus,
Harness.Bus.CreateClientFactory(TimeSpan.FromSeconds(5)),
new DefaultHubProtocolResolver(new IHubProtocol[]
{
new JsonHubProtocol(Options.Create(jsonOptions)),
new MessagePackHubProtocol(Options.Create(messagePackOptions)),
}, NullLogger <DefaultHubProtocolResolver> .Instance));
return(manager);
}
public async Task RemoveGroupFromLocalConnectionNotInGroupDoesNothing()
{
using (var client = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager = BackplaneHarness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager.RemoveFromGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
Assert.IsFalse(BackplaneHarness.GroupManagement.Consumed.Select <GroupManagement <MyHub> >()
.Any()); // Should not have published, because connection was local
}
}
public async Task InvokeConnectionAsyncOnServerWithoutConnectionWritesOutputToConnection()
{
using (var client = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> manager2 = Backplane2Harness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager2.SendConnectionAsync(connection.ConnectionId, "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(Backplane1Harness.Connection.Consumed.Select <Connection <MyHub> >().Any());
await AssertMessageAsync(client);
}
}
protected MassTransitHubLifetimeManager <THub> CreateLifetimeManager(MessagePackHubProtocolOptions messagePackOptions = null,
JsonHubProtocolOptions jsonOptions = null)
{
messagePackOptions ??= new MessagePackHubProtocolOptions();
jsonOptions ??= new JsonHubProtocolOptions();
var manager = new MassTransitHubLifetimeManager <THub>(
new HubLifetimeManagerOptions <THub> {
ServerName = $"{_prefix}_{Guid.NewGuid():N}"
},
new BusHubLifetimeScopeProvider(Harness.Bus),
new DefaultHubProtocolResolver(
new IHubProtocol[] { new JsonHubProtocol(Options.Create(jsonOptions)), new MessagePackHubProtocol(Options.Create(messagePackOptions)) },
NullLogger <DefaultHubProtocolResolver> .Instance)
);
return(manager);
}
public async Task WritingToRemoteConnectionThatFailsDoesNotThrow()
{
using (var client = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> manager2 = Backplane2Harness.HubLifetimeManager;
// Force an exception when writing to connection
var connectionMock = HubConnectionContextUtils.CreateMock(client.Connection);
await manager2.OnConnectedAsync(connectionMock).OrTimeout(Harness.TestTimeout);
// This doesn't throw because there is no connection.ConnectionId on this server so it has to publish to the backplane.
// And once that happens there is no way to know if the invocation was successful or not.
await manager1.SendConnectionAsync(connectionMock.ConnectionId, "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
Assert.IsTrue(Backplane2Harness.Connection.Consumed.Select <Connection <MyHub> >().Any());
}
}
public async Task AddGroupAsyncForLocalConnectionAlreadyInGroupDoesNothing()
{
using (var client = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager = BackplaneHarness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
await manager.AddToGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
await manager.SendGroupAsync("name", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await AssertMessageAsync(client);
Assert.Null(client.TryRead());
}
}
public async Task RemoveGroupFromConnectionOnDifferentServerNotInGroupDoesNothing()
{
using (var client = new TestClient())
{
Task <ConsumeContext <Ack <MyHub> > > ackHandler =
Harness.SubscribeHandler <Ack <MyHub> >(); // Lets us verify that the ack was sent back to our bus endpoint
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> manager2 = Backplane2Harness.HubLifetimeManager;
var connection = HubConnectionContextUtils.Create(client.Connection);
await manager1.OnConnectedAsync(connection).OrTimeout(Harness.TestTimeout);
await manager2.RemoveFromGroupAsync(connection.ConnectionId, "name").OrTimeout(Harness.TestTimeout);
Assert.IsTrue(Backplane1Harness.GroupManagement.Consumed.Select <GroupManagement <MyHub> >().Any());
ConsumeContext <Ack <MyHub> > responseContext = await ackHandler;
Assert.AreEqual(manager1.ServerName, responseContext.Message.ServerName);
}
}
public async Task InvokeUserSendsToAllConnectionsForUser()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
using (var client3 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> 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(Harness.TestTimeout);
await manager.OnConnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager.OnConnectedAsync(connection3).OrTimeout(Harness.TestTimeout);
await manager.SendUserAsync("userA", "Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await AssertMessageAsync(client1);
await AssertMessageAsync(client2);
}
}
public async Task InvokeConnectionAsyncForLocalConnectionDoesNotPublishToBackplane()
{
using (var client = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> 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 InvokeAllAsyncWithMultipleServersWritesToAllConnectionsOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> 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 InvokeAllAsyncWithMultipleServersDoesNotWriteToDisconnectedConnectionsOutput()
{
using (var client1 = new TestClient())
using (var client2 = new TestClient())
{
MassTransitHubLifetimeManager <MyHub> manager1 = Backplane1Harness.HubLifetimeManager;
MassTransitHubLifetimeManager <MyHub> 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 manager2.OnDisconnectedAsync(connection2).OrTimeout(Harness.TestTimeout);
await manager2.SendAllAsync("Hello", new object[] { "World" }).OrTimeout(Harness.TestTimeout);
await AssertMessageAsync(client1);
Assert.Null(client2.TryRead());
}
}
public GroupConsumer(MassTransitHubLifetimeManager <THub> hubLifetimeManager)
{
_hubLifetimeManager = hubLifetimeManager;
}
public GroupConsumer(HubLifetimeManager <THub> hubLifetimeManager)
{
_hubLifetimeManager = hubLifetimeManager as MassTransitHubLifetimeManager <THub> ?? throw new ArgumentNullException(nameof(hubLifetimeManager), "HubLifetimeManager<> must be of type MassTransitHubLifetimeManager<>");
}
public ConnectionConsumer(MassTransitHubLifetimeManager <THub> hubLifetimeManager)
{
_hubLifetimeManager = hubLifetimeManager;
}
