目录
项目功能
实现了一个负载均衡式的在线OJ平台，用户可以在浏览器访问各个题目，在编辑区编写代码提交，后端对代码进行编译运行，最终为用户返回结果。
项目描述
OJ模块基于MVC结构，调用数据库将题目显示给用户，用户编写提交代码，OJ模块通过网络通信，负载均衡式地选择compiler模块服务器，将用户代码和测试用例组合，编译运行后将结果返回给用户。
技术栈与开发环境
所用技术:
- C++ STL 标准库
- Boost 准标准库(字符串切割)
- cpp-httplib 第三方开源网络库
- ctemplate 第三方开源前端网页渲染库
- jsoncpp 第三方开源序列化、反序列化库
- 负载均衡设计
- 多进程、多线程
- MySQL C connect
- Ace前端在线编辑器(简单使用)
- html/css/js/jquery/ajax (简单使用)
开发环境：
- Centos 7 云服务器
- vscode
- Mysql Workbench
项目思维导图
项目宏观结构
我的项目核心是三个模块
- comm : 公共模块，提供一些时间戳获取，路径拼接，文件操作，字符串处理，网络请求，日志等项目里常用的功能。
- compile_server : 编译与运行模块，让用户提交的代码与测试用例拼接后在服务器上进行编译，运行，得到结果返回给用户。
- oj_server : 请求题目列表；请求一个具体题目，且有编辑区 ；提交判题请求。采用MVC的设计模式，使用负载均衡，访问文件或数据库，调用编译模块，以及把题目列表和编辑界面展示给用户。
用户直接访问的是OJServer模块，OJServer收到请求后会进行功能路由，根据不同的请求给用户返回不同的结果，如果用户是编写题目提交代码，那么OJServer模块会根据后端的CompilerServer服务器的负载情况，负载均衡地选择主机提供的编译运行服务，然后拿到编译运行结果返回给用户。Compiler服务器和OJ服务器，两个模块之间采用http网络通信，把编译运行模块部署在多台服务器上，OJ服务器只需要一台，能够把用户的请求发送给后端CompilerServer。
Comm公共模块
日志工具log.hpp
namespace ns_log
{
using namespace ns_util;
// 日志等级
enum
{
INFO, //就是整数
DEBUG,
WARNING,
ERROR,
FATAL
};
inline std::ostream &Log(const std::string &level, const std::string &file_name, int line)
{
// 添加日志等级
std::string message = "[";
message += level;
message += "]";
// 添加报错文件名称
message += "[";
message += file_name;
message += "]";
// 添加报错行
message += "[";
message += std::to_string(line);
message += "]";
// 日志时间戳
message += "[";
message += TimeUtil::GetTimeStamp();
message += "]";
// cout 本质 内部是包含缓冲区的
std::cout << message; //不要endl进行刷新
return std::cout;
}
// LOG(INFo) << "message" << "\n";
// 开放式日志
#define LOG(level) Log(#level, __FILE__, __LINE__)
}
其他工具util.hpp
namespace ns_util
{
class TimeUtil
{
public:
static std::string GetTimeStamp()
{
struct timeval _time;
gettimeofday(&_time, nullptr);
return std::to_string(_time.tv_sec);
}
//获得毫秒时间戳
static std::string GetTimeMs()
{
struct timeval _time;
gettimeofday(&_time, nullptr);
return std::to_string(_time.tv_sec * 1000 + _time.tv_usec / 1000);
}
};
const std::string temp_path = "./temp/";
class PathUtil
{
public:
static std::string AddSuffix(const std::string &file_name, const std::string &suffix)
{
std::string path_name = temp_path;
path_name += file_name;
path_name += suffix;
return path_name;
}
// 编译时需要有的临时文件
// 构建源文件路径+后缀的完整文件名
static std::string Src(const std::string &file_name)
{
return AddSuffix(file_name, ".cpp");
}
// 构建可执行程序的完整路径+后缀名
static std::string Exe(const std::string &file_name)
{
return AddSuffix(file_name, ".exe");
}
static std::string CompilerError(const std::string &file_name)
{
return AddSuffix(file_name, ".compile_error");
}
// 运行时需要的临时文件
static std::string Stdin(const std::string &file_name)
{
return AddSuffix(file_name, ".stdin");
}
static std::string Stdout(const std::string &file_name)
{
return AddSuffix(file_name, ".stdout");
}
// 构建该程序对应的标准错误完整的路径+后缀名
static std::string Stderr(const std::string &file_name)
{
return AddSuffix(file_name, ".stderr");
}
};
class FileUtil
{
public:
static bool IsFileExists(const std::string &path_name)
{
struct stat st;
if (stat(path_name.c_str(), &st) == 0)
{
//获取属性成功，文件已经存在
return true;
}
return false;
}
static std::string UniqFileName()
{
static std::atomic_uint id(0);
id++;
// 毫秒级时间戳+原子性递增唯一值: 来保证唯一性
std::string ms = TimeUtil::GetTimeMs();
std::string uniq_id = std::to_string(id);
return ms + "_" + uniq_id;
}
static bool WriteFile(const std::string &target, const std::string &content)
{
std::ofstream out(target);
if (!out.is_open())
{
return false;
}
out.write(content.c_str(), content.size());
out.close();
return true;
}
static bool ReadFile(const std::string &target, std::string *content, bool keep = false)
{
(*content).clear();
std::ifstream in(target);
if (!in.is_open())
{
return false;
}
std::string line;
// getline:不保存行分割符,有些时候需要保留\n,
// getline内部重载了强制类型转化
while (std::getline(in, line))
{
(*content) += line;
(*content) += (keep ? "\n" : "");
}
in.close();
return true;
}
};
class StringUtil
{
public:
static void SplitString(const std::string &str, std::vector<std::string> *target, const std::string &sep)
{
//boost split
boost::split((*target), str, boost::is_any_of(sep), boost::algorithm::token_compress_on);
}
};
}
CompilerServer模块
整体层次如图
编译模块compiler.hpp
// 只负责进行代码的编译
namespace ns_compiler
{
class Compiler
{
public:
Compiler()
{}
~Compiler()
{}
static bool Compile(const std::string &file_name)
{
pid_t pid = fork();
if(pid < 0)
{
LOG(ERROR) << "内部错误，创建子进程失败" << "\n";
return false;
}
else if (pid == 0)
{
umask(0);
int _stderr = open(PathUtil::CompilerError(file_name).c_str(), O_CREAT | O_WRONLY, 0644);
if(_stderr < 0){
LOG(WARNING) << "没有成功形成stderr文件" << "\n";
exit(1);
}
//重定向标准错误到_stderr
dup2(_stderr, 2);
//程序替换，并不影响进程的文件描述符表
//子进程: 调用编译器，完成对代码的编译工作
//g++ -o target src -std=c++11
execlp("g++", "g++", "-o", PathUtil::Exe(file_name).c_str(),\
PathUtil::Src(file_name).c_str(), "-D", "COMPILER_ONLINE","-std=c++11", nullptr/*不要忘记*/);
LOG(ERROR) << "启动编译器g++失败，可能是参数错误" << "\n";
exit(2);
}
else{
waitpid(pid, nullptr, 0);
//编译是否成功,就看有没有形成对应的可执行程序
if(FileUtil::IsFileExists(PathUtil::Exe(file_name))){
LOG(INFO) << PathUtil::Src(file_name) << " 编译成功!" << "\n";
return true;
}
}
LOG(ERROR) << "编译失败，没有形成可执行程序" << "\n";
return false;
}
};
}
运行模块runner.hpp
namespace ns_runner
{
class Runner
{
public:
Runner() {}
~Runner() {}
public:
//提供设置进程占用资源大小的接口
static void SetProcLimit(int _cpu_limit, int _mem_limit)
{
// 设置CPU时长
struct rlimit cpu_rlimit;
cpu_rlimit.rlim_max = RLIM_INFINITY;
cpu_rlimit.rlim_cur = _cpu_limit;
setrlimit(RLIMIT_CPU, &cpu_rlimit);
// 设置内存大小
struct rlimit mem_rlimit;
mem_rlimit.rlim_max = RLIM_INFINITY;
mem_rlimit.rlim_cur = _mem_limit * 1024; //转化成为KB
setrlimit(RLIMIT_AS, &mem_rlimit);
}
static int Run(const std::string &file_name, int cpu_limit, int mem_limit)
std::string _execute = PathUtil::Exe(file_name);
std::string _stdin = PathUtil::Stdin(file_name);
std::string _stdout = PathUtil::Stdout(file_name);
std::string _stderr = PathUtil::Stderr(file_name);
umask(0);
int _stdin_fd = open(_stdin.c_str(), O_CREAT|O_RDONLY, 0644);
int _stdout_fd = open(_stdout.c_str(), O_CREAT|O_WRONLY, 0644);
int _stderr_fd = open(_stderr.c_str(), O_CREAT|O_WRONLY, 0644);
if(_stdin_fd < 0 || _stdout_fd < 0 || _stderr_fd < 0){
LOG(ERROR) << "运行时打开标准文件失败" << "\n";
return -1; //代表打开文件失败
}
pid_t pid = fork();
if (pid < 0)
{
LOG(ERROR) << "运行时创建子进程失败" << "\n";
close(_stdin_fd);
close(_stdout_fd);
close(_stderr_fd);
return -2; //代表创建子进程失败
}
else if (pid == 0)
{
dup2(_stdin_fd, 0);
dup2(_stdout_fd, 1);
dup2(_stderr_fd, 2);
SetProcLimit(cpu_limit, mem_limit);
execl(_execute.c_str()/*我要执行谁*/, _execute.c_str()/*我想在命令行上如何执行该程序*/, nullptr);
exit(1);
}
else
{
close(_stdin_fd);
close(_stdout_fd);
close(_stderr_fd);
int status = 0;
waitpid(pid, &status, 0);
// 程序运行异常，一定是因为因为收到了信号！
LOG(INFO) << "运行完毕, info: " << (status & 0x7F) << "\n";
return status & 0x7F;
}
}
};
}
编译+运行compile_run.hpp
namespace ns_compile_and_run
{
class CompileAndRun
{
public:
static void RemoveTempFile(const std::string &file_name)
{
//清理文件的个数是不确定的，但是有哪些我们是知道的
std::string _src = PathUtil::Src(file_name);
if(FileUtil::IsFileExists(_src)) unlink(_src.c_str());
std::string _compiler_error = PathUtil::CompilerError(file_name);
if(FileUtil::IsFileExists(_compiler_error)) unlink(_compiler_error.c_str());
std::string _execute = PathUtil::Exe(file_name);
if(FileUtil::IsFileExists(_execute)) unlink(_execute.c_str());
std::string _stdin = PathUtil::Stdin(file_name);
if(FileUtil::IsFileExists(_stdin)) unlink(_stdin.c_str());
std::string _stdout = PathUtil::Stdout(file_name);
if(FileUtil::IsFileExists(_stdout)) unlink(_stdout.c_str());
std::string _stderr = PathUtil::Stderr(file_name);
if(FileUtil::IsFileExists(_stderr)) unlink(_stderr.c_str());
}
static std::string CodeToDesc(int code, const std::string &file_name)
{
std::string desc;
switch (code)
{
case 0:
desc = "编译运行成功";
break;
case -1:
desc = "提交的代码是空";
break;
case -2:
desc = "未知错误";
break;
case -3:
// desc = "代码编译的时候发生了错误";
FileUtil::ReadFile(PathUtil::CompilerError(file_name), &desc, true);
break;
case SIGABRT: // 6
desc = "内存超过范围";
break;
case SIGXCPU: // 24
desc = "CPU使用超时";
break;
case SIGFPE: // 8
desc = "浮点数溢出";
break;
default:
desc = "未知: " + std::to_string(code);
break;
}
return desc;
}
static void Start(const std::string &in_json, std::string *out_json)
{
Json::Value in_value;
Json::Reader reader;
reader.parse(in_json, in_value); //最后在处理差错问题
std::string code = in_value["code"].asString();
std::string input = in_value["input"].asString();
int cpu_limit = in_value["cpu_limit"].asInt();
int mem_limit = in_value["mem_limit"].asInt();
int status_code = 0;
Json::Value out_value;
int run_result = 0;
std::string file_name; //需要内部形成的唯一文件名
if (code.size() == 0)
{
status_code = -1; //代码为空
goto END;
}
// 形成的文件名只具有唯一性，没有目录没有后缀
// 毫秒级时间戳+原子性递增唯一值: 来保证唯一性
file_name = FileUtil::UniqFileName();
//形成临时src文件
if (!FileUtil::WriteFile(PathUtil::Src(file_name), code))
{
status_code = -2; //未知错误
goto END;
}
if (!Compiler::Compile(file_name))
{
//编译失败
status_code = -3; //代码编译的时候发生了错误
goto END;
}
run_result = Runner::Run(file_name, cpu_limit, mem_limit);
if (run_result < 0)
{
status_code = -2; //未知错误
}
else if (run_result > 0)
{
//程序运行崩溃了
status_code = run_result;
}
else
{
//运行成功
status_code = 0;
}
END:
out_value["status"] = status_code;
out_value["reason"] = CodeToDesc(status_code, file_name);
if (status_code == 0)
{
// 整个过程全部成功
std::string _stdout;
FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
out_value["stdout"] = _stdout;
std::string _stderr;
FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr, true);
out_value["stderr"] = _stderr;
}
Json::StyledWriter writer;
*out_json = writer.write(out_value);
RemoveTempFile(file_name);
}
};
}
Compiler模块compiler_server.cc
void Usage(std::string proc)
{
std::cerr << "Usage: " << "\n\t" << proc << " port" << std::endl;
}
//编译服务随时可能被多个人请求，必须保证传递上来的code，形成源文件名称的时候，要具有唯一性，要不然多个用户之间会互相影响
//./compile_server port
int main(int argc, char *argv[])
{
if(argc != 2){
Usage(argv[0]);
return 1;
}
Server svr;
svr.Post("/compile_and_run", [](const Request &req, Response &resp){
// 用户请求的服务正文是我们想要的json string
std::string in_json = req.body;
std::string out_json;
if(!in_json.empty()){
CompileAndRun::Start(in_json, &out_json);
resp.set_content(out_json, "application/json;charset=utf-8");
}
});
// svr.set_base_dir("./wwwroot");
svr.listen("0.0.0.0", atoi(argv[1])); //启动http服务
return 0;
}
OJServer
OJServer模块是直接和用户交互的，用户访问OJ系统，我需要有一个首页，其次需要有一个题目列表网页供用户选择题目，再者还需要一个可以给用户写代码做题的网页，并且可以提交代码，判断用户提交的代码是否正确。
总结用户的请求分为三种：
1.请求题目列表
2.请求一个具体的题目，并且需要有编译区域
3.提交，判题请求 OJServer模块主要要根据这三种请求提供对应的功能。
整个模块采用的是MVC的设计模式进行设计
通过这个设计模式，把数据，业务逻辑和网页界面进行了分离。
所以整个模块就包含四个部分：
oj_model模块： 负责模块前两个功能的数据部分，通过与题库交互，得到所有题目的信息或者某一个题目的信息
oj_view模块： 负责渲染用户得到网页，根据用户提交的不同请求，渲染不同的题目信息
oj_control模块： 负责整个OJServer模块的业务逻辑控制。对下负责负载均衡式的选择主机请求编译服务，对上根据用户的三种请求，配合上面两个模块，完成对应的功能。
oj_server模块： 搭建http服务，根据用户的请求，完成功能路由，调用control模块的对应方法完成功能
整体层次如图：
Model模块oj_model.hpp
oj_model模块的主要任务就是和后端的题库交互，主要是为了完成请求题目列表和请求单个题目的功能，得到题库中对应的题目信息。
这个是文件版本
// 根据题目list文件，加载所有的题目信息到内存中
// model: 主要用来和数据进行交互，对外提供访问数据的接口
namespace ns_model
{
struct Question
{
std::string number; //题目编号，唯一
std::string title; //题目的标题
std::string star; //难度: 简单 中等 困难
int cpu_limit; //题目的时间要求(S)
int mem_limit; //题目的空间要去(KB)
std::string desc; //题目的描述
std::string header; //题目预设给用户在线编辑器的代码
std::string tail; //题目的测试用例，需要和header拼接，形成完整代码
};
const std::string questins_list = "./questions/questions.list";
const std::string questins_path = "./questions/";
class Model
{
private:
//题号 : 题目细节
unordered_map<string, Question> questions;
public:
Model()
{
assert(LoadQuestionList(questins_list));
}
bool LoadQuestionList(const string &question_list)
{
//加载配置文件: questions/questions.list + 题目编号文件
ifstream in(question_list);
if(!in.is_open())
{
LOG(FATAL) << " 加载题库失败,请检查是否存在题库文件" << "\n";
return false;
}
string line;
while(getline(in, line))
{
vector<string> tokens;
StringUtil::SplitString(line, &tokens, " ");
// 1 判断回文数 简单 1 30000
if(tokens.size() != 5)
{
LOG(WARNING) << "加载部分题目失败, 请检查文件格式" << "\n";
continue;
}
Question q;
q.number = tokens[0];
q.title = tokens[1];
q.star = tokens[2];
q.cpu_limit = atoi(tokens[3].c_str());
q.mem_limit = atoi(tokens[4].c_str());
string path = questins_path;
path += q.number;
path += "/";
FileUtil::ReadFile(path+"desc.txt", &(q.desc), true);
FileUtil::ReadFile(path+"header.cpp", &(q.header), true);
FileUtil::ReadFile(path+"tail.cpp", &(q.tail), true);
questions.insert({q.number, q});
}
LOG(INFO) << "加载题库...成功!" << "\n";
in.close();
return true;
}
bool GetAllQuestions(vector<Question> *out)
{
if(questions.size() == 0)
{
LOG(ERROR) << "用户获取题库失败" << "\n";
return false;
}
for(const auto &q : questions){
out->push_back(q.second); //first: key, second: value
}
return true;
}
bool GetOneQuestion(const std::string &number, Question *q)
{
const auto& iter = questions.find(number);
if(iter == questions.end()){
LOG(ERROR) << "用户获取题目失败, 题目编号: " << number << "\n";
return false;
}
(*q) = iter->second;
return true;
}
~Model()
{}
};
}
下面是数据库版本
// 根据题目list文件，加载所有的题目信息到内存中
// model: 主要用来和数据进行交互，对外提供访问数据的接口
namespace ns_model
{
struct Question
{
std::string number; //题目编号，唯一
std::string title; //题目的标题
std::string star; //难度: 简单 中等 困难
std::string desc; //题目的描述
std::string header; //题目预设给用户在线编辑器的代码
std::string tail; //题目的测试用例，需要和header拼接，形成完整代码
int cpu_limit; //题目的时间要求(S)
int mem_limit; //题目的空间要去(KB)
};
const std::string oj_questions = "oj_questions";
const std::string host = "127.0.0.1";
const std::string user = "oj_client";
const std::string passwd = "xxxxxxxxxx";
const std::string db = "oj";
const int port = 3306;
class Model
{
public:
Model()
{}
bool QueryMySql(const std::string &sql, vector<Question> *out)
{
// 创建mysql句柄
MYSQL *my = mysql_init(nullptr);
// 连接数据库
if(nullptr == mysql_real_connect(my, host.c_str(), user.c_str(), passwd.c_str(),db.c_str(),port, nullptr, 0)){
LOG(FATAL) << "连接数据库失败!" << "\n";
return false;
}
// 一定要设置该链接的编码格式, 要不然会出现乱码问题
mysql_set_character_set(my, "utf8");
LOG(INFO) << "连接数据库成功!" << "\n";
// 执行sql语句
if(0 != mysql_query(my, sql.c_str()))
{
LOG(WARNING) << sql << " execute error!" << "\n";
return false;
}
// 提取结果
MYSQL_RES *res = mysql_store_result(my);
// 分析结果
int rows = mysql_num_rows(res); //获得行数量
int cols = mysql_num_fields(res); //获得列数量
Question q;
for(int i = 0; i < rows; i++)
{
MYSQL_ROW row = mysql_fetch_row(res);
q.number = row[0];
q.title = row[1];
q.star = row[2];
q.desc = row[3];
q.header = row[4];
q.tail = row[5];
q.cpu_limit = atoi(row[6]);
q.mem_limit = atoi(row[7]);
out->push_back(q);
}
// 释放结果空间
free(res);
// 关闭mysql连接
mysql_close(my);
return true;
}
bool GetAllQuestions(vector<Question> *out)
{
std::string sql = "select * from ";
sql += oj_questions;
return QueryMySql(sql, out);
}
bool GetOneQuestion(const std::string &number, Question *q)
{
bool res = false;
std::string sql = "select * from ";
sql += oj_questions;
sql += " where number=";
sql += number;
vector<Question> result;
if(QueryMySql(sql, &result))
{
if(result.size() == 1){
*q = result[0];
res = true;
}
}
return res;
}
~Model()
{}
};
}
题库的结构
题目的属性大致可以分为2类：
一种是题目编号，题目标题，题目难度，时间限制和内存限制这些字段，这些字段都比较小，可以把所有题目的这些信息存在一个文件里面。
还有一种就是题目描述，预置代码，测试用例等等，这类信息一般都比较大，可以根据题目编号给每道题建立一个与编号对应的文件夹，然后用三个文件保存这三个信息，到时候就可以通过题目编号找到题目对应的路径，然后读取对应的文件，不仅读取方便，还便于我们录题。
view模块oj_view.hpp
oj_view模块负责渲染给用户显示的网页。比如说用户请求访问题目列表，题目列表里的题目信息是从我们后端的题库中得到的，而把这些信息显示到网页上，这就是渲染网页。所有说view模块也应该提供两个接口，一个渲染题目列表，一个渲染单个题目的网页。
namespace ns_view
{
using namespace ns_model;
const std::string template_path = "./template_html/";
class View
{
public:
View(){}
~View(){}
public:
void AllExpandHtml(const vector<struct Question> &questions, std::string *html)
{
// 题目的编号 题目的标题 题目的难度
// 推荐使用表格显示
// 1. 形成路径
std::string src_html = template_path + "all_questions.html";
// 2. 形成数字典
ctemplate::TemplateDictionary root("all_questions");
for (const auto& q : questions)
{
ctemplate::TemplateDictionary *sub = root.AddSectionDictionary("question_list");
sub->SetValue("number", q.number);
sub->SetValue("title", q.title);
sub->SetValue("star", q.star);
}
//3. 获取被渲染的html
ctemplate::Template *tpl = ctemplate::Template::GetTemplate(src_html, ctemplate::DO_NOT_STRIP);
//4. 开始完成渲染功能
tpl->Expand(html, &root);
}
void OneExpandHtml(const struct Question &q, std::string *html)
{
// 1. 形成路径
std::string src_html = template_path + "one_question.html";
// 2. 形成数字典
ctemplate::TemplateDictionary root("one_question");
root.SetValue("number", q.number);
root.SetValue("title", q.title);
root.SetValue("star", q.star);
root.SetValue("desc", q.desc);
root.SetValue("pre_code", q.header);
//3. 获取被渲染的html
ctemplate::Template *tpl = ctemplate::Template::GetTemplate(src_html, ctemplate::DO_NOT_STRIP);
//4. 开始完成渲染功能
tpl->Expand(html, &root);
}
};
}
oj_control模块oj_control.hpp
oj_control模块是整个OJSever模块的逻辑功能部分，在上层做好了功能路由之后，通过调用control模块实现各个功能，所有oj_control模块既要可以返回对应的网页，还要可以负载均衡的判题。提供三个功能，即：一个可以构建好题目列表网页的接口，一个可以根据题目编号构建好单个题目网页的接口，还有一个判题接口。
构建题目列表和单个题目网页
bool AllQuestions(string *html)
{
bool ret = true;
vector<struct Question> all;
if (model_.GetAllQuestions(&all))
{
sort(all.begin(), all.end(), [](const struct Question &q1, const struct Question &q2){
return atoi(q1.number.c_str()) < atoi(q2.number.c_str());
});
// 获取题目信息成功，将所有的题目数据构建成网页
view_.AllExpandHtml(all, html);
}
else
{
*html = "获取题目失败, 形成题目列表失败";
ret = false;
}
return ret;
}
bool Question(const string &number, string *html)
{
bool ret = true;
struct Question q;
if (model_.GetOneQuestion(number, &q))
{
// 获取指定题目信息成功，将所有的题目数据构建成网页
view_.OneExpandHtml(q, html);
}
else
{
*html = "指定题目: " + number + " 不存在!";
ret = false;
}
return ret;
}
负载均衡模块
机器类的设计
负载均衡模块，最重要的功能就是可以负载均衡式的选择主机，我如何得知有哪些主机可以供我选择，怎么实现负载均衡。
所以模块内部要有一个结构包含提供服务的主机信息，用来表述主机的结构命名为Machine，然后用一个vector把所有提供服务的主机组织起来。
Machine类里有主机的IP，端口，还有负载情况。负载均衡判断的依据就是看主机的负载，所有类里还要提供方法，在有新请求请求该机器时增加负载，服务结束时减少负载，如果中途服务主机突然挂了，还要可以清空负载。
因为同一时刻可能有多个执行流在请求同一个主机，所有需要保证对负载操作的安全性，需要一个mutex互斥锁。
负载均衡模块设计
将来选择主机可以在vector中选，在此之前需要知道有哪些主机可以选，在当前路径下加一个.conf文件里面会存放所有的可以提供服务的主机信息，包括了IP和端口，每一行是一个主机的信息，负载均衡模块在构建时就可以读取该文件，初始化自己的vector结构。
然后就是选择主机功能，首先在同一时刻可能有很多执行流都在选择主机，所以对主机的选择需要加锁，也就是说负载均衡模块也需要一个互斥锁。
设计在control模块调用负载均衡模块时，如果说后端的编译服务主机出问题挂了，不应该影响我的OJServer服务，OJ服务正常运行，编译服务如果恢复了，那我正常请求，如果有一部分挂了，那我请求别的主机，全挂我就不请求，提示后端。
这个功能就由负载均衡模块负责，负载均衡模块除了可以选择主机，还要能够知道主机的情况，并能够根据情况更新。使用数组的下标表示每一个主机的编号，用两个数组，一个表示上线主机，元素的值就是主机编号，另一个表示下线的主机。提供方法，在后端编译服务重启时可以更新状态让主机上线，当请求主机失败时要更新状态让主机下线。
负载均衡的实现：
负载均衡就是尽量让每一台机器负责的请求平均，那就需要从所有在线的主机中选择出对应的主机。一是随机挑选主机，但是这种方法不能排除有时候一直选中某几台，有几台又一直选不上。还有一种比较严格，遍历所有在线的主机，找出负载最小的。
class Machine
{
public:
std::string ip; //编译服务的ip
int port; //编译服务的port
uint64_t load; //编译服务的负载
std::mutex *mtx; // mutex禁止拷贝的，使用指针
public:
Machine() : ip(""), port(0), load(0), mtx(nullptr)
{
}
~Machine()
{
}
public:
// 提升主机负载
void IncLoad()
{
if (mtx) mtx->lock();
++load;
if (mtx) mtx->unlock();
}
// 减少主机负载
void DecLoad()
{
if (mtx) mtx->lock();
--load;
if (mtx) mtx->unlock();
}
void ResetLoad()
{
if(mtx) mtx->lock();
load = 0;
if(mtx) mtx->unlock();
}
// 获取主机负载,没有太大的意义，只是为了统一接口
uint64_t Load()
{
uint64_t _load = 0;
if (mtx) mtx->lock();
_load = load;
if (mtx) mtx->unlock();
return _load;
}
};
const std::string service_machine = "./conf/service_machine.conf";
// 负载均衡模块
class LoadBlance
{
private:
// 可以给我们提供编译服务的所有的主机
// 每一台主机都有自己的下标，充当当前主机的id
std::vector<Machine> machines;
// 所有在线的主机id
std::vector<int> online;
// 所有离线的主机id
std::vector<int> offline;
// 保证LoadBlance它的数据安全
std::mutex mtx;
public:
LoadBlance()
{
assert(LoadConf(service_machine));
LOG(INFO) << "加载 " << service_machine << " 成功"
<< "\n";
}
~LoadBlance()
{
}
public:
bool LoadConf(const std::string &machine_conf)
{
std::ifstream in(machine_conf);
if (!in.is_open())
{
LOG(FATAL) << " 加载: " << machine_conf << " 失败"
<< "\n";
return false;
}
std::string line;
while (std::getline(in, line))
{
std::vector<std::string> tokens;
StringUtil::SplitString(line, &tokens, ":");
if (tokens.size() != 2)
{
LOG(WARNING) << " 切分 " << line << " 失败"
<< "\n";
continue;
}
Machine m;
m.ip = tokens[0];
m.port = atoi(tokens[1].c_str());
m.load = 0;
m.mtx = new std::mutex();
online.push_back(machines.size());
machines.push_back(m);
}
in.close();
return true;
}
// id: 输出型参数
// m : 输出型参数
bool SmartChoice(int *id, Machine **m)
{
// 1. 使用选择好的主机(更新该主机的负载)
// 2. 我们需要可能离线该主机
mtx.lock();
// 负载均衡的算法
// 1. 随机数+hash
// 2. 轮询+hash
int online_num = online.size();
if (online_num == 0)
{
mtx.unlock();
LOG(FATAL) << " 所有的后端编译主机已经离线, 请运维的同事尽快查看"
<< "\n";
return false;
}
// 通过遍历的方式，找到所有负载最小的机器
*id = online[0];
*m = &machines[online[0]];
uint64_t min_load = machines[online[0]].Load();
for (int i = 1; i < online_num; i++)
{
uint64_t curr_load = machines[online[i]].Load();
if (min_load > curr_load)
{
min_load = curr_load;
*id = online[i];
*m = &machines[online[i]];
}
}
mtx.unlock();
return true;
}
void OfflineMachine(int which)
{
mtx.lock();
for(auto iter = online.begin(); iter != online.end(); iter++)
{
if(*iter == which)
{
machines[which].ResetLoad();
//要离线的主机已经找到啦
online.erase(iter);
offline.push_back(which);
break; //因为break的存在，所有我们暂时不考虑迭代器失效的问题
}
}
mtx.unlock();
}
void OnlineMachine()
{
//我们统一上线，后面统一解决
mtx.lock();
online.insert(online.end(), offline.begin(), offline.end());
offline.erase(offline.begin(), offline.end());
mtx.unlock();
LOG(INFO) << "所有的主机有上线啦!" << "\n";
}
//for test
void ShowMachines()
{
mtx.lock();
std::cout << "当前在线主机列表: ";
for(auto &id : online)
{
std::cout << id << " ";
}
std::cout << std::endl;
std::cout << "当前离线主机列表: ";
for(auto &id : offline)
{
std::cout << id << " ";
}
std::cout << std::endl;
mtx.unlock();
}
};
判题模块
得到的参数是需要判的题目编号和用户传进来的json串形式的代码，通过题目编号，调用model模块得到题目相关的信息，然后通过反序列化用户传来的代码，得到代码内容。有了题目的信息和用户的代码，就可以拼接出可以用来编译的源码内容，构建出CompilerServer需要的json串。请求后端编译服务器主机。
选到主机之后通过主机的IP+端口，使用网络请求方式发起请求，除了通过请求的返回值判断请求是否成功，还需要判断请求的状态码，只有状态呢是200才表示请求成功。且需要更新请求时机器的负载情况。
void Judge(const std::string &number, const std::string in_json, std::string *out_json)
{
// LOG(DEBUG) << in_json << " \nnumber:" << number << "\n";
// 0. 根据题目编号，直接拿到对应的题目细节
struct Question q;
model_.GetOneQuestion(number, &q);
// 1. in_json进行反序列化，得到题目的id，得到用户提交源代码，input
Json::Reader reader;
Json::Value in_value;
reader.parse(in_json, in_value);
std::string code = in_value["code"].asString();
// 2. 重新拼接用户代码+测试用例代码，形成新的代码
Json::Value compile_value;
compile_value["input"] = in_value["input"].asString();
compile_value["code"] = code + "\n" + q.tail;
compile_value["cpu_limit"] = q.cpu_limit;
compile_value["mem_limit"] = q.mem_limit;
Json::FastWriter writer;
std::string compile_string = writer.write(compile_value);
// 3. 选择负载最低的主机(差错处理)
// 规则: 一直选择，直到主机可用，否则，就是全部挂掉
while(true)
{
int id = 0;
Machine *m = nullptr;
if(!load_blance_.SmartChoice(&id, &m))
{
break;
}
// 4. 然后发起http请求，得到结果
Client cli(m->ip, m->port);
m->IncLoad();
LOG(INFO) << " 选择主机成功, 主机id: " << id << " 详情: " << m->ip << ":" << m->port << " 当前主机的负载是: " << m->Load() << "\n";
if(auto res = cli.Post("/compile_and_run", compile_string, "application/json;charset=utf-8"))
{
// 5. 将结果赋值给out_json
if(res->status == 200)
{
*out_json = res->body;
m->DecLoad();
LOG(INFO) << "请求编译和运行服务成功..." << "\n";
break;
}
m->DecLoad();
}
else
{
//请求失败
LOG(ERROR) << " 当前请求的主机id: " << id << " 详情: " << m->ip << ":" << m->port << " 可能已经离线"<< "\n";
load_blance_.OfflineMachine(id);
load_blance_.ShowMachines(); //仅仅是为了用来调试
}
}
}
oj_server模块oj_server.cc
搭建一个http服务，通过用户请求的不同资源，完成功能路由的任务，调用oj_control模块的功能。
static Control *ctrl_ptr = nullptr;
void Recovery(int signo)
{
ctrl_ptr->RecoveryMachine();
}
int main()
{
signal(SIGQUIT, Recovery);
//用户请求的服务路由功能
Server svr;
Control ctrl;
ctrl_ptr = &ctrl;
// 获取所有的题目列表
svr.Get("/all_questions", [&ctrl](const Request &req, Response &resp){
//返回一张包含有所有题目的html网页
std::string html;
ctrl.AllQuestions(&html);
//用户看到的是什么呢？？网页数据 + 拼上了题目相关的数据
resp.set_content(html, "text/html; charset=utf-8");
});
// 用户要根据题目编号，获取题目的内容
// /question/100 -> 正则匹配
// R"()", 原始字符串raw string,保持字符串内容的原貌，不用做相关的转义
svr.Get(R"(/question/(\d+))", [&ctrl](const Request &req, Response &resp){
std::string number = req.matches[1];
std::string html;
ctrl.Question(number, &html);
resp.set_content(html, "text/html; charset=utf-8");
});
// 用户提交代码，使用我们的判题功能(1. 每道题的测试用例 2. compile_and_run)
svr.Post(R"(/judge/(\d+))", [&ctrl](const Request &req, Response &resp){
std::string number = req.matches[1];
std::string result_json;
ctrl.Judge(number, req.body, &result_json);
resp.set_content(result_json, "application/json;charset=utf-8");
// resp.set_content("指定题目的判题: " + number, "text/plain; charset=utf-8");
});
svr.set_base_dir("./wwwroot");
svr.listen("0.0.0.0", 8080);
return 0;
}
前端界面
前端简单使用：
html/css/js/jquery/ajax
Ace前端在线编辑器
项目扩展
- 把讨论求职等其他接口功能也接入到在线OJ中
- 添加注册和登陆功能
- 判断一道题目正确之后，自动下一道题目
项目展示
项目首页
题目列表，可以根据需求增加更多的题目
具体一道题
编辑代码提交
934
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
