Add Process.on_terminate

src/crystal/system/process.cr

@@ -44,7 +44,7 @@ struct Crystal::System::Process
 
   # Installs *handler* as the new handler for interrupt requests. Removes any
   # previously set interrupt handler.
-  # def self.on_interrupt(&handler : ->)
+  # def self.on_interrupt(&handler : ::Process::ExitReason ->)
 
   # Ignores all interrupt requests. Removes any custom interrupt handler set
   # def self.ignore_interrupts!

src/crystal/system/unix/process.cr

@@ -58,8 +58,34 @@ 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) : Nil
+    sig_handler = Proc(::Signal, Nil).new do |signal|
+      int_type = case signal
+                 when .int?
+                   ::Process::ExitReason::Interrupted
+                 when .hup?
+                   ::Process::ExitReason::TerminalDisconnected
+                 when .term?
+                   ::Process::ExitReason::SessionEnded
+                 else
+                   ::Process::ExitReason::Interrupted
+                 end
+
+      # maintain backwards compatibility
+      if handler.is_a? Proc(Nil)
+        handler.call
+      else
+        handler.call int_type
+      end
+
+      # 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/wasi/process.cr

@@ -48,7 +48,7 @@ struct Crystal::System::Process
     raise NotImplementedError.new("Process.signal")
   end
 
-  def self.on_interrupt(&handler : ->) : Nil
+  def self.on_interrupt(&handler) : Nil
     raise NotImplementedError.new("Process.on_interrupt")
   end
 

src/crystal/system/win32/process.cr

@@ -13,10 +13,11 @@
   @job_object : LibC::HANDLE
   @completion_key = IO::Overlapped::CompletionKey.new
 
-  @@interrupt_handler : Proc(Nil)?
+  @@interrupt_handler : Proc(::Process::ExitReason, Nil) | Proc(Nil)?
   @@interrupt_count = Crystal::AtomicSemaphore.new
   @@win32_interrupt_handler : LibC::PHANDLER_ROUTINE?
   @@setup_interrupt_handler = Atomic::Flag.new
+  @@last_interrupt = ::Process::ExitReason::Interrupted
 
   def initialize(process_info)
     @pid = process_info.dwProcessId
@@ -150,10 +151,19 @@
     raise NotImplementedError.new("Process.signal")
   end
 
-  def self.on_interrupt(&@@interrupt_handler : ->) : Nil
+  def self.on_interrupt(&@@interrupt_handler) : 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
+                           ::Process::ExitReason::Interrupted
+                         when LibC::CTRL_CLOSE_EVENT
+                           ::Process::ExitReason::TerminalDisconnected
+                         when LibC::CTRL_LOGOFF_EVENT, LibC::CTRL_SHUTDOWN_EVENT
+                           ::Process::ExitReason::SessionEnded
+                         else
+                           next 0
+                         end
       @@interrupt_count.signal
       1
     end
@@ -186,8 +196,14 @@
 
         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
+            case non_nil_handler
+            in Proc(Nil)
+              non_nil_handler.call
+            in Proc(::Process::ExitReason, Nil)
+              non_nil_handler.call int_type
+            end
           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

@@ -55,10 +55,11 @@ class Process
   #
   # 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) : Nil
     Crystal::System::Process.on_interrupt(&handler)
   end
 

src/process/status.cr

@@ -79,6 +79,18 @@ enum Process::ExitReason
   # A `Process::Status` that maps to `Unknown` may map to a different value if
   # new enum members are added to `ExitReason`.
   Unknown
+
+  # The process exited due to the user closing the terminal window or ending an ssh session.
+  #
+  # * On Unix-like systems, this corresponds to `Signal::HUP`
+  # * On Windows, this corresponds to the `CTRL_CLOSE_EVENT` message
+  TerminalDisconnected
+
+  # The process exited due to the user logging off or shutting down the OS.
+  #
+  # * On Unix-like systems, this corresponds to `Signal::TERM`
+  # * On Windows, this corresponds to the `CTRL_LOGOFF_EVENT`, `CTRL_SHUTDOWN_EVENT` messages
+  SessionEnded
 end
 
 # The status of a terminated process. Returned by `Process#wait`.