protected override IList <string> GetSignals(string userId, string connectionId)
{
var signals = _hubs.SelectMany(info =>
{
var items = new List <string>
{
PrefixHelper.GetHubName(info.Name),
PrefixHelper.GetHubConnectionId(info.CreateQualifiedName(connectionId)),
};
if (!String.IsNullOrEmpty(userId))
{
items.Add(PrefixHelper.GetHubUserId(info.CreateQualifiedName(userId)));
}
return(items);
})
.Concat(new[]
{
PrefixHelper.GetConnectionId(connectionId),
PrefixHelper.GetAck(connectionId)
});
return(signals.ToList());
}
internal static Task Ack(this IMessageBus bus, string acker, string waiter, string commandId)
{
// Prepare the ack
var message = new Message(acker, PrefixHelper.GetAck(waiter), null);
message.CommandId = commandId;
message.IsAck = true;
return(bus.Publish(message));
}
private IList <string> GetDefaultSignals(string userId, string connectionId)
{
// The list of default signals this connection cares about:
// 1. The default signal (the type name)
// 2. The connection id (so we can message this particular connection)
// 3. Ack signal
return(new string[] {
DefaultSignal,
PrefixHelper.GetConnectionId(connectionId),
PrefixHelper.GetAck(connectionId)
});
}
protected override IList <string> GetSignals(string connectionId)
{
return(_hubs.SelectMany(info => new[] { PrefixHelper.GetHubName(info.Name), PrefixHelper.GetHubConnectionId(info.CreateQualifiedName(connectionId)) })
.Concat(new[] { PrefixHelper.GetConnectionId(connectionId), PrefixHelper.GetAck(connectionId) })
.ToList());
}
public void AcksAreSentToCommandSource()
{
// Arrange
var waitCommand = new Command {
WaitForAck = true
};
var ackerId = "acker";
var waiterId = "waiter";
var messageId = "messageId";
var maxMessages = 1;
var ackHandler = new Mock <IAckHandler>();
ackHandler.Setup(m => m.TriggerAck(waitCommand.Id)).Returns(false);
var messageBus = new Mock <IMessageBus>();
Message waitMessage = null;
Message ackMessage = null;
messageBus.Setup(m => m.Publish(It.IsAny <Message>())).Returns <Message>(m =>
{
if (m.WaitForAck)
{
waitMessage = m;
}
else if (m.IsAck)
{
ackMessage = m;
}
return(TaskAsyncHelper.Empty);
});
var loggerFactory = new Mock <ILoggerFactory>();
var counters = new PerformanceCounterManager(loggerFactory.Object);
var serializer = JsonUtility.CreateDefaultSerializer();
var waiterConnection = new Connection(messageBus.Object,
serializer,
"signal",
waiterId,
new string[] { },
new string[] { },
loggerFactory.Object,
ackHandler.Object,
counters,
new Mock <IProtectedData>().Object,
new MemoryPool());
// Act
waiterConnection.Send(ackerId, waitCommand);
// Assert
Assert.NotNull(waitMessage);
Assert.Equal(waiterId, waitMessage.Source);
Assert.Equal(PrefixHelper.GetConnectionId(ackerId), waitMessage.Key);
// Arrange some more now that we have a waitMessage
var messages = new List <ArraySegment <Message> >()
{
new ArraySegment <Message>(new[] { waitMessage })
};
var messageResult = new MessageResult(messages, 1);
var ackerConnection = new Connection(messageBus.Object,
serializer,
"signal",
ackerId,
new string[] { },
new string[] { },
loggerFactory.Object,
ackHandler.Object,
counters,
new Mock <IProtectedData>().Object,
new Mock <IMemoryPool>().Object);
ackerConnection.WriteCursor = _ => { };
messageBus.Setup(m => m.Subscribe(ackerConnection,
messageId,
It.IsAny <Func <MessageResult, object, Task <bool> > >(),
maxMessages,
It.IsAny <object>()))
.Callback <ISubscriber,
string,
Func <MessageResult, object, Task <bool> >,
int,
object>((subsciber, cursor, callback, max, state) =>
{
callback(messageResult, state);
});
// Act
ackerConnection.Receive(messageId, (_, __) => TaskAsyncHelper.False, maxMessages, null);
// Assert
Assert.NotNull(ackMessage);
Assert.Equal(ackerId, ackMessage.Source);
Assert.Equal(PrefixHelper.GetAck(waiterId), ackMessage.Key);
}
