class Process

Defined in:

kernel.cr
process.cr
process/executable_path.cr
process/executable_path.cr

Constant Summary

PATH_DELIMITER = {% if flag?(:windows) %} ';' {% else %} ':' {% end %}

Constructors

Class Method Summary

Instance Method Summary

Instance methods inherited from class Reference

==(other : self)
==(other)
==
, dup dup, hash hash, inspect(io : IO) : Nil inspect, object_id : UInt64 object_id, pretty_print(pp) : Nil pretty_print, same?(other : Reference)
same?(other : Nil)
same?
, to_s(io : IO) : Nil to_s

Constructor methods inherited from class Reference

new new

Instance methods inherited from class Object

!=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other)
===
, =~(other) =~, class class, dup dup, hash hash, inspect(io : IO)
inspect
inspect
, itself itself, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, tap(&block) tap, to_json(io : IO)
to_json
to_json
, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ")
to_pretty_json
, to_s
to_s(io : IO)
to_s
, to_yaml(io : IO)
to_yaml
to_yaml
, try(&block) try, unsafe_as(type : T.class) forall T unsafe_as

Constructor methods inherited from class Object

from_json(string_or_io, root : String) : self
from_json(string_or_io) : self
from_json
, from_yaml(string_or_io) : self from_yaml

Constructor Detail

def self.fork : self? #

Duplicates the current process. Returns a Process representing the new child process in the current process and nil inside the new child process.


View source
def self.new(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : Stdio = false, output : Stdio = false, error : Stdio = false, chdir : String? = nil) #

Creates a process, executes it, but doesn't wait for it to complete.

To wait for it to finish, invoke #wait.

By default the process is configured without input, output or error.


View source

Class Method Detail

def self.after_fork_child_callbacks #

Hooks are defined here due to load order problems.


View source
def self.exec(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : Bool | IO::FileDescriptor = true, output : Bool | IO::FileDescriptor = true, error : Bool | IO::FileDescriptor = true, chdir : String? = nil) #

Replaces the current process with a new one.

The possible values for input, output and error are:

  • false: no IO (/dev/null)
  • true: inherit from parent
  • IO: use the given IO

View source
def self.executable_path #

Returns an absolute path to the executable file of the currently running program. This is in opposition to PROGRAM_NAME which may be a relative or absolute path, just the executable file name or a symlink.

The executable path will be canonicalized (all symlinks and relative paths will be expanded).

Returns nil if the file can't be found.


View source
def self.exists?(pid : Int) #

Returns true if the process identified by pid is valid for a currently registered process, false otherwise. Note that this returns true for a process in the zombie or similar state.


View source
def self.exit(status = 0) #

Terminate the current process immediately. All open files, pipes and sockets are flushed and closed, all child processes are inherited by PID 1. This does not run any handlers registered with at_exit, use ::exit for that.

status is the exit status of the current process.


View source
def self.find_executable(name, path = ENV["PATH"]?, pwd = Dir.current) #

Searches an executable, checking for an absolute path, a path relative to pwd or absolute path, then eventually searching in directories declared in path.


View source
def self.fork(&block) #

Runs the given block inside a new process and returns a Process representing the new child process.


View source
def self.kill(signal : Signal, *pids : Int) #

Sends a signal to the processes identified by the given pids.


View source
def self.pgid : LibC::PidT #

Returns the process group identifier of the current process.


View source
def self.pgid(pid : Int32) : LibC::PidT #

Returns the process group identifier of the process identified by pid.


View source
def self.pid : LibC::PidT #

Returns the process identifier of the current process.


View source
def self.ppid : LibC::PidT #

Returns the process identifier of the parent process of the current process.


View source
def self.run(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : Stdio = false, output : Stdio = false, error : Stdio = false, chdir : String? = nil) : Process::Status #

Executes a process and waits for it to complete.

By default the process is configured without input, output or error.


View source
def self.run(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : Stdio = nil, output : Stdio = nil, error : Stdio = nil, chdir : String? = nil, &block) #

Executes a process, yields the block, and then waits for it to finish.

By default the process is configured to use pipes for input, output and error. These will be closed automatically at the end of the block.

Returns the block's value.


View source
def self.times : Tms #

Returns a Tms for the current process. For the children times, only those of terminated children are returned.


View source

Instance Method Detail

def close #

Closes any pipes to the child process.


View source
def error #

A pipe to this process's error. Raises if a pipe wasn't asked when creating the process.


View source
def error? : IO::FileDescriptor? #

A pipe to this process's error. Raises if a pipe wasn't asked when creating the process.


View source
def exists? #

Whether the process is still registered in the system. Note that this returns true for processes in the zombie or similar state.


View source
def input #

A pipe to this process's input. Raises if a pipe wasn't asked when creating the process.


View source
def input? : IO::FileDescriptor? #

A pipe to this process's input. Raises if a pipe wasn't asked when creating the process.


View source
def kill(sig = Signal::TERM) #

See also: Process.kill


View source
def output #

A pipe to this process's output. Raises if a pipe wasn't asked when creating the process.


View source
def output? : IO::FileDescriptor? #

A pipe to this process's output. Raises if a pipe wasn't asked when creating the process.


View source
def pid : Int32 #

View source
def terminated? #

Whether this process is already terminated.


View source
def wait : Process::Status #

Waits for this process to complete and closes any pipes.


View source