/// <summary>
/// 从Response中解析JudgeTask
/// </summary>
/// <param name="jsonStr"></param>
/// <returns></returns>
private JudgeContext[] ParseTask(string jsonStr)
{
JArray jArray = JArray.Parse(jsonStr);
if (jArray.Count == 0)
{
return(new JudgeContext[0]);
}
JObject jObject = jArray[0] as JObject;
if (!CheckTaskJObject(jObject))
{
return(new JudgeContext[0]);
}
SDNUOJTaskEntity taskEntity = jObject.ToObject <SDNUOJTaskEntity>();
JudgeContext task = JudgeContextFactory.Create(
int.Parse(taskEntity.SubmitId), int.Parse(taskEntity.ProblemId), taskEntity.DataVersion,
taskEntity.Language.Substring(0, taskEntity.Language.Length - 2), taskEntity.SourceCode,
taskEntity.Author, int.Parse(taskEntity.TimeLimit), int.Parse(taskEntity.MemoryLimit),
false, false, bool.Parse(taskEntity.DbJudge));
return(new[] { task });
}
/// <summary>
/// 寻找评测目录下的SPJ程序
/// </summary>
/// <param name="context">评测上下文</param>
/// <returns>SPJ程序路径</returns>
public static string FindSpjProgramInJudger(JudgeContext context)
{
string compileDirectory = GetSpjDirectoryInJudger(context);
string[] files = Directory.GetFiles(compileDirectory);
if (files.Length > 2)
{
LogManager.Warning("Can not confirm the unique special judge program!");
}
string spjProgramPath = null;
foreach (string file in files)
{
if (Path.GetFileName(file) == (context.LangConfig as ProgramLangConfig).SourceCodeFileName)
{
continue;
}
spjProgramPath = file;
}
return(PathHelper.GetBaseAbsolutePath(spjProgramPath));
}
/// <summary>
/// 取回测试数据
/// 当Judger获得新任务，且本地不存在测试数据或数据过期时，会自动调用此方法拉取测试数据
/// 测试数据应当打包在zip文件中并以二进制保存
/// </summary>
/// <param name="context">评测任务</param>
/// <returns>测试数据</returns>
public override byte[] Fetch(JudgeContext context)
{
string url = Config.TestDataFetchUrl;
string requestBody = CreateRequestBody(context.Task.ProblemId);
return(HttpClient.UploadData(url, requestBody, 3));
}
private void Judge(JudgeContext context)
{
JudgeTask task = context.Task;
ITaskSubmitter submitter = AdapterFactory.CreateTaskSubmitter();
try
{
UpdateTestData(context);
using (BaseJudger judger = JudgerFactory.Create(context))
{
LogStartJudgeTask(task.SubmitId);
judger.Judge();
}
}
catch (ExpectedJudgeStopException)
{ }
catch (Exception ex) // 判题失败
{
context.Result = CreateFailedJudgeResult(context, ex.ToString());
throw;
}
finally
{
LogJudgeResult(context.Result);
submitter.Submit(context);
}
}
public SingleCaseJudger(JudgeContext context, BaseDbOperator dbOperator)
{
JudgeContext = context;
JudgeTask = context.Task;
UserOperator = dbOperator;
_caseSensitive = (context.LangConfig as DbLangConfig).CaseSensitive;
}
/// <summary>
/// 获取评测目录下的SPJ程序路径
/// </summary>
/// <param name="context">评测上下文</param>
/// <returns>SPJ程序路径</returns>
public static string GetSpjProgramPathInJudger(JudgeContext context)
{
string spjDirectory = GetSpjDirectoryInJudger(context);
string path = Path.Combine(spjDirectory, (context.LangConfig as ProgramLangConfig).ProgramFileName);
return(PathHelper.GetBaseAbsolutePath(path));
}
public SpecialSingleCaseJudger(JudgeContext judgeContext, JudgeContext spjContext) : base(judgeContext)
{
SpjJudgeContext = spjContext;
SpjTask = spjContext.Task;
SpjLangConfig = spjContext.LangConfig as ProgramLangConfig;
SpjLangConfig = spjContext.LangConfig as ProgramLangConfig;
}
private void LogAddTask(JudgeContext context)
{
JudgeTask task = context.Task;
LogManager.Info(
$"New task: SubmitID:{task.SubmitId} Language:{task.Language} " +
$"CodeLength:{task.SourceCode.Length} ProblemID:{task.ProblemId} Author:{task.Author}");
}
public SpecialJudger(JudgeContext context) : base(context)
{
JudgeTask.ProcessorAffinity = ProcessorAffinityManager.GetUsage();
LangConfig = context.LangConfig as ProgramLangConfig;
SpjContext = SpjManager.CreateSpjJudgeContext(context);
SpjTask = SpjContext.Task;
SpjLangConfig = SpjContext.LangConfig as ProgramLangConfig;
}
private void LogAddTask(JudgeContext context)
{
JudgeTask task = context.Task;
LogManager.Info(string.Format(
"New task: SubmitID:{0} Language:{1} CodeLength:{2} ProblemID:{3} Author:{4}",
task.SubmitId, task.Language, task.SourceCode.Length, task.ProblemId, task.Author));
}
public DbJudger(JudgeContext context) : base(context)
{
MainOperator = DbOperatorFactory.CreateMainOperatorByName(context.Task.Language);
_dbName = Path.GetFileName(context.TempDirectory).ToLower() + "db";
_dbUser = Path.GetFileName(context.TempDirectory).ToLower() + "user";
_dbPassword = Path.GetFileName(context.TempDirectory).ToLower() + "pwd";
_dbType = DbManager.GetDatabaseType(context.Task.Language);
}
public static BaseJudger Create(JudgeContext context)
{
return(context.Task.JudgeType switch
{
JudgeType.ProgramJudge => new ProgramJudger(context),
JudgeType.SpecialJudge => new SpecialProgramJudger(context),
JudgeType.DbJudge => new DbJudger(context),
_ => throw new JudgeException("Unknown JudgeType!")
});
/// <summary>
/// 获取评测目录下的SPJ目录
/// </summary>
/// <param name="context">评测上下文</param>
/// <returns>SPJ目录</returns>
public static string GetSpjDirectoryInJudger(JudgeContext context)
{
if (context.TempDirectory.EndsWith(SPJ_DIRECTORY))
{
return(context.TempDirectory);
}
return(Path.Combine(context.TempDirectory, SPJ_DIRECTORY));
}
/// <summary>
/// 提交评测任务
/// </summary>
/// <param name="context">评测任务</param>
/// <returns>提交是否成功</returns>
public override bool Submit(JudgeContext context)
{
string responseStr = HttpClient.UploadString(Config.ResultSubmitUrl, CreateRequestBody(context.Result), 3);
ServerResponse response = SampleJsonSerializer.DeSerialize <ServerResponse>(responseStr);
if (response.Code == ResponseCode.Fail || response.Code == ResponseCode.WrongToken)
{
throw new FetcherException(context.Result.SubmitId + " submit failed: " + response.Message);
}
return(true);
}
public override void Submit(JudgeContext context)
{
string requestBody = CreateRequestBody(context.Result);
string jsonResp = HttpClient.UploadString(Config.ResultSubmitUrl, requestBody, 3);
ServerResponse response = Json.DeSerialize <ServerResponse>(jsonResp);
if (response.Code == ResponseCode.Fail || response.Code == ResponseCode.WrongToken)
{
throw new AdapterException(context.Result.SubmitId + " submit failed: " + response.Message);
}
}
/// <summary>
/// 创建Judger实例
/// </summary>
/// <param name="context">JudgeContext</param>
/// <returns>Judger实例</returns>
public static BaseJudger Create(JudgeContext context)
{
switch (context.Task.JudgeType)
{
case JudgeType.ProgramJudge: return(new ProgramJudger(context));
case JudgeType.SpecialJudge: return(new SpecialJudger(context));
case JudgeType.DbJudge: return(new DbJudger(context));
default: throw new JudgeException("Unknown JudgeType!");
}
}
private JudgeResult CreateFailedJudgeResult(JudgeContext context, string message = "")
{
return(new JudgeResult
{
Author = context.Task.Author,
JudgeDetail = message,
MemoryCost = 0,
TimeCost = 0,
PassRate = 0,
ProblemId = context.Task.ProblemId,
SubmitId = context.Task.SubmitId,
ResultCode = JudgeResultCode.JudgeFailed
});
}
private JudgeContext CreateJudgeContext(string submitId)
{
GetSolutionInfo(submitId, out string problemId, out string author, out string lang);
GetProblemInfo(problemId, out int timeLimit, out int memoryLimit, out bool spj);
string sourceCode = GetSolutionSourceCode(submitId);
string dataMd5 = GetTestDataMd5(problemId);
JudgeContext context = JudgeContextFactory.Create(
submitId, problemId, dataMd5, lang, sourceCode,
author, timeLimit, memoryLimit, false, spj);
UpdateSolution(submitId, 3, 0, 0, 0.0);
return(context);
}
private void UpdateTestData(JudgeContext context)
{
JudgeTask task = context.Task;
// 检查本地测试数据是否为最新
if (!TestDataManager.CheckDataVersion(task.ProblemId, task.DataVersion))
{
LogInvalidTestData(task.ProblemId);
ITestDataFetcher fetcher = AdapterFactory.CreateTestDataFetcher();
TestDataManager.WriteTestData(task.ProblemId, fetcher.Fetch(context));
LogTestDataFetched(task.ProblemId);
}
}
public override object VisitJudge([NotNull] JudgeContext context)
{
if (context.op.Text == "~=")
{
return("!=");
}
else if (context.op.Text == "&")
{
return("&&");
}
else if (context.op.Text == "|")
{
return("||");
}
return(context.op.Text);
}
/// <summary>
/// 根据SubmitID获取JudgeTask
/// </summary>
private JudgeContext GetJudgeTask(string submitId)
{
GetSolutionInfo(submitId, out string problemId, out string author, out string lang);
string sourceCode = GetSolution(submitId);
GetProblemInfo(problemId, out int timeLimit, out int memoryLimit, out bool spj);
string dateMd5 = GetTestDataMd5(problemId);
JudgeContext task = JudgeContextFactory.Create(
submitId, problemId, dateMd5, lang, sourceCode,
author, timeLimit, memoryLimit, false, spj);
Authenticator.Instance.UpdateSolution(submitId, 3, 0, 0, 0.0);
return(task);
}
/// <summary>
/// 开始评测JudgeTask
/// </summary>
/// <param name="judgeTaskObject">JudgeTask对象</param>
private void RunJudgeTask(object judgeTaskObject)
{
JudgeContext context = judgeTaskObject as JudgeContext;
try
{
Judge(context);
}
catch (Exception ex)
{
LogException(ex);
}
lock (_queueLock)
RunningCount--;
//重新检查是否有任务
CheckTask();
}
private void RunJudgeTask(object contextObject)
{
JudgeContext context = contextObject as JudgeContext;
try
{
Judge(context);
}
catch (Exception ex)
{
LogException(ex);
}
lock (_checkRunLock)
{
RunningCount--;
}
//重新检查是否有任务
CheckRunTask();
}
/// <summary>
/// 创建SPJ的JudgeContext, 用于编译运行SPJ程序
/// </summary>
/// <param name="originContext">源评测任务</param>
/// <returns>SPJ的JudgeTask</returns>
public static JudgeContext CreateSpjJudgeContext(JudgeContext originContext)
{
JudgeContext newContext = originContext.Clone() as JudgeContext;
string spjSourceFilePath = FindSpjSourceFileInTestData(newContext.Task.ProblemId);
if (spjSourceFilePath == null) //没有SPJ程序源代码, 无法评测
{
throw new JudgeException("No special judge program exception!");
}
newContext.Task.SourceCode = File.ReadAllText(spjSourceFilePath);
newContext.LangConfig = GetLangConfigBySourceFilePath(spjSourceFilePath);
ProgramLangConfig langConfig = newContext.LangConfig as ProgramLangConfig;
newContext.Task.Language = newContext.LangConfig.Name;
string spjDir = GetSpjDirectoryInJudger(originContext) + "\\";
string appDir = PathHelper.GetBaseAbsolutePath("");
// 替换<tempdir>和<appdir>字段
langConfig.CompilerPath = langConfig.CompilerPath.Replace("<tempdir>", spjDir).Replace("<appdir>", appDir);
langConfig.CompilerWorkDirectory = langConfig.CompilerWorkDirectory.Replace("<tempdir>", spjDir)
.Replace("<appdir>", appDir);
langConfig.CompilerArgs = langConfig.CompilerArgs.Replace("<tempdir>", spjDir).Replace("<appdir>", appDir);
langConfig.RunnerPath = langConfig.RunnerPath.Replace("<tempdir>", spjDir).Replace("<appdir>", appDir);
langConfig.RunnerWorkDirectory = langConfig.RunnerWorkDirectory.Replace("<tempdir>", spjDir)
.Replace("<appdir>", appDir);
langConfig.RunnerArgs = langConfig.RunnerArgs.Replace("<tempdir>", spjDir).Replace("<appdir>", appDir);
newContext.TempDirectory = spjDir;
if (!Directory.Exists(spjDir))
{
Directory.CreateDirectory(spjDir);
}
return(newContext);
}
/// <summary>
/// 从Response中解析Task
/// </summary>
/// <param name="data">来自服务器的JObject任务数组</param>
/// <returns>JudgeContexts</returns>
private JudgeContext[] CreateTaskContexts(JToken data)
{
InnerJudgeTask[] innerJudgeTasks = data.ToObject <InnerJudgeTask[]>();
if (innerJudgeTasks == null || innerJudgeTasks.Length == 0)
{
return(new JudgeContext[0]);
}
List <JudgeContext> judgeTasks = new List <JudgeContext>();
foreach (var item in innerJudgeTasks)
{
JudgeContext task = JudgeContextFactory.Create(
item.SubmitId, item.ProblemId, item.DataVersion,
item.Language, item.SourceCode, item.Author,
item.TimeLimit, item.MemoryLimit,
item.JudgeAllCases, item.JudgeType);
judgeTasks.Add(task);
}
return(judgeTasks.ToArray());
}
private JudgeContext[] CreateJudgeContexts(string jsonResp)
{
JArray taskJArray = JArray.Parse(jsonResp);
if (taskJArray.Count == 0 || !(taskJArray[0] is JObject))
{
return(new JudgeContext[0]);
}
SdnuojJudgeTask task = taskJArray[0].ToObject <SdnuojJudgeTask>();
if (task == null)
{
return(new JudgeContext[0]);
}
JudgeContext context = JudgeContextFactory.Create(
task.SubmitId, task.ProblemId, task.DataVersion,
task.Language.Substring(0, task.Language.Length - 2), task.SourceCode,
task.Author, int.Parse(task.TimeLimit), int.Parse(task.MemoryLimit),
false, false, bool.Parse(task.DbJudge));
return(new[] { context });
}
public override byte[] Fetch(JudgeContext context)
{
return(Fetch(context.Task.ProblemId));
}
/// <summary>
/// 添加评测任务(上下文)
/// </summary>
/// 请使用Judger.Adapter.JudgeContextFactory创建评测上下文
public void AddTask(JudgeContext context)
{
LogAddTask(context);
_judgeQueue.Enqueue(context);
CheckRunTask();
}
public override bool Submit(JudgeContext context)
{
HttpClient.CookieContainer = Authenticator.Instance.CookieContainer;
HttpClient.UploadString(Config.ResultSubmitUrl, CreateResultBody(context.Result), 3);
return(true);
}
/// <summary>
/// 获取评测目录下的SPJ程序的源文件路径
/// </summary>
/// <param name="context">评测上下文</param>
/// <returns>SPJ源文件名</returns>
public static string GetSpjSourceFileInJudger(JudgeContext context)
{
return(Path.Combine(
GetSpjDirectoryInJudger(context),
(context.LangConfig as ProgramLangConfig).SourceCodeFileName));
}
