当前位置：首页 > article >正文

【c++实战项目】负载均衡式在线OJ

article 2025/1/11 16:40:58

主页：醋溜马桶圈-CSDN博客

专栏：实战项目_醋溜马桶圈的博客-CSDN博客

gitee：mnxcc (mnxcc) - Gitee.com
项目源码
文件版：OnlineJudge_file: 负载均衡在线OJ项目基于文件版本
数据库版：mnxcc/OnlineJudge_MySQL

1.项目目标

2.技术与开发环境

2.1 技术

2.2 开发环境

3.项目宏观结构

编辑

3.1 设计思路

4.compiler_server设计

4.1 compiler

4.1.1 Compile()

4.2 runner

4.2.1 Run()

4.2.2 Run超时/内存超限

1.超时退出

编辑

2.内存超限退出

编辑

3.终止进程

编辑

4.进程资源限制函数SetProcRlimit()

4.3 compile_run

4.3.1 jsoncpp

4.3.2 Start()

4.3.3 获取唯一文件名

4.3.4 将code写入.cpp文件

4.3.5 读取文件

4.3.6 测试用例

4.3.7 移除临时文件

4.3.4 形成网络服务

编辑

4.3.4.1 测试get服务

编辑

4.3.4.2 测试post请求

编辑

4.3.5 compile_server.cc

5.基于MVC结构的oj服务

5.1 oj_server.cc

5.1.1 测试

5.1.2 注意事项

5.2 文件版题目设计

编辑

5.2.1 oj_model设计

5.2.1.1 class Model

5.2.1.2 加载题目列表函数

5.2.1.3 SplitString设计-使用boost实现

5.2.2 oj_control设计

5.2.2.1 class Contril 设计

5.2.2.2 AllQuestions()设计

5.2.2.3 Question()设计

5.2.2.4 Judge()设计

5.2.3 oj_view设计

5.2.3.1 ctemplate库安装

编辑

5.2.3.2 测试ctemplate

5.2.3.3 渲染题目列表页

5.2.3.4 渲染题目描述页

5.2.4 class Machine设计

5.2.5 class LoadBalance设计

6.前端页面设计

6.1 丐版的页面-首页

6.2 所有题目列表的页面

6.3 OJ指定题目页面-代码提交

6.3.1 ACE在线编辑器

6.3.2 前后端交互jquery

6.3.2.1 通过ajax向后端发起请求

6.3.3 onequestion.html代码

7.基于数据库的版本

7.1 数据库设计

7.1.1mysql workbench创建表结构

7.1.1.1 oj_questions

7.1.2 数据库连接和设计问题

7.2 oj_model重新设计

7.2.1 引入三方库

7.2.2 oj_model代码

8.项目扩展

9.顶层makefile

1.项目目标

前端：题目列表（自动录题）在线OJ 报错提醒

后端：oj_server和compile_server服务器负载均衡数据库+文件

2.技术与开发环境

2.1 技术

C++ STL标准库
Boost准标准库（字符串切割）
cpp-httplib第三方开源网络库
ctemplate第三方开源前端网页渲染库
jsoncpp第三方开源序列化、反序列化库
负载均衡设计算法
多进程、多线程
MySQL C connect （数据库版本文件版本）
Ace前端在线编辑器
html/css/js/jquery/ajax

2.2 开发环境

Ubuntu 云服务器
vscode
MySQL Workbench

3.项目宏观结构

类似LeetCode模式：题目列表+在线编程功能

3.1 设计思路

(1) compile_server

(2) oj_server

(3) 基于文件的在线OJ

(4) 前端的页面设计

(5) 基于MySQL的在线OJ

4.compiler_server设计

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

4.1 compiler

4.1.1 Compile()

Compiler::Compile()核心代码：编译功能

        // 编译成功则生成可执行文件 返回true 否则返回false （只判断编译是否成功）
        static bool Compile(const std::string &file_name)
        {
            pid_t pid = fork();
            if (pid < 0)
            {
                LOG(ERROR) << "内部错误，创建子进程失败" << "\n";
                return false;
            }
            else if (pid == 0)
            {
                umask(0);
                int _compile_err = open(PathUtil::CompilerErr(file_name).c_str(), O_CREAT | O_WRONLY, 0644); // 以创建|读写方式打开file.stderr文件
                if (_compile_err < 0)
                {
                    LOG(WARNING) << "没有成功形成compile_err文件" << "\n";
                    exit(1);
                }
                // 重定向标准错误到_compile_err
                dup2(_compile_err, 2);
                // 子进程：调用编译器，完成对代码的编译工作
                // g++ -o target src -std=c++11
                execlp("g++", "g++", "-o", PathUtil::Exe(file_name).c_str(), PathUtil::Src(file_name).c_str(), "-std=c++11", nullptr);
                // 程序替换并不影响进程的文件描述符表
                LOG(ERROR) << "启动编译器g++失败，可能是参数错误" << "\n";
                exit(2);
            }
            else
            {
                // 父进程：等待子进程 等待失败直接返回false 等待成功再判断是否生成可执行程序(是否编译成功)
                waitpid(pid, nullptr, 0);
                if (FileUtil::IsFileExist(PathUtil::Exe(file_name)))
                {
                    LOG(INFO) << PathUtil::Src(file_name) << " 编译成功!" << "\n";
                    return true;
                }
            }
            LOG(ERROR) << "编译失败，没有形成可执行程序" << "\n";
            return false;
        }

4.2 runner

4.2.1 Run()

Runner::Run()核心代码：运行功能

        /********
         * 返回值>0：程序异常，返回退出信号
         * 返回值==0：程序运行成功，结果保存到stdout
         * 返回值<0：内部错误 文件错误 进程创建错误
         * cpu_rlimit：运行时消耗cpu资源的上限
         * mem_rlimit：运行时消耗内存资源的上限 以KB为单位
         ********/
        static int Run(const std::string &file_name, int cpu_limit, int mem_limit)
        {
            const std::string _execute = PathUtil::Exe(file_name);
            const std::string _stdin = PathUtil::Stdin(file_name);
            const std::string _stdout = PathUtil::Stdout(file_name);
            const std::string _stderr = PathUtil::Stderr(file_name);

            umask(0);
            int _stdin_fd = open(_stdin.c_str(), O_CREAT | O_WRONLY, 0644);
            int _stdout_fd = open(_stdout.c_str(), O_CREAT | O_WRONLY, 0644);
            int _stderr_fd = open(_stderr.c_str(), O_CREAT | O_WRONLY, 0644);

            if (_stdin_fd < 0 || _stdout_fd < 0 || _stderr_fd < 0)
            {
                LOG(ERROR) << "运行时打开标准文件失败" << "\n";
                return -1; // 表示文件打开或创建失败
            }
            pid_t pid = fork();
            if (pid < 0)
            {
                LOG(ERROR) << "创建子进程失败" << "\n";
                // 子进程创建失败
                close(_stdin_fd);
                close(_stdout_fd);
                close(_stderr_fd);
                return -2;
            }
            else if (pid == 0)
            {
                // 子进程 运行
                dup2(_stdin_fd, 0);
                dup2(_stdout_fd, 1);
                dup2(_stderr_fd, 2);

                SetProcRlimit(cpu_limit, mem_limit);

                execl(_execute.c_str(), _execute.c_str(), nullptr);
                exit(1);
            }
            else
            {
                // 父进程 等待
                close(_stdin_fd);
                close(_stdout_fd);
                close(_stderr_fd);
                int status;
                waitpid(pid, &status, 0);
                LOG(INFO) << PathUtil::Exe(file_name) << " 运行完毕，退出信号:" << (status & 0x7F) << "\n";
                return status & 0x7F;
                // 通过退出信号判断运行成功与否
                // 成功 status==0
                // 失败 status!=0
            }

4.2.2 Run超时/内存超限

使用setrlimit函数

1.超时退出

    struct rlimit rt;
    rt.rlim_cur=1;//软限制为1秒
    rt.rlim_max=RLIM_INFINITY;//硬限制为无穷
    setrlimit(RLIMIT_CPU,&rt);//CPU的运行时间限制
    while(1);

2.内存超限退出

    struct rlimit rt;
    rt.rlim_cur = 1024 * 1024 * 40; // 软限制为40MB空间
    rt.rlim_max = RLIM_INFINITY;    // 硬限制为无穷
    setrlimit(RLIMIT_AS, &rt);      // 虚拟内存大小限制
    int count = 0;
    while (1)
    {
        int *p = new int[1024 * 1024]; // 一次申请1MB的空间
        count++;
        std::cout << "size: " << count << std::endl;
        sleep(1);
    }

3.终止进程

资源不足，os通过信号终止进程

void handler(int signo)
{
    std::cout << "signo : " << signo << std::endl;
    exit(1);
}

    for (int i = 0; i < 31; i++)
        signal(i,handler);
// 为所有信号都注册了 handler 函数，当收到 SIGXCPU 信号时，handler 函数会被调用，输出信号编号，然后进程终止

4.进程资源限制函数SetProcRlimit()

        static void SetProcRlimit(int _cpu_limit, int _mem_limit)
        {
            struct rlimit cpu_rlimit;
            cpu_rlimit.rlim_cur = _cpu_limit;
            cpu_rlimit.rlim_max = RLIM_INFINITY;
            setrlimit(RLIMIT_CPU, &cpu_rlimit);

            struct rlimit mem_rlimit;
            mem_rlimit.rlim_cur = _mem_limit * 1024;
            mem_rlimit.rlim_max = RLIM_INFINITY;
            setrlimit(RLIMIT_AS, &mem_rlimit);
        }

4.3 compile_run

核心功能：编译运行

//适配用户请求 定制通信协议字段
//正确调用compile and run
//形成唯一文件名
// 整合服务
#pragma once
#include "compiler.hpp"
#include "runner.hpp"
#include "../comm/log.hpp"
#include "../comm/util.hpp"
#include <signal.h>
#include <unistd.h>
#include <jsoncpp/json/json.h>

namespace ns_compile_and_run
{
    using namespace ns_compiler;
    using namespace ns_runner;

    class CompileAndRun
    {
    public:
        // 移除临时文件 使用unlink系统调用
        static void RemoveTempFile(const std::string &file_name)
        {
            // 移除.cpp文件
            std::string _src = PathUtil::Src(file_name);
            if (FileUtil::IsFileExist(_src))
                unlink(_src.c_str());

            // 移除.compile_err文件
            std::string _compile_err = PathUtil::CompilerErr(file_name);
            if (FileUtil::IsFileExist(_compile_err))
                unlink(_compile_err.c_str());

            // 移除.exe文件
            std::string _exe = PathUtil::Exe(file_name);
            if (FileUtil::IsFileExist(_exe))
                unlink(_exe.c_str());

            // 移除.stdin文件
            std::string _stdin = PathUtil::Stdin(file_name);
            if (FileUtil::IsFileExist(_stdin))
                unlink(_stdin.c_str());

            // 移除.stdout文件
            std::string _stdout = PathUtil::Stdout(file_name);
            if (FileUtil::IsFileExist(_stdout))
                unlink(_stdout.c_str());

            // 移除.stderr文件
            std::string _stderr = PathUtil::Stderr(file_name);
            if (FileUtil::IsFileExist(_stderr))
                unlink(_stderr.c_str());
        }
        // 将错误码转化成错误码描述
        /****
         * >0
         * <0
         * =0
         ****/
        static std::string CodeToDesc(int code, const std::string &file_name)
        {
            std::string desc = "";
            switch (code)
            {
            case 0:
                desc = "编译运行成功";
                break;
            case -1:
                desc = "提交的代码为空";
                break;
            case -2:
                desc = "未知错误";
                break;
            case -3:
                // desc = "编译出错";
                FileUtil::ReadFile(PathUtil::CompilerErr(file_name), &desc, true);
                break;
            case SIGABRT: // 6
                desc = "超出内存限制";
                break;
            case SIGXCPU: // 24
                desc = "运行超时";
                break;
            case SIGFPE: // 8
                desc = "浮点数溢出错误";
                break;
            default:
                desc = "debug:" + std::to_string(code);
                break;
            }
            return desc;
        }
        /*******
         * 输入：一个json串
         * code：用户提交的代码
         * input：用户给自己提交的代码的对应的输入（扩展自测用例）
         * cpu_limit：时间要求
         * mem_limit：空间要求
         *
         * 输出：一个json串
         * 必填：
         * status：状态码
         * reason：请求结果 成功/失败
         * 选填：
         * stdout：运行完的结果
         * stderr：运行完的错误结果
         *******/
        // in_json :{"code":"#include...","input":" ","cpu_limit":"1","mem_limit":"1024"};
        // out_json :{"status":"0","reason":"",["stdout":"","stderr":""]};
        static void Start(const std::string &in_json, std::string *out_json)
        {
            // 将传入的in_put 反序列化得到kv值 使用jsoncpp库
            Json::Value in_value;
            Json::Reader reader;
            reader.parse(in_json, in_value);

            std::string code = in_value["code"].asString();
            std::string input = in_value["input"].asString();
            int cpu_limit = in_value["cpu_limit"].asInt();
            int mem_limit = in_value["mem_limit"].asInt();

            Json::Value out_value;
            std::string file_name = "";
            int status_code = 0;
            int run_result = 0;

            if (code.size() == 0)
            {
                status_code = -1; // 代码为空
                goto END;
            }

            // 形成的文件名具有唯一性 没有后缀和路径
            file_name = FileUtil::UniqFileName();

            // 形成临时文件src文件 把code写道file.cpp中
            if (!FileUtil::WriteFile(PathUtil::Src(file_name), code))
            {
                status_code = -2; // 内部错误：文件写入错误
                goto END;
            }

            // 编译
            if (!Compiler::Compile(file_name))
            {
                status_code = -3; // 编译错误
                goto END;
            }
            // 运行
            run_result = Runner::Run(file_name, cpu_limit, mem_limit);
            if (run_result < 0)
            {
                status_code = -2; // 内部错误：文件错误/创建进程
            }
            else if (run_result > 0)
            {
                status_code = run_result; // 运行出错：传递出错信号
            }
            else
            {
                status_code = 0; // 运行成功
            }
        END:
            out_value["status"] = status_code;
            out_value["reason"] = CodeToDesc(status_code, file_name);
            if (status_code == 0)
            {

                // 运行成功
                std::string _stdout;
                FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
                out_value["stdout"] = _stdout;

                std::string _stderr;
                FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr, true);
                out_value["stderr"] = _stderr;
            }
            // 序列化 返回 out_json
            Json::StyledWriter writer;
            *out_json = writer.write(out_value);

            // 移除临时文件
            RemoveTempFile(file_name);
        }
    };
}

4.3.1 jsoncpp

sudo apt-get install libjsoncpp-dev

问题：序列化后的string汉字变为乱码

#include <jsoncpp/json/json.h>
int main()
{
    // 序列化：将结构化的数据转化成一个字符串 方便在网络中传输
    // Value是一个Json的中间类，可以填充KV值
    Json::Value root;
    root["code"] = "mycode";
    root["name"] = "dc";
    root["age"] = "20";

    // Json::StyledWriter writer;
    Json::FastWriter writer;
    std::string str = writer.write(root);
    std::cout << str << std::endl;
    return 0;
}
// 编译的时候需要链接jsoncpp库 —ljsoncpp

序列化：kv->string

反序列化：string->kv

4.3.2 Start()

CompileAndRun::Start()核心功能：整合编译运行服务

判断六种情况 序列化给 *out_json
1.code为空 -1 reason
2.code写入.cpp失败 -2 reason
3.编译失败 -3 reason
4.内部错误非运行时错误（包含于运行函数） -2 reason
5.收到信号运行失败 signal reason
5.运行成功 0 reason stdout stderr(判断运行结果)

    class CompileAndRun
    {
    public:
        // 将错误码转化成错误码描述
        /****
         * >0
         * <0
         * =0
         ****/
        static std::string CodeToDesc(int code, const std::string &file_name)
        {
            std::string desc = "";
            switch (code)
            {
            case 0:
                desc = "编译运行成功";
                break;
            case -1:
                desc = "提交的代码为空";
                break;
            case -2:
                desc = "未知错误";
                break;
            case -3:
                // desc = "编译出错";
                FileUtil::ReadFile(PathUtil::CompilerErr(file_name), &desc, true);
                break;
            case SIGABRT: // 6
                desc = "超出内存限制";
                break;
            case SIGXCPU: // 24
                desc = "运行超时";
                break;
            case SIGFPE: // 8
                desc = "浮点数溢出错误";
                break;
            default:
                desc = "debug:" + std::to_string(code);
                break;
            }
            return desc;
        }
        /*******
         * 输入：一个json串
         * code：用户提交的代码
         * input：用户给自己提交的代码的对应的输入（扩展自测用例）
         * cpu_limit：时间要求
         * mem_limit：空间要求
         *
         * 输出：一个json串
         * 必填：
         * status：状态码
         * reason：请求结果 成功/失败
         * 选填：
         * stdout：运行完的结果
         * stderr：运行完的错误结果
         *******/
        // in_json :{"code":"#include...","input":" ","cpu_limit":"1","mem_limit":"1024"};
        // out_json :{"status":"0","reason":"",["stdout":"","stderr":""]};
        static void Start(const std::string &in_json, std::string *out_json)
        {
            // 将传入的in_put 反序列化得到kv值 使用jsoncpp库
            Json::Value in_value;
            Json::Reader reader;
            reader.parse(in_json, in_value);

            std::string code = in_value["code"].asString();
            std::string input = in_value["input"].asString();
            int cpu_limit = in_value["cpu_limit"].asInt();
            int mem_limit = in_value["mem_limit"].asInt();

            Json::Value out_value;
            std::string file_name = "";
            int status_code = 0;
            int run_result = 0;

            if (code.size() == 0)
            {
                status_code = -1; // 代码为空
                goto END;
            }

            // 形成的文件名具有唯一性 没有后缀和路径
            file_name = FileUtil::UniqFileName();

            // 形成临时文件src文件 把code写道file.cpp中
            if (!FileUtil::WriteFile(PathUtil::Src(file_name), code))
            {
                status_code = -2; // 内部错误：文件写入错误
                goto END;
            }

            // 编译
            if (!Compiler::Compile(file_name))
            {
                status_code = -3; // 编译错误
                goto END;
            }
            // 运行
            run_result = Runner::Run(file_name, cpu_limit, mem_limit);
            if (run_result < 0)
            {
                status_code = -2; // 内部错误：文件错误/创建进程
            }
            else if (run_result > 0)
            {
                status_code = run_result; // 运行出错：传递出错信号
            }
            else
            {
                status_code = 0; // 运行成功
            }
        END:
            out_value["status"] = status_code;
            out_value["reason"] = CodeToDesc(status_code, file_name);
            if (status_code == 0)
            {

                // 运行成功
                std::string _stdout;
                FileUtil::ReadFile(PathUtil::Stdout(file_name), &_stdout, true);
                out_value["stdout"] = _stdout;

                std::string _stderr;
                FileUtil::ReadFile(PathUtil::Stderr(file_name), &_stderr, true);
                out_value["stderr"] = _stderr;
            }
            // 序列化 返回 out_json
            Json::StyledWriter writer;
            *out_json = writer.write(out_value);
        }
    };

4.3.3 获取唯一文件名

通过毫秒级时间戳+原子性递增得到唯一文件名

        // 毫秒级时间戳
        static std::string GetTimeMs()
        {
            struct timeval _time;
            gettimeofday(&_time, nullptr); // 时间,时区
            return std::to_string(_time.tv_sec * 1000 + _time.tv_usec / 1000);
        }
        // 形成唯一文件名
        static std::string UniqFileName()
        {
            // 毫秒级时间戳+原子性递增
            static std::atomic_uint id(0);
            id++;
            std::string ms = TimeUtil::GetTimeMs();
            std::string uniq_id = std::to_string(id);
            return ms + "_" + uniq_id;
        }