在线OJ系统
Posted S for N
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了在线OJ系统相关的知识，希望对你有一定的参考价值。
项目开始之前
需要准备的第三方库
httplib
g++版本必须得是4.9以上
ctemplate
boost： yum install boost-devel.x86_64
jsoncpp： yum install jsoncpp-devel.x86_64
项目分析
我们可以看到一个在线OJ至少有
题目ID
名字
难易度
描述
测试用例
代码框架
然后我们试做一道题，可以大概看出一个在线OJ的流程，
1 在浏览器中展示题目
2 用户可以选择题目进行作答
3 后台获取用户代码
4 针对用户代码进行编译
5 后台运行代码
6 将运行结果进行打包
7 把结果返回给客户端。
因此我将这个流程分为两大模块题目管理模块、在线编译模块
两大模块
在线编译模块
整体思路
用户发来请求
将用户请求进行切分
改成json格式
分为用户代码“code”和用户输入“stdin”
然后调用编译模块进行编译
调用运行模块进行运行
把最终结果进行返回，构造json对象
按照&和=进行切分，Split是将boost库中的split进行封装
static void ParseBody(const std::string& body,
std::unordered_map<std::string, std::string>* params){
//将body字符串切分成键值对
//先按照&切分
std::vector<std::string> kvs;
Split(body, "&", &kvs);
for(size_t i = 0; i < kvs.size(); ++i){
std::vector<std::string> kv;
//按照 = 切分
Split(kvs[i], "=", &kv);
if(kv.size() != 2){
continue;
}
//对键值对进行urldecode
(*params)[kv[0]] = UrlDecode(kv[1]);
}
}
//解析body，获取到用户提交的代码
std::unordered_map<std::string, std::string> body_kv;
UrlUtil::ParseBody(req.body, &body_kv);
const std::string& user_code = body_kv["code"];
//构造json结构的参数
Json::Value req_json;
req_json["code"] = user_code + question.tail_cpp;
req_json["stdin"] = user_code;
Json::Value resp_json;
//调用编译模块进行编译
Compiler::CompileAndRun(req_json, &resp_json);
编译模块
整体思路
根据所传来的请求，生成对应的源代码文件，然后调用g++来编译文件，如果编译出错，重定向到文件中，然后调用可执行程序，同时将标准输出和标准错误也重定向到文件，最后把程序的最终结果进行返回。
根据请求对象生成源码文件
//根据请求对象生成源代码文件
if (req["code"].empty()){
(*resp)["error"] = 3;
(*resp)["reason"] = "code empty";
LOG(ERROR) << "code empty" <<std::endl;
return false;
}
const std::string& code = req["code"].asString();
const std::string&file_name=WriteTmpFile(code,req["stdin"].asString());
我们需要生成多种文件，有源代码文件、编译错误文件、可执行程序文件、标准输入文件、标准输出文件、标准错误文件
因此将它们用不同的后缀区分开，并放到同一路径下，传入名字，就可以生成对应的临时文件，例如源代码文件
//源代码文件, name表示当前请求的名字
static std::string SrcPath(const std::string& name){
return "./temp_files/" + name + ".cpp";
}
把代码写到文件中，并且分配一个唯一的名字
static std::string WriteTmpFile(const std::string& code,
const std::string& str_stdin){
static std::atomic_int id(0);
++id;
std::string file_name = "tmp_" + std::to_string(TimeUtil::TimeStamp())
+ "." + std::to_string(id);
FileUtil::Write(SrcPath(file_name), code);
FileUtil::Write(StdinPath(file_name), str_stdin);
return file_name;
}
注意这里的id需要转成原子操作，因为很有可能有多个用户同时发来请求
然后调用g++进行编译，创建子进程，然后重定向标准错误到编译错误文件中，最后用程序替换的方式执行编译命令
//调用g++进行编译
bool ret = Compile(file_name);
static bool Compile(const std::string& file_name){
// 构造出编译指令
char* command[20] = {0};
char buf[20][50] = {{0}};
for(int i = 0; i < 20; ++i){
command[i] = buf[i];
}
sprintf(command[0], "%s", "g++");
sprintf(command[1], "%s", SrcPath(file_name).c_str());
sprintf(command[2], "%s", "-o");
sprintf(command[3], "%s", ExePath(file_name).c_str());
sprintf(command[4], "%s", "-std=c++11");
command[5] = NULL;
//创建子进程
int ret = fork();
if(ret > 0){
//父进程进行进程等待
waitpid(ret, NULL, 0);;
}
else{
//子进程进行程序替换
int fd = open(CompileErrorPath(file_name).c_str(),
O_WRONLY | O_CREAT, 0666);
if (fd < 0){
LOG(ERROR) << "open Compile file error" << std::endl;
exit(1);
}
dup2(fd, 2);
execvp(command[0], command);
//如果子进程执行失败，就直接退出
exit(0);
}
//判定可执行文件是否存在来确定编译是否成功
struct stat st;
ret = stat(ExePath(file_name).c_str(), &st);
if(ret < 0){
//说明文件不存在
LOG(INFO) << "Compile failed!" << file_name << std::endl;
return false;
}
LOG(INFO) << "Compile " << file_name << " OK!" << std::endl;
return true;
}
调用可执行程序，思路和上面几乎一样
//调用可执行程序
int sig = Run(file_name);
static int Run(const std::string& file_name){
//创建子进程
int ret = fork();
if(ret > 0){
//父进程进行等待
int status = 0;
waitpid(ret, &status, 0);
return status & 0x7f;
}
else{
//进行标准输入，输出，错误的重定向
int fd_stdout = open(StdoutPath(file_name).c_str(),
O_WRONLY | O_CREAT, 0666);
dup2(fd_stdout, 1);
int fd_stderr = open(StderrPath(file_name).c_str(),
O_WRONLY | O_CREAT, 0666);
dup2(fd_stderr, 2);
//子进程进行程序替换
execl(ExePath(file_name).c_str(),
ExePath(file_name).c_str(), NULL);
exit(0);
}
}
把最终结果进行返回，构造json对象，执行到这步，那说明没有什么问题，上面编译和运行出错时都会做错误处理，
这部分我没有贴出来
(*resp)["error"] = 0;
(*resp)["reason"] = "";
std::string str_stdout;
FileUtil::Read(StdoutPath(file_name), &str_stdout);
(*resp)["stdout"] = str_stdout;
std::string str_stderr;
FileUtil::Read(StderrPath(file_name), &str_stderr);
(*resp)["stderr"] = str_stderr;
LOG(INFO) << "Program " << file_name << " Done" << std::endl;
return true;
至此在线编译模块就告一段落了
题目管理模块
总体思路
获取所有的题目列表
指定题目的详细内容
调用在线编译模块完成代码的编译和运行
根据上述思路，那么我们就需要将题目描述组织起来。
首先基于文件的方式来完成题目的组织，创建一个行文本文件作为总的目录与入口文件，每一个题目对应一个目录，目录的名字就是题目的id
目录里面包含以下几个文件：
1 题目的详细描述
2. 代码框架
3. 代码测试用例
用一个结构体来表示单个的题目
struct Question{
std::string id;
std::string name;
std::string dir; //题目对应的目录,目录包含了题目描述
//题目的代码框架/题目的测试用例
std::string diff; //难度
std::string desc; //题目的描述
std::string header_cpp; //题目的代码框架中的代码
std::string tail_cpp; //题目的测试用例代码
};
数据存储
整体思路
先打开oj_config.cfg文件（这个文件就是上述的总目录与入口文件，每一行都是一个题目，我选择用\\t来作为分割符）
然后按行读取oj_config.cfg文件，并且根据\\t进行切分与解析
根据解析出来的结果拼装到上述的结构体中，header.cpp文件与tail.cpp文件分别存放着代码框架中的代码与题目的测试用例代码，在编译运行的时候需要将这两个拼接起来。
最后将结构体存入哈希表中
将文件中的数据加载到结构体中
bool Load(){
//打开oj_config.cfg文件，按行读取，解析
std::ifstream file("./oj_data/oj_config.cfg");
if(!file.is_open()){
return false;
}
std::string line;
while(std::getline(file, line)){
//根据解析结果填入结构体
std::vector<std::string> tokens;
UrlUtil::Split(line, "\\t", &tokens);
if(tokens.size() != 4){
LOG(ERROR) << "config file format error!\\n";
continue;
}
Question q;
q.id = tokens[0];
q.name = tokens[1];
q.diff = tokens[2];
q.dir = tokens[3];
FileUtil::Read(q.dir + "/desc.txt", &q.desc);
FileUtil::Read(q.dir + "/header.cpp", &q.header_cpp);
FileUtil::Read(q.dir + "/tail.cpp", &q.tail_cpp);
//插入到hash表
_model[q.id] = q;
}
file.close();
LOG(INFO) << "Load" << _model.size() << " questions\\n";
return true;
}
然后就是读取全部的题目与读取单个题目了
bool GetAllQuestions(std::vector<Question>* questions) const{
//遍历hash表
questions->clear();
for(const auto& kv : _model){
questions->push_back(kv.second);
}
return true;
}
bool GetQuestion(const std::string& id, Question* q) const{
const auto pos = _model.find(id);
if(pos == _model.end()){
return false;
}
*q = pos->second;
return true;
}
页面显示
这里我们根据数据生成对应的html文件，我们这里使用ctemplate来帮助我们完成。
这里我们需要三个html，一个是所有的题目的html，一个是单个题目的html，还有一个是返回的结果的html。
ctemplate可以使我们所要填充的数据和界面分离，相当于把我们需要计算填入的位置挖出一个空，然后在编写代码的时候，我们将其替换。
将所有题目页面进行渲染
static void RenderAllQuestions(const std::vector<Question>& all_questions,
std::string* html) {
//将所有的题目数据转换成题目列表页html
//通过网页模板的方式来构造html
//创建一个总的ctemplate对象
ctemplate::TemplateDictionary dict("all_question");
for(const auto& question : all_questions){
//循环往这个对象中田间一些子对象
ctemplate::TemplateDictionary* table_dict
= dict.AddSectionDictionary("question");
//每个子对象再设置一些键值对和模板中的{{}}对应
table_dict->SetValue("id", question.id);
table_dict->SetValue("name", question.name);
table_dict->SetValue("diff", question.diff);
}
//进行数据的替换，生成最终的html
ctemplate::Template* tpl;
tpl = ctemplate::Template::GetTemplate(
"./template/all_questions.html",
ctemplate::DO_NOT_STRIP);
tpl->Expand(html, &dict);
}
另外两个的渲染原理相同。
服务器
这里构建服务器，使用了第三方库httplib，同时用C++11中的正则表达式，来忽略转义字符，并且获取题号。最终完成三种页面的创建。
int main(){
//加载题库数据
OjModel model;
model.Load();
//使用第三方库httplib 来搭建服务器
using namespace httplib;
Server server;
//所有题目页面
server.Get("/",[&model](const Request& req, Response& resp){
(void) req;
//通过model获取所有的题目信息
std::vector<Question> all_questions;
model.GetAllQuestions(&all_questions);
//将all_questions的数据转换为html
std::string html;
OjView::RenderAllQuestions(all_questions,&html);
//将后端处理完的请求返回给客户端
resp.set_content(html,"text/html");
});
//具体题目的页面
server.Get(R"(/question/(\\d+))",[&model](const Request& req, Response& resp){
//通过model获取指定题目的信息
Question question;
model.GetQuestion(req.matches[1].str(),&question);
//将question的数据转换为html
std::string html;
OjView::RenderQuestion(question,&html);
//将后端处理完的请求返回给客户端
resp.set_content(html,"text/html");
});
//代码运行结果界面
server.Post(R"(/compile/(\\d+))",[&model](const Request& req, Response& resp){
//1. 通过model获取指定题目的信息
Question question;以上是关于在线OJ系统的主要内容，如果未能解决你的问题，请参考以下文章