Esempio n. 1
0
        public void Start()
        {
            try
            {
                isWorking = true;
                endpoint.Open();
                while (isWorking)
                {
                    List <EndpointMessage> rawMessages = new List <EndpointMessage>();
                    for (int i = 0; i < messageThreshold.Size; i++)
                    {
                        EndpointMessage rawMessage = null;
                        if (!endpoint.BlockDequeue(messageThreshold.Delay, out rawMessage))
                        {
                            break;
                        }

                        CronusMessage transportMessage = (CronusMessage)serializer.DeserializeFromBytes(rawMessage.Body);
                        var           subscribers      = subscriptions.GetInterestedSubscribers(transportMessage);
                        foreach (var subscriber in subscribers)
                        {
                            subscriber.Process(transportMessage);
                        }
                        rawMessages.Add(rawMessage);
                    }

                    endpoint.AcknowledgeAll();
                }
            }
            catch (EndpointClosedException ex)
            {
                log.DebugException("Endpoint Closed", ex);
            }
            catch (Exception ex)
            {
                log.ErrorException("Unexpected Exception.", ex);
            }
            finally
            {
                try
                {
                    endpoint.AcknowledgeAll();
                    endpoint.Close();
                }
                catch (EndpointClosedException ex)
                {
                    log.DebugException("Endpoint Closed", ex);
                }
                ScheduledStart = DateTime.UtcNow.AddMilliseconds(30);
            }
        }
Esempio n. 2
0
        public void Start()
        {
            CronusMessage transportMessage = null;

            try
            {
                isWorking = true;
                while (isWorking)
                {
                    for (int i = 0; i < messageThreshold.Size; i++)
                    {
                        transportMessage = endpoint.Dequeue(TimeSpan.FromMilliseconds(messageThreshold.Delay));
                        if (transportMessage == null)
                        {
                            break;
                        }

                        var subscribers = subscriptions.GetInterestedSubscribers(transportMessage);
                        foreach (var subscriber in subscribers)
                        {
                            subscriber.Process(transportMessage);
                        }

                        endpoint.Acknowledge(transportMessage);
                    }
                }
            }
            catch (EndpointClosedException ex)
            {
                log.DebugException("Endpoint Closed", ex);
            }
            catch (Exception ex)
            {
                log.ErrorException("Unexpected Exception.", ex);
            }
            finally
            {
                try
                {
                    if (transportMessage != null)
                    {
                        endpoint.Acknowledge(transportMessage);
                    }
                }
                catch (EndpointClosedException ex)
                {
                    log.DebugException("Endpoint Closed", ex);
                }
                ScheduledStart = DateTime.UtcNow.AddMilliseconds(30);
            }
        }
Esempio n. 3
0
        public void Start()
        {
            try
            {
                if (isRunning)
                {
                    WorkStart();
                }
                else
                {
                    WorkStop();
                }

                while (isRunning)
                {
                    CronusMessage message = GetMessage();
                    if (ReferenceEquals(null, message))
                    {
                        break;
                    }
                    try
                    {
                        var subscribers = subscriptions.GetInterestedSubscribers(message);
                        foreach (var subscriber in subscribers)
                        {
                            subscriber.Process(message);
                        }
                    }
                    catch (Exception ex)
                    {
                        log.ErrorException("Unexpected Exception.", ex);
                    }
                    finally
                    {
                        MessageConsumed(message);
                    }
                }
            }
            catch (Exception ex)
            {
                log.ErrorException("Unexpected Exception.", ex);
            }
            finally
            {
                ScheduledStart = DateTime.UtcNow.AddMilliseconds(50);
            }
        }
Esempio n. 4
0
 protected override bool PublishInternal(CronusMessage message)
 {
     subscribtions.GetInterestedSubscribers(message);
     return(true);
 }
Esempio n. 5
0
 protected override bool PublishInternal(TContract message, Dictionary <string, string> messageHeaders)
 {
     subscribtions.GetInterestedSubscribers(new CronusMessage(message, messageHeaders));
     return(true);
 }