public object Deserialize(global::MongoDB.Bson.IO.BsonReader bsonReader, Type nominalType, Type actualType, IBsonSerializationOptions options) { if (nominalType != typeof(TriggerKey) || actualType != typeof(TriggerKey)) { var message = string.Format("Can't deserialize a {0} from {1}.", nominalType.FullName, this.GetType().Name); throw new BsonSerializationException(message); } var bsonType = bsonReader.CurrentBsonType; if (bsonType == BsonType.Document) { TriggerKey item; bsonReader.ReadStartDocument(); item = new TriggerKey( bsonReader.ReadString("Name"), bsonReader.ReadString("Group")); bsonReader.ReadEndDocument(); return item; } else if (bsonType == BsonType.Null) { bsonReader.ReadNull(); return null; } else { var message = string.Format("Can't deserialize a {0} from BsonType {1}.", nominalType.FullName, bsonType); throw new BsonSerializationException(message); } }
public override bool OnStart() { Trace.WriteLine("WorkerRole1 Run", "Information"); var properties = new NameValueCollection(); properties["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz"; properties["quartz.jobStore.dataSource"] = "default"; properties["quartz.jobStore.clustered"] = "true"; properties["quartz.jobStore.selectWithLockSQL"] = string.Format(CultureInfo.InvariantCulture, "SELECT * FROM {0}{1} WHERE {2} = {3} AND {4} = @lockName", new object[] { "{0}", "LOCKS", "SCHED_NAME", "{1}", "LOCK_NAME" }); properties["quartz.jobStore.acquireTriggersWithinLock"] = "true"; properties["quartz.scheduler.instanceId"] = "AUTO"; properties["quartz.threadPool.threadCount"] = "1"; properties["quartz.jobStore.tablePrefix"] = "Scheduling."; properties["quartz.dataSource.default.connectionString"] = @"Server = (local)\sqlexpress; Database = DB; Integrated Security = True"; properties["quartz.dataSource.default.provider"] = "SqlServer-20"; var scheduler = new StdSchedulerFactory(properties).GetScheduler(); scheduler.Clear(); var triggerKey = new TriggerKey("t1"); var trigger = scheduler.GetTrigger(triggerKey); var jobBuilder = JobBuilder.Create<Job>(); var job = jobBuilder.Build(); var t = scheduler.GetTrigger(new TriggerKey("t1")); trigger = new SimpleTriggerImpl("t1", 100000, TimeSpan.FromSeconds(5)); scheduler.ScheduleJob(job, trigger); scheduler.Start(); return base.OnStart(); }
public TriggerPropertyBundle LoadExtendedTriggerProperties(ConnectionAndTransactionHolder conn, TriggerKey triggerKey) { using (IDbCommand cmd = CommandAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectSimpleTrigger, TablePrefix, SchedNameLiteral))) { CommandAccessor.AddCommandParameter(cmd, "triggerName", triggerKey.Name); CommandAccessor.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)); } }
public TriggerPropertyBundle LoadExtendedTriggerProperties(ConnectionAndTransactionHolder conn, TriggerKey triggerKey) { using (IDbCommand cmd = CommandAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectCronTriggers, TablePrefix, SchedNameLiteral))) { CommandAccessor.AddCommandParameter(cmd, "triggerName", triggerKey.Name); CommandAccessor.AddCommandParameter(cmd, "triggerGroup", triggerKey.Group); using (IDataReader rs = cmd.ExecuteReader()) { if (rs.Read()) { string cronExpr = rs.GetString(AdoConstants.ColumnCronExpression); string timeZoneId = rs.GetString(AdoConstants.ColumnTimeZoneId); CronScheduleBuilder cb = CronScheduleBuilder.CronSchedule(cronExpr); if (timeZoneId != null) { cb.InTimeZone(TimeZoneInfo.FindSystemTimeZoneById(timeZoneId)); } return new TriggerPropertyBundle(cb, null, null); } } throw new InvalidOperationException("No record found for selection of Trigger with key: '" + triggerKey + "' and statement: " + AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectCronTriggers, TablePrefix, SchedNameLiteral)); } }
public void RemoveSchedule(Schedule schedule) { var triggerKey = new TriggerKey(schedule.Id.ToString(), schedule.CommandId.ToString()); var jobKey = new JobKey(schedule.Id.ToString(), schedule.CommandId.ToString()); scheduler.UnscheduleJob(triggerKey); scheduler.DeleteJob(jobKey); }
public void PostRestartTrigger(string key) { var triggerKey = new TriggerKey(key); var trigger = _scheduler.GetTrigger(triggerKey); if (trigger == null) throw new HttpResponseException(HttpStatusCode.NotFound); _scheduler.ResumeTrigger(triggerKey); }
public ExampleTrigger(TriggerKey key, DateTime startTimeRetryUtc, DateTime? endTimeRetryUtc, int v, TimeSpan zero) { this._key = key; this._startTimeRetryUtc = startTimeRetryUtc; this._endTimeRetryUtc = endTimeRetryUtc; this._v = v; this._zero = zero; }
public void TriggerKeyShouldBeSerializable() { TriggerKey original = new TriggerKey("name", "group"); TriggerKey cloned = original.DeepClone(); Assert.That(cloned.Name, Is.EqualTo(original.Name)); Assert.That(cloned.Group, Is.EqualTo(original.Group)); }
public int DeleteExtendedTriggerProperties(ConnectionAndTransactionHolder conn, TriggerKey triggerKey) { using (IDbCommand cmd = DbAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlDeleteCronTrigger, TablePrefix, SchedNameLiteral))) { DbAccessor.AddCommandParameter(cmd, "triggerName", triggerKey.Name); DbAccessor.AddCommandParameter(cmd, "triggerGroup", triggerKey.Group); return cmd.ExecuteNonQuery(); } }
/// <summary> /// Get the current state of the identified <see cref="T:Quartz.ITrigger"/>. /// </summary> /// <seealso cref="T:Quartz.TriggerState"/> public override TriggerState GetTriggerState(TriggerKey triggerKey) { var triggerHashKey = this.RedisJobStoreSchema.TriggerHashkey(triggerKey); if ( this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Paused), triggerHashKey) != null || this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.PausedBlocked), triggerHashKey) != null) { return TriggerState.Paused; } if ( this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Blocked), triggerHashKey) != null) { return TriggerState.Blocked; } if ( this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Waiting), triggerHashKey) != null || this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Acquired),triggerHashKey) !=null) { return TriggerState.Normal; } if ( this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Completed), triggerHashKey) != null) { return TriggerState.Complete; } if ( this.Db.SortedSetScore(this.RedisJobStoreSchema.TriggerStateSetKey(RedisTriggerState.Error), triggerHashKey) != null) { return TriggerState.Error; } return TriggerState.None; }
ITrigger CreateTrigger(RecurringSchedule schedule, IJobDetail jobDetail, TriggerKey triggerKey) { var tz = TimeZoneInfo.Local; if (!string.IsNullOrWhiteSpace(schedule.TimeZoneId) && schedule.TimeZoneId != tz.Id) { tz = TimeZoneInfo.FindSystemTimeZoneById(schedule.TimeZoneId); } var triggerBuilder = TriggerBuilder.Create() .ForJob(jobDetail) .WithIdentity(triggerKey) .StartAt(schedule.StartTime) .WithDescription(schedule.Description) .WithCronSchedule(schedule.CronExpression, x => { x.InTimeZone(tz); switch (schedule.MisfirePolicy) { case MissedEventPolicy.Skip: x.WithMisfireHandlingInstructionDoNothing(); break; case MissedEventPolicy.Send: x.WithMisfireHandlingInstructionFireAndProceed(); break; } }); if (schedule.EndTime.HasValue) { triggerBuilder.EndAt(schedule.EndTime); } return(triggerBuilder.Build()); }
public async Task Consume(ConsumeContext <ScheduleRecurringMessage> context) { if (_log.IsDebugEnabled) { _log.DebugFormat("ScheduleRecurringMessage: {0} at {1}", context.Message.CorrelationId, context.Message.Schedule.ScheduleId); } var jobKey = new JobKey(context.Message.Schedule.ScheduleId, context.Message.Schedule.ScheduleGroup); var jobDetail = await CreateJobDetail(context, context.Message.Destination, jobKey).ConfigureAwait(false); var triggerKey = new TriggerKey("Recurring.Trigger." + context.Message.Schedule.ScheduleId, context.Message.Schedule.ScheduleGroup); var trigger = CreateTrigger(context.Message.Schedule, jobDetail, triggerKey); if (_scheduler.CheckExists(triggerKey)) { _scheduler.RescheduleJob(triggerKey, trigger); } else { _scheduler.ScheduleJob(jobDetail, trigger); } }
public async Task <TriggerPropertyBundle> LoadExtendedTriggerProperties( ConnectionAndTransactionHolder conn, TriggerKey triggerKey, CancellationToken cancellationToken = default) { using (var cmd = DbAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(SelectSimplePropsTrigger, TablePrefix, SchedNameLiteral))) { 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)) { SimplePropertiesTriggerProperties properties = new SimplePropertiesTriggerProperties(); properties.String1 = rs.GetString(ColumnStrProp1); properties.String2 = rs.GetString(ColumnStrProp2); properties.String3 = rs.GetString(ColumnStrProp3); properties.Int1 = rs.GetInt32(ColumnIntProp1); properties.Int2 = rs.GetInt32(ColumnIntProp2); properties.Long1 = rs.GetInt64(ColumnLongProp1); properties.Long2 = rs.GetInt64(ColumnLongProp2); properties.Decimal1 = rs.GetDecimal(ColumnDecProp1); properties.Decimal2 = rs.GetDecimal(ColumnDecProp2); properties.Boolean1 = DbAccessor.GetBooleanFromDbValue(rs[ColumnBoolProp1]); properties.Boolean2 = DbAccessor.GetBooleanFromDbValue(rs[ColumnBoolProp2]); properties.TimeZoneId = rs.GetString(ColumnTimeZoneId); return(GetTriggerPropertyBundle(properties)); } } } throw new InvalidOperationException("No record found for selection of Trigger with key: '" + triggerKey + "' and statement: " + AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectSimpleTrigger, TablePrefix, SchedNameLiteral)); }
public void ShouldGetJobDetailWhenCalledGetJobDetailOfTrigger() { // Arrange Guid triggerId = Guid.NewGuid(); var triggerKey = new TriggerKey("TestTrigger", "TestTriggerGroup"); ITrigger trigger = new SimpleTriggerImpl { JobKey = new JobKey("TestJob", "TestJobGroup") }; _mockPersistanceStore.Setup(x => x.GetTriggerKey(triggerId)).Returns(triggerKey); _mockScheduler.Setup(x => x.GetTrigger(triggerKey)).Returns(trigger); _mockScheduler.Setup(i => i.GetJobDetail(trigger.JobKey)).Returns(new JobDetailImpl() { Key = trigger.JobKey, Group = "TestJobGroup" }); ISchedulerCore schedulerCore = new SchedulerCore(_mockScheduler.Object, _mockPersistanceStore.Object); // Act var group = schedulerCore.GetJobDetailOfTrigger(triggerId).Key.Group; // Assert Assert.Equal("TestJobGroup", group); }
/// <inheritdoc /> public virtual async Task <IJobDetail?> SelectJobForTrigger( ConnectionAndTransactionHolder conn, TriggerKey triggerKey, ITypeLoadHelper loadHelper, bool loadJobType, CancellationToken cancellationToken = default) { using var cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobForTrigger)); AddCommandParameter(cmd, "schedulerName", schedName); AddCommandParameter(cmd, "triggerName", triggerKey.Name); AddCommandParameter(cmd, "triggerGroup", triggerKey.Group); using var rs = await cmd.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false); if (await rs.ReadAsync(cancellationToken).ConfigureAwait(false)) { JobDetailImpl job = new JobDetailImpl(); job.Name = rs.GetString(ColumnJobName) !; job.Group = rs.GetString(ColumnJobGroup) !; job.Durable = GetBooleanFromDbValue(rs[ColumnIsDurable]); if (loadJobType) { job.JobType = loadHelper.LoadType(rs.GetString(ColumnJobClass) !) !; } job.RequestsRecovery = GetBooleanFromDbValue(rs[ColumnRequestsRecovery]); return(job); } if (logger.IsDebugEnabled()) { logger.Debug("No job for trigger '" + triggerKey + "'."); } return(null); }
/// <summary> /// Produce the <see cref="ITrigger" />. /// </summary> /// <remarks> /// </remarks> /// <returns>a Trigger that meets the specifications of the builder.</returns> public ITrigger Build() { if (scheduleBuilder == null) { scheduleBuilder = SimpleScheduleBuilder.Create(); } IMutableTrigger trig = scheduleBuilder.Build(); trig.CalendarName = calendarName; trig.Description = description; trig.StartTimeUtc = startTime; trig.EndTimeUtc = endTime; if (key == null) { key = new TriggerKey(Guid.NewGuid().ToString(), null); } trig.Key = key; if (jobKey != null) { trig.JobKey = jobKey; } trig.Priority = priority; if (!jobDataMap.IsEmpty) { trig.JobDataMap = jobDataMap; } return trig; }
/// <summary> /// Use a TriggerKey with the given name and group to /// identify the Trigger. /// </summary> /// <remarks> /// <para>If none of the 'withIdentity' methods are set on the TriggerBuilder, /// then a random, unique TriggerKey will be generated.</para> /// </remarks> /// <param name="name">the name element for the Trigger's TriggerKey</param> /// <param name="group">the group element for the Trigger's TriggerKey</param> /// <returns>the updated TriggerBuilder</returns> /// <seealso cref="TriggerKey" /> /// <seealso cref="ITrigger.Key" /> public TriggerBuilder WithIdentity(string name, string group) { key = new TriggerKey(name, group); return this; }
/// <summary> /// Remove (delete) the <see cref="ITrigger" /> with the /// given name. /// /// </summary> /// <returns> /// <see langword="true" /> if a <see cref="ITrigger" /> with the given /// name and group was found and removed from the store. /// </returns> /// <param name="key">The <see cref="ITrigger" /> to be removed.</param> /// <param name="removeOrphanedJob">Whether to delete orpahaned job details from scheduler if job becomes orphaned from removing the trigger.</param> public virtual bool RemoveTrigger(TriggerKey key, bool removeOrphanedJob) { bool found; lock (lockObject) { var trigger = this.RetrieveTrigger(key); found = trigger != null; if (found) { this.Triggers.Remove( Query.EQ("_id", trigger.Key.ToBsonDocument())); if (removeOrphanedJob) { IJobDetail jobDetail = this.RetrieveJob(trigger.JobKey); IList<IOperableTrigger> trigs = this.GetTriggersForJob(jobDetail.Key); if ((trigs == null || trigs.Count == 0) && !jobDetail.Durable) { if (this.RemoveJob(jobDetail.Key)) { signaler.NotifySchedulerListenersJobDeleted(jobDetail.Key); } } } } } return found; }
public async Task <TriggerPropertyBundle> LoadExtendedTriggerProperties(ConnectionAndTransactionHolder conn, TriggerKey triggerKey) { using (var cmd = DbAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectCronTriggers, TablePrefix, SchedNameLiteral))) { DbAccessor.AddCommandParameter(cmd, "triggerName", triggerKey.Name); DbAccessor.AddCommandParameter(cmd, "triggerGroup", triggerKey.Group); using (var rs = await cmd.ExecuteReaderAsync().ConfigureAwait(false)) { if (await rs.ReadAsync().ConfigureAwait(false)) { string cronExpr = rs.GetString(AdoConstants.ColumnCronExpression); string timeZoneId = rs.GetString(AdoConstants.ColumnTimeZoneId); CronScheduleBuilder cb = CronScheduleBuilder.CronSchedule(cronExpr); if (timeZoneId != null) { cb.InTimeZone(TimeZoneUtil.FindTimeZoneById(timeZoneId)); } return(new TriggerPropertyBundle(cb, null, null)); } } throw new InvalidOperationException("No record found for selection of Trigger with key: '" + triggerKey + "' and statement: " + AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlSelectCronTriggers, TablePrefix, SchedNameLiteral)); } }
/// <summary> /// Determine whether a <see cref="ITrigger" /> with the given identifier already /// exists within the scheduler. /// </summary> /// <param name="triggerKey">triggerKey the identifier to check for</param> /// <returns>true if a Trigger exists with the given identifier</returns> public bool CheckExists(TriggerKey triggerKey) { lock (lockObject) { return this.Triggers.FindOneByIdAs<BsonDocument>(triggerKey.ToBsonDocument()) != null; } }
/// <summary> /// Pause the <see cref="ITrigger" /> with the given name. /// </summary> public virtual void PauseTrigger(TriggerKey triggerKey) { lock (lockObject) { this.Triggers.Update( Query.And( Query.EQ("_id", triggerKey.ToBsonDocument()), Query.EQ("State", "Blocked")), Update.Set("State", "PausedAndBlocked")); this.Triggers.Update( Query.And( Query.EQ("_id", triggerKey.ToBsonDocument()), Query.NE("State", "Blocked")), Update.Set("State", "Paused")); } }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public virtual ITrigger GetTrigger(TriggerKey triggerKey) { return(sched.GetTrigger(triggerKey)); }
/// <summary> /// Resume (un-pause) the <see cref="ITrigger" /> with the given key. /// </summary> /// <remarks> /// If the <see cref="ITrigger" /> missed one or more fire-times, then the /// <see cref="ITrigger" />'s misfire instruction will be applied. /// </remarks> public virtual void ResumeTrigger(TriggerKey triggerKey) { lock (lockObject) { IOperableTrigger trigger = this.Triggers.FindOneByIdAs<IOperableTrigger>(triggerKey.ToBsonDocument()); // does the trigger exist? if (trigger == null) { return; } BsonDocument triggerState = this.Triggers.FindOneByIdAs<BsonDocument>(triggerKey.ToBsonDocument()); // if the trigger is not paused resuming it does not make sense... if (triggerState["State"] != "Paused" && triggerState["State"] != "PausedAndBlocked") { return; } if (this.BlockedJobs.FindOneByIdAs<BsonDocument>(trigger.JobKey.ToBsonDocument()) != null) { triggerState["State"] = "Blocked"; } else { triggerState["State"] = "Waiting"; } this.ApplyMisfire(trigger); this.Triggers.Save(triggerState); } }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public virtual DateTimeOffset?RescheduleJob(TriggerKey triggerKey, ITrigger newTrigger) { return(sched.RescheduleJob(triggerKey, newTrigger)); }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public virtual void PauseTrigger(TriggerKey triggerKey) { sched.PauseTrigger(triggerKey); }
public void TriggerResumed(TriggerKey triggerKey) { throw new System.NotImplementedException(); }
public void JobUnscheduled(TriggerKey triggerKey) { throw new System.NotImplementedException(); }
public async Task DeletScheduleJob(QuartzDTO quartzDTO) { TriggerKey triggerKey = new TriggerKey(quartzDTO.Id, quartzDTO.Group); await _scheduler.UnscheduleJob(triggerKey); }
/// <summary> /// 由于jobkey和triggerkey设置的identity是一样的,获取triggerstate需要triggerkey,因此做一个转变 /// </summary> /// <param name="triggerKey"></param> /// <returns></returns> public static JobKey ConvertKey(this TriggerKey triggerKey) { return(new JobKey(triggerKey.Name, triggerKey.Group)); }
protected override void PerformOperation(TriggerInput input) { var triggerKey = new TriggerKey(input.Trigger, input.Group); Scheduler.PauseTrigger(triggerKey); }
/// <summary> /// 创建一个触发器(仅执行一次) /// </summary> /// <param name="key">名称和分组</param> /// <param name="startTime">开始时间</param> /// <returns></returns> public static ITrigger CreateTrigger(TriggerKey key, DateTime startTime) { return(TriggerBuilder.Create().WithIdentity(key).StartAt(startTime).Build()); }
/// <summary> /// Notifies the scheduler listeners about job that was unscheduled. /// </summary> public virtual void NotifySchedulerListenersUnscheduled(TriggerKey triggerKey) { // build a list of all scheduler listeners that are to be notified... IList<ISchedulerListener> schedListeners = BuildSchedulerListenerList(); // notify all scheduler listeners foreach (ISchedulerListener sl in schedListeners) { try { if (triggerKey == null) { sl.SchedulingDataCleared(); } else { sl.JobUnscheduled(triggerKey); } } catch (Exception e) { log.ErrorFormat( CultureInfo.InvariantCulture, "Error while notifying SchedulerListener of unscheduled job. Trigger={0}", e, (triggerKey == null ? "ALL DATA" : triggerKey.ToString())); } } }
/// <summary> /// Retrieve the given <see cref="ITrigger" />. /// </summary> /// <returns> /// The desired <see cref="ITrigger" />, or null if there is no match. /// </returns> public virtual IOperableTrigger RetrieveTrigger(TriggerKey triggerKey) { lock (lockObject) { return this.Triggers .FindOneByIdAs<Spi.IOperableTrigger>(triggerKey.ToBsonDocument()); } }
/// <summary> /// Resume (un-pause) the <see cref="ITrigger" /> with the given /// name. /// <para> /// If the <see cref="ITrigger" /> missed one or more fire-times, then the /// <see cref="ITrigger" />'s misfire instruction will be applied. /// </para> /// </summary> public virtual void ResumeTrigger(TriggerKey triggerKey) { ValidateState(); resources.JobStore.ResumeTrigger(triggerKey); NotifySchedulerThread(null); NotifySchedulerListenersResumedTrigger(triggerKey); }
/// <summary> /// Get the current state of the identified <see cref="ITrigger" />. /// </summary> /// <seealso cref="TriggerState.Normal" /> /// <seealso cref="TriggerState.Paused" /> /// <seealso cref="TriggerState.Complete" /> /// <seealso cref="TriggerState.Error" /> /// <seealso cref="TriggerState.Blocked" /> /// <seealso cref="TriggerState.None"/> public virtual TriggerState GetTriggerState(TriggerKey triggerKey) { lock (lockObject) { BsonDocument triggerState = this.Triggers.FindOneByIdAs<BsonDocument>(triggerKey.ToBsonDocument()); if (triggerState.IsBsonNull) { return TriggerState.None; } if (triggerState["State"] == "Complete") { return TriggerState.Complete; } if (triggerState["State"] == "Paused") { return TriggerState.Paused; } if (triggerState["State"] == "PausedAndBlocked") { return TriggerState.Paused; } if (triggerState["State"] == "Blocked") { return TriggerState.Blocked; } if (triggerState["State"] == "Error") { return TriggerState.Error; } return TriggerState.Normal; } }
private bool MatchTriggerListener(ITriggerListener listener, TriggerKey key) { IList<IMatcher<TriggerKey>> matchers = ListenerManager.GetTriggerListenerMatchers(listener.Name); if (matchers == null) { return true; } return matchers.Any(matcher => matcher.IsMatch(key)); }
/// <summary> /// Remove (delete) the <see cref="ITrigger" /> with the /// given name. /// </summary> /// <returns> /// <see langword="true" /> if a <see cref="ITrigger" /> with the given /// name and group was found and removed from the store. /// </returns> public virtual bool RemoveTrigger(TriggerKey triggerKey) { return RemoveTrigger(triggerKey, true); }
/// <summary> /// Get the <see cref="ITrigger" /> instance with the given name and /// group. /// </summary> public virtual ITrigger GetTrigger(TriggerKey triggerKey) { ValidateState(); return resources.JobStore.RetrieveTrigger(triggerKey); }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public virtual bool UnscheduleJob(TriggerKey triggerKey) { return(sched.UnscheduleJob(triggerKey)); }
public async Task <int> DeleteExtendedTriggerProperties(ConnectionAndTransactionHolder conn, TriggerKey triggerKey) { using (var cmd = DbAccessor.PrepareCommand(conn, AdoJobStoreUtil.ReplaceTablePrefix(StdAdoConstants.SqlDeleteCronTrigger, TablePrefix, SchedNameLiteral))) { DbAccessor.AddCommandParameter(cmd, "triggerName", triggerKey.Name); DbAccessor.AddCommandParameter(cmd, "triggerGroup", triggerKey.Group); return(await cmd.ExecuteNonQueryAsync().ConfigureAwait(false)); } }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public bool CheckExists(TriggerKey triggerKey) { return(sched.CheckExists(triggerKey)); }
public Task TriggerResumed(TriggerKey triggerKey, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public virtual void ResumeTrigger(TriggerKey triggerKey) { sched.ResumeTrigger(triggerKey); }
public Task JobUnscheduled(TriggerKey triggerKey, CancellationToken cancellationToken = default(CancellationToken)) { throw new NotImplementedException(); }
/// <summary> /// Calls the equivalent method on the 'proxied' <see cref="QuartzScheduler" />. /// </summary> public virtual TriggerState GetTriggerState(TriggerKey triggerKey) { return(sched.GetTriggerState(triggerKey)); }
/// <summary> /// Called by the <see cref="T:Quartz.IScheduler" /> when a <see cref="T:Quartz.IJobDetail" /> /// is unscheduled. /// </summary> /// <seealso cref="M:Quartz.ISchedulerListener.SchedulingDataCleared(System.Threading.CancellationToken)" /> public Task JobUnscheduled(TriggerKey triggerKey, CancellationToken cancellationToken = new CancellationToken()) { return(Task.FromResult(0)); }
/// <summary> /// Notifies the scheduler listeners resumed trigger. /// </summary> public virtual void NotifySchedulerListenersResumedTrigger(TriggerKey triggerKey) { // build a list of all job listeners that are to be notified... IList<ISchedulerListener> schedListeners = BuildSchedulerListenerList(); // notify all scheduler listeners foreach (ISchedulerListener sl in schedListeners) { try { sl.TriggerResumed(triggerKey); } catch (Exception e) { log.Error(string.Format(CultureInfo.InvariantCulture, "Error while notifying SchedulerListener of resumed trigger. Trigger={0}", triggerKey), e); } } }
/// <summary> /// Called by the <see cref="T:Quartz.IScheduler" /> when a <see cref="T:Quartz.ITrigger" /> /// has been un-paused. /// </summary> public Task TriggerResumed(TriggerKey triggerKey, CancellationToken cancellationToken = new CancellationToken()) { return(Task.FromResult(0)); }
/// <summary> /// Remove (delete) the <see cref="ITrigger" /> with the /// given name, and store the new given one - which must be associated /// with the same job. /// </summary> /// <param name="triggerKey">the key of the trigger</param> /// <param name="newTrigger">The new <see cref="ITrigger" /> to be stored.</param> /// <returns> /// <see langword="null" /> if a <see cref="ITrigger" /> with the given /// name and group was not found and removed from the store, otherwise /// the first fire time of the newly scheduled trigger. /// </returns> public virtual DateTimeOffset? RescheduleJob(TriggerKey triggerKey, ITrigger newTrigger) { ValidateState(); if (triggerKey == null) { throw new ArgumentException("triggerKey cannot be null"); } if (newTrigger == null) { throw new ArgumentException("newTrigger cannot be null"); } var trigger = (IOperableTrigger) newTrigger; ITrigger oldTrigger = GetTrigger(triggerKey); if (oldTrigger == null) { return null; } trigger.JobKey = oldTrigger.JobKey; trigger.Validate(); ICalendar cal = null; if (newTrigger.CalendarName != null) { cal = resources.JobStore.RetrieveCalendar(newTrigger.CalendarName); } DateTimeOffset? ft = trigger.ComputeFirstFireTimeUtc(cal); if (!ft.HasValue) { var message = string.Format("Based on configured schedule, the given trigger '{0}' will never fire.", trigger.Key); throw new SchedulerException(message); } if (resources.JobStore.ReplaceTrigger(triggerKey, trigger)) { NotifySchedulerThread(newTrigger.GetNextFireTimeUtc()); NotifySchedulerListenersUnscheduled(triggerKey); NotifySchedulerListenersScheduled(newTrigger); } else { return null; } return ft; }
public virtual Task JobUnscheduled( TriggerKey triggerKey, CancellationToken cancellationToken = default) { return(TaskUtil.CompletedTask); }
/// <summary> /// Remove the indicated <see cref="ITrigger" /> from the /// scheduler. /// </summary> public virtual bool UnscheduleJob(TriggerKey triggerKey) { ValidateState(); if (resources.JobStore.RemoveTrigger(triggerKey)) { NotifySchedulerThread(null); NotifySchedulerListenersUnscheduled(triggerKey); } else { return false; } return true; }
public virtual Task TriggerResumed( TriggerKey triggerKey, CancellationToken cancellationToken = default) { return(TaskUtil.CompletedTask); }
/// <summary> /// Determine whether a <see cref="ITrigger" /> with the given identifier already /// exists within the scheduler. /// </summary> /// <remarks> /// </remarks> /// <param name="triggerKey">the identifier to check for</param> /// <returns>true if a Trigger exists with the given identifier</returns> public bool CheckExists(TriggerKey triggerKey) { ValidateState(); return resources.JobStore.CheckExists(triggerKey); }
static public TriggerState getTriggerStatus(string TriggerName, string TriggerGroup) { TriggerKey objTrigerKey = new TriggerKey(TriggerName, TriggerGroup); return(_scheduler.GetTriggerState(objTrigerKey)); }
/// <summary> /// Get the current state of the identified <see cref="ITrigger" />. /// </summary> /// <seealso cref="TriggerState" /> public virtual TriggerState GetTriggerState(TriggerKey triggerKey) { ValidateState(); return resources.JobStore.GetTriggerState(triggerKey); }
public async Task JobUnscheduled(TriggerKey triggerKey, CancellationToken token = default(CancellationToken)) { await WriteMesssage(".JobUnscheduled", token); }
/// <summary> /// Use a <see cref="TriggerKey" /> with the given name and default group to /// identify the Trigger. /// </summary> /// <remarks> /// <para>If none of the 'withIdentity' methods are set on the TriggerBuilder, /// then a random, unique TriggerKey will be generated.</para> /// </remarks> /// <param name="name">the name element for the Trigger's TriggerKey</param> /// <returns>the updated TriggerBuilder</returns> /// <seealso cref="TriggerKey" /> /// <seealso cref="ITrigger.Key" /> public TriggerBuilder WithIdentity(string name) { key = new TriggerKey(name, null); return this; }
public async Task TriggerResumed(TriggerKey triggerKey, CancellationToken token = default(CancellationToken)) { await WriteMesssage(".TriggerResumed", token); }
/// <summary> /// Use the given TriggerKey to identify the Trigger. /// </summary> /// <remarks> /// <para>If none of the 'withIdentity' methods are set on the TriggerBuilder, /// then a random, unique TriggerKey will be generated.</para> /// </remarks> /// <param name="key">the TriggerKey for the Trigger to be built</param> /// <returns>the updated TriggerBuilder</returns> /// <seealso cref="TriggerKey" /> /// <seealso cref="ITrigger.Key" /> public TriggerBuilder WithIdentity(TriggerKey key) { this.key = key; return this; }
public static ITrigger CreateTrigger(TriggerKey key, string cron) { return(CreateTrigger(key, cron, DateTime.UtcNow)); }