itsi 0.1.0 → 0.1.2

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

@@ -6,6 +6,142 @@ require_relative "scheduler/itsi_scheduler"
 module Itsi
   class Scheduler
     class Error < StandardError; end
-    # Your code goes here...
+
+    def self.resume_token
+      @resume_token ||= 0
+      @resume_token += 1
+    end
+
+    def initialize
+      @join_waiters = {}.compare_by_identity
+      @token_map = {}.compare_by_identity
+      @resume_tokens = {}.compare_by_identity
+      @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
+    end
+
+    def block(_, timeout, fiber = Fiber.current, token = Scheduler.resume_token)
+      @join_waiters[fiber] = true
+
+      start_timer(timeout, token) if timeout
+      @resume_tokens[token] = fiber
+      @token_map[fiber] = token
+      Fiber.yield
+    ensure
+      @resume_tokens.delete(token)
+      @token_map.delete(fiber)
+      @join_waiters.delete(fiber)
+    end
+
+    # Register an IO waiter.
+    # This will get resumed by our scheduler inside the call to
+    # fetch_events.
+    def io_wait(io, events, duration)
+      fiber = Fiber.current
+      token = Scheduler.resume_token
+      readiness = register_io_wait(io.fileno, events, duration, token)
+      readiness || block(nil, duration, fiber, token)
+    end
+
+    def unblock(_blocker, fiber)
+      @unblocked_mux.synchronize do
+        @unblocked[@unblock_idx] << fiber
+      end
+      wake
+    end
+
+    def kernel_sleep(duration)
+      block nil, duration
+    end
+
+    def tick
+      events = fetch_due_events
+      timers = fetch_due_timers
+      unblocked = switch_unblock_batch
+      events&.each(&@resume_fiber_with_readiness)
+      unblocked.each(&@resume_blocked)
+      unblocked.clear
+      timers&.each(&@resume_fiber)
+    end
+
+    def resume_fiber(token)
+      if (fiber = @resume_tokens.delete(token))
+        fiber.resume
+      end
+    rescue StandardError => e
+      warn "Failed to resume fiber #{fiber}: #{e.message}"
+    end
+
+    def resume_fiber_with_readiness((token, readiness))
+      if (fiber = @resume_tokens.delete(token))
+        fiber.resume(readiness)
+      end
+    rescue StandardError => e
+      warn "Failed to resume fiber #{fiber}: #{e.message}"
+    end
+
+    def resume_blocked(fiber)
+      if (token = @token_map[fiber])
+        resume_fiber(token)
+      elsif fiber.alive?
+        fiber.resume
+      end
+    end
+
+    def switch_unblock_batch
+      @unblocked_mux.synchronize do
+        current = @unblocked[@unblock_idx]
+        @unblock_idx = (@unblock_idx + 1) % 2
+        current
+      end
+    end
+
+    # Yields upwards to the scheduler, with an intention to
+    # resume the fiber that yielded ASAP.
+    def yield
+      kernel_sleep(0) if work?
+    end
+
+    # Keep running until we've got no timers we're awaiting, no pending IO, no temporary yields,
+    # no pending unblocks.
+    def work?
+      !@unblocked[@unblock_idx].empty? || !@join_waiters.empty? || has_pending_io?
+    end
+
+    # Run until no more work needs doing.
+    def run
+      tick while work?
+      debug "Exit Scheduler"
+    end
+
+    # Hook invoked at the end of the thread.
+    # Will start our scheduler's Reactor.
+    def scheduler_close
+      run
+    ensure
+      @closed ||= true
+      freeze
+    end
+
+    # 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)
+      Thread.new do
+        Process::Status.wait(pid, flags)
+      end.value
+    end
+
+    def closed?
+      @closed
+    end
+
+    # Spin up a new fiber and immediately resume it.
+    def fiber(&blk)
+      Fiber.new(blocking: false, &blk).tap(&:resume)
+    end
   end
 end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "minitest/reporters"
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+require "itsi/scheduler"
+require 'debug'
+module Itsi::Scheduler::TestHelper
+  SchedulerClass = Itsi::Scheduler
+
+  def with_scheduler(join: true, report_on_exception: false)
+    Thread.new do
+      Thread.current.report_on_exception = report_on_exception
+      scheduler = SchedulerClass.new
+      Fiber.set_scheduler(scheduler)
+      Fiber.schedule do
+        yield scheduler
+      end
+    end.yield_self do |thread|
+      thread.join if join
+      thread
+    end
+  end
+end

data/gems/scheduler/test/test_active_record.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+class TestActiveRecordFiberScheduler < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  # Set up an ActiveRecord connection to your PostgreSQL test database.
+  # Adjust the connection parameters as needed.
+  def setup
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+    ActiveRecord::Base.establish_connection(
+      adapter: "postgresql",
+      database: "fiber_scheduler_test",
+      pool: 2, # use a small pool to test contention scenarios
+      checkout_timeout: 5
+    )
+  end
+
+  # Disconnect after each test.
+  def teardown
+    ActiveRecord::Base.connection_pool.disconnect!
+  end
+
+  # Test a basic query execution inside a fiber.
+  def test_basic_query
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        result = ActiveRecord::Base.connection.select_value("SELECT 1")
+      end
+    end
+
+    # select_value returns a string from PG adapter so we compare with "1"
+    assert_equal "1", result.to_s
+  end
+
+  # Test running two queries concurrently in different fibers.
+  def test_concurrent_queries
+    results = []
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        results << ActiveRecord::Base.connection.select_value("SELECT 1")
+      end
+
+      Fiber.schedule do
+        results << ActiveRecord::Base.connection.select_value("SELECT 2")
+      end
+    end
+
+    # Ensure that both queries have executed and returned the expected values.
+    results = results.map(&:to_s)
+    assert_includes results, "1"
+    assert_includes results, "2"
+  end
+
+  # Test a query that involves a short delay using PostgreSQL's pg_sleep.
+  def test_query_with_delay
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # Introduce a 0.1 second delay.
+        ActiveRecord::Base.connection.execute("SELECT pg_sleep(0.1)")
+        result = ActiveRecord::Base.connection.select_value("SELECT 3")
+      end
+    end
+
+    assert_equal "3", result.to_s
+  end
+
+  # Test connection pool exhaustion by limiting the pool to one connection.
+  # Two fibers will attempt to get a connection concurrently.
+  def test_connection_pool_exhaustion
+    # Re-establish connection with a pool size of 1.
+    ActiveSupport::IsolatedExecutionState.isolation_level = :fiber
+    ActiveRecord::Base.establish_connection(
+      adapter: "postgresql",
+      host: "localhost",
+      database: "fiber_scheduler_test",
+      pool: 1,
+      checkout_timeout: 0.25
+    )
+    # ActiveRecord::Base.connection_pool.disconnect!
+
+    results = []
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        ActiveRecord::Base.connection_pool.with_connection(prevent_permanent_checkout: true) do
+          results << ActiveRecord::Base.connection.select_value("SELECT 1")
+        end
+      end
+
+      Fiber.schedule do
+        ActiveRecord::Base.connection_pool.with_connection(prevent_permanent_checkout: true) do
+          results << ActiveRecord::Base.connection.select_value("SELECT 2")
+        end
+      end
+    end
+
+    # Takes #{checkout_timeout} seconds between last
+    results = results.map(&:to_s)
+    assert_includes results, "1"
+    assert_includes results, "2"
+  end
+
+  # Test that after a Fiber finishes its work, its connection is automatically released.
+  def test_fiber_connection_release_after_completion
+    # Use the scheduler to run a fiber that checks out a connection and does a simple query.
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # This fiber checks out a connection to run a query.
+        ActiveRecord::Base.connection.select_value("SELECT 1")
+        # The fiber ends here.
+      end
+    end
+
+    # After the scheduler finishes, the fiber should have completed and released its connection.
+    # Now we attempt to checkout a connection manually. If the previous fiber's connection
+    # was not released, this would either time out or raise an error.
+    connection = ActiveRecord::Base.connection_pool.checkout
+    assert connection, "Expected to obtain a connection after fiber completion"
+    ActiveRecord::Base.connection_pool.checkin(connection)
+  end
+
+  # Test that a transaction works correctly when run inside a fiber.
+  # A temporary table is created, a record inserted and then queried before the transaction is rolled back.
+  def test_transaction_fiber
+    result = nil
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        ActiveRecord::Base.transaction do
+          # Create a temporary table for testing.
+          ActiveRecord::Base.connection.execute(<<~SQL)
+            CREATE TEMP TABLE IF NOT EXISTS test_table (
+              id serial PRIMARY KEY,
+              name text
+            )
+          SQL
+
+          # Insert a record.
+          ActiveRecord::Base.connection.execute("INSERT INTO test_table (name) VALUES ('Alice')")
+          # Query the inserted record.
+          result = ActiveRecord::Base.connection.select_value("SELECT name FROM test_table LIMIT 1")
+          # Roll back the transaction to avoid leaving test data.
+          raise ActiveRecord::Rollback
+        end
+      end
+    end
+
+    assert_equal "Alice", result.to_s
+  end
+end

data/gems/scheduler/test/test_address_resolve.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+require 'debug'
+
+
+class TestAddressResolve < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_addess_resolve
+    results = []
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        results << Addrinfo.getaddrinfo("www.ruby-lang.org", 80, nil, :STREAM)
+      end
+      Fiber.schedule do
+        results << Addrinfo.getaddrinfo("www.google.com", 80, nil, :STREAM)
+      end
+    end
+
+    assert  results.all?{|results| results.find(&:ipv4?) }
+    assert results.all?{|results| results.find(&:ipv6?) }
+  end
+end

data/gems/scheduler/test/test_block_unblock.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+
+class TestBlockUnblock < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_block_with_timeout
+    result = nil
+    start_time = Time.now
+
+    with_scheduler do |_scheduler|
+      Fiber.schedule do
+        # Simulate a blocking operation with a 0.1-second timeout.
+        Fiber.scheduler.block(nil, 0.1)
+        result = :resumed
+      end
+    end
+
+    elapsed_time = Time.now - start_time
+
+    assert_equal :resumed, result
+    assert_in_delta 0.1, elapsed_time, 0.01, "Fiber did not resume after the expected timeout"
+  end
+
+  # Test that a fiber blocked without a timeout can be manually unblocked.
+  def test_block_and_manual_unblock
+    result = nil
+
+    with_scheduler do |scheduler|
+      fiber = Fiber.schedule do
+        # This fiber blocks indefinitely until manually unblocked.
+        Fiber.scheduler.block(:self, nil)
+        result = :resumed
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        scheduler.unblock(:self, fiber)
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_double_unblock
+    result = nil
+    with_scheduler do |sched|
+      fiber = Fiber.schedule do
+        # This fiber blocks indefinitely until manually unblocked.
+        Fiber.scheduler.block(:self, nil)
+        result = :resumed
+      end
+
+      fiber_2 = Fiber.schedule do
+        Fiber.scheduler.unblock(:self, fiber)
+        Fiber.scheduler.unblock(:self, fiber)
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_timed_double_unblock
+    result = nil
+
+    fiber = scheduler = nil
+
+    Thread.new do
+      sleep 0.01
+      scheduler.unblock(:self, fiber)
+      scheduler.unblock(:self, fiber)
+      sleep 1
+    end
+
+    with_scheduler do |sched|
+      scheduler = sched
+      fiber = Fiber.schedule do
+        # This fiber blocks indefinitely until manually unblocked.
+        Fiber.scheduler.block(:self, 0.1)
+        Fiber.scheduler.block(:self, 0.1)
+        result = :resumed
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_condition_variable_signaling
+    result = nil
+    mutex = Mutex.new
+    cv = ConditionVariable.new
+
+    # Set a scheduler so that non-blocking fibers are active.
+    # (Without a scheduler, blocking operations run in the usual way.)
+    with_scheduler do
+      # Create a non-blocking fiber that waits on the condition variable.
+      fiber = Fiber.schedule do
+        mutex.synchronize do
+          # The call to cv.wait(mutex) internally triggers the scheduler’s block hook.
+          cv.wait(mutex)
+          result = :resumed
+        end
+      end
+
+      # In a separate thread, signal the condition variable after a delay.
+      Thread.new do
+        sleep 0.05
+        mutex.synchronize do
+          cv.signal # This should cause Ruby to internally call the scheduler’s unblock hook.
+        end
+      end
+
+      # Wait until the fiber finishes.
+      Timeout.timeout(1) do
+        sleep 0.01 while fiber.alive?
+      end
+    end
+    assert_equal :resumed, result
+  end
+
+  def test_queue_pop_unblocks_fiber
+    result = nil
+    queue = Queue.new
+
+    # Set a scheduler so that non-blocking fiber operations are enabled.
+    with_scheduler do
+      # Schedule a fiber that waits on the queue.
+      fiber = Fiber.schedule do
+        # queue.pop will block until an item is pushed.
+        result = queue.pop
+      end
+
+      # In a separate thread, push an element into the queue after a short delay.
+      Thread.new do
+        queue.push(:hello)
+      end.join
+
+      # Wait until the fiber finishes execution.
+      sleep 0.1 while fiber.alive?
+    end
+    assert_equal :hello, result
+  end
+
+  # Test that unblocking a fiber that isn’t blocked is a no-op.
+  def test_unblock_non_blocked_fiber
+    with_scheduler do |scheduler|
+      fiber = Fiber.new do
+        # Do nothing special.
+        :finished
+      end
+
+      # Try to unblock a fiber that isn’t currently blocked.
+      scheduler.unblock(nil, fiber)
+      # The fiber should finish normally.
+      assert_equal :finished, fiber.resume
+    end
+  end
+
+  def test_multiple_fibers_blocking_and_unblocking
+    results = {}
+
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        Fiber.scheduler.block(:resource1, 0.1)
+        results[:fiber1] = :resumed
+      end
+
+      fiber2 = Fiber.schedule do
+        Fiber.scheduler.block(:resource2, nil)
+        results[:fiber2] = :resumed
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        scheduler.unblock(:resource, fiber2)
+      end
+    end
+
+    assert_equal :resumed, results[:fiber1], "Fiber1 did not resume after timeout"
+    assert_equal :resumed, results[:fiber2], "Fiber2 did not resume after manual unblock"
+  end
+
+  def test_block_with_immediate_unblock
+    result = nil
+
+    with_scheduler do |scheduler|
+      fiber = Fiber.schedule do
+        Fiber.scheduler.block(:resource, 0.1)
+        result = :resumed
+      end
+
+      Fiber.schedule do
+        scheduler.unblock(:resource, fiber)
+      end
+    end
+
+    assert_equal :resumed, result
+  end
+
+  def test_block_with_no_unblock
+    result = nil
+
+    with_scheduler(join: false) do |_scheduler|
+      Fiber.schedule do
+        Fiber.scheduler.block(:resource, 0.1)
+        result = :resumed
+      end
+    end
+
+    assert_nil result, :resumed
+  end
+
+  def test_unblock_non_blocked_fiber_v2
+    result = :not_resumed
+
+    with_scheduler do |scheduler|
+      fiber = Fiber.schedule do
+        result = :resumed
+      end
+
+      Fiber.schedule do
+        sleep 0.05
+        scheduler.unblock(:resource, fiber)
+      end
+    end
+
+    assert_equal :resumed, result, "Fiber should have been resumed normally"
+  end
+end