public override IScheduleBuilder GetScheduleBuilder()
{
SimpleScheduleBuilder sb = SimpleScheduleBuilder.Create()
.WithInterval(RepeatInterval)
.WithRepeatCount(RepeatCount);
switch (MisfireInstruction)
{
case Quartz.MisfireInstruction.SimpleTrigger.FireNow: sb.WithMisfireHandlingInstructionFireNow();
break;
case Quartz.MisfireInstruction.SimpleTrigger.RescheduleNextWithExistingCount: sb.WithMisfireHandlingInstructionNextWithExistingCount();
break;
case Quartz.MisfireInstruction.SimpleTrigger.RescheduleNextWithRemainingCount: sb.WithMisfireHandlingInstructionNextWithRemainingCount();
break;
case Quartz.MisfireInstruction.SimpleTrigger.RescheduleNowWithExistingRepeatCount: sb.WithMisfireHandlingInstructionNowWithExistingCount();
break;
case Quartz.MisfireInstruction.SimpleTrigger.RescheduleNowWithRemainingRepeatCount: sb.WithMisfireHandlingInstructionNowWithRemainingCount();
break;
}
return(sb);
}
public async Task TestStoreAndRetrieveTriggers()
{
RAMJobStore store = new RAMJobStore();
// Store jobs and triggers.
for (int i = 0; i < 10; i++)
{
IJobDetail job = JobBuilder.Create <NoOpJob>().WithIdentity("job" + i).Build();
await store.StoreJob(job, true);
SimpleScheduleBuilder schedule = SimpleScheduleBuilder.Create();
ITrigger trigger = TriggerBuilder.Create().WithIdentity("job" + i).WithSchedule(schedule).ForJob(job).Build();
await store.StoreTrigger((IOperableTrigger)trigger, true);
}
// Retrieve job and trigger.
for (int i = 0; i < 10; i++)
{
JobKey jobKey = JobKey.Create("job" + i);
IJobDetail storedJob = await store.RetrieveJob(jobKey);
Assert.AreEqual(jobKey, storedJob.Key);
TriggerKey triggerKey = new TriggerKey("job" + i);
ITrigger storedTrigger = await store.RetrieveTrigger(triggerKey);
Assert.AreEqual(triggerKey, storedTrigger.Key);
}
}
public async Task Consume(ConsumeContext <ScheduleMessage> context)
{
var correlationId = context.Message.CorrelationId.ToString("N");
var jobKey = new JobKey(correlationId);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("ScheduleMessage: {0} at {1}", jobKey, context.Message.ScheduledTime);
}
var jobDetail = await CreateJobDetail(context, context.Message.Destination, jobKey).ConfigureAwait(false);
var trigger = TriggerBuilder.Create()
.ForJob(jobDetail)
.StartAt(context.Message.ScheduledTime)
.WithSchedule(SimpleScheduleBuilder.Create().WithMisfireHandlingInstructionFireNow())
.WithIdentity(new TriggerKey(correlationId))
.Build();
if (await _scheduler.CheckExists(trigger.Key).ConfigureAwait(false))
{
await _scheduler.RescheduleJob(trigger.Key, trigger).ConfigureAwait(false);
}
else
{
await _scheduler.ScheduleJob(jobDetail, trigger).ConfigureAwait(false);
}
}
public async Task <TriggerPropertyBundle> LoadExtendedTriggerProperties(
ConnectionAndTransactionHolder conn,
TriggerKey triggerKey,
CancellationToken cancellationToken = default)
{
using (var cmd = DbAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectSimpleTrigger, TablePrefix)))
{
DbAccessor.AddCommandParameter(cmd, "schedulerName", SchedName);
DbAccessor.AddCommandParameter(cmd, "triggerName", triggerKey.Name);
DbAccessor.AddCommandParameter(cmd, "triggerGroup", triggerKey.Group);
using (var rs = await cmd.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
{
if (await rs.ReadAsync(cancellationToken).ConfigureAwait(false))
{
int repeatCount = rs.GetInt32(AdoConstants.ColumnRepeatCount);
TimeSpan repeatInterval = DbAccessor.GetTimeSpanFromDbValue(rs[AdoConstants.ColumnRepeatInterval]) ?? TimeSpan.Zero;
int timesTriggered = rs.GetInt32(AdoConstants.ColumnTimesTriggered);
SimpleScheduleBuilder sb = SimpleScheduleBuilder.Create()
.WithRepeatCount(repeatCount)
.WithInterval(repeatInterval);
string[] statePropertyNames = { "timesTriggered" };
object[] statePropertyValues = { timesTriggered };
return(new TriggerPropertyBundle(sb, statePropertyNames, statePropertyValues));
}
}
throw new InvalidOperationException("No record found for selection of Trigger with key: '" + triggerKey + "' and statement: " + AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectSimpleTrigger, TablePrefix));
}
}
public TriggerPropertyBundle LoadExtendedTriggerProperties(ConnectionAndTransactionHolder conn, TriggerKey triggerKey)
{
using (IDbCommand cmd = adoUtil.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectSimpleTrigger, tablePrefix, schedNameLiteral)))
{
adoUtil.AddCommandParameter(cmd, "triggerName", triggerKey.Name);
adoUtil.AddCommandParameter(cmd, "triggerGroup", triggerKey.Group);
using (IDataReader rs = cmd.ExecuteReader())
{
if (rs.Read())
{
int repeatCount = rs.GetInt32(AdoConstants.ColumnRepeatCount);
long repeatInterval = rs.GetInt64(AdoConstants.ColumnRepeatInterval);
int timesTriggered = rs.GetInt32(AdoConstants.ColumnTimesTriggered);
SimpleScheduleBuilder sb = SimpleScheduleBuilder.Create()
.WithRepeatCount(repeatCount)
.WithInterval(TimeSpan.FromMilliseconds(repeatInterval));
string[] statePropertyNames = { "timesTriggered" };
object[] statePropertyValues = { timesTriggered };
return(new TriggerPropertyBundle(sb, statePropertyNames, statePropertyValues));
}
}
throw new InvalidOperationException("No record found for selection of Trigger with key: '" + triggerKey + "' and statement: " + AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectSimpleTrigger, tablePrefix, schedNameLiteral));
}
}
private static void zConfigureHourlySchedule(List <TriggerBuilder> triggerBuilderList, HourlySchedule schedule)
{
SimpleScheduleBuilder sb = zCreateSimpleSchedule(schedule)
.WithInterval(schedule.HourlyRecurrence)
.RepeatForever();
triggerBuilderList.Add(TriggerBuilder.Create().WithSchedule(sb));
}
/// <summary>
/// 设置重复执行次数
/// </summary>
private void SetRepeatCount(SimpleScheduleBuilder builder, JobBase job)
{
if (job.GetRepeatCount() == null)
{
builder.RepeatForever();
return;
}
builder.WithRepeatCount(job.GetRepeatCount().SafeValue());
}
public static void ConfigureBackgroundJobs(IContainer container, ServiceConfigurator <ITopshelfService> service)
{
var jobRegistrations =
container.ComponentRegistry.Registrations.Where(
x =>
x.Metadata.ContainsKey(JobConfigurationMetaDataItemNames.ComponentType) &&
x.Metadata[JobConfigurationMetaDataItemNames.ComponentType].ToString().Equals(typeof(IMessageDispatcherJob).Name, StringComparison.CurrentCultureIgnoreCase)
);
foreach (var jobRegistration in jobRegistrations)
{
var componentRegistration = jobRegistration;
if ((componentRegistration.Services.First() as KeyedService) == null)
{
continue;
}
var jobName = ((KeyedService)componentRegistration.Services.First()).ServiceKey.ToString();
var jobRepeatFrequencyInSeconds = componentRegistration.Metadata.ContainsKey(JobConfigurationMetaDataItemNames.RepeatFrequencyInSeconds)
? int.Parse(componentRegistration.Metadata[JobConfigurationMetaDataItemNames.RepeatFrequencyInSeconds].ToString())
: int.Parse(JobConfigurationMetaDataItemValues.RepeatFrequencyInSeconds);
var jobRepeatCount = componentRegistration.Metadata.ContainsKey(JobConfigurationMetaDataItemNames.RepeatCount)
? int.Parse(componentRegistration.Metadata[JobConfigurationMetaDataItemNames.RepeatCount].ToString())
: int.Parse(JobConfigurationMetaDataItemValues.RepeatCount);
var componentFullName = componentRegistration.Activator.LimitType.FullName;
var componentName = componentRegistration.Activator.LimitType.Name;
var componentType = componentRegistration.Activator.LimitType.Assembly.GetType(componentFullName);
service.ScheduleQuartzJob(q =>
{
q.WithJob(() =>
{
var jobDetail = new JobDetailImpl(jobName, null, componentType);
jobDetail.JobDataMap.Put(JobDataMapKeys.Name, jobName);
jobDetail.JobDataMap.Put(JobDataMapKeys.ComponentName, componentName);
jobDetail.JobDataMap.Put(JobDataMapKeys.ComponentFullName, componentName);
foreach (var item in componentRegistration.Metadata)
{
jobDetail.JobDataMap.Put(item.Key, item.Value);
}
return(jobDetail);
});
q.AddTrigger(() => TriggerBuilder.Create()
.WithIdentity(string.Format("{0}-Trigger", jobName), null)
.WithSchedule(jobRepeatCount > 0
? SimpleScheduleBuilder.RepeatSecondlyForTotalCount(jobRepeatCount, jobRepeatFrequencyInSeconds)
: SimpleScheduleBuilder.RepeatSecondlyForever(jobRepeatFrequencyInSeconds)
)
.Build());
});
}
}
public void Run(object input)
{
// Create the schedule for the 'Execute' method.
var job = JobBuilder.Create <ScheduledWork>().Build();
var schedule = SimpleScheduleBuilder.RepeatHourlyForTotalCount(10);
var trigger = TriggerBuilder.Create().WithSchedule(schedule).StartNow().Build();
ScheduleManager.Instance.ScheduleJob(job, trigger);
}
public void ConfigureMessage(SimpleScheduleBuilder scheduleBuilder)
{
scheduleBuilder.WithIntervalInSeconds((int) _scheduleMeRepetitive.RepetitionInterval.TotalSeconds);
if(_scheduleMeRepetitive.NumberOfRepetitions >= 0)
scheduleBuilder.WithRepeatCount(_scheduleMeRepetitive.NumberOfRepetitions);
if(_scheduleMeRepetitive.NumberOfRepetitions < 0)
scheduleBuilder.RepeatForever();
}
public void TesDirectivesNoOverwriteWithIgnoreDups()
{
// create temp file
string tempFileName = XMLSchedulingDataProcessor.QuartzXmlFileName;
using (TextWriter writer = new StreamWriter(tempFileName, false))
{
using (StreamReader reader = new StreamReader(ReadJobXmlFromEmbeddedResource("directives_overwrite_no-ignoredups.xml")))
{
writer.Write(reader.ReadToEnd());
writer.Flush();
writer.Close();
}
}
IScheduler scheduler = null;
try
{
StdSchedulerFactory factory = new StdSchedulerFactory();
scheduler = StdSchedulerFactory.GetDefaultScheduler();
// Setup existing job with same names as in xml data.
IJobDetail job = JobBuilder.Create <NoOpJob>()
.WithIdentity("job1")
.Build();
ITrigger trigger = TriggerBuilder.Create()
.WithIdentity("job1")
.WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
scheduler.ScheduleJob(job, trigger);
job = JobBuilder.Create <NoOpJob>()
.WithIdentity("job2")
.Build();
trigger = TriggerBuilder.Create().WithIdentity("job2").WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever()).Build();
scheduler.ScheduleJob(job, trigger);
// Now load the xml data with directives: overwrite-existing-data=false, ignore-duplicates=true
ITypeLoadHelper loadHelper = new SimpleTypeLoadHelper();
loadHelper.Initialize();
XMLSchedulingDataProcessor processor = new XMLSchedulingDataProcessor(loadHelper);
processor.ProcessFileAndScheduleJobs(tempFileName, scheduler);
Assert.AreEqual(2, scheduler.GetJobKeys(GroupMatcher <JobKey> .GroupEquals("DEFAULT")).Count);
Assert.AreEqual(2, scheduler.GetTriggerKeys(GroupMatcher <TriggerKey> .GroupEquals("DEFAULT")).Count);
}
finally
{
if (scheduler != null)
{
scheduler.Shutdown();
}
}
}
private static async Task ConfigureJob(CancellationToken cancellationToken, IScheduler scheduler)
{
var job = JobBuilder.Create <HealthcheckScheduledJob>().Build();
var trigger = TriggerBuilder.Create()
.StartNow()
.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(10)).Build();
await scheduler.ScheduleJob(job, trigger, cancellationToken);
}
public bool Start(HostControl hostControl)
{
IScheduler scheduler = StdSchedulerFactory.GetDefaultScheduler();
scheduler.Start();
CreateJob(typeof(Job), SimpleScheduleBuilder.RepeatSecondlyForever(1), scheduler);
return(true);
}
static void ConfigureScheduler(ServiceConfigurator <ServiceCore> svc)
{
svc.ScheduleQuartzJob(q => {
q.WithJob(JobBuilder.Create <HeartbeatJob>()
.WithIdentity("Heartbeat", "Maintenance")
.Build);
q.AddTrigger(() => TriggerBuilder.Create()
.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(30)).Build());
});
}
//This will create the time trigger of when to fire off the job
//Also adds to the job and associated trigger to the scheduler service
//Typically used, when already have a billpayID
//USED BY MODIFY JOB
public void createScheduledJobService(int billPayID, int accountNumber, int payeeID, decimal amount, char period, DateTime schedDate)
{
Debug.WriteLine("\n\n######### Creating Scheduled Job and trigger");
//Type changes are needed because the job dictionary cannot accept decimal
double convertedAmount = (double)amount;
string convertedStringDate = schedDate.ToString(dateFormat, CultureInfo.InvariantCulture);
DateTimeOffset startTime = DateTimeOffset.Now.AddMinutes(1); // schedule for 1 minute in the future to start fireing
Debug.WriteLine("###### Curent time: " + DateTime.Now.ToString());
Debug.WriteLine("###### Job Set to Fire at: " + startTime);
//If statements in charged of increasing the date depending on the type
if (period == 'S')
{
//This creates the trrigger, eg scheduling information
triggerDetail = TriggerBuilder
.Create()
.WithIdentity(billPayID.ToString(), "TriggerGrp1")
.StartAt(startTime) //Specify when to start first fire
//Specify when the trigger should start to be active. Eg telling when a job should start to take effect
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForTotalCount(1))
.Build();
}
else
{
//Set the repeat per minute indefintely here
//This creates the trrigger, eg scheduling information
triggerDetail = TriggerBuilder
.Create()
.WithIdentity(billPayID.ToString(), "TriggerGrp1")
.StartAt(startTime) //Specify when to start first fire
//Specify when the trigger should start to be active. Eg telling when a job should start to take effect
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForever())
//.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever())
.Build();
}
//Below Creates a job aswell as provide the details and information to the job as a map
//Create Job with the name "MyJob", Group: "MyJobGroup"
IJobDetail jobDetail = JobBuilder
.Create(typeof(BillPayJob))
.WithIdentity(billPayID.ToString(), "JobGroup1")
.UsingJobData("Account_Number", accountNumber)
.UsingJobData("Payee_ID", payeeID)
.UsingJobData("Amount", convertedAmount)
.UsingJobData("Date", convertedStringDate) //< can only support string as a date format, no datetime
.UsingJobData("Period", period)
.Build();
//Associate trigger with job and add to schedule
sched.ScheduleJob(jobDetail, triggerDetail);
}
private void SetSimpleRepeatCount(JobConfig jobConfig, SimpleScheduleBuilder simpleScheduleBuilder)
{
if (jobConfig.ExecCount.HasValue)
{
simpleScheduleBuilder.WithRepeatCount(jobConfig.ExecCount.Value);
}
else
{
simpleScheduleBuilder.RepeatForever();
}
}
private static void ConfigureJob(ServiceConfigurator <ServiceCore.ServiceCore> svc, JobConfiguration job)
{
svc.ScheduleQuartzJob(q =>
{
q.WithJob(JobBuilder.Create(job.JobType)
.WithDescription(job.JobDescription)
.Build);
q.AddTrigger(() => TriggerBuilder.Create()
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForever(job.JobTriggerInMinutes)).Build());
});
}
private static void ScheduleSyncTeamsJob(IScheduler scheduler)
{
var syncTeamsJob = JobBuilder.Create <SyncTeamsJob>().Build();
var syncTeamsTrigger =
TriggerBuilder
.Create()
.StartNow()
.WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever(1))
.Build();
scheduler.ScheduleJob(syncTeamsJob, syncTeamsTrigger).ConfigureAwait(true);
}
private static void ScheduleProcessInboxJob(IScheduler scheduler)
{
var processInboxJob = JobBuilder.Create <ProcessInboxJob>().Build();
var processInboxTrigger =
TriggerBuilder
.Create()
.StartNow()
.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(15))
.Build();
scheduler.ScheduleJob(processInboxJob, processInboxTrigger).ConfigureAwait(true);
}
public static void AddJobAndTrigger <T>(this IServiceCollectionQuartzConfigurator quartz, IConfiguration config) where T : IJob
{
string jobName = typeof(T).Name;
var jobKey = new JobKey(jobName);
quartz.AddJob <T>(opts => opts.WithIdentity(jobKey));
quartz.AddTrigger(opts => opts
.ForJob(jobKey)
.WithIdentity(jobName + "-trigger")
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForever()));
}
public async Task TestTriggerMisfiredMessage()
{
IOperableTrigger t = (IOperableTrigger)TriggerBuilder.Create()
.WithSchedule(SimpleScheduleBuilder.Create())
.Build();
t.JobKey = new JobKey("name", "group");
await plugin.TriggerMisfired(t);
Assert.That(plugin.InfoMessages.Count, Is.EqualTo(1));
}
public IScheduleBuilder GetScheduleBuilder()
{
var builder = SimpleScheduleBuilder.Create();
if (this.RepeatCount < 0)
{
builder.RepeatForever();
}
builder.WithInterval(this.Interval);
return(builder);
}
private static void ConfigureBackgroundJobs(ServiceConfigurator <ServiceCore> svc)
{
svc.UsingQuartzJobFactory(() => _container.Resolve <IJobFactory>());
svc.ScheduleQuartzJob(q =>
{
q.WithJob(JobBuilder.Create <HeartbeatJob>()
.WithIdentity("Heartbeat", "Maintenance")
.Build);
q.AddTrigger(() => TriggerBuilder.Create()
.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(2)).Build());
});
}
private void DefinirAgendamentoExecucao()
{
RegistroLog.RegistarLogInfo(Mensagem.SistemaAgendamentoInicio);
ISchedulerFactory schedFact = new StdSchedulerFactory();
ITrigger trigger;
this.scheduler = schedFact.GetScheduler();
//this.scheduler.Start();
IJobDetail job = JobBuilder.Create <FrmArquivoDataSUS>()
.WithIdentity("JobAplicacao", "groupAplicacao")
.Build();
if (this.gbxAcadaMinuto.Enabled)
{
trigger = TriggerBuilder.Create()
.StartNow()
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForever(Convert.ToInt32(this.nudCadaMinuto.Value.ToString())))
.Build();
}
else
{
CronScheduleBuilder cronScheduleBuilder;
Enumeradores.DiaDaSemana dia = Enumeradores.ConverterObject2DiaDaSemana(this.ddlDiaAgendamento.SelectedValue);
if (dia == Enumeradores.DiaDaSemana.AllDays)
{
cronScheduleBuilder = CronScheduleBuilder.DailyAtHourAndMinute(Convert.ToInt32(this.nudHora.Value), Convert.ToInt32(this.nudMinuto.Value));
}
else
{
cronScheduleBuilder = CronScheduleBuilder.WeeklyOnDayAndHourAndMinute((DayOfWeek)dia, Convert.ToInt32(this.nudHora.Value), Convert.ToInt32(this.nudMinuto.Value));
}
trigger = TriggerBuilder.Create()
.StartNow()
.WithSchedule(cronScheduleBuilder)
.Build();
}
this.scheduler.ScheduleJob(job, trigger);
this.scheduler.Start();
this.lblUltimaExecucao.Text = "--/--/---- --:--:--";
this.lblProximaExecucao.Text = trigger.GetNextFireTimeUtc().Value.LocalDateTime.ToString(Constantes.FormatoDataHora);
RegistroLog.RegistarLogInfo(Mensagem.SistemaAgendamentoFim);
}
private ITrigger GetTrigger(IJobDetail jobDetail)
{
TriggerBuilder builder = TriggerBuilder
.Create()
.ForJob(jobDetail)
.WithDescription(txtTriggerDescription.Text.Trim())
.WithIdentity(new TriggerKey(txtTriggerName.Text.Trim(), txtTriggerGroup.Text.Trim()));
if (cboTriggerType.SelectedText == "Simple")
{
return(builder.WithSchedule(SimpleScheduleBuilder.Create()).Build());
}
return(builder.WithSchedule(CronScheduleBuilder.CronSchedule(txtCronExpression.Text)).Build());
}
private void DefinirAgendamentoExecucao()
{
RegistroLog.RegistarLogInfo(Mensagem.SistemaAgendamentoInicio);
ISchedulerFactory schedFact = new StdSchedulerFactory();
ITrigger trigger;
this.scheduler = schedFact.GetScheduler();
IJobDetail job = JobBuilder.Create <ServicoArquivosDataSUS>()
.WithIdentity("JobServico", "groupServico")
.Build();
if (this.executarAcadaMinuto > 0)
{
trigger = TriggerBuilder.Create()
.StartNow()
.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForever(this.executarAcadaMinuto))
.Build();
}
else
{
CronScheduleBuilder cronScheduleBuilder;
Enumeradores.DiaDaSemana dia = Enumeradores.ConverterObject2DiaDaSemana(this.diaAgendamento);
if (dia == Enumeradores.DiaDaSemana.AllDays)
{
cronScheduleBuilder = CronScheduleBuilder.DailyAtHourAndMinute(this.hora, this.minuto);
}
else
{
cronScheduleBuilder = CronScheduleBuilder.WeeklyOnDayAndHourAndMinute((DayOfWeek)dia, this.hora, this.minuto);
}
trigger = TriggerBuilder.Create()
.StartNow()
.WithSchedule(cronScheduleBuilder)
.Build();
}
this.scheduler.ScheduleJob(job, trigger);
this.scheduler.Start();
RegistroLog.RegistarLogInfo(Mensagem.ServicoProximaExecucao + " - " + trigger.GetNextFireTimeUtc().Value.LocalDateTime.ToString(Constantes.FormatoDataHora));
RegistroLog.RegistarLogInfo(Mensagem.SistemaAgendamentoFim);
}
public async Task TestTriggerCompleteMessage()
{
ITrigger t = TriggerBuilder.Create()
.WithSchedule(SimpleScheduleBuilder.Create())
.Build();
IJobExecutionContext ctx = new JobExecutionContextImpl(
null,
TestUtil.CreateMinimalFiredBundleWithTypedJobDetail(typeof(NoOpJob), (IOperableTrigger)t),
null);
await plugin.TriggerComplete(t, ctx, SchedulerInstruction.ReExecuteJob);
Assert.That(plugin.InfoMessages.Count, Is.EqualTo(1));
}
public TriggerPropertyBundle ReadTriggerPropertyBundle(DbDataReader rs)
{
int repeatCount = rs.GetInt32(AdoConstants.ColumnRepeatCount);
TimeSpan repeatInterval = DbAccessor.GetTimeSpanFromDbValue(rs[AdoConstants.ColumnRepeatInterval]) ?? TimeSpan.Zero;
int timesTriggered = rs.GetInt32(AdoConstants.ColumnTimesTriggered);
SimpleScheduleBuilder sb = SimpleScheduleBuilder.Create()
.WithRepeatCount(repeatCount)
.WithInterval(repeatInterval);
string[] statePropertyNames = { "timesTriggered" };
object[] statePropertyValues = { timesTriggered };
return(new TriggerPropertyBundle(sb, statePropertyNames, statePropertyValues));
}
static void Main(string[] args)
{
Setup();
var job = JobBuilder.Create <TestJob1>().WithIdentity("test", "test-job").Build();
//var job1 = JobBuilder.Create<TestJob1>().WithIdentity("test1", "test-job1").Build();
//var job2 = JobBuilder.Create<TestJob2>().WithIdentity("test2", "test-job2").Build();
//var job3 = JobBuilder.Create<TestJob3>().WithIdentity("test3", "test-job3").Build();
var trigger = TriggerBuilder.Create()
.WithIdentity("test", "test-job")
.StartNow()
.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(2)).Build();
//var trigger1 = TriggerBuilder.Create()
// .WithIdentity("test1", "test-job")
// .StartNow()
// .WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(2)).Build();
//var trigger2 = TriggerBuilder.Create()
// .WithIdentity("test2", "test-job")
// .StartNow()
// .WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(2)).Build();
//var trigger3 = TriggerBuilder.Create()
// .WithIdentity("test3", "test-job")
// .StartNow()
// .WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(2)).Build();
var cts = new CancellationTokenSource();
_scheduler.ScheduleJob(job, trigger, cts.Token);
//_scheduler.ScheduleJob(job1, trigger1, cts.Token);
//_scheduler.ScheduleJob(job2, trigger2, cts.Token);
//_scheduler.ScheduleJob(job3, trigger3, cts.Token);
_scheduler.Start().Wait();
Console.ReadKey();
//Console.WriteLine();
//List<string> topics = new List<string>();
//topics.Add("JTmdb_Fd_Good");
//_consumerClient.Consume(topics, HandlerMessage);
//_bus.Send("ServiceBus.TestPublish.NetCore", new RequestIntegrationEvent() { Message = "Masstransit test Succees!" });
//_logger.Info("ServiceBus Logs test!!");
//Console.WriteLine("Masstransit test Succees！");
//Console.ReadKey();
}
private static ITrigger DefineIntervalTrigger(string _identity, DateTime _startTime, IntervalType _intervalType, int span, int count)
{
ITrigger trigger;
var _trigger = TriggerBuilder.Create()
.WithIdentity(_identity, Guid.NewGuid().ToString());
_trigger.StartAt(_startTime);
switch (_intervalType)
{
case IntervalType.Hourly:
if (count == 0)
{
_trigger.WithSchedule(SimpleScheduleBuilder.RepeatHourlyForever(span));
}
else
{
_trigger.WithSchedule(SimpleScheduleBuilder.RepeatHourlyForTotalCount(count, span));
}
break;
case IntervalType.Minutely:
if (count == 0)
{
_trigger.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForever(span));
}
else
{
_trigger.WithSchedule(SimpleScheduleBuilder.RepeatMinutelyForTotalCount(count, span));
}
break;
case IntervalType.Secondly:
if (count == 0)
{
_trigger.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever(span));
}
else
{
_trigger.WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForTotalCount(count, span));
}
break;
default:
break;
}
trigger = _trigger.Build();
return(trigger);
}
static void Main(string[] args)
{
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += new UnhandledExceptionEventHandler(exceptionHandler);
Console.TreatControlCAsInput = true;
// TODD: move schedule setting data to configure file to make it flexible
var scheduleFactory = new StdSchedulerFactory();
var schedular = scheduleFactory.GetScheduler();
var job = JobBuilder.Create <WeatherScrapeJob>()
.WithIdentity(typeof(WeatherScrapeJob).GetType().Name)
.StoreDurably()
.Build();
var simpleSchedule = SimpleScheduleBuilder.Create();
var trigger = TriggerBuilder.Create()
.StartNow()
.WithSchedule(simpleSchedule.WithIntervalInMinutes(10).RepeatForever())
//.WithCronSchedule("0 0/10 * * * ?")// every 10 mins execute the job
.WithIdentity(typeof(WeatherScrapeJob).GetType().Name + "Tr")
.Build();
schedular.ScheduleJob(job, trigger);
schedular.Start();
Console.WriteLine("Press [Escape (Esc)] to exit the tesing running of scrape weather job");
ConsoleKeyInfo cki;
do
{
cki = Console.ReadKey();
// do nothing
// blocking here
Thread.Sleep(50);
}while(cki.Key != ConsoleKey.Escape);
Console.WriteLine("Waiting job shut down...");
schedular.Shutdown(true);
Console.WriteLine("Job shut down competed,, please press any key to exit");
Console.ReadKey();
}
