HomePhorge
Diffusion Process Management Controller (HEAD -> master) Code

pmc/lib/process.cc
c102ec9084d7HEAD -> master

Last Change
Raw File

process.cc
View Options

#include "include/process.h"
#include <algorithm>
#include <chrono>
#include <fcntl.h>
#include <fstream>
#include <iostream>
#include <signal.h>
#include <sstream>
#include <sys/wait.h>
#include <thread>
#include <unistd.h>
#ifdef __APPLE__
#include <sys/sysctl.h>
#include <sys/types.h>
#endif
using namespace std;
namespace process {
volatile sig_atomic_t childExitStatus = 0;
std::string format(std::string text) {
std::replace(text.begin(), text.end(), ' ', '_');
return text;
}
pair<std::string, std::string> split(const std::string &str) {
size_t length = str.length();
size_t midpoint = length / 2;
std::string firstHalf = str.substr(0, midpoint);
std::string secondHalf = str.substr(midpoint);
return make_pair(firstHalf, secondHalf);
}
void sigchld_handler(int signo) {
(void)signo;
int status;
while (waitpid(-1, &status, WNOHANG) > 0) {
childExitStatus = status;
}
}
void Runner::New(const std::string &name, const std::string &logPath) {
std::string formattedName = format(name);
std::string stdoutFileName = logPath + "/" + formattedName + "-out.log";
std::string stderrFileName = logPath + "/" + formattedName + "-error.log";
stdout_fd = open(stdoutFileName.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644);
stderr_fd = open(stderrFileName.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644);
struct sigaction sa;
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
std::cerr << "[PMC] (cc) Error setting up SIGCHLD handler\n";
perror("Runner::New");
}
}
Runner::~Runner() {
if (stdout_fd != -1) {
close(stdout_fd);
}
if (stderr_fd != -1) {
close(stderr_fd);
}
}
int64_t Runner::Run(const std::string &command, const std::string &shell, Vec<String> args, Vec<String> env) {
pid_t pid = fork();
if (pid == -1) {
std::cerr << "[PMC] (cc) Unable to fork\n";
perror("Runner::Run");
return -1;
} else if (pid == 0) {
setsid();
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
dup2(stdout_fd, STDOUT_FILENO);
dup2(stderr_fd, STDERR_FILENO);
std::vector<const char *> argsArray;
std::vector<const char *> envArray;
argsArray.push_back(shell.c_str());
transform(args.begin(), args.end(), std::back_inserter(argsArray),
[](rust::String& arg) { return arg.c_str(); });
transform(env.begin(), env.end(), std::back_inserter(envArray),
[](rust::String& env) { return env.c_str(); });
argsArray.push_back(command.c_str());
argsArray.push_back(nullptr);
envArray.push_back(nullptr);
if (execve(shell.c_str(), const_cast<char* const*>(argsArray.data()), const_cast<char* const*>(envArray.data())) == -1) {
std::cerr << "[PMC] (cc) Unable to execute the command\n";
perror("execvp");
exit(EXIT_FAILURE);
}
} else {
close(stdout_fd);
close(stderr_fd);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::string proc_path = "/proc/" + std::to_string(pid) + "/task/" + std::to_string(pid) + "/children";
std::ifstream proc_file(proc_path);
if (proc_file.is_open()) {
std::string line;
if (std::getline(proc_file, line)) {
std::istringstream iss(line);
pid_t child_pid;
if (iss >> child_pid) {
return child_pid;
}
}
}
return pid;
}
return -1;
}}

Owner Packages

  • No Owners