Exemple #1
0
        public async Task Send(ExecuteActivityContext <TArguments> context, IPipe <ExecuteActivityContext <TArguments> > next)
        {
            if (_log.IsDebugEnabled)
            {
                _log.DebugFormat("Executing: {0}", context.TrackingNumber);
            }

            try
            {
                try
                {
                    ExecutionResult result = await context.Activity.Execute(context).ConfigureAwait(false);

                    await result.Evaluate().ConfigureAwait(false);

                    await next.Send(context).ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    ExecutionResult result = context.Faulted(ex);

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

                throw;
            }
        }
        public async Task Send(ExecuteActivityContext <TActivity, TArguments> context, IPipe <ExecuteActivityContext <TActivity, TArguments> > next)
        {
            try
            {
                if (_observers.Count > 0)
                {
                    await _observers.PreExecute(context).ConfigureAwait(false);
                }

                var result = context.Result = await context.Activity.Execute(context).ConfigureAwait(false)
                                              ?? context.Faulted(new ActivityExecutionException("The activity execute did not return a result"));

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

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

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

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

                throw;
            }
        }
Exemple #3
0
        public async Task Send(ExecuteActivityContext <TActivity, TArguments> context, IPipe <ExecuteActivityContext <TActivity, TArguments> > next)
        {
            context.Result = await context.Activity.Execute(context).ConfigureAwait(false);

            var result = context.Result ?? context.Faulted(new ActivityExecutionException("The activity execute did not return a result"));

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

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