Add Process.on_terminate

src/crystal/system/process.cr

@@ -77,6 +77,15 @@ struct Crystal::System::Process
 
   # Changes the root directory for the current process.
   # def self.chroot(path : String)
+
+  enum Interrupt
+    # sigint, ctrl-c or ctrl-break events
+    USER_SIGNALLED
+    # sighup or closed event
+    TERMINAL_DISCONNECTED
+    # sigterm, logoff or shutdown events
+    SESSION_ENDED
+  end
 end
 
 module Crystal::System

src/crystal/system/unix/process.cr

@@ -58,8 +58,28 @@ struct Crystal::System::Process
     raise RuntimeError.from_errno("kill") if ret < 0
   end
 
-  def self.on_interrupt(&handler : ->) : Nil
-    ::Signal::INT.trap { |_signal| handler.call }
+  def self.on_interrupt(&handler : Interrupt ->) : Nil
+    sig_handler = Proc(::Signal, Nil).new do |signal|
+      int_type = case signal
+                 when .int?
+                   Interrupt::USER_SIGNALLED
+                 when .hup?
+                   Interrupt::TERMINAL_DISCONNECTED
+                 when .term?
+                   Interrupt::SESSION_ENDED
+                 else
+                   Interrupt::USER_SIGNALLED
+                 end
+      handler.call int_type
+
+      # ignore prevents system defaults and clears registered interrupts
+      # hence we need to re-register
+      signal.ignore
+      Process.on_interrupt &handler
+    end
+    ::Signal::INT.trap &sig_handler
+    ::Signal::HUP.trap &sig_handler
+    ::Signal::TERM.trap &sig_handler
   end
 
   def self.ignore_interrupts! : Nil

src/crystal/system/win32/process.cr

@@ -10,10 +10,11 @@ struct Crystal::System::Process
   @thread_id : LibC::DWORD
   @process_handle : LibC::HANDLE
 
-  @@interrupt_handler : Proc(Nil)?
+  @@interrupt_handler : Proc(Interrupt, Nil)?
   @@interrupt_count = Crystal::AtomicSemaphore.new
   @@win32_interrupt_handler : LibC::PHANDLER_ROUTINE?
   @@setup_interrupt_handler = Atomic::Flag.new
+  @@last_interrupt = Interrupt::USER_SIGNALLED
 
   def initialize(process_info)
     @pid = process_info.dwProcessId
@@ -100,10 +101,19 @@ struct Crystal::System::Process
     raise NotImplementedError.new("Process.signal")
   end
 
-  def self.on_interrupt(&@@interrupt_handler : ->) : Nil
+  def self.on_interrupt(&@@interrupt_handler : Interrupt ->) : Nil
     restore_interrupts!
     @@win32_interrupt_handler = handler = LibC::PHANDLER_ROUTINE.new do |event_type|
-      next 0 unless event_type.in?(LibC::CTRL_C_EVENT, LibC::CTRL_BREAK_EVENT)
+      @@last_interrupt = case event_type
+                         when LibC::CTRL_C_EVENT, LibC::CTRL_BREAK_EVENT
+                           Interrupt::USER_SIGNALLED
+                         when LibC::CTRL_CLOSE_EVENT
+                           Interrupt::TERMINAL_DISCONNECTED
+                         when LibC::CTRL_LOGOFF_EVENT, LibC::CTRL_SHUTDOWN_EVENT
+                           Interrupt::SESSION_ENDED
+                         else
+                           next 0
+                         end
       @@interrupt_count.signal
       1
     end
@@ -136,8 +146,9 @@ struct Crystal::System::Process
 
         if handler = @@interrupt_handler
           non_nil_handler = handler # if handler is closured it will also have the Nil type
+          int_type = @@last_interrupt
           spawn do
-            non_nil_handler.call
+            non_nil_handler.call int_type
           rescue ex
             ex.inspect_with_backtrace(STDERR)
             STDERR.puts("FATAL: uncaught exception while processing interrupt handler, exiting")

src/lib_c/x86_64-windows-msvc/c/consoleapi.cr

@@ -14,8 +14,11 @@ lib LibC
   fun GetConsoleCP : DWORD
   fun GetConsoleOutputCP : DWORD
 
-  CTRL_C_EVENT     = 0
-  CTRL_BREAK_EVENT = 1
+  CTRL_C_EVENT        = 0
+  CTRL_BREAK_EVENT    = 1
+  CTRL_CLOSE_EVENT    = 2
+  CTRL_LOGOFF_EVENT   = 5
+  CTRL_SHUTDOWN_EVENT = 6
 
   alias PHANDLER_ROUTINE = DWORD -> BOOL
 

src/process.cr

@@ -50,15 +50,18 @@ class Process
     Crystal::System::Process.signal(pid, signal.value)
   end
 
+  alias Interrupt = Crystal::System::Process::Interrupt
+
   # Installs *handler* as the new handler for interrupt requests. Removes any
   # previously set interrupt handler.
   #
   # The handler is executed on a fresh fiber every time an interrupt occurs.
   #
-  # * On Unix-like systems, this traps `SIGINT`.
-  # * On Windows, this captures <kbd>Ctrl</kbd> + <kbd>C</kbd> and
-  #   <kbd>Ctrl</kbd> + <kbd>Break</kbd> signals sent to a console application.
-  def self.on_interrupt(&handler : ->) : Nil
+  # * On Unix-like systems, this traps `SIGINT`, `SIGHUP`, `SIGTERM`.
+  # * On Windows, this captures <kbd>Ctrl</kbd> + <kbd>C</kbd>,
+  #   <kbd>Ctrl</kbd> + <kbd>Break</kbd>, terminal close, windows logoff
+  #   and shutdown signals sent to a console application.
+  def self.on_interrupt(&handler : Interrupt ->) : Nil
     Crystal::System::Process.on_interrupt(&handler)
   end