• 基于负载均衡的在线OJ实战项目

    前言：

    该篇讲述了实现基于负载均衡式的在线oj，即类似在线编程做题网站一样，文章尽可能详细讲述细节即实现，便于大家了解学习。

    文章将采用单篇不分段形式（ps：切着麻烦），附图文，附代码，代码部署在云服务器上

    技术栈

    • C++ STL标准库

    • Boost 标准库

    • cpp-httpib 开源库

    • ctemplate 第三方开源前端网页渲染库

    • jsoncpp 第三方开源序列化、反序列化库

    • 负载均衡的设计

    • 多进程、多线程

    • MYSQL C connect

    • Ace前端在线编辑器

    • html/cdd/js/jquery/ajax

    开发环境

    • vscode
    • mysql workbench
    • Centos 7云服务器

    宏观结构

    • comm:公共模块
    • compile_sever:编译运行模块
    • oj_server：获取题目，负载均衡等

    376d0cae8c104c84b622c10cc9de0693.png

     

     

    项目演示： 


    https://blog.csdn.net/Obto_/article/details/132558642?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22132558642%22%2C%22source%22%3A%22Obto_%22%7Dhttps://blog.csdn.net/Obto_/article/details/132558642?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22132558642%22%2C%22source%22%3A%22Obto_%22%7D

     

    项目设计 -- 编译服务

    工具类的准备：

    供程序中各个部分调用的方法类：

    1. #pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. namespace ns_util
    14. {
    15.     class TimeUtil
    16.     {
    17.     public:
    18.         static std::string GetTimeStamp()
    19.         {
    20.             // 获取时间戳 gettimeofday
    21.             struct timeval _time;
    22.             gettimeofday(&_time, nullptr);
    23.             return std::to_string(_time.tv_sec);
    24.         }
    25.         // 获得毫秒时间戳
    26.         static std::string GetTimeMs()
    27.         {
    28.             struct timeval _time;
    29.             gettimeofday(&_time, nullptr);
    30.             return std::to_string(_time.tv_sec * 1000 + _time.tv_usec / 1000);
    31.         }
    32.     };
    33.  
    34.     const std::string temp_path = "./temp/";
    35.     class PathUtil
    36.     {
    37.     public:
    38.         static std::string AddSuffix(const std::string &file_name, const std::string &suffix)
    39.         {
    40.             std::string path_name = temp_path;
    41.             path_name += file_name;
    42.             path_name += suffix;
    43.             return path_name;
    44.         }
    45.         // 构建源文件路径+后缀的完整文件名
    46.         // 1234 -> ./temp/1234.cpp
    47.         static std::string Src(const std::string &file_name)
    48.         {
    49.             return AddSuffix(file_name, ".cpp");
    50.         }
    51.         // 构建可执行程序的完整路径 + 后缀名
    52.         static std::string Exe(const std::string &file_name)
    53.         {
    54.             return AddSuffix(file_name, ".exe");
    55.         }
    56.         static std::string CompilerError(const std::string &file_name)
    57.         {
    58.             return AddSuffix(file_name, ".compile_stderr");
    59.         }
    60.         //-------------------------------------------------------------------
    61.         // 构建该程序对应的标准错误完整的路径+后缀名
    62.         static std::string Stderr(const std::string &file_name)
    63.         {
    64.             return AddSuffix(file_name, ".stderr");
    65.         }
    66.         static std::string Stdin(const std::string &file_name)
    67.         {
    68.             return AddSuffix(file_name, ".stdin");
    69.         }
    70.         static std::string Stdout(const std::string &file_name)
    71.         {
    72.             return AddSuffix(file_name, ".stdout");
    73.         }
    74.     };
    75.  
    76.     class FileUtil
    77.     {
    78.     public:
    79.         static bool IsFileExists(const std::string &path_name)
    80.         {
    81.             struct stat st;
    82.             if (stat(path_name.c_str(), &st) == 0)
    83.             {
    84.                 // 获取属性成功，文件已经存在
    85.                 return true;
    86.             }
    87.             return false;
    88.         }
    89.         static std::string UniqFileName()
    90.         {
    91.             static std::atomic_uint id(0);
    92.             id++;
    93.             // 毫秒时间戳
    94.             std::string ms = TimeUtil::GetTimeMs();
    95.             std::string uniq_id = std::to_string(id);
    96.             return ms + "_" + uniq_id;
    97.         }
    98.         static bool WriteFile(const std::string &target, const std::string &content)
    99.         {
    100.             // waiting
    101.             std::ofstream out(target);
    102.             if (!out.is_open())
    103.             {
    104.                 return false;
    105.             }
    106.             out.write(content.c_str(), content.size());
    107.             out.close();
    108.             return true;
    109.         }
    110.         static bool ReadFile(const std::string &target, std::string *content, bool keep = false)
    111.         {
    112.             (*content).clear();
    113.             std::ifstream in(target);
    114.             if (!in.is_open())
    115.             {
    116.                 return false;
    117.             }
    118.             std::string line;
    119.             // getline是按行保存的，不保存行分隔符,自动去掉\n
    120.             // 但是有些时候，需要保留行分隔符
    121.             // getline内部重载了强制类型转化
    122.             while (std::getline(in, line))
    123.             {
    124.                 (*content) += line;
    125.                 (*content) += (keep ? "\n" : "");
    126.             }
    127.             in.close();
    128.             return true;
    129.         }
    130.     };
    131.  
    132.     class StringUtil
    133.     {
    134.         public:
    135.         /*
    136.         str：输入型，目标要切分的字符串
    137.         target：输出型，保存切分完毕的结果
    138.         sep：指定的分隔符
    139.         */
    140.         static void SplitString(const std::string &str,std::vector *target,std::string sep)
    141.         {
    142.             boost::split(*target,str,boost::is_any_of(sep),boost::algorithm::token_compress_on);
    143.             //boost split
    144.         }
    145.     };
    146.  
    147. }
    • PathUtil：路径工具
      • 形成exe完整路径
      • 形成cpp完整路径
      • 形成compile_stderr完整路径
      • 形成stderr完整路径
      • 形成stdin完整路径
      • 完整路径指的是当前代码在本地上的保存路径：即输入 1234 要形成 ./temp/1234.cpp等这里的相对路径形成依靠PathUtil工具
    • TimeUtil：时间工具
      • 获取时间戳 get time of day
      • 获得好面时间戳，用于形成文件唯一标识（名字）
    • FileUtil：文件工具
      • IsFileExits：判断某文件是否存在
      • UniqFileName：形成文件唯一名字
      • WriteFile：向指定文件写入指定字符串
      • ReadFile：读取某文件的内容
    • StringUtil：字符串工具
      • 使用boost库中的切分字符串Split()

     

    compiler编译服务设计 ：

    目的：能够编译并运行代码，得到格式化的相关结果

    bcc25d727a6e4f8f9fbb337b5612453d.png

     

    1. #pragma once
    2.  
    3. #include 
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include"../comm/util.hpp"
    10. #include"../comm/log.hpp"
    11. //只负责进行代码的编译
    12. namespace ns_compiler{
    13.     //引入路径拼接功能
    14.     using namespace ns_util;
    15.     using namespace ns_log;
    16.     class Compiler{
    17.         public:
    18.         Compiler()
    19.         {}
    20.         ~Compiler()
    21.         {}
    22.         //返回值是编译成功TRUE；else FALSE
    23.         //输入参数是编译的文件名
    24.         //file_name : 1234
    25.         //1234 -> ./temp/1234.cpp
    26.         //1234 -> ./temp/1234.exe
    27.         //1234 -> ./temp/1234.stderr
    28.         static bool Compile(const std::string &file_name)
    29.         {
    30.             pid_t pid = fork();
    31.             if(pid < 0)
    32.             {
    33.                 LOG(ERROR) << "内部错误，创建子进程失败"<<"\n";
    34.                 return false;
    35.             }
    36.             else if(pid == 0)//子进程
    37.             {
    38.                 umask(0);
    39.                 int _stderr = open(PathUtil::CompilerError(file_name).c_str(),O_CREAT | O_WRONLY,0644);
    40.                 if(_stderr < 0){
    41.                     LOG(WARNING)<<"没有成功行成stderr文件"<<"\n";
    42.                     exit(1);
    43.                 }
    44.                 //重定向标准错误到_stderr
    45.                 dup2(_stderr,2);
    46.                 //程序替婚，并不影响进程的文件描述符表
    47.                 //子进程：调用编译器
    48.                 execlp("g++","g++","-o",PathUtil::Exe(file_name).c_str(),PathUtil::Src(file_name).c_str(),"-std=c++11","-D","COMPILER_ONLINE",nullptr);
    49.                 LOG(ERROR) <<"启动编译器g++失败，可能是参数错误"<<"\n";
    50.                 exit(2);
    51.             }
    52.             else//父进程
    53.             {
    54.                 waitpid(pid,nullptr,0);
    55.                 //编译是否成功,就看有没有形成对应的可执行程序
    56.                 if(FileUtil::IsFileExists(PathUtil::Exe(file_name).c_str())){
    57.                     LOG(INFO) <Src(file_name)<<"编译成功!"<<"\n";
    58.                     return true;
    59.                 }
    60.             }
    61.             LOG(ERROR) <<"编译失败，没有形成可执行程序,return false"<<"\n";
    62.             return false;
    63.  
    64.         }
    65.     };
    66. };

    compiler编译服务只管编译传过来的代码，其他一律不管，它只关心程序是否能够编译过

    LOG日志的添加：

    1. #pragma once
    2. #include
    3. #include
    4. #include"util.hpp"
    5. namespace ns_log
    6. {
    7.     using namespace ns_util;
    8.     //日志等级
    9.     enum{
    10.         INFO,
    11.         DEBUG,
    12.         WARNING,
    13.         ERROR ,
    14.         FATAL
    15.     };
    16.     //LOG() << "message"
    17.     inline std::ostream &Log(const std::string &level, const std::string &file_name,int line)
    18.     {
    19.         //添加日志等级
    20.         std::string message = "[";
    21.         message+=level;
    22.         message+="]";
    23.  
    24.         //添加报错文件名称
    25.         message+="[";
    26.         message+=file_name;
    27.         message+="]";
    28.  
    29.         //添加报错行
    30.         message+="[";
    31.         message+=std::to_string(line);
    32.         message+="]";
    33.  
    34.         //添加日志时间戳
    35.  
    36.         message += "[";
    37.         message += TimeUtil::GetTimeStamp();
    38.         message += "]";
    39.  
    40.         //cout 本质内部是包含缓冲区的
    41.         std::cout<//不要endl刷新
    42.         return std::cout;
    43.     }
    44.     //LOG(INFo) << "message"
    45.     //开放式日志
    46.     #define LOG(level) Log(#level,__FILE__,__LINE__)
    47. }

    runner运行功能设计：

    1. #pragma once
    2.  
    3. #include 
    4. #include
    5. #include
    6. #include
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include
    12. #include
    13. #include
    14. #include 
    15. #include "../comm/log.hpp"
    16. #include "../comm/util.hpp"
    17. namespace ns_runner
    18. {
    19.     using namespace ns_log;
    20.     using namespace ns_util;
    21.     class Runner
    22.     {
    23.     public:
    24.         Runner() {}
    25.         ~Runner() {}
    26.  
    27.     public:
    28.         //提供设置进程占用资源大小的接口
    29.         static void SerProcLimit(int _cpu_limit,int _mem_limit)
    30.         {
    31.             //设置CPU时长
    32.             struct rlimit cpu_rlimit;
    33.             cpu_rlimit.rlim_max = RLIM_INFINITY;
    34.             cpu_rlimit.rlim_cur = _cpu_limit;
    35.             setrlimit(RLIMIT_CPU,&cpu_rlimit);
    36.             //设置内存大小
    37.             struct rlimit mem_rlimit;
    38.             mem_rlimit.rlim_max = RLIM_INFINITY;
    39.             mem_rlimit.rlim_cur = _mem_limit * 1024;//转化成kb
    40.             setrlimit(RLIMIT_AS,&mem_rlimit);
    41.         }
    42.         // 指明文件名即可，不需要带路径和后缀
    43.         /*
    44.         返回值如果是大于 0 ：程序异常了，退出时收到了信号，返回值就是对应的信号
    45.         返回值 == 0 就是正常运行完毕，结果是什么保存到了临时文件中，我不清楚
    46.         返回值 < 0 属于内部错误
    47.         cpu_limit:该程序运行的时候，可以使用的最大cpu的资源上限
    48.         mem_limit：该程序运行的时候，可以使用的最大内存大小KB
    49.         */
    50.         static int Run(const std::string &file_name,int cpu_limit,int mem_limit)
    51.         {
    52.             /*程序运行：
    53.             1.代码跑完结果争取
    54.             2.代码跑完结果不正确
    55.             3.代码没跑完，异常了
    56.             run不需要考虑运行完后正确与否，只管跑
    58.             首先我们必须知道可执行程序是谁？
    59.             标准输入：不处理
    60.             标准输入：程序运行完成，输出结果是什么
    61.             标准错误：运行时错误信息
    62.             */
    63.             std::string _execute = PathUtil::Exe(file_name);
    64.             std::string _stdin = PathUtil::Stdin(file_name);
    65.             std::string _stdout = PathUtil::Stdout(file_name);
    66.             std::string _stderr = PathUtil::Stderr(file_name);
    67.  
    68.             umask(0);
    69.             int _stdin_fd = open(_stdin.c_str(), O_CREAT | O_RDONLY, 0644);
    70.             int _stdout_fd = open(_stdout.c_str(), O_CREAT | O_WRONLY, 0644);
    71.             int _stderr_fd = open(_stderr.c_str(), O_CREAT | O_WRONLY, 0644);
    72.  
    73.             if (_stdin_fd < 0 || _stdout_fd < 0 || _stderr_fd < 0)
    74.             {
    75.                 LOG(ERROR)<<"运行时打开标准文件失败"<<"\n";
    76.                 return -1; // 代表打开文件失败
    77.             }
    78.             pid_t pid = fork();
    79.             if (pid < 0)
    80.             {
    81.                 LOG(ERROR)<<"运行时创建子进程失败"<<"\n";
    82.                 close(_stdin_fd);
    83.                 close(_stdout_fd);
    84.                 close(_stderr_fd);
    85.                 return -2; //代表创建子进程失败
    86.             }
    87.             else if (pid == 0)
    88.             {
    89.                 dup2(_stdin_fd,0);
    90.                 dup2(_stdout_fd,1);
    91.                 dup2(_stderr_fd,2);
    92.  
    93.                 SerProcLimit(cpu_limit,mem_limit);
    94.                 execl(_execute.c_str()/*我要执行谁*/,_execute.c_str()/*我想在命令航商如何执行*/,nullptr);
    95.                 exit(1);
    96.             }
    97.             else
    98.             {
    99.                 
    100.                 int status = 0;
    101.                 waitpid(pid,&status,0);
    102.                 //程序运行异常，一定是因为收到了信号
    103.                 LOG(INFO)<<"运行完毕，info："<<(status & 0x7F)<<"\n";
    104.                 close(_stdin_fd);
    105.                 close(_stdout_fd);
    106.                 close(_stderr_fd);
    107.                 return status&0x7F;
    108.             }
    109.         }
    110.     };
    111. }

    compile_run:编译并运行功能:

    1. #pragma once
    2. #include "compiler.hpp"
    3. #include
    4. #include "runner.hpp"
    5. #include "../comm/log.hpp"
    6. #include "../comm/util.hpp"
    7. #include 
    8. #include 
    9. namespace ns_compile_and_run
    10. {
    11.     using namespace ns_log;
    12.     using namespace ns_util;
    13.     using namespace ns_compiler;
    14.     using namespace ns_runner;
    15.     class CompileAndRun
    16.     {
    17.     public:
    18.         static void RemoveTempFile(const std::string& file_name)
    19.         {
    20.             //清理文件的个数是不确定的，但是有哪些我们是知道的
    21.             std::string _src = PathUtil::Src(file_name);
    22.             if(FileUtil::IsFileExists(_src))unlink(_src.c_str());
    23.             
    24.             std::string _compiler_error = PathUtil::CompilerError(file_name);
    25.             if(FileUtil::IsFileExists(_compiler_error))unlink(_compiler_error.c_str());
    26.             
    27.             std::string _execute = PathUtil::Exe(file_name);
    28.             if(FileUtil::IsFileExists(_execute)) unlink(_execute.c_str());
    29.  
    30.             std::string _stdin = PathUtil::Stdin(file_name);
    31.             if(FileUtil::IsFileExists(_stdin)) unlink(_stdin.c_str());
    32.  
    33.             std::string _stdout = PathUtil::Stdout(file_name);
    34.             if(FileUtil::IsFileExists(_stdout)) unlink(_stdout.c_str());
    35.  
    36.             std::string _stderr = PathUtil::Stderr(file_name);
    37.             if(FileUtil::IsFileExists(_stderr)) unlink(_stderr.c_str());
    38.         }
    39.         static std::string CodeToDesc(int code, std::string file_name) // code >0 <0 ==0
    40.         {
    41.             std::string desc;
    42.             switch (code)
    43.             {
    44.             case 0:
    45.                 desc = "编译运行成功";
    46.                 break;
    47.             case -1:
    48.                 desc = "用户提交的代码是空";
    49.                 break;
    50.             case -2:
    51.                 desc = "未知错误";
    52.                 break;
    53.             case -3:
    54.                 // desc = "编译发生报错";
    55.                 FileUtil::ReadFile(PathUtil::Stderr(file_name), &desc, true);
    56.                 break;
    57.             case -4:
    58.                 break;
    59.             case SIGABRT:
    60.                 desc = "内存超过范围";
    61.                 break;
    62.             case SIGXCPU:
    63.                 desc = "CPU信号超时";
    64.                 break;
    65.             case SIGFPE:
    66.                 desc = "除零错误,浮点数溢出";
    67.                 break;
    68.             default:
    69.                 desc = "未知：" + std::to_string(code);
    70.                 break;
    71.             }
    72.             return desc;
    73.         }
    74.         /*
    75.         输入：
    76.         code：用户提交的代码
    77.         input：用户自己提交的代码，对应的输入-》不做处理
    78.         cpu_limit：时间要求
    79.         mem_limit:空间要求
    80.         输出：
    81.         必填：
    82.         status：状态码
    83.         reason：请求结果
    84.         选填：
    85.         stdout：我的的程序运行完的结果
    86.         stderr：我的程序运行完的错误结构
    88.         参数：
    89.         in_json:{"code":"#include..."."input":"","cpu_limit":1,"mem_limit":10240}
    90.         out_json:{"status":"0","reason":"","stdout":"","stderr":""};
    91.         */
    92.         static void Start(const std::string &in_json, std::string *out_json)
    93.         {
    94.             LOG(INFO)<<"启动compile_and_run"<<"\n";
    95.             Json::Value in_value;
    96.             Json::Reader reader;
    97.             reader.parse(in_json, in_value); // 最后再处理差错问题
    98.  
    99.             std::string code = in_value["code"].asString();
    100.             std::string input = in_value["input"].asString();
    101.             int cpu_limit = in_value["cpu_limit"].asInt();
    102.             int men_limit = in_value["mem_limit"].asInt();
    103.  
    104.             int status_code = 0;
    105.             Json::Value out_value;
    106.             int run_result = 0;
    107.             std::string file_name; // 需要内部形成的唯一文件名
    108.  
    109.             if (code.size() == 0)
    110.             {
    111.                 // 说明用户一行代码都没提交
    112.                 status_code = -1;
    113.                 goto END;
    114.             }
    115.  
    116.             // 形成的文件名只具有唯一性，没有目录没有后缀
    117.             // 毫秒计时间戳+原子性递增的唯一值：来保证唯一性
    118.             file_name = FileUtil::UniqFileName(); // 形成唯一文件名字
    119.             LOG(DEBUG)<<"调用UniqFileName()形成唯一名字"<"\n";
    120.  
    121.             run_result = Runner::Run(file_name, cpu_limit, men_limit);
    122.             if (!FileUtil::WriteFile(PathUtil::Src(file_name), code)) // 形成临时src文件.cpp
    123.             {
    124.                 status_code = -2; // 未知错误
    125.                 goto END;
    126.             }
    127.  
    128.             if (!Compiler::Compile(file_name))
    129.             {
    130.                 // 编译失败
    131.                 status_code = -3;
    132.                 goto END;
    133.             }
    134.  
    135.             run_result = Runner::Run(file_name, cpu_limit, men_limit);
    136.             if (run_result < 0)
    137.             {
    138.                 // 服务器的内部错误，包括不限于文件打开失败，创建子进程失败等待
    139.                 status_code = -2; // 未知错误
    140.                 goto END;
    141.             }
    142.             else if (run_result > 0)
    143.             {
    144.                 status_code = run_result;
    145.             }
    146.             else
    147.             {
    148.                 // 运行成功
    149.                 status_code = 0;
    150.             }
    151.         END:
    152.             std::cout<<"到达end语句"<
    153.             // status_code
    154.             out_value["status"] = status_code;
    155.             out_value["reason"] = CodeToDesc(status_code, file_name);
    156.             LOG(DEBUG)<<CodeToDesc(status_code, file_name);
    157.             if (status_code == 0)
    158.             {
    159.                 // 整个过程全部成功 , 这时候才需要运行结果
    160.                 std::string _stdout;
    161.                 FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
    162.                 out_value["stdout"] = _stdout; 
    163.             }
    164.             else
    165.             {
    166.                 std::string _stderr;
    167.                 FileUtil::ReadFile(PathUtil::CompilerError(file_name), &_stderr, true);
    168.                 out_value["stderr"] = _stderr;
    169.             }
    170.             
    171.             // 序列化
    172.  
    173.             Json::StyledWriter writer;
    174.             *out_json = writer.write(out_value);
    175.  
    176.             //清理所有的临时文件
    177.             RemoveTempFile(file_name);
    178.         }
    179.     };
    180. }

    compile_run:它的功能是接收远端传进来的json包，并反序列化得到其中的代码与输入，并调用compile进行编译

    • 编译成功：调用runner将代码运行起来->将执行结果分别保存到.exe、.stdin、.stdout 、.stderr、.compile_stderr文件中
    • 编译失败：不调用runner

    最后按对应构造json 返回给上级调用，即write进out_json中,收尾清除创建的文件

     

    compile_server .cc文件编写：

     

    1. #include"compile_run.hpp"
    2. #include
    3. #include"../comm/httplib.h"
    4. using namespace ns_compile_and_run;
    5. using namespace httplib;
    6.  
    7. //编译服务随时可能被多个人请求,必须保证传递上来的code，形成源文件名称的时候，要具有唯一性，不然影响多个用户
    8. void Usage(std::string proc)
    9. {
    10.     std::cerr <<"Usage:"<<"\n\t"<"port"<
    11. }
    12. // ./compiler_server port
    13. int main(int argc,char *argv[])
    14. {
    15.     if(argc!=2){
    16.         Usage(argv[0]);
    17.     }
    18.     Server svr;
    19.  
    20.     svr.Get("/hello",[](const Request &req,Response &resp)
    21.     {
    22.         resp.set_content("hello httplib,你好httplib","content_type: text/plain");
    23.     });
    24.     //svr.set_base_dir("./wwwroot");
    25.     svr.Post("/compile_and_run",[](const Request &req,Response &resp){  
    26.         //请求服务正文是我们想要的json串
    27.         LOG(DEBUG)<<"调用compile_and_run"<<"\n";
    28.         std::string out_json;
    29.         std::string in_json = req.body;
    30.         if(!in_json.empty()){
    31.             LOG(DEBUG)<<"当前的in_json"<"\n";
    32.             CompileAndRun::Start(in_json,&out_json);
    33.             resp.set_content(out_json,"application/json;charset=utf-8");
    34.         }
    35.     });
    36.     svr.listen("0.0.0.0",atoi(argv[1]));//启动http服务了
    37.  
    38.     // std::string code = "code";
    39.     // Compiler::Compile(code);
    40.     // Runner::Run(code);
    41.  
    42.  
    43.     //0-----------------------测试代码-------------------
    44.     //下面的工作，充当客户端请求的json串
    45.     // std::string in_json;
    46.     // Json::Value in_value;
    47.     // //R"（）" raw string 凡事在这个圆括号里面的东西，就是字符串哪怕有一些特殊的字符串
    48.     // in_value["code"] =R"(#include
    49.     // int main(){
    50.     //         std::cout<<"测试成功"<
    51.     //         int a = 10;
    52.     //         a /= 0;
    53.     //         return 0;
    54.     //     })";
    55.     // in_value["input"] ="";
    56.     // in_value["cpu_limit"] = 1;
    57.     // in_value["mem_limit"] = 10240 * 3;
    58.  
    59.     // Json::FastWriter writer;
    60.     // std::cout<
    61.     // in_json = writer.write(in_value);
    62.  
    63.     // //这个是将来给客户端返回的字符串
    64.     // std::string out_json;
    65.     // CompileAndRun::Start(in_json,&out_json);
    66.  
    67.     // std::cout<
    68.     //0-----------------------------------------------------
    69.  
    70.  
    71.     //提供的编译服务，打包新城一个网络服务
    72.     //这次直接用第三方库，cpp-httplib
    73.  
    74.     return 0;
    75. }

    直接引入的httplib库， 设置好ip和端口就可以直接监听了

    • svr.get() ：就是当对该服务器发起/hello 请求的时候，我就会接受到该请求，以Get的方式返回resp

    makefile：

    由于当前使用的c++11的新特性，引入了json库，和多线程

    1. compile_server:compile_server.cc
    2. 	g++ -o $@ $^ -std=c++11 -ljsoncpp -lpthread
    3. .PHONY:clean
    4. clean:
    5. 	rm -f compile_server

    项目设计 -- 基于MVC结构的oj服务 

    本质：建立一个小型网站

    1.获取首页

    2.编辑区域页面

    3.提交判题功能（编译并运行） 

     

    M：Model，通常是和数据交互的模块，比如对题库的增删改查（文件版，mysql版）

    V：view，通常是拿到数据之后，要进行构建网页，渲染网页内容

    C：control，控制器，也就是我们核心业务逻辑

    用户的请求服务路由功能：

    1.  
    2. #include "../comm/httplib.h"
    3. #include "login.hpp"
    4. #include 
    5. #include 
    6. #include"oj_control.hpp"
    7. using namespace httplib;
    8. using namespace ns_control;
    9. const std::string login_path = "../oj_login/wwwroot/";
    10. static Control *ctrl_ptr = nullptr;
    11. void Recovery(int signo)
    12. {
    13.   ctrl_ptr->RecoveryMachine();
    14. }
    15. int main() {
    16.   signal(SIGQUIT,Recovery);
    17.   // 用户请求的服务路由功能
    18.   Server svr;
    19.   Control ctrl;
    20.   Login login;
    21.   ctrl_ptr = &ctrl;
    22.   /*
    23.   1获取所有的题目列表
    25.   */
    26.   svr.Get(R"(/all_questions)", [&ctrl](const Request &req, Response &resp) {
    27.     std::string html;
    28.     ctrl.AllQuestions(&html);
    29.     resp.set_content(html, "text/html;charset=utf-8");
    30.   });
    31.  
    32.   //   2用户要根据题目编号来选择题目
    33.   // 这里的\d是正则表达式 + 是匹配数字
    34.   // R"()"保持原始字符串不会被特殊字符影响比如\d \r \n之类的不需要做相关的转义
    35.   svr.Get(R"(/question/(\d+))", [&ctrl](const Request &req, Response &resp) {
    36.     std::string number = req.matches[1];
    37.     std::string html;
    38.     ctrl.OneQuestion(number,&html);
    39.     resp.set_content(html,"text/html;charset=utf-8");
    40.   });
    41.  
    42.   // 3用户提交代码，使用我们的判题功能（1.没道题目的测试用例 2.compile_and_run)
    43.   svr.Post(R"(/judge/(\d+))",[&ctrl](const Request &req, Response &resp){
    44.     std::string number = req.matches[1];
    45.     // resp.set_content("这是指定的一道题目的判题：" + number,
    46.     //                  "text/plain;charset=utf-8");
    47.     std::string result_json;
    48.     ctrl.Judge(number,req.body,&result_json);
    49.     resp.set_content(result_json,"application/json;charset=utf-8");
    50.   });
    51.   svr.Post(R"(/dealregister)",[&ctrl](const Request &req, Response &resp){
    52.     int status = 1;
    53.     std::string in_json = req.body;
    54.     std::string out_json;
    55.     if(!ctrl.UserRegister(in_json,&out_json)){
    56.       status = 0;
    57.     
    58.     }
    59.     LOG(INFO)<<"用户注册status : "<"\n";
    60.     Json::Value tmp;
    61.     tmp["status"] = status;
    62.     Json::FastWriter writer;
    63.     std::string res = writer.write(tmp);
    64.     resp.set_content(res,"application/json;charset=utf-8");
    65.   });
    66.  
    67.   svr.Get(R"(/my_login)",[&login,&ctrl](const Request &req,Response &resp){
    68.     //直接跳转到静态的html
    69.     std::string html;
    70.     ctrl.Login(req.body,&html);
    71.     resp.set_content(html, "text/html;charset=utf-8");
    72.   });
    73.  
    74.   svr.Get(R"(/register)",[&login,&ctrl](const Request &req,Response &resp){
    75.     //直接跳转到静态的html
    76.     std::string html;
    77.     ctrl.Register(req.body,&html);
    78.     resp.set_content(html, "text/html;charset=utf-8");
    79.   });
    80.  
    81.   svr.set_base_dir("./wwwroot");
    82.   svr.listen("0.0.0.0", 8080);
    83.   return 0;
    84. }

    这样当用户通过http请求我们的oj_server服务器的时候我们可以正确的路由到合适的功能

    model功能：提供对数据的操作（文件版）

    1. #pragma once
    2. //文件版本
    3. /*
    4. 编号
    5. 标题
    6. 难度
    7. 描述
    8. 时间（内部），空间（内部处理）
    10. 两批文件构成
    11. 1.question.list：题目列表：不需要出现题目描述
    12. 2.需要题目的描述，需要题目的预设置代码（header.cpp）,测试用例代码(tail.cpp)
    14. 这两个内容是通过题目的编号，产生关联的
    15. */
    16. #pragma once
    17. #include "../comm/log.hpp"
    18.  
    19. #include "../comm/util.hpp"
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. // 根据题目list文件，加载所有信息到内存中
    28. // model:主要用来和数据进行交互，对外提供访问数据的接口
    29.  
    30. namespace ns_model {
    31. using namespace std;
    32. using namespace ns_log;
    33. using namespace ns_util;
    34. class Question {
    35. public:
    36.   std::string number; // 题目编号
    37.   std::string title;  // 题目的标题
    38.   std::string star;   // 难度：简单中等困难
    39.   int cpu_limit;      // 时间要求 s
    40.   int mem_limit;      // 空间要求 kb
    41.   std::string desc;   // 题目的描述
    42.   std::string header; // 题目预设给用户在线编辑器的代码
    43.   std::string tail; // 题目的测试用例，需要和header拼接形成完整代码
    44. };
    45. const std::string question_list = "./questions/questions.list";
    46. const std::string question_path = "./questions/";
    47. class Model {
    48. private:
    49.   // 题号：题目细节
    50.   unordered_map questions;
    51.  
    52. public:
    53.   Model() { assert(LoadQuestionList(question_list)); }
    54.   bool LoadQuestionList(const std::string &question_list) {
    55.     // 加载配置文件questions/question.list + 题目编号文件
    56.     ifstream in(question_list);
    57.     if (!in.is_open()) {
    58.       LOG(FATEL) << "加载题库失败，请检查是否存在题库文件"
    59.                  << "\n";
    60.       return false;
    61.     }
    62.     std::string line;
    63.     while (getline(in, line)) {
    64.       vector tokens;
    65.       StringUtil::SplitString(line, &tokens, " ");
    66.       if (tokens.size() != 5) {
    67.  
    68.         LOG(WARNING) << "加载部分题目失败，请检查文件格式"
    69.                      << "\n";
    70.         continue;
    71.       }
    72.       Question q;
    73.       q.number = tokens[0];
    74.       q.title = tokens[1];
    75.       q.star = tokens[2];
    76.       q.cpu_limit = atoi(tokens[3].c_str());
    77.       q.mem_limit = atoi(tokens[4].c_str());
    78.  
    79.       std::string path = question_path;
    80.       path += q.number;
    81.       path += "/";
    82.       FileUtil::ReadFile(path + "desc.txt", &(q.desc), true);
    83.       FileUtil::ReadFile(path + "header.cpp", &(q.header), true);
    84.       FileUtil::ReadFile(path + "tail.cpp", &(q.tail), true);
    85.  
    86.       questions.insert({q.number, q});
    87.     }
    88.     LOG(INFO) << "加载题库成功！"
    89.               << "\n";
    90.     in.close();
    91.     return true;
    92.   }
    93.   bool GetAllQuestion(vector *out) {
    94.     if (questions.size() == 0) {
    95.       LOG(ERROR) << "用户获取题库失败"
    96.                  << "\n";
    97.       return false;
    98.     }
    99.     for (const auto &q : questions) {
    100.       out->push_back(q.second); // fir是key' sec是value
    101.     }
    102.     return true;
    103.   }
    104.   bool GetOneQuestion(const std::string &number, Question *q) {
    105.     const auto &iter = questions.find(number);
    106.     if (iter == questions.end()) {
    107.       LOG(ERROR) << "用户获取题目失败：" << number << "\n";
    108.  
    109.       return false;
    110.     }
    111.     (*q) = iter->second;
    112.     return true;
    113.   }
    114.   ~Model() {}
    115. };
    116. } // namespace ns_model

    该设计中有一个 question的题目清单,像题库的目录一样，填写每道题目的基本信息：

    对应的是:

    1.题目编号 2.题目名字 3.题目难度 4.时间限制 5.空间限制

    559bed10817d4f8280e61bce3787873a.png

     

     

     model功能：提供对数据的操作（数据库版）

    1. #pragma once
    2. //这个是mysql版本
    3. /*
    4. 编号
    5. 标题
    6. 难度
    7. 描述
    8. 时间（内部），空间（内部处理）
    10. 两批文件构成
    11. 1.question.list：题目列表：不需要出现题目描述
    12. 2.需要题目的描述，需要题目的预设置代码（header.cpp）,测试用例代码(tail.cpp)
    14. 这两个内容是通过题目的编号，产生关联的
    15. */
    16. #pragma once
    17. #include "../comm/log.hpp"
    18.  
    19. #include "../comm/util.hpp"
    20. #include 
    21. #include 
    22. #include 
    23. #include 
    24. #include 
    25. #include 
    26. #include 
    27. #include 
    28.  
    29. #include"include/mysql.h"
    30. // 根据题目list文件，加载所有信息到内存中
    31. // model:主要用来和数据进行交互，对外提供访问数据的接口
    32.  
    33. namespace ns_model {
    34. using namespace std;
    35. using namespace ns_log;
    36. using namespace ns_util;
    37. class Question {
    38. public:
    39.   std::string number; // 题目编号
    40.   std::string title;  // 题目的标题
    41.   std::string star;   // 难度：简单中等困难
    42.   int cpu_limit;      // 时间要求 s
    43.   int mem_limit;      // 空间要求 kb
    44.   std::string desc;   // 题目的描述
    45.   std::string header; // 题目预设给用户在线编辑器的代码
    46.   std::string tail; // 题目的测试用例，需要和header拼接形成完整代码
    47. };
    48.  
    49. const std::string oj_questions ="oj_questions"; 
    50. const std::string oj_user = "oj_user";
    51. const std::string host = "127.0.0.1";
    52. const std::string user = "oj_client";
    53. const std::string passwd = "123456";
    54. const std::string db = "oj";
    55. const int port = 3306;
    56. class Model {
    57. private:
    58.   // 题号：题目细节
    59.   unordered_map questions;
    60. public:
    61.   Model() { }
    62.   bool QueryMySql(const std::string &sql,vector *out)
    63.   {
    64.     //创建mysql句柄
    65.     MYSQL *my = mysql_init(nullptr);
    66.     //连接数据库
    67.     if(mysql_real_connect(my,host.c_str(),user.c_str(),passwd.c_str(),db.c_str(),port,nullptr,0) == nullptr){
    68.       LOG(FATAL)<<"连接数据库失败！"<<"\n";
    69.       return false;
    70.     }
    71.     //一定要设置该链接的编码格式默认是拉钉的
    72.     mysql_set_character_set(my,"utf8mb4");
    73.     LOG(INFO)<<"连接数据库成功"<<"\n";
    74.  
    75.     //执行sql语句
    76.     if(0 != mysql_query(my,sql.c_str()))
    77.     {
    78.       LOG(WARNING) << sql <<"execute error!"<<"\n";
    79.       return false;
    80.     }
    81.     MYSQL_RES *res = mysql_store_result(my);
    82.     //分析结果
    83.     int rows = mysql_num_rows(res); //获得行数量
    84.     int cols = mysql_num_fields(res);//获得列数量
    85.  
    86.     
    87.     Question q;
    88.     for(int i = 0;i
    89.     {
    90.       MYSQL_ROW row = mysql_fetch_row(res);
    91.       q.number = row[0];
    92.       q.title = row[1];
    93.       q.star = row[2];
    94.       q.desc = row[3];
    95.       q.header = row[4];
    96.       q.tail = row[5];
    97.       q.cpu_limit = atoi(row[6]);
    98.       q.mem_limit = atoi(row[7]);
    99.  
    100.       out->push_back(q);
    101.     }
    102.  
    103.  
    104.     //释放结果空间
    105.     free(res);
    106.     //关闭mysql连接
    107.     mysql_close(my);
    108.  
    109.     return true;
    110.   }
    111.   bool GetAllQuestion(vector *out) {
    112.     std::string sql ="select *from ";
    113.     sql += oj_questions;
    114.     return QueryMySql(sql,out);
    115.   }
    116.   bool GetOneQuestion(const std::string &number, Question *q) {
    117.     bool res = false;
    118.     std::string sql = "select *from ";
    119.     sql+=oj_questions;
    120.     sql+= " where number=";
    121.     sql+=number;
    122.     vector result;
    123.     if(QueryMySql(sql,&result))
    124.     {
    125.       if(result.size() == 1)
    126.       {
    127.         *q = result[0];
    128.         res = true;
    129.       }
    130.     }
    131.     return res;
    132.   }
    133.   
    134.   bool UserRegister(const std::string& in_json,std::string* out_json)
    135.   {
    136.     //这里先对in_json反序列化
    137.     Json::Reader reader;
    138.     Json::Value in_value;
    139.     reader.parse(in_json,in_value);
    140.     std::string number = in_value["number"].asString();
    141.     std::string name = in_value["name"].asString();
    142.     std::string password = in_value["password"].asString();
    143.     int limit = in_value["limit"].asInt();
    144.     int level = in_value["level"].asInt();
    145.     //判断账号密码是否可行
    146.     std::string sql = " select *from ";
    147.     sql+=oj_user;
    148.     sql+=" where number=";
    149.     sql+=number;
    150.  
    151.     //创建数据库
    152.     MYSQL *my = mysql_init(nullptr);
    153.     //连接数据库
    154.     if(mysql_real_connect(my,host.c_str(),user.c_str(),passwd.c_str(),db.c_str(),port,nullptr,0) == nullptr)
    155.     {
    156.       LOG(WARNING)<<"连接到用户数据库失败"<<"\n";
    157.       return false;
    158.     }
    159.     //一定要记得设置该链接的编码格式
    160.     mysql_set_character_set(my,"utf8");
    161.     LOG(INFO)<<"连接懂啊用户数据库成功"<<"\n";
    162.  
    163.     if(0 != mysql_query(my,sql.c_str())){
    164.       LOG(WARNING)<< sql <<"execute error!"<<"\n";
    165.       return false;
    166.     }
    167.     MYSQL_RES *res = mysql_store_result(my);
    168.     if(mysql_num_rows(res) == 0)//获得行数量
    169.     { 
    170.       //当前输入的数据可以创建用户
    171.       MYSQL_STMT *stmt = mysql_stmt_init(my);
    172.       const char* query = "insert into oj_user values (?,?,?,?,?)";
    173.       if(mysql_stmt_prepare(stmt,query,strlen(query)) != 0){
    174.         LOG(WARNING)<<"stmt出现错误"<<"\n";
    175.         mysql_stmt_close(stmt);
    176.         mysql_close(my);
    177.         return false;
    178.       }
    179.       //下面开始绑定
    180.       MYSQL_BIND bind_params[5];
    181.       memset(bind_params,0,sizeof bind_params);
    182.  
    183.       bind_params[0].buffer_type = MYSQL_TYPE_STRING;
    184.       bind_params[0].buffer = (char*)number.c_str();
    185.       bind_params[0].buffer_length = number.size();
    186.  
    187.       bind_params[1].buffer_type = MYSQL_TYPE_STRING;
    188.       bind_params[1].buffer = (char*)name.c_str();
    189.       bind_params[1].buffer_length = name.size();
    190.  
    191.       bind_params[2].buffer_type = MYSQL_TYPE_STRING;
    192.       bind_params[2].buffer = (char*)password.c_str();
    193.       bind_params[2].buffer_length = password.size();
    194.  
    195.       bind_params[3].buffer_type = MYSQL_TYPE_LONG;
    196.       bind_params[3].buffer = &limit;
    197.       bind_params[3].is_unsigned = 1;
    198.  
    199.       bind_params[4].buffer_type = MYSQL_TYPE_LONG;
    200.       bind_params[4].buffer = &level;
    201.       bind_params[4].is_unsigned = 1;
    202.       
    203.       if(mysql_stmt_bind_param(stmt,bind_params) !=0){
    204.         LOG(WARNING) <<"绑定stmt参数出错"<<"\n";
    205.         mysql_stmt_close(stmt);
    206.         mysql_close(my);
    207.         return false;
    208.       }
    209.  
    210.       //执行插入语句
    211.       if(mysql_stmt_execute(stmt)!=0){
    212.         LOG(WARNING)<<"执行stmt语句的时候出现错误..."<<"\n";
    213.         mysql_stmt_close(stmt);
    214.         mysql_close(my);
    215.         return false;
    216.       }
    217.       
    218.       mysql_stmt_close(stmt);
    219.       mysql_close(my);
    220.       return true;
    221.     }
    222.     else{
    223.       //服务器有重复的用户num ，不允许再创建了
    224.       return false;
    225.     }
    226.     //保存到服务器
    227.  
    228.     //这里out_json暂时没有用，没有要返回的值
    229.     return true;
    230.   }
    231.   ~Model() {}
    232. };
    233. } // namespace ns_model

    control：逻辑控制模块

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9. #include
    10. #include
    11. #include"oj_view.hpp" 
    12. // #include"oj_model.hpp"
    13. #include"oj_model2.hpp"
    14. #include"../comm/log.hpp"
    15. #include"../comm/util.hpp"
    16. #include"../comm/httplib.h"
    17. namespace ns_control
    18. {
    19.     using namespace std;
    20.     using namespace httplib;
    21.     using namespace ns_log;
    22.     using namespace ns_util;
    23.     using namespace ns_model; 
    24.     using namespace ns_view;
    25.     //提供服务的主机的内容
    26.     class Machine
    27.     {
    28.     public:
    29.         std::string ip; //编译服务器的ip
    30.         int port;       //编译服务器的端口
    31.         uint64_t load;  //编译服务器负载
    32.         std::mutex *mtx;//mutex是禁止拷贝的,使用指针来完成
    33.     public:
    34.         Machine():ip(""),port(0),load(0),mtx(nullptr)
    35.         {}
    36.         ~Machine()
    37.         {}
    38.     public:
    39.     void ResetLoad()
    40.     {
    41.         if(mtx)mtx->lock();
    42.         load = 0;
    43.         LOG(DEBUG)<<"当前ip:"<"端口："<"的load已经清除load = "<"\n";
    44.         if(mtx)mtx->unlock();
    45.     }
    46.     //提升主机负载
    47.         void IncLoad()
    48.         {
    49.             if(mtx) mtx->lock();
    50.             ++load;
    51.             if(mtx) mtx->unlock();
    52.         }
    53.     //减少主机负载
    54.         void DecLoad()
    55.         {
    56.             if(mtx) mtx->lock();
    57.             --load;
    58.             if(mtx) mtx->unlock();
    59.         }
    60.  
    61.         //获取主机负载,没有太大的意义，只是为了同一接口
    62.         uint64_t Load()
    63.         {
    64.             uint64_t _load = 0;
    65.             if(mtx) mtx->lock();
    66.             _load = load;
    67.             if(mtx) mtx->unlock();
    68.             return _load;
    69.         }
    70.     };
    71.     const std::string service_machine = "./conf/service_machine.conf";
    72.     //负载均衡模块
    73.     class LoadBalance
    74.     { 
    75.     private:
    76.         //可以给我们提供编译服务的所有的主机
    77.         //每一台主机都有自己的下标，充当当前主机的id
    78.         std::vector machines; 
    79.         //所有在线的主机
    80.         std::vector<int> online;
    81.         //所有离线主机的id
    82.         std::vector<int> offline;
    83.         //保证选择主机上的这个东西要保证数据安全
    84.         std::mutex mtx;
    85.     public:
    86.         LoadBalance(){
    87.             assert(LoadConf(service_machine));
    88.             LOG(INFO)<<"加载"<"成功"<<"\n";
    89.         }
    90.         ~LoadBalance(){}
    91.     public:
    92.         bool LoadConf(const std::string &machine_cof)
    93.         {
    94.             std::ifstream in(machine_cof);
    95.             if(!in.is_open())\
    96.             {
    97.                 LOG(FATAL) <<"加载："<"失败"<<"\n";
    98.                 return false;
    99.             }
    100.             std::string line;
    101.             while (getline(in,line))
    102.             {
    103.                 std::vector tokens;
    104.                 StringUtil::SplitString(line,&tokens,":");
    105.                 if(tokens.size()!=2)
    106.                 {
    107.                     LOG(WARNING) <<"切分"<"失败"<<"\n";
    108.                     std::cout<0]<<":"<1]<
    109.                     continue;
    110.                 }
    111.                 //LOG(INFO) <<"切分"<
    112.                 Machine m;
    113.                 m.ip = tokens[0];
    114.                 m.port = atoi(tokens[1].c_str());
    115.                 m.load = 0;
    116.                 m.mtx = new std::mutex();
    117.  
    118.                 online.push_back(machines.size());
    119.                 machines.push_back(m);
    120.             }
    121.             
    122.             in.close();
    123.             return true;
    124.         }
    125.         //id:是一个输出型参数
    126.         //m:是一个输出型参数
    127.         bool SmartChoice(int *id,Machine **m)
    128.         {
    129.             //1.使用选择好的主机(更新该主机的负载)
    130.             //2.我们需要可能离线该主机
    131.             mtx.lock();
    132.             //选择主机
    133.             //一般的负载均衡的算法
    134.             //1.随机数法 + hash
    135.             //2.轮询 + hash
    136.             int online_num = online.size();//在线主机的个数
    137.             if(online_num == 0){
    138.                 mtx.unlock();
    139.                 LOG(FATAL) << "所有的后端编译主机已经全部离线，请后端的尽快重启"<<"\n";
    140.                 return false;
    141.             }
    142.             LOG(DEBUG)<<"online:"<size()<<"\n";
    143.             //通过编译，找到负载最小的机器
    144.             *id = online[0];
    145.             *m = &machines[online[0]];
    146.             uint64_t min_load = machines[online[0]].Load();
    147.             for(int i = 1;i
    148.             {
    149.                 uint64_t curr_load = machines[online[i]].Load();
    150.                 if(min_load > curr_load){
    151.                     min_load = curr_load;
    152.                     *id = online[i];
    153.                     *m = &machines[online[i]];
    154.                 }
    155.             }
    156.             
    157.             mtx.unlock();
    158.             return true;
    159.         }
    160.         void OfflineMachine(int which)
    161.         {
    162.             mtx.lock();
    163.             for(auto iter = online.begin();iter!=online.end();iter++)
    164.             {
    165.                 if(*iter == which){
    166.                     //要离线的主机找到了
    167.                     machines[which].ResetLoad();
    168.                     LOG(DEBUG)<<"当前离线主机的负载更改为："<
    169.                     online.erase(iter);
    170.                     offline.push_back(which);
    171.                     break;//因为break的存在，所以暂时不考虑迭代器失效的问题
    172.                 }
    173.             }
    174.             mtx.unlock();
    175.         }
    176.         void OnlineMachine()
    177.         {
    178.             //我们统一上线,后面统一解决
    179.             mtx.lock();
    180.             
    181.             online.insert(online.end(),offline.begin(),offline.end());
    182.             offline.erase(offline.begin(),offline.end());
    183.             mtx.unlock();
    184.             LOG(INFO)<<"所有的主机又上线了"<<"\n";
    185.             LOG(INFO)<<"online:"<size()<<"offline"<size()<<"\n";
    186.             
    187.  
    188.         }
    189.         void ShowMachines()
    190.         {
    191.             mtx.lock();
    192.             LOG(INFO)<<"online:"<size()<<"offline"<size()<<"\n";
    193.             mtx.unlock();
    194.         }
    195.     };
    196.  
    197.     //这是我们核心业务逻辑的控制器
    198.     class Control
    199.     {
    200.     private:
    201.         Model model_;//提供后台数据
    202.         View view_; //提供网页渲染功能
    203.         LoadBalance load_blance_; //核心负载均衡器
    204.     public:
    205.         void RecoveryMachine()
    206.         {
    207.             load_blance_.OnlineMachine();
    208.         }
    209.         //根据题目数据构建网页
    210.         //html：输出型参数
    211.         bool AllQuestions(string *html)
    212.         {
    213.             bool ret = true;
    214.             vector all;
    215.             if(model_.GetAllQuestion(&all))
    216.             {
    217.                 sort(all.begin(),all.end(),[](const Question &q1,const Question &q2){
    218.                     return atoi(q1.number.c_str()) < atoi(q2.number.c_str());
    219.                 });
    220.  
    221.                 //获取题目信息 成功，将所有的题目数据构建成网页
    222.                 view_.AllExpandHtml(all,html);
    223.             }
    224.             else
    225.             {
    226.                 *html="获取题目失败，形成题目列表失败";
    227.                 ret = false;
    228.             }
    229.             return ret;
    230.         }
    231.         bool OneQuestion(const string &number,string *html)
    232.         {
    233.             Question q;
    234.             bool ret = true;
    235.             if(model_.GetOneQuestion(number,&q))
    236.             {
    237.                 //获取指定信息的题目成功，构建程网页
    238.                 view_.OneExpandHtml(q,html);
    239.             }
    240.             else
    241.             {
    242.                 *html="获取指定题目题目失败，形成题目列表失败";
    243.                 ret = false;
    244.             }
    245.             return ret;
    246.         }
    247.         void Login(const std::string in_json,std::string *out_json)
    248.         {
    249.             //in_json是发送过来的请求数据，用户的账号等待
    250.             //返回渲染的登录界面
    251.             view_.LoginExpandHtml(out_json);
    252.  
    253.         }
    254.         void Register(const std::string in_json,std::string *out_json)
    255.         {
    256.             if(view_.RegisterExpandHtml(out_json)){
    257.                 LOG(INFO)<<"插入成功"<<"\n";
    258.             }
    259.             else{
    260.                 LOG(INFO)<<"插入失败，可能是重复的用户"<<"\n";
    261.             }
    262.             
    263.         }
    264.         bool UserRegister(const std::string in_json,std::string *out_json)
    265.         {
    266.             return model_.UserRegister(in_json,out_json);
    267.         }
    268.         //id:: 100 
    269.         //code:include
    270.         //input:
    271.         void Judge(const std::string &number,const std::string in_json,std::string *out_json)
    272.         {
    273.             // LOG(INFO)<<"调用Judge功能"<<"\n";
    274.             // LOG(DEBUG)<
    275.             //0.根据题目编号，拿到题目细节
    276.             Question q;
    277.             model_.GetOneQuestion(number,&q);
    278.             //1.in_json反序列化 ，得到题目的id，得到源代码，input
    279.             Json::Reader reader;
    280.             Json::Value in_value;
    281.             reader.parse(in_json,in_value);
    282.             std::string code = in_value["code"].asString();
    283.             //2.重新拼接用户代码+测试用例代码，形成新的代码
    284.             Json::Value compile_value;
    285.             compile_value["input"] = in_value["input"].asString();
    286.             compile_value["code"] = code + q.tail;
    287.             compile_value["cpu_limit"] = q.cpu_limit;
    288.             compile_value["mem_limit"] = q.mem_limit;
    289.             Json::FastWriter writer;
    290.             std::string compile_string = writer.write(compile_value);
    291.             //3.选择负载最低的主机，然后发起HTTP请求得到结果
    292.             //规则：一直选择，直到主机可用，否则就是全部挂掉
    293.             while(true)
    294.             {
    295.                 int id = 0;
    296.                 Machine *m = nullptr;
    297.                 if(!load_blance_.SmartChoice(&id,&m))
    298.                 {   
    299.                     break;
    300.                 }
    301.                  //4.*out_json = 将结果复制给out_json
    302.                 Client cli(m->ip,m->port);
    303.                 m->IncLoad();
    304.                 LOG(DEBUG)<<"选择主机成功，主机id:"<"\n详情："<ip<<":"<port<<"当前主机负载："<Load()<<"\n";
    305.                 if(auto res = cli.Post("/compile_and_run",compile_string,"application/json;charset=utf-8"))
    306.                 {
    307.                     //将我们的结果返回给out_json
    308.                     if(res->status == 200)
    309.                     {
    310.                         *out_json = res->body;
    311.                         m->DecLoad();
    312.                         LOG(INFO)<<"请求编译和运行服务成功..."<<"\n";
    313.                         break;
    314.                     }                        
    315.                     m->DecLoad();
    316.  
    317.                 }
    318.                 else
    319.                 {
    320.                     //请求失败
    321.                     LOG(ERROR)<<"选择主机失败，主机id:"<"详情："<ip<<":"<port<<"可能已经离线"<<"\n";
    322.                     load_blance_.OfflineMachine(id);
    323.                     load_blance_.ShowMachines();//仅仅为了调试
    324.                     
    325.                 }
    326.                 //m->DecLoad();
    327.             }
    328.            
    329.  
    330.         }
    331.         Control(){}
    332.         ~Control(){}
    333.     };
    334. }

    control模块实现了 负载均衡

    • 负载均衡
      • 第一种：随机数+hash
      • 第二种：轮询+hash ， 本文是在用轮询+hash
    • 为了实现负载均衡所有要把所有主机管理起来，有了Machine类
      • std::string ip ：编译服务器的ip
      • int port：编译服务器的端口
      • uint64_t load ：编译服务器的负载
      • std::mutex *mtx：每个机器可能会同时被多个用户访问，所以要有锁来保证临界资源，并且mutex是不允许拷贝的，所以这里直接用指针，这样在赋值构造和拷贝构造就没事了

     

     view渲染功能：将后端的代码渲染到html返回给前端

    这里就要使用到ctemplate库了：

    0ac4557f0c2242cab7e55958412ab2ab.png

     

     

    1. #pragma once
    2.  
    3. #include
    4. #include
    5. #include
    6. // #include"oj_model.hpp"
    7. #include"oj_model2.hpp"
    8.  
    9.  
    10.  
    11. namespace ns_view
    12. {
    13.     using namespace ns_model;
    14.  
    15.     const std::string template_path ="./template_html/";
    16.     const std::string login_path = "./login_html/";
    17.     class View
    18.     {
    19.  
    20.     public:
    21.         View(){}
    22.         ~View(){}
    23.         bool RegisterExpandHtml(std::string *html)
    24.         {
    25.             //新城路径
    26.             std::string src_html = login_path + "register.html";
    27.             //形成数据字典
    28.             ctemplate::TemplateDictionary root("register");
    29.             //获取渲染的网页
    30.             ctemplate::Template *tpl = ctemplate::Template::GetTemplate(src_html,ctemplate::DO_NOT_STRIP);
    31.             //开始渲染
    32.             tpl->Expand(html,&root);
    33.             return true;
    34.         }
    35.         void LoginExpandHtml(std::string *html)
    36.         {
    37.             //形成路径
    38.             std::string src_html = login_path + "login.html";
    39.             //形成数据字典
    40.             ctemplate::TemplateDictionary root("my_login");
    41.             //获取渲染网页
    42.             ctemplate::Template *tpl = ctemplate::Template::GetTemplate(src_html,ctemplate::DO_NOT_STRIP);
    43.             //开始渲染
    44.             tpl->Expand(html,&root);
    45.         }
    46.         void AllExpandHtml(const vector &questions,std::string *html)
    47.         {
    48.             // 题目的编号 题目的标题 题目的难度
    49.             // 推荐使用表格显示
    50.             //1。形成路径
    51.             std::string src_html = template_path + "all_questions.html";
    52.             LOG(INFO)<<"形成路径成功:"<< src_html <<"\n";
    53.             //2.形成数据字典
    54.             ctemplate::TemplateDictionary root("all_questions");
    55.             for(const auto& q:questions)
    56.             {
    57.                 ctemplate::TemplateDictionary *sub = root.AddSectionDictionary("question_list");
    58.                 sub->SetValue("number",q.number);
    59.                 sub->SetValue("title",q.title);
    60.                 sub->SetValue("star",q.star);
    61.             }
    62.             //3.获取被渲染的网页html
    63.             ctemplate::Template *tpl = ctemplate::Template::GetTemplate(src_html,ctemplate::DO_NOT_STRIP);
    64.             LOG(INFO)<<"获取渲染网页的html成功"<<"\n";
    65.  
    66.             //4.开始完成渲染功能
    67.             tpl->Expand(html,&root);
    68.             LOG(INFO)<<"渲染成功"<<"\n";
    69.  
    70.         }
    71.         void OneExpandHtml(const Question &q,std::string *html)
    72.         {
    73.             //形成路径
    74.             std::string src_html = template_path + "one_question.html";
    75.             LOG(DEBUG)<<"one expand html :"<"\n";
    76.             //q.desc
    77.             //形成数字典
    78.             ctemplate::TemplateDictionary root("one_question");
    79.             root.SetValue("number",q.number);
    80.             root.SetValue("title",q.title);
    81.             root.SetValue("star",q.star);
    82.             root.SetValue("desc",q.desc);
    83.             root.SetValue("pre_code",q.header);
    84.             //获取被渲染的html
    85.             ctemplate::Template *tpl = ctemplate::Template::GetTemplate(src_html,ctemplate::DO_NOT_STRIP);
    86.             //开始渲染功能
    87.             tpl->Expand(html,&root);
    88.         }
    89.     };
    90. }

     

     

    总结 

    1.前端的代码在博客最上端绑定的文件当中 ，篇幅太长不展示出来了

    2.该项目的技术栈众多，是c++后端和前端进行交互的一个项目

    3.项目的难点有：负载均衡的分配到每一台编译服务器、容错处理，能够处理多种不同的错误原因、并发处理要对临界资源的管理、以及高并发访问的话要对效率有所保证，毕竟在线oj服务是具有时效性的

    4.debug困难，要在test.cc下测试成功后再进行编写，便于修改bug

     

     

     

     

     

     

     

     

     

     

     

     

     

     

  • 相关阅读:
    车企数智化丨帷幄SDP数字化护航经销商业务健康度
    2022年最新安徽建筑施工信号工（建筑特种作业）考试真题题库及答案
    LeetCode[636]函数的独占时间
    Tableau自学四部曲_Part3：基础图表制作
    【软考软件评测师】第二十五章 系统安全设计（网络攻击）
    【图论 树 深度优先搜索】2246. 相邻字符不同的最长路径
    第十二章 配置 Apache 以与 Web 网关配合使用 (Windows)
    厉害了！阿里内部都用的Spring+MyBatis源码手册，实战理论两不误
    docker安装anaconda3 python环境
    GEE16: 区域日均降水量计算
  • 原文地址：https://blog.csdn.net/Obto_/article/details/132558354