ori-rb 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cf224a1d5d0199cc58e2a4949a29f86ee513fcedb3abebd505c493c3e9287768
-  data.tar.gz: 9c2ff8e9fb423ee3e541397ca67172d7940d9f8025ae8c4c1b90b92cf988fd13
+  metadata.gz: dd8326ee1d0ef86eff23c6b472b82ee72d2253e41d1367f053aeb878ed926320
+  data.tar.gz: 02b872fdd48ef913857e022f9333f5a447c59493a2dd5ccdbccee5486c479d0d
 SHA512:
-  metadata.gz: 69ffdacdf5521d68c5106110ee13a69bc86c06a4aed4f461dd1e7c3809580873c5400ea5029ad03bca22504016463f4933a1ce229a27631c5a455ffc6b7bba83
-  data.tar.gz: 5fa8eeadf0a5948e85df6cfd2e1fd705ce3a87647856c08bc20dade18722e93d5a03a142b291f8184081a3a30b18e4891d3ae7961737e7d72c87b5e13330b8ad
+  metadata.gz: 102ff1557da066713c20b08e87f29e01fff6c07978c9a384d657df6dfb2bfc4f6e95edb0f966e58b68ff44b4430232a95d23be846bba66838848792e8f3dcd86
+  data.tar.gz: 76e6f9e1e3ed9d2dfbf8078325560a4ca40dcc770c5a2ba6ec16e58ed3809203e18a15d859ead27d236f0d9439a342326b64fe31edf81ff426e1b85926ed5107

data/.ruby-version

@@ -1 +1 @@
-3.4.7
+4.0.1

data/lib/ori/lazy.rb

@@ -1,4 +1,5 @@
 # typed: true
+# frozen_string_literal: true
 
 module Ori
   class Lazy

data/lib/ori/scope.rb

@@ -1,8 +1,11 @@
 # typed: true
+# frozen_string_literal: true
 
 require "nio"
+require "io/nonblock"
 require "random/formatter"
 require "ori/lazy"
+require "English"
 
 module Ori
   class Scope
@@ -51,6 +54,11 @@ module Ori
       @cancelled = false
       @closed = false
 
+      # Cross-thread wakeup mechanism for unblock
+      @wakeup_mutex = ::Mutex.new
+      @wakeup_queue = [] #: Array[Fiber]
+      @wakeup_reader, @wakeup_writer = IO.pipe
+
       # Instead, use thread-local storage
       thread_local_state[object_id] = ThreadLocalState.new
 
@@ -228,19 +236,102 @@ module Ori
     end
 
     def unblock(blocker, fiber)
-      unless fiber_ids.key?(Fiber.current)
+      unless fiber_ids.key?(fiber)
         return @parent_scope.unblock(blocker, fiber) if @parent_scope
       end
 
-      resume_fiber(fiber)
+      # Thread-safe: enqueue the fiber and signal the event loop
+      # via the wakeup pipe. unblock may be called from any thread.
+      @wakeup_mutex.synchronize { @wakeup_queue << fiber }
+      @wakeup_writer.write_nonblock(".") rescue nil # rubocop:disable Style/RescueModifier
+    end
+
+    def io_read(io, buffer, length, offset)
+      return @parent_scope.io_read(io, buffer, length, offset) unless fiber_ids.key?(Fiber.current)
+
+      io.nonblock = true unless io.closed?
+      total = 0 #: Integer
+
+      loop do
+        maximum_size = buffer.size - offset - total
+        break if maximum_size <= 0
+
+        case result = Fiber.blocking { io.read_nonblock(maximum_size, exception: false) }
+        when :wait_readable
+          break if total > 0
+
+          io_wait(io, IO::READABLE)
+        when nil # EOF
+          break
+        else
+          buffer.set_string(result, offset + total)
+          total += result.bytesize
+          break if length == 0 || total >= length
+        end
+      end
+
+      total
+    rescue SystemCallError => e
+      (total || 0) > 0 ? total : -(e.errno || 0)
+    end
+
+    def io_write(io, buffer, length, offset)
+      return @parent_scope.io_write(io, buffer, length, offset) unless fiber_ids.key?(Fiber.current)
+
+      io.nonblock = true unless io.closed?
+      total = 0 #: Integer
+      max_bytes = buffer.size - offset
+
+      while total < max_bytes
+        chunk = buffer.get_string(offset + total, max_bytes - total)
+        case result = Fiber.blocking { io.write_nonblock(chunk, exception: false) }
+        when :wait_writable
+          io_wait(io, IO::WRITABLE)
+        else
+          total += result
+        end
+      end
+
+      total
+    rescue SystemCallError => e
+      (total || 0) > 0 ? total : -(e.errno || 0)
     end
 
-    # def io_write(...) = ()
     # def io_pread(...) = ()
     # def io_pwrite(...) = ()
 
+    def process_wait(pid, flags)
+      return @parent_scope.process_wait(pid, flags) unless fiber_ids.key?(Fiber.current)
+
+      fiber = Fiber.current
+      id = fiber_ids[fiber]
+      @tracer&.record(id, :waiting_process, "pid=#{pid}")
+
+      # Bridge thread-based process waiting into the IO event loop.
+      # A pipe signals completion; the thread closes its end when done.
+      reader, writer = IO.pipe
+
+      thread = Thread.new(writer) do |w|
+        ::Process.wait(pid, flags)
+        $CHILD_STATUS # return the Process::Status
+      ensure
+        w.syswrite(".") rescue nil # rubocop:disable Style/RescueModifier
+        w.close rescue nil # rubocop:disable Style/RescueModifier
+      end
+
+      # Register directly on the event loop's readable set
+      readable[reader].add(fiber)
+      Fiber.yield
+
+      thread.value
+    ensure
+      readable[reader]&.delete(fiber) if reader
+      readable.delete(reader) if reader && readable[reader]&.empty?
+      reader&.close unless reader&.closed?
+      writer&.close unless writer&.closed?
+    end
+
     # TODO: Implement these
-    # def process_wait(...) = ()
     # def timeout_after(...) = ()
     # def address_resolve(...) = ()
 
@@ -262,6 +353,7 @@ module Ori
     def pending_work?
       return false if closed?
 
+      return true if @wakeup_mutex.synchronize { @wakeup_queue.any? }
       return true if pending.any?(&:alive?)
       return true if waiting.any? { |fiber, _| fiber.alive? }
       return true if blocked.any? { |fiber, _| fiber.alive? }
@@ -362,9 +454,24 @@ module Ori
     end
 
     def process_io_operations(now = nil)
-      return if readable.none? && writable.none?
+      has_io = readable.any? || writable.any?
+      has_wakeup = @wakeup_mutex.synchronize { @wakeup_queue.any? }
+
+      # Process any already-queued wakeups before selecting
+      drain_wakeup_queue if has_wakeup
+
+      return unless has_io
 
-      readable_out, writable_out = IO.select(readable.keys, writable.keys, [], next_timeout(now))
+      select_readable = readable.keys
+      select_readable << @wakeup_reader
+
+      readable_out, writable_out = IO.select(select_readable, writable.keys, [], next_timeout(now))
+
+      # Drain wakeup pipe if signaled
+      if readable_out&.delete(@wakeup_reader)
+        @wakeup_reader.read_nonblock(256) rescue nil # rubocop:disable Style/RescueModifier
+        drain_wakeup_queue
+      end
 
       process_ready_io(readable_out, readable)
       process_ready_io(writable_out, writable)
@@ -378,10 +485,17 @@ module Ori
       end
     end
 
+    def drain_wakeup_queue
+      fibers = @wakeup_mutex.synchronize { @wakeup_queue.shift(@wakeup_queue.size) }
+      fibers.each { |fiber| resume_fiber(fiber) if fiber.alive? }
+    end
+
     def close_scope
       @closed = true
       @tracer&.record_scope(@scope_id, :closed)
       thread_local_state&.delete(object_id)
+      @wakeup_reader&.close unless @wakeup_reader&.closed?
+      @wakeup_writer&.close unless @wakeup_writer&.closed?
     end
 
     # Timeouts and deadlines
@@ -428,7 +542,7 @@ module Ori
     end
 
     def next_timeout(now = nil)
-      timeouts = T.let([], T::Array[Numeric])
+      timeouts = [] #: Array[Numeric]
       timeouts.concat(waiting.values.compact) unless waiting.empty?
       timeouts << @deadline_at if @deadline_at
 

data/lib/ori/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module Ori
-  VERSION = "0.4.2"
+  VERSION = "0.4.4"
 end

data/mise.toml

@@ -1,5 +1,5 @@
 [tools]
-ruby = "3.4.7"
+ruby = "4.0.1"
 usage = "latest"
 watchexec = "latest"
 

data/sorbet/shims/fiber.rbi

@@ -11,6 +11,13 @@ class Fiber
 
     sig { returns(T.untyped) }
     def current_scheduler; end
+
+    sig do
+      type_parameters(:T)
+        .params(block: T.proc.returns(T.type_parameter(:T)))
+        .returns(T.type_parameter(:T))
+    end
+    def blocking(&block); end
   end
 
   sig { params(block: T.proc.void).void }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ori-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Jahfer Husain
@@ -152,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: A library for building concurrent applications.
 test_files: []