pg_pipeline 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca8a6402d9ee49ae0393f519c135f4174248df64aa27332f0773e095eb3179c8
-  data.tar.gz: 3c01ed0c9be6950a3b4d264bc613e5fef94c56dc81cb8916c791902ffeac61b0
+  metadata.gz: c7fdda2e5d806be070a3255e8cef4a63b72acaeac87d7a7777d580bfb0fc0d0a
+  data.tar.gz: 2b23bf8808241eb64396672959a86ae86c26af05bb0d72049de646907cc9e99d
 SHA512:
-  metadata.gz: dc55189c229e3958e40781e30577ac82c3645f70fa55c2bce894baf9e0a423caa67d3ba533f77d5fce627943b424e0c7de2cea5f99a2ea25b0903022f438b3df
-  data.tar.gz: 508c35a99f8a9f5f3fa3665b741adaf58f593b6cc6c95fbfb86b48ded121adb010d4203fce6d9063274e510171e9f401ed0295b8691f2211ce273395cd7dcb9d
+  metadata.gz: 37a5b065506fb61a675a72023057b0d24254ea7fa411ea358c68e255e0ffabf53079ab3a7214be59b2d09b02063aa2c09875576868a213df8c91526f90834ebd
+  data.tar.gz: fb0e3b15f73e8de66b56d09c7791b8e357477c859b83293474ec48c15d41d12298f91c974bd8ebeb0ae2cc6a3437ed598c442e6eb26e8a13787e71a3d35856f7

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [0.3.2] - 2026-08-17
+
+Runtime correctness. Public SQL, Sync-per-unit, failure model, and the
+`Fiber::Scheduler` host contract are unchanged.
+
+### Fixed
+
+- Bounded waits (`Notification#wait`, `Task#wait`) park through
+  `scheduler.block(blocker, remaining)` and a monotonic deadline. They no
+  longer wrap `park` in `Timeout.timeout`. A wait timeout is not a work
+  timeout: `Notification#wait` no longer rescues `TimeoutError`, so an
+  enclosing `Runtime.with_timeout` cannot be swallowed by
+  `BoundedQueue#wait_on` or `wait_for_pinned_idle`. `wait(0)` polls.
+- `Runtime.with_timeout` (health probes and other work limits) calls
+  `scheduler.timeout_after(duration, Deadline, message)` when the hook
+  exists. `Deadline < Exception`, so `rescue => e` cannot eat it; the
+  method still raises `Runtime::TimeoutError` at its own boundary. A
+  scheduler without the hook falls back to stdlib `Timeout` and warns
+  once — `Thread#raise` can hit the wrong fiber.
+- `Notification#signal` and `Semaphore#release` skip a waiter that
+  `Task#stop` already released, or a fiber that is no longer alive. On a
+  deferred `unblock` the previous `shift` + wake handed the signal to the
+  stopped waiter and left the live one parked; a dead semaphore waiter
+  burned a pinned-pool slot. `park` also raises `Cancel` after a stop-wake
+  so the wait is not mistaken for a successful signal.
+
+### Unchanged
+
+- Per-fiber waiter-hash reuse, `Request` one-shot completion, watcher
+  `fiber_interrupt` / poll shutdown, and the host-installed scheduler
+  rule.
+
 ## [0.3.1] - 2026-08-09
 
 Reliability and correctness fixes on top of 0.3.0. No public API changes other

data/lib/pg_pipeline/runtime/notification.rb

@@ -7,19 +7,24 @@ module PgPipeline
         @waiters = []
       end
 
+      def waiting = @waiters.size
+
       def wait(timeout = nil)
+        wait_until(Runtime.deadline_for(timeout))
+      end
+
+      def wait_until(deadline = nil)
         Runtime.with_waiter(self, @waiters) do |waiter|
-          Runtime.with_timeout(timeout) { Runtime.park(self, waiter) { false } }
-          true
-        rescue TimeoutError
-          false
+          Runtime.park(self, waiter, deadline) { false }
         end
       end
 
       def signal
-        waiter = @waiters.shift or return false
-        Runtime.wake_dequeued(waiter, self)
-        true
+        while (waiter = @waiters.shift)
+          return true if Runtime.wake_dequeued(waiter, self)
+        end
+
+        false
       end
 
       def signal_all

data/lib/pg_pipeline/runtime/semaphore.rb

@@ -23,12 +23,12 @@ module PgPipeline
       end
 
       def release
-        if (node = @waiting.shift)
+        while (node = @waiting.shift)
           node.grant!
-          node.resume
-        else
-          @available += 1
+          return @available if node.resume
         end
+
+        @available += 1
         @available
       end
 
@@ -126,9 +126,10 @@ module PgPipeline
 
         def resume
           fiber = @fiber
-          return unless fiber.alive?
+          return false unless fiber.alive?
 
           @scheduler.unblock(@blocker, fiber)
+          true
         end
       end
 

data/lib/pg_pipeline/runtime/task.rb

@@ -22,7 +22,10 @@ module PgPipeline
       end
 
       def wait(timeout = nil)
-        Runtime.with_timeout(timeout) { join }
+        unless @done
+          deadline = Runtime.deadline_for(timeout)
+          raise TimeoutError, "task did not finish in time" unless join(deadline)
+        end
         raise @error if @error
 
         @result
@@ -94,8 +97,8 @@ module PgPipeline
 
       def release_blocker
         waiter = @blocker or return false
-        Runtime.wake(waiter, waiter[:blocker])
-        waiter[:fiber].alive?
+
+        Runtime.wake(waiter, waiter[:blocker]) && waiter[:fiber].alive?
       end
 
       def complete(result, error)
@@ -107,11 +110,11 @@ module PgPipeline
         wake_waiters
       end
 
-      def join
-        return if @done
+      def join(deadline)
+        return true if @done
 
         Runtime.with_waiter(self, @waiters) do |waiter|
-          Runtime.park(self, waiter) { @done }
+          Runtime.park(self, waiter, deadline) { @done }
         end
       end
 

data/lib/pg_pipeline/runtime.rb

@@ -7,12 +7,25 @@ require_relative "errors"
 module PgPipeline
   module Runtime
     class Cancel < Exception; end
+    class Deadline < Exception; end
     class TimeoutError < Error; end
 
     module_function
 
     CURRENT_TASK_KEY = :pg_pipeline_current_task
     WAITER_KEY = :pg_pipeline_waiter
+    DEADLINE_MESSAGE = "execution expired"
+
+    MISSING_TIMEOUT_HOOK_WARNING = <<~MESSAGE
+      pg_pipeline: %s does not implement #timeout_after.
+
+      Falling back to stdlib Timeout, which uses Thread#raise and can deliver
+      the timeout to an unrelated fiber. Use a scheduler that implements
+      #timeout_after (async, itsi-scheduler) or avoid Runtime.with_timeout
+      on this host.
+    MESSAGE
+
+    @warned_schedulers = {}
 
     def spawn(name: nil, &block)
       Task.spawn(name: name, &block)
@@ -22,6 +35,10 @@ module PgPipeline
       Fiber.scheduler or raise Error, "operation requires an active Fiber scheduler"
     end
 
+    def native_timeouts?(target = Fiber.scheduler)
+      !target.nil? && target.respond_to?(:timeout_after)
+    end
+
     def current_task
       Thread.current[CURRENT_TASK_KEY]
     end
@@ -44,16 +61,20 @@ module PgPipeline
       waiter
     end
 
-    def park(blocker, waiter)
+    def park(blocker, waiter, deadline = nil)
       scheduler = waiter[:scheduler]
       task = current_task
       task&.enter_block(waiter)
 
       until waiter[:ready] || yield
-        scheduler.block(blocker, nil)
+        remaining = deadline ? (deadline - monotonic_now) : nil
+        return false if deadline && remaining <= 0
+
+        scheduler.block(blocker, remaining)
         task&.raise_if_cancelled!
       end
-      nil
+      task&.raise_if_cancelled!
+      true
     ensure
       waiter[:blocker] = nil
       task&.exit_block
@@ -65,7 +86,10 @@ module PgPipeline
       waiters << waiter
       yield waiter
     ensure
-      waiters.delete(waiter) if waiter[:queued]
+      if waiter[:queued]
+        waiters.delete(waiter)
+        waiter[:queued] = false
+      end
     end
 
     def wake_dequeued(waiter, blocker)
@@ -73,21 +97,59 @@ module PgPipeline
       wake(waiter, blocker)
     end
 
+    def wake(waiter, blocker)
+      return false if waiter[:ready]
+
+      waiter[:ready] = true
+      fiber = waiter[:fiber]
+      return false unless fiber.alive?
+
+      waiter[:scheduler].unblock(blocker, fiber)
+      true
+    end
+
+    def monotonic_now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def deadline_for(timeout)
+      return nil if timeout.nil?
+
+      seconds = Float(timeout)
+      raise ArgumentError, "timeout must be non-negative and finite" unless seconds.finite? && seconds >= 0
+
+      monotonic_now + seconds
+    end
+
     def with_timeout(duration)
       return yield if duration.nil?
 
-      timeout = Float(duration)
-      raise ArgumentError, "timeout must be non-negative and finite" unless timeout.finite? && timeout >= 0
+      seconds = Float(duration)
+      raise ArgumentError, "timeout must be non-negative and finite" unless seconds.finite? && seconds >= 0
 
-      ::Timeout.timeout(timeout, TimeoutError) { yield }
+      begin
+        arm_deadline(seconds) { yield }
+      rescue Deadline => e
+        raise TimeoutError, e.message
+      end
     end
 
-    def wake(waiter, blocker)
-      waiter[:ready] = true
-      fiber = waiter[:fiber]
-      return unless fiber.alive?
+    def arm_deadline(seconds, &block)
+      target = Fiber.scheduler
+      if native_timeouts?(target)
+        return target.timeout_after(seconds, Deadline, DEADLINE_MESSAGE, &block)
+      end
 
-      waiter[:scheduler].unblock(blocker, fiber)
+      warn_missing_timeout_hook(target) if target
+      ::Timeout.timeout(seconds, Deadline, DEADLINE_MESSAGE, &block)
+    end
+
+    def warn_missing_timeout_hook(target)
+      key = target.class
+      return if @warned_schedulers[key]
+
+      @warned_schedulers[key] = true
+      warn(format(MISSING_TIMEOUT_HOOK_WARNING, key))
     end
   end
 end

data/lib/pg_pipeline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgPipeline
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Roman Hajdarov