class Process

Defined in:

kernel.cr
process.cr:1
process.cr:14
process/executable_path.cr:5
process/executable_path.cr:62
process/shell.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 : JSON::Any)
==(other : YAML::Any)
==(other)
==
, dup dup, hash(hasher) 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

! : Bool !, !=(other) !=, !~(other) !~, ==(other) ==, ===(other : JSON::Any)
===(other : YAML::Any)
===(other)
===
, =~(other) =~, as(type : Class) as, as?(type : Class) as?, class class, dup dup, hash(hasher)
hash
hash
, in?(*values : Object) : Bool
in?(collection) : Bool
in?
, inspect : String
inspect(io : IO) : Nil
inspect
, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil! not_nil!, pretty_inspect(width = 79, newline = "\n", indent = 0) : String pretty_inspect, pretty_print(pp : PrettyPrint) : Nil pretty_print, responds_to?(name : Symbol) : Bool responds_to?, tap(&) tap, to_json(io : IO)
to_json
to_json
, to_pretty_json(io : IO, indent : String = " ")
to_pretty_json(indent : String = " ")
to_pretty_json
, to_s : String
to_s(io : IO) : Nil
to_s
, to_yaml(io : IO)
to_yaml
to_yaml
, try(&) try, unsafe_as(type : T.class) forall T unsafe_as

Class methods inherited from class Object

from_json(string_or_io, root : String)
from_json(string_or_io)
from_json
, from_yaml(string_or_io : String | IO) from_yaml

Constructor Detail

def self.new(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : Stdio = Redirect::Close, output : Stdio = Redirect::Close, error : Stdio = Redirect::Close, 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.

If shell is false, the command is the path to the executable to run, along with a list of args.

If shell is true, the command should be the full command line including space-separated args.

  • On POSIX this uses /bin/sh to process the command string. args are also passed to the shell, and you need to include the string "${@}" in the command to safely insert them there.
  • On Windows this is implemented by passing the string as-is to the process, and passing args is not supported.

[View source]

Class Method Detail

def self.chroot(path : String) : Nil #

Changes the root directory and the current working directory for the current process.

Available only on Unix-like operating systems.

Security: .chroot on its own is not an effective means of mitigation. At minimum the process needs to also drop privileges as soon as feasible after the .chroot. Changes to the directory hierarchy or file descriptors passed via recvmsg(2) from outside the .chroot jail may allow a restricted process to escape, even if it is unprivileged.

Process.chroot("/var/empty")

[View source]
def self.exec(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : ExecStdio = Redirect::Inherit, output : ExecStdio = Redirect::Inherit, error : ExecStdio = Redirect::Inherit, chdir : String? = nil) : NoReturn #

Replaces the current process with a new one. This function never returns.

Available only on Unix-like operating systems.


[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) : Bool #

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) : NoReturn #

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 | String, path : String? = ENV["PATH"]?, pwd : Path | String = Dir.current) : String? #

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.kill(signal : Signal, *pids : Int) #

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

DEPRECATED Use #signal instead


[View source]
def self.parse_arguments(line : String) : Array(String) #

Split a line string into the array of tokens in the same way the POSIX shell.

Process.parse_arguments(%q["foo bar" '\hello/' Fizz\ Buzz]) # => ["foo bar", "\\hello/", "Fizz Buzz"]

See https://pubs.opengroup.org/onlinepubs/009695399/utilities/xcu_chap02.html#tag_02_03


[View source]
def self.pgid : Int64 #

Returns the process group identifier of the current process.


[View source]
def self.pgid(pid : Int) : Int64 #

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


[View source]
def self.pid : Int64 #

Returns the process identifier of the current process.


[View source]
def self.ppid : Int64 #

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


[View source]
def self.quote(args : Enumerable(String)) : String #

Converts a sequence of strings to one joined string with each argument shell-quoted.

This is then safe to pass as part of the command when using shell: true or system().

NOTE The actual return value is system-dependent, so it mustn't be relied on in other contexts. See also: .quote_posix.

files = ["my file.txt", "another.txt"]
`grep -E 'fo+' -- #{Process.quote(files)}`

[View source]
def self.quote(arg : String) : String #

Shell-quotes one item, same as .quote({arg}).


[View source]
def self.quote_posix(args : Enumerable(String)) : String #

Converts a sequence of strings to one joined string with each argument shell-quoted.

This is then safe to pass to a POSIX shell.

files = ["my file.txt", "another.txt"]
Process.quote_posix(files) # => "'my file.txt' another.txt"

[View source]
def self.quote_posix(arg : String) : String #

Shell-quotes one item, same as .quote_posix({arg}).


[View source]
def self.run(command : String, args = nil, env : Env = nil, clear_env : Bool = false, shell : Bool = false, input : Stdio = Redirect::Close, output : Stdio = Redirect::Close, error : Stdio = Redirect::Close, 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 = Redirect::Pipe, output : Stdio = Redirect::Pipe, error : Stdio = Redirect::Pipe, chdir : String? = nil, &) #

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.signal(signal : Signal, pid : Int) : Nil #

Sends signal to the process identified by pid.


[View source]
def self.times : Tms #

Returns a Tms for the current process. For the children times, only those of terminated children are returned on Unix; they are zero on Windows.


[View source]

Instance Method Detail

def close #

Closes any system resources (e.g. pipes) held for the child 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 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 finalize #

[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 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

DEPRECATED Use #signal instead


[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 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 : Int64 #

Returns the process identifier of this process.


[View source]
def signal(signal : Signal) #

Sends signal to this process.


[View source]
def terminate #

Asks this process to terminate gracefully


[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]