ACE 6.0.1
Public Member Functions | Protected Member Functions | Protected Attributes | Private Member Functions | Friends

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]

List of all members.

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)

Protected Member Functions

void exit_code (ACE_exitcode code)

Protected Attributes

pid_t child_id_
 Process id of the child.
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 &)

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

void ACE_Process::exit_code ( ACE_exitcode  code) [protected]

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_exitcode ACE_Process::exit_code ( void  ) const

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.

ACE_HANDLE ACE_Process::gethandle ( void  ) const

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

pid_t ACE_Process::getpid ( void  ) const

Return the process id of the new child process.

int ACE_Process::kill ( int  signum = SIGINT)

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.

int ACE_Process::return_value ( void  ) const

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  )

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 
)

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

pid_t ACE_Process::child_id_ [protected]

Process id of the child.

Handle duplicates made for the child process.

Set of handles that were passed to the child process.


The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines