Пример #1
0
        public IEnumerable <HistoryMessage> GetAllProcessedMessages(int?batchSize = null)
        {
            int count      = 0;
            var enumerator = _messageHistory.GetEnumerator();

            while (enumerator.MoveNext() && count++ != batchSize)
            {
                var bookmark = enumerator.Current;
                bookmark.QueueName = _queueName;
                yield return(_messageHistory.ReadMessageWithId <HistoryMessage>(bookmark, _queueName, x =>
                {
                    x.MovedToHistoryAt = _messageHistory.ForColumnType <DateTimeColumn>().Get("moved_to_history_at");
                }));
            }
        }
Пример #2
0
        public PersistentMessage Dequeue(string subqueue)
        {
            var enumerator = _messages.GetEnumerator(new StringValueIndex("by_sub_queue", subqueue));

            while (enumerator.MoveNext())
            {
                var id     = _messages.GetMessageId();
                var status = (MessageStatus)_messages.ForColumnType <IntColumn>().Get("status");

                _logger.Debug("Scanning incoming message {2} on '{0}/{1}' with status {3}",
                              _queueName, subqueue, id, status);

                if (status != MessageStatus.ReadyToDeliver)
                {
                    continue;
                }

                try
                {
                    _messages.Update(() => _messages.ForColumnType <IntColumn>().Set("status", (int)MessageStatus.Processing));
                }
                catch (EsentErrorException e)
                {
                    _logger.Debug("Write conflict on '{0}/{1}' for {2}, skipping message",
                                  _queueName, subqueue, id);
                    if (e.Error == JET_err.WriteConflict)
                    {
                        continue;
                    }
                    throw;
                }
                var bookmark = enumerator.Current;
                bookmark.QueueName = _queueName;
                _changeNumberOfMessages(-1);

                _logger.Debug("Dequeuing message {2} from '{0}/{1}'",
                              _queueName, subqueue, id);

                return(_messages.ReadMessageWithId <PersistentMessage>(bookmark, _queueName, x =>
                {
                    x.SubQueue = subqueue;
                }));
            }

            return(null);
        }
Пример #3
0
        internal void ClearTable(EsentTable table)
        {
            var enumerator = table.GetEnumerator();

            while (enumerator.MoveNext())
            {
                table.Delete();
            }
        }
Пример #4
0
        private string[] GetSubqueues(string queueName)
        {
            var list       = new List <string>();
            var enumerator = subqueues.GetEnumerator(new StringValueIndex("by_queue", queueName));

            while (enumerator.MoveNext())
            {
                list.Add(subqueues.ForColumnType <StringColumn>().Get("subqueue"));
            }

            return(list.ToArray());
        }
Пример #5
0
        public QueueActions GetQueue(string queueName)
        {
            QueueActions actions;

            if (queuesByName.TryGetValue(queueName, out actions))
            {
                return(actions);
            }

            var enumerator = queues.GetEnumerator(new StringValueIndex("pk", queueName));

            if (!enumerator.MoveNext())
            {
                throw new QueueDoesNotExistsException(queueName);
            }

            queuesByName[queueName] = actions =
                new QueueActions(session, dbid, queueName, GetSubqueues(queueName), this,
                                 i => AddToNumberOfMessagesIn(queueName, i));
            return(actions);
        }