/// <summary> /// Called by the QuartzScheduler before the <see cref="T:Quartz.Spi.IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// here we default triggerLockTime out to 5 mins (number in miliseconds) /// default redisLockTimeout to 5 secs (number in miliseconds) /// </summary> public Task Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler, CancellationToken cancellationToken = default(CancellationToken)) { _storeSchema = new RedisJobStoreSchema(KeyPrefix ?? string.Empty, KeyDelimiter ?? ":"); _db = ConnectionMultiplexer.Connect(RedisConfiguration).GetDatabase(0); _storage = new RedisStorage(_storeSchema, _db, signaler, InstanceId, TriggerLockTimeout ?? 300000, RedisLockTimeout ?? 5000); return(Task.FromResult(0)); }
public Task Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler, CancellationToken cancellationToken = default) { _signaler = signaler; Store = Store ?? InitializeDocumentStore(); return(Task.CompletedTask); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// </summary> public override Task Initialize( ITypeLoadHelper loadHelper, ISchedulerSignaler signaler, CancellationToken cancellationToken = default) { base.Initialize(loadHelper, signaler, cancellationToken); Log.Info("JobStoreTX initialized."); return(TaskUtil.CompletedTask); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// </summary> /// <param name="loadHelper"></param> /// <param name="signaler"></param> public override void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { if (LockHandler == null) { // If the user hasn't specified an explicit lock handler, // then we ///must/// use DB locks with CMT... UseDBLocks = true; } base.Initialize(loadHelper, signaler); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// </summary> /// <param name="loadHelper"></param> /// <param name="signaler"></param> public override Task Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { if (LockHandler == null) { // If the user hasn't specified an explicit lock handler, // then we ///must/// use DB locks with CMT... UseDBLocks = true; } base.Initialize(loadHelper, signaler); Log.Info("JobStoreCMT initialized."); return(TaskUtil.CompletedTask); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// </summary> /// <param name="loadHelper"></param> /// <param name="signaler"></param> public override void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { base.Initialize(loadHelper, signaler); Log.Info("JobStoreTX initialized."); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// </summary> /// <param name="loadHelper"></param> /// <param name="signaler"></param> public override void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { base.Initialize(loadHelper, signaler); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore" /> is /// used, in order to give it a chance to Initialize. /// </summary> public virtual void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler s) { if (dataSource == null) { throw new SchedulerConfigException("DataSource name not set."); } typeLoadHelper = loadHelper; schedSignaler = s; // If the user hasn't specified an explicit lock handler, then // choose one based on CMT/Clustered/UseDBLocks. if (LockHandler == null) { // If the user hasn't specified an explicit lock handler, // then we *must* use DB locks with clustering if (Clustered) { UseDBLocks = true; } if (UseDBLocks) { if (Delegate is SqlServerDelegate) { if (SelectWithLockSQL == null) { const string DefaultLockSql = "SELECT * FROM {0}LOCKS WITH (UPDLOCK,ROWLOCK) WHERE " + ColumnSchedulerName + " = {1} AND LOCK_NAME = @lockName"; Log.InfoFormat("Detected usage of SqlServerDelegate - defaulting 'selectWithLockSQL' to '" + DefaultLockSql + "'.", TablePrefix, "'" + InstanceName + "'"); SelectWithLockSQL = DefaultLockSql; } } Log.Info("Using db table-based data access locking (synchronization)."); LockHandler = new StdRowLockSemaphore(TablePrefix, InstanceName, SelectWithLockSQL, DbProvider); } else { Log.Info("Using thread monitor-based data access locking (synchronization)."); LockHandler = new SimpleSemaphore(); } } else { // be ready to give a friendly warning if SQL Server is used and sub-optimal locking if (LockHandler is UpdateLockRowSemaphore && Delegate is SqlServerDelegate) { Log.Warn("Detected usage of SqlServerDelegate and UpdateLockRowSemaphore, removing 'quartz.jobStore.lockHandler.type' would allow more efficient SQL Server specific (UPDLOCK,ROWLOCK) row access"); } // be ready to give a friendly warning if SQL Server provider and wrong delegate if (DbProvider != null && DbProvider.Metadata.ConnectionType == typeof(SqlConnection) && !(Delegate is SqlServerDelegate)) { Log.Warn("Detected usage of SQL Server provider without SqlServerDelegate, SqlServerDelegate would provide better performance"); } } }
/// <summary> /// Create a <see cref="SchedulerScheduler" /> with the given configuration /// properties. /// </summary> /// <seealso cref="SchedulerSchedulerResources" /> public SchedulerScheduler(SchedulerSchedulerResources resources, SchedulingContext ctxt, TimeSpan idleWaitTime, TimeSpan dbRetryInterval) { Log = LogManager.GetLogger(GetType()); this.resources = resources; try { Bind(); } catch (Exception re) { throw new SchedulerException("Unable to bind scheduler to remoting context.", re); } schedThread = new SchedulerSchedulerThread(this, resources, ctxt); if (idleWaitTime > TimeSpan.Zero) { schedThread.IdleWaitTime = idleWaitTime; } if (dbRetryInterval > TimeSpan.Zero) { schedThread.DbFailureRetryInterval = dbRetryInterval; } jobMgr = new ExecutingJobsManager(); AddGlobalJobListener(jobMgr); errLogger = new ErrorLogger(); AddSchedulerListener(errLogger); signaler = new SchedulerSignalerImpl(this, this.schedThread); Log.Info(string.Format(CultureInfo.InvariantCulture, "Scheduler Scheduler v.{0} created.", Version)); }
public void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { this.loadHelper = loadHelper; this.signaler = signaler; }
/// <summary> /// Constructor /// </summary> /// <param name="redisJobStoreSchema">RedisJobStoreSchema</param> /// <param name="db">IDatabase</param> /// <param name="signaler">ISchedulerSignaler</param> /// <param name="schedulerInstanceId">SchedulerInstanceId</param> /// <param name="triggerLockTimeout">triggerLockTimeout</param> /// <param name="redisLockTimeout">redisLockTimeout</param> public RedisStorage(RedisJobStoreSchema redisJobStoreSchema, IDatabase db, ISchedulerSignaler signaler, string schedulerInstanceId, int triggerLockTimeout, int redisLockTimeout) : base(redisJobStoreSchema, db, signaler, schedulerInstanceId, triggerLockTimeout, redisLockTimeout) { }
/// <summary> /// Create a <see cref="QuartzScheduler" /> with the given configuration /// properties. /// </summary> /// <seealso cref="QuartzSchedulerResources" /> public QuartzScheduler(QuartzSchedulerResources resources, TimeSpan idleWaitTime, TimeSpan dbRetryInterval) { this.resources = resources; if (resources.JobStore is IJobListener) { AddInternalJobListener((IJobListener) resources.JobStore); } schedThread = new QuartzSchedulerThread(this, resources); IThreadExecutor schedThreadExecutor = resources.ThreadExecutor; schedThreadExecutor.Execute(schedThread); if (idleWaitTime > TimeSpan.Zero) { schedThread.IdleWaitTime = idleWaitTime; } if (dbRetryInterval > TimeSpan.Zero) { schedThread.DbFailureRetryInterval = dbRetryInterval; } jobMgr = new ExecutingJobsManager(); AddInternalJobListener(jobMgr); errLogger = new ErrorLogger(); AddInternalSchedulerListener(errLogger); signaler = new SchedulerSignalerImpl(this, schedThread); }
/// <summary> /// Create a <see cref="QuartzScheduler" /> with the given configuration /// properties. /// </summary> /// <seealso cref="QuartzSchedulerResources" /> public QuartzScheduler(QuartzSchedulerResources resources, TimeSpan idleWaitTime, TimeSpan dbRetryInterval) { log = LogManager.GetLogger(GetType()); this.resources = resources; if (resources.JobStore is IJobListener) { AddInternalJobListener((IJobListener) resources.JobStore); } schedThread = new QuartzSchedulerThread(this, resources); IThreadExecutor schedThreadExecutor = resources.ThreadExecutor; schedThreadExecutor.Execute(schedThread); if (idleWaitTime > TimeSpan.Zero) { schedThread.IdleWaitTime = idleWaitTime; } if (dbRetryInterval > TimeSpan.Zero) { schedThread.DbFailureRetryInterval = dbRetryInterval; } jobMgr = new ExecutingJobsManager(); AddInternalJobListener(jobMgr); errLogger = new ErrorLogger(); AddInternalSchedulerListener(errLogger); signaler = new SchedulerSignalerImpl(this, schedThread); log.InfoFormat(CultureInfo.InvariantCulture, "Quartz Scheduler v.{0} created.", Version); log.Info("Scheduler meta-data: " + (new SchedulerMetaData(SchedulerName, SchedulerInstanceId, GetType(), boundRemotely, RunningSince != null, InStandbyMode, IsShutdown, RunningSince, NumJobsExecuted, JobStoreClass, SupportsPersistence, Clustered, ThreadPoolClass, ThreadPoolSize, Version))); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="T:Quartz.Spi.IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// here we default triggerLockTime out to 5 mins (number in miliseconds) /// default redisLockTimeout to 5 secs (number in miliseconds) /// </summary> public void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { _storeSchema = new RedisJobStoreSchema(KeyPrefix ?? string.Empty, KeyDelimiter ?? ":"); _db = ConnectionMultiplexer.Connect(RedisConfiguration).GetDatabase(); _storage = new RedisStorage(_storeSchema, _db, signaler, InstanceId, TriggerLockTimeout ?? 300000, RedisLockTimeout ?? 5000); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore" /> is /// used, in order to give the it a chance to Initialize. /// </summary> public void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler s) { signaler = s; BsonSerializer.RegisterSerializer(typeof(JobKey), KeySerializer<JobKey>.Instance); BsonSerializer.RegisterSerializer(typeof(TriggerKey), KeySerializer<TriggerKey>.Instance); BsonClassMap.RegisterClassMap<AbstractTrigger>(cm => { cm.AutoMap(); cm.UnmapProperty(c => c.Key); cm.UnmapProperty(c => c.JobKey); cm.UnmapProperty(c => c.Group); cm.UnmapProperty(c => c.Name); cm.UnmapProperty(c => c.JobGroup); cm.UnmapProperty(c => c.JobName); }); BsonClassMap.RegisterClassMap<JobDetailImpl>(cm => { cm.AutoMap(); cm.MapProperty(c => c.JobType).SetSerializer(TypeSerializer.Instance); cm.UnmapProperty(c => c.Key); cm.UnmapProperty(c => c.Group); cm.UnmapProperty(c => c.Name); }); BsonClassMap.RegisterClassMap<BaseCalendar>(cm => { cm.MapProperty(c => c.Description); cm.MapProperty(c => c.TimeZone); cm.SetDiscriminatorIsRequired(true); cm.SetIsRootClass(true); }); database = MongoDatabase.Create(ConnectionString); // TODO: Ensure indexes ... // TODO: Get collections ... }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore" /> is /// used, in order to give it a chance to Initialize. /// </summary> public virtual void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler s) { if (dataSource == null) { throw new SchedulerConfigException("DataSource name not set."); } typeLoadHelper = loadHelper; schedSignaler = s; // If the user hasn't specified an explicit lock handler, then // choose one based on CMT/Clustered/UseDBLocks. if (LockHandler == null) { // If the user hasn't specified an explicit lock handler, // then we *must* use DB locks with clustering if (Clustered) { UseDBLocks = true; } if (UseDBLocks) { if (Delegate is SqlServerDelegate) { if (SelectWithLockSQL == null) { const string DefaultLockSql = "SELECT * FROM {0}LOCKS WITH (UPDLOCK,ROWLOCK) WHERE " + ColumnSchedulerName + " = {1} AND LOCK_NAME = @lockName"; Log.Info("Detected usage of MSSQLDelegate - defaulting 'selectWithLockSQL' to '" + DefaultLockSql + "'."); SelectWithLockSQL = DefaultLockSql; } } Log.Info("Using db table-based data access locking (synchronization)."); LockHandler = new StdRowLockSemaphore(TablePrefix, InstanceName, SelectWithLockSQL, DbProvider); } else { Log.Info("Using thread monitor-based data access locking (synchronization)."); LockHandler = new SimpleSemaphore(); } } }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore"/> is /// used, in order to give the it a chance to Initialize. /// </summary> /// <param name="loadHelper"></param> /// <param name="signaler"></param> public override Task Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler signaler) { base.Initialize(loadHelper, signaler); Log.Info("JobStoreTX initialized."); return(TaskUtil.CompletedTask); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore" /> is /// used, in order to give the it a chance to Initialize. /// </summary> public virtual void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler s) { signaler = s; Log.Info("MongoDB JobStore initialized."); }
/// <summary> /// constructor /// </summary> /// <param name="redisJobStoreSchema">RedisJobStoreSchema</param> /// <param name="db">IDatabase</param> /// <param name="signaler">ISchedulerSignaler</param> /// <param name="schedulerInstanceId">schedulerInstanceId</param> /// <param name="triggerLockTimeout">Trigger lock timeout(number in miliseconds) used in releasing the orphan triggers.</param> /// <param name="redisLockTimeout">Redis Lock timeout (number in miliseconds)</param> protected BaseJobStorage(RedisJobStoreSchema redisJobStoreSchema, IDatabase db, ISchedulerSignaler signaler, string schedulerInstanceId, int triggerLockTimeout, int redisLockTimeout) { RedisJobStoreSchema = redisJobStoreSchema; Db = db; SchedulerSignaler = signaler; SchedulerInstanceId = schedulerInstanceId; _logger = LogManager.GetLogger(GetType()); TriggerLockTimeout = triggerLockTimeout; RedisLockTimeout = redisLockTimeout; }
/// <summary> /// Create a <see cref="QuartzScheduler" /> with the given configuration /// properties. /// </summary> /// <seealso cref="QuartzSchedulerResources" /> public QuartzScheduler(QuartzSchedulerResources resources, TimeSpan idleWaitTime) { log = LogManager.GetLogger(GetType()); this.resources = resources; if (resources.JobStore is IJobListener) { AddInternalJobListener((IJobListener) resources.JobStore); } schedThread = new QuartzSchedulerThread(this, resources); IThreadExecutor schedThreadExecutor = resources.ThreadExecutor; schedThreadExecutor.Execute(schedThread); if (idleWaitTime > TimeSpan.Zero) { schedThread.IdleWaitTime = idleWaitTime; } jobMgr = new ExecutingJobsManager(); AddInternalJobListener(jobMgr); errLogger = new ErrorLogger(); AddInternalSchedulerListener(errLogger); signaler = new SchedulerSignalerImpl(this, schedThread); log.InfoFormat(CultureInfo.InvariantCulture, "Quartz Scheduler v.{0} created.", Version); }
/// <summary> /// Called by the QuartzScheduler before the <see cref="IJobStore" /> is /// used, in order to give it a chance to Initialize. /// </summary> public virtual void Initialize(ITypeLoadHelper loadHelper, ISchedulerSignaler s) { if (dataSource == null) { throw new SchedulerConfigException("DataSource name not set."); } typeLoadHelper = loadHelper; signaler = s; // If the user hasn't specified an explicit lock handler, then // choose one based on CMT/Clustered/UseDBLocks. if (LockHandler == null) { // If the user hasn't specified an explicit lock handler, // then we *must* use DB locks with clustering if (Clustered) { UseDBLocks = true; } if (UseDBLocks) { Log.Info("Using db table-based data access locking (synchronization)."); LockHandler = new StdRowLockSemaphore(TablePrefix, SelectWithLockSQL, DbProvider); } else { Log.Info("Using thread monitor-based data access locking (synchronization)."); LockHandler = new SimpleSemaphore(); } } }