Fixes issue #482: Work with < Rubies 3.2

The current Thread::Queue based Interruptible can not work with
Ruby version earlier than 3.2.  Given that SQ sets it's minimum
supported version of Ruby is derived from "full support of Rails 7.1",
this in theory mandates support for Ruby 2.7.8.  However, other
dependencies force the minimum version of Ruby to: 3.1.6

This commit adds a boot time check of the Ruby version and selects
either the current or original implementation of Interruptible.

Author: hms

Diff for: lib/solid_queue/dispatcher.rb

@@ -25,7 +25,7 @@ def metadata
       def poll
         batch = dispatch_next_batch
 
-        batch.size.zero? ? polling_interval : 0.seconds
+        batch.zero? ? polling_interval : 0.seconds
       end
 
       def dispatch_next_batch

Diff for: lib/solid_queue/engine.rb

@@ -37,5 +37,13 @@ class Engine < ::Rails::Engine
         include ActiveJob::ConcurrencyControls
       end
     end
+
+    initializer "solid_queue.include_interruptible_concern" do
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.2")
+        SolidQueue::Processes::Base.include SolidQueue::Processes::Interruptible
+      else
+        SolidQueue::Processes::Base.include SolidQueue::Processes::OgInterruptible
+      end
+    end
   end
 end

Diff for: lib/solid_queue/processes/base.rb

@@ -4,7 +4,7 @@ module SolidQueue
   module Processes
     class Base
       include Callbacks # Defines callbacks needed by other concerns
-      include AppExecutor, Registrable, Interruptible, Procline
+      include AppExecutor, Registrable, Procline
 
       attr_reader :name
 

Diff for: lib/solid_queue/processes/interruptible.rb

@@ -2,6 +2,8 @@
 
 module SolidQueue::Processes
   module Interruptible
+    include SolidQueue::AppExecutor
+
     def wake_up
       interrupt
     end
@@ -13,17 +15,19 @@ def interrupt
       end
 
       # Sleeps for 'time'.  Can be interrupted asynchronously and return early via wake_up.
-      # @param time [Numeric] the time to sleep. 0 returns immediately.
-      # @return [true, nil]
-      # * returns `true` if an interrupt was requested via #wake_up between the
-      #   last call to `interruptible_sleep` and now, resulting in an early return.
-      # * returns `nil` if it slept the full `time` and was not interrupted.
+      # @param time [Numeric, Duration] the time to sleep. 0 returns immediately.
       def interruptible_sleep(time)
         # Invoking this from the main thread may result in significant slowdown.
         # Utilizing asynchronous execution (Futures) addresses this performance issue.
         Concurrent::Promises.future(time) do |timeout|
-          queue.pop(timeout:).tap { queue.clear }
+          queue.clear unless queue.pop(timeout:).nil?
+        end.on_rejection! do |e|
+          wrapped_exception = RuntimeError.new("Interruptible#interruptible_sleep - #{e.class}: #{e.message}")
+          wrapped_exception.set_backtrace(e.backtrace)
+          handle_thread_error(wrapped_exception)
         end.value
+
+        nil
       end
 
       def queue

Diff for: lib/solid_queue/processes/og_interruptible.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# frozen_string_literal: true
+
+module SolidQueue::Processes
+  # The original implementation of Interruptible that works
+  # with Ruby 3.1 and earlier
+  module OgInterruptible
+    def wake_up
+      interrupt
+    end
+
+    private
+      SELF_PIPE_BLOCK_SIZE = 11
+
+      def interrupt
+        self_pipe[:writer].write_nonblock(".")
+      rescue Errno::EAGAIN, Errno::EINTR
+        # Ignore writes that would block and retry
+        # if another signal arrived while writing
+        retry
+      end
+
+      def interruptible_sleep(time)
+        if time > 0 && self_pipe[:reader].wait_readable(time)
+          loop { self_pipe[:reader].read_nonblock(SELF_PIPE_BLOCK_SIZE) }
+        end
+      rescue Errno::EAGAIN, Errno::EINTR
+      end
+
+      # Self-pipe for signal-handling (http://cr.yp.to/docs/selfpipe.html)
+      def self_pipe
+        @self_pipe ||= create_self_pipe
+      end
+
+      def create_self_pipe
+        reader, writer = IO.pipe
+        { reader: reader, writer: writer }
+      end
+  end
+end