public bool NeedToHandleMessage(MessageEx message) { if (_accountCollection.GetOrCreate(message.AccountTag).Profiles.Any()) { return true; } var conditionalMessageRouter = ObjectFactory.TryGetInstance<ITargetProcessConditionalMessageRouter>(); return conditionalMessageRouter != null && conditionalMessageRouter.Handle(message); }
public bool Handle(MessageEx message) { return message.AccountTag != AccountName.Empty; }
private bool OnFailedMessageProcessing(MessageEx message) { try { if (FailedMessageProcessing != null) { FailedMessageProcessing(this, null); } } catch (Exception e) { Logger.Warn(LoggerContext.New(message.MessageOrigin.Name), "Failed raising 'failed message processing' event.", e); return false; } return true; }
private bool OnTransportMessageReceived(TransportMessage msg, MessageEx origin) { try { if (TransportMessageReceived != null) { TransportMessageReceived(this, new TransportMessageReceivedEventArgs(msg)); } Logger.Debug(LoggerContext.New(origin.MessageOrigin.Name, msg), "Transport message received"); } catch (Exception e) { Logger.Warn(LoggerContext.New(origin.MessageOrigin.Name, msg), "Failed raising 'transport message received' event for message with ID=" + msg.Id, e); return false; } return true; }
/// <summary> /// Moves the given message to the configured error queue. /// </summary> /// <param name="message"></param> protected void MoveToErrorQueue(MessageEx message) { var m = message.Message; m.Label = m.Label + string.Format("<{0}>{1}</{0}><{2}>{3}<{2}>", FAILEDQUEUE, message.MessageOrigin.Name, ORIGINALID, m.Id); if (_errorQueue != null) { _errorQueue.Send(m, MessageQueueTransactionType.Single); } }
private void ProcessMessage(MessageEx message) { var m = message.Message; _messageId = m.Id; if (IsTransactional) { if (HandledMaxRetries(m.Id)) { Logger.Error(LoggerContext.New(message.MessageOrigin.Name), string.Format("Message has failed the maximum number of times allowed, ID={0}.", m.Id)); MoveToErrorQueue(message); return; } } //exceptions here will cause a rollback - which is what we want. if (StartedMessageProcessing != null) { StartedMessageProcessing(this, null); } TransportMessage result = Convert(m); if (SkipDeserialization) { result.BodyStream = m.BodyStream; } else { try { result.Body = Extract(m); } catch (TypeNotFoundWhileDeserializationException e) { Logger.Warn(LoggerContext.New(message.MessageOrigin.Name, result), "Could not extract message data.", e); OnFinishedMessageProcessing(message); return; } catch (Exception e) { Logger.Error(LoggerContext.New(message.MessageOrigin.Name, result), "Could not extract message data.", e); MoveToErrorQueue(message); OnFinishedMessageProcessing(message); // don't care about failures here return; } } //care about failures here var exceptionNotThrown = OnTransportMessageReceived(result, message); //and here var otherExNotThrown = OnFinishedMessageProcessing(message); //but need to abort takes precedence - failures aren't counted here, //so messages aren't moved to the error queue. if (_needToAbort) { throw new AbortHandlingCurrentMessageException(); } if (!(exceptionNotThrown && otherExNotThrown)) //cause rollback { throw new ApplicationException("Exception occured while processing message."); } }
private void ReceiveFromQueue(MessageEx message, Action<MessageEx> processMessageAction) { var m = message.Message; if (m == null) { Logger.Info(LoggerContext.New(message.MessageOrigin.Name), string.Format("Peek returned null message.")); return; } message.DoReceive(); processMessageAction(message); }
private void Handle(MessageEx message) { _needToAbort = false; _messageId = string.Empty; try { if (IsTransactional) { new TransactionWrapper().RunInTransaction(() => ReceiveFromQueue(message, ProcessMessage), IsolationLevel, TransactionTimeout); ClearFailuresForMessage(_messageId); } else { ReceiveFromQueue(message, ProcessMessage); } } catch (AbortHandlingCurrentMessageException) { //in case AbortHandlingCurrentMessage was called return; } catch (Exception e) { Logger.Warn(LoggerContext.New(message.MessageOrigin.Name), "Failed to process message.", e); if (IsTransactional) { IncrementFailuresForMessage(_messageId); } OnFailedMessageProcessing(message); } }
private void HandleAsync(MessageEx message) { _messageId = string.Empty; ReceiveFromQueue(message, m => ThreadPool.QueueUserWorkItem(state => { try { ProcessMessage(m); } catch (Exception e) { Logger.Warn(LoggerContext.New(message.MessageOrigin.Name), "Failed to process message.", e); OnFailedMessageProcessing(message); } })); }
private string GetQueueNameToRouteMessageIn(MessageEx m) { string accountName = m.AccountTag; return string.IsNullOrEmpty(accountName) ? null : GetQueueName(accountName); }
private void HandleAsync(MessageEx message) { _messageId = string.Empty; ReceiveFromQueue(message, m => ThreadPool.QueueUserWorkItem(state => { try { ProcessMessage(m); } catch { OnFailedMessageProcessing(message); } })); }
private string GetQueueNameToRouteMessageIn(MessageEx m) { string name = MessageAccountParser.Instance.Parse(m.Message).Name; return string.IsNullOrEmpty(name) ? null : InputQueue + "." + name; }