Executable.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS system source for the DUNE DAQ project.
// Fork baseline commit: system-00-00-20 (2020-09-25).
// Renamed since fork: yes (from src/Executable.cxx to src/Executable.cpp).
 
/*
 *  Executable.cxx
 *  ers
 *
 *  Created by Matthias Wiesmann on 06.01.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <cstdio>
#include <cstdlib>
#include <fcntl.h>
#include <iostream>
#include <pthread.h>
#include <signal.h>
#include <sstream>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
 
#include "ers/Assertion.hpp"
#include "ers/ers.hpp"
 
#include "okssystem/Descriptor.hpp"
#include "okssystem/Environment.hpp"
#include "okssystem/Executable.hpp"
#include "okssystem/Process.hpp"
#include "okssystem/exceptions.hpp"
 
const char* const OksSystem::Executable::SHELL_COMMAND = "/bin/sh";
const char* const OksSystem::Executable::SHELL_COMMAND_PARAM = "-c";

 
std::string
OksSystem::Executable::okssystem(const std::string& command)
{
  OksSystem::Executable shell(SHELL_COMMAND);
  std::vector<std::string> params;
  params.push_back(SHELL_COMMAND_PARAM);
  params.push_back(command);
  return shell.pipe_in(params);
} // std::string
 
OksSystem::Executable::Executable(const OksSystem::File& file)
  : OksSystem::File(file)
{
}
OksSystem::Executable::Executable(const char* filename)
  : OksSystem::File(filename)
{
}
OksSystem::Executable::Executable(const std::string& filename)
  : OksSystem::File(filename)
{
}
OksSystem::Executable::~Executable() {}

 
void
OksSystem::Executable::exec(char** argv) const
{
  ERS_PRECONDITION(argv);
  ERS_PRECONDITION(argv[0]);
  const int status = ::execv(argv[0], argv);
  throw OksSystem::ExecutionIssue(ERS_HERE, errno, argv[0], status);
} // exec

void
OksSystem::Executable::exec(char** const argv, char** const env) const
{
  ERS_PRECONDITION(argv);
  ERS_PRECONDITION(argv[0]);
  ERS_PRECONDITION(env);
  const int status = ::execve(argv[0], argv, env);
  throw OksSystem::ExecutionIssue(ERS_HERE, errno, argv[0], status);
}

 
void
OksSystem::Executable::exec(const param_collection& params) const
{
  const int argc = params.size(); // number of parameters
  const int argclen = argc + 2;   // size of array parameters + program name + null pointer
  char** argv = (char**)calloc(sizeof(char*), argclen);
  OKSSYSTEM_ALLOC_CHECK(argv, sizeof(char*) * argclen);
  const char* name = *this;
  argv[0] = strdup(name);
  OKSSYSTEM_ALLOC_CHECK(argv[0], strlen(name));
  for (int i = 0; i < argc; i++) {
    argv[i + 1] = strdup(params[i].c_str());
  } // loop over args
  argv[argc + 1] = 0;
  try {
    exec(argv);
  } catch (OksSystem::ExecutionIssue& ex) {
    for (int i = 0; argv[i] != 0; i++) {
      free(argv[i]);
    } // for
    free(argv);
    throw;
  } catch (ers::Issue& issue) { // there was a problem so we deallocate the argc array.
    for (int i = 0; argv[i] != 0; i++) {
      free(argv[i]);
    } // for
    free(argv);
    throw;
  } // catch
} // exec

 
void
OksSystem::Executable::exec(const param_collection& params, const env_collection& envs) const
{
 
  // Elaborate the environment
  const unsigned int envArraySize = envs.size() + 1; // The last elements must be NULL
  char** const env = new char*[envArraySize];
 
  {
    const env_collection::const_iterator b = envs.begin();
    const env_collection::const_iterator e = envs.end();
    env_collection::const_iterator it;
 
    unsigned int counter = 0;
    for (it = b; it != e; ++it) {
      const std::string entry = it->first + "=" + it->second;
      env[counter] = new char[entry.size() + 1]; // Add the NULL terminator
      ::strcpy(env[counter], entry.c_str());
      ++counter;
    }
 
    env[envArraySize - 1] = (char*)0;
  }
 
  // Elaborate the paramenters
  const unsigned int paramArraySize = params.size() + 2; // Add the executable name and the NULL terminator
  char** const par = new char*[paramArraySize];
 
  {
    const std::string& binName = this->full_name();
    par[0] = new char[binName.size() + 1]; // Add the NULL terminator
    ::strcpy(par[0], binName.c_str());
 
    const param_collection::const_iterator b = params.begin();
    const param_collection::const_iterator e = params.end();
    param_collection::const_iterator it;
 
    unsigned int counter = 1;
    for (it = b; it != e; ++it) {
      const std::string& value = *it;
      par[counter] = new char[value.size() + 1]; // Add the NULL terminator
      ::strcpy(par[counter], value.c_str());
      ++counter;
    }
 
    par[paramArraySize - 1] = (char*)0;
  }
 
  try {
    exec(par, env);
  } catch (OksSystem::ExecutionIssue& ex) {
    // if we are here it means that the exec call failed!!!
    // Free the allocated memory
    for (unsigned int i = 0; i < envArraySize; ++i) {
      delete[] env[i];
    }
    delete[] env;
 
    for (unsigned int i = 0; i < paramArraySize; ++i) {
      delete[] par[i];
    }
    delete[] par;
 
    // Re-throw the exception
    throw ex;
  }
}

 
OksSystem::Process
OksSystem::Executable::start(const param_collection& params) const
{
 
  // Block all signals before fork()
  sigset_t new_set;
  sigset_t old_set;
  sigfillset(&new_set);
  pthread_sigmask(SIG_SETMASK, &new_set, &old_set);
 
  const pid_t child_id = fork();
  if (0 == child_id) { // we are the child
 
    // Put some signals to their default
    signal(SIGTERM, SIG_DFL);
    signal(SIGINT, SIG_DFL);
 
    // Restore the original signal mask in child
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    try {
      exec(params);
    } catch (OksSystem::ExecutionIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (ers::Issue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    }
 
  } // we are the child
  if (child_id > 0) { // we are the parent
 
    // Restore the original signal mask in parent
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    return Process(child_id, to_string(params));
 
  } // we are the parent
 
  // Restore the original signal mask in case of a fork() failure
  pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
  throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "fork", ""); // We are screwed up
} // start

 
OksSystem::Process
OksSystem::Executable::start_and_forget(const param_collection& params) const
{
 
  // Block all signals before fork()
  sigset_t new_set;
  sigset_t old_set;
  sigfillset(&new_set);
  pthread_sigmask(SIG_SETMASK, &new_set, &old_set);
 
  signal(SIGCLD, SIG_IGN); /* now I don't have to wait()! */
 
  const pid_t child_id = fork();
  if (0 == child_id) { // we are the child
 
    // Put some signals to their default
    signal(SIGTERM, SIG_DFL);
    signal(SIGINT, SIG_DFL);
    signal(SIGCLD, SIG_DFL); /* Restore default SIGCLD handling in the child process */
 
    // Restore the original signal mask in child
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    try {
      exec(params);
    } catch (OksSystem::ExecutionIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (ers::Issue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    }
 
  } // we are the child
  if (child_id > 0) { // we are the parent
 
    // Restore the original signal mask in parent
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    return Process(child_id, to_string(params));
  } // we are the parent
 
  // Restore the original signal mask in case of a fork() failure
  pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
  throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "fork", ""); // We are screwed up
} // start

 
void
OksSystem::Executable::copy_fd(int fd, std::ostream& target)
{
  while (true) {
    char buffer[256];
    long status = read(fd, buffer, sizeof(buffer));
    if (status <= 0)
      return;
    ERS_ASSERT(status <= (long)sizeof(buffer));
    for (int i = 0; i < status; i++) {
      target << (char)buffer[i];
    } // for
  } // while
} // copy_fd

 
std::string
OksSystem::Executable::pipe_in(const param_collection& params) const
{
 
  int input_pipe[2];
  int data_pipe[2];
  int error_pipe[2];
  const int input_pipe_status = pipe(input_pipe);
  if (input_pipe_status < 0)
    throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "pipe", "");
  const int data_pipe_status = pipe(data_pipe);
  if (data_pipe_status < 0)
    throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "pipe", "");
  const int error_pipe_status = pipe(error_pipe);
  if (error_pipe_status < 0)
    throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "pipe", "");
 
  // Block all signals before fork()
  sigset_t new_set;
  sigset_t old_set;
  sigfillset(&new_set);
  pthread_sigmask(SIG_SETMASK, &new_set, &old_set);
 
  const pid_t child_id = fork();
  if (0 == child_id) { // we are the child
 
    // Put some signals to their default
    signal(SIGTERM, SIG_DFL);
    signal(SIGINT, SIG_DFL);
 
    // Restore the original signal mask in child
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    dup2(input_pipe[1], fileno(stdin));
    dup2(data_pipe[1], fileno(stdout));
    dup2(error_pipe[1], fileno(stderr));
 
    try {
      this->exec(params);
    } catch (OksSystem::ExecutionIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (ers::Issue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    }
 
  } // we are the child
  if (child_id > 0) { // we are the parent
 
    // Restore the original signal mask in parent
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    Process child_process(child_id, to_string(params));
    close(input_pipe[1]);
    close(data_pipe[1]);
    close(error_pipe[1]);
    const int child_status = child_process.join();
    const int in_fd = input_pipe[0];
    const int err_fd = error_pipe[0];
    const int out_fd = data_pipe[0];
    std::ostringstream in_stream;
    std::ostringstream out_stream;
    std::ostringstream err_stream;
    copy_fd(in_fd, in_stream);
    copy_fd(out_fd, out_stream);
    copy_fd(err_fd, err_stream);
    close(in_fd);
    close(out_fd);
    close(err_fd);
    if (0 == child_status) {
      return out_stream.str();
    } // if
    std::string command = to_string(params);
    std::string error_str = err_stream.str();
    throw OksSystem::ExecutionIssue(ERS_HERE, errno, command.c_str(), child_status);
  } // we are the parent
 
  // Restore the original signal mask in case of a fork() failure
  pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
  return std::string();
} // pipe_in

 
std::string
OksSystem::Executable::pipe_in(const param_collection& params, const env_collection& envs) const
{
  OksSystem::Environment::set(envs);
  return pipe_in(params);
} // pipe_in

 
OksSystem::Process
OksSystem::Executable::pipe_out(const param_collection& params,
                                const File& input_file,
                                const File& output_file,
                                const File& error_file,
                                mode_t perm) const
{
 
  // Block all signals before fork()
  sigset_t new_set;
  sigset_t old_set;
  sigfillset(&new_set);
  pthread_sigmask(SIG_SETMASK, &new_set, &old_set);
 
  OksSystem::Descriptor in(
    &input_file, OksSystem::Descriptor::flags(true, false), perm); // May throw OksSystem::OpenFileIssue
  OksSystem::Descriptor out(&output_file, OksSystem::Descriptor::flags(false, true), perm);
  OksSystem::Descriptor err(&error_file, OksSystem::Descriptor::flags(false, true), perm);
 
  const pid_t child_id = fork();
  if (0 == child_id) { // we are the child
 
    // Put some signals to their default
    signal(SIGTERM, SIG_DFL);
    signal(SIGINT, SIG_DFL);
 
    // Restore the original signal mask in child
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    try {
      ::dup2(in, ::fileno(stdin));
      ::dup2(out, ::fileno(stdout));
      ::dup2(err, ::fileno(stderr));
      ::close(in.fd());
      ::close(out.fd());
      ::close(err.fd());
      this->exec(params);
    } catch (OksSystem::ExecutionIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (OksSystem::PosixIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (ers::Issue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    }
 
  } // we are the child
  if (child_id > 0) { // we are the parent
 
    // Restore the original signal mask in parent
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    return Process(child_id, to_string(params));
  } // we are the parent
 
  // Restore the original signal mask in case of a fork() failure
  pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
  throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "fork", ""); // We are screwed up
} // pipe_out

 
OksSystem::Process
OksSystem::Executable::pipe_out(const param_collection& params,
                                const env_collection& envs,
                                const File& input_file,
                                const File& output_file,
                                const File& error_file,
                                mode_t perm) const
{
 
  // Block all signals before fork()
  sigset_t new_set;
  sigset_t old_set;
  sigfillset(&new_set);
  pthread_sigmask(SIG_SETMASK, &new_set, &old_set);
 
  OksSystem::Descriptor in(
    &input_file, OksSystem::Descriptor::flags(true, false), perm); // May throw OksSystem::OpenFileIssue
  OksSystem::Descriptor out(&output_file, OksSystem::Descriptor::flags(false, true), perm);
  OksSystem::Descriptor err(&error_file, OksSystem::Descriptor::flags(false, true), perm);
 
  const pid_t child_id = fork();
  if (0 == child_id) { // we are the child
 
    // Put some signals to their default
    signal(SIGTERM, SIG_DFL);
    signal(SIGINT, SIG_DFL);
 
    // Restore the original signal mask in child
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    try {
      ::dup2(in, ::fileno(stdin));
      ::dup2(out, ::fileno(stdout));
      ::dup2(err, ::fileno(stderr));
      ::close(in.fd());
      ::close(out.fd());
      ::close(err.fd());
      this->exec(params, envs);
    } catch (OksSystem::ExecutionIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (OksSystem::PosixIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (ers::Issue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    }
 
  } // we are the child
  if (child_id > 0) { // we are the parent
 
    // Restore the original signal mask in parent
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    return Process(child_id, to_string(params));
  } // we are the parent
 
  // Restore the original signal mask in case of a fork() failure
  pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
  throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "fork", ""); // We are screwed up
 
} // pipe_out

 
OksSystem::Process
OksSystem::Executable::start(const param_collection& params, const env_collection& envs) const
{
 
  // Block all signals before fork()
  sigset_t new_set;
  sigset_t old_set;
  sigfillset(&new_set);
  pthread_sigmask(SIG_SETMASK, &new_set, &old_set);
 
  const pid_t child_id = fork();
  if (child_id == 0) { // we are the child
 
    // Put some signals to their default
    signal(SIGTERM, SIG_DFL);
    signal(SIGINT, SIG_DFL);
 
    // Restore the original signal mask in child
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    try {
      exec(params, envs);
    } catch (OksSystem::ExecutionIssue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    } catch (ers::Issue& ex) {
      ers::warning(ex);
      _exit(EXIT_FAILURE);
    }
 
  } // we are the child
  if (child_id > 0) { // we are the parent
 
    // Restore the original signal mask in parent
    pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
    return Process(child_id);
  } // we are the parent
 
  // Restore the original signal mask in case of a fork() failure
  pthread_sigmask(SIG_SETMASK, &old_set, NULL);
 
  throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "fork", ""); // We are screwed up
} // start

 
std::string
OksSystem::Executable::to_string(const param_collection& params) const
{
  std::ostringstream stream;
  stream << m_full_name;
  for (param_collection::const_iterator pos = params.begin(); pos != params.end(); ++pos) {
    stream << " " << (*pos);
  } // for
  return stream.str();
} // to_string