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.seconds
Signal::INT.trap do
  puts "Gotcha!"
end
puts "Ctrl+C will be caught from now on"
sleep 3.seconds
Signal::INT.reset
puts "Ctrl+C is back to the OS default action"
sleep 3.secondsWARNING An uncaught exception in a signal handler is a fatal error.
Portability
The set of available signals is platform-dependent. Only signals that exist on the target platform are available as members of this enum.
- ABRT,- FPE,- ILL,- INT,- SEGV, and- TERMare guaranteed to exist on all platforms.
- PWR,- STKFLT, and- UNUSEDonly exist on Linux.
- BREAKonly exists on Windows.
- All other signals exist on all POSIX platforms.
The methods #trap, #reset, and #ignore may not be implemented at all on
non-POSIX systems.
The standard library provides several platform-agnostic APIs to achieve tasks that are typically solved with signals on POSIX systems:
- The portable API for responding to a termination request is
Process.on_terminate.
- The portable API for sending a TERMorKILLsignal to a process isProcess#terminate.
- The portable API for retrieving the exit signal of a process
(Process::Status#exit_signal) isProcess::Status#exit_reason.
Defined in:
signal.crEnum Members
- 
        INT = 2
- 
        ILL = 4
- 
        FPE = 8
- 
        SEGV = 11
- 
        TERM = 15
- 
        ABRT = 6
- 
        HUP = 1
- 
        QUIT = 3
- 
        TRAP = 5
- 
        IOT = 6
- 
        KILL = 9
- 
        BUS = 7
- 
        SYS = 31
- 
        PIPE = 13
- 
        ALRM = 14
- 
        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
- 
        #abrt?
        
          Returns trueif this enum value equalsABRT
- 
        #alrm?
        
          Returns trueif this enum value equalsALRM
- 
        #bus?
        
          Returns trueif this enum value equalsBUS
- 
        #chld?
        
          Returns trueif this enum value equalsCHLD
- 
        #cont?
        
          Returns trueif this enum value equalsCONT
- 
        #fpe?
        
          Returns trueif this enum value equalsFPE
- 
        #hup?
        
          Returns trueif this enum value equalsHUP
- 
        #ignore : Nil
        
          Clears the handler for this signal and prevents the OS default action. 
- 
        #ill?
        
          Returns trueif this enum value equalsILL
- 
        #int?
        
          Returns trueif this enum value equalsINT
- 
        #io?
        
          Returns trueif this enum value equalsIO
- 
        #iot?
        
          Returns trueif this enum value equalsIOT
- 
        #kill?
        
          Returns trueif this enum value equalsKILL
- 
        #pipe?
        
          Returns trueif this enum value equalsPIPE
- 
        #pwr?
        
          Returns trueif this enum value equalsPWR
- 
        #quit?
        
          Returns trueif this enum value equalsQUIT
- 
        #reset : Nil
        
          Resets the handler for this signal to the OS default. 
- 
        #segv?
        
          Returns trueif this enum value equalsSEGV
- 
        #stkflt?
        
          Returns trueif this enum value equalsSTKFLT
- 
        #stop?
        
          Returns trueif this enum value equalsSTOP
- 
        #sys?
        
          Returns trueif this enum value equalsSYS
- 
        #term?
        
          Returns trueif this enum value equalsTERM
- 
        #trap(&handler : Signal -> ) : Nil
        
          Sets the handler for this signal to the passed function. 
- 
        #trap?
        
          Returns trueif this enum value equalsTRAP
- 
        #trap_handler?
        
          Returns any existing handler for this signal 
- 
        #tstp?
        
          Returns trueif this enum value equalsTSTP
- 
        #ttin?
        
          Returns trueif this enum value equalsTTIN
- 
        #ttou?
        
          Returns trueif this enum value equalsTTOU
- 
        #unused?
        
          Returns trueif this enum value equalsUNUSED
- 
        #urg?
        
          Returns trueif this enum value equalsURG
- 
        #usr1?
        
          Returns trueif this enum value equalsUSR1
- 
        #usr2?
        
          Returns trueif this enum value equalsUSR2
- 
        #vtalrm?
        
          Returns trueif this enum value equalsVTALRM
- 
        #winch?
        
          Returns trueif this enum value equalsWINCH
- 
        #xcpu?
        
          Returns trueif this enum value equalsXCPU
- 
        #xfsz?
        
          Returns trueif this enum value equalsXFSZ
Instance methods inherited from struct Enum
  
  
    
      &(other : self) : self
    &, 
    
  
    
      +(other : Int) : self
    +, 
    
  
    
      -(other : Int) : self
    -, 
    
  
    
      <=>(other : self)
    <=>, 
    
  
    
      ==(other : self)==(other) ==, ^(other : self) : self ^, |(other : self) : self |, ~ : self ~, clone clone, each(& : self -> ) each, hash(hasher) hash, includes?(other : self) : Bool includes?, inspect(io : IO) : Nil inspect, 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_i128 : Int128 to_i128, to_i128! : Int128 to_i128!, 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_u128 : UInt128 to_u128, to_u128! : UInt128 to_u128!, 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, value : Int value
Constructor methods inherited from struct Enum
  
  
    
      from_value(value : Int) : self
    from_value, 
    
  
    
      new(ctx : YAML::ParseContext, node : YAML::Nodes::Node)new(value : self)
new(pull : JSON::PullParser) new, parse(string : String) : self parse
Class methods inherited from struct Enum
  
  
    
      each(& : self -> )
    each, 
    
  
    
      from_value?(value : Int) : self | Nil
    from_value?, 
    
  
    
      names : Array(String)
    names, 
    
  
    
      parse?(string : String) : self | Nil
    parse?, 
    
  
    
      valid?(value : self) : Bool
    valid?, 
    
  
    
      values : Array(self)
    values
    
  
      
  Macros inherited from struct Enum
  
  
    
      [](*values)
    [], 
    
  
    
      flags(*values)
    flags
    
  
    
      
  Instance methods inherited from module Comparable(Enum)
  
  
    
      <(other : T) : Bool
    <, 
    
  
    
      <=(other : T)
    <=, 
    
  
    
      <=>(other : T)
    <=>, 
    
  
    
      ==(other : T)
    ==, 
    
  
    
      >(other : T) : Bool
    >, 
    
  
    
      >=(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(hasher)
hash hash, in?(collection : Object) : Bool
in?(*values : Object) : Bool in?, inspect(io : IO) : Nil
inspect : String inspect, is_a?(type : Class) : Bool is_a?, itself itself, nil? : Bool nil?, not_nil!(message)
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) : Nil
to_json : String to_json, to_pretty_json(indent : String = " ") : String
to_pretty_json(io : IO, indent : String = " ") : Nil to_pretty_json, to_s(io : IO) : Nil
to_s : String to_s, to_yaml(io : IO) : Nil
to_yaml : String 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
Macros inherited from class Object
  
  
    
      class_getter(*names, &block)
    class_getter, 
    
  
    
      class_getter!(*names)
    class_getter!, 
    
  
    
      class_getter?(*names, &block)
    class_getter?, 
    
  
    
      class_property(*names, &block)
    class_property, 
    
  
    
      class_property!(*names)
    class_property!, 
    
  
    
      class_property?(*names, &block)
    class_property?, 
    
  
    
      class_setter(*names)
    class_setter, 
    
  
    
      def_clone
    def_clone, 
    
  
    
      def_equals(*fields)
    def_equals, 
    
  
    
      def_equals_and_hash(*fields)
    def_equals_and_hash, 
    
  
    
      def_hash(*fields)
    def_hash, 
    
  
    
      delegate(*methods, to object)
    delegate, 
    
  
    
      forward_missing_to(delegate)
    forward_missing_to, 
    
  
    
      getter(*names, &block)
    getter, 
    
  
    
      getter!(*names)
    getter!, 
    
  
    
      getter?(*names, &block)
    getter?, 
    
  
    
      property(*names, &block)
    property, 
    
  
    
      property!(*names)
    property!, 
    
  
    
      property?(*names, &block)
    property?, 
    
  
    
      setter(*names)
    setter
    
  
    
  Instance Method Detail
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.
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.
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 throughout 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.
NOTE  Process.on_terminate is preferred over Signal::INT.trap as a
portable alternative which also works on Windows.
Returns any existing handler for this signal
Signal::USR1.trap { }
prev_handler = Signal::USR1.trap_handler?
Signal::USR1.trap do |signal|
  prev_handler.try &.call(signal)
  # ...
end