private void RenderResults(JobInstance ji) { var q = (QueryBase)ji.Parameters["Query"].Value; var codegen = new SqlServerCodeGenerator(); string sql = codegen.GenerateSelectStarQuery(q.Destination.GetTable(), 100); using (var cn = new SqlConnection()) { cn.ConnectionString = MyDBDataset.ConnectionString; cn.Open(); using (var cmd = cn.CreateCommand()) { cmd.CommandText = sql; cmd.CommandType = CommandType.Text; using (var dr = cmd.ExecuteReader(CommandBehavior.SequentialAccess)) { RenderTable(dr); } } } }
static void CreateJobs(ClusterLoadRepository repo, string poolName) { Task <IEnumerable <JobInstance> > tJobs; var J1 = new JobInstance() { id = Guid.NewGuid().ToString(), Nodes = 4, QueueName = poolName, SchedulerId = "124", Status = AutoScaling.Models.JobStatusEnum.Queued }; repo.CreateJobInstanceAsync(J1).Wait(); var J2 = new JobInstance() { id = Guid.NewGuid().ToString(), Nodes = 4, QueueName = poolName, SchedulerId = "127", Status = AutoScaling.Models.JobStatusEnum.Queued }; repo.CreateJobInstanceAsync(J2).Wait(); var J3 = new JobInstance() { id = Guid.NewGuid().ToString(), Nodes = 8, QueueName = poolName, SchedulerId = "130", Status = AutoScaling.Models.JobStatusEnum.Queued }; repo.CreateJobInstanceAsync(J3).Wait(); tJobs = repo.GetJobInstancesAsync(poolName); var jobs = tJobs.Result; foreach (var item in jobs) { Console.WriteLine($"{item.id} {item.Status}"); } }
/// <summary> /// Creates a row mapper for job executions. /// </summary> /// <param name="jobInstance">the job instance of the executions to create (optional)</param> /// <returns>a row mapper for job executions</returns> private RowMapper <JobExecution> GetJobExecutionRowMapper(JobInstance jobInstance = null) { JobParameters jobParameters = null; return((dataRecord, i) => { var wrapper = new DataRecordWrapper(dataRecord); var id = wrapper.Get <long>(0); var jobConfigurationLocation = wrapper.Get <string>(9); if (jobParameters == null) { jobParameters = GetJobParameters(id); } var jobExecution = jobInstance == null ? new JobExecution(id, jobParameters, jobConfigurationLocation) : new JobExecution(jobInstance, id, jobParameters, jobConfigurationLocation); jobExecution.StartTime = wrapper.Get <DateTime?>(1); jobExecution.EndTime = wrapper.Get <DateTime?>(2); jobExecution.Status = dataRecord.IsDBNull(3) ? null : BatchStatus.ValueOf(dataRecord.GetString(3)); jobExecution.ExitStatus = new ExitStatus(wrapper.Get <string>(4), wrapper.Get <string>(5)); jobExecution.CreateTime = wrapper.Get <DateTime>(6); jobExecution.LastUpdated = wrapper.Get <DateTime?>(7); jobExecution.Version = wrapper.Get <int?>(8); return jobExecution; }); }
private static void pollForJobCompletion(OrchestratorContext sco, Guid jobID) { try { while (!SCOrch.getJobDetails(sco, jobID).job.Status.Equals("Completed")) { System.Threading.Thread.Sleep(new TimeSpan(0, 0, 3)); } JobInstance j = SCOrch.getJobDetails(sco, jobID); Console.WriteLine("<OutputParameters>"); foreach (string key in j.OutputParameters.Keys) { Console.WriteLine(string.Format("\t<{0}>{1}</{0}>", key, j.OutputParameters[key])); } Console.WriteLine("</OutputParameters>"); } // Allow for 1 webservice Error catch { sco = setupOrchestratorConnection(); while (!SCOrch.getJobDetails(sco, jobID).job.Status.Equals("Completed")) { System.Threading.Thread.Sleep(new TimeSpan(0, 0, 3)); } JobInstance j = SCOrch.getJobDetails(sco, jobID); Console.WriteLine("<OutputParameters>"); foreach (string key in j.OutputParameters.Keys) { Console.WriteLine(string.Format("\t<{0}>{1}</{0}>", key, j.OutputParameters[key])); } Console.WriteLine("</OutputParameters>"); } }
public static JobDescription GetJobDescription(JobInstance job) { // In this function, we don't directly deserialize query parameters because // that could break old job definitions once the job format changes. It's // save to read parameters from the xml representation directly. var jobDescription = new JobDescription(); jobDescription.Job = job; try { if (queryJobDefinitions.ContainsKey(job.JobDefinitionReference.Guid)) { GetQueryJobDescription(job, jobDescription); } else if (exportJobDefinitions.ContainsKey(job.JobDefinitionReference.Guid)) { GetExportJobDescription(job, jobDescription); } else { jobDescription.JobType = JobType.Unknown; } } catch (Exception) { jobDescription.JobType = JobType.Unknown; } return(jobDescription); }
public void Initialize() { _jobInstance = new JobInstance(1, "testJob"); _jobExecution = new JobExecution(_jobInstance, new JobParameters()); _stepExecution1 = new StepExecution("testStep1", _jobExecution, 1); _stepExecution2 = new StepExecution("testStep2", _jobExecution, 2); }
private IEnumerable <JobDetails> parseResults(JobInstance job) { for (int i = 0; i < 1; i++) { yield return(new JobDetails(job)); } }
protected void RenderOutput() { Response.Expires = -1; try { var ji = new JobInstance(RegistryContext); ji.Guid = LastQueryJobGuid; ji.Load(); switch (ji.JobExecutionStatus) { case JobExecutionState.Completed: RenderResults(ji); break; case JobExecutionState.Scheduled: case JobExecutionState.Starting: case JobExecutionState.Executing: RenderExecuting(); break; default: RenderFailed(ji); break; } } catch (Exception ex) { RenderException(ex); } }
/// <summary> /// IJobExecutionDao#FindJobExecutions. /// </summary> /// <param name="jobInstance"></param> /// <returns></returns> public IList <JobExecution> FindJobExecutions(JobInstance jobInstance) { return(_executionsById.Values.Where(j => j.JobInstance.Equals(jobInstance)) .Select(Copy) .OrderByDescending(j => j.Id) .ToList()); }
/// <summary> /// Creates a job instance with given name and parameters. /// A job instance with the same name and parameters should not already exist. /// </summary> /// <param name="jobName">the job name</param> /// <param name="jobParameters">job parameters</param> /// <returns>a new persisted job instance</returns> public JobInstance CreateJobInstance(string jobName, JobParameters jobParameters) { Assert.NotNull(jobName, "Job name must not be null"); Assert.NotNull(jobParameters, "Job parameters must not be null"); Assert.State(GetJobInstance(jobName, jobParameters) == null, "A job instance with this combination of name and parameters must not already exist"); using (var scope = new TransactionScope(TransactionScopeOption.Required, TransactionOptions)) { var jobId = _jobIncrementer.NextLong(); var jobInstance = new JobInstance(jobId, jobName); jobInstance.IncrementVersion(); var parameters = new Dictionary <string, object> { { "id", jobId }, { "jobName", jobName }, { "key", _jobKeyGenerator.GenerateKey(jobParameters) }, { "version", jobInstance.Version } }; DbOperator.Update(InsertTablePrefix(CreateJobInstanceQuery), parameters); scope.Complete(); return(jobInstance); } }
public void Initialize() { _jobExecutionDao = new MapJobExecutionDao(); _instance = new JobInstance(1, "testJob"); _parameters = new JobParameters(); _execution = new JobExecution(_instance, _parameters); }
/// <summary> /// Finished the execution of a job and records the results in the registry. /// </summary> /// <param name="workflowInstanceId"></param> /// <param name="eventType"></param> private void FinishJob(Job job, HostEventArgs e) { using (Context context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit)) { context.JobGuid = job.Guid; context.ContextGuid = contextGuid; JobInstance ji = new JobInstance(context); ji.Guid = job.Guid; ji.Load(); // Update execution status, error message and finish time switch (e.EventType) { case WorkflowEventType.Completed: ji.JobExecutionStatus = JobExecutionState.Completed; break; case WorkflowEventType.Cancelled: ji.JobExecutionStatus = JobExecutionState.Cancelled; break; case WorkflowEventType.TimedOut: ji.JobExecutionStatus = JobExecutionState.TimedOut; break; case WorkflowEventType.Persisted: ji.JobExecutionStatus = JobExecutionState.Persisted; break; case WorkflowEventType.Failed: ji.JobExecutionStatus = JobExecutionState.Failed; ji.ExceptionMessage = e.ExceptionMessage; break; } // Update registry ji.DateFinished = DateTime.Now; ji.Save(); ji.ReleaseLock(false); ji.RescheduleIfRecurring(); // Do local bookkeeping lock (runningJobs) { lock (Cluster.Queues[job.QueueGuid].Jobs) { Cluster.Queues[job.QueueGuid].Jobs.Remove(job.Guid); } runningJobs.Remove(job.WorkflowInstanceId); } if (interactive) { Console.WriteLine("Finishing job: {0}", ji.Guid); } } }
private void CancelOrTimeOutJob(Job job, bool timeout) { using (Context context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit)) { context.JobGuid = job.Guid; context.ContextGuid = contextGuid; var ji = new JobInstance(context); ji.Guid = job.Guid; ji.Load(); // Update registry ji.JobExecutionStatus = JobExecutionState.Cancelling; ji.Save(); } // Update job status if (timeout) { job.Status = JobStatus.TimedOut; appDomains[job.AppDomainID].TimeOutJob(job); } else { job.Status = JobStatus.Cancelled; appDomains[job.AppDomainID].CancelJob(job); } }
/// <summary> /// Finds all dependencies for a JobExecution, including JobInstance (which /// requires JobParameters) plus StepExecutions. /// </summary> /// <param name="jobExecution"></param> private void GetJobExecutionDependencies(JobExecution jobExecution) { JobInstance jobInstance = _jobInstanceDao.GetJobInstance(jobExecution); _stepExecutionDao.AddStepExecutions(jobExecution); jobExecution.JobInstance = jobInstance; jobExecution.ExecutionContext = _executionContextDao.GetExecutionContext(jobExecution); }
public static string GetFormattedJobInfoAsHtml(Integration integration, JobInstance jobInstance, JobStepInstance jobStepInstance) { StringBuilder jobInfo = new StringBuilder(); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Integration: ")); if (integration == null) { jobInfo.Append("N/A"); } else { jobInfo.Append(string.Format("{0} ({1})", integration.Name, integration.Id)); } jobInfo.Append(HtmlBuilder.GetLineBreak()); if (jobInstance == null) { jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job:") + " N/A"); jobInfo.Append(HtmlBuilder.GetLineBreak()); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Queue Request:") + " N/A"); jobInfo.Append(HtmlBuilder.GetLineBreak()); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job Instance:") + " N/A"); jobInfo.Append(HtmlBuilder.GetLineBreak()); } else { jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job: ")); jobInfo.Append(string.Format("{0} ({1})", jobInstance.Job.Name, jobInstance.Job.Id)); jobInfo.Append(HtmlBuilder.GetLineBreak()); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Queue Request: ")); jobInfo.Append(string.Format("{0} ({1})", jobInstance.QueueRequest.InvocationSourceType, jobInstance.QueueRequest.Id)); jobInfo.Append(HtmlBuilder.GetLineBreak()); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job Instance: ")); jobInfo.Append(jobInstance.Id); jobInfo.Append(HtmlBuilder.GetLineBreak()); } if (jobStepInstance == null) { jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job Step:") + " N/A"); jobInfo.Append(HtmlBuilder.GetLineBreak()); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job Step Instance:") + " N/A"); jobInfo.Append(HtmlBuilder.GetLineBreak()); } else { jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job Step: ")); jobInfo.Append(string.Format("{0} ({1})", jobStepInstance.JobStep.Name, jobStepInstance.JobStep.Id)); jobInfo.Append(HtmlBuilder.GetLineBreak()); jobInfo.Append(HtmlBuilder.WrapInBoldTags("Job Step Instance: ")); jobInfo.Append(jobStepInstance.Id); jobInfo.Append(HtmlBuilder.GetLineBreak()); } jobInfo.Append(HtmlBuilder.GetLineBreak()); return(jobInfo.ToString()); }
private JobInstance LoadJobInstance(Context context, Job job) { var ji = new JobInstance(context); ji.Guid = job.Guid; ji.Load(); return(ji); }
private void InitializeMembers() { this.job = null; this.jobType = JobType.Unknown; this.query = null; this.schemaName = null; this.objectName = null; this.path = null; }
private static bool runRunbook() { bool status = true; OrchestratorContext sco = setupOrchestratorConnection(); OrchestratorInterop.SCOrchestrator.Job job; try { if (string.IsNullOrEmpty(TargetRunbookServer)) { if (!String.IsNullOrEmpty(RunbookPath)) { job = SCOrch.startRunbookJob(sco, RunbookPath, _InputParameters); } else if (!String.IsNullOrEmpty(RunbookGUID)) { job = SCOrch.startRunbookJob(sco, new Guid(RunbookGUID), _InputParameters); } else { throw new Exception("Must pass either -RunbookPath or -RunbookGUID"); } } else { if (!String.IsNullOrEmpty(RunbookPath)) { job = SCOrch.startRunbookJob(sco, RunbookPath, TargetRunbookServer, _InputParameters); } else if (!String.IsNullOrEmpty(RunbookGUID)) { job = SCOrch.startRunbookJob(sco, new Guid(RunbookGUID), TargetRunbookServer, _InputParameters); } else { throw new Exception("Must pass either -RunbookPath or -RunbookGUID"); } } if (WaitForExit) { pollForJobCompletion(sco, job.Id); } else { JobInstance ji = new JobInstance(); ji.job = job; // WriteObject(ji); } } catch { throw; } return(status); }
private static void pollForJobCompletion(OrchestratorContext sco, Guid jobID) { while (!SCOrch.getJobDetails(sco, jobID).job.Status.Equals("Completed")) { System.Threading.Thread.Sleep(new TimeSpan(0, 0, 3)); } JobInstance j = SCOrch.getJobDetails(sco, jobID); //WriteObject(j); }
/// <summary> /// @see IJobInstanceDao#CreateJobInstance. /// </summary> /// <param name="jobName"></param> /// <param name="jobParameters"></param> /// <returns></returns> public JobInstance CreateJobInstance(string jobName, JobParameters jobParameters) { Assert.State(GetJobInstance(jobName, jobParameters) == null, "A job instance with this name and parameters should not already exist"); JobInstance jobInstance = new JobInstance(Interlocked.Increment(ref _currentId), jobName); jobInstance.IncrementVersion(); _jobInstances[GetKey(jobName, jobParameters)] = jobInstance; return jobInstance; }
/// <summary> /// @see IJobOperator#GetExecutions . /// </summary> /// <param name="instanceId"></param> /// <returns></returns> /// <exception cref="NoSuchJobInstanceException"> </exception> public IList <long?> GetExecutions(long instanceId) { JobInstance jobInstance = JobExplorer.GetJobInstance(instanceId); if (jobInstance == null) { throw new NoSuchJobInstanceException(string.Format("No job instance with id={0}", instanceId)); } return(JobExplorer.GetJobExecutions(jobInstance).Select(jobExecution => jobExecution.Id).ToList()); }
/// <summary> /// Should it start ? /// </summary> /// <param name="stepExecution"></param> /// <param name="context"></param> /// <returns></returns> /// <exception cref="JobExecutionException"></exception> protected bool GetStartable(StepExecution stepExecution, ExecutionContext context) { JobInstance jobInstance = stepExecution.JobExecution.JobInstance; string stepName = stepExecution.StepName; StepExecution lastStepExecution = JobRepository.GetLastStepExecution(jobInstance, stepName); bool isRestart = (lastStepExecution != null && lastStepExecution.BatchStatus != BatchStatus.Completed); stepExecution.ExecutionContext = isRestart ? lastStepExecution.ExecutionContext : context; return(ShouldStart(AllowStartIfComplete, stepExecution, lastStepExecution) || isRestart); }
private static void NotifyViaMail(Exception ex) { // if a MailException itself, exit to avoid an infinite loop if (ex is MailException || !EnableMailNotifications) { return; } if (mailNotifier == null) { WriteToLog(LogEntryType.Warning, "Email notifications are enabled but not configured. The email could not be sent."); return; } string msg = ""; Integration integration = null; JobInstance jobInstance = null; JobStepInstance jobStepInstance = null; try { // returns null if not found jobInstance = JobQueueManager.GetJobInstanceByParallelTaskId(Thread.CurrentThread.ManagedThreadId); if (jobInstance != null) { integration = jobInstance.Integration; jobStepInstance = jobInstance.RunningJobStepInstance; } var jobInfo = MailFormatter.GetFormattedJobInfoAsHtml(integration, jobInstance, jobStepInstance); msg = MailFormatter.GetTextAsFormattedDiv(jobInfo) + ExceptionFormatter.FormatExceptionForWeb(ex); } catch (Exception innerEx) { StringBuilder failureInfo = new StringBuilder(); failureInfo.AppendFormat("<b>Job info could not be obtained because of error:</b><br /> {0} {1}", innerEx.Message, innerEx.StackTrace); failureInfo.Append(HtmlBuilder.GetLineBreak(2)); msg = MailFormatter.GetTextAsFormattedDiv(failureInfo.ToString()) + ExceptionFormatter.FormatExceptionForWeb(ex); } // Exceptions are caught within MailNotifier class and logged via the SyncEngineLogger if (integration == null) { mailNotifier.SendMessage("SyncObjX Integration Services - An Error Has Occurred", msg); } else { mailNotifier.SendMessage(string.Format("SyncObjX Integration Services - Error Occurred in \"{0}\"", integration.Name), msg); } }
protected void CancelJob(Guid guid) { using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.AutoCommit)) { var job = new JobInstance(context); job.Guid = guid; job.Load(); job.Cancel(); } }
protected JobInstance LoadJob(Guid guid) { using (var context = ContextManager.Instance.CreateContext(ConnectionMode.AutoOpen, TransactionMode.DirtyRead)) { var job = new JobInstance(context); job.Guid = guid; job.Load(); return(job); } }
/// <summary> /// @see IJobInstanceDao#CreateJobInstance. /// </summary> /// <param name="jobName"></param> /// <param name="jobParameters"></param> /// <returns></returns> public JobInstance CreateJobInstance(string jobName, JobParameters jobParameters) { Assert.State(GetJobInstance(jobName, jobParameters) == null, "A job instance with this name and parameters should not already exist"); JobInstance jobInstance = new JobInstance(Interlocked.Increment(ref _currentId), jobName); jobInstance.IncrementVersion(); _jobInstances[GetKey(jobName, jobParameters)] = jobInstance; return(jobInstance); }
public static void WriteToLog(LogEntryType logEntryType, JobInstance jobInstance, JobStepInstance jobStepInstance, DataSource dataSource, string message) { try { WriteToLog(logEntryType, jobInstance.Integration, dataSource, jobInstance, jobStepInstance, message); } catch (Exception ex) { WriteExceptionToLog(jobInstance, ex, "An exception occurred for message: {0}", message ?? ""); } }
public static void WriteToLog(LogEntryType logEntryType, JobInstance jobInstance, JobStepInstance jobStepInstance, DataSource dataSource, string format, params object[] args) { try { WriteToLog(logEntryType, jobInstance.Integration, dataSource, jobInstance, jobStepInstance, () => { return(string.Format(format, args)); }); } catch (Exception ex) { WriteExceptionToLog(jobInstance, ex); } }
/// <summary> /// Returns StepExecution count. /// </summary> /// <param name="jobInstance"></param> /// <param name="stepName"></param> /// <returns></returns> public int GetStepExecutionCount(JobInstance jobInstance, string stepName) { var count = 0; var jobExecutions = _jobExecutionDao.FindJobExecutions(jobInstance); foreach (var jobExecution in jobExecutions) { _stepExecutionDao.AddStepExecutions(jobExecution); count += jobExecution.StepExecutions.Count(stepExecution => stepName.Equals(stepExecution.StepName)); } return(count); }
private JobInstance GetInitializedJobInstance(string queueName, string comments) { JobInstance job = CreateJobInstance( EntityFactory.CombineName(EntityType.JobDefinition, Registry.AppSettings.FederationName, typeof(ExportTablesJob).Name), queueName, comments); job.Name = String.Format("{0}_{1}", Context.UserName, job.JobID); job.Comments = comments; return(job); }
/// <summary> /// Retrieves job executions by their job instance. The corresponding step /// executions may not be fully hydrated (e.g. their execution context may be /// missing), depending on the implementation. Use /// <see cref="GetStepExecution"/> to hydrate them in that case. /// </summary> /// <param name="jobInstance">the JobInstance to query</param> /// <returns>the set of all executions for the specified JobInstance</returns> public IList<JobExecution> GetJobExecutions(JobInstance jobInstance) { IList<JobExecution> executions = _jobExecutionDao.FindJobExecutions(jobInstance); foreach (JobExecution jobExecution in executions) { GetJobExecutionDependencies(jobExecution); foreach (StepExecution stepExecution in jobExecution.StepExecutions) { GetStepExecutionDependencies(stepExecution); } } return executions; }
public void TestFindRunningJobExecutions() { var instance2 = new JobInstance(2, "testJob2"); var execution2 = new JobExecution(instance2, _parameters); _jobExecutionDao.SaveJobExecution(_execution); _jobExecutionDao.SaveJobExecution(execution2); var runningExecutions = _jobExecutionDao.FindRunningJobExecutions("testJob"); Assert.AreEqual(1, runningExecutions.Count); Assert.IsTrue(runningExecutions.Contains(_execution)); }
void CreateJobInstance() { _jobInstance = new JobInstance { JobId = Job.JobId, Start = Time }; lock (JobSchedulerModelLocker) { Model.Add(_jobInstance); Model.SaveChanges(); } }
/// <summary> /// Creates a job instance with given name and parameters. /// A job instance with the same name and parameters should not already exist. /// </summary> /// <param name="jobName">the job name</param> /// <param name="jobParameters">job parameters</param> /// <returns>a new persisted job instance</returns> public JobInstance CreateJobInstance(string jobName, JobParameters jobParameters) { Assert.NotNull(jobName, "Job name must not be null"); Assert.NotNull(jobParameters, "Job parameters must not be null"); Assert.State(GetJobInstance(jobName, jobParameters) == null, "A job instance with this combination of name and parameters must not already exist"); using (var scope = new TransactionScope(TransactionScopeOption.Required, TransactionOptions)) { var jobId = _jobIncrementer.NextLong(); var jobInstance = new JobInstance(jobId, jobName); jobInstance.IncrementVersion(); var parameters = new Dictionary<string, object> { { "id", jobId }, { "jobName", jobName }, { "key", _jobKeyGenerator.GenerateKey(jobParameters) }, { "version", jobInstance.Version } }; DbOperator.Update(InsertTablePrefix(CreateJobInstanceQuery), parameters); scope.Complete(); return jobInstance; } }
/// <summary> /// Creates JobExecution. /// </summary> /// <param name="jobInstance"></param> /// <param name="jobParameters"></param> /// <param name="jobConfigurationLocation"></param> /// <returns></returns> public JobExecution CreateJobExecution(JobInstance jobInstance, JobParameters jobParameters, string jobConfigurationLocation) { Assert.NotNull(jobInstance, "A JobInstance is required to associate the JobExecution with"); Assert.NotNull(jobParameters, "A JobParameters object is required to create a JobExecution"); ExecutionContext executionContext = new ExecutionContext(); var jobExecution = new JobExecution(jobInstance, jobParameters, jobConfigurationLocation) { ExecutionContext = executionContext, LastUpdated = DateTime.Now }; // Save the JobExecution so that it picks up an ID (useful for clients // monitoring asynchronous executions): _jobExecutionDao.SaveJobExecution(jobExecution); _executionContextDao.SaveExecutionContext(jobExecution); return jobExecution; }
/// <summary> /// Returns StepExecution count. /// </summary> /// <param name="jobInstance"></param> /// <param name="stepName"></param> /// <returns></returns> public int GetStepExecutionCount(JobInstance jobInstance, string stepName) { var count = 0; var jobExecutions = _jobExecutionDao.FindJobExecutions(jobInstance); foreach (var jobExecution in jobExecutions) { _stepExecutionDao.AddStepExecutions(jobExecution); count += jobExecution.StepExecutions.Count(stepExecution => stepName.Equals(stepExecution.StepName)); } return count; }
/// <summary> /// Returns last StepExecution. /// </summary> /// <param name="jobInstance"></param> /// <param name="stepName"></param> /// <returns></returns> public StepExecution GetLastStepExecution(JobInstance jobInstance, string stepName) { var jobExecutions = _jobExecutionDao.FindJobExecutions(jobInstance); var stepExecutions = new List<StepExecution>(jobExecutions.Count); foreach (var jobExecution in jobExecutions) { _stepExecutionDao.AddStepExecutions(jobExecution); stepExecutions.AddRange(jobExecution.StepExecutions.Where(stepExecution => stepName.Equals(stepExecution.StepName))); } StepExecution latest = null; foreach (var stepExecution in stepExecutions) { if (latest == null) { latest = stepExecution; } if (latest.StartTime.Ticks < stepExecution.StartTime.Ticks) { latest = stepExecution; } } if (latest == null) { return null; } var stepExecutionContext = _executionContextDao.GetExecutionContext(latest); latest.ExecutionContext = stepExecutionContext; var jobExecutionContext = _executionContextDao.GetExecutionContext(latest.JobExecution); latest.JobExecution.ExecutionContext = jobExecutionContext; return latest; }
/// <summary> /// Finds all the job executions for a job instance, /// sorted by descending creation order (the first element is the most recent). /// </summary> /// <param name="jobInstance">a job instance</param> /// <returns>a list of job executions</returns> public IList<JobExecution> FindJobExecutions(JobInstance jobInstance) { Assert.NotNull(jobInstance, "The job must not be null."); Assert.NotNull(jobInstance.Id, "the job id must not be null."); using (var scope = new TransactionScope(TransactionScopeOption.Required, TransactionOptions)) { var result = DbOperator.Select(InsertTablePrefix(FindJobExecutionsQuery), GetJobExecutionRowMapper(jobInstance), new Dictionary<string, object> { { "id", jobInstance.Id } }); scope.Complete(); return result; } }
/// <summary> /// Returns the last job execution for a given job instance. /// </summary> /// <param name="jobInstance">a job instance</param> /// <returns>the last created job execution for the job instance</returns> public JobExecution GetLastJobExecution(JobInstance jobInstance) { using (var scope = new TransactionScope(TransactionScopeOption.Required, TransactionOptions)) { var executions = DbOperator.Select(InsertTablePrefix(GetLastExecutionQuery), GetJobExecutionRowMapper(jobInstance), new Dictionary<string, object> { { "id", jobInstance.Id } }); var result = executions.Count > 0 ? executions[0] : null; scope.Complete(); return result; } }
/// <summary> /// Creates a row mapper for job executions. /// </summary> /// <param name="jobInstance">the job instance of the executions to create (optional)</param> /// <returns>a row mapper for job executions</returns> private RowMapper<JobExecution> GetJobExecutionRowMapper(JobInstance jobInstance = null) { JobParameters jobParameters = null; return (dataRecord, i) => { var wrapper = new DataRecordWrapper(dataRecord); var id = wrapper.Get<long>(0); var jobConfigurationLocation = wrapper.Get<string>(9); if (jobParameters == null) { jobParameters = GetJobParameters(id); } var jobExecution = jobInstance == null ? new JobExecution(id, jobParameters, jobConfigurationLocation) : new JobExecution(jobInstance, id, jobParameters, jobConfigurationLocation); jobExecution.StartTime = wrapper.Get<DateTime?>(1); jobExecution.EndTime = wrapper.Get<DateTime?>(2); jobExecution.Status = dataRecord.IsDBNull(3) ? null : BatchStatus.ValueOf(dataRecord.GetString(3)); jobExecution.ExitStatus = new ExitStatus(wrapper.Get<string>(4), wrapper.Get<string>(5)); jobExecution.CreateTime = wrapper.Get<DateTime>(6); jobExecution.LastUpdated = wrapper.Get<DateTime?>(7); jobExecution.Version = wrapper.Get<int?>(8); return jobExecution; }; }
/// <summary> /// IJobExecutionDao#FindJobExecutions. /// </summary> /// <param name="jobInstance"></param> /// <returns></returns> public IList<JobExecution> FindJobExecutions(JobInstance jobInstance) { return _executionsById.Values.Where(j => j.JobInstance.Equals(jobInstance)) .Select(Copy) .OrderByDescending(j => j.Id) .ToList(); }
/// <summary> /// @see IJobExecutionDao#GetLastJobExecution. /// </summary> /// <param name="jobInstance"></param> /// <returns></returns> public JobExecution GetLastJobExecution(JobInstance jobInstance) { return _executionsById.Values.Where(e => e.JobInstance.Equals(jobInstance)) .OrderByDescending(e => e.CreateTime) .First(); }