quicsilver 0.4.0 → 0.5.0

data/lib/quicsilver/server/schedulers/fiber_scheduler.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative "../scheduler"
+
+module Quicsilver
+  class Server
+    module Schedulers
+      # Fiber-based scheduler — uses Async::Queue for cooperative scheduling.
+      # Expects to be running inside an Async reactor (e.g. Falcon provides one).
+      # Requires the async gem.
+      class FiberScheduler < Scheduler
+        def initialize(concurrency:, max_queue_size:, &handler)
+          require "async"
+          require "async/queue"
+          require "async/barrier"
+
+          @concurrency = concurrency
+          @max_queue_size = max_queue_size
+          @handler = handler
+          @queue = Async::Queue.new
+          @running = false
+          @barrier = nil
+        end
+
+        def enqueue(work)
+          @queue.enqueue(work)
+        end
+
+        def full?
+          @queue.size >= @max_queue_size
+        end
+
+        def pending
+          @queue.size
+        end
+
+        # Spawn fiber workers inside the current Async reactor.
+        # Caller must already be inside Async do (e.g. Falcon).
+        def start
+          @running = true
+          @barrier = Async::Barrier.new
+
+          @concurrency.times do
+            @barrier.async do
+              while @running
+                work = @queue.dequeue
+                break if work == :shutdown
+
+                run(work)
+              end
+            end
+          end
+        end
+
+        # One unit of work must not take the worker fiber down with it; see
+        # the thread scheduler for the same reasoning.
+        private def run(work)
+          @handler.call(work)
+        rescue => e
+          Quicsilver.logger.error("Unhandled error in worker: #{e.class} - #{e.message}")
+          Quicsilver.logger.debug(e.backtrace&.first(5)&.join("\n").to_s)
+        end
+
+        def drain(timeout: 5)
+          deadline = Time.now + timeout
+          while @queue.size > 0 && Time.now < deadline
+            sleep 0.05
+          end
+        end
+
+        def stop
+          @running = false
+          @concurrency.times { @queue.enqueue(:shutdown) }
+          @barrier&.wait
+        end
+      end
+    end
+  end
+end

data/lib/quicsilver/server/schedulers/thread_scheduler.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../scheduler"
+
+module Quicsilver
+  class Server
+    module Schedulers
+      # Thread-based scheduler — uses a thread pool with Thread::Queue.
+      class ThreadScheduler < Scheduler
+        def initialize(concurrency:, max_queue_size:, &handler)
+          @size = concurrency
+          @max_queue_size = max_queue_size
+          @handler = handler
+          @queue = Queue.new
+          @threads = []
+          @mutex = Mutex.new
+        end
+
+        def enqueue(work)
+          @queue.push(work)
+        end
+
+        def full?
+          @queue.size >= @max_queue_size
+        end
+
+        def pending
+          @queue.size
+        end
+
+        def start
+          @size.times do
+            thread = Thread.new do
+              while (work = @queue.pop)
+                break if work == :shutdown
+
+                run(work)
+              end
+            end
+            @mutex.synchronize { @threads << thread }
+          end
+        end
+
+        def drain(timeout: 5)
+          deadline = Time.now + timeout
+          while @queue.size > 0 && Time.now < deadline
+            sleep 0.05
+          end
+        end
+
+        # One unit of work must not take the worker down with it. An escaping
+        # error would end the thread, shrinking the pool for the rest of the
+        # process, and Thread#join would re-raise it in whoever stops the
+        # server. DrainTimeoutError is our own interruption, so it ends the
+        # worker as intended.
+        private def run(work)
+          @handler.call(work)
+        rescue DrainTimeoutError
+          raise
+        rescue => e
+          Quicsilver.logger.error("Unhandled error in worker: #{e.class} - #{e.message}")
+          Quicsilver.logger.debug(e.backtrace&.first(5)&.join("\n").to_s)
+        end
+
+        def stop
+          @size.times { @queue.push(:shutdown) }
+          @mutex.synchronize do
+            @threads.each { |t| t.join(2) }
+            @threads.each { |t| t.raise(DrainTimeoutError, "drain timeout") if t.alive? }
+            @threads.clear
+          end
+        end
+      end
+    end
+  end
+end