public ActionResult DeleteConfirmed(int id)
{
SubmissionLog submissionLog = db.SubmissionLogs.Find(id);
db.SubmissionLogs.Remove(submissionLog);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "ID,OpponentName,Position,WinLoss,DateOfEvent,StudentID")] SubmissionLog submissionLog)
{
if (ModelState.IsValid)
{
db.Entry(submissionLog).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(submissionLog));
}
public ActionResult Create([Bind(Include = "ID,OpponentName,Position,WinLoss,DateOfEvent,StudentID")] SubmissionLog submissionLog)
{
if (ModelState.IsValid)
{
db.SubmissionLogs.Add(submissionLog);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(submissionLog));
}
// GET: SubmissionLog/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SubmissionLog submissionLog = db.SubmissionLogs.Find(id);
if (submissionLog == null)
{
return(HttpNotFound());
}
return(View(submissionLog));
}
public bool SendSubmissionLog(SubmissionLog log)
{
string endpoint = buildEndpoint("submissions", log.SubmissionId, "logs");
var responseMessage = client.PostAsync(endpoint, log.AsJson()).Result;
logger.Debug("{1} log for submission {0} send {2}", log.SubmissionId,
log.Type.ToString(), responseMessage.StatusCode == HttpStatusCode.NoContent ?
"successfully" : "failed");
if (responseMessage.StatusCode != HttpStatusCode.NoContent)
{
logger.Error("Sending submission log failed. Server error message: {0}",
responseMessage.Content?.ReadAsStringAsync()?.Result);
}
return(responseMessage.StatusCode == HttpStatusCode.NoContent);
}
public async Task <IActionResult> LoadResponse(ResponseViewModel model)
{
model.SelectedFiles = Directory.EnumerateFiles(model.FilePath).Select(x => Path.GetFileName(x)).ToList();
foreach (string fileName in model.SelectedFiles)
{
if (fileName.ToUpper().Contains("PCPA"))
{
ResponseFile pcpaResponseFile = new ResponseFile();
pcpaResponseFile.responseHierarchy = new List <ResponseHierarchy>();
pcpaResponseFile.responseHierarchy.Add(new ResponseHierarchy {
levelIdentifier = "File", sectionIdentifier = null, responses = new List <ResponseDetail>(), children = new List <ResponseChildren>()
});
pcpaResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "Header", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
pcpaResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "PCPA", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
string ss2 = System.IO.File.ReadAllText(Path.Combine(model.FilePath, fileName));
pcpaResponseFile = JsonLib.JsonDeserialize.DeserializeReponseFile(ref ss2);
//check if it's test file or production file
SubmissionLog slog = _contextLog.SubmissionLogs.FirstOrDefault(x => x.FileName == pcpaResponseFile.fileName);
long pcpaPointer = 0;
PcpHeader header = null;
if (slog != null)
{
header = _contextHistory.PcpHeaders.FirstOrDefault(x => x.ReportingPeriod.Substring(0, 6) == slog.RecordYear + slog.RecordMonth);
pcpaPointer = _contextHistory.PcpAssignments.Where(x => x.PcpHeaderId == header.PcpHeaderId).Min(x => x.PcpAssignmentId);
}
McpdipHeader rHeader = new McpdipHeader
{
FileName = pcpaResponseFile.fileName,
FileType = pcpaResponseFile.fileType,
SubmitterName = pcpaResponseFile.submitterName,
SubmissionDate = pcpaResponseFile.submissionDate,
ValidationStatus = pcpaResponseFile.validationStatus,
Levels = pcpaResponseFile.levels,
SchemaVersion = pcpaResponseFile.schemaVersion
};
if (slog != null)
{
rHeader.RecordYear = slog.RecordYear;
rHeader.RecordMonth = slog.RecordMonth;
}
else
{
rHeader.RecordYear = _contextStaging.McpdHeaders.First().ReportingPeriod.Substring(0, 4);
rHeader.RecordMonth = _contextStaging.McpdHeaders.First().ReportingPeriod.Substring(4, 2);
}
_context.McpdipHeaders.Add(rHeader);
await _context.SaveChangesAsync();
McpdipHierarchy hierarchy = new McpdipHierarchy
{
HeaderId = rHeader.HeaderId,
LevelIdentifier = pcpaResponseFile.responseHierarchy[0].levelIdentifier,
SectionIdentifier = pcpaResponseFile.responseHierarchy[0].sectionIdentifier
};
_context.McpdipHierarchies.Add(hierarchy);
await _context.SaveChangesAsync();
if (pcpaResponseFile.responseHierarchy[0].responses.Count > 0)
{
foreach (var response in pcpaResponseFile.responseHierarchy[0].responses)
{
McpdipDetail detail = new McpdipDetail
{
ResponseTarget = "PcpaFile",
ChildrenId = hierarchy.HierarchyId,
ItemReference = response.itemReference,
Id = response.id,
Description = response.description,
Severity = response.severity
};
}
}
foreach (var child in pcpaResponseFile.responseHierarchy[0].children)
{
McpdipChildren rChild = new McpdipChildren
{
HierarchyId = hierarchy.HierarchyId,
LevelIdentifier = child.levelIdentifier == "Header" ? "PcpaHeader" : child.levelIdentifier,
SectionIDentifier = child.sectionIdentifier
};
_context.McpdipChildrens.Add(rChild);
await _context.SaveChangesAsync();
HashSet <int> LineNumbers = new HashSet <int>();
if (child.responses.Count > 0)
{
foreach (var response in child.responses)
{
McpdipDetail detail = new McpdipDetail
{
ResponseTarget = rChild.LevelIdentifier == "Header" ? "PcpaHeader" : rChild.LevelIdentifier,
ChildrenId = rChild.ChildrenId,
ItemReference = response.itemReference,
Id = response.id,
Description = response.description,
Severity = response.severity
};
if (rChild.LevelIdentifier != "Header" && slog != null)
{
detail.OriginalTable = "History.PcpAssignment";
int RecordNumber = -1;
if (!int.TryParse(response.itemReference.Split('[', ']')[1], out RecordNumber))
{
RecordNumber = -1;
}
detail.OriginalHeaderId = header.PcpHeaderId;
if (RecordNumber >= 0)
{
detail.OriginalId = pcpaPointer + RecordNumber;
PcpAssignment assignment = _contextHistory.PcpAssignments.Find(detail.OriginalId);
if (assignment != null)
{
detail.OriginalCin = assignment.Cin;
detail.OriginalItemId = assignment.Npi;
}
if (detail.Severity == "Error" && !LineNumbers.Contains(RecordNumber))
{
LineNumbers.Add(RecordNumber);
}
}
}
_context.McpdipDetails.Add(detail);
}
await _context.SaveChangesAsync();
if (slog != null)
{
slog.TotalPCPARejected = LineNumbers.Count();
slog.TotalPCPAAccepted = slog.TotalPCPASubmitted - slog.TotalPCPARejected;
slog.UpdateDate = DateTime.Now;
slog.UpdateBy = User.Identity.Name;
await _contextLog.SaveChangesAsync();
}
}
}
}
else if (fileName.ToUpper().Contains("MCPD"))
{
ResponseFile mcpdResponseFile = new ResponseFile();
mcpdResponseFile.responseHierarchy = new List <ResponseHierarchy>();
mcpdResponseFile.responseHierarchy.Add(new ResponseHierarchy {
levelIdentifier = "File", sectionIdentifier = null, responses = new List <ResponseDetail>(), children = new List <ResponseChildren>()
});
mcpdResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "Header", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
mcpdResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "Grievances", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
mcpdResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "Appeals", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
mcpdResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "ContinuityOfCare", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
mcpdResponseFile.responseHierarchy[0].children.Add(new ResponseChildren {
levelIdentifier = "OutOfNetwork", sectionIdentifier = null, responses = new List <ResponseDetail>()
});
string ss2 = System.IO.File.ReadAllText(Path.Combine(model.FilePath, fileName));
mcpdResponseFile = JsonLib.JsonDeserialize.DeserializeReponseFile(ref ss2);
//check if it's test file or production file
SubmissionLog slog = _contextLog.SubmissionLogs.FirstOrDefault(x => x.FileName == mcpdResponseFile.fileName);
long grievancePointer = 0, appealPointer = 0, cocPointer = 0, oonPointer = 0;
McpdHeader header = null;
if (slog != null)
{
header = _contextHistory.McpdHeaders.FirstOrDefault(x => x.ReportingPeriod.Substring(0, 6) == slog.RecordYear + slog.RecordMonth);
grievancePointer = _contextHistory.Grievances.Where(x => x.McpdHeaderId == header.McpdHeaderId).Min(x => x.McpdGrievanceId);
appealPointer = _contextHistory.Appeals.Where(x => x.McpdHeaderId == header.McpdHeaderId).Min(x => x.McpdAppealId);
cocPointer = _contextHistory.McpdContinuityOfCare.Where(x => x.McpdHeaderId == header.McpdHeaderId).Min(x => x.McpdContinuityOfCareId);
oonPointer = _contextHistory.McpdOutOfNetwork.Where(x => x.McpdHeaderId == header.McpdHeaderId).Min(x => x.McpdOutOfNetworkId);
}
McpdipHeader rHeader = new McpdipHeader
{
FileName = mcpdResponseFile.fileName,
FileType = mcpdResponseFile.fileType,
SubmitterName = mcpdResponseFile.submitterName,
SubmissionDate = mcpdResponseFile.submissionDate,
ValidationStatus = mcpdResponseFile.validationStatus,
Levels = mcpdResponseFile.levels,
SchemaVersion = mcpdResponseFile.schemaVersion
};
if (slog != null)
{
rHeader.RecordYear = slog.RecordYear;
rHeader.RecordMonth = slog.RecordMonth;
}
else
{
rHeader.RecordYear = _contextStaging.McpdHeaders.First().ReportingPeriod.Substring(0, 4);
rHeader.RecordMonth = _contextStaging.McpdHeaders.First().ReportingPeriod.Substring(4, 2);
}
_context.McpdipHeaders.Add(rHeader);
await _context.SaveChangesAsync();
McpdipHierarchy hierarchy = new McpdipHierarchy
{
HeaderId = rHeader.HeaderId,
LevelIdentifier = mcpdResponseFile.responseHierarchy[0].levelIdentifier,
SectionIdentifier = mcpdResponseFile.responseHierarchy[0].sectionIdentifier
};
_context.McpdipHierarchies.Add(hierarchy);
await _context.SaveChangesAsync();
if (mcpdResponseFile.responseHierarchy[0].responses.Count > 0)
{
foreach (var response in mcpdResponseFile.responseHierarchy[0].responses)
{
McpdipDetail detail = new McpdipDetail
{
ResponseTarget = "McpdFile",
ChildrenId = hierarchy.HierarchyId,
ItemReference = response.itemReference,
Id = response.id,
Description = response.description,
Severity = response.severity
};
}
}
HashSet <int> LineNumberG = new HashSet <int>();
HashSet <int> LineNumberA = new HashSet <int>();
HashSet <int> LineNumberC = new HashSet <int>();
HashSet <int> LineNumberO = new HashSet <int>();
foreach (var child in mcpdResponseFile.responseHierarchy[0].children)
{
McpdipChildren rChild = new McpdipChildren
{
HierarchyId = hierarchy.HierarchyId,
LevelIdentifier = child.levelIdentifier == "Header" ? "McpdHeader" : child.levelIdentifier,
SectionIDentifier = child.sectionIdentifier
};
_context.McpdipChildrens.Add(rChild);
await _context.SaveChangesAsync();
if (child.responses.Count > 0)
{
foreach (var response in child.responses)
{
McpdipDetail detail = new McpdipDetail
{
ResponseTarget = rChild.LevelIdentifier == "Header" ? "McpdHeader" : rChild.LevelIdentifier,
ChildrenId = rChild.ChildrenId,
ItemReference = response.itemReference,
Id = response.id,
Description = response.description,
Severity = response.severity
};
if (rChild.LevelIdentifier != "Header" && slog != null)
{
int RecordNumber = -1;
if (!int.TryParse(response.itemReference.Split('[', ']')[1], out RecordNumber))
{
RecordNumber = -1;
}
detail.OriginalHeaderId = header.McpdHeaderId;
switch (rChild.LevelIdentifier)
{
case "Grievances":
detail.OriginalTable = "History.McpdGrievance";
if (RecordNumber >= 0)
{
detail.OriginalId = grievancePointer + RecordNumber;
McpdGrievance grievance = _contextHistory.Grievances.Find(detail.OriginalId);
if (grievance != null)
{
detail.OriginalCin = grievance.Cin;
detail.OriginalItemId = grievance.GrievanceId;
}
if (detail.Severity == "Error" && !LineNumberG.Contains(RecordNumber))
{
LineNumberG.Add(RecordNumber);
}
}
break;
case "Appeals":
detail.OriginalTable = "History.McpdAppeal";
if (RecordNumber >= 0)
{
detail.OriginalId = appealPointer + RecordNumber;
McpdAppeal appeal = _contextHistory.Appeals.Find(detail.OriginalId);
if (appeal != null)
{
detail.OriginalCin = appeal.Cin;
detail.OriginalItemId = appeal.AppealId;
}
if (detail.Severity == "Error" && !LineNumberA.Contains(RecordNumber))
{
LineNumberA.Add(RecordNumber);
}
}
break;
case "ContinuityOfCare":
detail.OriginalTable = "History.McpdContinuityOfCare";
if (RecordNumber >= 0)
{
detail.OriginalId = cocPointer + RecordNumber;
McpdContinuityOfCare coc = _contextHistory.McpdContinuityOfCare.Find(detail.OriginalId);
if (coc != null)
{
detail.OriginalCin = coc.Cin;
detail.OriginalItemId = coc.CocId;
}
if (detail.Severity == "Error" && !LineNumberC.Contains(RecordNumber))
{
LineNumberC.Add(RecordNumber);
}
}
break;
case "OutOfNetwork":
detail.OriginalTable = "History.McpdOutOfNetwork";
if (RecordNumber >= 0)
{
detail.OriginalId = oonPointer + RecordNumber;
McpdOutOfNetwork oon = _contextHistory.McpdOutOfNetwork.Find(detail.OriginalId);
if (oon != null)
{
detail.OriginalCin = oon.Cin;
detail.OriginalItemId = oon.OonId;
}
if (detail.Severity == "Error" && !LineNumberO.Contains(RecordNumber))
{
LineNumberO.Add(RecordNumber);
}
}
break;
}
}
_context.McpdipDetails.Add(detail);
}
await _context.SaveChangesAsync();
if (slog != null)
{
slog.TotalGrievanceRejected = LineNumberG.Count();
slog.TotalGrievanceAccepted = slog.TotalGrievanceSubmitted - slog.TotalGrievanceRejected;
slog.TotalAppealRejected = LineNumberA.Count();
slog.TotalAppealAccepted = slog.TotalAppealSubmitted - slog.TotalAppealRejected;
slog.TotalCOCRejected = LineNumberC.Count();
slog.TotalCOCAccepted = slog.TotalCOCSubmitted - slog.TotalCOCRejected;
slog.TotalOONRejected = LineNumberO.Count();
slog.TotalOONAccepted = slog.TotalOONSubmitted - slog.TotalOONRejected;
slog.UpdateDate = DateTime.Now;
slog.UpdateBy = User.Identity.Name;
await _contextLog.SaveChangesAsync();
}
}
}
}
System.IO.File.Move(Path.Combine(model.FilePath, fileName), Path.Combine(model.ArchivePath, fileName));
}
model.Message = "Load Response files successful";
return(View(model));
}
public WorkerResult Testing(Submission submission, Problem problem, ProblemFile solution)
{
string workdir = new DirectoryInfo(Path.Combine(Application.Get().Configuration.TestingWorkDirectory, Guid.NewGuid().ToString())).FullName;
Directory.CreateDirectory(workdir);
logger.Info("Slot {0} starting testing at {1}", slotNum, workdir);
Compiler checkerCompiler = Application.Get().Compilers.GetCompiler(problem.CheckerCompilerId);
Compiler solutionCompiler = Application.Get().Compilers.GetCompiler(submission.CompilerId);
string inputFileFullPath = Path.Combine(workdir, Application.Get().Configuration.InputFileName);
string outputFileFullPath = Path.Combine(workdir, Application.Get().Configuration.OutputFileName);
string answerFileFullPath = Path.Combine(workdir, Application.Get().Configuration.AnswerFileName);
string reportFileFullPath = Path.Combine(workdir, Application.Get().Configuration.ReportFileName);
string compilerLogFileFullPath = Path.Combine(workdir, Application.Get().Configuration.CompilerLogFileName);
if (!compileChecker(workdir, problem.Checker, checkerCompiler))
{
SubmissionLog log = new SubmissionLog();
log.SubmissionId = submission.Id;
log.Type = SubmissionLogType.Checker;
log.Data = File.ReadAllText(compilerLogFileFullPath);
Application.Get().RequestMessages.Enqueue(apiClient.GetSendLogRequestMessage(log));
return(WorkerResult.TestingError);
}
{
bool st = compileSolution(workdir, solution, solutionCompiler);
SubmissionLog log = new SubmissionLog();
log.SubmissionId = submission.Id;
log.Type = SubmissionLogType.Source;
log.Data = File.ReadAllText(compilerLogFileFullPath);
if (!string.IsNullOrWhiteSpace(log.Data))
{
Application.Get().RequestMessages.Enqueue(apiClient.GetSendLogRequestMessage(log));
}
if (!st)
{
return(WorkerResult.CompilerError);
}
}
for (uint i = 0; i < problem.Tests.Length; i++)
{
logger.Info("Slot {0}: Starting testing test with num {1}", slotNum, problem.Tests[i].Num);
logger.Info("Slot {0}: Preparion solution start enviroment", slotNum);
logger.Debug("Slot {0}: Copy input file.", slotNum);
Application.Get().FileProvider.Copy(problem.Tests[i].Input, inputFileFullPath);
TestResult testResult = new TestResult();
testResult.SubmissionId = submission.Id;
testResult.TestId = problem.Tests[i].Id;
{
Tester tester = new Tester();
var replacement = GenerateReplacementDictionary(
binaryFullPath: Path.Combine(workdir, solutionBinaryFilename),
binaryFilename: solutionBinaryFilename,
workDirecrory: workdir);
string program = solutionCompiler.RunCommand.Program.ReplaceByDictionary(re, replacement);
string args = solutionCompiler.RunCommand.Arguments.ReplaceByDictionary(re, replacement);
tester.SetProgram(program, $"\"{program}\" {args}");
tester.SetWorkDirectory(workdir);
tester.SetRealTimeLimit(submission.RealTimeLimit);
tester.SetMemoryLimit(submission.MemoryLimit);
tester.RedirectIOHandleToFile(IOHandleType.Input, inputFileFullPath);
tester.RedirectIOHandleToFile(IOHandleType.Output, outputFileFullPath);
tester.RedirectIOHandleToHandle(IOHandleType.Error, tester.GetIORedirectedHandle(IOHandleType.Output));
logger.Info("Slot {0}: Run solution", slotNum);
if (tester.Run(true))
{
logger.Info("Slot {0}: Solution run successfully", slotNum);
}
else
{
logger.Error("Slot {0}: Can't run solution", slotNum);
return(WorkerResult.TestingError);
}
var waitStatus = tester.Wait();
if (waitStatus == WaitingResult.Ok)
{
logger.Debug("Slot {0}: Waited successfully", slotNum);
}
else if (waitStatus == WaitingResult.Timeout)
{
testResult.UsedMemmory = tester.GetUsedResources().PeakMemoryUsageKB;
testResult.WorkTime = tester.GetUsedResources().RealTimeUsageMS;
testResult.Result = TestingResult.TimeLimitExceeded;
Application.Get().RequestMessages.Enqueue(apiClient.GetSendTestingResultRequestMessage(testResult));
logger.Info("Slot {0}: Wait timeouted", slotNum);
//Not start checker
tester.Destroy();
continue;
}
else
{
logger.Error("Slot {0}: Wait failed", slotNum);
return(WorkerResult.TestingError);
}
uint exitCode = tester.GetExitCode();
if (exitCode == 0)
{
logger.Info("Slot {0}: Solution exited successfully", slotNum);
}
else
{
testResult.UsedMemmory = tester.GetUsedResources().PeakMemoryUsageKB;
testResult.WorkTime = tester.GetUsedResources().CPUWorkTimeMS;
testResult.Result = TestingResult.RuntimeError;
Application.Get().RequestMessages.Enqueue(apiClient.GetSendTestingResultRequestMessage(testResult));
logger.Info("Slot {0}: Solution exit with code {1}", slotNum, exitCode);
//Not start checker
tester.Destroy();
continue;
}
testResult.UsedMemmory = tester.GetUsedResources().PeakMemoryUsageKB;
testResult.WorkTime = tester.GetUsedResources().CPUWorkTimeMS;
tester.Destroy();
}
if (testResult.WorkTime > submission.TimeLimit)
{
testResult.Result = TestingResult.TimeLimitExceeded;
Application.Get().RequestMessages.Enqueue(apiClient.GetSendTestingResultRequestMessage(testResult));
logger.Info("Slot {0}: Solution work {1}ms and time limit {2}ms",
slotNum, testResult.WorkTime, submission.TimeLimit);
//Not start checker
continue;
}
if (testResult.UsedMemmory > submission.MemoryLimit)
{
testResult.Result = TestingResult.MemoryLimitExceeded;
Application.Get().RequestMessages.Enqueue(apiClient.GetSendTestingResultRequestMessage(testResult));
logger.Info("Slot {0}: Solution used {1}kb memory and memory limit {2}kb",
slotNum, testResult.UsedMemmory, submission.MemoryLimit);
//Not start checker
continue;
}
logger.Info("Slot {0}: Preparion checker start enviroment", slotNum);
logger.Info("Slot {0}: Copy answer file.", slotNum);
Application.Get().FileProvider.Copy(problem.Tests[i].Answer, answerFileFullPath);
{
Tester tester = new Tester();
var replacement = GenerateReplacementDictionary(
binaryFullPath: Path.Combine(workdir, checkerBinaryFilename),
binaryFilename: checkerBinaryFilename,
workDirecrory: workdir,
inputFilePath: inputFileFullPath,
outputFilePath: outputFileFullPath,
answerFilePath: answerFileFullPath,
reportFilePath: reportFileFullPath);
string program = checkerCompiler.RunCommand.Program.ReplaceByDictionary(re, replacement);
string args = $"{checkerCompiler.RunCommand.Arguments} {checkerCompiler.RunCommand.CheckerArguments}".
ReplaceByDictionary(re, replacement);
tester.SetProgram(program, $"\"{program}\" {args}");
tester.SetWorkDirectory(workdir);
tester.SetRealTimeLimit(60 * 1000);
//tester.RedirectIOHandleToFile(IOHandleType.Output, reportFileFullPath);
//tester.RedirectIOHandleToHandle(IOHandleType.Error, tester.GetIORedirectedHandle(IOHandleType.Output));
logger.Info("Slot {0}: Run checker", slotNum);
if (tester.Run())
{
logger.Info("Slot {0}: Checker run successfully", slotNum);
}
else
{
logger.Error("Slot {0}: Can't run checker", slotNum);
return(WorkerResult.TestingError);
}
if (tester.Wait() == WaitingResult.Ok)
{
logger.Debug("Slot {0}: Waited successfully", slotNum);
}
else
{
logger.Error("Slot {0}: Wait failed", slotNum);
return(WorkerResult.TestingError);
}
uint exitCode = tester.GetExitCode();
logger.Info("Slot {0}: Checker exit with code {1}", slotNum, exitCode);
testResult.Result = (TestingResult)exitCode;
testResult.Log = File.ReadAllText(reportFileFullPath);
Application.Get().RequestMessages.Enqueue(apiClient.GetSendTestingResultRequestMessage(testResult));
tester.Destroy();
}
}
try
{
Directory.Delete(workdir, true);
}
catch (Exception ex)
{
logger.Error(ex, "Slot {0}: Can not delete work directory.", slotNum);
}
return(WorkerResult.Ok);
}
public RequestMessage GetSendLogRequestMessage(SubmissionLog log) =>
new RequestMessage(buildEndpoint("submissions", log.SubmissionId, "logs"), log.AsJson());
