【C++项目】负载均衡oj

​

​

​

​

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;
        }
 
        // 编译临时文件
        // 拼接源文件 文件名+cpp
        static std::string Src(const std::string& file_name)
        {
            return splic(file_name, ".cpp");
        }
 
        // 拼接可执行文件 文件名+exe
        static 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";
//         }
// #endif
        std::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()
        {
            // 使用系统调用gettimeofday
            struct 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 
#include 
#include 
#include 
#include 
#include 
#include 
#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 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#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空间限制KB
        static 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->kb
            setrlimit(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 
#include 
#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, kb
            int 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_error
                goto 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)
    {
        // 满足传递 ./ port
        User(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");
    // 监听全体网卡，端口号固定8080
    svr.listen("0.0.0.0", 8080);

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

#ifndef COMPILE_ONLINE
#include "header.cpp"  // 条件编译，引入头文件只是为了不报错和语法提示，之后会进行拼接
#endif
 
void test1(UnusualAdd& use1)
{
    // 测试用例1
    int sum = use1.addAB(1, 1);
    if (sum == 2)
    {
        cout << "测试用例1通过!" << endl; 
    }
    else cout << "测试用例1没有通过"<< "1 + 1" << endl;
}
 
void test2(UnusualAdd& use2)
{
    // 测试用例2
    int 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& 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 
#include 
#include 
#include 
#include 
 
#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;  // 运行时间限制S
        int mem_commit;  // 内存占用限制KB
 
        std::string desc;  // 文件描述
        std::string header;  // 用户预设代码
        std::string tail;  // 测试代码
    };
 
    class Model
    {
        const std::string questions_path = "./questions/question.list";
    private:
        std::unordered_map _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 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& 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 
#include 
#include 
#include 
#include 
#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;  // 运行时间限制S
        int mem_commit;  // 内存占用限制KB
 
        std::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& v)
        {
            // c连接mysql库，创建mysql对象-初始化mysql句柄
            MYSQL* oj_client = mysql_init(nullptr);
            // 连接数据库，连接失败返回nullptr
            if (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& 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 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 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;  // 编译服务主机ip
        uint16_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 _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 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();
        }
    };