private void ProcessMessageActions(INyxMessage msg)
{
try
{
var action = msg.Action;
var borgPlugins = _plugman.GetActions <IBorgAction>(p => p.SupportedActions.Contains(action)).ToList();
if (borgPlugins.Count == 0)
{
return;
}
var sw = Stopwatch.StartNew();
_logger.Trace("Plugins with action {0}: {1} in {2}", msg.Action, borgPlugins.Count(), _plugman.GetActions <IBorgAction>().Count());
void forAction(IBorgAction borgPlug)
{
try
{
_logger.Debug("Running action {0} for message {1} on processor {2}", msg.Action, msg, borgPlug.GetType().Name);
borgPlug.ProcessMessage(msg.AsReadOnly());
}
catch (Exception ex)
{
_logger.Error($"Error running action on {borgPlug.GetType().Name}", ex);
}
}
borgPlugins.ForEach(forAction);
_logger.Trace("Message actions took {0}ms", sw.ElapsedMilliseconds);
sw.Stop();
}
catch (Exception ex)
{
_logger.Error("Error processing actions.", ex);
}
}
/// <summary>
/// Broadcast message to the given channel(s)
/// </summary>
/// <param name="msg"></param>
public void BroadcastMessage(INyxMessage msg)
{
if (!_isStarted || _hubActor == null)
{
_logger.Warn("Hub is not started.");
return;
}
_logger.Debug("Broadcasting message to channel {0}...", StringExtensions.Trimmer(msg.Target));
((NyxMessage)msg).Direction = MessageDirection.Out;
var error = string.Empty;
try
{
var filterFound = _plugman.GetFilters(f => f.Direction.HasFlag(MessageDirection.Out) && f.CanFilter(this)).FirstOrDefault(filter => !filter.AllowMessage(msg, this, out error));
if (filterFound != null)
{
_logger.Warn("Message not sent. Was filtered by {0}. {1}", filterFound.GetType().Name, error);
return;
}
}
catch (Exception ex)
{
_logger.Error("Error filtering message.", ex);
}
_hubActor.SendMoreFrame("broadcast").SendMoreFrame(msg.Target).SendFrame(msg.ToDefault());
_outMessageStatus.OnNext(msg.AsReadOnly().SuccessfullSent(this));
}
/// <summary>
/// Allows all messages to pass, just add new info to them, or removes so they don't get into the borgs by mistake.
/// </summary>
/// <param name="message"></param>
/// <param name="sender"></param>
/// <param name="error"></param>
/// <returns></returns>
public bool AllowMessage(INyxMessage message, INyxNode sender, out string error)
{
lock (FilterLock)
{
error = string.Empty;
if (sender is INyxBorg)
{
if (message.Direction == MessageDirection.Out)
{
PrepareNodeInfo(message, sender);
}
return(true);
}
var msg = message.AsReadOnly();
// We use a queue
_tasker.QueueTask(() =>
{
try
{
RunNodeCollector(msg);
}
catch (Exception ex)
{
_logger.Error("Error processing node info.", ex);
}
});
}
return(true);
}
private MessageStatus ProcessExternalMessages(INyxMessage msg)
{
if (FilterMessage(msg))
{
return(msg.Filtered(this, "Filtered."));
}
if (msg.Direction == MessageDirection.In)
{
ProcessMessageActions(msg.AsReadOnly());
}
_messageReceived.OnNext(msg.SuccessfullReceived(this));
return(msg.SuccessfullSent(this));
}
/// <summary>
/// Override this for handling the SubSocket receive
/// </summary>
/// <param name="msg"></param>
private void ReceivedMessage(INyxMessage msg)
{
var data = string.Empty;
try
{
_logger.Trace("Received message...");
_logger.Trace("Message source: {0}", msg.Source);
if (FilterMessage(msg))
{
return;
}
// Run message processing in another thread
var readOnly = msg.AsReadOnly();
void processMessages() => ProcessMessageActions(readOnly);
if (_multithread)
{
_tasker.QueueTask(processMessages);
}
else
{
processMessages();
}
// Notify
_messageReceived.OnNext(msg.SuccessfullReceived(this));
}
catch (Exception ex)
{
_logger.Error($"Exception caught in message {data}.", ex);
}
}
public static MessageStatus SuccessfullSent(this INyxMessage msg, INyxNode sender)
{
return(new MessageStatus(sender, msg.AsReadOnly(), MessageCondition.Sent));
}
public static MessageStatus Filtered(this INyxMessage msg, INyxNode sender, string description)
{
return(new MessageStatus(sender, msg.AsReadOnly(), MessageCondition.Filtered, description));
}
