public async Task ProcessMessage(IReceivedMessage message)
{
_logger.Information(AppendingPrimaryKeyInfoToMessage("ProcessMessage() enter."));
string str = Encoding.UTF8.GetString(message.GetBody());
var msg = JsonHelper.DeserializeJsonToObject <MessageDto>(str);
if (msg.MessageDirection == MessageDirection.ToClient)
{
var clientRouterGrain = GrainFactory.GetGrain <IClientMessageRouterGrain>(Guid.NewGuid());
await clientRouterGrain.RouteMessageToClient(message);
}
if (msg.MessageDirection == MessageDirection.ToHub)
{
var hubRouterGrain = GrainFactory.GetGrain <IHubMessageRouterGrain>(Guid.NewGuid());
await hubRouterGrain.RouteMessageToHub(message);
}
if (msg.MessageDirection == MessageDirection.ToPush)
{
var pushRouterGrain = GrainFactory.GetGrain <IPushRouterGrain>(Guid.NewGuid());
await pushRouterGrain.RouteMessageToPush(message);
}
if (msg.MessageDirection == MessageDirection.ToStart)
{
var commandListenerGrain = GrainFactory.GetGrain <ICommandListenerGrain>("CommandListener");
await commandListenerGrain.StartCommandProcessorHost(ConnectionConst.AmqpConnection, msg.Message);
}
_logger.Information(string.Format("Message received: {0}", str));
}
public async Task StartEventProcessorHost(string connectionString, params string[] queueNames)
{
_logger.Information(AppendingPrimaryKeyInfoToMessage(string.Format("StartEventProcessorHost() enter. ConnectionString: {0}", connectionString)));
_orleansTaskScheduler = TaskScheduler.Current;
try
{
if (_queueListner == null)
{
var reminderName = string.Format("{0}", "keepalive");
await RegisterOrUpdateReminder(reminderName, new TimeSpan(0, 10, 0), new TimeSpan(0, 10, 0));
_queueListner = new RabbitMqQueueListener(connectionString, queueNames);
await Task.Run(() => _queueListner.Start(queueNames).WithMessageAction(queueNames, (queueName, message) =>
{
return(Task.Factory.StartNew(() =>
{
var processor = GrainFactory.GetGrain <IEventProcessorGrain>(queueName);
return processor.ProcessMessage(message);
}, CancellationToken.None, TaskCreationOptions.None, _orleansTaskScheduler));
}));
}
}
catch (RabbitMQException rabbitmqEx)
{
_logger.Error(rabbitmqEx);
}
catch (Exception ex)
{
_logger.Error(ex);
}
_logger.Information(AppendingPrimaryKeyInfoToMessage("StartEventProcessorHost() exit."));
}
public async Task RouteMessageToPush(IReceivedMessage message)
{
_logger.Information(AppendingPrimaryKeyInfoToMessage("RouteMessageToPush() enter."));
var pusher = GrainFactory.GetGrain <IMessagePushGrain>(0);
await pusher.SendMessage(message);
_logger.Information(AppendingPrimaryKeyInfoToMessage("RouteMessageToClient() exit."));
}
public async Task SendMessage(ISendMessage message, string connectionString, string exchange, string routingKey)
{
_logger.Information(AppendingPrimaryKeyInfoToMessage("RabbitMQSenderGrain.SendMessage() enter"));
using (_sender = new RabbitMqQueueSender(connectionString, exchange, routingKey))
{
await _sender.Send(message);
}
_logger.Information(AppendingPrimaryKeyInfoToMessage("RabbitMQSenderGrain.SendMessage() exit"));
}
public async Task <bool> IsCompleteAsync()
{
if (_resultValue != null)
{
_logger.Information(string.Format("IsCompleteAsync [{0}]>> Polling, DONE", _correlationId));
return(await Task.FromResult(true));
}
_logger.Information(string.Format("IsCompleteAsync [{0}]>> Polling, NOT READY", _correlationId));
return(await Task.FromResult(false));
}
public override async Task OnActivateAsync()
{
_correlationId = this.GetPrimaryKey();
_logger = OrleansLoggerSingleton.Logger;
_logger.Information(string.Format("CommandResponseGrain [{0}]>> Grain Activated", _correlationId));
await TaskDone.Done;
}
public async Task StartCommandProcessorHost(string connectionString, string deviceId)
{
_logger.Information(AppendingPrimaryKeyInfoToMessage(string.Format("StartCommandProcessorHost() enter. ConnectionString: {0}", connectionString)));
await ReadStateAsync();
_orleansTaskScheduler = TaskScheduler.Current;
try
{
string queueName;
State.DeviceMappings.TryGetValue(deviceId, out queueName);
if (string.IsNullOrEmpty(queueName))
{
State.DeviceMappings.TryAdd(deviceId, queueName);
var pusher = GrainFactory.GetGrain <IMessagePushGrain>(1);
await pusher.NotifyNewDevice(deviceId);
// State.DeviceObserverManager.Notify((observer) => observer.NotifyNewDevice(deviceId));
await WriteStateAsync();
queueName = ConnectionConst.CommandQueuePrefix + deviceId;
var _queueListner = new RabbitMqQueueListener(connectionString, queueName);
await Task.Run(() => _queueListner.Start(queueName).WithMessageAction(queueName, (message) =>
{
return(Task.Factory.StartNew(() =>
{
var processor = GrainFactory.GetGrain <IEventProcessorGrain>(queueName);
return processor.ProcessMessage(message);
}, CancellationToken.None, TaskCreationOptions.None, _orleansTaskScheduler));
}));
}
}
catch (RabbitMQException rabbitmqEx)
{
_logger.Error(rabbitmqEx);
}
catch (Exception ex)
{
_logger.Error(ex);
}
_logger.Information(AppendingPrimaryKeyInfoToMessage("StartCommandProcessorHost() exit."));
}
public async Task RouteMessageToHub(IReceivedMessage message)
{
_logger.Information(AppendingPrimaryKeyInfoToMessage("RouteMessageToClient() enter."));
var header = message.Header;
string correlationId = header.CorrelationId;
Guid correlationGuid;
if (Guid.TryParse(correlationId, out correlationGuid) == false)
{
_logger.Error("Error when parse CorrelationId: {0}", new object[] { correlationId });
await TaskDone.Done;
}
var cmdResponseGrain =
GrainFactory.GetGrain <ICommandResponseGrain <CommandResult> >(correlationGuid);
await cmdResponseGrain.SetResponseAsync("Request", message);
_logger.Information(AppendingPrimaryKeyInfoToMessage("RouteMessageToClient() exit."));
}
