ACE  6.1.5
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Friends | List of all members
ACE_Process Class Reference

Process. More...

#include <Process.h>

Inheritance diagram for ACE_Process:
Inheritance graph
[legend]
Collaboration diagram for ACE_Process:
Collaboration graph
[legend]

Public Member Functions

 ACE_Process (void)
 Default construction. Must use <ACE_Process::spawn> to start.
 
virtual ~ACE_Process (void)
 Destructor.
 
virtual int prepare (ACE_Process_Options &options)
 
virtual pid_t spawn (ACE_Process_Options &options)
 
virtual void parent (pid_t child)
 
virtual void child (pid_t parent)
 
virtual void unmanage (void)
 
pid_t wait (ACE_exitcode *status=0, int wait_options=0)
 
pid_t wait (const ACE_Time_Value &tv, ACE_exitcode *status=0)
 
int kill (int signum=SIGINT)
 
int terminate (void)
 
pid_t getpid (void) const
 Return the process id of the new child process.
 
ACE_HANDLE gethandle (void) const
 Return the handle of the process, if it has one.
 
int running (void) const
 Return 1 if running; 0 otherwise.
 
ACE_exitcode exit_code (void) const
 
int return_value (void) const
 
void close_dup_handles (void)
 
void close_passed_handles (void)
 
PROCESS_INFORMATION process_info (void)
 

Protected Member Functions

void exit_code (ACE_exitcode code)
 

Protected Attributes

PROCESS_INFORMATION process_info_
 
ACE_exitcode exit_code_
 
ACE_Handle_Set handles_passed_
 Set of handles that were passed to the child process.
 
ACE_Handle_Set dup_handles_
 Handle duplicates made for the child process.
 

Private Member Functions

 ACE_Process (const ACE_Process &)
 
void operator= (const ACE_Process &)
 
wchar_t * convert_env_buffer (const char *env) const
 

Friends

class ACE_Process_Manager
 

Detailed Description

Process.

A Portable encapsulation for creating new processes. Notice that on UNIX platforms, if the <setenv> is used, the <spawn> is using the <execve> system call. It means that the <command_line> should include a full path to the program file (<execve> does not search the PATH). If <setenv> is not used then, the <spawn> is using the <execvp> which searches for the program file in the PATH variable.

Constructor & Destructor Documentation

ACE_Process::ACE_Process ( void  )

Default construction. Must use <ACE_Process::spawn> to start.

ACE_Process::~ACE_Process ( void  )
virtual

Destructor.

ACE_Process::ACE_Process ( const ACE_Process )
private

Member Function Documentation

void ACE_Process::child ( pid_t  parent)
virtual

Called just after <ACE_OS::fork> in the child's context. The default does nothing. This function is not called on Win32 because the process-creation scheme does not allow it.

void ACE_Process::close_dup_handles ( void  )

Close all the handles in the set obtained from the

void ACE_Process::close_passed_handles ( void  )

Close all the handles in the set obtained from the

wchar_t * ACE_Process::convert_env_buffer ( const char *  env) const
private
ACE_exitcode ACE_Process::exit_code ( void  ) const
inline

Return the Process' exit code. This method returns the raw exit status returned from system APIs (such as <wait> or <waitpid>). This value is system dependent.

void ACE_Process::exit_code ( ACE_exitcode  code)
inlineprotected

Set this process' <exit_code_>. ACE_Process_Manager uses this method to set the <exit_code_> after successfully waiting for this process to exit.

ACE_HANDLE ACE_Process::gethandle ( void  ) const
inline

Return the handle of the process, if it has one.

pid_t ACE_Process::getpid ( void  ) const
inline

Return the process id of the new child process.

int ACE_Process::kill ( int  signum = SIGINT)
inline

Send the process a signal. This is only portable to operating systems that support signals, such as UNIX/POSIX.

void ACE_Process::operator= ( const ACE_Process )
private
void ACE_Process::parent ( pid_t  child)
virtual

Called just after <ACE_OS::fork> in the parent's context, if the <fork> succeeds. The default is to do nothing.

int ACE_Process::prepare ( ACE_Process_Options options)
virtual

Called just before <ACE_OS::fork> in the <spawn>. If this returns non-zero, the <spawn> is aborted (and returns ACE_INVALID_PID). The default simply returns zero.

PROCESS_INFORMATION ACE_Process::process_info ( void  )
inline
int ACE_Process::return_value ( void  ) const
inline

Return the Process' return value. This method returns the actual return value that a child process returns or <exit>s.

int ACE_Process::running ( void  ) const

Return 1 if running; 0 otherwise.

pid_t ACE_Process::spawn ( ACE_Process_Options options)
virtual

Launch a new process as described by options. On success, returns 1 if the option avoid_zombies is set, else returns the process id of the newly spawned child. Returns -1 on failure. This will be fixed in the future versions of ACE when the process id of the child will be returned regardless of the option.

int ACE_Process::terminate ( void  )
inline

Terminate the process abruptly using ACE::terminate_process(). This call doesn't give the process a chance to cleanup, so use it with caution...

void ACE_Process::unmanage ( void  )
virtual

Called by a Process_Manager that is removing this Process from its table of managed Processes. Default is to do nothing.

Reimplemented in ACE_Managed_Process.

pid_t ACE_Process::wait ( ACE_exitcode status = 0,
int  wait_options = 0 
)
inline

Wait for the process we've created to exit. If status != 0, it points to an integer where the function store the exit status of child process to. If wait_options == WNOHANG then return 0 and don't block if the child process hasn't exited yet. A return value of -1 represents the <wait> operation failed, otherwise, the child process id is returned.

pid_t ACE_Process::wait ( const ACE_Time_Value tv,
ACE_exitcode status = 0 
)

Timed wait for the process we've created to exit. A return value of -1 indicates that the something failed; 0 indicates that a timeout occurred. Otherwise, the child's process id is returned. If status != 0, it points to an integer where the function stores the child's exit status.

Note
On UNIX platforms this function uses <ualarm>, i.e., it overwrites any existing alarm. In addition, it steals all <SIGCHLD>s during the timeout period, which will break another <ACE_Process_Manager> in the same process that's expecting <SIGCHLD> to kick off process reaping.

Friends And Related Function Documentation

friend class ACE_Process_Manager
friend

Member Data Documentation

ACE_Handle_Set ACE_Process::dup_handles_
protected

Handle duplicates made for the child process.

ACE_exitcode ACE_Process::exit_code_
protected
ACE_Handle_Set ACE_Process::handles_passed_
protected

Set of handles that were passed to the child process.

PROCESS_INFORMATION ACE_Process::process_info_
protected

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