kino 0.5.0-aarch64-linux → 0.7.0-aarch64-linux

data/lib/kino/threaded_pool.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+module Kino
+  # @private
+  # The :threaded-mode worker pool: `workers` groups of `threads` plain
+  # Threads, each thread on its own dispatch slot. A group is one ractor's
+  # worth of capacity, so `workers` and `max_workers` mean the same thing
+  # in both modes. Behind PoolScaler here (`grow`, `retire`, `groups`,
+  # `active_count`), the quarantine monitor's replacer (`replace`), and
+  # the join/kill sweeps Server#shutdown runs.
+  class ThreadedPool
+    def initialize(server_id, app, threads:, batch: 1, hooks: nil, on_worker_exit: nil)
+      @server_id = server_id
+      @app = app
+      @threads = threads
+      @batch = batch
+      @hooks = hooks
+      @on_worker_exit = on_worker_exit
+      @lock = Mutex.new
+      # index => {slots:, threads:}; the groups asked to leave; quarantine
+      # replacements (one thread each, standing in for a wedged slot:
+      # neither counted nor retired, so the wedged group keeps counting as
+      # the capacity it still is). Retired groups hand their slots back to
+      # the bank.
+      @groups = {}
+      @slot_to_group = {}
+      @retiring = {}
+      @bank = SlotBank.new(server_id)
+      @replacements = {}
+      @wedged = {}
+      @next_index = -1
+    end
+
+    def start(workers)
+      workers.times { spawn_group }
+      report_active
+      self
+    end
+
+    # Groups that are staying: quarantine replacements aside, and minus
+    # those already told to leave. A retiring group leaves the count at
+    # once, not when its last thread exits, so the scaler never sees a
+    # stale surplus and retires past its floor.
+    def active_count
+      @lock.synchronize do
+        @groups.count { |index, _| !@replacements.key?(index) && !@retiring.key?(index) }
+      end
+    end
+
+    # Group index => slot ids for every group the scaler may retire: not
+    # already leaving, not wedged, not a quarantine replacement.
+    def groups
+      reap
+      @lock.synchronize do
+        @groups
+          .reject { |index, _| @retiring.key?(index) || @wedged.key?(index) || @replacements.key?(index) }
+          .transform_values { |group| group[:slots].dup }
+      end
+    end
+
+    # Add one group; returns its index.
+    def grow
+      reap
+      index = spawn_group
+      report_active
+      index
+    end
+
+    # Send a group home: its slots stop receiving work now, each thread
+    # finishes what it holds and leaves at its next idle tick, and the
+    # slots come back to the free list once every thread has exited.
+    def retire(index)
+      slots = @lock.synchronize do
+        next nil unless @groups.key?(index) && !@retiring.key?(index)
+
+        @retiring[index] = true
+        @groups[index][:slots]
+      end
+      return false unless slots
+
+      slots.each { |id| Native.retire_slot(@server_id, id) }
+      true
+    end
+
+    # The quarantine replacer: spawn a replacement thread on a fresh slot
+    # FIRST (may raise ThreadError), then quarantine the wedged slot.
+    def replace(worker_id)
+      spawn_group(slots: 1, replacement: true)
+      Native.quarantine_slot(@server_id, worker_id)
+      @lock.synchronize do
+        wedged = @slot_to_group[worker_id]
+        @wedged[wedged] = true if wedged
+      end
+      true
+    end
+
+    # Join every thread up to the (numeric) deadline.
+    def shutdown(timeout)
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+      all_threads.each do |thread|
+        remaining = deadline - Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        thread.join([remaining, 0.01].max)
+      end
+    end
+
+    def done?
+      all_threads.none?(&:alive?)
+    end
+
+    # Block until every thread exits on its own (drain elsewhere).
+    def join
+      all_threads.each(&:join)
+    end
+
+    def kill_stragglers
+      all_threads.each { |thread| thread.kill if thread.alive? }
+    end
+
+    private
+
+    def all_threads
+      @lock.synchronize { @groups.values.flat_map { |group| group[:threads] } }
+    end
+
+    # The group is in the table before its first thread starts, so a
+    # ThreadError partway through leaves nothing untracked for shutdown.
+    def spawn_group(slots: @threads, replacement: false)
+      group = {slots: [], threads: []}
+      index = @lock.synchronize do
+        @next_index += 1
+        @groups[@next_index] = group
+        @replacements[@next_index] = true if replacement
+        @next_index
+      end
+      slots.times do
+        id = @bank.claim
+        @lock.synchronize do
+          group[:slots] << id
+          @slot_to_group[id] = index
+        end
+        thread = spawn_thread(id)
+        @lock.synchronize { group[:threads] << thread }
+      end
+      index
+    end
+
+    def spawn_thread(worker_id)
+      Thread.new do
+        # Named so log lines from inside say which worker spoke.
+        Thread.current.name = "worker-#{worker_id}"
+        error = nil
+        begin
+          Worker.run(@server_id, worker_id, @app, @batch, @hooks)
+        rescue Exception => e # rubocop:disable Lint/RescueException -- a hard crash in a threaded worker thread
+          error = e
+          raise
+        ensure
+          HookFire.fire(@on_worker_exit, "on_worker_exit", worker_id, error)
+        end
+      end
+    end
+
+    # Retiring groups whose threads have all exited give their slots back
+    # and leave the table. Runs before every pool decision, so the count
+    # the control plane sees never lags by more than a scaler tick.
+    def reap
+      freed = @lock.synchronize do
+        done = @retiring.keys.select { |index| @groups[index][:threads].none?(&:alive?) }
+        done.flat_map do |index|
+          group = @groups.delete(index)
+          @retiring.delete(index)
+          group[:slots].each { |id| @slot_to_group.delete(id) }
+          group[:slots]
+        end
+      end
+      return if freed.empty?
+
+      @bank.release(freed)
+      report_active
+    end
+
+    def report_active
+      Native.set_active_workers(@server_id, active_count)
+    end
+  end
+end

data/lib/kino/version.rb

@@ -2,5 +2,5 @@
 
 module Kino
   # The gem version (single source of truth; ext/kino/Cargo.toml syncs).
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/kino/worker.rb

@@ -20,12 +20,16 @@ module Kino
 
     def run(server_id, worker_id, app, batch_size = 1, hooks = nil)
       fire_after_worker_boot(hooks, worker_id)
+      # One resolution of (server, worker) into a native handle; every take
+      # after this skips the registry lookup. nil = server already gone.
+      worker = Native.worker(server_id, worker_id)
+      return unless worker
       if batch_size <= 1
-        env = Native.take_one(server_id, worker_id)
-        env = handle_one(env, server_id, worker_id, app, hooks) while env
+        env = worker.take_one
+        env = handle_one(env, worker, app, hooks) while env
       else
-        batch = Native.take_batch(server_id, worker_id, batch_size)
-        batch = process(batch, server_id, worker_id, app, batch_size, hooks) while batch
+        batch = worker.take_batch(batch_size)
+        batch = process(batch, worker, app, batch_size, hooks) while batch
       end
     end
 
@@ -35,22 +39,21 @@ module Kino
     NOT_FUSED = Object.new.freeze
 
     # Handle one request; returns the next env (fused take) or nil.
-    def handle_one(env, server_id, worker_id, app, hooks)
+    def handle_one(env, worker, app, hooks)
       result = serve(env, app, hooks) do |request, status, headers, chunks|
-        request.respond_and_take_one(server_id, worker_id, status, headers, chunks)
+        request.respond_and_take_one(worker, status, headers, chunks)
       end
-      result.equal?(NOT_FUSED) ? Native.take_one(server_id, worker_id) : result
+      result.equal?(NOT_FUSED) ? worker.take_one : result
     end
 
     # Handle every env in the batch; returns the next batch (the last
     # simple response rides the fused respond_and_take) or nil on shutdown.
-    def process(batch, server_id, worker_id, app, batch_size, hooks)
+    def process(batch, worker, app, batch_size, hooks)
       last = batch.size - 1
       batch.each_with_index do |env, index|
         result = serve(env, app, hooks) do |request, status, headers, chunks|
           if index == last
-            request.respond_and_take(server_id, worker_id, batch_size,
-              status, headers, chunks)
+            request.respond_and_take(worker, batch_size, status, headers, chunks)
           else
             request.send_simple(status, headers, chunks)
             NOT_FUSED
@@ -58,7 +61,7 @@ module Kino
         end
         return result if index == last && !result.equal?(NOT_FUSED)
       end
-      Native.take_batch(server_id, worker_id, batch_size)
+      worker.take_batch(batch_size)
     end
 
     # Run one request through the app. Complete bodies are yielded so the

data/lib/kino.rb

@@ -57,8 +57,12 @@ require_relative "kino/configuration"
 require_relative "kino/hook_fire"
 require_relative "kino/worker_hooks"
 require_relative "kino/worker"
+require_relative "kino/slot_bank"
 require_relative "kino/ractor_supervisor"
+require_relative "kino/threaded_pool"
+require_relative "kino/monitor"
 require_relative "kino/quarantine_monitor"
+require_relative "kino/pool_scaler"
 require_relative "kino/server"
 
 # Hand the frozen shareable singletons to the native layer: it sets them

data/lib/rackup/handler/kino.rb

@@ -9,13 +9,13 @@ module Rackup
     module Kino
       # Host option name => Kino setting plus the coercion it needs: rackup
       # hands `-O NAME=VALUE` values (and its own -p) over as strings.
-      OPTION_MAP = {
+      OPTION_MAP = Ractor.make_shareable({
         Host: [:bind, ->(value) { value.to_s }],
         Port: [:port, ->(value) { Integer(value) }],
         Workers: [:workers, ->(value) { Integer(value) }],
         Threads: [:threads, ->(value) { Integer(value) }],
         Mode: [:mode, ->(value) { value.to_sym }]
-      }.freeze
+      })
       private_constant :OPTION_MAP
 
       # Boot a server for `app` and block until it shuts down, the way the
@@ -27,7 +27,7 @@ module Rackup
       #   want a handle on it
       # @return [::Kino::Server] the stopped server, after shutdown
       def self.run(app, **options)
-        require "kino"
+        require "kino" # audition:disable runtime-require
         server = ::Kino::Server.new(app, **server_options(options))
         yield server if block_given?
         server.run
@@ -58,7 +58,7 @@ module Rackup
       # @param options [Hash{Symbol => Object}]
       # @return [Hash{Symbol => Object}]
       def self.server_options(options)
-        require "kino"
+        require "kino" # audition:disable runtime-require
         options = options.dup
         host_defaults = {}
         if (typed = options.delete(:user_supplied_options))

data/sig/kino.rbs

@@ -110,6 +110,8 @@ module Kino
       def bind: (String host) -> untyped
       def port: (int port) -> untyped
       def workers: (int count) -> untyped
+      def max_workers: (int count) -> untyped
+      def scale_down_after: (Numeric seconds) -> untyped
       def threads: (int count) -> untyped
       def mode: (Symbol | String mode) -> untyped
       def queue_depth: (int depth) -> untyped
@@ -130,6 +132,7 @@ module Kino
       def io_threads: (int? count) -> untyped
       def tokio_threads: (int count) -> untyped
       def tls: (cert: String, key: String) -> untyped
+      def http2: (?boolish enabled) -> untyped
       def environment: (String | Symbol env) -> untyped
       def pidfile: (String path) -> untyped
       def control_bind: (String addr) -> String

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kino
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: aarch64-linux
 authors:
 - Yaroslav Markin
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-08-29 00:00:00.000000000 Z
+date: 2026-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: logger
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rackup
   requirement: !ruby/object:Gem::Requirement
@@ -166,12 +180,16 @@ files:
 - lib/kino/kino.so
 - lib/kino/log.rb
 - lib/kino/logger.rb
+- lib/kino/monitor.rb
 - lib/kino/null_input.rb
+- lib/kino/pool_scaler.rb
 - lib/kino/quarantine_monitor.rb
 - lib/kino/ractor_supervisor.rb
 - lib/kino/server.rb
+- lib/kino/slot_bank.rb
 - lib/kino/stream.rb
 - lib/kino/templates/kino.rb.tt
+- lib/kino/threaded_pool.rb
 - lib/kino/version.rb
 - lib/kino/worker.rb
 - lib/kino/worker_hooks.rb