public static IServiceCollection RegisterJobSchedulerServices(this IServiceCollection services, IConfiguration configuration)
{
// TODO: impelement job scheduler persistence
// var connectionString = configuration?.GetSection("ConnectionStrings")?["Quartz"];
//
// if (connectionString == null)
// throw new InvalidOperationException("Quartz connection string not setup.");
services.AddSingleton <ISchedulerFactory>(provider =>
{
var quartzSchedulerBuilder = SchedulerBuilder.Create();
// quartzSchedulerBuilder.UsePersistentStore(
// options =>
// {
// //options.UseProperties = true;
// options.UsePostgres(connectionString);
// options.UseJsonSerializer();
// }
// );
return(quartzSchedulerBuilder.Build());
});
services.AddSingleton <IScheduler, DependencyInjectionQuartzScheduler>();
services.AddSingleton <IJobFactory, DependencyInjectionQuartzJobFactory>();
return(services);
}
public void TestTimeZonePlugin()
{
var builder = SchedulerBuilder.Create()
.UseTimeZoneConverter();
Assert.That(builder.Properties["quartz.plugin.timeZoneConverter.type"], Is.EqualTo(typeof(TimeZoneConverterPlugin).AssemblyQualifiedNameWithoutVersion()));
}
private async Task RunAdoJobStoreTest(
string dbProvider,
string connectionStringId,
string serializerType,
NameValueCollection extraProperties,
bool clustered = true)
{
var config = SchedulerBuilder.Create("instance_one", "TestScheduler");
config.UseDefaultThreadPool(x =>
{
x.MaxConcurrency = 10;
});
config.MisfireThreshold = TimeSpan.FromSeconds(60);
config.UsePersistentStore(store =>
{
store.UseProperties = false;
if (clustered)
{
store.UseClustering(c =>
{
c.CheckinInterval = TimeSpan.FromMilliseconds(1000);
});
}
store.UseGenericDatabase(dbProvider, db =>
db.ConnectionString = dbConnectionStrings[connectionStringId]
);
if (serializerType == "json")
{
store.UseJsonSerializer();
}
else
{
store.UseBinarySerializer();
}
});
if (extraProperties != null)
{
foreach (string key in extraProperties.Keys)
{
config.SetProperty(key, extraProperties[key]);
}
}
// Clear any old errors from the log
FailFastLoggerFactoryAdapter.Errors.Clear();
// First we must get a reference to a scheduler
IScheduler sched = await config.BuildScheduler();
SmokeTestPerformer performer = new SmokeTestPerformer();
await performer.Test(sched, clearJobs, scheduleJobs);
Assert.IsEmpty(FailFastLoggerFactoryAdapter.Errors, "Found error from logging output");
}
public void TestSqlServerJobStore()
{
var config = SchedulerBuilder.Create();
config.UsePersistentStore(js =>
{
js.UseJsonSerializer();
js.RetryInterval = TimeSpan.FromSeconds(20);
js.UseClustering(c =>
{
c.CheckinInterval = TimeSpan.FromSeconds(10);
c.CheckinMisfireThreshold = TimeSpan.FromSeconds(15);
});
js.UseSqlServer(db =>
{
db.ConnectionString = "Server=localhost;Database=quartznet;";
db.TablePrefix = "QRTZ2019_";
});
});
Assert.That(config.Properties["quartz.dataSource.default.connectionString"], Is.EqualTo("Server=localhost;Database=quartznet;"));
Assert.That(config.Properties["quartz.jobStore.type"], Is.EqualTo(typeof(JobStoreTX).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.jobStore.driverDelegateType"], Is.EqualTo(typeof(SqlServerDelegate).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.jobStore.dataSource"], Is.EqualTo("default"));
Assert.That(config.Properties["quartz.jobStore.tablePrefix"], Is.EqualTo("QRTZ2019_"));
Assert.That(config.Properties["quartz.jobStore.clusterCheckinInterval"], Is.EqualTo("10000"));
Assert.That(config.Properties["quartz.jobStore.clusterCheckinMisfireThreshold"], Is.EqualTo("15000"));
Assert.That(config.Properties["quartz.jobStore.dbRetryInterval"], Is.EqualTo("20000"));
}
public void TestSqlServerJobStore()
{
var builder = SchedulerBuilder.Create()
.UsePersistentStore(persistence =>
persistence
.WithJsonSerializer()
.Clustered(cluster => cluster
.WithCheckinInterval(TimeSpan.FromSeconds(10))
.WithCheckinMisfireThreshold(TimeSpan.FromSeconds(15))
)
.UseSqlServer(db =>
db.WithConnectionString("Server=localhost;Database=quartznet;")
)
.WithTablePrefix("QRTZ2019_")
);
Assert.That(builder.Properties["quartz.dataSource.default.connectionString"], Is.EqualTo("Server=localhost;Database=quartznet;"));
Assert.That(builder.Properties["quartz.jobStore.type"], Is.EqualTo(typeof(JobStoreTX).AssemblyQualifiedNameWithoutVersion()));
Assert.That(builder.Properties["quartz.jobStore.driverDelegateType"], Is.EqualTo(typeof(SqlServerDelegate).AssemblyQualifiedNameWithoutVersion()));
Assert.That(builder.Properties["quartz.jobStore.dataSource"], Is.EqualTo("default"));
Assert.That(builder.Properties["quartz.jobStore.tablePrefix"], Is.EqualTo("QRTZ2019_"));
Assert.That(builder.Properties["quartz.jobStore.clusterCheckinInterval"], Is.EqualTo("10000"));
Assert.That(builder.Properties["quartz.jobStore.clusterCheckinMisfireThreshold"], Is.EqualTo("15000"));
}
protected override Task <IScheduler> CreateScheduler(string name, int threadPoolSize)
{
var builder = SchedulerBuilder.Create()
.WithName(name + "Scheduler")
.WithId("AUTO")
.WithDefaultThreadPool(x => x.WithThreadCount(threadPoolSize));
return(builder.Build());
}
protected override Task<IScheduler> CreateScheduler(string name, int threadPoolSize)
{
var config = SchedulerBuilder.Create()
.SetSchedulerName(name + "Scheduler")
.SetSchedulerId("AUTO");
config.UseDefaultThreadPool(x => x.SetThreadCount(threadPoolSize));
return config.BuildScheduler();
}
public void TestRamJobStore()
{
var config = SchedulerBuilder.Create();
config.UseInMemoryStore();
config.UseDefaultThreadPool(x => x.ThreadCount = 100);
Assert.That(config.Properties["quartz.jobStore.type"], Is.EqualTo(typeof(RAMJobStore).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.threadPool.threadCount"], Is.EqualTo("100"));
}
public async Task Should_Create_Activity()
{
// Arrange
Barrier barrier = new Barrier(2);
List <DateTime> jobExecTimestamps = new List <DateTime>();
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using var tel = Sdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddQuartzInstrumentation()
.AddProcessor(activityProcessor.Object)
.Build();
var schedulerConfig = SchedulerBuilder.Create("AUTO", "Scheduler");
schedulerConfig.UseDefaultThreadPool(x => x.MaxConcurrency = 10);
var scheduler = await schedulerConfig.BuildScheduler();
scheduler.Context.Put("BARRIER", barrier);
scheduler.Context.Put("DATESTAMPS", jobExecTimestamps);
await scheduler.Start();
JobDataMap jobDataMap = new JobDataMap {
{ "A", "B" }
};
var name = Guid.NewGuid().ToString();
var job = JobBuilder.Create <TestJob>()
.WithIdentity(name, SchedulerConstants.DefaultGroup)
.UsingJobData(jobDataMap)
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity(name, SchedulerConstants.DefaultGroup)
.StartNow()
.Build();
// Act
await scheduler.ScheduleJob(job, trigger);
barrier.SignalAndWait(TestTimeout);
await scheduler.Shutdown(true);
// Assert
Assert.Equal(3, activityProcessor.Invocations.Count);
var activity = (Activity)activityProcessor.Invocations[1].Arguments[0];
Assert.Contains("execute ", activity.DisplayName);
Assert.Equal("Quartz.Job.Execute", activity.OperationName);
Assert.Equal(ActivityKind.Internal, activity.Kind);
Assert.Equal("Scheduler", activity.Tags.SingleOrDefault(t => t.Key.Equals("scheduler.name")).Value);
Assert.Equal(SchedulerConstants.DefaultGroup, activity.Tags.SingleOrDefault(t => t.Key.Equals("job.group")).Value);
Assert.Equal(SchedulerConstants.DefaultGroup, activity.Tags.SingleOrDefault(t => t.Key.Equals("trigger.group")).Value);
}
public async Task Should_Record_Exception_When_Record_Exception_Enabled()
{
// Arrange
Barrier barrier = new Barrier(2);
List <DateTime> jobExecTimestamps = new List <DateTime>();
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using var tel = Sdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddQuartzInstrumentation(q =>
q.RecordException = true)
.AddProcessor(activityProcessor.Object)
.Build();
var schedulerConfig = SchedulerBuilder.Create("AUTO", "Scheduler");
schedulerConfig.UseDefaultThreadPool(x => x.MaxConcurrency = 10);
var scheduler = await schedulerConfig.BuildScheduler();
scheduler.Context.Put("BARRIER", barrier);
scheduler.Context.Put("DATESTAMPS", jobExecTimestamps);
await scheduler.Start();
var testId = Guid.NewGuid().ToString();
JobDataMap jobDataMap = new JobDataMap {
{ "TestId", testId }
};
var name = Guid.NewGuid().ToString();
var job = JobBuilder.Create <TestJobExecutionExceptionJob>()
.WithIdentity(name, SchedulerConstants.DefaultGroup)
.UsingJobData(jobDataMap)
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity(name, SchedulerConstants.DefaultGroup)
.StartNow()
.Build();
// Act
await scheduler.ScheduleJob(job, trigger);
barrier.SignalAndWait(TimeSpan.FromSeconds(1));
await scheduler.Shutdown(true);
// Assert
Assert.Equal(3, activityProcessor.Invocations.Count);
var activity = (Activity)activityProcessor.Invocations[1].Arguments[0];
Assert.Equal("exception", activity.Events.First().Name);
Assert.Equal("ERROR", activity.Tags.SingleOrDefault(t => t.Key.Equals(SpanAttributeConstants.StatusCodeKey)).Value);
Assert.Equal("Catch me if you can!", activity.Tags.SingleOrDefault(t => t.Key.Equals(SpanAttributeConstants.StatusDescriptionKey)).Value);
}
public async Task Should_Not_Record_Activity_When_Trace_Operation_Is_Not_Present()
{
// Arrange
Barrier barrier = new Barrier(2);
List <DateTime> jobExecTimestamps = new List <DateTime>();
var activityProcessor = new Mock <BaseProcessor <Activity> >();
using var tel = Sdk.CreateTracerProviderBuilder()
.SetSampler(new AlwaysOnSampler())
.AddQuartzInstrumentation(q =>
{
q.TracedOperations = new HashSet <string>();
})
.AddProcessor(activityProcessor.Object)
.Build();
var schedulerConfig = SchedulerBuilder.Create("AUTO", "Scheduler");
schedulerConfig.UseDefaultThreadPool(x => x.MaxConcurrency = 10);
var scheduler = await schedulerConfig.BuildScheduler();
scheduler.Context.Put("BARRIER", barrier);
scheduler.Context.Put("DATESTAMPS", jobExecTimestamps);
await scheduler.Start();
var testId = Guid.NewGuid().ToString();
JobDataMap jobDataMap = new JobDataMap {
{ "TestId", testId }
};
var name = Guid.NewGuid().ToString();
var job = JobBuilder.Create <TestJob>()
.WithIdentity(name, SchedulerConstants.DefaultGroup)
.UsingJobData(jobDataMap)
.Build();
var trigger = TriggerBuilder.Create()
.WithIdentity(name, SchedulerConstants.DefaultGroup)
.StartNow()
.Build();
// Act
await scheduler.ScheduleJob(job, trigger);
barrier.SignalAndWait(TestTimeout);
await scheduler.Shutdown(true);
// Assert
var activities = activityProcessor.Invocations.SelectMany(i => i.Arguments.OfType <Activity>())
.Where(a => a.IsAllDataRequested);
Assert.Empty(activities);
}
private static void _registerJobs(SchedulerBuilder builder, Type[] jobs)
{
Type[] types = new Type[] { };
MethodInfo method = typeof(SchedulerBuilder).GetMethod(nameof(SchedulerBuilder.AddJob), types);
foreach (Type job in jobs)
{
MethodInfo generic = method.MakeGenericMethod(job);
generic.Invoke(builder, null);
}
}
public static Task <IScheduler> CreateAndConfigureSchedulerAsync()
{
var runEvery = ConfigurationManager.AppSettings["runEvery"];
var jobData = new JobDataMap();
jobData.SetExecutionData();
return(SchedulerBuilder.Create()
.WithJobFactory(CreateJobFactory())
.ScheduleJob <MessageUpdater>(runEvery, jobData)
.BuildAsync());
}
protected override Task <IScheduler> CreateScheduler(string name, int threadPoolSize)
{
var config = SchedulerBuilder.Create("AUTO", name + "Scheduler");
config.UseDefaultThreadPool(x =>
{
x.MaxConcurrency = threadPoolSize;
});
return(config.BuildScheduler());
}
public void TestSQLiteJsobStore()
{
var config = SchedulerBuilder.Create();
config.UsePersistentStore(options =>
options.UseSQLite("Server=localhost;Database=quartznet;")
);
Assert.That(config.Properties["quartz.dataSource.default.connectionString"], Is.EqualTo("Server=localhost;Database=quartznet;"));
Assert.That(config.Properties["quartz.jobStore.type"], Is.EqualTo(typeof(JobStoreTX).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.jobStore.driverDelegateType"], Is.EqualTo(typeof(SQLiteDelegate).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.jobStore.dataSource"], Is.EqualTo("default"));
}
public void TestFirebirdJobStore()
{
var config = SchedulerBuilder.Create();
config
.UsePersistentStore(persistence =>
persistence.UseFirebird(db => db
.SetConnectionString("Server=localhost;Database=quartznet;"))
);
Assert.That(config.Properties["quartz.dataSource.default.connectionString"], Is.EqualTo("Server=localhost;Database=quartznet;"));
Assert.That(config.Properties["quartz.jobStore.type"], Is.EqualTo(typeof(JobStoreTX).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.jobStore.driverDelegateType"], Is.EqualTo(typeof(FirebirdDelegate).AssemblyQualifiedNameWithoutVersion()));
Assert.That(config.Properties["quartz.jobStore.dataSource"], Is.EqualTo("default"));
}
public void TestXmlSchedulingPlugin()
{
var builder = SchedulerBuilder.Create()
.UseXmlSchedulingConfiguration(x => x
.SetFiles("jobs.xml", "jobs2.xml")
.SetScanInterval(TimeSpan.FromSeconds(2))
.SetFailOnFileNotFound()
.SetFailOnSchedulingError()
);
Assert.That(builder.Properties["quartz.plugin.xml.type"], Is.EqualTo(typeof(XMLSchedulingDataProcessorPlugin).AssemblyQualifiedNameWithoutVersion()));
Assert.That(builder.Properties["quartz.plugin.xml.fileNames"], Is.EqualTo("jobs.xml,jobs2.xml"));
Assert.That(builder.Properties["quartz.plugin.xml.failOnFileNotFound"], Is.EqualTo("true"));
Assert.That(builder.Properties["quartz.plugin.xml.failOnSchedulingError"], Is.EqualTo("true"));
Assert.That(builder.Properties["quartz.plugin.xml.scanInterval"], Is.EqualTo("2"));
}
public void TestMySqlJobStore()
{
var builder = SchedulerBuilder.Create()
.UsePersistentStore(persistence =>
persistence
.UseMySql(db =>
db.WithConnectionString("Server=localhost;Database=quartznet;")
)
);
Assert.That(builder.Properties["quartz.dataSource.default.connectionString"], Is.EqualTo("Server=localhost;Database=quartznet;"));
Assert.That(builder.Properties["quartz.jobStore.type"], Is.EqualTo(typeof(JobStoreTX).AssemblyQualifiedNameWithoutVersion()));
Assert.That(builder.Properties["quartz.jobStore.driverDelegateType"], Is.EqualTo(typeof(MySQLDelegate).AssemblyQualifiedNameWithoutVersion()));
Assert.That(builder.Properties["quartz.jobStore.dataSource"], Is.EqualTo("default"));
}
public async Task Run()
{
Console.WriteLine("------- Initializing ----------------------");
// First we must get a reference to a scheduler
var sched = await SchedulerBuilder.Create()
.WithName("XmlConfiguredInstance")
.UseDefaultThreadPool(maxConcurrency: 5)
// job initialization plugin handles our xml reading, without it defaults are used
.UseXmlSchedulingConfiguration(x =>
{
x.Files = new[] { "~/quartz_jobs.xml" };
// this is the default
x.FailOnFileNotFound = true;
// this is not the default
x.FailOnSchedulingError = true;
})
.BuildScheduler();
// we need to add calendars manually, lets create a silly sample calendar
var dailyCalendar = new DailyCalendar("00:01", "23:59");
dailyCalendar.InvertTimeRange = true;
await sched.AddCalendar("cal1", dailyCalendar, false, false);
Console.WriteLine("------- Initialization Complete -----------");
// all jobs and triggers are now in scheduler
// Start up the scheduler (nothing can actually run until the
// scheduler has been started)
await sched.Start();
Console.WriteLine("------- Started Scheduler -----------------");
// wait long enough so that the scheduler as an opportunity to
// fire the triggers
Console.WriteLine("------- Waiting 30 seconds... -------------");
await Task.Delay(30 *1000);
// shut down the scheduler
Console.WriteLine("------- Shutting Down ---------------------");
await sched.Shutdown(true);
Console.WriteLine("------- Shutdown Complete -----------------");
}
public static SchedulerBuilder <T> Month <T>(this SchedulerBuilder <T> builder, string name)
where T : class, ISchedulerEvent
{
return(builder
.Name(name)
.Views(views =>
{
views.MonthView(m => m.Title("Месяц")
.DayTemplate("<span>#=kendo.toString(date, \"dd\")#</span>"));
})
.Messages(messages =>
{
messages.Today("Сегодня");
})
.Editable(false)
.Selectable(false));
}
public static void AddJobs(this SchedulerBuilder builder, params Assembly[] assembliesToScan)
{
foreach (var assembly in assembliesToScan)
{
var jobs = assembly
.GetTypes()
.Where(x =>
x.GetInterfaces().Contains(typeof(IScheduledJob)) &&
!x.IsAbstract &&
!x.IsInterface &&
x.IsClass
)
.ToArray();
_registerJobs(builder, jobs);
}
}
private async Task RunAdoJobStoreTest(
string dbProvider,
string connectionStringId,
string serializerType,
NameValueCollection extraProperties,
bool clustered = true)
{
var builder = SchedulerBuilder.Create("instance_one", "TestScheduler")
.WithDefaultThreadPool(x => x.WithThreadCount(10))
.WithMisfireThreshold(TimeSpan.FromSeconds(60))
.UsePersistentStore(store =>
{
var x = store
.UseProperties(false)
.Clustered(clustered, options => options.WithCheckinInterval(TimeSpan.FromMilliseconds(1000)))
.UseGenericDatabase(dbProvider, db => db.WithConnectionString(dbConnectionStrings[connectionStringId]));
x = serializerType == "json"
? x.WithJsonSerializer()
: x.WithBinarySerializer();
});
if (extraProperties != null)
{
foreach (string key in extraProperties.Keys)
{
builder.SetProperty(key, extraProperties[key]);
}
}
// Clear any old errors from the log
FailFastLoggerFactoryAdapter.Errors.Clear();
// First we must get a reference to a scheduler
IScheduler sched = await builder.Build();
SmokeTestPerformer performer = new SmokeTestPerformer();
await performer.Test(sched, clearJobs, scheduleJobs);
Assert.IsEmpty(FailFastLoggerFactoryAdapter.Errors, "Found error from logging output");
}
public virtual async Task Run()
{
// First we must get a reference to a scheduler
IScheduler sched = await SchedulerBuilder.Create()
.WithName("RemoteClient")
.UseDefaultThreadPool(x => x.MaxConcurrency = 5)
.ProxyToRemoteScheduler("tcp://127.0.0.1:555/QuartzScheduler")
.BuildScheduler();
// define the job and ask it to run
IJobDetail job = JobBuilder.Create <SimpleJob>()
.WithIdentity("remotelyAddedJob", "default")
.Build();
JobDataMap map = job.JobDataMap;
map.Put("msg", "Your remotely added job has executed!");
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("remotelyAddedTrigger", "default")
.ForJob(job.Key)
.WithCronSchedule("/5 * * ? * *")
.Build();
// schedule the job
await sched.ScheduleJob(job, trigger);
Console.WriteLine("Remote job scheduled, scheduler now has following jobs:");
var keys = await sched.GetJobKeys(GroupMatcher <JobKey> .AnyGroup());
foreach (var key in keys)
{
Console.WriteLine("\t " + key);
}
}
public async Task Run()
{
Console.WriteLine("------- Initializing ----------------------");
// First we must get a reference to a scheduler
var sched = await SchedulerBuilder.Create()
.WithName("PriorityExampleScheduler")
// Set thread count to 1 to force Triggers scheduled for the same time to
// to be ordered by priority.
.UseDefaultThreadPool(1)
.BuildScheduler();
Console.WriteLine("------- Initialization Complete -----------");
Console.WriteLine("------- Scheduling Jobs -------------------");
IJobDetail job = JobBuilder.Create <TriggerEchoJob>()
.WithIdentity("TriggerEchoJob")
.Build();
// All three triggers will fire their first time at the same time,
// ordered by their priority, and then repeat once, firing in a
// staggered order that therefore ignores priority.
//
// We should see the following firing order:
// 1. Priority10Trigger15SecondRepeat
// 2. Priority5Trigger10SecondRepeat
// 3. Priority1Trigger5SecondRepeat
// 4. Priority1Trigger5SecondRepeat
// 5. Priority5Trigger10SecondRepeat
// 6. Priority10Trigger15SecondRepeat
// Calculate the start time of all triggers as 5 seconds from now
DateTimeOffset startTime = DateBuilder.FutureDate(5, IntervalUnit.Second);
// First trigger has priority of 1, and will repeat after 5 seconds
ITrigger trigger1 = TriggerBuilder.Create()
.WithIdentity("Priority1Trigger5SecondRepeat")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithRepeatCount(1).WithIntervalInSeconds(5))
.WithPriority(1)
.ForJob(job)
.Build();
// Second trigger has default priority of 5 (default), and will repeat after 10 seconds
ITrigger trigger2 = TriggerBuilder.Create()
.WithIdentity("Priority5Trigger10SecondRepeat")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithRepeatCount(1).WithIntervalInSeconds(10))
.ForJob(job)
.Build();
// Third trigger has priority 10, and will repeat after 15 seconds
ITrigger trigger3 = TriggerBuilder.Create()
.WithIdentity("Priority10Trigger15SecondRepeat")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithRepeatCount(1).WithIntervalInSeconds(15))
.WithPriority(10)
.ForJob(job)
.Build();
// Tell quartz to schedule the job using our trigger
await sched.ScheduleJob(job, trigger1);
await sched.ScheduleJob(trigger2);
await sched.ScheduleJob(trigger3);
// Start up the scheduler (nothing can actually run until the
// scheduler has been started)
await sched.Start();
Console.WriteLine("------- Started Scheduler -----------------");
// wait long enough so that the scheduler as an opportunity to
// fire the triggers
Console.WriteLine("------- Waiting 30 seconds... -------------");
await Task.Delay(TimeSpan.FromSeconds(30));
// shut down the scheduler
Console.WriteLine("------- Shutting Down ---------------------");
await sched.Shutdown(true);
Console.WriteLine("------- Shutdown Complete -----------------");
}
public virtual async Task Run(bool inClearJobs, bool inScheduleJobs)
{
// First we must get a reference to a scheduler
IScheduler sched = await SchedulerBuilder.Create()
.WithId("instance_one")
.WithName("TestScheduler")
.UseDefaultThreadPool(x => x.MaxConcurrency = 5)
.WithMisfireThreshold(TimeSpan.FromSeconds(60))
.UsePersistentStore(x =>
{
x.UseProperties = true;
x.UseClustering();
x.UseSqlServer(TestConstants.SqlServerConnectionString);
x.UseJsonSerializer();
})
.BuildScheduler();
// if running SQLite we need this
// properties["quartz.jobStore.lockHandler.type"] = "Quartz.Impl.AdoJobStore.UpdateLockRowSemaphore, Quartz";
if (inClearJobs)
{
Console.WriteLine("***** Deleting existing jobs/triggers *****");
await sched.Clear();
}
Console.WriteLine("------- Initialization Complete -----------");
if (inScheduleJobs)
{
Console.WriteLine("------- Scheduling Jobs ------------------");
string schedId = sched.SchedulerInstanceId;
int count = 1;
IJobDetail job = JobBuilder.Create <SimpleRecoveryJob>()
.WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("triger_" + count, schedId)
.StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second))
.WithSimpleSchedule(x => x.WithRepeatCount(20).WithInterval(TimeSpan.FromSeconds(5)))
.Build();
Console.WriteLine("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, trigger.GetNextFireTimeUtc(), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds);
count++;
job = JobBuilder.Create <SimpleRecoveryJob>()
.WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("triger_" + count, schedId)
.StartAt(DateBuilder.FutureDate(2, IntervalUnit.Second))
.WithSimpleSchedule(x => x.WithRepeatCount(20).WithInterval(TimeSpan.FromSeconds(5)))
.Build();
Console.WriteLine($"{job.Key} will run at: {trigger.GetNextFireTimeUtc()} and repeat: {trigger.RepeatCount} times, every {trigger.RepeatInterval.TotalSeconds} seconds");
await sched.ScheduleJob(job, trigger);
count++;
job = JobBuilder.Create <SimpleRecoveryStatefulJob>()
.WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("triger_" + count, schedId)
.StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second))
.WithSimpleSchedule(x => x.WithRepeatCount(20).WithInterval(TimeSpan.FromSeconds(3)))
.Build();
Console.WriteLine($"{job.Key} will run at: {trigger.GetNextFireTimeUtc()} and repeat: {trigger.RepeatCount} times, every {trigger.RepeatInterval.TotalSeconds} seconds");
await sched.ScheduleJob(job, trigger);
count++;
job = JobBuilder.Create <SimpleRecoveryJob>()
.WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("triger_" + count, schedId)
.StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second))
.WithSimpleSchedule(x => x.WithRepeatCount(20).WithInterval(TimeSpan.FromSeconds(4)))
.Build();
Console.WriteLine($"{job.Key} will run at: {trigger.GetNextFireTimeUtc()} & repeat: {trigger.RepeatCount}/{trigger.RepeatInterval}");
await sched.ScheduleJob(job, trigger);
count++;
job = JobBuilder.Create <SimpleRecoveryJob>()
.WithIdentity("job_" + count, schedId) // put triggers in group named after the cluster node instance just to distinguish (in logging) what was scheduled from where
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("triger_" + count, schedId)
.StartAt(DateBuilder.FutureDate(1, IntervalUnit.Second))
.WithSimpleSchedule(x => x.WithRepeatCount(20).WithInterval(TimeSpan.FromMilliseconds(4500)))
.Build();
Console.WriteLine($"{job.Key} will run at: {trigger.GetNextFireTimeUtc()} & repeat: {trigger.RepeatCount}/{trigger.RepeatInterval}");
await sched.ScheduleJob(job, trigger);
}
// jobs don't start firing until start() has been called...
Console.WriteLine("------- Starting Scheduler ---------------");
await sched.Start();
Console.WriteLine("------- Started Scheduler ----------------");
Console.WriteLine("------- Waiting for one hour... ----------");
await Task.Delay(TimeSpan.FromHours(1));
Console.WriteLine("------- Shutting Down --------------------");
await sched.Shutdown();
Console.WriteLine("------- Shutdown Complete ----------------");
}
