Re-implemented background job & worker disable logic

framework/src/Volo.Abp.BackgroundJobs.HangFire/Volo/Abp/BackgroundJobs/Hangfire/AbpBackgroundJobsHangfireModule.cs

@@ -1,4 +1,8 @@
-using Volo.Abp.Hangfire;
+using System;
+using Hangfire;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Volo.Abp.Hangfire;
 using Volo.Abp.Modularity;
 
 namespace Volo.Abp.BackgroundJobs.Hangfire
@@ -9,5 +13,20 @@ namespace Volo.Abp.BackgroundJobs.Hangfire
     )]
     public class AbpBackgroundJobsHangfireModule : AbpModule
     {
+        public override void OnPreApplicationInitialization(ApplicationInitializationContext context)
+        {
+            var options = context.ServiceProvider.GetRequiredService<IOptions<AbpBackgroundJobOptions>>().Value;
+            if (!options.IsJobExecutionEnabled)
+            {
+                var hangfireOptions = context.ServiceProvider.GetRequiredService<IOptions<AbpHangfireOptions>>().Value;
+                hangfireOptions.BackgroundJobServerFactory = CreateOnlyEnqueueJobServer;
+            }
+        }
+
+        private BackgroundJobServer CreateOnlyEnqueueJobServer(IServiceProvider serviceProvider)
+        {
+            serviceProvider.GetRequiredService<JobStorage>();
+            return null;
+        }
     }
 }

framework/src/Volo.Abp.BackgroundJobs.Quartz/Volo/Abp/BackgroundJobs/Quartz/AbpBackgroundJobsQuartzModule.cs

@@ -1,4 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using Volo.Abp.Modularity;
 using Volo.Abp.Quartz;
 
@@ -14,5 +16,15 @@ namespace Volo.Abp.BackgroundJobs.Quartz
         {
             context.Services.AddTransient(typeof(QuartzJobExecutionAdapter<>));
         }
+
+        public override void OnPreApplicationInitialization(ApplicationInitializationContext context)
+        {
+            var options = context.ServiceProvider.GetService<IOptions<AbpBackgroundJobOptions>>().Value;
+            if (!options.IsJobExecutionEnabled)
+            {
+                var quartzOptions = context.ServiceProvider.GetService<IOptions<AbpQuartzOptions>>().Value;
+                quartzOptions.StartSchedulerFactory  = scheduler => Task.CompletedTask;
+            }
+        }
     }
 }

framework/src/Volo.Abp.BackgroundJobs.Quartz/Volo/Abp/BackgroundJobs/Quartz/QuartzJobExecutionAdapter.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;

framework/src/Volo.Abp.BackgroundWorkers.Quartz/Volo/Abp/BackgroundWorkers/Quartz/AbpBackgroundWorkersQuartzModule.cs

@@ -1,5 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
 using Volo.Abp.Modularity;
 using Volo.Abp.Quartz;
 
@@ -15,15 +16,29 @@ namespace Volo.Abp.BackgroundWorkers.Quartz
         {
             context.Services.AddConventionalRegistrar(new AbpQuartzConventionalRegistrar());
         }
+        
+        public override void OnPreApplicationInitialization(ApplicationInitializationContext context)
+        {
+            var options = context.ServiceProvider.GetService<IOptions<AbpBackgroundWorkerOptions>>().Value;
+            if (!options.IsEnabled)
+            {
+                var quartzOptions = context.ServiceProvider.GetService<IOptions<AbpQuartzOptions>>().Value;
+                quartzOptions.StartSchedulerFactory  = scheduler => Task.CompletedTask;
+            }
+        }
 
         public override void OnApplicationInitialization(ApplicationInitializationContext context)
         {
-            var backgroundWorkerManager = context.ServiceProvider.GetService<IBackgroundWorkerManager>();
-            var works = context.ServiceProvider.GetServices<IQuartzBackgroundWorker>();
-
-            foreach (var work in works)
+            var options = context.ServiceProvider.GetService<IOptions<AbpBackgroundWorkerOptions>>().Value;
+            if (options.IsEnabled)
             {
-                backgroundWorkerManager.Add(work);
+                var backgroundWorkerManager = context.ServiceProvider.GetService<IBackgroundWorkerManager>();
+                var works = context.ServiceProvider.GetServices<IQuartzBackgroundWorker>();
+
+                foreach (var work in works)
+                {
+                    backgroundWorkerManager.Add(work);
+                }
             }
         }
     }

framework/src/Volo.Abp.BackgroundWorkers.Quartz/Volo/Abp/BackgroundWorkers/Quartz/QuartzBackgroundWorkerManager.cs

@@ -30,14 +30,28 @@ namespace Volo.Abp.BackgroundWorkers.Quartz
         }
 
         public void Add(IBackgroundWorker worker)
+        {
+            AsyncHelper.RunSync(() => ReScheduleJobAsync(worker));
+        }
+
+        private async Task ReScheduleJobAsync(IBackgroundWorker worker)
         {
             if (worker is IQuartzBackgroundWorker quartzWork)
             {
                 Check.NotNull(quartzWork.Trigger, nameof(quartzWork.Trigger));
                 Check.NotNull(quartzWork.JobDetail, nameof(quartzWork.JobDetail));
-
-                AsyncHelper.RunSync(() => _scheduler.ScheduleJob(quartzWork.JobDetail, quartzWork.Trigger));
+                
+                if (await _scheduler.CheckExists(quartzWork.JobDetail.Key))
+                {
+                    await _scheduler.AddJob(quartzWork.JobDetail, true);
+                    await _scheduler.ResumeJob(quartzWork.JobDetail.Key);
+                    await _scheduler.RescheduleJob(quartzWork.Trigger.Key, quartzWork.Trigger);
+                }
+                else
+                {
+                    await _scheduler.ScheduleJob(quartzWork.JobDetail, quartzWork.Trigger);
+                }
             }
         }
     }
-}
+}

framework/src/Volo.Abp.Quartz/Volo/Abp/Quartz/AbpQuartzModule.cs

@@ -14,32 +14,33 @@ namespace Volo.Abp.Quartz
 
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
-            var options = context.Services.ExecutePreConfiguredActions<AbpQuartzPreOptions>();
+            var options = context.Services.ExecutePreConfiguredActions<AbpQuartzOptions>();
             context.Services.AddSingleton(AsyncHelper.RunSync(() => new StdSchedulerFactory(options.Properties).GetScheduler()));
             context.Services.AddSingleton(typeof(IJobFactory), typeof(AbpQuartzJobFactory));
+
+            Configure<AbpQuartzOptions>(quartzOptions =>
+            {
+                quartzOptions.Properties = options.Properties;
+                quartzOptions.StartDelay = options.StartDelay;
+            });
         }
 
         public override void OnApplicationInitialization(ApplicationInitializationContext context)
         {
-            var options = context.ServiceProvider.GetRequiredService<IOptions<AbpQuartzPreOptions>>().Value;
-            
+            var options = context.ServiceProvider.GetRequiredService<IOptions<AbpQuartzOptions>>().Value;
+
             _scheduler = context.ServiceProvider.GetService<IScheduler>();
             _scheduler.JobFactory = context.ServiceProvider.GetService<IJobFactory>();
-            
-            if (options.StartDelay.Ticks > 0)
-            {
-                AsyncHelper.RunSync(() => _scheduler.StartDelayed(options.StartDelay));
-            }
-            else
-            {
-                AsyncHelper.RunSync(() => _scheduler.Start());
-            }
+
+            AsyncHelper.RunSync(() => options.StartSchedulerFactory.Invoke(_scheduler));
         }
 
         public override void OnApplicationShutdown(ApplicationShutdownContext context)
         {
-            //TODO: ABP may provide two methods for application shutdown: OnPreApplicationShutdown & OnApplicationShutdown
-            AsyncHelper.RunSync(() => _scheduler.Shutdown());
+            if (_scheduler.IsStarted)
+            {
+                AsyncHelper.RunSync(() => _scheduler.Shutdown());
+            }
         }
     }
-}
+}

framework/src/Volo.Abp.Quartz/Volo/Abp/Quartz/AbpQuartzOptions.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Specialized;
+using System.Threading.Tasks;
+using JetBrains.Annotations;
+using Quartz;
+
+namespace Volo.Abp.Quartz
+{
+    public class AbpQuartzOptions
+    {
+        /// <summary>
+        /// The quartz configuration. Available properties can be found within Quartz.Impl.StdSchedulerFactory.
+        /// </summary>
+        public NameValueCollection Properties { get; set; }
+
+        /// <summary>
+        /// How long Quartz should wait before starting. Default: 0.
+        /// </summary>
+        public TimeSpan StartDelay { get; set; }
+
+        [NotNull]
+        public Func<IScheduler, Task> StartSchedulerFactory
+        {
+            get => _startSchedulerFactory;
+            set => _startSchedulerFactory = Check.NotNull(value, nameof(value));
+        }
+        private Func<IScheduler, Task> _startSchedulerFactory;
+
+        public AbpQuartzOptions()
+        {
+            Properties = new NameValueCollection();
+            StartDelay = new TimeSpan(0);
+            _startSchedulerFactory = StartSchedulerAsync;
+        }
+        
+        private async Task StartSchedulerAsync(IScheduler scheduler)
+        {
+            if (StartDelay.Ticks > 0)
+            {
+                await scheduler.StartDelayed(StartDelay);
+            }
+            else
+            {
+                await scheduler.Start();
+            }
+        }
+    }
+}

framework/src/Volo.Abp.Quartz/Volo/Abp/Quartz/AbpQuartzPreOptions.cs

@@ -1,23 +0,0 @@
-using System;
-using System.Collections.Specialized;
-
-namespace Volo.Abp.Quartz
-{
-    public class AbpQuartzPreOptions
-    {
-        /// <summary>
-        /// The quartz configuration. Available properties can be found within Quartz.Impl.StdSchedulerFactory.
-        /// </summary>
-        public NameValueCollection Properties { get; set; }
-        /// <summary>
-        /// How long Quartz should wait before starting. Default: 0.
-        /// </summary>
-        public TimeSpan StartDelay { get; set; }
-
-        public AbpQuartzPreOptions()
-        {
-            Properties = new NameValueCollection();
-            StartDelay = new TimeSpan(0);
-        }
-    }
-}