• 负载均衡在线oj

    1.项目源码🌹load-balanced-online-oj · fortianyang/project - 码云 - 开源中国 (gitee.com)

    2.相关技术⭐

    ⭕C++ STL 标准库
    ⭕Boost 准标准库(字符串切割)
    ⭕cpp-httplib 第三方开源网络库
    ⭕ctemplate 第三方开源前端网页渲染库
    ⭕jsoncpp 第三方开源序列化、反序列化库
    ⭕负载均衡设计
    ⭕多进程、多线程

    3. 开发环境 ⚙  

    ⭕quanCentos 7 云服务器
    ⭕vscode

    4.项目结构 🌼

    5. compile服务设计🌼

    compile： 编译并且运行代码，得到格式化的相关结果

    第一个功能compiler ：编译功能❀ ❀❀

    ✍compile代码实现❤

    1. //compile.hpp
    2. #pragma once
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #include "../comm/util.hpp"
    12. #include "../comm/log.hpp"
    13.  
    14. // 只负责进行代码的编译
    15.  
    16. namespace ns_compiler
    17. {
    18.     // 引入路径拼接功能
    19.     using namespace ns_util;
    20.     using namespace ns_log;
    21.  
    22.     class Compiler
    23.     {
    24.     public:
    25.         Compiler()
    26.         {}
    27.         ~Compiler()
    28.         {}
    29.         //返回值：编译成功：true，否则：false
    30.         //输入参数：编译的文件名
    31.         //file_name: 1234
    32.         //1234 -> ./temp/1234.cpp
    33.         //1234 -> ./temp/1234.exe
    34.         //1234 -> ./temp/1234.stderr
    35.         static bool Compile(const std::string &file_name)
    36.         {
    37.             pid_t pid = fork();
    38.             if(pid < 0)
    39.             {
    40.                 LOG(ERROR) << "内部错误，创建子进程失败" << "\n";
    41.                 return false;
    42.             }
    43.             else if (pid == 0)
    44.             {
    45.                 umask(0);//⭐ 小细节 (*^_^*)
    46.                 int _stderr = open(PathUtil::CompilerError(file_name).c_str(), O_CREAT | O_WRONLY, 0644);
    47.                 if(_stderr < 0){
    48.                     LOG(WARNING) << "没有成功形成stderr文件" << "\n";
    49.                     exit(1);
    50.                 }
    51.                 //重定向标准错误到_stderr
    52.                 dup2(_stderr, 2);
    53.                 
    54.                 //程序替换，并不影响进程的文件描述符表
    55.                 //子进程: 调用编译器，完成对代码的编译工作
    56.                 //g++ -o target src -std=c++11
    57.                 execlp("g++", "g++", "-o", PathUtil::Exe(file_name).c_str(),\
    58.                  PathUtil::Src(file_name).c_str(),"-std=c++11",  nullptr/*不要忘记*/);//♥
    59.                 // PathUtil::Src(file_name).c_str(), "-D", "COMPILER_ONLINE","-std=c++11",  nullptr/*不要忘记*/);//♥
    60.                
    61.                 LOG(ERROR) << "启动编译器g++失败，可能是参数错误" << "\n";
    62.                 exit(2);//♥
    63.             }
    64.             else{
    65.                 waitpid(pid, nullptr, 0);
    66.                 //编译是否成功,就看有没有形成对应的可执行程序
    67.                 if(FileUtil::IsFileExists(PathUtil::Exe(file_name))){
    68.                     LOG(INFO) << PathUtil::Src(file_name) << " 编译成功!" << "\n";
    69.                     return true;
    70.                 }
    71.             }
    72.             LOG(DEBUG)<Src(file_name)<<"\n";
    73.             LOG(ERROR) << "编译失败，没有形成可执行程序" << "\n";
    74.             return false;//♥
    75.         }
    76.     };
    77. }
    ✍Log功能♥
    1. //log.hpp
    2. #pragma once
    3.  
    4. #include 
    5. #include 
    6. #include "util.hpp"
    7.  
    8. namespace ns_log
    9. {
    10.     using namespace ns_util;
    11.  
    12.     // 日志等级
    13.     enum
    14.     {
    15.         INFO, //就是整数
    16.         DEBUG,
    17.         WARNING,
    18.         ERROR,
    19.         FATAL
    20.     };
    21.  
    22.     inline std::ostream &Log(const std::string &level, const std::string &file_name, int line)
    23.     {
    24.         // 添加日志等级
    25.         std::string message = "[";
    26.         message += level;
    27.         message += "]";
    28.  
    29.         // 添加报错文件名称
    30.         message += "[";
    31.         message += file_name;
    32.         message += "]";
    33.  
    34.         // 添加报错行
    35.         message += "[";
    36.         message += std::to_string(line);
    37.         message += "]";
    38.  
    39.         // 日志时间戳
    40.         message += "[";
    41.         message += TimeUtil::GetTimeStamp();
    42.         message += "]";
    43.  
    44.         // cout 本质 内部是包含缓冲区的
    45.         std::cout << message; //不要endl进行刷新
    46.  
    47.         return std::cout;
    48.     }
    49.     // LOG(INFo) << "message" << "\n";
    50.     // 开放式日志
    51.     #define LOG(level) Log(#level, __FILE__, __LINE__)
    52. }
    ✍工具类♥
    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.  
    14. namespace ns_util
    15. {
    16.     class TimeUtil
    17.     {
    18.     public:
    19.         static std::string GetTimeStamp()
    20.         {
    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.  
    36.     class PathUtil
    37.     {
    38.     public:
    39.         static std::string AddSuffix(const std::string &file_name, const std::string &suffix)
    40.         {
    41.             std::string path_name = temp_path;
    42.             path_name += file_name;
    43.             path_name += suffix;
    44.             return path_name;
    45.         }
    46.         // 编译时需要有的临时文件
    47.         // 构建源文件路径+后缀的完整文件名
    48.         // 1234 -> ./temp/1234.cpp
    49.         static std::string Src(const std::string &file_name)
    50.         {
    51.             return AddSuffix(file_name, ".cpp");
    52.         }
    53.         // 构建可执行程序的完整路径+后缀名
    54.         static std::string Exe(const std::string &file_name)
    55.         {
    56.             return AddSuffix(file_name, ".exe");
    57.         }
    58.         static std::string CompilerError(const std::string &file_name)
    59.         {
    60.             return AddSuffix(file_name, ".compile_error");
    61.         }
    62.  
    63.         // 运行时需要的临时文件
    64.         static std::string Stdin(const std::string &file_name)
    65.         {
    66.             return AddSuffix(file_name, ".stdin");
    67.         }
    68.         static std::string Stdout(const std::string &file_name)
    69.         {
    70.             return AddSuffix(file_name, ".stdout");
    71.         }
    72.         // 构建该程序对应的标准错误完整的路径+后缀名
    73.         static std::string Stderr(const std::string &file_name)
    74.         {
    75.             return AddSuffix(file_name, ".stderr");
    76.         }
    77.     };
    78.  
    79.     class FileUtil
    80.     {
    81.     public:
    82.         static bool IsFileExists(const std::string &path_name)
    83.         {
    84.             struct stat st;
    85.             if (stat(path_name.c_str(), &st) == 0)
    86.             {
    87.                 //获取属性成功，文件已经存在
    88.                 return true;
    89.             }
    90.  
    91.             return false;
    92.         }
    93.         static std::string UniqFileName()
    94.         {
    95.             static std::atomic_uint id(0);
    96.             id++;
    97.             // 毫秒级时间戳+原子性递增唯一值: 来保证唯一性
    98.             std::string ms = TimeUtil::GetTimeMs();
    99.             std::string uniq_id = std::to_string(id);
    100.             return ms + "_" + uniq_id;
    101.         }
    102.         static bool WriteFile(const std::string &target, const std::string &content)
    103.         {
    104.             std::ofstream out(target);
    105.             if (!out.is_open())
    106.             {
    107.                 return false;
    108.             }
    109.             out.write(content.c_str(), content.size());
    110.             out.close();
    111.             return true;
    112.         }
    113.         static bool ReadFile(const std::string &target, std::string *content, bool keep = false)
    114.         {
    115.             (*content).clear();
    116.  
    117.             std::ifstream in(target);
    118.             if (!in.is_open())
    119.             {
    120.                 return false;
    121.             }
    122.             std::string line;
    123.             // getline:不保存行分割符,有些时候需要保留\n,
    124.             // getline内部重载了强制类型转化
    125.             while (std::getline(in, line))
    126.             {
    127.                 (*content) += line;
    128.                 (*content) += (keep ? "\n" : "");
    129.             }
    130.             in.close();
    131.             return true;
    132.         }
    133.     };
    134.  
    135.     class StringUtil
    136.     {
    137.     public:
    138.         /*************************************
    139.          * str: 输入型，目标要切分的字符串
    140.          * target: 输出型，保存切分完毕的结果
    141.          * sep: 指定的分割符
    142.          * **********************************/
    143.         static void SplitString(const std::string &str, std::vector *target, const std::string &sep)
    144.         {
    145.             //boost split
    146.             boost::split((*target), str, boost::is_any_of(sep), boost::algorithm::token_compress_on);
    147.         }
    148.     };
    149. }
    ✍测试♥

    编译功能的基本代码已经完成，我们可以简单编写一个 temp目录，再在该目录下编写一个code.cpp才进行测试

    1. //code.cc
    2. #include
    3.  
    4. int main()
    5. {
    6. //aaa--也可以加一点错误的信息，更好观察stderr的内容⭐
    7.     std::cout<<"hello"<
    8.     return 0;
    9. }
    1. //compile_server.cc
    2. #include"compiler.hpp"
    3.  
    4. using namespace ns_compiler;
    5.  
    6.  
    7. #include "compile_run.hpp"
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     std::string code="code";
    12.     Compiler::Compile(code);
    13.     return 0;
    14. }

    📕 📕运行结果
    📕 运行结果 1.0

    正常运行结束，stderr无输出。

    📕运行结果 2.0

    1. ./temp/code.cpp: In function ‘int main()’:
    2. ./temp/code.cpp:6:5: error: ‘aaa’ was not declared in this scope
    3.      aaa
    4.      ^
    5. ./temp/code.cpp:7:5: error: expected ‘;’ before ‘std’
    6.      std::cout<<"hello"<<std::endl;
    7.      ^

    第二个功能 runner ：运行功能🌼

    功能分析

    ⭕ 程序运行：

    🐱      1. 代码跑完，结果正确

    🐱      2. 代码跑完，结果不正确

    🐱       3. 代码没跑完，异常了

    🐱        Run需要考虑代码跑完，结果正确与否吗？？不考虑！

     ▷      结果正确与否：是由我们的测试用例决定的！

     ▷        我们只考虑：是否正确运行完毕

                 *

    🐱      我们必须知道可执行程序是谁？

     ▷        一个程序在默认启动的时候

             ▷       标准输入: 不处理

             ▷        标准输出: 程序运行完成，输出结果是什么

             ▷       标准错误: 运行时错误信息

    ❀基础版本

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

    ✍ 测试

    1. #include"compiler.hpp"
    2. #include"runner.hpp"
    3.  
    4. using namespace ns_compiler;
    5. using namespace ns_runner;
    6.  
    7. int main(int argc, char *argv[])
    8. {
    9.     std::string code="code";
    10.     Compiler::Compile(code);
    11.     Runner::Run(code);
    12.     return 0;
    13. }

    测试结果

    程序正常运行结束，code.compile_error无输出

    ✍ 添加测试资源限制

    小测试

    我们通过下面这个简单的小实验来测试限制运行资源和时间资源，避免一些死循环或者资源消耗过大的测试恶意攻击

    1. #include 
    2. #include
    3. #include 
    4. #include 
    5. #include
    6. #include
    7. #include
    8.  
    9. void handler(int signo)
    10. {
    11.     std::cout<<"signo : "<
    12. }
    13. int main()
    14. {
    15.     // 资源不足导致os终止进程，是通过信号终止的
    16.     for(int i;i<=31;i++)
    17.     {
    18.         signal(i,handler);
    19.     }
    20.     // //限制累计运行时长
    21.     // struct rlimit r;
    22.     // r.rlim_cur=1;
    23.     // r.rlim_max=RLIM_INFINITY;
    24.     // setrlimit(RLIMIT_CPU,&r);
    25.     // while (1) ;
    26.  
    27.  
    28.     //限制使用的空间大小
    29.     struct rlimit r;
    30.     r.rlim_cur=1024*1024*40;//20M
    31.     r.rlim_max=RLIM_INFINITY;
    32.     setrlimit(RLIMIT_AS,&r);
    33.     int count=0;
    34.     while(true)
    35.     {
    36.         int *p=new int[1024*1024];
    37.         count++;
    38.         std::cout<<"size: "<
    39.         sleep(1);
    40.     }
    41.     return 0;
    42. }
    测试结果

    添加资源限制功能到runner中

    代码实现

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

    通常我们的code.cpp并不是直接写在我们的某个文件夹中的，需要我们从网络中获取，这就需要我们了解一点json相关的知识了。

    安装json

    sudo yum install -y jsoncpp-devel

    使用json

    ✍ 代码示例

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. int main()
    9. {
    10.     //序列化
    11.     //Value是Json的一个中间类，可以填充k，v对象
    12.     Json::Value root;
    13.     root["value"]="mycode";
    14.     root["user"]="hty";
    15.     root["age"]="22";
    16.  
    17.     // Json::StyledWriter writer;
    18.     //反序列化
    19.     Json::FastWriter writer;
    20.     std::string str=writer.write(root);
    21.     std::cout<
    22.  
    23.     return 0;
    24. }

    运行结果

    compile_run 模块

    分析

         ⭕输入:

                🐟 code： 用户提交的代码

                🐟 input: 用户给自己提交的代码对应的输入，不做处理

                🐟cpu_limit: 时间要求

                🐟 mem_limit: 空间要求

       

        ⭕输出:

            🐱 必填

                🐟status: 状态码

                🐟 reason: 请求结果

            🐱 选填：

                🐟stdout: 我的程序运行完的结果

                🐟stderr: 我的程序运行完的错误结果

    ✍compile_run.hpp代码 
    1. #pragma once
    2.  
    3. #include "compiler.hpp"
    4. #include "runner.hpp"
    5. #include "../comm/log.hpp"
    6. #include "../comm/util.hpp"
    7.  
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. namespace ns_compile_and_run
    13. {
    14.     using namespace ns_log;
    15.     using namespace ns_util;
    16.     using namespace ns_compiler;
    17.     using namespace ns_runner;
    18.  
    19.     class CompileAndRun
    20.     {
    21.     public:
    22.         // code > 0 : 进程收到了信号导致异常奔溃
    23.         // code < 0 : 整个过程非运行报错(代码为空，编译报错等)
    24.         // code = 0 : 整个过程全部完成
    25.         //待完善
    26.         static std::string CodeToDesc(int code, const std::string &file_name)
    27.         {
    28.             std::string desc;
    29.             switch (code)
    30.             {
    31.             case 0:
    32.                 desc = "编译运行成功";
    33.                 break;
    34.             case -1:
    35.                 desc = "提交的代码是空";
    36.                 break;
    37.             case -2:
    38.                 desc = "未知错误";
    39.                 break;
    40.             case -3:
    41.                 // desc = "代码编译的时候发生了错误";
    42.                 FileUtil::ReadFile(PathUtil::CompilerError(file_name), &desc, true);
    43.                 break;
    44.             case SIGABRT: // 6
    45.                 desc = "内存超过范围";
    46.                 break;
    47.             case SIGXCPU: // 24
    48.                 desc = "CPU使用超时";
    49.                 break;
    50.             case SIGFPE: // 8
    51.                 desc = "浮点数溢出";
    52.                 break;
    53.             default:
    54.                 desc = "未知: " + std::to_string(code);
    55.                 break;
    56.             }
    57.  
    58.             return desc;
    59.         }
    60.  
    61.         /***************************************
    62.          * 输入:
    63.          * code： 用户提交的代码
    64.          * input: 用户给自己提交的代码对应的输入，不做处理
    65.          * cpu_limit: 时间要求
    66.          * mem_limit: 空间要求
    67.          *
    68.          * 输出:
    69.          * 必填
    70.          * status: 状态码
    71.          * reason: 请求结果
    72.          * 选填：
    73.          * stdout: 我的程序运行完的结果
    74.          * stderr: 我的程序运行完的错误结果
    75.          *
    76.          * 参数：
    77.          * in_json: {"code": "#include...", "input": "","cpu_limit":1, "mem_limit":10240}
    78.          * out_json: {"status":"0", "reason":"","stdout":"","stderr":"",}
    79.          * ************************************/
    80.         static void Start(const std::string &in_json, std::string *out_json)
    81.         {
    82.             Json::Value in_value;
    83.             Json::Reader reader;
    84.             reader.parse(in_json, in_value); //最后在处理差错问题
    85.  
    86.             std::string code = in_value["code"].asString();
    87.             std::string input = in_value["input"].asString();
    88.             int cpu_limit = in_value["cpu_limit"].asInt();
    89.             int mem_limit = in_value["mem_limit"].asInt();
    90.  
    91.             int status_code = 0;
    92.             Json::Value out_value;//返回数据
    93.             int run_result = 0;
    94.             std::string file_name; //需要内部形成的唯一文件名
    95.  
    96.             if (code.size() == 0)
    97.             {
    98.                 status_code = -1; //代码为空
    99.                 goto END;
    100.             }
    101.             // 形成的文件名只具有唯一性，没有目录没有后缀
    102.             // 毫秒级时间戳+原子性递增唯一值: 来保证唯一性
    103.             file_name = FileUtil::UniqFileName();
    104.             //形成临时src文件
    105.             if (!FileUtil::WriteFile(PathUtil::Src(file_name), code))
    106.             {
    107.                 status_code = -2; //未知错误
    108.                 goto END;
    109.             }
    110.  
    111.             if (!Compiler::Compile(file_name))
    112.             {
    113.                 //编译失败
    114.                 status_code = -3; //代码编译的时候发生了错误
    115.                 goto END;
    116.             }
    117.  
    118.             run_result = Runner::Run(file_name, cpu_limit, mem_limit);
    119.             if (run_result < 0)
    120.             {
    121.                 status_code = -2; //未知错误
    122.             }
    123.             else if (run_result > 0)
    124.             {
    125.                 //程序运行崩溃了
    126.                 status_code = run_result;
    127.             }
    128.             else
    129.             {
    130.                 //运行成功
    131.                 status_code = 0;
    132.             }
    133.         END:
    134.             out_value["status"] = status_code;
    135.             out_value["reason"] = CodeToDesc(status_code, file_name);
    136.             if (status_code == 0)
    137.             {
    138.                 // 整个过程全部成功
    139.                 std::string _stdout;
    140.                 FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
    141.                 out_value["stdout"] = _stdout;
    142.  
    143.                 std::string _stderr;
    144.                 FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr, true);
    145.                 out_value["stderr"] = _stderr;
    146.             }
    147.  
    148.             Json::StyledWriter writer;
    149.             *out_json = writer.write(out_value);
    150.  
    151.         }
    152.     };
    153. }
    测试
    ✍代码示例
    1. #include "compile_run.hpp"
    2.  
    3. using namespace ns_compiler;
    4. using namespace ns_runner;
    5. using namespace ns_compile_and_run;
    6.  
    7. int main(int argc, char *argv[])
    8. {
    9.     //通过Http 让client给我们上传一个json string
    10.     std::string in_json;
    11.  
    12.     Json::Value in_value;
    13.     in_value["code"]=R"(#include
    14.     int main(){
    15.         std::cout << "你可以看见我了" << std::endl;
    16.         //aaaaaaaa
    17.         return 0;
    18.     })";
    19.     in_value["input"]="";
    20.     in_value["cpu_cimit"]=1;
    21.     in_value["mem_limit"]=10240*3;
    22.  
    23.     Json::FastWriter writer;
    24.     in_json=writer.write(in_value);
    25.     std::cout<
    26.  
    27.     // CompileAndRun::Start();
    28.     return 0;
    29. }
    📕 输出结果1.0：

    📕输出结果2.0：（源文件里有错误的代码）

    添加清理功能

    1.         static void RemoveTempFile(const std::string &file_name)
    2.         {
    3.             //清理文件的个数是不确定的，但是有哪些我们是知道的
    4.             std::string _src = PathUtil::Src(file_name);
    5.             if(FileUtil::IsFileExists(_src)) unlink(_src.c_str());
    6.  
    7.             std::string _compiler_error = PathUtil::CompilerError(file_name);
    8.             if(FileUtil::IsFileExists(_compiler_error)) unlink(_compiler_error.c_str());
    9.  
    10.             std::string _execute = PathUtil::Exe(file_name);
    11.             if(FileUtil::IsFileExists(_execute)) unlink(_execute.c_str());
    12.  
    13.             std::string _stdin = PathUtil::Stdin(file_name);
    14.             if(FileUtil::IsFileExists(_stdin)) unlink(_stdin.c_str());
    15.  
    16.             std::string _stdout = PathUtil::Stdout(file_name);
    17.             if(FileUtil::IsFileExists(_stdout)) unlink(_stdout.c_str());
    18.  
    19.             std::string _stderr = PathUtil::Stderr(file_name);
    20.             if(FileUtil::IsFileExists(_stderr)) unlink(_stderr.c_str());
    21.         }

    将函数调用添加到END部分即可，为了观察现象比较明显，暂时屏蔽掉

    第三个功能: 把编译并运行功能，形成网络服务

    引入httplib第三方库
    最新的cpp-httplib在使用的时候，如果gcc不是特别新的话有可能会有运行时错误的问题
    建议：cpp-httplib 0.7.15
    下载zip安装包，上传到服务器即可
    cpp-httplib gitee链接：https://gitee.com/yuanfeng1897/cpp-httplib?_from=gitee_search
    v0.7.15版本链接： https://gitee.com/yuanfeng1897/cpp-httplib/tree/v0.7.15
    把httplib.h拷贝到我们的项目中即可，就这么简单(可以用vscode打开笨的下载好的文件夹，直接将文件夹拷贝到云服务器上，最好是单的的目录下，再拷贝对应的httplib.h文件到comm目录下)

    另外，使用这个文件需要将gcc进行升级

    升级 gcc
    百度搜索： scl gcc devsettool 升级 gcc
    安装 scl 
    $ sudo yum install centos-release-scl scl-utils-build
    安装新版本 gcc ，这里也可以把 7 换成 8 或者 9 ，我用的是 9 ，也可以都安装 
    1. $ sudo yum install -y devtoolset-7-gcc devtoolset-7-gcc-c++
    2. $ ls /opt/rh/

    启动： 细节，命令行启动只能在本会话有效

    1. $ scl enable devtoolset-7 bash
    2. $ gcc -v

    可选：如果想每次登陆的时候，都是较新的gcc，需要把上面的命令添加到你的~/.bash_profile中 

    1. $ cat ~/.bash_profile
    2. # .bash_profile
    3. # Get the aliases and functions
    4. if [ -f ~/.bashrc ]; then
    5. . ~/.bashrc
    添加下面的命令，每次启动的时候，都会执行这个scl命令 
    1.  
    2. scl enable devtoolset-7 bash
    3. or
    4. scl enable devtoolset-8 bash
    5. or
    6. scl enable devtoolset-9 bash

    获得下面的结果gcc 就升级好啦 🌹🌹🌹🌹🌹

    httplib文件测试

    ✍ 代码示例

    1. #include "compile_run.hpp"
    2. #include"../comm/httplib.h"
    3.  
    4. using namespace httplib;
    5. using namespace ns_compiler;
    6. using namespace ns_runner;
    7. using namespace ns_compile_and_run;
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     //使用cpp-httplib
    12.     Server svr;
    13.     svr.Get("/hello",[](const Request &req, Response &resp){
    14.         // 用来进行基本测试
    15.         resp.set_content("hello httplib,你好 httplib!", "text/plain;charset=utf-8");
    16.     });
    17.  
    18.     svr.listen("0.0.0.0",8080);
    19.  
    20.     return 0;
    21. }

    📕 输出结果

    ✍代码示例2

    wwroot目录下的index.html文件(仅作测试使用)

    1. html>
    2. <html>
    3. <head>
    4. <meta charset="utf-8">
    5. <title>测试title>
    6. head>
    7. <body>
    8.  
    9. <p>这是一个段落。p>
    10. <p>这是一个段落。p>
    11. <p>这是一个段落。p>
    12.  
    13. body>
    14. html>

    compile_server.cc

    1. #include "compile_run.hpp"
    2. #include"../comm/httplib.h"
    3.  
    4. using namespace httplib;
    5. using namespace ns_compiler;
    6. using namespace ns_runner;
    7. using namespace ns_compile_and_run;
    8.  
    9. int main(int argc, char *argv[])
    10. {
    11.     //使用cpp-httplib
    12.     Server svr;
    13.     svr.Get("/hello",[](const Request &req, Response &resp){
    14.         // 用来进行基本测试
    15.         resp.set_content("hello httplib,你好 httplib!", "text/plain;charset=utf-8");
    16.     });
    17.     svr.set_base_dir("./wwwroot");
    18.  
    19.     svr.listen("0.0.0.0",8080);
    20.  
    21.     return 0;
    22. }

    📕输出结果

    用postman软件进行测试

    5. 基于MVC 结构的oj 服务设计

    🌼🌼🌼 本质：建立一个小型网站 🌼🌼🌼
    ⭕ 1. 获取首页，用题目列表充当
    ⭕ 2. 编辑区域页面
    ⭕ 3. 提交判题功能(编译并运行)
    🐟 M: Model,通常是和数据交互的模块，比如，对题库进行增删改查（文件版，MySQL）
    🐟 V: view, 通常是拿到数据之后，要进行构建网页，渲染网页内容，展示给用户的(浏览器)
    🐟 C: control, 控制器，就是我们的核心业务逻辑

    ✍第一个功能：用户请求的服务路由功能 

    1. #include 
    2. #include 
    3.  
    4. #include "../comm/httplib.h"
    5. #include "oj_control.hpp"
    6.  
    7. using namespace httplib;
    8. using namespace ns_control;
    9.  
    10. static Control *ctrl_ptr = nullptr;
    11.  
    12. void Recovery(int signo)
    13. {
    14.     ctrl_ptr->RecoveryMachine();
    15. }
    16.  
    17. int main()
    18. {
    19.     signal(SIGQUIT, Recovery);
    20.  
    21.     //用户请求的服务路由功能
    22.     Server svr;
    23.  
    24.     Control ctrl;
    25.     ctrl_ptr = &ctrl;
    26.  
    27.     // 获取所有的题目列表
    28.     svr.Get("/all_questions", [&ctrl](const Request &req, Response &resp){
    29.         //返回一张包含有所有题目的html网页
    30.         std::string html;
    31.         ctrl.AllQuestions(&html);
    32.         //用户看到的是什么呢？？网页数据 + 拼上了题目相关的数据
    33.         resp.set_content(html, "text/html; charset=utf-8");
    34.     });
    35.  
    36.     // 用户要根据题目编号，获取题目的内容
    37.     // /question/100 -> 正则匹配
    38.     // R"()", 原始字符串raw string,保持字符串内容的原貌，不用做相关的转义
    39.     svr.Get(R"(/question/(\d+))", [&ctrl](const Request &req, Response &resp){
    40.         std::string number = req.matches[1];
    41.         std::string html;
    42.         ctrl.Question(number, &html);
    43.         resp.set_content(html, "text/html; charset=utf-8");
    44.     });
    45.  
    46.     // 用户提交代码，使用我们的判题功能(1. 每道题的测试用例 2. compile_and_run)
    47.     svr.Post(R"(/judge/(\d+))", [&ctrl](const Request &req, Response &resp){
    48.         std::string number = req.matches[1];
    49.         std::string result_json;
    50.         ctrl.Judge(number, req.body, &result_json);
    51.         resp.set_content(result_json, "application/json;charset=utf-8");
    52.         // resp.set_content("指定题目的判题: " + number, "text/plain; charset=utf-8");
    53.     });
    54.     
    55.     svr.set_base_dir("./wwwroot");
    56.     svr.listen("0.0.0.0", 8080);
    57.     return 0;
    58. }

    ✍第二个功能：题目设计

    📕分析

    ⭕   题目的编号
    ⭕   题目的标题
    ⭕   题目的难度
    ⭕   题目的描述 ， 题面
    ⭕   时间要求 ( 内部处理 )
    ⭕   空间要求 ( 内部处理 )
    🐱两批文件构成
            🐟 第一个： questions . list : 题目列表（不需要题目的内容）
            🐟 第二个：题目的描述，题目的预设置代码 ( header . cpp ), 测试用例代码 ( tail . cpp )

    测试用例的设计详细参见  测试用例设计    

    更多测试用例的编辑可以参考 题目以及测试用例

    boost库引入（用于分割字符串）

    安装boost库 🆒

    sudo yum install -y boost-devel //是boost 开发库

    ✍小实验

    1. #include 
    2.  
    3. #include 
    4. #include 
    5.  
    6. int main()
    7. {
    8.     std::vector tokens;
    9.     const std::string str = "1 判断回文数 简单 30000";
    10.     const std::string sep = " ";
    11.     // boost::split(tokens,str,boost::is_any_of(sep),boost::algorithm::token_compress_off);
    12.     boost::split(tokens, str, boost::is_any_of(sep), boost::algorithm::token_compress_on);
    13.     for (auto &iter : tokens)
    14.     {
    15.         std::cout << iter << std::endl;
    16.     }
    17.     return 0;
    18. }

    📕 运行结果

    项目中的具体使用

    ✍第三个功能：control，逻辑控制模块

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

    附加功能：需要有数据渲染
    小实验✍
    代码示例 
    1. //git clone  https://hub.fastgit.xyz/OlafvdSpek/ctemplate
    2. #include
    3. #include
    4. #include
    5.  
    6. int main()
    7. {
    8.     std::string in_html="./test.html";
    9.     std::string value="学习";
    10.  
    11.     //形成数据字典
    12.     ctemplate::TemplateDictionary root("test");
    13.     root.SetValue("key",value);
    14.  
    15.     //获取被渲染网页对象
    16.     ctemplate::Template *tpl=ctemplate::Template::GetTemplate(in_html,ctemplate::DO_NOT_STRIP);
    17.  
    18.     //添加字典数据到网页中
    19.     std::string out_html;
    20.     tpl->Expand(&out_html,&root);
    21.  
    22.     std::cout<
    23.  
    24.  
    25.     return 0;
    26. }

    📕运行结果

    ⭐ 如果后续引入了ctemplate ，一旦对网页结构进行修改，尽量的每次想看到结果，将 server 重启一下。 ctemplate 有 自己的优化加速策略，可能在内存中存在缓存网页数据(old)
    ⭐ 当我们完成全部功能之后，需要注意：
    要给编译模块添加 —D 条件编译掉测试用例中的头文件 inclde

    前端页面设计请移步 首页设计  和     后续网页设计  

    🌼🌼🌼🌼🌼🌼🌼最终显示结果🌼🌼🌼🌼🌼🌼🌼

    ​项目介绍就到这里，谢谢你那么忙。还花时间看到这个，把花花送给这么支持我的你​

  • 相关阅读:
    [微前端实战]---035react16-资讯,视频,视频详情
    mac inter 芯片遇到程序无法打开（无法验证开发者）
    【CentOS 】DHCP 更改为静态 IP 地址并且遇到无法联网
    C语言程序设计 复习总结[持续更新ing]
    微软首款AI芯片代号“雅典娜”；马斯克四年内将让“星舰”上火星丨 RTE 开发者日报 Vol.61
    mac通过docker一键部署Jenkins
    数据分析基础之《jupyter notebook工具》
    笔试强训Day2
    苹果 AR/VR 头显售价 12000 元起，网友：“买来能干啥？”
    鸿鹄工程项目管理系统 Spring Cloud+Spring Boot+Mybatis+Vue+ElementUI+前后端分离构建工程项目管理系统
  • 原文地址：https://blog.csdn.net/qq_59293418/article/details/133090556