【负载均衡式在线OJ项目day3】运行模块

一.前言

上一篇文章实现了编译模块，今天来实现Runner运行模块

二.设计思路

运行模块只负责运行可执行程序，所以前提是已经有了可执行程序。

首先创建子进程，然后子进程程序替换成可执行程序，然后把退出信息交给父进程。父进程只关心可执行程序是否是正常退出，而不关心运行结果是否正确，所以父进程只关注退出信息中的退出信号。

子进程程序替换之前，应当将标准输入，标准输出，标准错误重定向到临时文件，因为将来的输入的测试用例一定是从文件中来，输出结果也放到文件中方便对比正确性，运行中的错误信息也放到文件，将来返回给用户。

这里涉及到一个细节，临时文件是放在父进程还是子进程打开？在设计编译模块时，临时文件打开和重定向都是在子进程，但这里却没这么简单。编译模块之所以在子进程打开，是因为父进程能通过是否形成了可执行程序，来判断编译是否成功，但此处就没有这种巧妙的判断方法。

如果子进程在打开临时文件或者程序替换时出错，父进程如何得知呢？通过子进程的退出码吗？不可行，因为父进程无法知道这个退出码是用户的程序返回的，还是程序替换前我们的代码返回的。所以不得不使用进程间通信的方式，例如匿名管道。所以这里索性麻烦一些，在父进程就打开临时文件，让子进程继承下去，方便做差错处理。不过要记得关闭文件描述符

 运行时还应该有时间和空间资源限制，可以使用setrlimt系统调用，来限制进程占用CPU的时间，和申请虚拟内存的大小。如果超时进程会受到SIGXCPU，超空间会收到SIGABRT信号，使进程退出。

三.接口设计 

参数：

1.fileName:要运行的可执行程序名(不包括后缀和路径)

2.cpuLimit:程序运行可以使用最大CPU资源上限，单位s

3.memLimit:程序运行可以使用最大内存资源上限，单位KB

       

返回值val:

1.val = 0：代码跑完，正常退出

2.val > 0:代码没跑完，收到信号退出了，val就是信号编号

3.val < 0:内部出错了。打开临时文件失败返回-1。创建子进程失败返回-2，

这里的返回值并没有像编译模块一样，直接返回true或者false，因为后续如果进程异常退出，我们想给用户返回信号编号。

四.代码实现 

#pragma once
#include <iostream>
#include <string>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <cstdlib>
#include <sys/time.h>
#include <sys/resource.h>
#include "../Common/Util.hpp"
#include "../Common/Log.hpp"
namespace ns_runner
{
    using namespace ns_util;
    using namespace ns_log;

    class Runner
    {
    public:
        /*******************
         * 返回值val:
         * 1.val = 0：代码跑完，正常退出
         * 2.val > 0:代码没跑完，收到信号退出了，val就是信号编号
         * 3.val < 0:内部出错了。创建子进程失败返回-2，打开临时文件失败返回-1
         *
         * 参数:
         * 1.fileName:要运行的可执行程序名(不包括后缀和路径)
         * 2.cpuLimit:程序运行可以使用最大CPU资源上限，单位s
         * 3.memLimit:程序运行可以使用最大内存资源上限，单位KB
         * ****************/
        static int run(const std::string &fileName, int cpuLimit, int memLimit)
        {

            // 打开标准输入，标准输出，标准错误重定向的临时文件
            // 本来在子进程中做更合适，但是如果出错了不便于把错误码交给父进程
            umask(0);
            int _stdin = open(PathUtil::stdin(fileName).c_str(), O_CREAT | O_RDONLY, 0664);
            int _stdout = open(PathUtil::stdout(fileName).c_str(), O_CREAT | O_WRONLY, 0664);
            int _stderr = open(PathUtil::stderr(fileName).c_str(), O_CREAT | O_WRONLY, 0664);
            if (_stdin < 0 || _stdout < 0 || _stderr < 0)
            {
                close(_stdin);
                close(_stdout);
                close(_stderr);

                LOG(ERROR) << "运行时打开临时文件失败" << std::endl;
                return -1;
            }

            pid_t pid = fork();
            if (pid < 0)
            {
                LOG(ERROR) << "运行时创建子进程失败" << std::endl;
                
                close(_stdin);
                close(_stdout);
                close(_stderr);

                return -2; // 创建子进程失败
            }
            else if (pid == 0)
            {

                dup2(_stdin, 0);
                dup2(_stdout, 1);
                dup2(_stderr, 2);
                
                setProcLimit(cpuLimit, memLimit);
                std::string excute = PathUtil::exe(fileName);
                execl(excute.c_str(), excute.c_str(), nullptr);
                exit(1);
            }
            else
            {
                int status = 0;
                waitpid(pid, &status, 0);
                LOG(INFO) << "运行完毕, info: " << (status & 0x7f) << std::endl;

                close(_stdin);
                close(_stdout);
                close(_stderr);

                return status & 0x7f;
            }
        }
        /***********
         * 功能：设置进程占用资源限制
         * 
         * 参数：
         * 1.cpuLimit:程序运行可以使用最大CPU资源上限，单位s
         * 2.memLimit:程序运行可以使用最大虚拟内存资源上限，单位KB
         * ***********/
        static void setProcLimit(int cpuLimit, int memLimit)
        {
            struct rlimit cpuRlimit;
            cpuRlimit.rlim_max = RLIM_INFINITY;
            cpuRlimit.rlim_cur = cpuLimit;
            setrlimit(RLIMIT_CPU, &cpuRlimit);

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