Пример #1
0
        void consumeMessages()
        {
            MessageProcessor processor = new MessageProcessor();

            foreach (Message message in blockingCollection.GetConsumingEnumerable())
            {
                Logger.Current.Informational("Processing message:" + message.MessageId);
                MessageHandlerStatus status = processor.Process(message);
                if (status == MessageHandlerStatus.LeadScoreAuditedSuccessfully)
                {
                    client.Complete(message.LockToken);
                    Logger.Current.Informational("Processed message, marked as complete:" + message.MessageId);
                }
                else if (status == MessageHandlerStatus.LeadScoreRuleNotDefined)
                {
                    client.Complete(message.LockToken);
                    Logger.Current.Informational("Rule not defined for this message, marked as complete:" + message.MessageId);
                }
                else if (status == MessageHandlerStatus.InvalidMessageHandler)
                {
                    client.Complete(message.LockToken);
                    Logger.Current.Informational("Handler not defined for this message, marked as complete:" + message.MessageId);
                }
                else if (status == MessageHandlerStatus.DuplicateLeadScoreRequest)
                {
                    client.Complete(message.LockToken);
                    Logger.Current.Informational("A duplicate lead score request, marked as complete:" + message.MessageId);
                }
                else if (status == MessageHandlerStatus.FailedToAuditScore)
                {
                    client.Abandon(message.LockToken);
                    Logger.Current.Informational("Failed to process this message, Abandoned message to fall back in the queue:" + message.MessageId);
                }
            }
        }
Пример #2
0
        void consumeMessage(Message message)
        {
            var sw = new System.Diagnostics.Stopwatch();

            sw.Start();
            try
            {
                Dictionary <int, bool>           canComplete = new Dictionary <int, bool>();
                IEnumerable <AutomationWorkflow> workflows   = getMatchedWorkflows(message);

                foreach (AutomationWorkflow workflow in workflows)
                {
                    if (canComplete.ContainsKey(workflow.WorkflowId))
                    {
                        continue;
                    }
                    var result = workflow.ProcessMessage(message, workflow.WorkflowId);

                    if (result == WorkflowStateTransitionStatus.TransitedSuccessfully || result == WorkflowStateTransitionStatus.TransitionDelayed)
                    {
                        var removeFromWorkflows = workflowService.IsEnrolledToRemove(new IsEnrolledToRemoveRequest()
                        {
                            WorkflowId = workflow.WorkflowId
                        }).WorkflowIds;
                        if (removeFromWorkflows != null && removeFromWorkflows.Any())
                        {
                            Dictionary <int, bool> canEnter = new Dictionary <int, bool>();
                            foreach (var id in removeFromWorkflows)
                            {
                                //var startTriggers = automationWorkflows.Values.Where(w => w.WorkflowId == id).SelectMany(s => s.allowedTriggers);
                                //var entries = startTriggers.Where(k => k.Value);
                                //if (entries.Count() > 0)
                                canEnter.Add(id, false);
                                //else
                                //canEnter.Add(id, true);
                            }
                            if (canEnter.Any(d => d.Value == false))
                            {
                                canComplete.Add(workflow.WorkflowId, true);
                                continue;
                            }
                        }
                    }

                    if (result == WorkflowStateTransitionStatus.TransitedSuccessfully || result == WorkflowStateTransitionStatus.UnAuthorizedTransition ||
                        result == WorkflowStateTransitionStatus.TransitionDelayed || result == WorkflowStateTransitionStatus.TransitionFailed)
                    {
                        canComplete.Add(workflow.WorkflowId, true);
                    }
                    else
                    {
                        canComplete.Add(workflow.WorkflowId, false);
                    }
                }

                if (canComplete.All(d => d.Value == true))
                {
                    sw.Stop();
                    var te = sw.Elapsed;

                    if (!(message.LockToken.ToString() == "00000000-0000-0000-0000-000000000000"))
                    {
                        client.Complete(message.LockToken);
                    }
                    Logger.Current.Verbose("Marked the message as complete, messageid:" + message.MessageId + " Time taken : " + te.TotalMilliseconds);
                }
            }
            catch (Exception ex)
            {
                sw.Stop();
                var te = sw.Elapsed;

                client.Abandon(message.LockToken);
                Logger.Current.Error("Exception occurred while consuming the message:" + message.ToString() + "Time taken to process the message : " + te.TotalMilliseconds, ex);
            }
        }