public void Setup()
{
scheduler = (StdScheduler) new StdSchedulerFactory().GetScheduler().GetAwaiter().GetResult();
var job = JobBuilder.Create <NoOpJob>().Build();
var trigger = (IOperableTrigger)TriggerBuilder.Create()
.ForJob(job.Key)
.WithSimpleSchedule()
.StartNow()
.Build();
trigger.FireInstanceId = "fire-instance-id";
trigger.SetNextFireTimeUtc(DateTimeOffset.UtcNow.AddSeconds(10));
var bundle = new TriggerFiredBundle(job, trigger, null, false, DateTimeOffset.UtcNow, null, null, null);
shell = new JobRunShell(scheduler, bundle);
}
private static IScheduler CreateScheduler(string customerCode)
{
var ramJobStore = new RAMJobStore();
var schedulerResources = new QuartzSchedulerResources
{
JobRunShellFactory = new StdJobRunShellFactory(),
JobStore = ramJobStore,
Name = $"TasksScheduler_{customerCode}"
};
var threadPool = new DefaultThreadPool();
threadPool.Initialize();
schedulerResources.ThreadPool = threadPool;
var quartzScheduler = new QuartzScheduler(schedulerResources, TimeSpan.Zero);
ITypeLoadHelper loadHelper;
try
{
loadHelper = ObjectUtils.InstantiateType <ITypeLoadHelper>(typeof(SimpleTypeLoadHelper));
}
catch (Exception e)
{
throw new SchedulerConfigException("Unable to instantiate type load helper: {0}".FormatInvariant(e.Message), e);
}
loadHelper.Initialize();
ramJobStore.Initialize(loadHelper, quartzScheduler.SchedulerSignaler);
var standartScheduler = new StdScheduler(quartzScheduler);
schedulerResources.JobRunShellFactory.Initialize(standartScheduler);
quartzScheduler.Initialize();
SchedulerRepository schedRep = SchedulerRepository.Instance;
schedRep.Bind(standartScheduler);
return(standartScheduler);
}
/// <summary>
/// Creates a scheduler using the specified thread pool and job store and
/// binds it to RMI.
/// </summary>
/// <param name="schedulerName">The name for the scheduler.</param>
/// <param name="schedulerInstanceId">The instance ID for the scheduler.</param>
/// <param name="threadPool">The thread pool for executing jobs</param>
/// <param name="jobStore">The type of job store</param>
/// <param name="schedulerPluginMap"></param>
/// <param name="idleWaitTime">The idle wait time. You can specify TimeSpan.Zero for
/// the default value, which is currently 30000 ms.</param>
/// <param name="dbFailureRetryInterval">The db failure retry interval.</param>
public virtual void CreateScheduler(string schedulerName, string schedulerInstanceId, IThreadPool threadPool,
IJobStore jobStore, IDictionary schedulerPluginMap, TimeSpan idleWaitTime,
TimeSpan dbFailureRetryInterval)
{
// Currently only one run-shell factory is available...
IJobRunShellFactory jrsf = new StdJobRunShellFactory();
// Fire everything up
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
SchedulingContext schedCtxt = new SchedulingContext();
schedCtxt.InstanceId = schedulerInstanceId;
SchedulerSchedulerResources qrs = new SchedulerSchedulerResources();
qrs.Name = schedulerName;
qrs.InstanceId = schedulerInstanceId;
qrs.JobRunShellFactory = jrsf;
qrs.ThreadPool = threadPool;
qrs.JobStore = jobStore;
// add plugins
if (schedulerPluginMap != null)
{
foreach (ISchedulerPlugin plugin in schedulerPluginMap.Values)
{
qrs.AddSchedulerPlugin(plugin);
}
}
SchedulerScheduler qs = new SchedulerScheduler(qrs, schedCtxt, idleWaitTime, dbFailureRetryInterval);
ITypeLoadHelper cch = new CascadingClassLoadHelper();
cch.Initialize();
jobStore.Initialize(cch, qs.SchedulerSignaler);
IScheduler scheduler = new StdScheduler(qs, schedCtxt);
// Initialize plugins now that we have a Scheduler instance.
if (schedulerPluginMap != null)
{
foreach (DictionaryEntry pluginEntry in schedulerPluginMap)
{
((ISchedulerPlugin)pluginEntry.Value).Initialize(
(string) pluginEntry.Key, scheduler);
}
}
jrsf.Initialize(scheduler, schedCtxt);
Log.Info(string.Format(CultureInfo.InvariantCulture, "Scheduler scheduler '{0}", scheduler.SchedulerName));
Log.Info(string.Format(CultureInfo.InvariantCulture, "Scheduler scheduler version: {0}", qs.Version));
SchedulerRepository schedRep = SchedulerRepository.Instance;
qs.AddNoGCObject(schedRep); // prevents the repository from being
// garbage collected
schedRep.Bind(scheduler);
}
protected internal virtual IScheduler Instantiate(SchedulerSchedulerResources rsrcs, SchedulerScheduler qs)
{
SchedulingContext schedCtxt = new SchedulingContext();
schedCtxt.InstanceId = rsrcs.InstanceId;
IScheduler sched = new StdScheduler(qs, schedCtxt);
return sched;
}
protected virtual IScheduler Instantiate(QuartzSchedulerResources rsrcs, QuartzScheduler qs)
{
IScheduler sched = new StdScheduler(qs);
return(sched);
}
