Process.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/Process.cxx to src/Process.cpp).
 
/*
 *  Process.cxx
 *  OksSystem 
 *
 *  Created by Matthias Wiesmann on 18.01.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include <sys/wait.h>
#include <sys/types.h>
#include <unistd.h>
#include <sysexits.h>
 
#include <iostream>
#include <sstream>
 
#include "ers/ers.hpp"
 
#include "okssystem/exceptions.hpp"
#include "okssystem/Process.hpp"
 
 
const int OksSystem::Process::TEST_BASE_VALUE = 182;
const int OksSystem::Process::TEST_MAX_VALUE = 186; 
 
const int OksSystem::Process::TERMINATION_WAIT = 100000; 
 
const char * const OksSystem::Process::SYS_EXITS_NAMES[] = { "command line usage error", "data format error", "cannot open input", "addressee unknown", "host name unknown", "service unavailable", "internal software error", "okssystem error", 
    "critical OS file missing", "can't create (user) output file", "input/output error", "temp failure; user is invited to retry", "remote error in protocol", "permission denied ", "configuration error" };
const char * const OksSystem::Process::TEST_EXITS_NAMES[] = { "undefined test", "test failed", "test unresolved", "test untested", "unsupported test" };
const char * const OksSystem::Process::OK_EXIT_NAME = "ok";
 
OksSystem::Process *OksSystem::Process::s_instance = 0;

 
const char* OksSystem::Process::exit_text(int return_value) {
    if ( 0==return_value) return OK_EXIT_NAME;
    if ((return_value >= EX__BASE)  && (return_value <= EX__MAX)) return SYS_EXITS_NAMES[return_value-EX__BASE];
    if ((return_value >= TEST_BASE_VALUE) && (return_value <= TEST_MAX_VALUE)) return TEST_EXITS_NAMES[return_value-TEST_BASE_VALUE];
    return 0;
} // return_text

 
std::string OksSystem::Process::exit_pretty(int return_value) {
    std::ostringstream stream;
    const char* text = OksSystem::Process::exit_text(return_value);
    if (text) {
    stream << text << '(' << return_value << ')';
    } else {
    stream << return_value ;
    }
    return stream.str(); 
} // exit_string
 

 
const OksSystem::Process *OksSystem::Process::instance() throw() {
    if (0==s_instance) {
    s_instance = new OksSystem::Process(); 
    } // if
    return s_instance;
} // instance
 

 
void OksSystem::Process::set_name(const std::string &name) throw() {
    (void) instance();
    s_instance->m_process_name = name;
} // set_name
 

 
OksSystem::Process::Process() {
    m_process_id = ::getpid();
} // Process

 
OksSystem::Process::Process(const Process &other) {
    m_process_id = other.m_process_id;
    m_process_name = other.m_process_name;
} // Process

 
OksSystem::Process::Process(pid_t id){
    m_process_id = id;
} // Process 

 
OksSystem::Process::Process(pid_t id, const std::string &name) {
    m_process_id = id;
    m_process_name = name;
} 
 

 
OksSystem::Process::~Process() throw() {
    m_process_id = 0;
} // ~Process

 
OksSystem::Process::operator pid_t() const throw() {
    return m_process_id;
} // operator pid_t
 

 
int OksSystem::Process::join(bool throw_non_zero) const {
    ERS_PRECONDITION(! equals(*instance())); 
    int status;
    errno = 0;
    pid_t pid = ::waitpid(m_process_id,&status,0); 
    if (pid!=m_process_id) {
        std::string message = "on process " + this->to_string();
    throw OksSystem::OksSystemCallIssue( ERS_HERE, errno, "waitpid", message.c_str() ); 
    } // if 
    if (WIFEXITED(status)) {
    int exit_status = WEXITSTATUS(status);
    if ((throw_non_zero==false) || (exit_status==0)) return exit_status;
    throw OksSystem::TerminationIssue(ERS_HERE, errno, exit_status);
    } // exit status
    if (WIFSIGNALED(status)) throw OksSystem::SignalIssue(ERS_HERE,errno,WTERMSIG(status));
    if (WIFSTOPPED(status)) throw OksSystem::SignalIssue(ERS_HERE,errno,WSTOPSIG(status));
    return WEXITSTATUS(status);
} // join

 
void OksSystem::Process::signal(int signal_number) const {
    const int status = ::kill(m_process_id,signal_number);
    if (status < 0) {
      std::string message = "on process " + this->to_string();
      throw OksSystem::OksSystemCallIssue(ERS_HERE, errno, "kill", message.c_str());
    }
} // signal

 
bool OksSystem::Process::exists() const {
    const int status = ::kill(m_process_id,0);
    return (status>=0);
} // exists

 
bool OksSystem::Process::equals(const Process &other) const throw() {
    return m_process_id == other.m_process_id;
} // equals

 
void OksSystem::Process::terminate() const {
  /*
    struct timespec wait_time;
    struct timespec remain_time;
    wait_time.tv_sec = 0;
    wait_time.tv_nsec = TERMINATION_WAIT;
  */
    if (exists()) {
    signal(SIGTERM);
    }
    return;
} 
 
/* This is a piece of crap 
    nanosleep(&wait_time,&remain_time); 
    if (exists()) {
    signal(SIGQUIT);
    } else {
    return;
    } //
    nanosleep(&wait_time,&remain_time); 
    if (exists()) {
    signal(SIGKILL);
    } // exists
} // terminate
*/
 
std::string OksSystem::Process::to_string() const throw() {
    std::ostringstream stream;
    if (! m_process_name.empty()) {
    stream << m_process_name << ' ';
    } 
    stream << "pid: " << m_process_id;
    return stream.str(); 
} // to_string

 
pid_t OksSystem::Process::process_id() const throw() { return m_process_id;} 

 
std::ostream& operator<<(std::ostream& out, const OksSystem::Process &proc) {
    out << proc.to_string();
    return out;
} // operator<<

 
bool operator ==(const OksSystem::Process &a, const OksSystem::Process &b)  throw() {
    return a.equals(b);
} // operator ==

 
bool operator !=(const OksSystem::Process &a, const OksSystem::Process &b)  throw() {
    return ! a.equals(b); 
} // operator !=