itsi 0.2.25 → 0.2.27.rc1

data/gems/scheduler/Cargo.toml

@@ -4,4 +4,3 @@ resolver = "2"
 
 [patch.crates-io]
 magnus = { git = "https://github.com/matsadler/magnus.git", rev = "1ed232edb2b75a2eed9b1def34ad57e55c411a5c" }
-rb-sys-build = { path = "vendor/rb-sys-build" }

data/gems/scheduler/Gemfile

@@ -2,10 +2,16 @@ source "https://rubygems.org"
 
 gemspec
 
-group :development, :test do
+group :development do
   gem "bundler"
-  gem "minitest", "~> 5.16"
   gem "rake", "~> 13.0"
   gem "rake-compiler"
   gem "rb_sys", "~> 0.9.91"
 end
+
+group :test do
+  gem "activerecord"
+  gem "minitest", "~> 5.16"
+  gem "minitest-reporters"
+  gem "pg"
+end

data/gems/scheduler/Gemfile.lock

@@ -0,0 +1,107 @@
+PATH
+  remote: .
+  specs:
+    itsi-scheduler (0.2.27.rc1)
+      rb_sys (~> 0.9.91)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (8.1.3)
+      activesupport (= 8.1.3)
+    activerecord (8.1.3)
+      activemodel (= 8.1.3)
+      activesupport (= 8.1.3)
+      timeout (>= 0.4.0)
+    activesupport (8.1.3)
+      base64
+      bigdecimal
+      concurrent-ruby (~> 1.0, >= 1.3.1)
+      connection_pool (>= 2.2.5)
+      drb
+      i18n (>= 1.6, < 2)
+      json
+      logger (>= 1.4.2)
+      minitest (>= 5.1)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
+      uri (>= 0.13.1)
+    ansi (1.6.0)
+    base64 (0.3.0)
+    bigdecimal (4.1.2)
+    builder (3.3.0)
+    concurrent-ruby (1.3.6)
+    connection_pool (3.0.2)
+    drb (2.2.3)
+    i18n (1.14.8)
+      concurrent-ruby (~> 1.0)
+    json (2.19.4)
+    logger (1.7.0)
+    minitest (5.27.0)
+    minitest-reporters (1.8.0)
+      ansi
+      builder
+      minitest (>= 5.0, < 7)
+      ruby-progressbar
+    pg (1.6.3)
+    pg (1.6.3-arm64-darwin)
+    rake (13.3.1)
+    rake-compiler (1.3.0)
+      rake
+    rake-compiler-dock (1.11.0)
+    rb_sys (0.9.126)
+      json (>= 2)
+      rake-compiler-dock (= 1.11.0)
+    ruby-progressbar (1.13.0)
+    securerandom (0.4.1)
+    timeout (0.6.1)
+    tzinfo (2.0.6)
+      concurrent-ruby (~> 1.0)
+    uri (1.1.1)
+
+PLATFORMS
+  arm64-darwin-24
+  ruby
+
+DEPENDENCIES
+  activerecord
+  bundler
+  itsi-scheduler!
+  minitest (~> 5.16)
+  minitest-reporters
+  pg
+  rake (~> 13.0)
+  rake-compiler
+  rb_sys (~> 0.9.91)
+
+CHECKSUMS
+  activemodel (8.1.3) sha256=90c05cbe4cef3649b8f79f13016191ea94c4525ce4a5c0fb7ef909c4b91c8219
+  activerecord (8.1.3) sha256=8003be7b2466ba0a2a670e603eeb0a61dd66058fccecfc49901e775260ac70ab
+  activesupport (8.1.3) sha256=21a5e0dfbd4c3ddd9e1317ec6a4d782fa226e7867dc70b0743acda81a1dca20e
+  ansi (1.6.0) sha256=ac9ea0c0ea8d32fb4e271348e609963ac78882f34b73836c2a02b3622e666658
+  base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
+  bigdecimal (4.1.2) sha256=53d217666027eab4280346fba98e7d5b66baaae1b9c3c1c0ffe89d48188a3fbd
+  builder (3.3.0) sha256=497918d2f9dca528fdca4b88d84e4ef4387256d984b8154e9d5d3fe5a9c8835f
+  concurrent-ruby (1.3.6) sha256=6b56837e1e7e5292f9864f34b69c5a2cbc75c0cf5338f1ce9903d10fa762d5ab
+  connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a
+  drb (2.2.3) sha256=0b00d6fdb50995fe4a45dea13663493c841112e4068656854646f418fda13373
+  i18n (1.14.8) sha256=285778639134865c5e0f6269e0b818256017e8cde89993fdfcbfb64d088824a5
+  itsi-scheduler (0.2.27.rc1)
+  json (2.19.4) sha256=670a7d333fb3b18ca5b29cb255eb7bef099e40d88c02c80bd42a3f30fe5239ac
+  logger (1.7.0) sha256=196edec7cc44b66cfb40f9755ce11b392f21f7967696af15d274dde7edff0203
+  minitest (5.27.0) sha256=2d3b17f8a36fe7801c1adcffdbc38233b938eb0b4966e97a6739055a45fa77d5
+  minitest-reporters (1.8.0) sha256=8ce5280fb73ad3178ae525454df169b6f28c1b38b1d088ea91815d3a370ba384
+  pg (1.6.3) sha256=1388d0563e13d2758c1089e35e973a3249e955c659592d10e5b77c468f628a99
+  pg (1.6.3-arm64-darwin) sha256=7240330b572e6355d7c75a7de535edb5dfcbd6295d9c7777df4d9dddfb8c0e5f
+  rake (13.3.1) sha256=8c9e89d09f66a26a01264e7e3480ec0607f0c497a861ef16063604b1b08eb19c
+  rake-compiler (1.3.0) sha256=eec272ef6d4dad27b36f5cdcf5b9ee4df2193751f4082b095f981ebf9cdf4127
+  rake-compiler-dock (1.11.0) sha256=eab51f2cd533eb35cea6b624a75281f047123e70a64c58b607471bb49428f8c2
+  rb_sys (0.9.126) sha256=ba958e0b8b4b89eeae0b3d24b64c809eb2c37e0ab0773a49e9b1c2e22c95aef8
+  ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33
+  securerandom (0.4.1) sha256=cc5193d414a4341b6e225f0cb4446aceca8e50d5e1888743fac16987638ea0b1
+  timeout (0.6.1) sha256=78f57368a7e7bbadec56971f78a3f5ecbcfb59b7fcbb0a3ed6ddc08a5094accb
+  tzinfo (2.0.6) sha256=8daf828cc77bcf7d63b0e3bdb6caa47e2272dcfaf4fbfe46f8c3a9df087a829b
+  uri (1.1.1) sha256=379fa58d27ffb1387eaada68c749d1426738bd0f654d812fcc07e7568f5c57c6
+
+BUNDLED WITH
+  2.6.9

data/gems/scheduler/Rakefile

@@ -1,7 +1,17 @@
 # frozen_string_literal: true
 
 require "bundler/gem_tasks"
-require "minitest/test_task"
+
+def test_tasks_requested?
+  requested = Rake.application.top_level_tasks
+  return true if requested.empty?
+
+  requested.any? do |task_name|
+    task_name == "test" || task_name.start_with?("test:")
+  end
+end
+
+require "minitest/test_task" if test_tasks_requested?
 
 SMOKE_TEST_GLOBS = %w[
   test/test_itsi_scheduler.rb
@@ -11,6 +21,16 @@ SMOKE_TEST_GLOBS = %w[
   test/test_file_io.rb
 ].freeze
 
+def native_build_tasks_requested?
+  requested = Rake.application.top_level_tasks
+  return true if requested.empty?
+
+  requested.any? do |task_name|
+    task_name == "default" ||
+      task_name.start_with?("build", "compile", "cross", "clobber")
+  end
+end
+
 def configure_test_task(task_name, test_globs)
   Minitest::TestTask.create(task_name) do |t|
     t.libs << "test"
@@ -21,19 +41,23 @@ def configure_test_task(task_name, test_globs)
   end
 end
 
-configure_test_task(:test, ["test/**/*.rb"])
-configure_test_task("test:smoke", SMOKE_TEST_GLOBS)
+if test_tasks_requested?
+  configure_test_task(:test, ["test/**/*.rb"])
+  configure_test_task("test:smoke", SMOKE_TEST_GLOBS)
 
-task "test:full" => :test
+  task "test:full" => :test
+end
 
-require "rb_sys/extensiontask"
+if native_build_tasks_requested?
+  require "rb_sys/extensiontask"
 
-task build: :compile
+  task build: :compile
 
-GEMSPEC = Gem::Specification.load("itsi-scheduler.gemspec")
+  GEMSPEC = Gem::Specification.load("itsi-scheduler.gemspec")
 
-RbSys::ExtensionTask.new("itsi-scheduler", GEMSPEC) do |ext|
-  ext.lib_dir = "lib/itsi/scheduler"
+  RbSys::ExtensionTask.new("itsi-scheduler", GEMSPEC) do |ext|
+    ext.lib_dir = "lib/itsi/scheduler"
+  end
 end
 
 task default: %i[compile test rubocop]

data/gems/scheduler/itsi-scheduler.gemspec

@@ -30,8 +30,6 @@ Gem::Specification.new do |spec|
   end + Dir["../../crates/**/*.{toml,rs,lock}"].map do |ext_file|
     "ext/#{ext_file[%r{.*crates/(.*?)$}, 1]}"
   end.compact +
-    Dir["vendor/rb-sys-build/**/*.{toml,rs,h,lock}"] +
-    Dir["vendor/rb-sys-build/LICENSE-*"] +
     Dir.glob("lib/**/*.{rb,bundle,so,dylib,dll}")
   spec.files.uniq!
 

data/gems/scheduler/lib/itsi/scheduler/version.rb

@@ -2,6 +2,6 @@
 
 module Itsi
   class Scheduler
-    VERSION = "0.2.25"
+    VERSION = "0.2.27.rc1"
   end
 end

data/gems/scheduler/lib/itsi/scheduler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "etc"
+
 require_relative "scheduler/version"
 require_relative "scheduler/native_extension"
 require_relative "schedule_refinement"
@@ -7,6 +9,7 @@ require_relative "schedule_refinement"
 module Itsi
   class Scheduler
     class Error < StandardError; end
+    WorkRequest = Struct.new(:fiber, :work, :result, :error, keyword_init: true)
 
     def self.resume_token
       @resume_token ||= 0
@@ -17,12 +20,14 @@ module Itsi
       @join_waiters = {}.compare_by_identity
       @token_map = {}.compare_by_identity
       @resume_tokens = {}.compare_by_identity
+      @timeout_requests = {}
       @unblocked = [[], []]
       @unblock_idx = 0
       @unblocked_mux = Mutex.new
       @resume_fiber = method(:resume_fiber).to_proc
       @resume_fiber_with_readiness = method(:resume_fiber_with_readiness).to_proc
       @resume_blocked = method(:resume_blocked).to_proc
+      setup_worker_pool
     end
 
     def block(_, timeout, fiber = Fiber.current, token = Scheduler.resume_token)
@@ -33,6 +38,7 @@ module Itsi
       @token_map[fiber] = token
       Fiber.yield
     ensure
+      cancel_wait(token)
       @resume_tokens.delete(token)
       @token_map.delete(fiber)
       @join_waiters.delete(fiber)
@@ -61,6 +67,60 @@ module Itsi
       block nil, duration
     end
 
+    def timeout_after(duration, klass = Timeout::Error, message = "execution expired")
+      fiber = Fiber.current
+      token = Scheduler.resume_token
+      exception = klass.is_a?(Class) ? klass.new(message) : klass
+      @timeout_requests[token] = [fiber, exception]
+      start_timer(duration, token)
+      yield duration
+    ensure
+      clear_timer(token) if token
+      @timeout_requests.delete(token) if token
+    end
+
+    def fiber_interrupt(fiber, exception)
+      cancel_wait(@token_map[fiber]) if @token_map.key?(fiber)
+      fiber.raise(exception)
+      true
+    rescue FiberError
+      false
+    end
+
+    def blocking_operation_wait(work)
+      request = WorkRequest.new(fiber: Fiber.current, work: work)
+      @worker_queue << request
+      block(nil, nil, request.fiber)
+      raise request.error if request.error
+
+      request.result
+    end
+
+    def io_select(readables, writables, exceptables, timeout)
+      readables = Array(readables).compact
+      writables = Array(writables).compact
+      exceptables = Array(exceptables).compact
+      ios = (readables + writables + exceptables).uniq
+
+      if ios.length == 1
+        io = ios.first
+        events = 0
+        events |= IO::READABLE if readables.include?(io)
+        events |= IO::WRITABLE if writables.include?(io)
+        events |= IO::PRIORITY if exceptables.include?(io)
+        readiness = io_wait(io, events, timeout)
+        return nil unless readiness
+
+        return [
+          (readiness & IO::READABLE).zero? ? [] : readables.select { |entry| entry == io },
+          (readiness & IO::WRITABLE).zero? ? [] : writables.select { |entry| entry == io },
+          (readiness & IO::PRIORITY).zero? ? [] : exceptables.select { |entry| entry == io }
+        ]
+      end
+
+      blocking_operation_wait(-> { IO.select(readables, writables, exceptables, timeout) })
+    end
+
     def tick
       events = fetch_due_events
       timers = fetch_due_timers
@@ -72,6 +132,12 @@ module Itsi
     end
 
     def resume_fiber(token)
+      if (request = @timeout_requests.delete(token))
+        fiber, exception = request
+        fiber_interrupt(fiber, exception)
+        return
+      end
+
       if (fiber = @resume_tokens.delete(token))
         fiber.resume
       end
@@ -126,6 +192,7 @@ module Itsi
     def close
       run
     ensure
+      shutdown_worker_pool
       @closed ||= true
       freeze
     end
@@ -133,12 +200,17 @@ module Itsi
     # Need to defer to Process::Status rather than our extension
     # as we don't have a means of creating our own Process::Status.
     def process_wait(pid, flags)
-      result = nil
-      thread = Thread.new do
-        result = Process::Status.wait(pid, flags)
-      end
-      thread.join
-      result
+      blocking_operation_wait(-> { Process::Status.wait(pid, flags) })
+    end
+
+    def address_resolve(hostname)
+      blocking_operation_wait(-> { native_address_resolve(hostname) })
+    end
+
+    def process_fork
+      shutdown_worker_pool
+      setup_worker_pool
+      nil
     end
 
     def closed?
@@ -149,5 +221,48 @@ module Itsi
     def fiber(&blk)
       Fiber.new(blocking: false, &blk).tap(&:resume)
     end
+
+    private
+
+    def setup_worker_pool
+      @worker_stop_token = Object.new
+      @worker_queue = Queue.new
+      @worker_threads = Array.new(worker_pool_size) { start_worker_thread }
+    end
+
+    def start_worker_thread
+      Thread.new do
+        Thread.current.report_on_exception = false
+        Thread.current.thread_variable_set(:fork_safe, true)
+
+        loop do
+          request = @worker_queue.pop
+          break if request.equal?(@worker_stop_token)
+
+          begin
+            request.result = request.work.call
+          rescue Exception => exception
+            request.error = exception
+          ensure
+            unblock(nil, request.fiber)
+          end
+        end
+      end
+    end
+
+    def shutdown_worker_pool
+      return unless @worker_threads
+
+      @worker_threads.size.times { @worker_queue << @worker_stop_token }
+      @worker_threads.each(&:join)
+      @worker_threads.clear
+    end
+
+    def worker_pool_size
+      size = ENV.fetch("ITSI_WORKER_POOL_SIZE", Etc.nprocessors.to_s).to_i
+      size.positive? ? size : 1
+    rescue StandardError
+      1
+    end
   end
 end

data/gems/scheduler/test/helpers/test_helper.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+Warning[:experimental] = false if Warning.respond_to?(:[]=)
+
 require "minitest/reporters"
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 

data/gems/scheduler/test/test_address_resolve.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ipaddr"
+
 class TestAddressResolve < Minitest::Test
   include Itsi::Scheduler::TestHelper
 
@@ -15,7 +17,11 @@ class TestAddressResolve < Minitest::Test
       end
     end
 
-    assert  results.all?{|results| results.find(&:ipv4?) }
-    assert results.all?{|results| results.find(&:ipv6?) }
+    assert_equal 2, results.length
+    assert results.all?(&:any?)
+    results.flatten.each do |addrinfo|
+      assert_instance_of Addrinfo, addrinfo
+      assert IPAddr.new(addrinfo.ip_address)
+    end
   end
 end

data/gems/scheduler/test/test_itsi_scheduler.rb

@@ -29,4 +29,84 @@ class TestItsiScheduler < Minitest::Test
     assert_equal total, 6
     assert_match /terminated on exception/, out
   end
+
+  def test_blocking_operation_wait_returns_result_without_stalling_scheduler
+    result = nil
+    marker = nil
+
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        result = scheduler.blocking_operation_wait(-> do
+          sleep 0.05
+          :done
+        end)
+      end
+
+      Fiber.schedule do
+        sleep 0.01
+        marker = :progressed
+      end
+    end
+
+    assert_equal :done, result
+    assert_equal :progressed, marker
+  end
+
+  def test_blocking_operation_wait_propagates_exceptions
+    error = nil
+
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        begin
+          scheduler.blocking_operation_wait(-> { raise ArgumentError, "boom" })
+        rescue => exception
+          error = exception
+        end
+      end
+    end
+
+    refute_nil error
+    assert_equal ArgumentError, error.class
+    assert_equal "boom", error.message
+  end
+
+  def test_io_select_returns_ready_descriptors_without_stalling_scheduler
+    ready = nil
+    marker = nil
+    reader, writer = IO.pipe
+
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        ready = scheduler.io_select([reader], nil, nil, 0.2)
+      end
+
+      Fiber.schedule do
+        sleep 0.01
+        marker = :progressed
+        writer.write("x")
+      end
+    end
+
+    assert_equal :progressed, marker
+    assert_equal [[reader], [], []], ready
+  ensure
+    reader&.close
+    writer&.close
+  end
+
+  def test_process_fork_reinitializes_worker_pool
+    worker_threads = nil
+    refreshed_threads = nil
+
+    with_scheduler do |scheduler|
+      worker_threads = scheduler.instance_variable_get(:@worker_threads)
+      scheduler.process_fork
+      refreshed_threads = scheduler.instance_variable_get(:@worker_threads)
+    end
+
+    refute_nil worker_threads
+    refute_nil refreshed_threads
+    refute_same worker_threads, refreshed_threads
+    assert_equal worker_threads.length, refreshed_threads.length
+  end
 end

data/gems/scheduler/test/test_timeout_after.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+class TestTimeoutAfter < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_timeout_after_raises_timeout_error
+    result = nil
+
+    with_scheduler do
+      Fiber.schedule do
+        begin
+          Timeout.timeout(0.01, Timeout::Error, "benchmark timeout") do
+            sleep 0.05
+          end
+        rescue Timeout::Error => error
+          result = error.message
+        end
+      end
+    end
+
+    assert_equal "benchmark timeout", result
+  end
+
+  def test_timeout_after_cancels_fast_work_without_waiting_for_timeout
+    result = nil
+    started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    with_scheduler do
+      Fiber.schedule do
+        Timeout.timeout(0.05, Timeout::Error, "benchmark timeout") do
+          sleep 0.001
+          result = :completed
+        end
+      end
+    end
+
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+
+    assert_equal :completed, result
+    assert_operator elapsed, :<, 0.03
+  end
+
+  def test_timeout_after_interrupts_io_wait_without_leaking_waiters
+    result = nil
+    reader, writer = IO.pipe
+    started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+    with_scheduler do
+      Fiber.schedule do
+        begin
+          Timeout.timeout(0.01, Timeout::Error, "benchmark timeout") do
+            reader.readpartial(1)
+          end
+        rescue Timeout::Error
+          result = :timed_out
+        end
+      end
+    end
+
+    elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+
+    assert_equal :timed_out, result
+    assert_operator elapsed, :<, 0.05
+  ensure
+    reader&.close
+    writer&.close
+  end
+
+  def test_cascading_timeout_workload_completes
+    completed = 0
+    timed_out = 0
+    total = 0
+
+    with_scheduler do
+      20.times do |index|
+        Fiber.schedule do
+          50.times do |iteration|
+            slow = ((iteration * 7 + index * 3) % 10) < 3
+
+            begin
+              Timeout.timeout(0.01, Timeout::Error, "benchmark timeout") do
+                sleep(slow ? 0.05 : 0.002)
+                completed += 1
+              end
+            rescue Timeout::Error
+              timed_out += 1
+            ensure
+              total += 1
+            end
+          end
+        end
+      end
+    end
+
+    assert_equal 1000, total
+    assert_operator completed, :>, 0
+    assert_operator timed_out, :>, 0
+    assert_equal total, completed + timed_out
+  end
+end