Exemplo n.º 1
0
        async Task Run <T>(ConsumerJobContext <T> jobContext, IJobFactory <T> jobFactory)
            where T : class
        {
            try
            {
                IPipe <JobContext <T> > nextPipe = Pipe.ExecuteAsync <JobContext <T> >(async context =>
                {
                    await context.Publish <JobCompleted>(new Completed(context.JobId)).ConfigureAwait(false);
                });

                await jobFactory.Execute(jobContext, nextPipe).ConfigureAwait(false);
            }
            catch (TaskCanceledException)
            {
                await NotifyCanceled(jobContext).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                await NotifyCanceled(jobContext).ConfigureAwait(false);
            }
            catch (Exception exception)
            {
                JobContext <T> context = jobContext;

                await context.Publish <JobFaulted <T> >(new Faulted <T>(jobContext.JobId, jobContext.Message, exception)).ConfigureAwait(false);
            }
            finally
            {
                jobContext.Dispose();
            }
        }
Exemplo n.º 2
0
        async Task Run <T>(ConsumerJobContext <T> jobContext, IJobFactory <T> jobFactory)
            where T : class
        {
            try
            {
                IPipe <JobContext <T> > pipe = Pipe.New <JobContext <T> >(cfg =>
                {
                    cfg.UseRetry(r =>
                    {
                        r.Ignore <TaskCanceledException>();
                        r.Ignore <OperationCanceledException>();
                        r.Interval(1, 1000);
                    });

                    cfg.UseExecuteAsync(context => context.NotifyStarted(_managementAddress));

                    cfg.UseInlineFilter(jobFactory.Execute);

                    cfg.UseExecuteAsync(context => context.NotifyCompleted());
                });

                await pipe.Send(jobContext).ConfigureAwait(false);
            }
            catch (TaskCanceledException)
            {
                await jobContext.NotifyCanceled("Task canceled").ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
                await jobContext.NotifyCanceled("Operation canceled").ConfigureAwait(false);
            }
            catch (Exception exception)
            {
                await jobContext.NotifyFaulted(exception).ConfigureAwait(false);
            }
            finally
            {
                jobContext.Dispose();
            }
        }
Exemplo n.º 3
0
        async Task Run <T>(ConsumerJobContext <T> jobContext, IJobFactory <T> jobFactory)
            where T : class
        {
            try
            {
                var nextPipe = Pipe.ExecuteAsync <JobContext <T> >(async context =>
                {
                    await context.Publish <JobCompleted>(new Completed(context.JobId)).ConfigureAwait(false);
                });

                await jobFactory.Execute(jobContext, nextPipe).ConfigureAwait(false);
            }
            catch (Exception exception)
            {
                JobContext <T> context = jobContext;

                await context.Publish <JobFaulted>(new Faulted(jobContext.JobId, exception)).ConfigureAwait(false);
            }
            finally
            {
                jobContext.Dispose();
            }
        }