OksSystem::Executable Class Reference

Wrapper for executable file manipulation. More...

#include <Executable.hpp>

Inheritance diagram for OksSystem::Executable:

Collaboration diagram for OksSystem::Executable:

Public Types
typedef std::vector< std::string >	param_collection
typedef std::map< std::string, std::string >	env_collection
Public Types inherited from OksSystem::File
typedef std::vector< OksSystem::File >	file_list_t

Public Member Functions
	Executable (const OksSystem::File &file)
	Executable (const char *filename)
	Executable (const std::string &filename)
	~Executable ()
void	exec () const
	run the executable
void	exec (const param_collection &params) const
	run the executable
std::string	pipe_in (const param_collection &params) const
	run the executable and pipe results back
std::string	pipe_in (const param_collection &params, const env_collection &envs) const
Process	pipe_out (const param_collection &params, const File &input_file, const File &output_file, const File &error_file, mode_t perm) const
Process	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
void	exec (const param_collection &params, const env_collection &envs) const
	run the executable
Process	start (const param_collection &params) const
	start the executable in another process
Process	start_and_forget (const param_collection &params) const
	start the executable in another process; do not wait for termination of child
Process	start (const param_collection &params, const env_collection &envs) const
	start the executable in another process
std::string	to_string (const param_collection &params) const
	converts executable name and a parameter sequence into a string
Public Member Functions inherited from OksSystem::File
	File (const std::string &name)
	File (const char *name)
	File (const File &other)
virtual	~File ()
	operator std::string () const throw ()
	operator const char * () const throw ()
	operator bool () const throw ()
bool	equals (const File &other) const throw ()
	compare two files *‍/
	operator size_t () const
const std::string &	full_name () const throw ()
	full name for file *‍/
const char *	c_full_name () const throw ()
std::string	short_name () const throw ()
	short name for file *‍/
std::string	parent_name () const throw ()
	path of directory containing file *‍/
std::string	extension () const throw ()
	extension for file *‍/
int	depth () const throw ()
	depth of the file *‍/
OksSystem::File	parent () const
	parent of the current file *‍/
OksSystem::File	child (const std::string &name) const
	named child of the current directory *‍/
OksSystem::File	temporary (const std::string &prefix) const
bool	exists () const throw ()
	does the file exist *‍/
mode_t	permissions () const
	permissions for the file *‍/
std::string	pretty_permissions () const
	pretty permissions for the file *‍/
size_t	size () const
	size of file *‍/
uid_t	owner_id () const
	owner id of file *‍/
User	owner () const
	owner of the file *‍/
gid_t	group () const
	group of file *‍/
bool	is_regular () const
	is the file a directory *‍/
bool	is_directory () const
	is the file a regular file *‍/
bool	is_fifo () const
	is the file a named pipe *‍/
std::string	file_type () const
	type of the file *‍/
file_list_t	directory () const
	list of file in directory *‍/
void	unlink () const
	deletes (unlinks) file *‍/
void	rmdir () const
	deletes directory *‍/
void	remove () const
	recursively delete files and directories *‍/
void	rename (const File &other) const
	rename or moves the file *‍/
void	permissions (mode_t permissions) const
	sets the type of the file *‍/
void	make_dir (mode_t permissions) const
	creates a directory *‍/
void	make_path (mode_t permissions) const
	creates a full path *‍/
void	make_fifo (mode_t permissions) const
	creates a FIFO (named pipe) *‍/
void	ensure_path (mode_t permissions) const
	creates the parent path *‍/
std::istream *	input () const
	returns an input stream from the file*‍/
std::ostream *	output (bool append=false) const
	returns an output stream to the file*‍/

Static Public Member Functions
static std::string	okssystem (const std::string &command)
	execute a command in a shell
Static Public Member Functions inherited from OksSystem::File
static std::string	protocol (const std::string &url) throw ()
	extracts the protocol part of an url *‍/
static std::string	extension (const std::string &url) throw ()
	extracts the extension of a path or an url *‍/
static std::string	uri (const std::string &url) throw ()
	extracts the local path of an url *‍/
static std::string	short_name (const std::string &url) throw ()
	extracts the short file name of an url *‍/
static int	depth (const std::string &path) throw ()
	calculates depth of a path *‍/
static std::string	first_line (const std::string &text)
	extracts the first line of a text *‍/
static File	from_url (const std::string &url)
	build a file out of an URL *‍/
static std::string	working_directory ()
	current directory of process *‍/
static void	working_directory (const File &dir)
	set working directory of process *‍/
static std::string	expand_home (const std::string path)
	resolve home directory *‍/
static std::string	pretty_permissions (mode_t permissions)
	pretty prints permissions *‍/
static std::string	to_string (mode_t permissions) throw ()
	converts permission to string *‍/
static std::string	pretty_open_flag (int flags)
	pretty prints open flags *‍/
static std::string	pretty_size (size_t size, bool cut_small)
	pretty prints a file size *‍/

Protected Member Functions
void	exec (char **argv) const
	does the actual exec
void	exec (char **const argv, char **const env) const
	does the actual exec setting the right environment for the child process
Protected Member Functions inherited from OksSystem::File
void	set_name (const std::string &name)
	sets the name of the file *‍/
mode_t	get_mode () const
	get mode associated with file (permission + type) *‍/

Static Protected Member Functions
static void	copy_fd (int fd, std::ostream &target)
	copies the content of a file descriptor into a STL stream
Static Protected Member Functions inherited from OksSystem::File
static int	unit (int u)
	calculates the value of a computer unit of order n (i.e KB,GB, etc *‍/

Static Protected Attributes
static const char *const	SHELL_COMMAND = "/bin/sh"
	command to execute in a shell
static const char *const	SHELL_COMMAND_PARAM = "-c"
	parameter to execute in a shell
Static Protected Attributes inherited from OksSystem::File
static const char *const	HUMAN_SIZE_STR [] = { "B", "KB", "MB", "GB" }
	strings for pretty printing file sizes *‍/
static const char *const	HUMAN_OPEN_STR [] = { "READ", "WRITE", "NOBLOCK", "APPEND", "CREATE", "TRUNCATE","EXCLUSIVE" }
	strings for pretty printing open flags *‍/
static const int	KILOBYTE = 1024
	number of bytes in a kilobyte *‍/
static const char *const	FILE_COMMAND_PATH = "/usr/bin/file"

Additional Inherited Members
Static Public Attributes inherited from OksSystem::File
static const char *const	FILE_FLAG_STR = "-rwxS"
	column headers for display of permissions *‍/
static const char *const	FILE_PROTOCOL = "file"
	string for the file protocol *‍/
Protected Attributes inherited from OksSystem::File
std::string	m_full_name
	full name (path) of the file *‍/

Detailed Description

Wrapper for executable file manipulation.

This class represents an executable file, that is a program. The class offers facilities to launch the program with given parameters environnement variables

Author

Matthias Wiesmann

Version

1.0

Definition at line 29 of file Executable.hpp.

Member Typedef Documentation

env_collection

std::map<std::string, std::string> OksSystem::Executable::env_collection

Definition at line 33 of file Executable.hpp.

param_collection

std::vector<std::string> OksSystem::Executable::param_collection

Definition at line 32 of file Executable.hpp.

Constructor & Destructor Documentation

Executable() [1/3]

OksSystem::Executable::Executable

(

const OksSystem::File &

file

)

Definition at line 54 of file Executable.cpp.

: OksSystem::File(file) {}

Executable() [2/3]

OksSystem::Executable::Executable

(

const char *

filename

)

Definition at line 55 of file Executable.cpp.

: OksSystem::File(filename) {}

Executable() [3/3]

OksSystem::Executable::Executable

(

const std::string &

filename

)

Definition at line 56 of file Executable.cpp.

: OksSystem::File(filename) {}

~Executable()

OksSystem::Executable::~Executable

(

)

Definition at line 57 of file Executable.cpp.

{}

Member Function Documentation

copy_fd()

void OksSystem::Executable::copy_fd ( int fd, std::ostream & target )

staticprotected

copies the content of a file descriptor into a STL stream

Copies the content of a file descriptor into a STL stream

Parameters

fd	the source file descriptor
target	the target stream

Note

a more efficient version could use the underlying STL buffer

Definition at line 311 of file Executable.cpp.

                                                            {
    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 

exec() [1/5]

void OksSystem::Executable::exec

(

)

const

run the executable

exec() [2/5]

void OksSystem::Executable::exec ( char ** argv ) const

protected

does the actual exec

Core execution method. This method assumes the datastructures have been setup correctly for execv. It basically adds some error handling to execv

Parameters

argv	array of arguments, with name of the executable in first position

Note

this method should not be called directly

Definition at line 67 of file Executable.cpp.

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

exec() [3/5]

void OksSystem::Executable::exec ( char **const argv, char **const env ) const

protected

does the actual exec setting the right environment for the child process

Core execution method. This method assumes the datastructures have been setup correctly for execve. It basically adds some error handling to execve. Look at the execve man pages for details.

Parameters

argv	array of arguments, with name of the executable in first position
env	array containing the environment the process will be started with

Definition at line 81 of file Executable.cpp.

                                                                        {
    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 );   
}

exec() [4/5]

void OksSystem::Executable::exec

(

const param_collection &

params

)

const

run the executable

Simple execution method. This methods converts the vector of strings into the correct data structures for execv. The argv structure is allocated dynamically and new string copied into it.

Definition at line 94 of file Executable.cpp.

                                                                   {
    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 

exec() [5/5]

void OksSystem::Executable::exec	(	const param_collection &	params,
		const env_collection &	envs ) const

run the executable

This execution method calls the 'execve' function executing the

Parameters

params	the parameters to use when launching the executable
envs	table of the environnement variables set for the executable

Definition at line 130 of file Executable.cpp.

                                                                                               {
 
  // 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()

std::string OksSystem::Executable::okssystem ( const std::string & command )

static

execute a command in a shell

This method is a safe replacement for the okssystem function. It basically offers the same functionality with better error handling. The command is executed in a shell via /bin/sh -c. If the command is successfull (return value 0), this method returns the resulting string.
If the command fails, this method throws an exception of type okssystem::ExecutionIssue. This exception contains the return code and the content of stderr.

Parameters

command

the command to execute

Returns

the content of the stdout stream for the executed command

See also

pipe_in()

Definition at line 46 of file Executable.cpp.

                                                                 {
    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

pipe_in() [1/2]

std::string OksSystem::Executable::pipe_in

(

const param_collection &

params

)

const

run the executable and pipe results back

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 325 of file Executable.cpp.

                                                                           {
 
    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

pipe_in() [2/2]

std::string OksSystem::Executable::pipe_in	(	const param_collection &	params,
		const env_collection &	envs ) const

This method executes the process and pipes stdout and stderr back and waits for execution termination. If the return value is zero then the content of stdout is copied into a string and returned. In case of a non-zero value, an exception is thrown. This exception contains the return code and the content of stderr.

Returns

content of stdout

Parameters

params	the parameters to the executable
envs	the environnement variables to set

Exceptions

OksSystem::ExecutionIssue	if command execution did not return 0.
OksSystem::ExecFail	if the exec okssystem call failed.
OksSystem::PipeIssue	if the pipe okssystem call failed.

Definition at line 418 of file Executable.cpp.

                                                                                                       {
    OksSystem::Environment::set(envs);
    return pipe_in(params); 
} // pipe_in

pipe_out() [1/2]

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

Runs the executable and redirects the two output streams

Parameters

params	the parameters for the executable
envs	the environnements for the executable
input_file	the input file for stdin
output_file	the output file for stdout
error_file	the output file for stderr
perm	permissions for both output streams

Definition at line 493 of file Executable.cpp.

                                                                                                                                                                                                     {
 
  // 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

pipe_out() [2/2]

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

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

Definition at line 425 of file Executable.cpp.

                                                                                                                                                                        {
 
  // 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

start() [1/2]

OksSystem::Process OksSystem::Executable::start

(

const param_collection &

params

)

const

start the executable in another process

This method starts the executable in another process using fork

Parameters

params

the parameters to use when launching the executable

Returns

A process object representing the started process

Definition at line 204 of file Executable.cpp.

                                                                                {
 
  // 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

start() [2/2]

OksSystem::Process OksSystem::Executable::start	(	const param_collection &	params,
		const env_collection &	envs ) const

start the executable in another process

This method starts the executable in another process using fork

Parameters

params	the parameters to use when launching the executable
envs	table of the environnement variables set for the executable

Definition at line 558 of file Executable.cpp.

                                                                                                            {
 
  // 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

start_and_forget()

OksSystem::Process OksSystem::Executable::start_and_forget

(

const param_collection &

params

)

const

start the executable in another process; do not wait for termination of child

This method starts the executable in another process using fork. The parent will not wait on the child termination.

Parameters

params

the parameters to use when launching the executable

Returns

A process object representing the started process

Definition at line 256 of file Executable.cpp.

                                                                                           {
  
  // 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

to_string()

std::string OksSystem::Executable::to_string

(

const param_collection &

params

)

const

converts executable name and a parameter sequence into a string

Converts the executable name and a list of parameters into a string, suitable for display.

Parameters

params

the list of parameters

Returns

a string with command name and parameters separated by spaces

Definition at line 609 of file Executable.cpp.

                                                                             {
    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

Member Data Documentation

SHELL_COMMAND

const char *const OksSystem::Executable::SHELL_COMMAND = "/bin/sh"

staticprotected

command to execute in a shell

Definition at line 37 of file Executable.hpp.

SHELL_COMMAND_PARAM

const char *const OksSystem::Executable::SHELL_COMMAND_PARAM = "-c"

staticprotected

parameter to execute in a shell

Definition at line 38 of file Executable.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/okssystem/include/okssystem/Executable.hpp
• /github/workspace/dunedaq/sourcecode/okssystem/src/Executable.cpp