public void CancelJob()
{
var proj = this.Project;
var api = new JobsApi();
api.CancelJobAsync(proj.Owner.Name, proj.Name, this.JobID);
}
private static CloudJob GetJob(Project proj, string jobID)
{
var api = new JobsApi();
var job = api.GetJob(proj.Owner.Name, proj.Name, jobID.ToString());
return(job);
}
private static JobsApi GetApiInstance(string token, string serverUrl)
{
var apiInstance = new JobsApi(serverUrl);
apiInstance.Configuration.AccessToken = token;
return(apiInstance);
}
public static JobReport pollJob(JobReport job, string sessionId, string url)
{
JobsApi jobsApi = new JobsApi(url);
JobReport polledJob;
do
{
Thread.Sleep(1000);
polledJob = jobsApi.JobGet(sessionId, job.Id);
Console.WriteLine(polledJob.Status);
} while (polledJob.Status != "error" && polledJob.Status != "finished");
return(polledJob);
}
public static JobViewModel GetJobViewModel(AuthAPIManager apiManager, string jobId)
{
JobsApi jobsApi = new JobsApi(apiManager.Configuration);
try
{
return(jobsApi.ApiV1JobsViewIdGet(jobId));
}
catch (Exception ex)
{
// In case of Unauthorized request
if (ex.GetType().GetProperty("ErrorCode").GetValue(ex, null).ToString() == "401")
{
// Refresh Token and Call API
jobsApi.Configuration.AccessToken = apiManager.GetToken();
return(jobsApi.ApiV1JobsViewIdGet(jobId));
}
throw ex;
}
}
public static int UpdateJobPatch(AuthAPIManager apiManager, string id, List <Operation> body)
{
JobsApi jobsApi = new JobsApi(apiManager.Configuration);
try
{
return(jobsApi.ApiV1JobsIdPatchWithHttpInfo(id, body).StatusCode);
}
catch (Exception ex)
{
// In case of Unauthorized request
if (ex.GetType().GetProperty("ErrorCode").GetValue(ex, null).ToString() == "401")
{
// Refresh Token and Call API
jobsApi.Configuration.AccessToken = apiManager.GetToken();
return(jobsApi.ApiV1JobsIdPatchWithHttpInfo(id, body).StatusCode);
}
throw ex;
}
}
public static ApiResponse <Job> UpdateJobStatus(AuthAPIManager apiManager, string agentId, string jobId, JobStatusType status, JobErrorViewModel errorModel = null)
{
JobsApi jobsApi = new JobsApi(apiManager.Configuration);
try
{
return(jobsApi.ApiV1JobsIdStatusStatusPutWithHttpInfo(agentId, jobId, status, errorModel));
}
catch (Exception ex)
{
// In case of Unauthorized request
if (ex.GetType().GetProperty("ErrorCode").GetValue(ex, null).ToString() == "401")
{
// Refresh Token and Call API
jobsApi.Configuration.AccessToken = apiManager.GetToken();
return(jobsApi.ApiV1JobsIdStatusStatusPutWithHttpInfo(agentId, jobId, status, errorModel));
}
throw ex;
}
}
public JobsApiTests()
{
instance = new JobsApi();
}
public void Init()
{
api = new JobsApi();
Project = CreateProject(NewProject);
}
public async Task <string> WatchJobStatusAsync(Action <string> progressAction = default, System.Threading.CancellationToken cancelToken = default)
{
var api = new JobsApi();
var proj = this.Project;
var jobId = this.JobID;
var cloudJob = api.GetJob(proj.Owner.Name, proj.Name, jobId);
var status = cloudJob.Status;
var startTime = status.StartedAt;
while (status.FinishedAt <= status.StartedAt)
{
var currentSeconds = Math.Round((DateTime.UtcNow - startTime).TotalSeconds);
// wait 5 seconds before calling api to re-check the status
var totalDelaySeconds = status.Status == JobStatusEnum.Created ? 3 : 5;
var running = status.RunsPending + status.RunsRunning;
var done = status.RunsFailed + status.RunsCompleted + status.RunsCancelled;
var total = running + done;
for (int i = 0; i < totalDelaySeconds; i++)
{
// suspended by user
cancelToken.ThrowIfCancellationRequested();
var timer = GetUserFriendlyTimeCounter(TimeSpan.FromSeconds(currentSeconds));
var message = total > 1 ? $"{status.Status}: [{done}/{total}]\n{timer}": $"{status.Status}: [{timer}]";
progressAction?.Invoke(message);
await Task.Delay(1000);
currentSeconds++;
}
// suspended by user
cancelToken.ThrowIfCancellationRequested();
// update status
await Task.Delay(1000);
cloudJob = api.GetJob(proj.Owner.Name, proj.Name, jobId);
status = cloudJob.Status;
//_simulation = new Simulation(proj, simuId);
}
this.CloudJob = cloudJob;
// suspended by user
cancelToken.ThrowIfCancellationRequested();
var totalTime = status.FinishedAt - startTime;
var finishMessage = status.Status.ToString();
//progressAction?.Invoke($"Task: {status.Status}");
finishMessage = $"{finishMessage}: [{GetUserFriendlyTimeCounter(totalTime)}]";
progressAction?.Invoke(finishMessage);
return(finishMessage);
string GetUserFriendlyTimeCounter(TimeSpan timeDelta)
{
string format = @"hh\:mm\:ss";
if (timeDelta.Days > 0)
{
format = @"d\ hh\:mm\:ss";
}
else if (timeDelta.Hours > 0)
{
format = @"hh\:mm\:ss";
}
else if (timeDelta.Minutes > 0)
{
format = @"mm\:ss";
}
else
{
format = @"ss";
}
return(timeDelta.ToString(format));
}
}
public SimpleApi(IBitmovinApiClientFactory apiClientFactory)
{
Jobs = new JobsApi(apiClientFactory);
}
public void Init()
{
instance = new JobsApi();
}
/// <summary>
/// Run and monitor the simulation on Pollination
/// </summary>
/// <param name="project">Pollination project</param>
/// <param name="workflow">use </param>
/// <param name="progressLogAction"></param>
/// <param name="cancelFunc"></param>
/// <param name="actionWhenDone"></param>
/// <returns></returns>
private async Task <CloudJob> ScheduleCloudJobAsync(
Project project,
Job job,
Action <string> progressLogAction = default,
CancellationToken cancellationToken = default,
Action actionWhenDone = default)
{
// Get project
var proj = project;
//var job = this._Job;
// Check if recipe can be used in this project
CheckRecipeInProject(job.Source, proj);
// Upload artifacts
// check artifacts
var tempProjectDir = CheckArtifacts(job, this.JobInfo.SubFolderPath);
// upload artifacts
if (!string.IsNullOrEmpty(tempProjectDir))
{
Action <int> updateMessageProgress = (int p) => {
progressLogAction?.Invoke($"Preparing: [{p}%]");
};
await Helper.UploadDirectoryAsync(proj, tempProjectDir, updateMessageProgress, cancellationToken);
}
// suspended by user
var emptyID = Guid.Empty;
if (cancellationToken.IsCancellationRequested)
{
progressLogAction?.Invoke($"Canceled: {cancellationToken.IsCancellationRequested}");
Helper.Logger.Information($"ScheduleRunAsync: canceled by user");
return(null);
}
// update Artifact to cloud's relative path after uploaded.
var newJob = UpdateArtifactPath(job, this.JobInfo.SubFolderPath);
//var json = newJob.ToJson();
// create a new Simulation
var api = new JobsApi();
progressLogAction?.Invoke($"Start running.");
Helper.Logger.Information($"ScheduleRunAsync: Start running.");
try
{
// schedule a simulation on Pollination.Cloud
var jobForLog = newJob.DuplicateJob();
jobForLog.Arguments = jobForLog.Arguments.Take(3).ToList();
Helper.Logger.Information($"ScheduleRunAsync: Scheduling a job in {proj.Owner.Name}/{proj.Name}");
Helper.Logger.Information($"ONLY PRINTING OUT THE FIRST THREE ARGUMENTS \n{jobForLog.ToJson()}");
var runJob = await api.CreateJobAsync(proj.Owner.Name, proj.Name, newJob);
Helper.Logger.Information($"ScheduleRunAsync: Job scheduled\n{runJob.ToJson()}");
progressLogAction?.Invoke($"Start running..");
// give server a moment to start the simulation after it's scheduled.
await Task.Delay(500);
// monitoring the running simulation
progressLogAction?.Invoke($"Start running...");
// suspended by user
if (cancellationToken.IsCancellationRequested)
{
Helper.Logger.Information($"ScheduleRunAsync: canceled by user");
progressLogAction?.Invoke($"Canceled: {cancellationToken.IsCancellationRequested}");
return(null);
}
var cloudJob = await api.GetJobAsync(proj.Owner.Name, proj.Name, runJob.Id.ToString());
actionWhenDone?.Invoke();
return(cloudJob);
}
catch (Exception ex)
{
//Eto.Forms.MessageBox.Show(e.Message, Eto.Forms.MessageBoxType.Error);
Helper.Logger.Error(ex, $"ScheduleRunAsync: failed to run.");
throw ex;
}
}
