private async Task HandleGroupMessage(MsmqMessage m)
{
try
{
var groupMessage = this.protocol.ReadGroupCommand(m.Body);
var connection = this.connections[groupMessage.ConnectionId];
if (connection == null)
{
// user not on this server
return;
}
if (groupMessage.Action == GroupAction.Remove)
{
await this.RemoveGroupAsyncCore(connection, groupMessage.GroupName);
}
if (groupMessage.Action == GroupAction.Add)
{
await this.AddGroupAsyncCore(connection, groupMessage.GroupName);
}
// Send an ack to the server that sent the original command.
var ack = this.protocol.WriteAck(groupMessage.Id);
await this.msmqBus.PublishAsync(this.queues.GroupManagement(groupMessage.ServerName), ack);
}
catch (Exception ex)
{
MsmqLog.InternalMessageFailed(this.logger, ex);
}
}
private async Task EnsureMsmqServerConnection()
{
if (this.msmqChannel == null)
{
await this.connectionLock.WaitAsync();
try
{
if (this.msmqChannel == null)
{
this.msmqChannel = await this.msmqBus.SubscribeAsync(this.queues.Invocations(Environment.MachineName));
MsmqLog.Connected(this.logger);
this.msmqChannel.OnMessage(this.HandleRegularMessage);
var msmqGroupChannel = await this.msmqBus.SubscribeAsync(this.queues.GroupManagement(Environment.MachineName));
msmqGroupChannel.OnMessage(this.HandleGroupMessage);
var msmqAckChannel = await this.msmqBus.SubscribeAsync(this.queues.Ack(Environment.MachineName));
msmqAckChannel.OnMessage(this.HandleAckMessage);
}
}
catch (Exception e)
{
MsmqLog.ConnectionFailed(this.logger, e);
}
finally
{
this.connectionLock.Release();
}
}
}
private async Task HandleRegularMessage(MsmqMessage m)
{
try
{
MsmqLog.ReceivedFromChannel(this.logger, m.ChannelName);
var invocation = this.protocol.ReadInvocation(m.Body);
var tasks = new List <Task>(this.connections.Count);
foreach (var connection in this.connections)
{
if (invocation.ExcludedConnectionIds == null || !invocation.ExcludedConnectionIds.Contains(connection.ConnectionId))
{
tasks.Add(connection.WriteAsync(invocation.Message).AsTask());
}
}
await Task.WhenAll(tasks);
}
catch (Exception ex)
{
MsmqLog.FailedWritingMessage(this.logger, ex);
}
}
private Task RemoveUserAsync(HubConnectionContext connection)
{
return(this.users.RemoveSubscriptionAsync(connection.UserIdentifier, connection, channelName =>
{
MsmqLog.Unsubscribe(this.logger, "user:" + connection.UserIdentifier);
return Task.CompletedTask;
}));
}
/// <summary>
/// This takes <see cref="HubConnectionContext"/> because we want to remove the connection from the
/// _connections list in OnDisconnectedAsync and still be able to remove groups with this method.
/// </summary>
private async Task RemoveGroupAsyncCore(HubConnectionContext connection, string groupName)
{
await this.groups.RemoveSubscriptionAsync(groupName, connection, channelName =>
{
MsmqLog.Unsubscribe(this.logger, channelName);
return(Task.CompletedTask);
});
}
private async Task PublishGroupCommandAsync(byte[] payload)
{
var channels = await this.msmqBus.GetAllQueueNamesAsync();
foreach (var channel in channels.Where(x => x.StartsWith(this.queues.GroupManagement(string.Empty))))
{
MsmqLog.PublishToChannel(this.logger, channel);
await this.msmqBus.PublishAsync(channel, payload);
}
}
private async Task PublishAsync(byte[] payload)
{
await this.EnsureMsmqServerConnection();
var channels = await this.msmqBus.GetAllQueueNamesAsync();
foreach (var channel in channels.Where(x => x.StartsWith(this.queues.Invocations(string.Empty))))
{
MsmqLog.PublishToChannel(this.logger, channel);
await this.msmqBus.PublishAsync(channel, payload);
}
}
private Task HandleAckMessage(MsmqMessage m)
{
try
{
var ackId = this.protocol.ReadAck(m.Body);
this.ackHandler.TriggerAck(ackId);
}
catch (Exception ex)
{
MsmqLog.InternalMessageFailed(this.logger, ex);
}
return(Task.CompletedTask);
}
public MsmqHubLifetimeManager(
ILogger <MsmqHubLifetimeManager <THub> > logger,
IOptions <MsmqOptions> options,
IHubProtocolResolver hubProtocolResolver,
IMsmqBus msmqBus)
{
this.logger = logger;
this.options = options.Value;
this.protocol = new MsmqProtocol(hubProtocolResolver.AllProtocols);
this.msmqBus = msmqBus;
this.queues = new MsmqQueues(this.options.ApplicationName);
this.ackHandler = new AckHandler();
MsmqLog.ConnectingToEndpoints(this.logger, this.options.ConnectionString, this.options.ApplicationName);
_ = this.EnsureMsmqServerConnection();
}
public bool CanRecalculate(MsmqLog log, DateTime arrivedTime)
{
if (log != null)
{
//last recalculation was done
if (log.EndTime.HasValue)
{
//last arrivedTime is older that recalculation end time so no need of action.
if (log.EndTime.Value > arrivedTime)
{
return(false);
}
}
//last recalculation was not finished and it is the same or newer that arrived time.
else if (log.StartTime.HasValue && log.StartTime.Value >= arrivedTime)
{
return(false);
}
}
return(true);
}
