public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
var tasks = (from t in job.Tasks
select new { Task = t, Dependencies = t.Dependencies.Count }).ToList();
while(tasks.Count() > 0)
{
var task = (from t in tasks
where t.Dependencies == 0
select t.Task).First();
updateStatus(string.Format("Creating task \"{0}\"...", task.Name));
tasks = (from t in tasks
where t.Task != task
let dependencyList = t.Task.Dependencies
let dependencyCount = t.Dependencies
select new
{
Task = t.Task,
Dependencies = dependencyList.Contains(task)
?
dependencyCount - 1
:
dependencyCount
}).ToList();
task.Id = jobManager.CreateTask(task.ToContract());
}
}
public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
}
public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
var allFiles = job.Files.ToDictionary(file => file, _ => false);
var totalItems = job.Tasks.Count;
var currentItem = 0;
foreach(var task in job.Tasks)
{
updateStatus(string.Format("Processing files used by task \"{0}\"...", task.Name));
allFiles[task.EntryPoint.Assembly] = true;
foreach(var file in task.EntryPoint.References)
allFiles[file] = true;
foreach(var file in task.InputFiles)
allFiles[file] = true;
foreach(var file in task.OutputFiles)
allFiles[file] = true;
currentItem++;
}
updateStatus("Building file list...");
job.Files = allFiles.Where(pair => pair.Value)
.Select(pair => pair.Key)
.ToList();
}
public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
job.Id = jobManager.CreateJob(job.Name).Id;
}
public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
updateStatus("Validating job's graph...");
var index = 0;
var count = job.Tasks.Count;
if(!job.Tasks.All(task => RecoursiveCheckGraph(task, ImmutableList<Japi.Task>.Empty)))
{
throw new Exception("Job is invalid: graph contains cycles.");
}
}
public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
foreach(var file in job.Files)
{
if(file is Japi.CreateFile)
updateStatus(string.Format("Creating file: {0}...", file.Name));
else
updateStatus(string.Format("Uploading file: {0}...", file.Name));
file.SaveFile(repositoryService);
}
}
private static void ExecuteJob(Japi.Job job)
{
var stagesProvider = new StagesProvider();
var repositoryClientFactory = new RepositoryClientFactory();
var jobManagerClientFactory = new JobManagerClientFactory();
using(var repository = repositoryClientFactory.CreateClient())
{
using(var jobManager = jobManagerClientFactory.CreateClient(new JobManagerCallback()))
{
foreach(var stage in stagesProvider.Stages)
{
Console.WriteLine(stage.Name + "...");
stage.Execute(job, Console.WriteLine, repository, jobManager);
}
}
}
}
public override void Execute(
Japi.Job job,
Action<string> updateStatus,
IRepository repositoryService,
IJobManager jobManager)
{
var timer = Stopwatch.StartNew();
jobManager.OpenJob(job.Id);
jobManager.StartJob();
while(true)
{
var state = jobManager.QueryJobState(job.Id);
if(state == JobState.Completed)
{
timer.Stop();
updateStatus(string.Format("Job completed in {0} ms", timer.ElapsedMilliseconds));
return;
}
if(state == JobState.Failed)
{
timer.Stop();
using (ConsoleMessage.Error())
{
updateStatus("Job failed. Loading error report...");
var summary = jobManager.GetErrorReport(job.Id);
updateStatus(string.Format("Error report for job {{{0}, \"{1}\"}}", summary.JobId,
summary.JobName));
foreach (var report in summary.Errors)
{
updateStatus(string.Format("Task {{{0}, \"{1}\"}}: {2}",
report.Task.Id, report.Task.Name, report.Error));
}
}
return;
}
Thread.Sleep(100);
}
}
private static bool RecoursiveCheckGraph(Japi.Task root, ImmutableList<Japi.Task> previousTasks)
{
if(previousTasks.Contains(root))
{
Console.WriteLine("1: {0}", root);
return false;
}
foreach(var task in root.Dependencies)
{
if(previousTasks.Contains(task))
{
Console.WriteLine("2: {0}", root);
return false;
}
if(!RecoursiveCheckGraph(task, previousTasks.Add(root)))
return false;
}
return true;
}
