public async Task HandleMessage(Guid clientId, NanoPublishMessage nanoPublishMessage)
{
var tasks = new List <Task>();
NanoMessage publishMessage = null;
List <NanoHandler> nanoSubscribers;
if (nanoPublishMessage.NanoDocumentId != NanoDocumentId.Empty)
{
if (_handlersByDocumentId.TryGetValue(nanoPublishMessage.NanoDocumentId, out nanoSubscribers))
{
publishMessage = nanoPublishMessage.ToNewPublishMessage();
//TODO: find a solution elliminating where condition...
tasks.AddRange(nanoSubscribers.AsSnapshot().Where(a => a.ClientId != clientId).Select(subscriber => subscriber.HandleMessageAsync(publishMessage)));
}
}
if (_handlersByDocumentId.TryGetValue(NanoDocumentId.Empty, out nanoSubscribers))
{
publishMessage = publishMessage ?? nanoPublishMessage.ToNewPublishMessage();
//TODO: find a solution elliminating where condition...
tasks.AddRange(nanoSubscribers.AsSnapshot().Where(a => a.ClientId != clientId).Select(subscriber => subscriber.HandleMessageAsync(publishMessage)));
}
await TaskHelpers.Iterate(tasks);
}
public async Task PublishAsync <TMessage>(TMessage message) where TMessage : IDomainMessage <TDocument>
{
var nanoMessage = NanoMessage.CreatePublishMessage <TDocument, TMessage>(NanoBusClient.ClientId, message, false);
EnqueueMessage(nanoMessage);
//distribute local callbacks without server roundtrip
await Task.Run(() => NanoBusClient.DistributePublishMessageAsync(nanoMessage.PublishMessage).ConfigureAwait(false));
}
private async Task OnReceivedNanoMessageAsync(NanoMessage nanoMessage)
{
Interlocked.Increment(ref _rxCount);
if (nanoMessage.PublishMessage != null)
{
await OnReceivedPublishMessageAsync(nanoMessage.PublishMessage);
}
if (nanoMessage.IsAckRequested)
{
EnqueueMessage(nanoMessage.CreateAckMessage(0));
}
}
private INanoSubscription CreateSubscription <TMessage>(NanoSubsciptionKey subscriptionKey) where TMessage : IDomainMessage <TDocument>
{
if (_messageTypeMap.TryAdd(typeof(TMessage).FullName, typeof(TMessage)))
{
var subscription = new NanoSubscription <TDocument, TMessage>();
var nanoMessage = NanoMessage.CreateSubscribeMessage <TDocument, TMessage>(NanoBusClient.ClientId, subscriptionKey.NanoDocumentId);
EnqueueMessage(nanoMessage);
return(subscription);
}
;
throw new InvalidOperationException();
}
private async Task OnNanoMessageAsync(NanoMessage nanoMessage)
{
Interlocked.Increment(ref _rxCount);
if (nanoMessage.PublishMessage != null)
{
await PublishAsync(nanoMessage.ClientId, nanoMessage.PublishMessage).ConfigureAwait(false);
}
if (nanoMessage.SubscribeMessage != null)
{
Subscribe(nanoMessage.ClientId, nanoMessage.SubscribeMessage);
}
if (nanoMessage.IsAckRequested)
{
EnqueueMessage(nanoMessage.CreateAckMessage(0));
}
}
public Task HandleMessageAsync(NanoMessage nanoMessage)
{
return(_onMessage(nanoMessage));
}
public void EnqueueMessage(NanoMessage nanoMessage)
{
_txQueue.Enqueue(nanoMessage);
_txEvent.Set();
}
private Task EnqueueMessageAsync(NanoMessage message)
{
EnqueueMessage(message);
return(TaskHelpers.Completed());
}
private void EnqueueMessage(NanoMessage nanoMessage)
{
_nanoBusClient.NanoConnections.Next().EnqueueMessage(nanoMessage);
}
