/// <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 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>
/// 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>
/// 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 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 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>
/// <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 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();
}
}
}
