public virtual async Task Run()
{
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = await sf.GetScheduler();
Console.WriteLine("------- Initialization Complete -----------");
Console.WriteLine("------- Scheduling Jobs -------------------");
Random r = new Random();
// schedule 500 jobs to run
for (int count = 1; count <= NumberOfJobs; count++)
{
IJobDetail job = JobBuilder
.Create <SimpleJob>()
.WithIdentity("job" + count, "group_1")
.RequestRecovery() // ask scheduler to re-execute this job if it was in progress when the scheduler went down...
.Build();
// tell the job to delay some small amount... to simulate work...
long timeDelay = (long)(r.NextDouble() * 2500);
job.JobDataMap.Put(SimpleJob.DelayTime, timeDelay);
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger_" + count, "group_1")
.StartAt(DateBuilder.FutureDate(10000 + count * 100, IntervalUnit.Millisecond)) // space fire times a small bit
.Build();
await sched.ScheduleJob(job, trigger);
if (count % 25 == 0)
{
Console.WriteLine("...scheduled " + count + " jobs");
}
}
Console.WriteLine("------- Starting Scheduler ----------------");
// start the schedule
await sched.Start();
Console.WriteLine("------- Started Scheduler -----------------");
Console.WriteLine("------- Waiting five minutes... -----------");
// wait five minutes to give our jobs a chance to run
await Task.Delay(TimeSpan.FromMinutes(5));
// shut down the scheduler
Console.WriteLine("------- Shutting Down ---------------------");
await sched.Shutdown(true);
Console.WriteLine("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await sched.GetMetaData();
Console.WriteLine("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
public virtual void Run()
{
log.Info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
// get a "nice round" time a few seconds in the future...
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 15);
IJobDetail job = JobBuilder.Create <DumbInterruptableJob>()
.WithIdentity("interruptableJob1", "group1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "group1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(5).RepeatForever())
.Build();
DateTimeOffset ft = sched.ScheduleJob(job, trigger);
log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.Key, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds));
// start up the scheduler (jobs do not start to fire until
// the scheduler has been started)
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Starting loop to interrupt job every 7 seconds ----------");
for (int i = 0; i < 50; i++)
{
try
{
Thread.Sleep(TimeSpan.FromSeconds(7));
// tell the scheduler to interrupt our job
sched.Interrupt(job.Key);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted));
}
public SchedulerData GetSchedulerData()
{
IScheduler scheduler = _scheduler;
SchedulerMetaData metadata = scheduler.GetMetaData();
IList <ExecutingJobInfo> inProgressJobs = metadata.SchedulerRemote ? (IList <ExecutingJobInfo>) new ExecutingJobInfo[0] :
scheduler
.GetCurrentlyExecutingJobs()
.Select(x => new ExecutingJobInfo
{
UniqueTriggerKey = x.Trigger.Key.ToString(),
FireInstanceId = x.FireInstanceId
})
.ToList();
return(new SchedulerData
{
Name = scheduler.SchedulerName,
InstanceId = scheduler.SchedulerInstanceId,
JobGroups = GetJobGroups(scheduler),
Status = GetSchedulerStatus(scheduler),
JobsExecuted = metadata.NumberOfJobsExecuted,
JobsTotal = scheduler.IsShutdown ? 0 : scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()).Count,
RunningSince = metadata.RunningSince.ToDateTime(),
InProgress = inProgressJobs
});
}
public async Task Run(ILog log)
{
// our properties that enable XML configuration plugin
// and makes it watch for changes every two minutes (120 seconds)
var properties = new NameValueCollection
{
["quartz.plugin.triggHistory.type"] = "Quartz.Plugin.History.LoggingJobHistoryPlugin",
["quartz.plugin.jobInitializer.type"] = "Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin",
["quartz.plugin.jobInitializer.fileNames"] = "JobConfig.xml",
["quartz.plugin.jobInitializer.failOnFileNotFound"] = "true",
["quartz.plugin.jobInitializer.scanInterval"] = "10",
["quartz.scheduler.instanceName"] = "TestScheduler",
["quartz.scheduler.instanceId"] = "instance_one",
["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz",
["quartz.threadPool.threadCount"] = "5",
["quartz.jobStore.misfireThreshold"] = "60000",
["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz",
["quartz.jobStore.useProperties"] = "false",
["quartz.jobStore.dataSource"] = "default",
["quartz.jobStore.tablePrefix"] = "QRTZ_",
["quartz.jobStore.clustered"] = "true",
["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.SqlServerDelegate, Quartz",
["quartz.dataSource.default.connectionString"] =
@"Server=LENOVO-PC\SQLEXPRESS;Database=CountingKs;Trusted_Connection=True;",
["quartz.dataSource.default.provider"] = "SqlServer-20"
};
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = sf.GetScheduler();
//log.Warn("***** Deleting existing jobs/triggers *****");
//sched.Clear();
log.Info("------- Initialization Complete -----------");
log.Info("------- Not Scheduling any Jobs - relying on XML definitions --");
log.Info("------- Starting Scheduler ----------------");
// start the schedule
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting five minutes... -----------");
// wait five minutes to give our jobs a chance to run
await Task.Delay(TimeSpan.FromMinutes(5));
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
protected override void OnStop()
{
_log.Info("停止调度任务。");
_scheduler.Shutdown(true);
SchedulerMetaData metaData = _scheduler.GetMetaData();
_log.Info("执行了 " + metaData.NumberOfJobsExecuted + " 个任务。");
}
public async Task <SchedulerDto> SchedulerDetails(string schedulerName)
{
IScheduler scheduler = await GetScheduler(schedulerName).ConfigureAwait(false);
SchedulerMetaData metaData = await scheduler.GetMetaData().ConfigureAwait(false);
return(new SchedulerDto(scheduler, metaData));
}
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(TriggeringAJobUsingJobListenersExample));
log.Info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
// schedule a job to run immediately
IJobDetail job = JobBuilder.Create <SimpleJob1>()
.WithIdentity("job1")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("trigger1")
.StartNow()
.Build();
// Set up the listener
IJobListener listener = new SimpleJob1Listener();
IMatcher <JobKey> matcher = KeyMatcher <JobKey> .KeyEquals(job.Key);
sched.ListenerManager.AddJobListener(listener, matcher);
// schedule the job to run
await sched.ScheduleJob(job, trigger);
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
log.Info("------- Starting Scheduler ----------------");
await sched.Start();
// wait 30 seconds:
// note: nothing will run
log.Info("------- Waiting 30 seconds... --------------");
// wait 30 seconds to show jobs
await Task.Delay(TimeSpan.FromSeconds(30));
// executing...
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await sched.GetMetaData();
log.Info($"Executed {metaData.NumberOfJobsExecuted} jobs.");
}
public virtual void Run()
{
ILog log = LogManager.GetLogger(typeof(ListenerExample));
log.Info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
// schedule a job to run immediately
JobDetail job = new JobDetail("job1", "group1", typeof(SimpleJob1));
SimpleTrigger trigger = new SimpleTrigger("trigger1", "group1", DateTime.UtcNow, null, 0, TimeSpan.Zero);
// Set up the listener
IJobListener listener = new Job1Listener();
sched.AddJobListener(listener);
// make sure the listener is associated with the job
job.AddJobListener(listener.Name);
// schedule the job to run
sched.ScheduleJob(job, trigger);
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
log.Info("------- Starting Scheduler ----------------");
sched.Start();
// wait 30 seconds:
// note: nothing will run
log.Info("------- Waiting 30 seconds... --------------");
try
{
// wait 30 seconds to show jobs
Thread.Sleep(TimeSpan.FromSeconds(30));
// executing...
}
catch (ThreadInterruptedException)
{
}
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info(string.Format("Executed {0} jobs.", metaData.NumJobsExecuted));
}
/// <summary>
/// This example will start a server that will allow clients to remotely schedule jobs.
/// </summary>
/// <author> James House, Bill Kratzer
/// </author>
public virtual void Run()
{
ILog log = LogManager.GetLogger(typeof(RemoteServerExample));
NameValueCollection properties = new NameValueCollection();
properties["quartz.scheduler.instanceName"] = "RemoteServer";
// set thread pool info
properties["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz";
properties["quartz.threadPool.threadCount"] = "5";
properties["quartz.threadPool.threadPriority"] = "Normal";
// set remoting exporter
properties["quartz.scheduler.exporter.type"] = "Quartz.Simpl.RemotingSchedulerExporter, Quartz";
properties["quartz.scheduler.exporter.port"] = "555";
properties["quartz.scheduler.exporter.bindName"] = "QuartzScheduler";
properties["quartz.scheduler.exporter.channelType"] = "tcp";
properties["quartz.scheduler.exporter.channelName"] = "httpQuartz";
// reject non-local requests
properties["quartz.scheduler.exporter.rejectRemoteRequests"] = "true";
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Not scheduling any Jobs - relying on a remote client to schedule jobs --");
log.Info("------- Starting Scheduler ----------------");
// start the schedule
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting 5 minutes... ------------");
// wait to give our jobs a chance to run
try
{
Thread.Sleep(TimeSpan.FromMinutes(5));
}
catch (ThreadInterruptedException)
{
}
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
public async System.Threading.Tasks.Task StopAsync()
{
await _scheduler.Shutdown(true);
logger.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await _scheduler.GetMetaData();
logger.Info($"Executed {metaData.NumberOfJobsExecuted} jobs.");
}
public SchedulerDto(IScheduler scheduler, SchedulerMetaData metaData)
{
Name = scheduler.SchedulerName;
SchedulerInstanceId = scheduler.SchedulerInstanceId;
Status = SchedulerHeaderDto.TranslateStatus(scheduler);
ThreadPool = new SchedulerThreadPoolDto(metaData);
JobStore = new SchedulerJobStoreDto(metaData);
Statistics = new SchedulerStatisticsDto(metaData);
}
public override void Update(IScheduler scheduler)
{
this.Scheduler = scheduler;
this.Metadata = scheduler.GetMetaData();
this.Summary = this.Metadata.GetSummary();
this.NotifyOfPropertyChange(() => this.Metadata);
this.NotifyOfPropertyChange(() => this.Summary);
}
protected async override void OnStop()
{
//Shut down the scheduler when you are ready to close your program
await scheduler.Shutdown();
//Write scheduler MetaData
SchedulerMetaData metaData = await scheduler.GetMetaData();
Logger.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
Logger.Info("Service Stopped");
}
public void ShutDown()
{
if (sched != null)
{
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
}
protected void Page_Load(object sender, EventArgs e)
{
IScheduler scheduler = SchedulerPool.Scheduler;
SchedulerMetaData metaInfo = scheduler.GetMetaData();
scheduleName.InnerText = metaInfo.SchedulerName;
scheduleRunStatus.InnerText = metaInfo.Started ? "Running" : "Stop";
scheduleRunSTime.InnerText = metaInfo.RunningSince.Value.ToString("yyyy-MM-dd hh:mm:ss");
scheduleInstance.InnerText = metaInfo.SchedulerInstanceId;
threadSize.InnerText = metaInfo.ThreadPoolSize.ToString();
version.InnerText = metaInfo.Version;
jobCount.InnerText = JobDbScheduleFactory.JobDetailDao.GetJobCount().ToString();
}
public virtual void Run()
{
log.Info("------- Initializing ----------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Scheduling Jobs -------------------");
// get a "nice round" time a few seconds in the future...
DateTime ts = TriggerUtils.GetNextGivenSecondDate(null, 15);
JobDetail job = new JobDetail("interruptableJob1", "group1", typeof(DumbInterruptableJob));
SimpleTrigger trigger = new SimpleTrigger("trigger1", "group1", ts, null, SimpleTrigger.RepeatIndefinitely, TimeSpan.FromSeconds(5));
DateTime ft = sched.ScheduleJob(job, trigger);
log.Info(string.Format("{0} will run at: {1} and repeat: {2} times, every {3} seconds", job.FullName, ft.ToString("r"), trigger.RepeatCount, trigger.RepeatInterval.TotalSeconds));
// start up the scheduler (jobs do not start to fire until
// the scheduler has been started)
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Starting loop to interrupt job every 7 seconds ----------");
for (int i = 0; i < 50; i++)
{
try
{
Thread.Sleep(7 * 1000);
// tell the scheduler to interrupt our job
sched.Interrupt(job.Name, job.Group);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info(string.Format("Executed {0} jobs.", metaData.NumJobsExecuted));
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="scheduler">The <see cref="IScheduler"/> instance.</param>
/// <param name="metaData">The <see cref="SchedulerMetaData"/> meta data.</param>
public SchedulerDetails(IScheduler scheduler, SchedulerMetaData metaData)
{
Name = scheduler.SchedulerName;
SchedulerInstanceId = scheduler.SchedulerInstanceId;
Status = TranslateStatus(scheduler);
RunningSince = metaData.RunningSince?.LocalDateTime.ToString(CultureInfo.InvariantCulture) ?? "N / A";
QuartzVersion = metaData.Version;
ThreadPool = new SchedulerThreadPoolDetails(metaData);
JobStore = new SchedulerJobStoreDetails(metaData);
Statistics = new SchedulerStatisticsDetails(metaData);
JobKeys = scheduler.GetJobKeys(GroupMatcher <JobKey> .AnyGroup()).GetAwaiter().GetResult();
TriggerKeys = scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .AnyGroup()).GetAwaiter().GetResult();
GetJobTriggerPausedGroups(scheduler).GetAwaiter().GetResult();
}
public virtual void Run()
{
ILog log = LogManager.GetLogger(typeof(PlugInExample));
// our properties that enable XML configuration plugin
// and makes it watch for changes every two minutes (120 seconds)
var properties = new NameValueCollection();
properties["quartz.plugin.triggHistory.type"] = "Quartz.Plugin.History.LoggingJobHistoryPlugin";
properties["quartz.plugin.jobInitializer.type"] = "Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin";
properties["quartz.plugin.jobInitializer.fileNames"] = "quartz_jobs.xml";
properties["quartz.plugin.jobInitializer.failOnFileNotFound"] = "true";
properties["quartz.plugin.jobInitializer.scanInterval"] = "120";
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Not Scheduling any Jobs - relying on XML definitions --");
log.Info("------- Starting Scheduler ----------------");
// start the schedule
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting five minutes... -----------");
// wait five minutes to give our jobs a chance to run
try
{
Thread.Sleep(TimeSpan.FromMinutes(5));
}
catch (ThreadInterruptedException)
{
}
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
/// <summary>
/// This example will start a server that will allow clients to remotely schedule jobs.
/// </summary>
/// <author> James House, Bill Kratzer
/// </author>
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(RemoteServerJobSchedulingExample));
// set remoting exporter
// reject non-local requests
NameValueCollection properties = new NameValueCollection
{
["quartz.scheduler.instanceName"] = "RemoteServer",
["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz",
["quartz.threadPool.threadCount"] = "5",
["quartz.serializer.type"] = "json",
["quartz.scheduler.exporter.type"] = "Quartz.Simpl.RemotingSchedulerExporter, Quartz",
["quartz.scheduler.exporter.port"] = "555",
["quartz.scheduler.exporter.bindName"] = "QuartzScheduler",
["quartz.scheduler.exporter.channelType"] = "tcp",
["quartz.scheduler.exporter.channelName"] = "httpQuartz",
["quartz.scheduler.exporter.rejectRemoteRequests"] = "true"
};
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Not scheduling any Jobs - relying on a remote client to schedule jobs --");
log.Info("------- Starting Scheduler ----------------");
// start the schedule
await sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting 5 minutes... ------------");
// wait to give our jobs a chance to run
await Task.Delay(TimeSpan.FromMinutes(5));
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
public virtual void Run()
{
//Set Adapter
_logger.Info("------- Initializing -------------------");
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
_logger.Info("------- Initialization Complete --------");
_logger.Info("------- Scheduling Jobs ----------------");
// jobs can be scheduled before sched.start() has been called
JobDetail job = new JobDetail("job1", "group1", typeof(CDRJob));
string cronExpression = ConfigurationSettings.AppSettings["cronExpression"];
CronTrigger trigger = new CronTrigger("trigger1", "group1", "job1", "group1", cronExpression);
sched.AddJob(job, true);
DateTime ft = sched.ScheduleJob(trigger);
#if !NET_35
ft = trigger.TimeZone.ToLocalTime(ft);
#else
ft = TimeZoneInfo.ConvertTimeFromUtc(ft, trigger.TimeZone);
#endif
_logger.Info(string.Format("{0} has been scheduled to run at: {1} and repeat based on expression: {2}", job.FullName, ft.ToString("r"), trigger.CronExpressionString));
_logger.Info("------- Starting Scheduler ----------------");
// All of the jobs have been added to the scheduler, but none of the
// jobs
// will run until the scheduler has been started
sched.Start();
try
{
// wait 5 seconds to show jobs
Thread.Sleep(5 * 1000);
// executing...
}
catch (ThreadInterruptedException)
{
}
SchedulerMetaData metaData = sched.GetMetaData();
_logger.Info(string.Format("Executed {0} jobs.", metaData.NumJobsExecuted));
}
public async void JobExecuted(IScheduler sched)
{
int count = 0;
try
{
SchedulerMetaData metaData = await sched.GetMetaData();
count = metaData.NumberOfJobsExecuted;
Console.WriteLine("Jobs Executed:" + count);
}
catch (Exception err)
{
Console.WriteLine(err.Message);
}
}
public async Task RunAsync()
{
IScheduler scheduler = await StdSchedulerFactory.GetDefaultScheduler();
DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(null, 10);
IJobDetail job = JobBuilder.Create <InterruptJob>()
.WithIdentity("job1", "jobGroup1")
.Build();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("trigger1", "triggerGroup1")
.StartAt(startTime)
.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever())
.Build();
DateTimeOffset df = await scheduler.ScheduleJob(job, trigger);
ConsoleExtend.WriteLineRed($"作业【{job.Key}】 触发器【{trigger.Key}】 执行时间【{df.LocalDateTime}】 " +
$"执行时间间隔【{trigger.RepeatInterval.Seconds}】s 重复执行次数【{trigger.RepeatCount}】");
await scheduler.Start();
Console.WriteLine("每7秒中断一次调度");
for (int i = 0; i < 50; i++)
{
await Task.Delay(TimeSpan.FromSeconds(7));
try
{
await scheduler.Interrupt(job.Key);
}
catch (Exception ex)
{
ConsoleExtend.WriteLineError(ex.Message);
}
}
await scheduler.Shutdown(true);
SchedulerMetaData metaData = await scheduler.GetMetaData();
ConsoleExtend.WriteLineDebug2($"执行了 {metaData.NumberOfJobsExecuted} 次作业.");
ConsoleExtend.WriteLineDebug2($"作业【{job.Key}】 中循环共执行了【{InterruptJob.ExecutedCount}】次" +
$"，其中成功【{InterruptJob.SuccessfulCount}】次，中断【{InterruptJob.InterruptlCount}】次");
}
public virtual async Task Run()
{
ILog log = LogProvider.GetLogger(typeof(RunningJobsByPlugInXmlConfigurationExample));
// our configuration that enables XML configuration plugin
// and makes it watch for changes every two minutes (120 seconds)
var properties = new NameValueCollection
{
["quartz.plugin.triggHistory.type"] = "Quartz.Plugin.History.LoggingJobHistoryPlugin, Quartz.Plugins",
["quartz.plugin.jobInitializer.type"] = "Quartz.Plugin.Xml.XMLSchedulingDataProcessorPlugin, Quartz.Plugins",
["quartz.plugin.jobInitializer.fileNames"] = "quartz_jobs.xml",
["quartz.plugin.jobInitializer.failOnFileNotFound"] = "true",
["quartz.plugin.jobInitializer.scanInterval"] = "120"
};
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory(properties);
IScheduler sched = await sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- Not Scheduling any Jobs - relying on XML definitions --");
log.Info("------- Starting Scheduler ----------------");
// start the schedule
await sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting five minutes... -----------");
// wait five minutes to give our jobs a chance to run
await Task.Delay(TimeSpan.FromMinutes(5));
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
await sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = await sched.GetMetaData();
log.Info("Executed " + metaData.NumberOfJobsExecuted + " jobs.");
}
public void Shutdown()
{
if (isClustered)
{
log.Info("------- Cluster Disconnect, Not Shutting Down ---------------------");
return;
}
// XTradeMQLServer.Stop();
if (bInitialized)
{
log.Info("------- Shutting Down ---------------------");
SchedulerMetaData metaData = sched.GetMetaData().Result;
log.Info(string.Format("Executed {0} jobs.", metaData.NumberOfJobsExecuted));
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
}
}
public JsonResult GetSchedulerInfo()
{
string json = string.Empty;
bool ret = false;
try
{
SchedulerMetaData data = sched.GetMetaData();
json = JsonConvert.SerializeObject(data);
ret = true;
}
catch (Exception ex)
{
json = ex.Message;
}
return(Json(new { Result = ret, Data = json }, JsonRequestBehavior.AllowGet));
}
public static SchedulerSummary Map(this SchedulerMetaData x)
{
return(new SchedulerSummary
{
InStandbyMode = x.InStandbyMode,
JobStoreClustered = x.JobStoreClustered,
JobStoreSupportsPersistence = x.JobStoreSupportsPersistence,
JobStoreType = x.JobStoreType.FullName,
NumberOfJobsExecuted = x.NumberOfJobsExecuted,
RunningSince = x.RunningSince,
SchedulerInstanceId = x.SchedulerInstanceId,
SchedulerName = x.SchedulerName,
SchedulerRemote = x.SchedulerRemote,
SchedulerType = x.SchedulerType.FullName,
Shutdown = x.Shutdown,
Started = x.Started,
ThreadPoolSize = x.ThreadPoolSize,
ThreadPoolType = x.ThreadPoolType.FullName,
Version = x.Version,
});
}
public virtual bool Initialize()
{
log.Info("------- Initializing Scheduler -------------------");
try
{
XTradeConfig config = MainService.thisGlobal.Container.Resolve <XTradeConfig>();
var properties = config.Quartz();
// First we must get a reference to a scheduler
sf = new StdSchedulerFactory(properties);
sched = sf.GetScheduler().Result;
// All of the jobs have been added to the scheduler, but none of the jobs
// will run until the scheduler has been started
sched.Start();
while (!sched.IsStarted)
{
log.Info("Waiting for scheduler to start.");
Thread.Sleep(1000);
}
log.Info("IsStarted=" + sched.IsStarted);
log.Info("InstanceId=" + sched.SchedulerInstanceId);
log.Info("SchedulerName=" + sched.SchedulerName);
SchedulerMetaData metadata = sched.GetMetaData().Result;
log.Info("IS REMOTE (CLUSTERED )=" + metadata.SchedulerRemote);
isClustered = metadata.SchedulerRemote;
RunJobSupervisor();
}
catch (Exception ex)
{
log.Error("Error Initializing Scheduler: " + ex.Message);
bInitialized = false;
return(bInitialized);
}
bInitialized = true;
return(bInitialized);
}
public virtual void Run()
{
ILog log = LogManager.GetLogger(typeof(PlugInExample));
// First we must get a reference to a scheduler
ISchedulerFactory sf = new StdSchedulerFactory();
IScheduler sched = sf.GetScheduler();
log.Info("------- Initialization Complete -----------");
log.Info("------- (Not Scheduling any Jobs - relying on XML definitions --");
log.Info("------- Starting Scheduler ----------------");
// start the schedule
sched.Start();
log.Info("------- Started Scheduler -----------------");
log.Info("------- Waiting five minutes... -----------");
// wait five minutes to give our jobs a chance to run
try
{
Thread.Sleep(TimeSpan.FromMinutes(5));
}
catch (ThreadInterruptedException)
{
}
// shut down the scheduler
log.Info("------- Shutting Down ---------------------");
sched.Shutdown(true);
log.Info("------- Shutdown Complete -----------------");
SchedulerMetaData metaData = sched.GetMetaData();
log.Info("Executed " + metaData.NumJobsExecuted + " jobs.");
}
public SchedulerDetails GetSchedulerDetails()
{
IScheduler scheduler = _scheduler;
SchedulerMetaData metadata = scheduler.GetMetaData();
return(new SchedulerDetails
{
InStandbyMode = metadata.InStandbyMode,
JobStoreClustered = metadata.JobStoreClustered,
JobStoreSupportsPersistence = metadata.JobStoreSupportsPersistence,
JobStoreType = metadata.JobStoreType,
NumberOfJobsExecuted = metadata.NumberOfJobsExecuted,
RunningSince = metadata.RunningSince.ToUnixTicks(),
SchedulerInstanceId = metadata.SchedulerInstanceId,
SchedulerName = metadata.SchedulerName,
SchedulerRemote = metadata.SchedulerRemote,
SchedulerType = metadata.SchedulerType,
Shutdown = metadata.Shutdown,
Started = metadata.Started,
ThreadPoolSize = metadata.ThreadPoolSize,
ThreadPoolType = metadata.ThreadPoolType,
Version = metadata.Version
});
}
public SchedulerStatisticsDto(SchedulerMetaData metaData)
{
NumberOfJobsExecuted = metaData.NumberOfJobsExecuted;
}
private void outputMetadata(SchedulerMetaData metaData)
{
_Log.InfoFormat("Scheduler Metadata:\nRunning Since: {0}", metaData.RunningSince);
}
public SchedulerStatisticsDto(SchedulerMetaData metaData)
{
NumberOfJobsExecuted = metaData.NumberOfJobsExecuted;
}
