public void QuartzSelectCommand()
{
var args = new DelegateInitializationArgs();
args.Logger = LogManager.GetLogger(GetType());
args.TablePrefix = "LAVA_";
args.InstanceName = "Lava";
args.InstanceId = "AUTO";
args.DbProvider = new DbProvider("SqlServer-20", "Data Source=.;Initial Catalog=Lava;User ID=sa;Password=123");
args.TypeLoadHelper = new SimpleTypeLoadHelper();
args.ObjectSerializer = new DefaultObjectSerializer();
StdAdoDelegate adoDelegate = new StdAdoDelegate();
adoDelegate.Initialize(args);
using (SqlConnection conn = new SqlConnection("Data Source=.;Initial Catalog=Lava;User ID=sa;Password=123"))
{
conn.Open();
SqlTransaction tran = conn.BeginTransaction();
try
{
ConnectionAndTransactionHolder holder = new ConnectionAndTransactionHolder(conn, tran);
var num = adoDelegate.SelectNumJobs(holder);
tran.Commit();
}
catch (Exception ex)
{
tran.Rollback();
}
}
}
public async Task TestSelectSimpleTriggerWithDeleteBeforeSelectExtendedProps()
{
var dbProvider = A.Fake <IDbProvider>();
var connection = A.Fake <DbConnection>();
var transaction = A.Fake <DbTransaction>();
var command = (DbCommand)A.Fake <StubCommand>();
var dbMetadata = new DbMetadata();
A.CallTo(() => dbProvider.Metadata).Returns(dbMetadata);
A.CallTo(() => dbProvider.CreateCommand()).Returns(command);
var dataReader = A.Fake <DbDataReader>();
A.CallTo(command).Where(x => x.Method.Name == "ExecuteDbDataReaderAsync")
.WithReturnType <Task <DbDataReader> >()
.Returns(Task.FromResult(dataReader));
A.CallTo(command).Where(x => x.Method.Name == "get_DbParameterCollection")
.WithReturnType <DbParameterCollection>()
.Returns(new StubParameterCollection());
A.CallTo(() => command.CommandText).Returns("");
A.CallTo(command).Where(x => x.Method.Name == "CreateDbParameter")
.WithReturnType <DbParameter>()
.Returns(new SqlParameter());
var persistenceDelegate = A.Fake <ITriggerPersistenceDelegate>();
var exception = new InvalidOperationException();
A.CallTo(() => persistenceDelegate.LoadExtendedTriggerProperties(A <ConnectionAndTransactionHolder> .Ignored, A <TriggerKey> .Ignored, CancellationToken.None)).Throws(exception);
StdAdoDelegate adoDelegate = new TestStdAdoDelegate(persistenceDelegate);
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
// First result set has results, second has none
A.CallTo(() => dataReader.ReadAsync(CancellationToken.None)).Returns(true).Once();
A.CallTo(() => dataReader[AdoConstants.ColumnTriggerType]).Returns(AdoConstants.TriggerTypeSimple);
A.CallTo(() => dataReader[A <string> ._]).Returns("1");
var conn = new ConnectionAndTransactionHolder(connection, transaction);
IOperableTrigger trigger = await adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.That(trigger, Is.Null);
A.CallTo(() => persistenceDelegate.LoadExtendedTriggerProperties(A <ConnectionAndTransactionHolder> .Ignored, A <TriggerKey> .Ignored, CancellationToken.None)).MustHaveHappened();
}
public void CronTrigger_AfterTriggerUpdate_Retains_Cron_Type()
{
//Arrange
var cronTriggerImpl = new CronTriggerImpl("Trigger", "Trigger.Group", "JobName", "JobGroup", "0 15 23 * * ?");
cronTriggerImpl.CalendarName = "calName";
cronTriggerImpl.MisfireInstruction = 1;
cronTriggerImpl.Description = "Description";
cronTriggerImpl.SetPreviousFireTimeUtc(new DateTimeOffset(new DateTime(2010, 1, 1)));
cronTriggerImpl.SetNextFireTimeUtc(new DateTimeOffset(new DateTime(2010, 2, 1)));
cronTriggerImpl.JobKey = new JobKey("JobKey", "JobKeyGroup");
cronTriggerImpl.Priority = 1;
var dbProvider = MockRepository.GenerateStub <IDbProvider>();
var dbCommand = MockRepository.GenerateStub <IDbCommand>();
var dataParameterCollection = MockRepository.GenerateStub <IDataParameterCollection>();
dbProvider.Stub(d => d.CreateCommand()).Return(dbCommand).Repeat.Any();
Func <StubDataParameter> dataParam = () => new StubDataParameter();
dbProvider.Stub(d => d.CreateParameter()).Do(dataParam);
dbCommand.Stub(c => c.CreateParameter()).Do(dataParam);
var dataParameterCollectionOutputs = new List <object>();
Func <object, int> dataParameterFunc = x =>
{
dataParameterCollectionOutputs.Add(x);
return(1);
};
dataParameterCollection.Stub(d => d.Add(Arg <object> .Is.Anything)).Do(dataParameterFunc);
dbCommand.Stub(c => c.Parameters).Return(dataParameterCollection);
var metaData = MockRepository.GenerateStub <DbMetadata>();
dbProvider.Stub(d => d.Metadata).Return(metaData);
Func <string, string> paramFunc = x => x;
metaData.Stub(m => m.GetParameterName(Arg <string> .Is.Anything)).Do(paramFunc);
var adoDelegate = new StdAdoDelegate(LogManager.GetLogger(GetType()), "QRTZ_", "TESTSCHED", "INSTANCE", dbProvider, new SimpleTypeLoadHelper());
var dbConnection = new StubConnection();
var conn = new ConnectionAndTransactionHolder(dbConnection, null);
var jobDetail = MockRepository.GenerateMock <IJobDetail>();
var jobDataMap = new JobDataMap();
jobDataMap.ClearDirtyFlag();
cronTriggerImpl.JobDataMap = jobDataMap;
//Act
adoDelegate.UpdateTrigger(conn, cronTriggerImpl, "state", jobDetail);
//Assert
var resultDataParameters = dataParameterCollectionOutputs.Select(x => x as IDataParameter).Where(x => x.ParameterName == "triggerType").FirstOrDefault();
Assert.AreEqual("CRON", resultDataParameters.Value);
}
public IDbCommand PrepareCommand(ConnectionAndTransactionHolder cth, string commandText)
{
IDbCommand cmd = dbProvider.CreateCommand();
cmd.CommandText = commandText;
cmd.Connection = cth.Connection;
cmd.Transaction = cth.Transaction;
return cmd;
}
public void TestSelectSimpleTriggerWithExceptionWithExtendedProps()
{
var dbProvider = MockRepository.GenerateMock <IDbProvider>();
var connection = MockRepository.GenerateMock <IDbConnection>();
var transaction = MockRepository.GenerateMock <IDbTransaction>();
var command = (IDbCommand)MockRepository.GenerateMock <StubCommand>();
var dbMetadata = new DbMetadata();
dbProvider.Stub(x => x.Metadata).Repeat.Any().Return(dbMetadata);
dbProvider.Stub(x => x.CreateCommand()).Return(command);
var dataReader = MockRepository.GenerateMock <IDataReader>();
command.Stub(x => x.ExecuteReader()).Return(dataReader);
command.Stub(x => x.Parameters).Repeat.Any().Return(new StubParameterCollection());
command.Stub(x => x.CommandText).Return("").Repeat.Any();
command.Stub(x => x.CreateParameter()).Repeat.Any().Return(new StubDataParameter());
var persistenceDelegate = MockRepository.GenerateMock <ITriggerPersistenceDelegate>();
var exception = new InvalidOperationException();
persistenceDelegate.Stub(x => x.LoadExtendedTriggerProperties(Arg <ConnectionAndTransactionHolder> .Is.Anything, Arg <TriggerKey> .Is.Anything)).Throw(exception);
StdAdoDelegate adoDelegate = new TestStdAdoDelegate(persistenceDelegate);
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
Logger = LogManager.GetLogger(GetType()),
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
// Mock basic trigger data
dataReader.Stub(x => x.Read()).Return(true).Repeat.Any();
dataReader.Stub(x => x[AdoConstants.ColumnTriggerType]).Return(AdoConstants.TriggerTypeSimple);
try
{
var conn = new ConnectionAndTransactionHolder(connection, transaction);
adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.Fail("Trigger selection should result in exception");
}
catch (InvalidOperationException e)
{
Assert.That(e, Is.SameAs(exception));
}
persistenceDelegate.AssertWasCalled(x => x.LoadExtendedTriggerProperties(Arg <ConnectionAndTransactionHolder> .Is.Anything, Arg <TriggerKey> .Is.Anything));
}
public async Task TestSelectBlobTriggerWithNoBlobContent()
{
var dbProvider = A.Fake <IDbProvider>();
var connection = A.Fake <DbConnection>();
var transaction = A.Fake <DbTransaction>();
var command = (DbCommand)A.Fake <StubCommand>();
var dbMetadata = new DbMetadata();
A.CallTo(() => dbProvider.Metadata).Returns(dbMetadata);
A.CallTo(() => dbProvider.CreateCommand()).Returns(command);
var dataReader = A.Fake <DbDataReader>();
A.CallTo(command).Where(x => x.Method.Name == "ExecuteDbDataReaderAsync")
.WithReturnType <Task <DbDataReader> >()
.Returns(dataReader);
A.CallTo(command).Where(x => x.Method.Name == "get_DbParameterCollection")
.WithReturnType <DbParameterCollection>()
.Returns(new StubParameterCollection());
A.CallTo(() => command.CommandText).Returns("");
A.CallTo(command).Where(x => x.Method.Name == "CreateDbParameter")
.WithReturnType <DbParameter>()
.Returns(new SqlParameter());
var adoDelegate = new StdAdoDelegate();
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
Logger = LogProvider.GetLogger(GetType()),
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
var conn = new ConnectionAndTransactionHolder(connection, transaction);
// First result set has results, second has none
A.CallTo(() => dataReader.ReadAsync(CancellationToken.None)).Returns(true).Once();
A.CallTo(() => dataReader.ReadAsync(CancellationToken.None)).Returns(false);
A.CallTo(() => dataReader[AdoConstants.ColumnTriggerType]).Returns(AdoConstants.TriggerTypeBlob);
IOperableTrigger trigger = await adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.That(trigger, Is.Null);
}
public async Task <long> GetTotalJobsFailed(string schedulerName, CancellationToken cancellationToken = default)
{
using (ConnectionAndTransactionHolder dbConnection = GetConnection(IsolationLevel.ReadUncommitted))
{
string sqlCount = AdoJobStoreUtil.ReplaceTablePrefix(PropertySqlSelectHistoryFailedCount, _tablePrefix, null);
using (DbCommand dbCommand = Delegate.PrepareCommand(dbConnection, sqlCount))
{
Delegate.AddCommandParameter(dbCommand, "schedulerName", schedulerName);
return((long)await dbCommand.ExecuteScalarAsync(cancellationToken).ConfigureAwait(false));
}
}
}
public async Task <IEnumerable <ExecutionHistoryEntry> > FilterLast(string schedulerName, int limit, CancellationToken cancellationToken = default)
{
//return await Task.FromResult(new List<ExecutionHistoryEntry>());
List <ExecutionHistoryEntry> list = new List <ExecutionHistoryEntry>();
using (ConnectionAndTransactionHolder dbConnection = GetConnection(IsolationLevel.ReadUncommitted))
{
string sql = string.Format(PropertySqlServerSelectHistory, _tablePrefix);
if (_provider.Equals("MySql"))
{
sql = string.Format(PropertyMySqlSelectHistory, _tablePrefix);
}
using (DbCommand dbCommand = Delegate.PrepareCommand(dbConnection, sql))
{
Delegate.AddCommandParameter(dbCommand, "schedulerName", schedulerName);
Delegate.AddCommandParameter(dbCommand, "limit", limit);
using (DbDataReader reader = await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
{
while (await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
{
var entry = new ExecutionHistoryEntry
{
Recovering = Delegate.GetBooleanFromDbValue(reader["Recovering"]),
Vetoed = Delegate.GetBooleanFromDbValue(reader["Vetoed"]),
ActualFireTimeUtc = Convert.ToDateTime(reader["Actual_Fire_Time_Utc"]),
FinishedTimeUtc = Convert.ToDateTime(reader["Finished_Time_Utc"]),
FireInstanceId = reader.GetString("Fire_Instance_Id"),
ScheduledFireTimeUtc = Convert.ToDateTime(reader["Scheduled_Fire_Time_Utc"]),
SchedulerInstanceId = reader.GetString("Scheduler_Instance_Id"),
SchedulerName = reader.GetString("SCHED_NAME"),
JobName = reader.GetString("JOB_NAME"),
JobGroup = reader.GetString("JOB_GROUP"),
TriggerName = reader.GetString("TRIGGER_NAME"),
TriggerGroup = reader.GetString("TRIGGER_GROUP"),
FiredTime = Delegate.GetDateTimeFromDbValue(reader["FIRED_TIME"]).GetValueOrDefault(),
ScheduledTime = Delegate.GetDateTimeFromDbValue(reader["SCHED_TIME"]).GetValueOrDefault(),
RunTime = Delegate.GetTimeSpanFromDbValue(reader["RUN_TIME"]).GetValueOrDefault(),
Error = Delegate.GetBooleanFromDbValue(reader["ERROR"]),
ErrorMessage = reader.GetString("ERROR_MESSAGE")
};
list.Add(entry);
}
}
}
}
list.Reverse();
return(list);
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <returns>True if the lock was obtained.</returns>
public virtual bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lock (this)
{
lockName = String.Intern(lockName);
if (log.IsDebugEnabled)
log.Debug("Lock '" + lockName + "' is desired by: " + Thread.CurrentThread.Name);
if (!IsLockOwner(conn, lockName))
{
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' is being obtained: " + Thread.CurrentThread.Name);
}
while (locks.Contains(lockName))
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' was not obtained by: " + Thread.CurrentThread.Name);
}
}
}
if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' given to: {1}", lockName, Thread.CurrentThread.Name));
}
ThreadLocks.Add(lockName);
locks.Add(lockName);
}
else if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' already owned by: {1} -- but not owner!", lockName, Thread.CurrentThread.Name), new Exception("stack-trace of wrongful returner"));
}
return true;
}
}
public void TestSelectBlobTriggerWithNoBlobContent()
{
var dbProvider = MockRepository.GenerateMock <IDbProvider>();
var connection = MockRepository.GenerateMock <IDbConnection>();
var transaction = MockRepository.GenerateMock <IDbTransaction>();
var command = (IDbCommand)MockRepository.GenerateMock <StubCommand>();
var dbMetadata = new DbMetadata();
dbProvider.Stub(x => x.Metadata).Repeat.Any().Return(dbMetadata);
dbProvider.Stub(x => x.CreateCommand()).Return(command);
var dataReader = MockRepository.GenerateMock <IDataReader>();
command.Stub(x => x.ExecuteReader()).Return(dataReader);
command.Stub(x => x.Parameters).Repeat.Any().Return(new StubParameterCollection());
command.Stub(x => x.CommandText).Return("").Repeat.Any();
command.Stub(x => x.CreateParameter()).Repeat.Any().Return(new StubDataParameter());
var adoDelegate = new StdAdoDelegate();
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
Logger = LogManager.GetLogger(GetType()),
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
var conn = new ConnectionAndTransactionHolder(connection, transaction);
// First result set has results, second has none
dataReader.Stub(x => x.Read()).Return(true).Repeat.Once();
dataReader.Stub(x => x.Read()).Return(false);
dataReader.Stub(x => x[AdoConstants.ColumnTriggerType]).Return(AdoConstants.TriggerTypeBlob);
IOperableTrigger trigger = adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.That(trigger, Is.Null);
}
public async Task UpdateJobHistoryEntryVetoed(
IJobExecutionContext context,
CancellationToken cancellationToken = default(CancellationToken))
{
string sql = AdoJobStoreUtil.ReplaceTablePrefix(PropertySqlUpdateHistoryVetoed, _tablePrefix, null);
using (ConnectionAndTransactionHolder connection = GetConnection(IsolationLevel.ReadUncommitted))
{
using (DbCommand command = Delegate.PrepareCommand(connection, sql))
{
Delegate.AddCommandParameter(command, "vetoed", true);
Delegate.AddCommandParameter(command, "fireInstanceId", context.FireInstanceId);
await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
connection.Commit(false);
}
}
}
public async Task UpdateJobHistoryEntryError(
IJobExecutionContext context,
JobExecutionException jobException,
CancellationToken cancellationToken = default(CancellationToken))
{
string sql = AdoJobStoreUtil.ReplaceTablePrefix(PropertySqlUpdateHistoryError, _tablePrefix, null);
using (ConnectionAndTransactionHolder connection = GetConnection(IsolationLevel.ReadUncommitted))
{
using (DbCommand command = Delegate.PrepareCommand(connection, sql))
{
Delegate.AddCommandParameter(command, "error", Delegate.GetDbBooleanValue(jobException != null));
Delegate.AddCommandParameter(command, "errorMessage", jobException?.GetBaseException()?.Message);
Delegate.AddCommandParameter(command, "fireInstanceId", context.FireInstanceId);
await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
connection.Commit(false);
}
}
}
public async Task CreateJobHistoryEntry(
IJobExecutionContext context,
CancellationToken cancellationToken = default(CancellationToken))
{
string sql = AdoJobStoreUtil.ReplaceTablePrefix(PropertySqlInsertJobExecuted, _tablePrefix, null);
using (ConnectionAndTransactionHolder connection = GetConnection(IsolationLevel.ReadUncommitted))
{
using (DbCommand command = Delegate.PrepareCommand(connection, sql))
{
Delegate.AddCommandParameter(command, "schedulerName", context.Scheduler.SchedulerName);
Delegate.AddCommandParameter(command, "schedulerInstanceName", context.Scheduler.SchedulerInstanceId);
Delegate.AddCommandParameter(command, "jobName", context.JobDetail.Key.Name);
Delegate.AddCommandParameter(command, "jobGroup", context.JobDetail.Key.Group);
Delegate.AddCommandParameter(command, "triggerName", context.Trigger.Key.Name);
Delegate.AddCommandParameter(command, "triggerGroup", context.Trigger.Key.Group);
Delegate.AddCommandParameter(command, "scheduledTime", Delegate.GetDbDateTimeValue(context.ScheduledFireTimeUtc));
Delegate.AddCommandParameter(command, "firedTime", Delegate.GetDbDateTimeValue(context.FireTimeUtc));
Delegate.AddCommandParameter(command, "runTime", Delegate.GetDbTimeSpanValue(context.JobRunTime));
Delegate.AddCommandParameter(command, "fireInstanceId", context.FireInstanceId);
Delegate.AddCommandParameter(command, "scheduledFireTimeUtc", context.ScheduledFireTimeUtc?.UtcDateTime);
Delegate.AddCommandParameter(command, "actualFireTimeUtc", context.FireTimeUtc.UtcDateTime);
Delegate.AddCommandParameter(command, "finishedTimeUtc", DateTime.UtcNow);
Delegate.AddCommandParameter(command, "recovering", context.Recovering);
Delegate.AddCommandParameter(command, "vetoed", false);
Delegate.AddCommandParameter(command, "error", false);
try
{
await command.ExecuteNonQueryAsync(cancellationToken).ConfigureAwait(false);
connection.Commit(false);
}
catch (Exception ex)
{
throw ex;
}
}
}
}
/// <summary>
/// Delete all fired triggers of the given instance.
/// </summary>
/// <param name="conn">The DB Connection</param>
/// <param name="instanceName">The instance id.</param>
/// <returns>The number of rows deleted</returns>
public virtual int DeleteFiredTriggers(ConnectionAndTransactionHolder conn, string instanceName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlDeleteInstancesFiredTriggers)))
{
AddCommandParameter(cmd, 1, "instanceName", instanceName);
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Determine whether the calling thread owns a lock on the identified
/// resource.
/// </summary>
public virtual bool IsLockOwner(ConnectionAndTransactionHolder conn, String lockName)
{
lock (this)
{
lockName = String.Intern(lockName);
return ThreadLocks.Contains(lockName);
}
}
public async Task CronTrigger_AfterTriggerUpdate_Retains_Cron_Type()
{
//Arrange
var cronTriggerImpl = new CronTriggerImpl("Trigger", "Trigger.Group", "JobName", "JobGroup", "0 15 23 * * ?");
cronTriggerImpl.CalendarName = "calName";
cronTriggerImpl.MisfireInstruction = 1;
cronTriggerImpl.Description = "Description";
cronTriggerImpl.SetPreviousFireTimeUtc(new DateTimeOffset(new DateTime(2010, 1, 1)));
cronTriggerImpl.SetNextFireTimeUtc(new DateTimeOffset(new DateTime(2010, 2, 1)));
cronTriggerImpl.JobKey = new JobKey("JobKey", "JobKeyGroup");
cronTriggerImpl.Priority = 1;
var dbProvider = A.Fake <IDbProvider>();
var dbCommand = A.Fake <DbCommand>();
var dataParameterCollection = A.Fake <DbParameterCollection>();
A.CallTo(() => dbProvider.CreateCommand()).Returns(dbCommand);
Func <DbParameter> dataParam = () => new SqlParameter();
A.CallTo(dbProvider)
.Where(x => x.Method.Name == "CreateDbParameter")
.WithReturnType <DbParameter>()
.ReturnsLazily(dataParam);
A.CallTo(dbCommand)
.Where(x => x.Method.Name == "CreateDbParameter")
.WithReturnType <DbParameter>()
.ReturnsLazily(dataParam);
var dataParameterCollectionOutputs = new List <object>();
A.CallTo(() => dataParameterCollection.Add(A <object> ._)).Invokes(x =>
{
dataParameterCollectionOutputs.Add(x.Arguments.Single());
});
A.CallTo(dbCommand)
.Where(x => x.Method.Name == "get_DbParameterCollection")
.WithReturnType <DbParameterCollection>()
.Returns(dataParameterCollection);
var metaData = A.Fake <DbMetadata>();
A.CallTo(() => dbProvider.Metadata).Returns(metaData);
Func <string, string> paramFunc = x => x;
A.CallTo(() => metaData.GetParameterName(A <string> .Ignored)).ReturnsLazily(paramFunc);
DelegateInitializationArgs args = new DelegateInitializationArgs();
args.Logger = LogProvider.GetLogger(GetType());
args.TablePrefix = "QRTZ_";
args.InstanceName = "TESTSCHED";
args.InstanceId = "INSTANCE";
args.DbProvider = dbProvider;
args.TypeLoadHelper = new SimpleTypeLoadHelper();
var adoDelegate = new StdAdoDelegate();
adoDelegate.Initialize(args);
var dbConnection = new StubConnection();
var conn = new ConnectionAndTransactionHolder(dbConnection, null);
var jobDetail = A.Fake <IJobDetail>();
var jobDataMap = new JobDataMap();
jobDataMap.ClearDirtyFlag();
cronTriggerImpl.JobDataMap = jobDataMap;
//Act
await adoDelegate.UpdateTrigger(conn, cronTriggerImpl, "state", jobDetail);
//Assert
var resultDataParameters = dataParameterCollectionOutputs.Select(x => x as IDataParameter).Where(x => x.ParameterName == "triggerType").FirstOrDefault();
Assert.AreEqual("CRON", resultDataParameters.Value);
}
/// <summary>
/// Insert the simple trigger data.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="trigger">The trigger to insert.</param>
/// <returns>The number of rows inserted.</returns>
public virtual int InsertSimpleTrigger(ConnectionAndTransactionHolder conn, SimpleTrigger trigger)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlInsertSimpleTrigger)))
{
AddCommandParameter(cmd, 1, "triggerName", trigger.Name);
AddCommandParameter(cmd, 2, "triggerGroup", trigger.Group);
AddCommandParameter(cmd, 3, "triggerRepeatCount", trigger.RepeatCount);
AddCommandParameter(cmd, 4, "triggerRepeatInterval", trigger.RepeatInterval.TotalMilliseconds);
AddCommandParameter(cmd, 5, "triggerTimesTriggered", trigger.TimesTriggered);
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Select all of the jobs contained in a given group.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="groupName">The group containing the jobs.</param>
/// <returns>An array of <see cref="String" /> job names.</returns>
public virtual String[] SelectJobsInGroup(ConnectionAndTransactionHolder conn, string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobsInGroup)))
{
AddCommandParameter(cmd, 1, "jobGroup", groupName);
using (IDataReader rs = cmd.ExecuteReader())
{
ArrayList list = new ArrayList();
while (rs.Read())
{
list.Add(GetString(rs[0]));
}
object[] oArr = list.ToArray();
string[] sArr = new string[oArr.Length];
Array.Copy(oArr, 0, sArr, 0, oArr.Length);
return sArr;
}
}
}
/// <summary>
/// Get all of the listeners for a given job.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="jobName">The job name whose listeners are wanted.</param>
/// <param name="groupName">The group containing the job.</param>
/// <returns>Array of <see cref="String" /> listener names.</returns>
public virtual string[] SelectJobListeners(ConnectionAndTransactionHolder conn, string jobName, string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobListeners)))
{
ArrayList list = new ArrayList();
AddCommandParameter(cmd, 1, "jobName", jobName);
AddCommandParameter(cmd, 2, "jobGroup", groupName);
using (IDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
list.Add(dr[0]);
}
return (string[])list.ToArray(typeof(string));
}
}
}
/// <summary>
/// Update the job data map for the given job.
/// </summary>
/// <param name="conn">The conn.</param>
/// <param name="job">the job to update</param>
/// <returns>the number of rows updated</returns>
public virtual int UpdateJobData(ConnectionAndTransactionHolder conn, JobDetail job)
{
byte[] baos = SerializeJobData(job.JobDataMap);
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlUpdateJobData)))
{
AddCommandParameter(cmd, 1, "jobDataMap", baos, dbProvider.Metadata.DbBinaryType);
AddCommandParameter(cmd, 2, "jobName", job.Name);
AddCommandParameter(cmd, 3, "jobGroup", job.Group);
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Check whether or not the given job is stateful.
/// </summary>
/// <param name="conn">the DB Connection</param>
/// <param name="jobName">the name of the job</param>
/// <param name="groupName">the group containing the job</param>
/// <returns>
/// true if the job exists and is stateful, false otherwise
/// </returns>
public virtual bool IsJobStateful(ConnectionAndTransactionHolder conn, string jobName, string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobStateful)))
{
AddCommandParameter(cmd, 1, "jobName", jobName);
AddCommandParameter(cmd, 2, "jobGroup", groupName);
object o = cmd.ExecuteScalar();
if (o != null)
{
return (bool)o;
}
else
{
return false;
}
}
}
/// <summary>
/// Delete all job listeners for the given job.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="jobName">The name of the job.</param>
/// <param name="groupName">The group containing the job.</param>
/// <returns>The number of rows deleted.</returns>
public virtual int DeleteJobListeners(ConnectionAndTransactionHolder conn, string jobName, string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlDeleteJobListeners)))
{
AddCommandParameter(cmd, 1, "jobName", jobName);
AddCommandParameter(cmd, 2, "jobGroup", groupName);
return cmd.ExecuteNonQuery();
}
}
public async Task <PagedResultDto <ExecutionHistoryEntry> > GetPageJobHistoryEntries(
string schedulerName,
int pageIndex, int pageSize,
string orderByStr,
CancellationToken cancellationToken = default)
{
var pageResult = new PagedResultDto <ExecutionHistoryEntry>();
using (ConnectionAndTransactionHolder dbConnection = GetConnection(IsolationLevel.ReadUncommitted))
{
//string sql = AdoJobStoreUtil.ReplaceTablePrefix(PropertySqlServerSelectHistoryEntry, _tablePrefix, null);
string sql = string.Format(PropertySqlServerSelectHistoryEntryPage, _tablePrefix, orderByStr);
if (_provider.Equals("MySql"))
{
//sql = AdoJobStoreUtil.ReplaceTablePrefix(PropertyMySqlSelectHistoryEntry, _tablePrefix, null);
sql = string.Format(PropertyMySqlSelectHistoryEntryPage, _tablePrefix, orderByStr);
}
pageResult.TotalCount = await GetAllCount(schedulerName, cancellationToken);
using (DbCommand dbCommand = Delegate.PrepareCommand(dbConnection, sql))
{
int page = pageIndex > 1 ? (pageIndex - 1) * pageSize : 0;
Delegate.AddCommandParameter(dbCommand, "schedulerName", schedulerName);
Delegate.AddCommandParameter(dbCommand, "page", page);
if (_provider.Equals("MySql"))
{
// pageSize
Delegate.AddCommandParameter(dbCommand, "pageSize", pageSize);
}
else
{
// endPage
Delegate.AddCommandParameter(dbCommand, "endPage", page + pageSize);
}
using (DbDataReader reader = await dbCommand.ExecuteReaderAsync(cancellationToken).ConfigureAwait(false))
{
List <ExecutionHistoryEntry> list = new List <ExecutionHistoryEntry>();
while (await reader.ReadAsync(cancellationToken).ConfigureAwait(false))
{
var entry = new ExecutionHistoryEntry
{
Recovering = Delegate.GetBooleanFromDbValue(reader["Recovering"]),
Vetoed = Delegate.GetBooleanFromDbValue(reader["Vetoed"]),
ActualFireTimeUtc = Convert.ToDateTime(reader["Actual_Fire_Time_Utc"]),
FinishedTimeUtc = Convert.ToDateTime(reader["Finished_Time_Utc"]),
FireInstanceId = reader.GetString("Fire_Instance_Id"),
ScheduledFireTimeUtc = Convert.ToDateTime(reader["Scheduled_Fire_Time_Utc"]),
SchedulerInstanceId = reader.GetString("Scheduler_Instance_Id"),
SchedulerName = reader.GetString("SCHED_NAME"),
JobName = reader.GetString("JOB_NAME"),
JobGroup = reader.GetString("JOB_GROUP"),
TriggerName = reader.GetString("TRIGGER_NAME"),
TriggerGroup = reader.GetString("TRIGGER_GROUP"),
FiredTime = Delegate.GetDateTimeFromDbValue(reader["FIRED_TIME"]).GetValueOrDefault(),
ScheduledTime = Delegate.GetDateTimeFromDbValue(reader["SCHED_TIME"]).GetValueOrDefault(),
RunTime = Delegate.GetTimeSpanFromDbValue(reader["RUN_TIME"]).GetValueOrDefault(),
Error = Delegate.GetBooleanFromDbValue(reader["ERROR"]),
ErrorMessage = reader.GetString("ERROR_MESSAGE")
};
list.Add(entry);
}
pageResult.Items = list.AsReadOnly();
}
}
}
return(pageResult);
}
/// <summary>
/// Update the job detail record.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="job">The job to update.</param>
/// <returns>Number of rows updated.</returns>
public virtual int UpdateJobDetail(ConnectionAndTransactionHolder conn, JobDetail job)
{
byte[] baos = SerializeJobData(job.JobDataMap);
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlUpdateJobDetail)))
{
AddCommandParameter(cmd, 1, "jobDescription", job.Description);
AddCommandParameter(cmd, 2, "jobType", GetStorableJobTypeName(job.JobType));
AddCommandParameter(cmd, 3, "jobDurable", GetDbBooleanValue(job.Durable));
AddCommandParameter(cmd, 4, "jobVolatile", GetDbBooleanValue(job.Volatile));
AddCommandParameter(cmd, 5, "jobStateful", GetDbBooleanValue(job.Stateful));
AddCommandParameter(cmd, 6, "jobRequestsRecovery", GetDbBooleanValue(job.RequestsRecovery));
AddCommandParameter(cmd, 7, "jobDataMap", baos, dbProvider.Metadata.DbBinaryType);
AddCommandParameter(cmd, 8, "jobName", job.Name);
AddCommandParameter(cmd, 9, "jobGroup", job.Group);
int insertResult = cmd.ExecuteNonQuery();
if (insertResult > 0)
{
DeleteJobListeners(conn, job.Name, job.Group);
String[] jobListeners = job.JobListenerNames;
for (int i = 0; jobListeners != null && i < jobListeners.Length; i++)
{
InsertJobListener(conn, job, jobListeners[i]);
}
}
return insertResult;
}
}
/// <summary>
/// Get the names of all of the triggers associated with the given job.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="jobName">The name of the job.</param>
/// <param name="groupName">The group containing the job.</param>
/// <returns>An array of <see cref="Key" /> objects</returns>
public virtual Key[] SelectTriggerNamesForJob(ConnectionAndTransactionHolder conn, string jobName,
string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectTriggersForJob)))
{
AddCommandParameter(cmd, 1, "jobName", jobName);
AddCommandParameter(cmd, 2, "jobGroup", groupName);
using (IDataReader rs = cmd.ExecuteReader())
{
ArrayList list = new ArrayList(10);
while (rs.Read())
{
string trigName = GetString(rs[ColumnTriggerName]);
string trigGroup = GetString(rs[ColumnTriggerGroup]);
list.Add(new Key(trigName, trigGroup));
}
object[] oArr = list.ToArray();
Key[] kArr = new Key[oArr.Length];
Array.Copy(oArr, 0, kArr, 0, oArr.Length);
return kArr;
}
}
}
/// <summary>
/// Select the total number of jobs stored.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <returns>The total number of jobs stored.</returns>
public virtual int SelectNumJobs(ConnectionAndTransactionHolder conn)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectNumJobs)))
{
return (int)cmd.ExecuteScalar();
}
}
/// <summary>
/// Delete the job detail record for the given job.
/// </summary>
/// <param name="conn">the DB Connection</param>
/// <param name="jobName">the name of the job</param>
/// <param name="groupName">the group containing the job</param>
/// <returns>the number of rows deleted</returns>
public virtual int DeleteJobDetail(ConnectionAndTransactionHolder conn, string jobName, string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlDeleteJobDetail)))
{
if (logger.IsDebugEnabled)
{
logger.Debug("Deleting job: " + groupName + "." + jobName);
}
AddCommandParameter(cmd, 1, "jobName", jobName);
AddCommandParameter(cmd, 2, "jobGroup", groupName);
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Updates the state of the scheduler.
/// </summary>
/// <param name="conn">The database connection.</param>
/// <param name="instanceName">The instance id.</param>
/// <param name="checkInTime">The check in time.</param>
/// <returns></returns>
public virtual int UpdateSchedulerState(ConnectionAndTransactionHolder conn, string instanceName, DateTime checkInTime)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlUpdateSchedulerState)))
{
AddCommandParameter(cmd, 1, "lastCheckinTime", checkInTime.Ticks);
AddCommandParameter(cmd, 2, "instanceName", instanceName);
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Check whether or not the given job exists.
/// </summary>
/// <param name="conn">the DB Connection</param>
/// <param name="jobName">the name of the job</param>
/// <param name="groupName">the group containing the job</param>
/// <returns>true if the job exists, false otherwise</returns>
public virtual bool JobExists(ConnectionAndTransactionHolder conn, string jobName, string groupName)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobExistence)))
{
AddCommandParameter(cmd, 0, "jobName", jobName);
AddCommandParameter(cmd, 1, "jobGroup", groupName);
using (IDataReader dr = cmd.ExecuteReader())
{
if (dr.Read())
{
return true;
}
else
{
return false;
}
}
}
}
/// <summary>
/// A List of all current <see cref="SchedulerStateRecord" />s.
/// <p>
/// If instanceId is not null, then only the record for the identified
/// instance will be returned.
/// </p>
/// </summary>
/// <param name="conn">The DB Connection</param>
/// <param name="instanceName">The instance id.</param>
/// <returns></returns>
public virtual IList SelectSchedulerStateRecords(ConnectionAndTransactionHolder conn, string instanceName)
{
IDbCommand cmd;
ArrayList list = new ArrayList();
if (instanceName != null)
{
cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectSchedulerState));
AddCommandParameter(cmd, 1, "instanceName", instanceName);
}
else
{
cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectSchedulerStates));
}
using (IDataReader rs = cmd.ExecuteReader())
{
while (rs.Read())
{
SchedulerStateRecord rec = new SchedulerStateRecord();
rec.SchedulerInstanceId = GetString(rs[ColumnInstanceName]);
rec.CheckinTimestamp = new DateTime(Convert.ToInt64(rs[ColumnLastCheckinTime], CultureInfo.InvariantCulture));
rec.CheckinInterval = TimeSpan.FromMilliseconds(Convert.ToInt64(rs[ColumnCheckinInterval], CultureInfo.InvariantCulture));
list.Add(rec);
}
}
return list;
}
/// <summary>
/// Associate a listener with a job.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="job">The job to associate with the listener.</param>
/// <param name="listener">The listener to insert.</param>
/// <returns>The number of rows inserted.</returns>
public virtual int InsertJobListener(ConnectionAndTransactionHolder conn, JobDetail job, string listener)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlInsertJobListener)))
{
AddCommandParameter(cmd, 1, "jobName", job.Name);
AddCommandParameter(cmd, 2, "jobGroup", job.Group);
AddCommandParameter(cmd, 3, "listener", listener);
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Get the number of triggers in the given states that have
/// misfired - according to the given timestamp.
/// </summary>
/// <param name="conn"></param>
/// <param name="state1"></param>
/// <param name="state2"></param>
/// <param name="ts"></param>
/// <returns></returns>
public int CountMisfiredTriggersInStates(ConnectionAndTransactionHolder conn, string state1, string state2, DateTime ts)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlCountMisfiredTriggersInStates)))
{
AddCommandParameter(cmd, 1, "nextFireTime", Convert.ToDecimal(ts.Ticks));
AddCommandParameter(cmd, 2, "state1", state1);
AddCommandParameter(cmd, 3, "state2", state2);
using (IDataReader rs = cmd.ExecuteReader())
{
if (rs.Read())
{
return Convert.ToInt32(rs.GetValue(0), CultureInfo.InvariantCulture);
}
}
throw new Exception("No misfired trigger count returned.");
}
}
/// <summary>
/// Select the JobDetail object for a given job name / group name.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <param name="jobName">The job name whose listeners are wanted.</param>
/// <param name="groupName">The group containing the job.</param>
/// <param name="loadHelper">The load helper.</param>
/// <returns>The populated JobDetail object.</returns>
public virtual JobDetail SelectJobDetail(ConnectionAndTransactionHolder conn, string jobName, string groupName,
ITypeLoadHelper loadHelper)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobDetail)))
{
AddCommandParameter(cmd, 1, "jobName", jobName);
AddCommandParameter(cmd, 2, "jobGroup", groupName);
using (IDataReader rs = cmd.ExecuteReader())
{
JobDetail job = null;
if (rs.Read())
{
job = new JobDetail();
job.Name = GetString(rs[ColumnJobName]);
job.Group = GetString(rs[ColumnJobGroup]);
job.Description = GetString(rs[ColumnDescription]);
job.JobType = loadHelper.LoadType(GetString(rs[ColumnJobClass]));
job.Durable = GetBoolean(rs[ColumnIsDurable]);
job.Volatile = GetBoolean(rs[ColumnIsVolatile]);
job.RequestsRecovery = GetBoolean(rs[ColumnRequestsRecovery]);
IDictionary map;
if (CanUseProperties)
{
map = GetMapFromProperties(rs, 8);
}
else
{
map = (IDictionary)GetObjectFromBlob(rs, 8);
}
if (null != map)
{
job.JobDataMap = new JobDataMap(map);
}
}
return job;
}
}
}
/// <summary>
/// Get the names of all of the jobs that are volatile.
/// </summary>
/// <param name="conn">The DB Connection</param>
/// <returns>An array of <see cref="Key" /> objects.</returns>
public virtual Key[] SelectVolatileJobs(ConnectionAndTransactionHolder conn)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectVolatileJobs)))
{
AddCommandParameter(cmd, 1, "isVolatile", GetDbBooleanValue(true));
using (IDataReader dr = cmd.ExecuteReader())
{
ArrayList list = new ArrayList();
while (dr.Read())
{
string triggerName = (string)dr[ColumnJobName];
string groupName = (string)dr[ColumnJobGroup];
list.Add(new Key(triggerName, groupName));
}
Object[] oArr = list.ToArray();
Key[] kArr = new Key[oArr.Length];
Array.Copy(oArr, 0, kArr, 0, oArr.Length);
return kArr;
}
}
}
/// <summary>
/// Select all of the job group names that are stored.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <returns>An array of <see cref="String" /> group names.</returns>
public virtual string[] SelectJobGroups(ConnectionAndTransactionHolder conn)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectJobGroups)))
{
using (IDataReader rs = cmd.ExecuteReader())
{
ArrayList list = new ArrayList();
while (rs.Read())
{
list.Add(rs[0]);
}
object[] oArr = list.ToArray();
string[] sArr = new string[oArr.Length];
Array.Copy(oArr, 0, sArr, 0, oArr.Length);
return sArr;
}
}
}
/// <summary>
/// Selects the paused trigger groups.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <returns></returns>
public virtual ISet SelectPausedTriggerGroups(ConnectionAndTransactionHolder conn)
{
HashSet retValue = new HashSet();
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectPausedTriggerGroups)))
{
using (IDataReader dr = cmd.ExecuteReader())
{
while (dr.Read())
{
string groupName = (string)dr[ColumnTriggerGroup];
retValue.Add(groupName);
}
}
return retValue;
}
}
//---------------------------------------------------------------------------
// triggers
//---------------------------------------------------------------------------
/// <summary>
/// Insert the base trigger data.
/// </summary>
/// <param name="conn">the DB Connection</param>
/// <param name="trigger">the trigger to insert</param>
/// <param name="state">the state that the trigger should be stored in</param>
/// <param name="jobDetail">The job detail.</param>
/// <returns>the number of rows inserted</returns>
public virtual int InsertTrigger(ConnectionAndTransactionHolder conn, Trigger trigger, string state,
JobDetail jobDetail)
{
byte[] baos = null;
if (trigger.JobDataMap.Count > 0)
{
baos = SerializeJobData(trigger.JobDataMap);
}
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlInsertTrigger)))
{
AddCommandParameter(cmd, 1, "triggerName", trigger.Name);
AddCommandParameter(cmd, 2, "triggerGroup", trigger.Group);
AddCommandParameter(cmd, 3, "triggerJobName", trigger.JobName);
AddCommandParameter(cmd, 4, "triggerJobGroup", trigger.JobGroup);
AddCommandParameter(cmd, 5, "triggerVolatile", GetDbBooleanValue(trigger.Volatile));
AddCommandParameter(cmd, 6, "triggerDescription", trigger.Description);
if (trigger.GetNextFireTimeUtc().HasValue)
{
AddCommandParameter(cmd, 7, "triggerNextFireTime",
Convert.ToDecimal(trigger.GetNextFireTimeUtc().Value.Ticks));
}
else
{
AddCommandParameter(cmd, 7, "triggerNextFireTime", null);
}
long prevFireTime = -1;
if (trigger.GetPreviousFireTimeUtc().HasValue)
{
prevFireTime = trigger.GetPreviousFireTimeUtc().Value.Ticks;
}
AddCommandParameter(cmd, 8, "triggerPreviousFireTime", Convert.ToDecimal(prevFireTime));
AddCommandParameter(cmd, 9, "triggerState", state);
string paramName = "triggerType";
if (trigger is SimpleTrigger && !trigger.HasAdditionalProperties)
{
AddCommandParameter(cmd, 10, paramName, TriggerTypeSimple);
}
else if (trigger is CronTrigger && !trigger.HasAdditionalProperties)
{
AddCommandParameter(cmd, 10, paramName, TriggerTypeCron);
}
else
{
// (trigger instanceof BlobTrigger or additional properties in sub-class
AddCommandParameter(cmd, 10, paramName, TriggerTypeBlob);
}
AddCommandParameter(cmd, 11, "triggerStartTime", Convert.ToDecimal(trigger.StartTimeUtc.Ticks));
long endTime = 0;
if (trigger.EndTimeUtc.HasValue)
{
endTime = trigger.EndTimeUtc.Value.Ticks;
}
AddCommandParameter(cmd, 12, "triggerEndTime", Convert.ToDecimal(endTime));
AddCommandParameter(cmd, 13, "triggerCalendarName", trigger.CalendarName);
AddCommandParameter(cmd, 14, "triggerMisfireInstruction", trigger.MisfireInstruction);
paramName = "triggerJobJobDataMap";
if (baos != null)
{
AddCommandParameter(cmd, 15, paramName, baos, dbProvider.Metadata.DbBinaryType);
}
else
{
AddCommandParameter(cmd, 15, paramName, null, dbProvider.Metadata.DbBinaryType);
}
AddCommandParameter(cmd, 16, "triggerPriority", trigger.Priority);
int insertResult = cmd.ExecuteNonQuery();
if (insertResult > 0)
{
string[] trigListeners = trigger.TriggerListenerNames;
for (int i = 0; trigListeners != null && i < trigListeners.Length; i++)
{
InsertTriggerListener(conn, trigger, trigListeners[i]);
}
}
return insertResult;
}
}
/// <summary>
/// Get the names of all of the triggers in the given group and state that
/// have misfired.
/// </summary>
/// <param name="conn">The DB Connection</param>
/// <param name="groupName">Name of the group.</param>
/// <param name="state">The state.</param>
/// <param name="ts">The timestamp.</param>
/// <returns>an array of <see cref="Key" /> objects</returns>
public virtual Key[] SelectMisfiredTriggersInGroupInState(ConnectionAndTransactionHolder conn, string groupName,
string state,
long ts)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectMisfiredTriggersInGroupInState))
)
{
AddCommandParameter(cmd, 1, "timestamp", Convert.ToDecimal(ts));
AddCommandParameter(cmd, 2, "triggerGroup", groupName);
AddCommandParameter(cmd, 3, "state", state);
using (IDataReader rs = cmd.ExecuteReader())
{
ArrayList list = new ArrayList();
while (rs.Read())
{
string triggerName = GetString(rs[ColumnTriggerName]);
list.Add(new Key(triggerName, groupName));
}
object[] oArr = list.ToArray();
Key[] kArr = new Key[oArr.Length];
Array.Copy(oArr, 0, kArr, 0, oArr.Length);
return kArr;
}
}
}
/// <summary>
/// Insert the cron trigger data.
/// </summary>
/// <param name="conn">the DB Connection</param>
/// <param name="trigger">the trigger to insert</param>
/// <returns>the number of rows inserted</returns>
public virtual int InsertCronTrigger(ConnectionAndTransactionHolder conn, CronTrigger trigger)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlInsertCronTrigger)))
{
AddCommandParameter(cmd, 1, "triggerName", trigger.Name);
AddCommandParameter(cmd, 2, "triggerGroup", trigger.Group);
AddCommandParameter(cmd, 3, "triggerCronExpression", trigger.CronExpressionString);
#if NET_35
AddCommandParameter(cmd, 4, "triggerTimeZone", trigger.TimeZone.Id);
#else
AddCommandParameter(cmd, 4, "triggerTimeZone", trigger.TimeZone.StandardName);
#endif
return cmd.ExecuteNonQuery();
}
}
protected IDbCommand PrepareCommand(ConnectionAndTransactionHolder cth, string commandText)
{
return adoUtil.PrepareCommand(cth, commandText);
}
/// <summary> Release the lock on the identified resource if it is held by the calling
/// thread.
/// </summary>
public virtual void ReleaseLock(ConnectionAndTransactionHolder conn, string lockName)
{
lock (this)
{
lockName = String.Intern(lockName);
if (IsLockOwner(conn, lockName))
{
if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' retuned by: {1}", lockName, Thread.CurrentThread.Name));
}
ThreadLocks.Remove(lockName);
locks.Remove(lockName);
Monitor.PulseAll(this);
}
else if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' attempt to retun by: {1} -- but not owner!", lockName, Thread.CurrentThread.Name), new Exception("stack-trace of wrongful returner"));
}
}
}
/// <summary>
/// Select all of the triggers for jobs that are requesting recovery. The
/// returned trigger objects will have unique "recoverXXX" trigger names and
/// will be in the <see cref="SchedulerConstants.DefaultRecoveryGroup" />
/// trigger group.
/// </summary>
/// <remarks>
/// In order to preserve the ordering of the triggers, the fire time will be
/// set from the <i>ColumnFiredTime</i> column in the <i>TableFiredTriggers</i>
/// table. The caller is responsible for calling <see cref="Trigger.ComputeFirstFireTimeUtc" />
/// on each returned trigger. It is also up to the caller to insert the
/// returned triggers to ensure that they are fired.
/// </remarks>
/// <param name="conn">The DB Connection</param>
/// <returns> an array of <see cref="Trigger" /> objects</returns>
public virtual Trigger[] SelectTriggersForRecoveringJobs(ConnectionAndTransactionHolder conn)
{
ArrayList list = new ArrayList();
using (
IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlSelectInstancesRecoverableFiredTriggers)))
{
AddCommandParameter(cmd, 1, "instanceName", instanceId);
AddCommandParameter(cmd, 2, "requestsRecovery", GetDbBooleanValue(true));
using (IDataReader rs = cmd.ExecuteReader())
{
long dumId = DateTime.UtcNow.Ticks;
while (rs.Read())
{
string jobName = GetString(rs[ColumnJobName]);
string jobGroup = GetString(rs[ColumnJobGroup]);
// string trigName = GetString(rs[ColumnTriggerName]);
// string trigGroup = GetString(rs[ColumnTriggerGroup]);
long firedTimeInTicks = Convert.ToInt64(rs[ColumnFiredTime], CultureInfo.InvariantCulture);
int priority = Convert.ToInt32(rs[ColumnPriority], CultureInfo.InvariantCulture);
DateTime firedTime = new DateTime(firedTimeInTicks);
SimpleTrigger rcvryTrig =
new SimpleTrigger("recover_" + instanceId + "_" + Convert.ToString(dumId++, CultureInfo.InvariantCulture),
SchedulerConstants.DefaultRecoveryGroup, firedTime);
rcvryTrig.JobName = jobName;
rcvryTrig.JobGroup = jobGroup;
rcvryTrig.Priority = priority;
rcvryTrig.MisfireInstruction = MisfireInstruction.SimpleTrigger.FireNow;
list.Add(rcvryTrig);
}
}
}
// read JobDataMaps with different reader..
foreach (SimpleTrigger trigger in list)
{
JobDataMap jd = SelectTriggerJobDataMap(conn, trigger.Name, trigger.Group);
jd.Put(SchedulerConstants.FailedJobOriginalTriggerName, trigger.Name);
jd.Put(SchedulerConstants.FailedJobOriginalTriggerGroup, trigger.Group);
jd.Put(SchedulerConstants.FailedJobOriginalTriggerFiretimeInMillisecoonds, Convert.ToString(trigger.StartTimeUtc, CultureInfo.InvariantCulture));
trigger.JobDataMap = jd;
}
object[] oArr = list.ToArray();
Trigger[] tArr = new Trigger[oArr.Length];
Array.Copy(oArr, 0, tArr, 0, oArr.Length);
return tArr;
}
/// <summary>
/// Delete all fired triggers.
/// </summary>
/// <param name="conn">The DB Connection.</param>
/// <returns>The number of rows deleted.</returns>
public virtual int DeleteFiredTriggers(ConnectionAndTransactionHolder conn)
{
using (IDbCommand cmd = PrepareCommand(conn, ReplaceTablePrefix(SqlDeleteFiredTriggers)))
{
return cmd.ExecuteNonQuery();
}
}
/// <summary>
/// Closes the connection.
/// </summary>
/// <param name="connectionAndTransactionHolder">The connection and transaction holder.</param>
protected override void CloseConnection(ConnectionAndTransactionHolder connectionAndTransactionHolder)
{
// Will work for transactional and non-transactional connections.
ConnectionUtils.DisposeConnection(connectionAndTransactionHolder.Connection, dbProvider);
}
