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