pmc 2.0.0

PMC is a simple and easy to use PM2 alternative
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#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;
}}