​

​

​

​

namespace ns_util
{const std::string path = "./temp/";// 合并路径类class PathUtil{public:// 拼接函数static std::string splic(const std::string& str1, const std::string& str2){std::string temp = path;temp += str1;temp += str2;return temp;}// 编译临时文件// 拼接源文件 文件名+cppstatic std::string Src(const std::string& file_name){return splic(file_name, ".cpp");}// 拼接可执行文件 文件名+exestatic std::string Exe(const std::string& file_name){return splic(file_name, ".exe");}// 拼接保存标准错误文件static std::string CompileError(const std::string& file_name){return splic(file_name, ".compile_error");}}
}

namespace ns_log
{using namespace ns_util;// 日志等级enum{INFO,    // 正常DEBUG,   // 调试WARING,  // 警告ERROR,   // 错误FATAL    // 致命};// 开放式输出日志信息inline std::ostream& Log(const std::string& level, const std::string& file_name, int line){
// #ifndef MYLOGDEBUG
//         if (level == "DEBUG"){
//             return std::cout << "\n";
//         }
// #endifstd::string log;// 添加日志等级log += "[";log += level;log += "]";// 添加输出日志文件名log += "[";log += file_name;log += "]";// 添加日志行号log += "[";log += std::to_string(line);log += "]";// 添加当前日志时间戳log += "(";log += TimeUtil::GetTimeStamp();log += ") ";std::cout << log;  // 不使用endl进行刷新，利用缓冲区 开放式日志文件return std::cout;}// 利用宏定义完善一点 - LOG(INFO) << "一切正常\n";#define LOG(level) Log(#level, __FILE__, __LINE__)
}
#endif

    // 时间相关类class TimeUtil{public:static std::string GetTimeStamp(){// 使用系统调用gettimeofdaystruct timeval t;gettimeofday(&t, nullptr);  // 获取时间戳的结构体、时区return std::to_string(t.tv_sec);}}

    // 文件相关类class FileUtil{public:// 判断传入文件（完整路径）是否存在static bool IsFileExist(const std::string& pathFile){// 使用系统调用stat查看文件属性，查看成功说明存在文件，否则没有struct stat st;if (stat(pathFile.c_str(), &st) == 0){// 说明存在文件return true;}return false;  // 否则不存在此文件}}

#ifndef __COMPILER_HPP__
#define __COMPILER_HPP__
// 编译模块
#include <iostream>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include "../common/util.hpp"
#include "../common/log.hpp"namespace ns_compiler
{using namespace ns_util;using namespace ns_log;class Compiler{public:Compiler(){}~Compiler(){}// 编译函数  编译临时文件// 输入：需要编译的临时文件名（存在./temp/文件名.cpp文件，不需要带cpp/cc后缀）// 输出：编译成功true，false失败static bool compile(std::string &file_name){pid_t childPid = fork();if (childPid < 0){// 子进程创建失败LOG(ERROR) << "内部错误，当前子进程无法创建" << "\n";return false;}if (childPid == 0){// 子进程// 如果编译失败，需要将错误信息输入到错误文件内，利用重定向umask(0);  // 防止平台的影响，影响文件权限int errFd = open(PathUtil::CompileError(file_name).c_str(), O_CREAT | O_WRONLY, 0644);  // rw_r__r__if (errFd < 0){// 异常，终止程序LOG(ERROR) << "内部错误，错误输出文件打开/创建失败" << "\n";exit(1);}// 打开成功重定向dup2(errFd, 2);  // 将标准错误重新向到错误文件内，这样出错就可以将错误信息写入其中execlp("g++", "g++", "-o", PathUtil::Exe(file_name).c_str(), PathUtil::Src(file_name).c_str(), "-D", "COMPILE_ONLINE", NULL);  // p默认从环境变量下搜索LOG(ERROR) << "g++执行失败，检查参数是否传递正确" << "\n";exit(2);  // 如果执行这一步说明上面的exec程序替换函数执行失败}// 父进程waitpid(childPid, nullptr, 0);  // 阻塞等待子进程// 判断是否编译成功可以根据是否生成exe可执行文件进行判断if (FileUtil::IsFileExist(PathUtil::Exe(file_name))){// .exe文件存在LOG(INFO) << "编译成功！" << "\n";return true;  // 编译成功}LOG(ERROR) << "编译失败！" << "\n";return false;  // exe文件不存在，编译失败}};
}#endif

​

        // 运行临时文件// 拼接保存标准输入文件static std::string Stdin(const std::string& file_name){return splic(file_name, ".stdin");}// 拼接保存标准输出文件static std::string Stdout(const std::string& file_name){return splic(file_name, ".stdout");}// 拼接保存标准错误文件static std::string Stderr(const std::string& file_name){return splic(file_name, ".stderr");}

#ifndef __RUNNER_HPP__
#define __RUNNER_HPP__
// 运行模块
#include <string>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.h>
#include "../common/util.hpp"
#include "../common/log.hpp"namespace ns_runner
{using namespace ns_util;using namespace ns_log;class Runner{public:Runner() {}~Runner() {}public:// 资源限制接口// cpu_limit时间限制s  men_limit空间限制KBstatic void SetProCLimit(int cpu_limit, int mem_limit){// 时间限制struct rlimit cpuLimit;cpuLimit.rlim_max = RLIM_INFINITY;cpuLimit.rlim_cur = cpu_limit;setrlimit(RLIMIT_CPU, &cpuLimit);// 空间限制struct rlimit memLimit;memLimit.rlim_max = RLIM_INFINITY;memLimit.rlim_cur = mem_limit * 1024;  // byte->kbsetrlimit(RLIMIT_AS, &memLimit);}// 运行模块// 输入可执行文件名 在temp目录下的.exe文件// 返回值：0表示运行成功、<0表示内部错误，>0表示运行出错// 时间限制：cpu_limit  空间限制：men_limit// 返回值： <0 内部错误 =0运行成功，成功写入stdout等文件 >0运行中断，用户代码存在问题static int Run(const std::string& file_name, int cpu_limit, int mem_limit){// 在父进程中先将运行所需要的三个临时文件打开int _stdin  = open(PathUtil::Stdin(file_name).c_str(), O_CREAT | O_RDONLY, 0644);int _stdout = open(PathUtil::Stdout(file_name).c_str(), O_CREAT | O_WRONLY, 0644);int _stderr = open(PathUtil::Stderr(file_name).c_str(), O_CREAT | O_WRONLY, 0644);// 打开文件进行差错处理if (_stdin < 0 || _stdout < 0 || _stderr < 0){// 文件打不开运行程序没有意义了LOG(ERROR) << "内部错误, 标准文件打开/创建失败" << "\n";return -1;}pid_t childPid = fork();if (childPid < 0){// 创建子进程失败// 创建失败，打开的文件需要收回-否则占用无效资源！close(_stdin);close(_stdout);close(_stderr);LOG(ERROR) << "内部错误, 创建子进程失败" << "\n";return -2;}if (childPid == 0){// 子进程// 资源限制SetProCLimit(cpu_limit, mem_limit);dup2(_stdin, 0);dup2(_stdout, 1);dup2(_stderr, 2);execl(PathUtil::Exe(file_name).c_str(), PathUtil::Exe(file_name).c_str(), nullptr);  // execl函数，不从环境变量下找，直接根据路径找可执行文件 路径、可执行文件exit(-1);  // 程序替换出错}// 父进程close(_stdin);close(_stdout);close(_stderr);//父进程等待子进程，查看返回情况int status;  //输出参数，接收状态信息waitpid(childPid, &status, 0);  // 阻塞等待if (status < 0){//信号不等于0说明执行失败LOG(ERROR) << "内部错误, execl参数或者路径不正确" << status << "\n";return status;}else LOG(INFO) << "运行完毕！退出码为: " << (status & 0x7F)<< "\n";return (status & 0x7F);}};
}#endif

{"code": code,"input": input,"cpu_limit": S,"mem_limit": kb
}

        // 获取毫秒级时间戳static std::string GetTimeMs(){struct timeval t;gettimeofday(&t, nullptr);return std::to_string((t.tv_sec * 1000 + t.tv_usec / 1000)); // 秒+微秒}//......// 生成唯一的文件名// 利用微秒时间戳和原子性的唯一增长数字组成static std::string UniqueFileName(){// 利用C++11的特性，生成一个原子性的计数器static std::atomic_uint id(0);id++;std::string ms = TimeUtil::GetTimeMs();return ms + "-" + std::to_string(id);}

        // 根据路径文件进行写入static bool WriteFile(const std::string& path_file, const std::string& content){// 利用C++的文件流进行简单的操作std::ofstream out(path_file);// 判断此文件是否存在if (!out.is_open()) return false;out.write(content.c_str(), content.size());out.close();return true;}// 根据路径文件进行读出// 注意，默认每行的\\n是不进行保存的，需要保存请设置参数static std::string ReadFile(const std::string& path_file, bool keep = false){// 利用C++的文件流进行简单的操作std::string content, line;std::ifstream in(path_file);if (!in.is_open()) return "";while (std::getline(in, line)){content += line;if (keep) content += "\n";}in.close();return content;}

{"status": status,"reason": reason,"stdout": stdout,"stderr": stderr
}

​

#ifndef __COMPILE_RUN_HPP__
#define __COMPILE_RUN_HPP__
// 编译运行整合模块#include <unistd.h>
#include <jsoncpp/json/json.h>
#include "compiler.hpp"
#include "runner.hpp"
#include "../common/util.hpp"
#include "../common/log.hpp"namespace ns_compile_and_run
{using namespace ns_compiler;using namespace ns_runner;using namespace ns_log;using namespace ns_util;class CompileAndRun{public:// 删除临时文件static void RemoveFile(const std::string& file_name){// 因为临时文件的存在情况存在多种，删除文件采用系统接口unlink，但是需要判断std::string src_path = PathUtil::Src(file_name);if (FileUtil::IsFileExist(src_path)) unlink(src_path.c_str());std::string stdout_path = PathUtil::Stdout(file_name);if (FileUtil::IsFileExist(stdout_path)) unlink(stdout_path.c_str());std::string stdin_path = PathUtil::Stdin(file_name);if (FileUtil::IsFileExist(stdin_path)) unlink(stdin_path.c_str());std::string stderr_path = PathUtil::Stderr(file_name);if (FileUtil::IsFileExist(stderr_path)) unlink(stderr_path.c_str());std::string compilererr_path = PathUtil::CompileError(file_name);if (FileUtil::IsFileExist(compilererr_path)) unlink(compilererr_path.c_str());std::string exe_path = PathUtil::Exe(file_name);if (FileUtil::IsFileExist(exe_path)) unlink(exe_path.c_str());}// 根据不同的状态码进行解析结果输入信息// > 0 运行中断  6-内存超过范围、24-cpu使用时间超时、8-浮点数溢出（除0异常）// = 0 运行成功// < 0 整个过程，非运行报错（内部错误、编译报错、代码为空）static std::string CodeToDesc(int status, const std::string& file_name){std::string desc;switch(status){case 0:desc = "运行成功！";break;case -1:desc = "代码为空";break;case -2:desc = "未知错误";break;case -3:desc = "编译报错\n";desc += FileUtil::ReadFile(PathUtil::CompileError(file_name), true);break;case 6:desc = "内存超过范围";break;case 24:desc = "时间超时";break;case 8:desc = "浮点数溢出";break;case 11:desc = "野指针错误";break;default:desc = "未处理的报错-status为:" + std::to_string(status);break;}return desc;}/************************ 编译运行模块* 输入：in_json输入序列化串  *out_json 输出序列化串(输出参数)* 输出* in_json  {"code":..., "input":..., "cpu_limit":..., "mem_limit":...}* out_json {"status":..., "reason":...[, "stdout":..., "stderr":...]}***********************/static void Start(const std::string& in_json, std::string* out_json){std::string code, input, file_name;int cpu_limit, mem_limit;  // s, kbint status, run_reason;  // 状态码, 运行返回码// 首先反序列化in_json,提取信息Json::Value in_value;Json::Reader read;read.parse(in_json, in_value);  // 序列化可能出问题code = in_value["code"].asString();input = in_value["input"].asString();cpu_limit = in_value["cpu_limit"].asInt();mem_limit = in_value["mem_limit"].asInt();// 首先检测code是否存在数据if(code.empty()){status = -1;  // 用户错误goto END;}// 首先生成唯一的临时文件名file_name = FileUtil::UniqueFileName();// code写入文件if(!FileUtil::WriteFile(PathUtil::Src(file_name), code)){// 如果写入失败，内部报错status = -2;goto END;}// 写入文件成功的话，我们进行编译步骤if (!Compiler::compile(file_name)){status = -3;  // 编译失败，导入结果compile_errorgoto END;}// 将input标准输入写入文件if(!FileUtil::WriteFile(PathUtil::Stdin(file_name), input)){// 如果写入失败，内部报错status = -2;goto END;}// 编译步骤成功，我们进行运行步骤run_reason = Runner::Run(file_name, cpu_limit, mem_limit);if (run_reason < 0){// 内部错误status = -2;}else{// 运行成功或者中断status = run_reason;}END:// 构建返回序列化串Json::Value out_value;out_value["status"] = status;out_value["reason"] = CodeToDesc(status, file_name);  // 需要接口// 如果运行成功，那么构建可选字段if (status == 0){out_value["stdout"] = FileUtil::ReadFile(PathUtil::Stdout(file_name), true);out_value["stderr"] = FileUtil::ReadFile(PathUtil::Stderr(file_name), true);}Json::StyledWriter write;*out_json = write.write(out_value);RemoveFile(file_name);}};
}#endif

#include "compile_run.hpp"
#include "../common/httplib.h"using namespace ns_compile_and_run;
using namespace httplib;void User(char * use)
{std::cout << "User:" << "\n\t";std::cout << use << " port" << std::endl;
}int main(int argc, char* argv[])
{if (argc != 2){// 满足传递 ./ portUser(argv[0]);return 1;}// 将我们的编译运行服务打包为网络服务 - 为负载均衡做准备Server svr;svr.Get("/hello", [](const Request& req, Response& resp){resp.set_content("你好呀，这里是编译运行服务，访问服务请访问资源/compile_and_run", "text/plain;charset=utf-8");});  // 请求资源svr.Post("/compile_and_run", [](const Request& req, Response& resp){// 首先提取用户提交的json串std::string in_json = req.body;std::string out_json;// 判断json串是空的吗？空的拒绝服务if(!in_json.empty())CompileAndRun::Start(in_json, &out_json);// 返回out_json串给客户端resp.set_content(out_json, "application/json;charset=utf-8");});  // 提交json串，返回json串// 注册运行svr.listen("0.0.0.0", atoi(argv[1]));return 0;
}

​

int main()
{Server svr;  // 服务器对象
}

    // 1.用户获取题目列表数据svr.Get("/all_questions", [&ctl](const Request& req, Response& resp){// 扩至模块返回后构建渲染网页返回resp});

    // 2.用户获取单题题目内容svr.Get(R"(/question/(\d+))", [&ctl](const Request& req, Response& resp){  // (\\d+是正则表达式)std::string number = req.matches[1];  // 1对应的就是获取正则表达式中的内容// 控制模块返回结果构建渲染单个题目的网页返回resp});

    // 3.用户获取单体解析结果svr.Post(R"(/judge/(\d+))", [&ctl](const Request& req, Response& resp){std::string number = req.matches[1];  // 1对应的就是获取正则表达式中的内容// 控制模块返回结果的json串，返回给resp});

    // 设置根目录svr.set_base_dir("./wwwroot");// 监听全体网卡，端口号固定8080svr.listen("0.0.0.0", 8080);

class UnusualAdd {
public:int addAB(int A, int B) {}
};

#ifndef COMPILE_ONLINE
#include "header.cpp"  // 条件编译，引入头文件只是为了不报错和语法提示，之后会进行拼接
#endifvoid test1(UnusualAdd& use1)
{// 测试用例1int sum = use1.addAB(1, 1);if (sum == 2){cout << "测试用例1通过!" << endl; }else cout << "测试用例1没有通过"<< "1 + 1" << endl;
}void test2(UnusualAdd& use2)
{// 测试用例2int sum = use2.addAB(1, -1);if (sum == 0){cout << "测试用例2通过!" << endl; }else cout << "测试用例2没有通过" << "1 + (-1)" << endl;
}int main()
{UnusualAdd ues;test1(ues);test2(ues);return 0;
}

​

    // 字符串相关工具类class StringUtil{public:// 切割字符串，保存入vector中static void SpiltString(const std::string& src, std::vector<std::string>& target, std::string op){boost::split(target, src, boost::is_any_of(op), boost::algorithm::token_compress_on);  // 数组、遇到对应分隔符全部切割 压缩（切割出来的空串删除）}};

#ifndef __OJ_MODEL_HPP__
#define __OJ_MODEL_HPP__
// OJ题库与数据交互
#include <iostream>
#include <unordered_map>
#include <string>
#include <fstream>
#include <cstring>#include "../common/util.hpp"
#include "../common/log.hpp"// 文件版本
namespace ns_model
{using namespace ns_util;using namespace ns_log;// 每一个题目独享的内存细节struct Question{std::string number;  // 题目编号std::string title;  // 题目标题std::string star;  // 题目难度int cpu_commit;  // 运行时间限制Sint mem_commit;  // 内存占用限制KBstd::string desc;  // 文件描述std::string header;  // 用户预设代码std::string tail;  // 测试代码};class Model{const std::string questions_path = "./questions/question.list";private:std::unordered_map<std::string, Question> _map;public:Model(){// 题库信息加载入内存assert(LoadQuestionlist(questions_path));}~Model(){}// 开始加载题库入内存bool LoadQuestionlist(const std::string& path)  // 题库文件questions的路径{std::ifstream in(path);if (!in.is_open()){// 此时致命错误-影响全部，检查文件路径LOG(FATAL) << "题库配置文件未能打开，请检查相关路径或者文件是否存在" << "\n";return false;}std::string line;while (std::getline(in, line)){if (line[0] == '#') continue;  // 注释行跳过// 对于配置的一行，我们需要进行字符串分割std::vector<std::string> target;StringUtil::SpiltString(line, target, " ");if (target.size() != 6){// 此时当前配置行存在误输，警告LOG(WARING) << line[0] << "编号配置文件出错" << "\n"; continue;}Question q;q.number = target[0];q.title = target[1];q.star = target[2];q.cpu_commit = atoi(target[3].c_str());q.mem_commit = atoi(target[4].c_str());q.desc = FileUtil::ReadFile(target[5] + "/desc.txt", true);q.header = FileUtil::ReadFile(target[5] + "/header.cpp", true);q.tail = FileUtil::ReadFile(target[5] + "/tail.cpp", true);if (q.desc == "" || q.header == "" || q.tail == ""){// 当前记录文件读取失败！或者无记录，那么就无效，不纳入统计LOG(WARING) << "检查编号" << line[0] << "文件目录下文件是否录入成功或者填写信息" << "\n"; LOG(DEBUG) <<  target[5] << "\n";continue;}_map[target[0]] = q;  // 保存记录}in.close();LOG(INFO) << "题库录入内存成功！" << "\n";return true;}// 获取当前题目列表信息bool GetAllQuestions(std::vector<Question>& v){if (_map.empty()){// 当前内存题目信息为空，获取失败LOG(ERROR) << "当前用户获取题目信息失败，内存中不存在题目信息记录" << "\n";return false;}for (auto& s : _map){v.push_back(s.second);}return true;}// 获取单个题目信息，给我number// 已经提供日志差错处理bool GetOneQuestion(const std::string& number, Question& q){auto it = _map.find(number);if (it == _map.end()){// 提供的number不存在当前题库中LOG(ERROR) << "当前用户获取题目信息失败，内存中不存在此题目信息记录" << "\n";return false;}q = it->second;return true;}};
}#endif

create user 'oj_client'@'%' identified by '123456';  --创建用户，任意ip登录，密码--root建库
create database oj;
--root赋权
grant all on oj.* to 'oj_client'@'%';  -- 赋予oj_clinet@%用户oj数据库的所有权限--创建question表，表结构设计出来
use oj;
create table oj_questions(number int primary key auto_increment comment '题目的编号',title varchar(128) not null comment '题目的标题',star char(2) not null, `desc` text not null comment '题目的描述',header text not null comment '预设给用户看的代码',tail text comment '对应题目的测试用例代码',cpu_limit int default 1 comment '对应题目的时间限制',mem_limit int default 50000 comment '对应题目的最大空间' 
)engine=innoDB default charset=utf8;

​

​

#ifndef __OJ_MODEL_HPP__
#define __OJ_MODEL_HPP__
// OJ题库与数据交互
#include <iostream>
#include <unordered_map>
#include <string>
#include <fstream>
#include <cstring>
#include "./mysql-connect/include/mysql.h"// 引用c-mysql-connect#include "../common/util.hpp"
#include "../common/log.hpp"// mysql版本
namespace ns_model
{using namespace ns_util;using namespace ns_log;// 每一个题目独享的内存细节struct Question{std::string number;  // 题目编号std::string title;  // 题目标题std::string star;  // 题目难度int cpu_commit;  // 运行时间限制Sint mem_commit;  // 内存占用限制KBstd::string desc;  // 文件描述std::string header;  // 用户预设代码std::string tail;  // 测试代码};const std::string oj_table_name = "oj_questions";const std::string oj_host = "自己的公网ip";const std::string oj_user = "oj_client";const std::string oj_password = "123456";const std::string oj_db = "oj";const unsigned int oj_port = 3306;class Model{public:Model(){}~Model(){}// 执行sql语句处bool QueryMySql(const std::string& sql, std::vector<Question>& v){// c连接mysql库，创建mysql对象-初始化mysql句柄MYSQL* oj_client = mysql_init(nullptr);// 连接数据库，连接失败返回nullptrif (nullptr == mysql_real_connect(oj_client, oj_host.c_str(), oj_user.c_str(), oj_password.c_str(), oj_db.c_str(), oj_port, nullptr, 0)){// 表示连接数据库失败LOG(FATAL) << "数据库连接失败！请尽快联系数据库管理员....." << "\n";return false;}// 连接成功后先执行编码格式mysql_set_character_set(oj_client, "utf8");// 连接成功后执行语句int result = mysql_query(oj_client, sql.c_str());if (result != 0){// 执行失败LOG(WARING) << "当前sql执行失败: " << sql << " \n";return false;}// 执行成功，提取数据MYSQL_RES* res = mysql_store_result(oj_client);// 解析数据int rows = mysql_num_rows(res);  // 获取行数int fields = mysql_num_fields(res);  // 获取列数// 读取每一个元组，提取每一个元组的九个属性for (int i = 0; i < rows; ++i){MYSQL_ROW line = mysql_fetch_row(res);Question q;q.number = line[0];q.title = line[1];q.star = line[2];q.cpu_commit = atoi(line[3]);q.mem_commit = atoi(line[4]);q.desc = line[5];q.header = line[6];q.tail = line[7];v.push_back(q);}// LOG(DEBUG) << "正常访问数据库成功..." << "\n";return true;}// 获取当前题目列表信息bool GetAllQuestions(std::vector<Question>& v){std::string sql = "select * from ";sql += oj_table_name;return QueryMySql(sql, v);}// 获取单个题目信息，给我number// 已经提供日志差错处理bool GetOneQuestion(const std::string& number, Question& q){std::string sql = "select * from ";sql += oj_table_name;sql += " where number=";sql += number;std::vector<Question> v;if (QueryMySql(sql, v)){if (v.size() == 1){// 只能存在一个记录q = v[0];return true;}}return false;}};
}#endif

namespace ns_contol
{class Control{private:Model _model;  // 数据对象View _view;  // 渲染对象public:Control(){}~Control(){}// 从题库中获取题目信息(model)，渲染成网页返回(view)bool AllQuestions(std::string& html){std::vector<Question> v;if (_model.GetAllQuestions(v)){// 对数组进行排序std::sort(v.begin(), v.end(), [](Question& q1, Question& q2){return atoi(q1.number.c_str()) < atoi(q2.number.c_str());});// 成功，根据获取的信息渲染网页_view.AllExpandHtml(v, html);  // 后面完成return true;}else{// 获取题目列表失败return false;}}}
}

    // 1.用户获取题目列表数据svr.Get("/all_questions", [&ctl](const Request& req, Response& resp){std::string html;ctl.AllQuestions(html);resp.set_content(html, "text/html;charset=utf8");});

        // 根据题目编号获取单个题目细节信息，渲染成网页进行返回bool OneQuestion(const std::string& number, std::string& html){Question q;if (_model.GetOneQuestion(number, q)){// 成功，根据题目文件渲染为网页_view.OneExpandHtml(q, html);return true;}else{// 查无此物return false;}}

    // 2.用户获取单题题目内容svr.Get(R"(/question/(\d+))", [&ctl](const Request& req, Response& resp){  // (\\d+是正则表达式)std::string number = req.matches[1];  // 1对应的就是获取正则表达式中的内容std::string html;ctl.OneQuestion(number, html);resp.set_content(html, "text/html;charset=utf8");});

// 用户通过浏览器上传的json数据
{"code": code,"input":  ,
}// 凭借好准备发送给compile_server的json串数据
{"code": code+q.tail,"input":  ,"cpu_limit": q.cpu_limit,"mem_limit": q.mem_limit,
}
// 注意上面的q为Question对象，根据路由传上来的题目编号决定，通过model模块获取

    class Machine{public:std::string ip;  // 编译服务主机ipuint16_t port;  // 编译服务主机端口private:uint64_t _load;  // 当前主机负载 - 使用个数std::mutex* _mtx;  // 当前主机锁，保护对负载数的安全public:// 构造一个主机对象，给定ip和port。为之后的连接编译服务做准备Machine(const std::string& ip_ = "", uint16_t port_ = 0):ip(ip_), port(port_), _load(0), _mtx(nullptr){if (ip_ != "" && port_ != 0) _mtx = new std::mutex();}~Machine(){}// 对负载进行递增 - 可能存在多个对象对此主机对象进行操作，必须保证原子性void IncLoad(){if (_mtx){_mtx->lock();++_load;_mtx->unlock();}}// 对负载进行递减void DecLoad(){if (_mtx){_mtx->lock();--_load;_mtx->unlock();}}// 获取当前主机负载uint64_t Load(){uint64_t load = 0;if (_mtx){_mtx->lock();load = _load;_mtx->unlock();}return load;}// 清空当前负载void ClearLoad(){if (_mtx){_mtx->lock();_load = 0;_mtx->unlock();}}};

    // 负载均衡模块class LoadBlance{const std::string confPath = "./conf/server_machine.conf";private:std::vector<Machine> _machines;  // 存放全体主机对象的地方， 包括离线和在线的主机，下标对应主机编号std::vector<int> _online;  // 存放在线主机的地方std::vector<int> _offline;  // 存放离线主机的地方 std::mutex _mtx;// 保证在智能选择或者对数据查询时出现不可重入，保证负载均衡数据安全public:LoadBlance(){assert(LoadConf(confPath));LOG(INFO) << "编译服务主机配置设置成功..." << "\n";}~LoadBlance(){}// 加载编译服务主机入内存bool LoadConf(const std::string& path_conf){std::ifstream in(path_conf);if (!in.is_open()){LOG(FATAL) << "加载主机配置文件失败, 请检查server_machine.conf文件的相关配置路径..." << "\n";return false;}std::string line;  // 一行一行的读取while(std::getline(in, line)){std::vector<std::string> machines;StringUtil::SpiltString(line, machines, ":");if (machines.size() != 2){LOG(WARING) << "当前行配置文件出错：" << line << "...\n";continue;}Machine m(machines[0], atoi(machines[1].c_str()));// 先加载入在线主机数组_online.push_back(_machines.size());_machines.push_back(m);}in.close();return true;}// 负载均衡选择，轮询查询，找到当前负载最小的编译服务主机// 参数id为主机编号，m为主机对象，均为输出型参数bool SmartChoice(int& id, Machine** m){_mtx.lock();// 首先检测当前主机是否存在在线if (_online.size() == 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.size(); ++i){uint64_t load = _machines[_online[i]].Load();if (min_load > load){id = _online[i];*m = &_machines[_online[i]];min_load = load;              }}_mtx.unlock();return true;}// 离线指定id主机void OfflineMachine(int which){// 操作数据的时候，避免线程安全问题，加锁_mtx.lock();// 从在线列表中退出，加入离线列表for (auto it = _online.begin(); it != _online.end(); ++it){if (*it == which){// 找到了，退出online，加入offline_online.erase(it);  // 注意删除后存在迭代器失效问题_offline.push_back(which);  // 添加即可break;}}_machines[which].ClearLoad();  // 离线清空负载情况_mtx.unlock();}// 上线主机void OnlineMachine(){// 上线主机默认全部上线_online.insert(_online.end(), _offline.begin(), _offline.end());_offline.clear();  // 清空LOG(INFO) << "当前主机全部上线！" << "\n";}// debug 展示当前在线主机和离线主机 - compile_run server服务void ShowMachines(){// 访问数据上锁访问哦_mtx.lock();std::cout << "当前在线主机id: ";for (auto i : _online){std::cout << i << " ";}std::cout << std::endl;std::cout << "当前离线主机id: ";for (auto i : _offline){std::cout << i << " ";}std::cout << std::endl;_mtx.unlock();}};

        // 重新上线主机void AllOnLineMachine(){_load_blance.OnlineMachine();}/*******************************         判题功能judge* 1.number 题目编号* 2.in_json 用户提交的json串，包含写过的code代码、以及input输入* 3.out_json 最后返回给调用的串，结果为compile_run服务的结果 - 输出型参数* 本模块根据配置文件负载均衡选择后端的compile_run服务，实现oj功能*******************************/void Judge(const std::string& number, const std::string& in_json, std::string& out_json){// LOG(DEBUG) << in_json << "\n";Question q;if (!_model.GetOneQuestion(number, q)) return;// 待提交给后端编译服务的json串std::string result_json;// 1.反序列化Json::Value in;Json::Reader read;read.parse(in_json, in);// 2.现在开始序列化 根据题目细节和用户提交的code拼接给后端编译服务提交的json串Json::Value out;Json::FastWriter write;// 后续测试运行会有扩展out["code"] = in["code"].asString() + "\n" + q.tail;  // 拼接代码out["input"] = in["input"].asString();out["cpu_limit"] = q.cpu_commit;out["mem_limit"] = q.mem_commit;result_json = write.write(out);// 3. 负载均衡模块，选择一台服务主机进行发送，接收消息// 因为存在选择一台主机发送消息可能得不到消息，所以决定循环式的发送消息，直到主机全部挂掉或者得到消息为止while(true){int machine_id;Machine* m = nullptr;if (!_load_blance.SmartChoice(machine_id, &m)) break;  // 此时全体挂掉了// 发起http请求httplib::Client cli(m->ip, m->port);// 注意，请求是需要时间的并且是阻塞式的，同时间内可能会来多个请求，那么需要怎加负载进行访问m->IncLoad();LOG(INFO) << "主机编号为:" << machine_id << " 详细信息ip:" << m->ip << " port:" << m->port << " 当前负载:" << m->Load() << "\n";if (auto res = cli.Post("/compile_and_run", result_json, "application/json;charset=utf-8"))  // 注意res重载了bool，如果没有返回一个响应对象会显示false{// 得到响应了// 先判断是不是正确的响应if(res->status == 200){out_json = res->body;  // post json串在body内m->DecLoad();  // 别忘了减少负载LOG(INFO) << "请求编译运行服务成功..." << "\n";break;}}else{// 没有得到响应，说明此服务器可能挂掉了，加载入离线主机m->DecLoad();LOG(ERROR) << "主机编号:" << machine_id << "详细信息ip:" << m->ip << " port:" << m->port << "可能已经离线....." << "\n";_load_blance.OfflineMachine(machine_id);_load_blance.ShowMachines();}}}