Let's talk about how to refactor judger-core

[slhmy]

In order to perform the refactor better, I decide to plan these things more specifically so that we can divide the models and tasks more clearly.

[slhmy]

The core problem we need to solve in this topic is, how we describe the judge task.
What kind of workers are there, and how to make them run logically in the task.

[akamya997]

Afaic, we can just define the judge task as a simple work flow: Compiler-Runner.
Firstly, a Compiler is necessary for the code building. Then, a Runner is used to run the code as well as give out the score/result.
The most important thing is that how we split the Runner functionalities, it should be available for various kinds of problems and could run in different kind of sandbox environment.

[slhmy]

Afaic, we can just define the judge task as a simple work flow: Compiler-Runner.

Firstly, a Compiler is necessary for the code building. Then, a Runner is used to run the code as well as give out the score/result.

The most important thing is that how we split the Runner functionalities, it should be available for various kinds of problems and could run in different kind of sandbox environment.

For a complete composition of the above speeking as Runner, let's first consider the most composit situation.

An interactive judge need three threads running in the same time.

• first, a thread protecting the judged process. This thread avoid it's process do anything dangerous or illegal, and also collect run result like memory usage ETC. It's the common usage of Runner actually.
• second, a thread handling the custom interactive judge process. This is a more simple copy of runner (we can simply copy one if we do good enough)
• third, a broker thread for managing and recording all data flow between the two side, also being the last thread to quit it needs to tell whether the two side has already quit.

[akamya997]

So we can simply split them into two parts:

• A module which is used to run the code.
• A module which is used to control the data flow, we should define different control for interactive/regular problem.

By the way, a sandbox should be used here for system resource splitting.

[akamya997]

Now, I would like to raise a new problem.

Actually, there are different work flow for different kind of languages. For example, we do not need to compile for Python.
Which means that we should design a different runner for different languages. I am looking for an elegant way to implement this feature.

[akamya997]

Meanwhile, we should define different running method for different languages, like python a.py for Python, and ./w for a binary compiled file.

[slhmy]

We should define a Command struct for running (or compiling), then we only need to give preset setting in this kind of struct when we choose different languages.

[akamya997]

By the way, there still exist something that should be made clear.
For our monitor module, which is used to monitor the program running, I want to know whether the following process is ok.

1. Set up a sandbox with restricted resource.
2. Compile the program if needed.
3. Run both the checker and user program and control their data flow.
4. Monitor the program running.
5. Report the result of judging.

If this is ok, then it would be the main thread for our judge task. Otherwise, is there a better way to order these functionalities?

[slhmy]

I don't think compiling & judging should be included in Monitor, in my opinion Monitor should be an inside model of Runner.
Just do 1, 3, 4 should be fine.

[akamya997]

Thanks for all your help, now I have built a basic work flow for both traditional judge and interactive judge. I will describe current design here.
There are still many things to be completed now, if you have any advice or concern on it, please reply to me.

SandBox Implementation

In the sandbox.rs, a SandBox and a ProcessListener are designed to run and listen any program.

A SandBox describe the running process. stdio can be redirected by set_io here. Two spawn function spawn and spawn_with_io run the program. Here a better implementation is needed for exec different kind of program.

A ProcessListener simply wrap a SandBox with spawning a process to listen to the status of the sandbox. It is expected to report the end of sandbox process in report_exit.

Monitor Implementation

Here in monitor.rs, two kinds of judge flow is defined. Namely, run_judge and run_interact for traditional judge flow and interactive judge flow seperately.

In run_judge, SandBox is set up to run user program and checker program. The stdio is redirected to file fds. The checker program takes cmd args to run.

In run_interact, ProcessListener is set up for user program and interactor program. The stdio is piped to an epoll proxy, which would record the communication content to output_file(If you need more details on how the epoll here work, please tell me). At last, a checker program run in SandBox is used to do the final check.

It should be mentioned that the checker and interactor is not restricted by seccomp now. Here, a script running resource limitation should be set for both checker and interactor.

TODO

So here are a TODO list that I concern most now:

• SandBox: Reimplement the exec so that it can serve for other kinds of program running.
• SandBox: Optimize the implementation of spawn. (i.e. It takes too much arguments and is designed differently ragarding to io)
• Result: Define the returning verdict.
• Monitor: Set default resource limitation for judger script.
• Monitor: Exception handling, and inferring the verdict during judge flow from running status.
• Monitor: Resize the pipe, in case of overflow.
• Monitor/interactor: Get the running status of user program and interactor program from ProcessListener.
• Monitor/interactor: Format the output_file content.
• Monitor/interactor: Handle the exit event of the user program and the interactor program.
• Monitor/interactor: It should be checked whether the asynchronous work flow is correct, and whether the flag of fds is set properly(e.g. Nonblocking).

[akamya997]

BTW, do we need to manage the closed fd carefully here?