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