quicsilver 0.5.0-x86_64-linux

data/lib/quicsilver/server/request_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    class RequestRegistry
+      def initialize
+        @requests = {}
+        @mutex = Mutex.new
+      end
+
+      def track(stream_id, connection_handle, path:, method:, started_at: Time.now)
+        @mutex.synchronize do
+          @requests[key_for(stream_id, connection_handle)] = {
+            connection_handle: connection_handle,
+            stream_id: stream_id,
+            path: path,
+            method: method,
+            started_at: started_at
+          }
+        end
+      end
+
+      def complete(stream_id, connection_handle)
+        @mutex.synchronize do
+          @requests.delete(key_for(stream_id, connection_handle))
+        end
+      end
+
+      def active_count
+        @mutex.synchronize { @requests.size }
+      end
+
+      def active_requests
+        @mutex.synchronize { @requests.dup }
+      end
+
+      def requests_older_than(seconds)
+        cutoff = Time.now - seconds
+        @mutex.synchronize do
+          @requests.select { |_, r| r[:started_at] < cutoff }
+        end
+      end
+
+      def empty?
+        @mutex.synchronize { @requests.empty? }
+      end
+
+      def include?(stream_id, connection_handle)
+        @mutex.synchronize do
+          @requests.key?(key_for(stream_id, connection_handle))
+        end
+      end
+
+      private
+
+      def key_for(stream_id, connection_handle)
+        raise ArgumentError, "Connection handle is required" if connection_handle.nil?
+
+        [connection_handle, stream_id]
+      end
+    end
+  end
+end

data/lib/quicsilver/server/scheduler.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Quicsilver
+  class Server
+    # Base class for work schedulers.
+    #
+    # A scheduler controls how incoming request work units are executed —
+    # via threads, fibers, or any other concurrency model. Subclasses
+    # implement the delivery mechanism.
+    #
+    # Usage:
+    #   scheduler = ThreadScheduler.new(size: 10, max_queue_size: 100, &handler)
+    #   scheduler.start               # start workers
+    #   scheduler.enqueue(work)        # schedule a work unit
+    #   scheduler.drain(timeout: 5)    # wait for queue to empty
+    #   scheduler.stop                 # shut down workers
+    #
+    class Scheduler
+      # Schedule a work unit for execution.
+      def enqueue(work)
+        raise NotImplementedError
+      end
+
+      # Is the work queue at capacity?
+      def full?
+        raise NotImplementedError
+      end
+
+      # Number of pending work units.
+      def pending
+        raise NotImplementedError
+      end
+
+      # Wait for the queue to empty.
+      def drain(timeout: 5)
+        raise NotImplementedError
+      end
+
+      # Start processing work units.
+      def start
+        raise NotImplementedError
+      end
+
+      # Shut down workers.
+      def stop
+        raise NotImplementedError
+      end
+    end
+  end
+end

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