Exemplo n.º 1
0
 public static void Publish <TJob>(this IJobPublisher publisher, DateTime?runAtUtc = null, int?jobTimeoutMs = null)
 {
     publisher.Publish(new[] { JobInfo.For <TJob, VoidArgs>(null, runAtUtc, null, jobTimeoutMs) });
 }
Exemplo n.º 2
0
 public static void Publish <TJob, TArgs>(this IJobPublisher publisher, IEnumerable <TArgs> jobArgs, TimeSpan runIn, int?jobTimeoutMs = null)
 {
     publisher.Publish <TJob, TArgs>(jobArgs, DateTime.UtcNow.Add(runIn), jobTimeoutMs);
 }
Exemplo n.º 3
0
 public static void Publish <TJob, TArgs>(this IJobPublisher publisher, TArgs jobArgs, TimeSpan runIn, int?jobTimeoutMs = null)
 {
     publisher.Publish(new[] { JobInfo.For <TJob, TArgs>(jobArgs, DateTime.UtcNow.Add(runIn), null, jobTimeoutMs) });
 }
Exemplo n.º 4
0
 public static void Publish(this IJobPublisher publisher, JobInfo jobInfo)
 {
     publisher.Publish(new[] { jobInfo });
 }
 public SchedulePendingHandler(IJobExecutionRepository jobExecutionRepository, IRepository <JobExecution> jobExecutionRepo, IJobPublisher jobPublisher)
 {
     _jobExecutionRepository = jobExecutionRepository;
     _jobExecutionRepo       = jobExecutionRepo;
     _jobPublisher           = jobPublisher;
 }
Exemplo n.º 6
0
        protected void InvokePerform(IJobPublisher publisher, IMessageReceiver receiver, JobInfo jobInfo, ulong deliveryTag, IJobServiceScope serviceScope, CancellationToken cancellationToken)
        {
            IBrokerTransaction tx = null;

            try
            {
                var reflectionInfo = ReflectionUtilities.ReflectionCache.GetJobReflectionInfo(jobInfo.JobType, jobInfo.ArgsType);

                object job;

                switch (reflectionInfo.CtorType)
                {
                case ReflectionUtilities.ConstructorType.NoArgs:
                    job = reflectionInfo.Ctor.Invoke(null);
                    break;

                case ReflectionUtilities.ConstructorType.NeedsPublisher:
                    job = reflectionInfo.Ctor.Invoke(new object[] { publisher });
                    break;

                default:
                    var parametersInfo = reflectionInfo.Ctor.GetParameters();
                    var parameters     = new object[parametersInfo.Length];

                    for (var i = 0; i < parametersInfo.Length; i++)
                    {
                        if (parametersInfo[i].IsOut)
                        {
                            throw new Exception("Out parameters are not supported.");
                        }
                        parameters[i] = serviceScope.GetRequiredService(parametersInfo[i].ParameterType);
                    }

                    job = reflectionInfo.Ctor.Invoke(parameters);
                    break;
                }

                if (job == null)
                {
                    throw new Exception($"Job type {jobInfo.JobType} is not registered in service scope and appropriate constructor does not exist!");
                }

                if ((bool)reflectionInfo.UseTransactionGetter(job))
                {
                    tx = receiver.BeginTransaction(serviceScope);
                }

                object result;

                switch (reflectionInfo.PerfMethodType)
                {
                case ReflectionUtilities.PerformMethodType.NoArgs:
                    result = reflectionInfo.PerformDelegate1(job);
                    break;

                case ReflectionUtilities.PerformMethodType.NeedsArgs:
                    result = reflectionInfo.PerformDelegate2(job, jobInfo.Args);
                    break;

                case ReflectionUtilities.PerformMethodType.NeedsCancellationToken:
                    result = reflectionInfo.PerformDelegate3(job, cancellationToken);
                    break;

                case ReflectionUtilities.PerformMethodType.NeedsArgsAndCancellationToken:
                    result = reflectionInfo.PerformDelegate4(job, jobInfo.Args, cancellationToken);
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(reflectionInfo.PerfMethodType));
                }

                if (result != null && result is Task taskResult)
                {
                    taskResult.Wait(cancellationToken);
                }

                receiver.AckBatchMessageProcessed(serviceScope, deliveryTag);

                tx?.Commit();
            }
            catch (TargetInvocationException ex)
            {
                try
                {
                    tx?.Rollback();
                }
                catch (Exception rollbackEx)
                {
                    _logger.LogError(rollbackEx, "Rollback failed");
                }

                if (ex.InnerException == null)
                {
                    throw;
                }
                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
            }
            finally
            {
                tx.SafeDispose(_logger);
            }
        }