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)); }