Process

Terminate execution immediately, effectively by calling Kernel.exit(1). If msg is given, it is written to STDERR prior to terminating.

Some operating systems retain the status of terminated child processes until the parent collects that status (normally using some variant of wait(). If the parent never collects this status, the child stays around as a zombie process. Process::detach prevents this by setting up a separate Ruby thread whose sole job is to reap the status of the process pid when it terminates. Use detach only when you do not intent to explicitly wait for the child to terminate. detach only checks the status periodically (currently once each second).

The waiting thread returns the exit status of the detached process when it terminates, so you can use Thread#join to know the result. If specified pid is not a valid child process ID, the thread returns nil immediately.

In this first example, we don‘t reap the first child process, so it appears as a zombie in the process status display.

   p1 = fork { sleep 0.1 }
   p2 = fork { sleep 0.2 }
   Process.waitpid(p2)
   sleep 2
   system("ps -ho pid,state -p #{p1}")

produces:

   27389 Z

In the next example, Process::detach is used to reap the child automatically.

   p1 = fork { sleep 0.1 }
   p2 = fork { sleep 0.2 }
   Process.detach(p1)
   Process.waitpid(p2)
   sleep 2
   system("ps -ho pid,state -p #{p1}")

(produces no output)

Returns the effective group ID for this process. Not available on all platforms.

   Process.egid   #=> 500

Sets the effective group ID for this process. Not available on all platforms.

Returns the effective user ID for this process.

   Process.euid   #=> 501

Sets the effective user ID for this process. Not available on all platforms.

Replaces the current process by running the given external command. If exec is given a single argument, that argument is taken as a line that is subject to shell expansion before being executed. If multiple arguments are given, the second and subsequent arguments are passed as parameters to command with no shell expansion. If the first argument is a two-element array, the first element is the command to be executed, and the second argument is used as the argv[0] value, which may show up in process listings. In MSDOS environments, the command is executed in a subshell; otherwise, one of the exec(2) system calls is used, so the running command may inherit some of the environment of the original program (including open file descriptors).

   exec "echo *"       # echoes list of files in current directory
   # never get here

   exec "echo", "*"    # echoes an asterisk
   # never get here

Initiates the termination of the Ruby script by raising the SystemExit exception. This exception may be caught. The optional parameter is used to return a status code to the invoking environment.

   begin
     exit
     puts "never get here"
   rescue SystemExit
     puts "rescued a SystemExit exception"
   end
   puts "after begin block"

produces:

   rescued a SystemExit exception
   after begin block

Just prior to termination, Ruby executes any at_exit functions (see Kernel::at_exit) and runs any object finalizers (see ObjectSpace::define_finalizer).

   at_exit { puts "at_exit function" }
   ObjectSpace.define_finalizer("string",  proc { puts "in finalizer" })
   exit

produces:

   at_exit function
   in finalizer

Exits the process immediately. No exit handlers are run. fixnum is returned to the underlying system as the exit status.

   Process.exit!(0)

Creates a subprocess. If a block is specified, that block is run in the subprocess, and the subprocess terminates with a status of zero. Otherwise, the fork call returns twice, once in the parent, returning the process ID of the child, and once in the child, returning nil. The child process can exit using Kernel.exit! to avoid running any at_exit functions. The parent process should use Process.wait to collect the termination statuses of its children or use Process.detach to register disinterest in their status; otherwise, the operating system may accumulate zombie processes.

The thread calling fork is the only thread in the created child process. fork doesn‘t copy other threads.

Returns the process group ID for the given process id. Not available on all platforms.

   Process.getpgid(Process.ppid())   #=> 25527

Returns the process group ID for this process. Not available on all platforms.

   Process.getpgid(0)   #=> 25527
   Process.getpgrp      #=> 25527

Gets the scheduling priority for specified process, process group, or user. kind indicates the kind of entity to find: one of Process::PRIO_PGRP, Process::PRIO_USER, or Process::PRIO_PROCESS. integer is an id indicating the particular process, process group, or user (an id of 0 means current). Lower priorities are more favorable for scheduling. Not available on all platforms.

   Process.getpriority(Process::PRIO_USER, 0)      #=> 19
   Process.getpriority(Process::PRIO_PROCESS, 0)   #=> 19

Gets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit.

resource indicates the kind of resource to limit: such as Process::RLIMIT_CORE, Process::RLIMIT_CPU, etc. See Process.setrlimit for details.

cur_limit and max_limit may be Process::RLIM_INFINITY, Process::RLIM_SAVED_MAX or Process::RLIM_SAVED_CUR. See Process.setrlimit and the system getrlimit(2) manual for details.

Returns the (real) group ID for this process.

   Process.gid   #=> 500

Sets the group ID for this process.

Get an Array of the gids of groups in the supplemental group access list for this process.

   Process.groups   #=> [27, 6, 10, 11]

Set the supplemental group access list to the given Array of group IDs.

   Process.groups   #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
   Process.groups = [27, 6, 10, 11]   #=> [27, 6, 10, 11]
   Process.groups   #=> [27, 6, 10, 11]

Initializes the supplemental group access list by reading the system group database and using all groups of which the given user is a member. The group with the specified gid is also added to the list. Returns the resulting Array of the gids of all the groups in the supplementary group access list. Not available on all platforms.

   Process.groups   #=> [0, 1, 2, 3, 4, 6, 10, 11, 20, 26, 27]
   Process.initgroups( "mgranger", 30 )   #=> [30, 6, 10, 11]
   Process.groups   #=> [30, 6, 10, 11]

Sends the given signal to the specified process id(s), or to the current process if pid is zero. signal may be an integer signal number or a POSIX signal name (either with or without a SIG prefix). If signal is negative (or starts with a minus sign), kills process groups instead of processes. Not all signals are available on all platforms.

   pid = fork do
      Signal.trap("HUP") { puts "Ouch!"; exit }
      # ... do some work ...
   end
   # ...
   Process.kill("HUP", pid)
   Process.wait

produces:

   Ouch!

Returns the maximum number of gids allowed in the supplemental group access list.

   Process.maxgroups   #=> 32

Sets the maximum number of gids allowed in the supplemental group access list.

Returns the process id of this process. Not available on all platforms.

   Process.pid   #=> 27415

Returns the process id of the parent of this process. Always returns 0 on NT. Not available on all platforms.

   puts "I am #{Process.pid}"
   Process.fork { puts "Dad is #{Process.ppid}" }

produces:

   I am 27417
   Dad is 27417

Sets the process group ID of pid (0 indicates this process) to integer. Not available on all platforms.

Equivalent to setpgid(0,0). Not available on all platforms.

See Process#getpriority.

   Process.setpriority(Process::PRIO_USER, 0, 19)      #=> 0
   Process.setpriority(Process::PRIO_PROCESS, 0, 19)   #=> 0
   Process.getpriority(Process::PRIO_USER, 0)          #=> 19
   Process.getpriority(Process::PRIO_PROCESS, 0)       #=> 19

Sets the resource limit of the process. cur_limit means current (soft) limit and max_limit means maximum (hard) limit.

If max_limit is not given, cur_limit is used.

resource indicates the kind of resource to limit. The list of resources are OS dependent. Ruby may support following resources.

Process::RLIMIT_CORE

core size (bytes) (SUSv3)

Process::RLIMIT_CPU

CPU time (seconds) (SUSv3)

Process::RLIMIT_DATA

data segment (bytes) (SUSv3)

Process::RLIMIT_FSIZE

file size (bytes) (SUSv3)

Process::RLIMIT_NOFILE

file descriptors (number) (SUSv3)

Process::RLIMIT_STACK

stack size (bytes) (SUSv3)

Process::RLIMIT_AS

total available memory (bytes) (SUSv3, NetBSD, FreeBSD, OpenBSD but 4.4BSD-Lite)

Process::RLIMIT_MEMLOCK

total size for mlock(2) (bytes) (4.4BSD, GNU/Linux)

Process::RLIMIT_NPROC

number of processes for the user (number) (4.4BSD, GNU/Linux)

Process::RLIMIT_RSS

resident memory size (bytes) (4.2BSD, GNU/Linux)

Process::RLIMIT_SBSIZE

all socket buffers (bytes) (NetBSD, FreeBSD)

Other Process::RLIMIT_??? constants may be defined.

cur_limit and max_limit may be Process::RLIM_INFINITY, which means that the resource is not limited. They may be Process::RLIM_SAVED_MAX or Process::RLIM_SAVED_CUR too. See system setrlimit(2) manual for details.

Establishes this process as a new session and process group leader, with no controlling tty. Returns the session id. Not available on all platforms.

   Process.setsid   #=> 27422

Returns a Tms structure (see Struct::Tms on page 388) that contains user and system CPU times for this process.

   t = Process.times
   [ t.utime, t.stime ]   #=> [0.0, 0.02]

Returns the (real) user ID of this process.

   Process.uid   #=> 501

Sets the (integer) user ID for this process. Not available on all platforms.

Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object containing information on that process. Which child it waits on depends on the value of pid:

The flags argument may be a logical or of the flag values Process::WNOHANG (do not block if no child available) or Process::WUNTRACED (return stopped children that haven‘t been reported). Not all flags are available on all platforms, but a flag value of zero will work on all platforms.

Calling this method raises a SystemError if there are no child processes. Not available on all platforms.

   include Process
   fork { exit 99 }                 #=> 27429
   wait                             #=> 27429
   $?.exitstatus                    #=> 99

   pid = fork { sleep 3 }           #=> 27440
   Time.now                         #=> Wed Apr 09 08:57:09 CDT 2003
   waitpid(pid, Process::WNOHANG)   #=> nil
   Time.now                         #=> Wed Apr 09 08:57:09 CDT 2003
   waitpid(pid, 0)                  #=> 27440
   Time.now                         #=> Wed Apr 09 08:57:12 CDT 2003

Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a Process::Status object) of that child. Raises a SystemError if there are no child processes.

   Process.fork { exit 99 }   #=> 27437
   pid, status = Process.wait2
   pid                        #=> 27437
   status.exitstatus          #=> 99

Waits for all children, returning an array of pid/status pairs (where status is a Process::Status object).

   fork { sleep 0.2; exit 2 }   #=> 27432
   fork { sleep 0.1; exit 1 }   #=> 27433
   fork {            exit 0 }   #=> 27434
   p Process.waitall

produces:

   [[27434, #<Process::Status: pid=27434,exited(0)>],
    [27433, #<Process::Status: pid=27433,exited(1)>],
    [27432, #<Process::Status: pid=27432,exited(2)>]]

Waits for a child process to exit, returns its process id, and sets $? to a Process::Status object containing information on that process. Which child it waits on depends on the value of pid:

The flags argument may be a logical or of the flag values Process::WNOHANG (do not block if no child available) or Process::WUNTRACED (return stopped children that haven‘t been reported). Not all flags are available on all platforms, but a flag value of zero will work on all platforms.

Calling this method raises a SystemError if there are no child processes. Not available on all platforms.

   include Process
   fork { exit 99 }                 #=> 27429
   wait                             #=> 27429
   $?.exitstatus                    #=> 99

   pid = fork { sleep 3 }           #=> 27440
   Time.now                         #=> Wed Apr 09 08:57:09 CDT 2003
   waitpid(pid, Process::WNOHANG)   #=> nil
   Time.now                         #=> Wed Apr 09 08:57:09 CDT 2003
   waitpid(pid, 0)                  #=> 27440
   Time.now                         #=> Wed Apr 09 08:57:12 CDT 2003

Waits for a child process to exit (see Process::waitpid for exact semantics) and returns an array containing the process id and the exit status (a Process::Status object) of that child. Raises a SystemError if there are no child processes.

   Process.fork { exit 99 }   #=> 27437
   pid, status = Process.wait2
   pid                        #=> 27437
   status.exitstatus          #=> 99