private RemoteSubmissionResult ExecuteSubmissionRemotely(
IOjsSubmission submission,
object submissionRequestBody)
{
RemoteSubmissionResult result;
try
{
result = this.http.PostJson <object, RemoteSubmissionResult>(this.endpoint, submissionRequestBody);
}
catch (Exception ex)
{
submission.ProcessingComment = $"Exception in getting remote submission result: {ex.Message}";
throw new Exception($"Exception in {nameof(this.ExecuteSubmissionRemotely)}", ex);
}
if (result.Exception == null)
{
return(result);
}
submission.ProcessingComment = $"Exception in executing the submission: {result.Exception.Message}";
throw new Exception(result.Exception.Message);
}
// Overload accepting IOjsSubmission and doing cast, because upon getting the submission,
// TInput is not known and no specific type could be given to the generic ProcessSubmission<>
private void ProcessSubmission(IOjsSubmission submission)
{
try
{
switch (submission.ExecutionType)
{
case ExecutionType.TestsExecution:
var testsSubmission = (OjsSubmission <TestsInputModel>)submission;
this.ProcessSubmission <TestsInputModel, TestResult>(testsSubmission);
break;
case ExecutionType.SimpleExecution:
var simpleSubmission = (OjsSubmission <string>)submission;
this.ProcessSubmission <string, OutputResult>(simpleSubmission);
break;
default:
throw new ArgumentOutOfRangeException(
nameof(submission.ExecutionType),
"Invalid execution type!");
}
}
catch (Exception ex)
{
this.logger.Error(
"{SubmissionProcessor}: The method {Method} has thrown an exception on submission {Submission}!",
this.Name,
nameof(this.ProcessSubmission),
ex);
this.submissionProcessingStrategy.OnError(submission);
}
}
private void BeforeExecute(IOjsSubmission submission)
{
try
{
this.submissionProcessingStrategy.BeforeExecute();
}
catch (Exception ex)
{
submission.ProcessingComment = $"Exception before executing the submission: {ex.Message}";
throw new Exception($"Exception in {nameof(this.submissionProcessingStrategy.BeforeExecute)}", ex);
}
}
private void ProcessExecutionResult <TOutput>(IExecutionResult <TOutput> executionResult, IOjsSubmission submission)
where TOutput : ISingleCodeRunResult, new()
{
try
{
this.submissionProcessingStrategy.ProcessExecutionResult(executionResult);
}
catch (Exception ex)
{
submission.ProcessingComment = $"Exception in processing execution result: {ex.Message}";
throw new Exception($"Exception in {nameof(this.ProcessExecutionResult)}", ex);
}
}
private bool IsEnabledStrategy(IOjsSubmission submission) => this.EnabledExecutionStrategyTypes.Count == 0 || this.EnabledExecutionStrategyTypes.Contains(submission.ExecutionStrategyType);
private bool IsDisabledStrategy(IOjsSubmission submission) => this.DisabledExecutionStrategyTypes.Count > 0 && this.DisabledExecutionStrategyTypes.Contains(submission.ExecutionStrategyType);
protected virtual bool CanProcessSubmissionInternal(IOjsSubmission submission, ISubmissionWorker submissionWorker) => true;
public bool CanProcessSubmission(IOjsSubmission submission, ISubmissionWorker submissionWorker) => submission != null && !this.IsDisabledStrategy(submission) && this.IsEnabledStrategy(submission) && this.CanProcessSubmissionInternal(submission, submissionWorker);
public abstract void OnError(IOjsSubmission submission);
public override void OnError(IOjsSubmission submissionModel)
{
this.submission.ProcessingComment = submissionModel.ProcessingComment;
this.UpdateResults();
}
protected override bool CanProcessSubmissionInternal(IOjsSubmission submission, ISubmissionWorker submissionWorker) => this.IsOnline(submissionWorker);
