itsi 0.1.0 → 0.1.3

data/gems/scheduler/test/test_nested_fibers.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+class TestNestedFibers < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def each_pop(queue)
+    loop do
+      if item = queue.pop
+        sleep 0.001
+        yield item
+      else
+        break
+      end
+    end
+  end
+
+  def test_async_queue
+    results = []
+    queue = Queue.new
+
+    # In the thread running the scheduler, we use an enumerator, which
+    # uses a new Fiber per iteration
+    with_scheduler do
+      Fiber.schedule do
+        each_pop(queue) do |item|
+          results << item
+        end
+      end
+
+      # Non scheduler thread pushes to queue every 0.1 seconds
+      Thread.new do
+        1.times do |i|
+          queue.push(i)
+          sleep 0.1
+        end
+        queue.push(nil)
+      end.join
+    end
+
+    assert_equal [*0...1], results
+  end
+
+  def test_base_unowned_no_scheduler_transfer
+    results = []
+    scheduler = nil
+    outer = Fiber.new do
+      inner = Fiber.new do
+        results << 0
+        sleep 0.02
+        scheduler.transfer
+        results << 4
+      end
+
+      results << 1
+      inner.transfer
+      results << 2
+      inner.transfer
+    end
+
+    scheduler = Fiber.new do
+      outer.transfer while outer.alive?
+    end
+    scheduler.transfer
+
+    assert_equal [1, 0, 2, 4], results
+  end
+
+  def test_base_unowned_no_scheduler_yield
+    results = []
+
+    Fiber.new do
+      inner = Fiber.new do
+        results << 0
+        Fiber.yield
+        results << 4
+      end
+
+      results << 1
+      inner.resume
+      results << 2
+      inner.resume
+    end.resume
+
+    assert_equal [1, 0, 2, 4], results
+  end
+
+  def test_base_unowned_no_scheduler_combine_resume_and_transfer
+    results = []
+    scheduler = nil
+    inner = nil
+    outer = Fiber.new do
+      inner = Fiber.new do
+        results << 0
+        scheduler.transfer(inner)
+        results << 4
+      end
+      results << 1
+      inner.resume
+      results << 2
+    end
+    scheduler = Fiber.new do |fib|
+      fib = fib.transfer while fib
+    end
+    scheduler.transfer(outer)
+
+    assert_equal [1, 0, 4, 2], results
+  end
+
+  def test_base_unowned_no_scheduler_combine_resume_and_transfer_with_scheduler
+    results = []
+    with_scheduler do |scheduler|
+      results = []
+      inner = nil
+      outer = Fiber.new do
+        inner = Fiber.new do
+          results << 0
+          sleep 0.1
+          results << 4
+        end
+        results << 1
+        inner.resume
+        results << 2
+      end
+      outer.transfer
+    end
+
+    assert_equal [1, 0, 2, 4], results
+  end
+
+
+  def test_base_owned_with_scheduler
+    results = []
+    with_scheduler do |scheduler|
+      scheduler = nil
+
+      Fiber.schedule do
+        Fiber.schedule do
+          Fiber.schedule do
+            results << 0
+            sleep 0.01
+            results << 4
+          end
+
+          results << 1
+          sleep 0.03
+          results << 2
+          sleep 0.01
+        end
+      end
+    end
+    assert_equal [0, 1, 4, 2], results
+  end
+
+  def test_nested_owned_fibers
+    results = []
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        Fiber.schedule do
+          results << 0
+          sleep 0.02
+          results << 4
+        end
+
+        Fiber.schedule do
+          results << 1
+          sleep 0.2
+          Fiber.schedule do
+            results << 5
+            sleep 0.2
+            results << 7
+          end
+          results << 6
+        end
+        results << 2
+        sleep 0.01
+        results << 3
+      end
+    end
+    assert_equal [0, 1, 2, 3, 4, 5, 6, 7], results
+  end
+
+  def test_nested_unowned_fibers_with_scheduler
+    results = []
+    out, err = capture_subprocess_io do
+      begin
+        with_scheduler do |scheduler|
+          Fiber.new do
+            fib = Fiber.new do
+              results << 4
+              sleep 0.001
+              results << 5
+              sleep 0.001
+              results << 6
+            end
+
+            Fiber.new do
+              results << 0
+              sleep 0.001
+              Fiber.new do
+                results << 1
+                sleep 0.1
+                results << 8
+              end.transfer
+              results << 2
+            end.resume
+
+            results << 3
+
+            fib.resume
+            sleep 0.01
+            results << 7
+          end.transfer
+        end
+      rescue
+      end
+    end
+    # Transfered fibers are not resumed after yielding out.
+    assert_equal [0, 3, 4, 1, 5, 6], results
+    # assert_match /attempt to yield on a not resumed fiber/, out
+  end
+
+  def test_nested_unowned_fibers_no_scheduler
+    results = []
+    Fiber.new do
+      fib = Fiber.new do
+        results << 5
+        sleep 0.001
+        results << 6
+        sleep 0.001
+        results << 7
+      end
+
+      Fiber.new do
+        results << 0
+        sleep 0.001
+        Fiber.new do
+          results << 1
+          sleep 0.1
+          results << 2
+        end.resume
+        results << 3
+      end.resume
+
+      results << 4
+      fib.resume
+      sleep 0.01
+      results << 8
+    end.transfer
+
+    assert_equal [0, 1, 2, 3, 4, 5, 6, 7, 8], results
+  end
+
+  def test_nested_owned_fibers_resume
+    results = []
+    with_scheduler do |scheduler|
+      Fiber.schedule do
+        fib = Fiber.new do
+          results << 2
+          sleep 0.001
+          results << 5
+          sleep 0.001
+          results << 6
+        end
+
+        Fiber.schedule do
+          results << 0
+          sleep 0.001
+          Fiber.schedule do
+            results << 3
+            sleep 0.1
+            results << 8
+          end
+          results << 4
+        end
+
+        results << 1
+        fib.resume
+        sleep 0.01
+        results << 7
+      end
+    end
+    assert_equal [0, 1, 2, 3, 4, 5, 6, 7, 8], results
+  end
+end

data/gems/scheduler/test/test_network_io.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "socket"
+require "timeout"
+require "debug"
+
+class TestNetworkIO < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_tcp_echo
+    message = "Hello, Itsi!"
+    response = nil
+
+    with_scheduler do |_scheduler|
+      server = TCPServer.new("127.0.0.1", 0)
+      port = server.addr[1]
+
+      # Server fiber: accept one connection and echo data.
+      Fiber.schedule do
+        client = server.accept
+        data = client.read(message.size)
+        client.write(data)
+        client.close
+        server.close
+      end
+
+      # Client fiber: connect, send message, and read echo.
+      Fiber.schedule do
+        client = TCPSocket.new("127.0.0.1", port)
+        client.write(message)
+        response = client.read(message.size)
+        client.close
+      end
+    end
+
+    assert_equal message, response
+  end
+
+  def test_concurrent_tcp_clients
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    messages = %w[first second third fourth]
+    responses = {}
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept several connections.
+      Fiber.schedule do
+        messages.size.times do
+          client = server.accept
+          # Spawn a fiber for each connection to echo the data.
+          Fiber.schedule do
+            data = client.readpartial(1024)
+            client.write(data)
+            client.close
+          end
+        end
+        server.close
+      end
+
+      # Client fibers: connect concurrently and send messages.
+      messages.each do |msg|
+        Fiber.schedule do
+          sleep rand(0.01..0.05) # random delay for interleaving
+          client = TCPSocket.new("127.0.0.1", port)
+          client.write(msg)
+          responses[msg] = client.read(msg.size)
+          client.close
+        end
+      end
+    end
+
+    messages.each do |msg|
+      assert_equal msg, responses[msg]
+    end
+  end
+
+  def test_interleaved_network_and_sleep
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    responses = {}
+
+    with_scheduler do |_scheduler|
+      # Echo server that delays between chunks.
+      Fiber.schedule do
+        client = server.accept
+        data = "".dup
+        # Read in chunks until we have received 12 bytes.
+        while data.size < 12
+          begin
+            chunk = client.readpartial(3)
+          rescue EOFError
+            break
+          end
+          data << chunk
+          sleep 0.02 # delay between chunks
+        end
+        # Echo back the reversed data.
+        client.write(data.reverse)
+        client.close
+        server.close
+      end
+
+      # Client fiber: send data in small chunks.
+      Fiber.schedule do
+        sleep 0.05 # allow server to start
+        client = TCPSocket.new("127.0.0.1", port)
+        "HelloWorld!!".chars.each_slice(3) do |slice|
+          client.write(slice.join)
+          sleep 0.01
+        end
+        responses[:result] = client.read(12)
+        client.close
+      end
+    end
+
+    expected = "HelloWorld!!".reverse[0, 12]
+    assert_equal expected, responses[:result]
+  end
+
+  def test_tcp_timeout
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    result = nil
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept the connection but delay sending.
+      Fiber.schedule do
+        client = server.accept
+        sleep 0.2 # delay long enough to force a timeout on the client
+        client.write("late data")
+        client.close
+        server.close
+      end
+
+      # Client fiber: connect and wait for data with a short timeout.
+      Fiber.schedule do
+        sleep 0.05
+        client = TCPSocket.new("127.0.0.1", port)
+        result = if client.wait_readable(0.1)
+                   client.readpartial(1024)
+                 else
+                   nil
+                 end
+        client.close
+      end
+    end
+
+    # The client should time out (i.e. result remains nil) because the server waits too long.
+    assert_nil result
+  end
+
+  def test_multiple_fibers_on_same_socket
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    results = []
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept a connection and send a short message.
+      Fiber.schedule do
+        client1 = server.accept
+        client2 = server.accept
+        client1.write("network")
+        client2.write("network")
+        client1.close
+        client2.close
+        server.close
+      end
+
+      # Two separate client fibers using separate connections.
+      # (In many schedulers, if two fibers wait on the same IO object,
+      # only one may be resumed when data becomes available.)
+      2.times do |i|
+        Fiber.schedule do
+          sleep 0.001
+          client = TCPSocket.new("127.0.0.1", port)
+          res = client.wait_readable(0.05) ? "readable" : "timeout"
+          results << res
+          client.close
+        end
+      end
+    end
+
+    assert_equal 2, results.size
+    assert_includes results, "readable"
+  end
+
+  def test_two_fibers_only_one_connects
+    server = TCPServer.new("127.0.0.1", 0)
+    port = server.addr[1]
+    results = []
+
+    with_scheduler do |_scheduler|
+      # Server fiber: accept a connection and send a short message.
+      Fiber.schedule do
+        client1 = server.accept
+        client1.write("network")
+        client1.close
+        sleep 0.1
+        server.close
+      end
+
+      # Two separate client fibers using separate connections.
+      # (In many schedulers, if two fibers wait on the same IO object,
+      # only one may be resumed when data becomes available.)
+      2.times do |i|
+        Fiber.schedule do
+          sleep 0.001
+          client = TCPSocket.new("127.0.0.1", port)
+          res = client.wait_readable(0.05) ? "readable" : "timeout"
+          results << res
+          client.close
+        end
+      end
+    end
+
+    assert_equal 2, results.size
+    assert_includes results, "readable"
+    assert_includes results, "timeout"
+  end
+
+  def test_udp_and_tcp_interleaving
+    # Set up a UDP server.
+    udp_server = UDPSocket.new
+    udp_server.bind("127.0.0.1", 0)
+    udp_port = udp_server.addr[1]
+
+    # Set up a TCP server.
+    tcp_server = TCPServer.new("127.0.0.1", 0)
+    tcp_port = tcp_server.addr[1]
+
+    udp_result = nil
+    tcp_result = nil
+
+    with_scheduler do |_scheduler|
+      # UDP server fiber: wait for a datagram.
+      Fiber.schedule do
+        udp_result = udp_server.recvfrom(1024)[0]
+        udp_server.close
+      end
+
+      # TCP server fiber: accept a connection and read data.
+      Fiber.schedule do
+        client = tcp_server.accept
+        tcp_result = client.readpartial(1024)
+        client.close
+        tcp_server.close
+      end
+
+      # UDP client fiber: send a datagram.
+      Fiber.schedule do
+        sleep 0.02
+        udp_client = UDPSocket.new
+        udp_client.send("udp data", 0, "127.0.0.1", udp_port)
+        udp_client.close
+      end
+
+      # TCP client fiber: connect and send data.
+      Fiber.schedule do
+        sleep 0.02
+        client = TCPSocket.new("127.0.0.1", tcp_port)
+        client.write("tcp data")
+        client.close
+      end
+
+      # Additional fiber to interleave a sleep.
+      Fiber.schedule do
+        sleep 0.05
+      end
+    end
+
+    assert_equal "udp data", udp_result
+    assert_equal "tcp data", tcp_result
+  end
+end

data/gems/scheduler/test/test_process_wait.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'debug'
+
+
+class TestProcessWait < Minitest::Test
+  include Itsi::Scheduler::TestHelper
+
+  def test_process_wait
+    start_time = Time.now
+    pids = []
+
+    with_scheduler do |_scheduler|
+      3.times do
+        pids << Process.spawn("sleep 0.25")
+      end
+      3.times do |i|
+        Fiber.schedule do
+          Process.wait(pids[i])
+        end
+      end
+    end
+    end_time = Time.now
+    assert_in_delta(0.25, end_time - start_time, 0.1)
+
+  end
+end