enum Signal

Overview

Safely handle inter-process signals on POSIX systems.

Signals are dispatched to the event loop and later processed in a dedicated fiber. Some received signals may never be processed when the program terminates.

puts "Ctrl+C still has the OS default action (stops the program)"
sleep 3

Signal::INT.trap do
  puts "Gotcha!"
end
puts "Ctrl+C will be caught from now on"
sleep 3

Signal::INT.reset
puts "Ctrl+C is back to the OS default action"
sleep 3

Note:

Defined in:

signal.cr

Enum Members

HUP = 1
INT = 2
QUIT = 3
ILL = 4
TRAP = 5
IOT = 6
ABRT = 6
FPE = 8
KILL = 9
BUS = 7
SEGV = 11
SYS = 31
PIPE = 13
ALRM = 14
TERM = 15
URG = 23
STOP = 19
TSTP = 20
CONT = 18
CHLD = 17
TTIN = 21
TTOU = 22
IO = 29
XCPU = 24
XFSZ = 25
VTALRM = 26
USR1 = 10
USR2 = 12
WINCH = 28
PWR = 30
STKFLT = 16
UNUSED = 31

Instance Method Summary

Instance methods inherited from struct Enum

&(other : self) &, +(other : Int) +, -(other : Int) -, <=>(other : self) <=>, ==(other : self) ==, ^(other : self) ^, clone clone, each(&) each, hash(hasher) hash, includes?(other : self) includes?, to_f32 : Float32 to_f32, to_f32! : Float32 to_f32!, to_f64 : Float64 to_f64, to_f64! : Float64 to_f64!, to_i : Int32 to_i, to_i16 : Int16 to_i16, to_i16! : Int16 to_i16!, to_i32 : Int32 to_i32, to_i32! : Int32 to_i32!, to_i64 : Int64 to_i64, to_i64! : Int64 to_i64!, to_i8 : Int8 to_i8, to_i8! : Int8 to_i8!, to_json(json : JSON::Builder) to_json, to_s(io : IO) : Nil
to_s : String
to_s
, to_u16 : UInt16 to_u16, to_u16! : UInt16 to_u16!, to_u32 : UInt32 to_u32, to_u32! : UInt32 to_u32!, to_u64 : UInt64 to_u64, to_u64! : UInt64 to_u64!, to_u8 : UInt8 to_u8, to_u8! : UInt8 to_u8!, to_yaml(yaml : YAML::Nodes::Builder) to_yaml, |(other : self) |, ~ ~

Constructor methods inherited from struct Enum

from_value(value : Int) : self from_value, from_value?(value : Int) : self? from_value?, new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)
new(pull : JSON::PullParser)
new
, parse(string : String) : self parse, parse?(string : String) : self? parse?

Class methods inherited from struct Enum

each(&) each, names : Array(String) names, valid?(value : self) : Bool valid?, values : Array(self) values

Instance methods inherited from module Comparable(Enum)

<(other : T) <, <=(other : T) <=, <=>(other : T) <=>, ==(other : T) ==, >(other : T) >, >=(other : T) >=, clamp(min, max)
clamp(range : Range)
clamp

Instance methods inherited from struct Value

==(other : JSON::Any)
==(other : YAML::Any)
==(other)
==
, dup dup

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
hash(hasher)
hash
, inspect(io : IO) : Nil
inspect : String
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(indent : String = " ")
to_pretty_json(io : IO, 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

Instance Method Detail

def abrt? #

[View source]
def alrm? #

[View source]
def bus? #

[View source]
def chld? #

[View source]
def cont? #

[View source]
def fpe? #

[View source]
def hup? #

[View source]
def ignore : Nil #

Clears the handler for this signal and prevents the OS default action.

Note that trying to ignore CHLD will actually set the default crystal handler that monitors and reaps child processes. This prevents zombie processes and is required by Process#wait for example.


[View source]
def ill? #

[View source]
def int? #

[View source]
def io? #

[View source]
def iot? #

[View source]
def kill? #

[View source]
def pipe? #

[View source]
def pwr? #

[View source]
def quit? #

[View source]
def reset : Nil #

Resets the handler for this signal to the OS default.

Note that trying to reset CHLD will actually set the default crystal handler that monitors and reaps child processes. This prevents zombie processes and is required by Process#wait for example.


[View source]
def segv? #

[View source]
def stkflt? #

[View source]
def stop? #

[View source]
def sys? #

[View source]
def term? #

[View source]
def trap(&handler : Signal -> ) : Nil #

Sets the handler for this signal to the passed function.

After executing this, whenever the current process receives the corresponding signal, the passed function will be called (instead of the OS default). The handler will run in a signal-safe fiber thought the event loop; there is no limit to what functions can be called, unlike raw signals that run on the sigaltstack.

Note that CHLD is always trapped and child processes will always be reaped before the custom handler is called, hence a custom CHLD handler must check child processes using Process.exists?. Trying to use waitpid with a zero or negative value won't work.


[View source]
def trap? #

[View source]
def tstp? #

[View source]
def ttin? #

[View source]
def ttou? #

[View source]
def unused? #

[View source]
def urg? #

[View source]
def usr1? #

[View source]
def usr2? #

[View source]
def vtalrm? #

[View source]
def winch? #

[View source]
def xcpu? #

[View source]
def xfsz? #

[View source]