public async Task Send(CompensateActivityContext <TLog> context, IPipe <CompensateActivityContext <TLog> > next)
        {
            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Compensating: {0}", context.TrackingNumber);
            }

            try
            {
                try
                {
                    CompensationResult result = await context.Activity.Compensate(context);

                    await result.Evaluate();

                    await next.Send(context);
                }
                catch (Exception ex)
                {
                    CompensationResult result = context.Failed(ex);

                    await result.Evaluate();
                }
            }
            catch (Exception ex)
            {
                _log.Error($"The activity {TypeMetadataCache.GetShortName(context.Activity.GetType())} threw an exception", ex);

                throw;
            }
        }
        public async Task Send(CompensateActivityContext <TActivity, TLog> context, IPipe <CompensateActivityContext <TActivity, TLog> > next)
        {
            context.Result = await context.Activity.Compensate(context).ConfigureAwait(false);

            var result = context.Result ?? context.Failed(new ActivityCompensationException("The activity compensation did not return a result"));

            if (result.IsFailed(out var exception))
            {
                throw new AggregateException(exception);
            }

            await next.Send(context).ConfigureAwait(false);
        }
예제 #3
0
        public async Task Send(CompensateActivityContext <TActivity, TLog> context, IPipe <CompensateActivityContext <TActivity, TLog> > next)
        {
            try
            {
                if (_observers.Count > 0)
                {
                    await _observers.PreCompensate(context).ConfigureAwait(false);
                }

                var result = context.Result = await context.Activity.Compensate(context).ConfigureAwait(false)
                                              ?? context.Failed(new ActivityCompensationException("The activity compensation did not return a result"));

                if (result.IsFailed(out var exception))
                {
                    exception.Rethrow();
                }

                await next.Send(context).ConfigureAwait(false);

                if (_observers.Count > 0)
                {
                    await _observers.PostCompensate(context).ConfigureAwait(false);
                }
            }
            catch (Exception exception)
            {
                if (context.Result == null || !context.Result.IsFailed(out var faultException) || faultException != exception)
                {
                    context.Result = context.Failed(exception);
                }

                if (_observers.Count > 0)
                {
                    await _observers.CompensateFail(context, exception).ConfigureAwait(false);
                }

                throw;
            }
        }