• 负载均衡的在线OJ

    1.所用技术与开发环境

    所用技术 :
    C++ STL 标准库
    Boost 准标准库 ( 字符串切割 )
    cpp - httplib 第三方开源网络库
    ctemplate 第三方开源前端网页渲染库
    jsoncpp 第三方开源序列化、反序列化库
    负载均衡设计
    多进程、多线程
    MySQL C connect
    Ace 前端在线编辑器
    html/css/js/jquery/ajax 

    2.开发环境

    Centos 7 云服务器
    vscode
    Mysql Workbench

    3. 项目宏观结构

    我们的项目核心是三个模块
    1. comm : 公共模块
    2. compile_server : 编译与运行模块
    3. oj_server : 获取题目列表，查看题目编写题目界面，负载均衡，其他功能

    I. leetcode 结构

    只实现类似 leetcode 的题目列表 + 在线编程功能

    II. 我们的项目宏观结构

    III. 编写思路

    1. 先编写 compile_server
    2. oj_server
    3. version1 基于文件版的在线 OJ
    4. 前端的页面设计
    5. version2 基于 MySQL 版的在线 OJ

    4. compiler 服务设计

    提供的服务：编译并运行代码，得到格式化的相关的结果

     第一个功能 compiler ：编译功能 

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include "../comm/util.hpp"
    9. #include "../comm/log.hpp"
    10. //只负责代码的编译
    11. namespace ns_compiler
    12. {
    13.     //引入路径拼接功能
    14.     using namespace ns_util;
    15.     using namespace ns_log;
    16.     class Compiler
    17.     {
    18.     public:
    19.         Compiler() = default;
    20.         ~Compiler() = default;
    21.  
    22.         //返回值：编译成功：True 编译失败：False
    23.         //输入参数：编译文件名
    24.         // file_name: 123
    25.         // 123 ->./temp/123.cpp
    26.         // 123 ->./temp/123.exe
    27.         // 123 ->./temp/123.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::Error(file_name).c_str(), O_CREAT | O_WRONLY, 0644);
    40.                 if (_stderr < 0)
    41.                 {
    42.                     LOG(WARNING)<<"没有形成stderr文件"<<"\n";
    43.                     exit(1);
    44.                 }
    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", 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)))
    57.                 {
    58.                     LOG(INFO)<Src(file_name)<<"编译成功"<<"\n";
    59.                     return true;
    60.                 }
    61.             }
    62.             LOG(ERROR)<<"编译失败，没有形成可执行文件"<<"\n";
    63.             return false;
    64.         }
    65.     };
    66. }
    Log 功能 
    1. #pragma once
    2. #include 
    3. #include 
    4. #include "util.hpp"
    5. namespace ns_log
    6. {
    7.     //日志等级
    8.     enum
    9.     {
    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,const 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.         message += "[";
    36.         message += ns_util::TimeUtil::GetTimeStamp();
    37.         message += "]";
    38.  
    39.  
    40.         std::cout << message;
    41.  
    42.         return std::cout;
    43.     }
    44.  
    45.     //开放日志
    46.     #define LOG(level) Log(#level,__FILE__,__LINE__)
    47. }
    第二个功能 runner ：运行功能 
    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include "../comm/util.hpp"
    12. #include "../comm/log.hpp"
    13.  
    14.  
    15. namespace ns_runner
    16. {
    17.     class Runner
    18.     {
    19.     public:
    20.         Runner() = default;
    21.         ~Runner() = default;
    22.  
    23.     public:
    24.         static void SetProcLimit(int cpu_limit,int mem_limit)
    25.         {
    26.             //设置CPU时长
    27.             struct rlimit _cpu_limit;
    28.             _cpu_limit.rlim_max = RLIM_INFINITY;
    29.             _cpu_limit.rlim_cur = cpu_limit;
    30.             setrlimit(RLIMIT_CPU,&_cpu_limit);
    31.  
    32.             //设置内存大小
    33.  
    34.              struct rlimit _mem_limit;
    35.              _mem_limit.rlim_max = RLIM_INFINITY;
    36.              _mem_limit.rlim_cur = mem_limit*1024; //转化成KB
    37.              setrlimit(RLIMIT_AS,&_mem_limit);
    38.         }
    39.         //返回值 > 0 ,程序异常，收到信号，返回值就是信号编号
    40.         //返回值 == 0 ，正常运行完毕，结果保存到对应的临时文件
    41.         //返回值 < 0 ,内部错误
    42.         //cpu_limit:该程序运行的时候，可以使用的最大CPU资源上限
    43.         //mem_limit:该程序运行的时候，可以使用最大内存
    44.         static int Run(const std::string &file_name,int cpu_limit,int mem_limit)
    45.         {
    46.             //只考虑是否正确运行，不考虑结果是否正确
    47.             /*
    48.             一个程序在默认启动的时候
    49.             标准输入：不处理
    50.             标准输出：结果
    51.             标准错误：运行时错误信息
    52.             */
    53.             std::string _exectue = ns_util::PathUtil::Exe(file_name);
    54.             std::string _stdin = ns_util::PathUtil::Stdin(file_name);
    55.             std::string _stdout = ns_util::PathUtil::Stdout(file_name);
    56.             std::string _stderr = ns_util::PathUtil::Stderr(file_name);
    57.  
    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.             if(_stdin_fd < 0 || _stdout_fd < 0 || _stderr_fd < 0)
    64.             {
    65.                 ns_log::LOG(ERROR)<<"运行时打开文件失败"<<"\n";
    66.                 return -1;  //文件打开失败
    67.             }
    68.             pid_t pid = fork();
    69.             if (pid < 0)
    70.             {
    71.                 ns_log::LOG(ERROR)<<"运行时创建子进程失败"<<"\n";
    72.                 close(_stdin_fd);
    73.                 close(_stdout_fd);
    74.                 close(_stderr_fd);
    75.             }
    76.             else if (pid == 0)
    77.             {
    78.                 dup2(_stdin_fd,0);
    79.                 dup2(_stdout_fd,1);
    80.                 dup2(_stderr_fd,2);
    81.  
    82.                 SetProcLimit(cpu_limit,mem_limit);
    83.                 execl(_exectue.c_str(),_exectue.c_str(),nullptr);
    84.                 exit(1);
    85.             }
    86.             else
    87.             {
    88.                // std::cout<<"关闭文件描述符"<
    89.                 close(_stdin_fd);
    90.                 close(_stdout_fd);
    91.                 close(_stderr_fd);
    92.                 int status = 0;
    93.                 //进程异常收到信号
    94.                 waitpid(pid, &status,0);
    95.                 ns_log::LOG(INFO)<<"运行完毕,info:"<< (status & 0x7F) << "\n";
    96.                 return status & 0x7F;
    97.             }
    98.             return 0;
    99.         }
    100.     };
    101. }
    测试资源限制： 
    1. #include  
    2. #include  
    3. #include 
    4.  #include  
    5.  #include  
    6.  void handler(int signo) 
    7.  { 
    8.     std::cout << "signo : " << signo << std::endl; exit(1);
    9.  }
    10.  int main() 
    11.  { 
    12.     //资源不足，导致OS终止进程，是通过信号终止的 for(int i =1; i <= 31; i++)
    13.     { signal(i, handler);
    14. // struct rlimit r; 
    15.     // r.rlim_cur = 1; 
    16.     // r.rlim_max = RLIM_INFINITY;
    17.      // setrlimit(RLIMIT_CPU, &r); 
    18.      //while(1); struct rlimit r;
    19.       r.rlim_cur = 1024 * 1024 * 40;
    20.      //20M r.rlim_max = RLIM_INFINITY;
    21.       setrlimit(RLIMIT_AS, &r); 
    22.       int count = 0; while(true) 
    23.       { 
    24.         int *p = new int[1024*1024];
    25.          count++; std::cout << "size: " << count << std::endl; 
    26.          sleep(1); 
    27.       }
    28.          return 0; 
    29.     }
    30. }// 限
    // 内存申请失败
    terminate called after throwing an instance of 'std::bad_alloc'
    what (): std::bad_alloc
    signo : 6
    [ whb@bite - alicloud OnlineJudge ] $ kill - l
    1 ) SIGHUP 2 ) SIGINT 3 ) SIGQUIT 4 ) SIGILL 5 ) SIGTRAP
    6 ) SIGABRT 7 ) SIGBUS 8 ) SIGFPE 9 ) SIGKILL 10 ) SIGUSR1
    11 ) SIGSEGV 12 ) SIGUSR2 13 ) SIGPIPE 14 ) SIGALRM 15 ) SIGTERM
    16 ) SIGSTKFLT 17 ) SIGCHLD 18 ) SIGCONT 19 ) SIGSTOP 20 ) SIGTSTP
            
    //CPU 使用超时
    [ whb@bite - alicloud OnlineJudge ] $ . / a . out
    signo : 24
    [ whb@bite - alicloud OnlineJudge ] $ kill - l
    1 ) SIGHUP 2 ) SIGINT 3 ) SIGQUIT 4 ) SIGILL 5 ) SIGTRAP
    6 ) SIGABRT 7 ) SIGBUS 8 ) SIGFPE 9 ) SIGKILL 10 ) SIGUSR1
    11 ) SIGSEGV 12 ) SIGUSR2 13 ) SIGPIPE 14 ) SIGALRM 15 ) SIGTERM
    16 ) SIGSTKFLT 17 ) SIGCHLD 18 ) SIGCONT 19 ) SIGSTOP 20 ) SIGTSTP
    21 ) SIGTTIN 22 ) SIGTTOU 23 ) SIGURG 24 ) SIGXCPU 25 ) SIGXFSZ
    26 ) SIGVTALRM 27 ) SIGPROF 28 ) SIGWINCH 29 ) SIGIO 30 ) SIGPWR
    第三个功能 compile_run ：编译并运行功能 
    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include "compiler.hpp"
    7. #include "complie_run.hpp"
    8. #include "../comm/log.hpp"
    9. #include "../comm/util.hpp"
    10. #include "runner.hpp"
    11. namespace ns_compile_and_run
    12. {
    13.     class ComplieAndRun
    14.     {
    15.     public:
    16.         static std::string CodeToDesc(int  code, const std::string &file_name)
    17.         {
    18.             std::string desc;
    19.             switch (code)
    20.             {
    21.             case 0:
    22.                 desc = "编译运行成功";
    23.                 break;
    24.             case -1:
    25.                 desc = "用户提交的代码为空";
    26.                 break;
    27.             case -2:
    28.                 desc = "未知错误";
    29.                 break;
    30.             case -3:
    31.                 // desc = "代码编译是出现错误";
    32.                 ns_util::FileUtil::ReadFile(ns_util::PathUtil::Error(file_name), &desc, true);
    33.                 break;
    34.             case SIGABRT: // 6
    35.                 desc = "内存超过范围";
    36.                 break;
    37.             case SIGXCPU: // 24
    38.                 desc = "CPU使用超时";
    39.                 break;
    40.             case SIGFPE:             // 8
    41.                 desc = "浮点数溢出"; //除0
    42.                 break;
    43.             default:
    44.                 desc = "未知错误" + std::to_string(code);
    45.                 break;
    46.             }
    47.             return desc;
    48.         }
    49.  
    50.     public: 
    51.         static void RemoveTempFile(const std::string &file_name)
    52.         {
    53.             std::vector AllTempFile{ns_util::PathUtil::Src(file_name),
    54.                                                 ns_util::PathUtil::Error(file_name),
    55.                                                 ns_util::PathUtil::Exe(file_name),
    56.                                                 ns_util::PathUtil::Stderr(file_name),
    57.                                                 ns_util::PathUtil::Stdin(file_name),
    58.                                                 ns_util::PathUtil::Stdout(file_name)};
    59.             for(const auto &e :AllTempFile)
    60.             {
    61.                 if(ns_util::FileUtil::IsFileExists(e));
    62.                 unlink(e.c_str());
    63.             }
    64.         }
    65.         /*
    66.             输入：
    67.             code:用户给自己提交的代码
    68.             input:用户给自己的代码对应的输入，不作处理(后期可以扩展)
    69.             cpu_limit:时间复杂度
    70.             mem_limit:时间复杂度
    71.             输出：
    72.             status:状态码(必填)
    73.             reason:请求结果(必填)
    74.             stdout:程序运行结果(选填)
    75.             stderr:程序运行完的错误结果(选填)
    77.         */
    78.         //参数
    79.         // in_json:{"code":"";"input":"";"cpu_limit":"";"mem_limit":"";}
    80.         // out_json:{"status":"0";"reason":"";"stdout":"";"stderr":""}
    81.         static void Start(const std::string &in_json, std::string *out_json)
    82.         {
    83.             Json::Value in_vaule;
    84.             Json::Reader reader;
    85.             reader.parse(in_json, in_vaule); //最后在差错处理
    86.  
    87.             std::string code = in_vaule["code"].asString();
    88.             std::string input = in_vaule["input"].asString();
    89.             int cpu_limit = in_vaule["cpu_limit"].asInt();
    90.             int mem_limit = in_vaule["mem_limit"].asInt();
    91.             Json::Value out_vaule;
    92.  
    93.             int status_code = 0;
    94.             std::string file_name;
    95.             int run_result = 0;
    96.             if (code.size() == 0)
    97.             {
    98.                 // //最后差错处理
    99.                 // out_vaule["status"] = -1; //代码为空
    100.                 // out_vaule["reason"] = "用户提交的代码是空的";
    101.                 // //序列化
    102.                 // return;
    103.                 status_code = -1;
    104.                 goto END;
    105.             }
    106.             //形成唯一文件名 毫秒级时间戳 + 原子性递增唯一值
    107.             file_name = ns_util::FileUtil::UniqFileName();
    108.             if (!ns_util::FileUtil::WiterFile(ns_util::PathUtil::Src(file_name), code)) //形成临时源src文件
    109.             {
    110.                 // out_vaule["status"] = -2; //未知错误
    111.                 // out_vaule["reason"] = "提交的代码发生了未知错误";
    112.                 // //序列化
    113.                 // return;
    114.                 status_code = -2;
    115.                 goto END;
    116.             }
    117.             if (!ns_compiler::Compiler::Compile(file_name)) //编译失败
    118.             {
    119.                 // out_vaule["status"] = -3;
    120.                 // //编译失败的内容保存到了.error文件中，读取序列化
    121.                 // out_vaule["reason"] = us_util::FileUtil::ReadFile(us_util::PathUtil::Error(file_name));
    122.                 // //序列化
    123.                 // return;
    124.                 status_code = -3;
    125.                 goto END;
    126.             }
    127.             run_result = ns_runner::Runner::Run(file_name, cpu_limit, mem_limit); //需要知道时间复杂度和空间复杂度
    128.             if (run_result < 0)
    129.             {
    130.                 // out_vaule["status"] = -2; //未知错误
    131.                 // out_vaule["reason"] = "发生了未知错误";
    132.                 // //序列化
    133.                 // return;
    134.                 status_code = -2;
    135.                 goto END;
    136.             }
    137.             else if (run_result > 0)
    138.             {
    139.                 // out_vaule["status"] = -4;  //运行时报错，收到信号
    140.                 // out_vaule["reason"] = SignoToDesc(); //将信号转化成报错原因；
    141.                 // //序列化
    142.                 // return;
    143.                 status_code = run_result;
    144.                 goto END;
    145.             }
    146.             else
    147.             {
    148.                 // //运行成功
    149.                 // out_vaule["status"] = 0;
    150.                 // out_vaule["reason"] = "运行成功";
    151.                 status_code = 0;
    152.             }
    153.         END:
    154.             out_vaule["status"] = status_code;
    155.             out_vaule["reason"] = CodeToDesc(status_code,file_name);
    156.             if (status_code == 0)
    157.             {
    158.                 //全部成功
    159.                 std::string _stdout;
    160.                 ns_util::FileUtil::ReadFile(ns_util::PathUtil::Stdout(file_name), &_stdout, true);
    161.                 out_vaule["stdout"] = _stdout;
    162.                // std::cout<<"标准输出："<<_stdout<
    163.                 std::string _stderr;
    164.                 ns_util::FileUtil::ReadFile(ns_util::PathUtil::Stderr(file_name), &_stderr, true);
    165.                 out_vaule["stderr"] = _stderr;
    166.             }
    167.             //序列化
    168.             Json::StyledWriter writer;
    169.             *out_json = writer.write(out_vaule);
    170.             RemoveTempFile(file_name);
    171.         }
    172.     };
    173. }

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

    本质：建立一个小型网站
    1. 获取首页，用题目列表充当
    2. 编辑区域页面
    3. 提交判题功能 ( 编译并运行 )
    M : Model , 通常是和数据交互的模块，比如，对题库进行增删改查（文件版， MySQL ）
    V : view , 通常是拿到数据之后，要进行构建网页，渲染网页内容，展示给用户的 ( 浏览器 )
    C : control , 控制器，就是我们的核心业务逻辑
    第一个功能：用户请求的服务路由功能 
    1. #include 
    2. #include "../comm/httplib.h"
    3. #include "oj_control.hpp"
    4. using namespace httplib;
    5.  
    6. int main()
    7. {
    8.     //用户请求的的路由功能
    9.     Server svr;
    10.     ns_control::Control ctrl;
    11.     //获取所有题目列表
    12.     svr.Get("/all_questions",[&ctrl](const Request& req,Response &resq){
    13.         //返回一张带有所有题目的html网页
    14.         std::string html;
    15.         ctrl.ALlQuestions(&html);
    16.         resq.set_content(html,"text/html;charset=utf-8");
    17.     });
    18.     //获取要根据题目编号，获取题目的内容
    19.     svr.Get(R"(/question/(\d+))",[&ctrl](const Request& req,Response &resq){
    20.         std::string num = req.matches[1];
    21.         std::string html;
    22.         ctrl.Question(num,&html);
    23.         resq.set_content(html,"text/html;charset=utf-8");
    24.     });
    25.     //用户提交代码，使用我们的判题功能()
    26.     svr.Post(R"(/judge/(\d+))",[&ctrl](const Request& req,Response &resq){
    27.         std::string number = req.matches[1];
    28.         std::string result_json;
    29.         ctrl.Judge(number,req.body,&result_json);
    30.         resq.set_content(result_json,"application/json;charset=utf-8");
    31.        // resq.set_content("指明题目的判题:"+num,"text/plain;charset=utf-8");
    32.     });
    33.  
    34.     
    35.     svr.set_base_dir("./wwwroot");
    36.     svr.listen("0.0.0.0",8080);
    37.     return 0;
    38. }
    第二个功能：model功能，提供对数据的操作 
    1. #pragma once
    2. //文件版本
    3. #include "../comm/util.hpp"
    4. #include "../comm/log.hpp"
    5.  
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. // 根据题目list文件，加载所有的题目信息到内存中
    15. // model: 主要用来和数据进行交互，对外提供访问数据的接口
    16.  
    17. namespace ns_model
    18. {
    19.     using namespace std;
    20.     using namespace ns_log;
    21.     using namespace ns_util;
    22.  
    23.     struct Question
    24.     {
    25.         std::string number; //题目编号，唯一
    26.         std::string title;  //题目的标题
    27.         std::string star;   //难度: 简单 中等 困难
    28.         int cpu_limit;      //题目的时间要求(S)
    29.         int mem_limit;      //题目的空间要去(KB)
    30.         std::string desc;   //题目的描述
    31.         std::string header; //题目预设给用户在线编辑器的代码
    32.         std::string tail;   //题目的测试用例，需要和header拼接，形成完整代码
    33.     };
    34.  
    35.     const std::string questins_list = "./questions/questions.list";
    36.     const std::string questins_path = "./questions/";
    37.  
    38.     class Model
    39.     {
    40.     private:
    41.         //题号 : 题目细节
    42.         unordered_map questions;
    43.  
    44.     public:
    45.         Model()
    46.         {
    47.             assert(LoadQuestionList(questins_list));
    48.         }
    49.         bool LoadQuestionList(const string &question_list)
    50.         {
    51.             //加载配置文件: questions/questions.list + 题目编号文件
    52.             ifstream in(question_list);
    53.             if (!in.is_open())
    54.             {
    55.                 LOG(FATAL) << " 加载题库失败,请检查是否存在题库文件"<< "\n";
    56.                 return false;
    57.             }
    58.  
    59.             string line;
    60.             while (getline(in, line))
    61.             {
    62.                 vector tokens;
    63.                 StringUtil::SplitString(line, &tokens, " ");
    64.                 // 1 判断回文数 简单 1 30000
    65.                 if (tokens.size() != 5)
    66.                 {
    67.                     LOG(WARNING) << "加载部分题目失败, 请检查文件格式" << "\n";
    68.                     continue;
    69.                 }
    70.                 Question q;
    71.                 q.number = tokens[0];
    72.                 q.title = tokens[1];
    73.                 //std::cout<
    74.                 q.star = tokens[2];
    75.                 q.cpu_limit = atoi(tokens[3].c_str());
    76.                 q.mem_limit = atoi(tokens[4].c_str());
    77.  
    78.                 string path = questins_path;
    79.                 path += q.number;
    80.                 path += "/";
    81.  
    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.  
    92.             return true;
    93.         }
    94.         bool GetAllQuestions(vector *out)
    95.         {
    96.             if (questions.size() == 0)
    97.             {
    98.                 LOG(ERROR) << "用户获取题库失败"<< "\n";
    99.                 return false;
    100.             }
    101.             for (const auto &q : questions)
    102.             {
    103.                 out->push_back(q.second); // first: key, second: value
    104.             }
    105.  
    106.             return true;
    107.         }
    108.         bool GetOneQuestion(const std::string &number, Question *q)
    109.         {
    110.             const auto &iter = questions.find(number);
    111.             if (iter == questions.end())
    112.             {
    113.                 LOG(ERROR) << "用户获取题目失败, 题目编号: " << number << "\n";
    114.                 return false;
    115.             }
    116.             (*q) = iter->second;
    117.             return true;
    118.         }
    119.         ~Model()
    120.         {
    121.         }
    122.     };
    123. } // namespace ns_model
    第三个功能：control，逻辑控制模块 
    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include "oj_model.hpp"
    9. #include "../comm/log.hpp"
    10. #include "../comm/util.hpp"
    11. #include "oj_view.hpp"
    12. #include "../comm/httplib.h"
    13. namespace ns_control
    14. {
    15.     const std::string service_machine = "./conf/service_machine.conf";
    16.     //提供服务的主机
    17.     class Machine
    18.     {
    19.     public:
    20.         std::string ip; //编译服务的ip
    21.         int port;       //编译服务的端口
    22.         uint64_t load;  //编译服务的负载
    23.         std::mutex *mtx;  //mutex禁止拷贝的，使用指针来完成
    24.     public:
    25.         Machine()
    26.         :ip("")
    27.         ,port(0)
    28.         ,load(0)
    29.         ,mtx(nullptr)
    30.         {
    31.  
    32.         }
    33.         ~Machine()
    34.         {
    35.  
    36.         }
    37.     public:
    38.         void IncLoad()  //提升负载
    39.         {
    40.             if(mtx) mtx->lock();
    41.             ++load;
    42.             if(mtx) mtx->unlock();
    43.         }
    44.         void DecLoad() //减少负载
    45.         {
    46.             if(mtx) mtx->lock();
    47.             --load;
    48.             if(mtx) mtx->unlock(); 
    49.         }
    50.         uint64_t Load() //获取负载
    51.         {
    52.             uint64_t _load = 0;
    53.              if(mtx) mtx->lock();
    54.             _load = load;
    55.             if(mtx) mtx->unlock(); 
    56.  
    57.             return _load;
    58.         }
    59.     };
    60.     //负载均衡模块
    61.     class LoadBlance
    62.     {
    63.     private:
    64.         std::vector machines; //可以提供编译服务所有主机
    65.         std::vector<int> online; //所有在线的主机
    66.         std::vector<int> offline; //所有离线主机
    67.         std::mutex mtx;           //保证LoadBlance数据安全
    68.     public:
    69.         LoadBlance()
    70.         {
    71.             assert(LoadConf(service_machine));
    72.             ns_log::LOG(ns_log::INFO)<<" 加载 "<" 成功 "<<"\n";
    73.         }
    74.         ~LoadBlance()
    75.         {
    76.  
    77.         }
    78.     public:
    79.         bool LoadConf(const std::string &machine_conf)
    80.         {
    81.             std::ifstream in(machine_conf);
    82.             if(!in.is_open())
    83.             {
    84.                 ns_log::LOG(ns_log::FATAL)<<"加载配置:"<"文件失败"<<"\n";
    85.                 return false;
    86.             }
    87.             std::string line;
    88.             while(getline(in,line))
    89.             {
    90.                 std::vector tokens;
    91.                 ns_util::StringUtil::SplitString(line,&tokens,":");
    92.  
    93.                 if(tokens.size() != 2)
    94.                 {
    95.                      ns_log::LOG(ns_log::WARNING) <<" 切分 "<" 失败 "<<"\n";
    96.                      continue;
    97.                 }
    98.  
    99.                 Machine m;
    100.                 m.ip = tokens[0];
    101.                 m.port = atoi(tokens[1].c_str());
    102.                 m.load = 0;
    103.                 m.mtx = new std::mutex();
    104.  
    105.                 online.push_back(machines.size());
    106.                 machines.push_back(m);
    107.             }
    108.             in.close();
    109.             return true;
    110.         }
    111.         //id:输出型参数
    112.         //m :输出型参数
    113.         bool SmartChoice(int* id,Machine **m)
    114.         {
    115.             //1.使用选择好的主机(更新该主机的负载)
    116.             //2.我们需要可能离线该主机
    117.             mtx.lock();
    118.             //负载均衡的算法
    119.             //1.随机数 + hash
    120.             //2.轮询 + hash
    121.             int online_num = online.size();
    122.             if(online_num == 0)
    123.             {
    124.                 mtx.unlock();
    125.                 ns_log::LOG(ns_log::FATAL) << "后端编译服务全部挂掉了,请运维的老铁尽快查看"<<"\n";
    126.                 return false;
    127.             }
    128.             //通过编译找到负载最小的机器
    129.             *id = online[0];
    130.             *m =  &machines[online[0]];
    131.             uint64_t min_load = machines[online[0]].Load();
    132.             for(int i = 0; i < online_num; ++i)
    133.             {
    134.                 min_load = min_load < machines[online[i]].Load() ? machines[online[i]].Load() : min_load;
    135.                 *id = online[i];
    136.                 *m  = &machines[online[i]];
    137.             }
    138.             mtx.unlock();
    139.             return true;
    140.         }
    141.         void OfflineMachine(int which)
    142.         {
    143.             mtx.lock();
    144.             for(auto iter = online.begin(); iter != online.end(); ++iter)
    145.             {
    146.                 if(*iter == which)
    147.                 {
    148.                     online.erase(iter);
    149.                     offline.push_back(which);
    150.                     break;
    151.                 }
    152.             }
    153.             mtx.unlock();
    154.         }
    155.         void OnlineMachine()
    156.         {
    157.  
    158.         }
    159.         void ShowMachines()
    160.         {
    161.             mtx.lock();
    162.             std::cout<<"当前在线主机列表：";
    163.             for(auto &id : online)
    164.             {
    165.                 std::cout << id <<" ";
    166.             }
    167.             std::cout<
    168.             for(auto &id : offline)
    169.             {
    170.              std::cout<<"当前离线主机列表：";
    171.                 std::cout << id << " ";
    172.             }
    173.             std::cout<
    174.             mtx.unlock();
    175.         }
    176.     };
    177.  
    178.  
    179.     class Control
    180.     {
    181.     private:
    182.         ns_model::Model _model; //提供后台服务
    183.         ns_view::View _view;    //提供html渲染功能
    184.         LoadBlance _load_blance; //提供负载均衡器
    185.     public:
    186.         Control()
    187.         {
    188.  
    189.         }
    190.         //根据题目数据构建网页
    191.         bool ALlQuestions(std::string *html)
    192.         {
    193.             std::vector all;
    194.             if(_model.GetAllQuestions(&all))
    195.             {
    196.                 //获取题目信息成功，将所有的题目数据构建成网页
    197.                 _view.AllExpandHtml(all,html);
    198.             }
    199.             else
    200.             {
    201.                 *html = "获取题目失败，形成题目列表失败";
    202.                 return false;
    203.             }
    204.             return true;
    205.         }
    206.         bool Question(const std::string number,std::string *html)
    207.         {
    208.             ns_model::Question q;
    209.             if(_model.GetOneQuestion(number,&q))
    210.             {
    211.                 //获取指定题目成功，将题目数据构建成网页
    212.                 _view.OneExpandHtml(q,html);
    213.             }
    214.             else
    215.             {
    216.                 *html = "指定题目" + number + "不存在";
    217.                 return false;
    218.             }
    219.             return true;
    220.         }
    221.         void Judge(const std::string& number, const std::string in_json,std::string *out_json)
    222.         {
    223.             //0.根据题号，直接拿到题目细节
    224.             ns_model::Question q;
    225.             _model.GetOneQuestion(number,&q);
    226.             //1.in_json进行反序列化，得到题目的id，得到用户提交的源代码，input
    227.             Json::Reader reader;
    228.             Json::Value in_value;
    229.             reader.parse(in_json,in_value);
    230.             //2.重新拼接用户代码 + 测试用例代码，形成新代码
    231.             std::string code = in_value["code"].asString();
    232.             Json::Value compile_value;
    233.             compile_value["input"] = in_value["input"].asString();
    234.             compile_value["code"] = code + q.tail;
    235.             compile_value["cpu_limit"] = q.cpu_limit;
    236.             compile_value["mem_limit"] = q.mem_limit;
    237.             Json::FastWriter writer;
    238.             std::string complie_string = writer.write(compile_value);
    239.             //3.选择负载最低的主机（差错处理）
    240.             for( ; ;)
    241.             {
    242.                 int id = 0;
    243.                 Machine *m = nullptr;
    244.                 if(!_load_blance.SmartChoice(&id,&m))
    245.                 {
    246.                     break;
    247.                 }
    248.                 ns_log::LOG(ns_log::INFO) <<"选择主机成功"<"详情"<ip<<":"<port<<"\n";
    249.                 //4.然后发起http请求，得到结果
    250.                 httplib::Client cli(m->ip,m->port);
    251.                 m->IncLoad();
    252.                 if(auto res = cli.Post("/compile_and_run",complie_string, "application/json;charset=utf-8"))
    253.                 {
    254.                     //5.将结果赋值给out_json
    255.                     if(res->status == 200)
    256.                     {
    257.                          *out_json = res->body;
    258.                          m->DecLoad();
    259.                          break;
    260.                     }
    261.                      m->DecLoad();
    262.                 }
    263.                 else
    264.                 {
    265.                     //请求失败
    266.                     ns_log::LOG(ns_log::ERROR)<<"详情：" << id <<":"<< m->ip << ":"<port<<"可能已经离线"<<"\n";
    267.                     _load_blance.OfflineMachine(id);
    268.                     _load_blance.ShowMachines();
    269.                 }   
    270.             }  
    271.         }
    272.         ~Control()
    273.         {
    274.  
    275.         }
    276.     };
    277. }
    附加功能：需要有数据渲染
    // 如果后续引入了 ctemplate ，一旦对网页结构进行修改，尽量的每次想看到结果，将 server 重启一下。 ctemplate 有 自己的优化加速策略，可能在内存中存在缓存网页数据(old)

     

    当我们完成全部功能之后，需要注意：
    要给编译模块添加—D条件编译掉测试用例中的头文件incldue

    6. version1 文件版题目设计

    1. 题目的编号
    2. 题目的标题
    3. 题目的难度
    4. 题目的描述，题面
    5. 时间要求 ( 内部处理 )
    6. 空间要求 ( 内部处理 )
    两批文件构成
    1. 第一个： questions . list : 题目列表（不需要题目的内容）
    2. 第二个：题目的描述，题目的预设置代码 ( header . cpp ), 测试用例代码 ( tail . cpp )
    这两个内容是通过题目的编号，产生关联的
    1. 当用户提交自己的代码的时候： header . cpp 
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. using namespace std;
    8.  
    9. class Solution{
    10.     public:
    11.         bool isPalindrome(int x)
    12.         {
    13.             //将你的代码写在下面
    14.             
    15.             return true;
    16.         }
    17. };
    该题号对应的测试用例 ： tail . cpp 
    1. #ifndef COMPILER_ONLINE
    2. #include "header.cpp"
    3. #endif
    4.  
    5.  
    6. void Test1()
    7. {
    8.     // 通过定义临时对象，来完成方法的调用
    9.     bool ret = Solution().isPalindrome(121);
    10.     if(ret){
    11.         std::cout << "通过用例1, 测试121通过 ... OK!" << std::endl;
    12.     }
    13.     else{
    14.         std::cout << "没有通过用例1, 测试的值是: 121"  << std::endl;
    15.     }
    16. }
    17.  
    18. void Test2()
    19. {
    20.     // 通过定义临时对象，来完成方法的调用
    21.     bool ret = Solution().isPalindrome(-10);
    22.     if(!ret){
    23.         std::cout << "通过用例2, 测试-10通过 ... OK!" << std::endl;
    24.     }
    25.     else{
    26.         std::cout << "没有通过用例2, 测试的值是: -10"  << std::endl;
    27.     }
    28. }
    29.  
    30. int main()
    31. {
    32.     Test1();
    33.     Test2();
    34.  
    35.     return 0;
    36. }

    后端全部写完使用Postman 来测试

     

     

     

    7. 前端页面设计

    8. version2 MySQL版题目设计

    9.综合测试

    10.项目扩展思路

  • 相关阅读:
    【Java】-【使用smtp协议发邮件】
    Windows cmd窗口常用命令
    python中怎样把一个文件夹中所有的*.ts文件都读进来形成一个视频文件？
    Window环境下不安装DM数据库，编译dmPython
    如何快速解决d3dcompiler_43.dll缺失问题?五种方法快速解决
    Jmeter压测实战：Jmeter二次开发之自定义函数
    单细胞聚类，究竟聚类聚成多少类比较合适？全代码分享
    Spring Security 实现动态权限菜单方案（附源码）
    SpringBoot-单元测试
    苹果起诉以色列安全公司NSO，间谍软件是侵犯隐私还是打击犯罪？
  • 原文地址：https://blog.csdn.net/qq_57283958/article/details/126439223