コード例 #1
0
        protected override async Task <MessageProcessingResult> DispatchMessage(TransportMessage message, long taskId, CancellationToken token, ITransactionContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context), "ITransactionContext context == null");
            }
            var stepContext = new IncomingStepContext(message, context);
            await _pipelineInvoker.Invoke(stepContext);

            return(new MessageProcessingResult {
                isRollBack = false
            });
        }
コード例 #2
0
ファイル: TplWorker.cs プロジェクト: xiaguoli/Rebus
        async Task ProcessMessage(TransactionContext context, TransportMessage transportMessage)
        {
            try
            {
                AmbientTransactionContext.SetCurrent(context);

                var stepContext = new IncomingStepContext(transportMessage, context);
                await _pipelineInvoker.Invoke(stepContext);

                try
                {
                    await context.Complete();
                }
                catch (Exception exception)
                {
                    _log.Error(exception, "An error occurred when attempting to complete the transaction context");
                }
            }
            catch (OperationCanceledException exception)
            {
                context.Abort();

                _log.Error(exception, "Worker was aborted while handling message {messageLabel}", transportMessage.GetMessageLabel());
            }
            catch (Exception exception)
            {
                context.Abort();

                _log.Error(exception, "Unhandled exception while handling message {messageLabel}", transportMessage.GetMessageLabel());
            }
            finally
            {
                AmbientTransactionContext.SetCurrent(null);
            }
        }
コード例 #3
0
        async void TryReceiveNewMessage()
        {
            using (var operation = _parallelOperationsManager.TryBegin())
            {
                // if we didn't get to do our thing, pause the thread a very short while to avoid thrashing too much
                if (!operation.CanContinue())
                {
                    Thread.Sleep(10);
                    return;
                }

                using (var transactionContext = new DefaultTransactionContext())
                {
                    AmbientTransactionContext.Current = transactionContext;
                    try
                    {
                        var message = await TryReceiveTransportMessage(transactionContext);

                        if (message == null)
                        {
                            // no message: finish the tx and wait....
                            await transactionContext.Complete();

                            await _backoffStrategy.Wait();

                            return;
                        }

                        // we got a message, so we reset the backoff strategy
                        _backoffStrategy.Reset();

                        var context = new IncomingStepContext(message, transactionContext);

                        var stagedReceiveSteps = _pipeline.ReceivePipeline();

                        await _pipelineInvoker.Invoke(context, stagedReceiveSteps);

                        try
                        {
                            await transactionContext.Complete();
                        }
                        catch (Exception exception)
                        {
                            _log.Error(exception, "An error occurred when attempting to complete the transaction context");
                        }
                    }
                    catch (Exception exception)
                    {
                        // we should not end up here unless something is off....
                        _log.Error(exception, "Unhandled exception in thread worker - the pipeline didn't handle its own errors (this is bad)");
                        Thread.Sleep(100);
                    }
                    finally
                    {
                        AmbientTransactionContext.Current = null;
                    }
                }
            }
        }
コード例 #4
0
        async void TryProcessMessage()
        {
            using (var op = _parallelOperationsManager.TryBegin())
            {
                if (!op.CanContinue())
                {
                    Thread.Sleep(10);
                    return;
                }

                using (var transactionContext = new DefaultTransactionContext())
                {
                    AmbientTransactionContext.Current = transactionContext;
                    try
                    {
                        var message = await _transport.Receive(transactionContext);

                        if (message == null)
                        {
                            // finish the tx and wait....
                            await transactionContext.Complete();

                            await _backoffHelper.Wait();

                            return;
                        }

                        _backoffHelper.Reset();

                        var context = new IncomingStepContext(message, transactionContext);
                        transactionContext.Items[StepContext.StepContextKey] = context;

                        var stagedReceiveSteps = _pipeline.ReceivePipeline();

                        await _pipelineInvoker.Invoke(context, stagedReceiveSteps);

                        await transactionContext.Complete();
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception, "Unhandled exception in thread worker");
                    }
                    finally
                    {
                        AmbientTransactionContext.Current = null;
                    }
                }
            }
        }
コード例 #5
0
ファイル: ThreadPoolWorker.cs プロジェクト: crazyants/Rebus
        async Task ProcessMessage(TransactionContext context, TransportMessage transportMessage)
        {
            try
            {
                context.Items["OwningBus"] = _owningBus;

                AmbientTransactionContext.SetCurrent(context);

                var incomingSteps = _pipeline.ReceivePipeline();
                var stepContext   = new IncomingStepContext(transportMessage, context);
                await _pipelineInvoker.Invoke(stepContext, incomingSteps);

                try
                {
                    await context.Complete();
                }
                catch (Exception exception)
                {
                    _log.Error(exception, "An error occurred when attempting to complete the transaction context");
                }
            }
            catch (ThreadAbortException exception)
            {
                context.Abort();

                _log.Error(exception, $"Worker was killed while handling message {transportMessage.GetMessageLabel()}");
            }
            catch (Exception exception)
            {
                context.Abort();

                _log.Error(exception, $"Unhandled exception while handling message {transportMessage.GetMessageLabel()}");
            }
            finally
            {
                AmbientTransactionContext.SetCurrent(null);
            }
        }
コード例 #6
0
        async Task SendUsingTransactionContext(IEnumerable <string> destinationAddresses, Message logicalMessage, ITransactionContext transactionContext)
        {
            var context = new OutgoingStepContext(logicalMessage, transactionContext, new DestinationAddresses(destinationAddresses));

            await _pipelineInvoker.Invoke(context, _pipeline.SendPipeline());
        }
コード例 #7
0
        async void TryReceiveNewMessage()
        {
            using (var operation = _parallelOperationsManager.TryBegin())
            {
                // if we didn't get to do our thing, let the OS decide what to do next.... we don't hog the processor
                if (!operation.CanContinue())
                {
                    Thread.Yield();
                    return;
                }

                using (var transactionContext = new DefaultTransactionContext())
                {
                    transactionContext.Items["CancellationToken"] = _cancellationTokenSource.Token;
                    transactionContext.Items["OwningBus"]         = _owningBus;
                    AmbientTransactionContext.Current             = transactionContext;
                    try
                    {
                        var result = await TryReceiveTransportMessage(transactionContext, _cancellationTokenSource.Token);

                        if (result.Exception != null)
                        {
                            if (result.Exception is TaskCanceledException || result.Exception is OperationCanceledException)
                            {
                                // this is normal - we're being shut down so we just return quickly
                                transactionContext.Dispose();
                                return;
                            }

                            _log.Warn("An error occurred when attempting to receive transport message: {0}", result.Exception);

                            // error: finish the tx and wait....
                            transactionContext.Dispose();

                            await _backoffStrategy.WaitError();

                            return;
                        }

                        var message = result.TransportMessage;
                        if (message == null)
                        {
                            // no message: finish the tx and wait....
                            await transactionContext.Complete();

                            transactionContext.Dispose();

                            await _backoffStrategy.Wait();

                            return;
                        }

                        // we got a message, so we reset the backoff strategy
                        _backoffStrategy.Reset();

                        var context            = new IncomingStepContext(message, transactionContext);
                        var stagedReceiveSteps = _pipeline.ReceivePipeline();

                        await _pipelineInvoker.Invoke(context, stagedReceiveSteps);

                        try
                        {
                            await transactionContext.Complete();
                        }
                        catch (Exception exception)
                        {
                            _log.Error(exception, "An error occurred when attempting to complete the transaction context");
                        }
                    }
                    catch (Exception exception)
                    {
                        // we should not end up here unless something is off....
                        _log.Error(exception, "Unhandled exception in thread worker - the pipeline didn't handle its own errors (this is bad)");
                        Thread.Sleep(100);
                    }
                    finally
                    {
                        AmbientTransactionContext.Current = null;
                    }
                }
            }
        }