Пример #1
0
        public override void StartWorking(Func <QueueEntry <T>, CancellationToken, Task> handler, bool autoComplete = false, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            // TODO: use the cancellation token.

            _queueClient.OnMessageAsync(async message => {
                Interlocked.Increment(ref _dequeuedCount);
                var data = message.GetBody <T>();

                var workItem = new QueueEntry <T>(message.LockToken.ToString(), data, this, message.EnqueuedTimeUtc, message.DeliveryCount);
                try {
                    await handler(workItem, cancellationToken).AnyContext();
                    if (autoComplete)
                    {
                        await workItem.CompleteAsync().AnyContext();
                    }
                } catch (Exception ex) {
                    Interlocked.Increment(ref _workerErrorCount);
                    Logger.Error().Exception(ex).Message("Error sending work item to worker: {0}", ex.Message).Write();
                    await workItem.AbandonAsync().AnyContext();
                }
            });
        }
Пример #2
0
        public override void StartWorking(Func <QueueEntry <T>, CancellationToken, Task> handler, bool autoComplete = false, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            Logger.Trace().Message("Queue {0} start working", typeof(T).Name).Write();

            var linkedCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(_disposeTokenSource.Token, cancellationToken).Token;

            Task.Run(async() => {
#if DEBUG
                Logger.Trace().Message("WorkerLoop Start {0}", typeof(T).Name).Write();
#endif
                while (!linkedCancellationToken.IsCancellationRequested)
                {
#if DEBUG
                    Logger.Trace().Message("WorkerLoop Signaled {0}", typeof(T).Name).Write();
#endif
                    QueueEntry <T> queueEntry = null;
                    try {
                        queueEntry = await DequeueAsync(cancellationToken: cancellationToken).AnyContext();
                    } catch (Exception ex) {
                        Logger.Error().Message("Error on Dequeue: " + ex.Message).Exception(ex).Write();
                    }

                    if (queueEntry == null)
                    {
                        return;
                    }

                    try {
                        await handler(queueEntry, linkedCancellationToken).AnyContext();
                        if (autoComplete)
                        {
                            await queueEntry.CompleteAsync().AnyContext();
                        }
                    } catch (Exception ex) {
                        Logger.Error().Exception(ex).Message("Worker error: {0}", ex.Message).Write();
                        await queueEntry.AbandonAsync().AnyContext();
                        Interlocked.Increment(ref _workerErrorCount);
                    }
                }
#if DEBUG
                Logger.Trace().Message("WorkLoop End").Write();
#endif
            }, linkedCancellationToken);
        }
Пример #3
0
        public override void StartWorking(Func <QueueEntry <T>, CancellationToken, Task> handler, bool autoComplete = false, CancellationToken cancellationToken = default(CancellationToken))
        {
            if (handler == null)
            {
                throw new ArgumentNullException(nameof(handler));
            }

            var linkedCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(_queueDisposedCancellationTokenSource.Token, cancellationToken).Token;

            Task.Run(async() => {
#if DEBUG
                Logger.Trace().Message($"WorkerLoop Start {_queueName}").Write();
#endif
                while (!linkedCancellationToken.IsCancellationRequested)
                {
#if DEBUG
                    Logger.Trace().Message($"WorkerLoop Pass {_queueName}").Write();
#endif
                    QueueEntry <T> queueEntry = null;
                    try {
                        queueEntry = await DequeueAsync(cancellationToken: cancellationToken).AnyContext();
                    } catch (TimeoutException) { }

                    if (linkedCancellationToken.IsCancellationRequested || queueEntry == null)
                    {
                        continue;
                    }

                    try {
                        await handler(queueEntry, linkedCancellationToken).AnyContext();
                        if (autoComplete)
                        {
                            await queueEntry.CompleteAsync().AnyContext();
                        }
                    } catch (Exception ex) {
                        Logger.Error().Exception(ex).Message("Worker error: {0}", ex.Message).Write();
                        await queueEntry.AbandonAsync().AnyContext();
                        Interlocked.Increment(ref _workerErrorCount);
                    }
                }
#if DEBUG
                Logger.Trace().Message("Worker exiting: {0} Cancel Requested: {1}", _queueName, linkedCancellationToken.IsCancellationRequested).Write();
#endif
            }, linkedCancellationToken);
        }