pg_pipeline 0.2.5 → 0.3.1

data/lib/pg_pipeline/request.rb

@@ -255,13 +255,11 @@ module PgPipeline
       req.waiter = waiter
       req.waiter_scheduler = scheduler
 
-      begin
-        scheduler.block(req, nil) until req.settled
-      ensure
-        if req.waiter.equal?(waiter)
-          req.waiter = nil
-          req.waiter_scheduler = nil
-        end
+      scheduler.block(req, nil) until req.settled
+    ensure
+      if waiter && req.waiter.equal?(waiter)
+        req.waiter = nil
+        req.waiter_scheduler = nil
       end
     end
 

data/lib/pg_pipeline/runtime/notification.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module PgPipeline
+  module Runtime
+    class Notification
+      def initialize
+        @waiters = []
+      end
+
+      def wait(timeout = nil)
+        Runtime.with_waiter(self, @waiters) do |waiter|
+          Runtime.with_timeout(timeout) { Runtime.park(self, waiter) { false } }
+          true
+        rescue TimeoutError
+          false
+        end
+      end
+
+      def signal
+        waiter = @waiters.shift or return false
+        Runtime.wake_dequeued(waiter, self)
+        true
+      end
+
+      def signal_all
+        pending, @waiters = @waiters, []
+        pending.each { |waiter| Runtime.wake_dequeued(waiter, self) }
+        nil
+      end
+    end
+  end
+end

data/lib/pg_pipeline/runtime/queue.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module PgPipeline
+  module Runtime
+    class Queue
+      def initialize
+        @queue = ::Thread::Queue.new
+      end
+
+      def enqueue(item)
+        @queue.push(item)
+        item
+      rescue ClosedQueueError
+        nil
+      end
+
+      def dequeue
+        @queue.pop
+      end
+
+      def close
+        @queue.close
+        nil
+      end
+
+      def closed? = @queue.closed?
+      def empty? = @queue.empty?
+      def size = @queue.size
+    end
+  end
+end

data/lib/pg_pipeline/runtime/semaphore.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module PgPipeline
+  module Runtime
+    class Semaphore
+      def initialize(limit)
+        @limit = Integer(limit)
+        raise ArgumentError, "limit must be >= 0" if @limit.negative?
+
+        @available = @limit
+        @waiting = WaitList.new
+      end
+
+      def acquire
+        wait
+        return @available unless block_given?
+
+        begin
+          yield
+        ensure
+          release
+        end
+      end
+
+      def release
+        if (node = @waiting.shift)
+          node.grant!
+          node.resume
+        else
+          @available += 1
+        end
+        @available
+      end
+
+      private
+
+      def wait
+        return (@available -= 1) if @available.positive?
+
+        task = Runtime.current_task
+        node = FiberNode.new(Fiber.current, self)
+        @waiting.push(node)
+        task&.enter_block(node.waiter)
+
+        begin
+          until node.granted?
+            node.suspend
+            abandon_wait!(node, task) if task&.cancelled?
+          end
+          abandon_wait!(node, task) if task&.cancelled?
+        ensure
+          task&.exit_block
+          @waiting.remove(node) unless node.granted? || node.list.nil?
+        end
+      end
+
+      def abandon_wait!(node, task)
+        node.granted? ? release : @waiting.remove(node)
+        task.raise_if_cancelled!
+      end
+
+      class WaitList
+        attr_reader :size
+
+        def initialize
+          @head = @tail = nil
+          @size = 0
+        end
+
+        def first = @head
+        def empty? = @head.nil?
+
+        def push(node)
+          raise ArgumentError, "node already queued" if node.list
+
+          node.list = self
+          node.prev = @tail
+          node.next = nil
+          @tail ? (@tail.next = node) : (@head = node)
+          @tail = node
+          @size += 1
+          node
+        end
+
+        def shift
+          node = @head or return nil
+          remove(node)
+        end
+
+        def remove(node)
+          return nil unless node.list.equal?(self)
+
+          node.prev ? (node.prev.next = node.next) : (@head = node.next)
+          node.next ? (node.next.prev = node.prev) : (@tail = node.prev)
+          node.list = node.prev = node.next = nil
+          @size -= 1
+          node
+        end
+      end
+
+      class FiberNode
+        attr_accessor :list, :prev, :next
+        attr_reader :fiber, :waiter, :blocker
+
+        def initialize(fiber, blocker)
+          @fiber = fiber
+          @blocker = blocker
+          @list = @prev = @next = nil
+          @granted = false
+          @scheduler = Fiber.scheduler
+          @waiter = {fiber: fiber, scheduler: @scheduler, ready: false, blocker: blocker, queued: true}
+        end
+
+        def granted? = @granted
+
+        def grant!
+          @granted = true
+          @waiter[:ready] = true
+          @waiter[:queued] = false
+          self
+        end
+
+        def suspend
+          @scheduler.block(@blocker, nil)
+        end
+
+        def resume
+          fiber = @fiber
+          return unless fiber.alive?
+
+          @scheduler.unblock(@blocker, fiber)
+        end
+      end
+
+      private_constant :WaitList, :FiberNode
+    end
+  end
+end

data/lib/pg_pipeline/runtime/task.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module PgPipeline
+  module Runtime
+    class Task
+      attr_reader :fiber, :name, :error
+
+      def self.spawn(name: nil, &block)
+        raise ArgumentError, "block required" unless block
+
+        task = new(name: name)
+        task.__send__(:start, &block)
+        task
+      end
+
+      def initialize(name: nil)
+        @fiber, @scheduler, @blocker, @result, @error = nil, nil, nil, nil, nil
+        @done, @cancelled = false, false
+
+        @name = name
+        @waiters = []
+      end
+
+      def wait(timeout = nil)
+        Runtime.with_timeout(timeout) { join }
+        raise @error if @error
+
+        @result
+      end
+
+      def stop
+        return false if @done
+
+        @cancelled = true
+
+        return true if interrupt_fiber
+        return true if release_blocker
+
+        false
+      end
+
+      def cancelled? = @cancelled
+
+      def raise_if_cancelled!
+        raise Cancel, "task stopped" if @cancelled
+      end
+
+      def enter_block(waiter)
+        @blocker = waiter
+      end
+
+      def exit_block
+        @blocker = nil
+      end
+
+      def finished? = @done
+
+      private
+
+      def start(&block)
+        @scheduler = Runtime.scheduler!
+        this = self
+
+        scheduled = Fiber.schedule do
+          this.__send__(:adopt_fiber, Fiber.current)
+          Thread.current[Runtime::CURRENT_TASK_KEY] = this
+          begin
+            this.__send__(:complete, block.call, nil)
+          rescue Cancel
+            this.__send__(:complete, nil, nil)
+          rescue Exception => e
+            this.__send__(:complete, nil, e)
+          end
+        end
+
+        @fiber ||= scheduled
+      end
+
+      def adopt_fiber(fiber)
+        @fiber ||= fiber
+      end
+
+      def interrupt_fiber
+        fiber = @fiber
+        scheduler = @scheduler
+        return false unless fiber&.alive?
+        return false unless scheduler&.respond_to?(:fiber_interrupt)
+
+        result = scheduler.fiber_interrupt(fiber, Cancel.new("task stopped"))
+        result != false
+      rescue FiberError
+        false
+      end
+
+      def release_blocker
+        waiter = @blocker or return false
+        Runtime.wake(waiter, waiter[:blocker])
+        waiter[:fiber].alive?
+      end
+
+      def complete(result, error)
+        return if @done
+
+        @result = result
+        @error = error
+        @done = true
+        wake_waiters
+      end
+
+      def join
+        return if @done
+
+        Runtime.with_waiter(self, @waiters) do |waiter|
+          Runtime.park(self, waiter) { @done }
+        end
+      end
+
+      def wake_waiters
+        pending, @waiters = @waiters, []
+        pending.each { |waiter| Runtime.wake_dequeued(waiter, self) }
+      end
+    end
+  end
+end

data/lib/pg_pipeline/runtime.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "timeout"
+
+require_relative "errors"
+
+module PgPipeline
+  module Runtime
+    class Cancel < Exception; end
+    class TimeoutError < Error; end
+
+    module_function
+
+    CURRENT_TASK_KEY = :pg_pipeline_current_task
+    WAITER_KEY = :pg_pipeline_waiter
+
+    def spawn(name: nil, &block)
+      Task.spawn(name: name, &block)
+    end
+
+    def scheduler!
+      Fiber.scheduler or raise Error, "operation requires an active Fiber scheduler"
+    end
+
+    def current_task
+      Thread.current[CURRENT_TASK_KEY]
+    end
+
+    def build_waiter(blocker)
+      waiter = Thread.current[WAITER_KEY] ||= {
+        fiber: nil, scheduler: nil, ready: false, blocker: nil
+      }
+
+      if waiter[:blocker]
+        raise Error, "waiter already parked on #{waiter[:blocker].class}; " \
+                     "a fiber may only park in one place at a time"
+      end
+
+      waiter[:fiber] = Fiber.current
+      waiter[:scheduler] = scheduler!
+      waiter[:ready] = false
+      waiter[:queued] = false
+      waiter[:blocker] = blocker
+      waiter
+    end
+
+    def park(blocker, waiter)
+      scheduler = waiter[:scheduler]
+      task = current_task
+      task&.enter_block(waiter)
+
+      until waiter[:ready] || yield
+        scheduler.block(blocker, nil)
+        task&.raise_if_cancelled!
+      end
+      nil
+    ensure
+      waiter[:blocker] = nil
+      task&.exit_block
+    end
+
+    def with_waiter(blocker, waiters)
+      waiter = build_waiter(blocker)
+      waiter[:queued] = true
+      waiters << waiter
+      yield waiter
+    ensure
+      waiters.delete(waiter) if waiter[:queued]
+    end
+
+    def wake_dequeued(waiter, blocker)
+      waiter[:queued] = false
+      wake(waiter, blocker)
+    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
+
+      ::Timeout.timeout(timeout, TimeoutError) { yield }
+    end
+
+    def wake(waiter, blocker)
+      waiter[:ready] = true
+      fiber = waiter[:fiber]
+      return unless fiber.alive?
+
+      waiter[:scheduler].unblock(blocker, fiber)
+    end
+  end
+end
+
+require_relative "runtime/notification"
+require_relative "runtime/queue"
+require_relative "runtime/semaphore"
+require_relative "runtime/task"

data/lib/pg_pipeline/session_guard.rb

@@ -18,7 +18,6 @@ module PgPipeline
       "select-into-temp" => /\binto\s+(?:(?:global|local)\s+)?temp(?:orary)?\b/i,
       "select-into-pg-temp" => /\binto\s+(?:table\s+)?pg_temp(?:_\d+)?\s*\./i
     }.freeze
-
     STRICT_FORBIDDEN = {
       "nextval" => /\bnextval\s*\(/i,
       "setval" => /\bsetval\s*\(/i,
@@ -28,9 +27,9 @@ module PgPipeline
       "session-advisory-unlock" => /\bpg_advisory_unlock(?:_shared|_all)?\s*\(/i,
       "pg_export_snapshot" => /\bpg_export_snapshot\s*\(/i
     }.freeze
-
     PATTERN_PREFILTER = /\binto\b/i
-    NEEDS_MASK = /['"]|--|\/\*|\$[A-Za-z_0-9]*\$/
+    DOLLAR_QUOTE_TAG = /\A\$(?:(?:[A-Za-z_]|[^\x00-\x7F])(?:[A-Za-z0-9_]|[^\x00-\x7F])*)?\$/
+    NEEDS_MASK = /['"]|--|\/\*|\$(?:(?:[A-Za-z_]|[^\x00-\x7F])(?:[A-Za-z0-9_]|[^\x00-\x7F])*)?\$/
     LEADING_KEYWORD = /\A\s*([a-zA-Z_]+)/
     WHITESPACE_BYTES = [9, 10, 11, 12, 13, 32].freeze
 
@@ -84,7 +83,6 @@ module PgPipeline
       FORBIDDEN_PATTERNS.each do |name, pattern|
         return name if code.match?(pattern)
       end
-
       if mode == :strict
         STRICT_FORBIDDEN.each do |name, pattern|
           return "strict:#{name}" if code.match?(pattern)
@@ -111,7 +109,6 @@ module PgPipeline
       while index < size
         byte = source.getbyte(index)
         nxt = index + 1 < size ? source.getbyte(index + 1) : nil
-
         if block_depth.positive?
           if byte == 47 && nxt == 42
             block_depth += 1
@@ -159,7 +156,7 @@ module PgPipeline
 
         if byte == 36
           remainder = source.byteslice(index, size - index)
-          tag = remainder.match(/\A\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/)&.[](0)
+          tag = DOLLAR_QUOTE_TAG.match(remainder)&.[](0)
           if tag
             closing = source.index(tag, index + tag.bytesize)
             finish = closing ? closing + tag.bytesize : size
@@ -182,7 +179,6 @@ module PgPipeline
 
       while index < source.bytesize
         byte = source.getbyte(index)
-
         if escape_backslash && byte == 92
           output << " "
           index += 1
@@ -203,7 +199,6 @@ module PgPipeline
           index += 1
         end
       end
-
       index
     end
     private_class_method :mask_quoted

data/lib/pg_pipeline/transaction.rb

@@ -39,7 +39,7 @@ module PgPipeline
       tx.__send__(:open=, true)
       begin
         result = yield tx
-        conn.exec("COMMIT")
+        commit(conn)
         tx.__send__(:open=, false)
         result
       rescue Exception
@@ -48,6 +48,28 @@ module PgPipeline
       end
     end
 
+    def commit(conn)
+      conn.exec("COMMIT")
+    rescue PG::Error => error
+      raise unless indeterminate_commit_failure?(conn, error)
+
+      raise IndeterminateCommitError.new(
+        "COMMIT acknowledgement was not received; the transaction may have committed " \
+        "and must not be retried blindly (#{error.class}: #{error.message})"
+      ), cause: error
+    end
+
+    def indeterminate_commit_failure?(conn, error)
+      return true if defined?(PG::ConnectionBad) && error.is_a?(PG::ConnectionBad)
+      return true if conn.finished?
+
+      conn.status != PG::CONNECTION_OK
+    rescue PG::Error
+      true
+    rescue NoMethodError
+      false
+    end
+
     def savepoint(tx, name)
       SessionOps.ensure_active!(tx)
       raise Error, "savepoint requires an open transaction" unless tx.open?
@@ -57,7 +79,6 @@ module PgPipeline
       tx.__send__(:savepoint_seq=, seq)
       point = name || "pgp_sp_#{seq}"
       ident = conn.quote_ident(point)
-
       conn.exec("SAVEPOINT #{ident}")
       begin
         result = yield tx

data/lib/pg_pipeline/version.rb

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

data/lib/pg_pipeline.rb

@@ -2,6 +2,7 @@
 
 require_relative "pg_pipeline/version"
 require_relative "pg_pipeline/errors"
+require_relative "pg_pipeline/runtime"
 require_relative "pg_pipeline/server_caps"
 require_relative "pg_pipeline/session_guard"
 require_relative "pg_pipeline/session"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_pipeline
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.1
 platform: ruby
 authors:
 - Roman Hajdarov
@@ -9,20 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: async
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.42'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.42'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -43,6 +29,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.42'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.42'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -101,10 +101,12 @@ dependencies:
         version: '0.2'
 description: |
   A driver-adjacent Ruby control-plane over ruby-pg/libpq. It multiplexes
-  independent, session-neutral extended-protocol operations from many Async
-  fibers onto a small number of PostgreSQL connections while keeping explicit
+  independent, session-neutral extended-protocol operations from many fibers
+  onto a small number of PostgreSQL connections while keeping explicit
   transactions and session-changing work on exclusive pinned connections.
-  Control-plane only: all wire work stays in libpq. Zero lines of C.
+  Requires any Fiber::Scheduler host (Async::Scheduler, Itsi::Scheduler, …);
+  the gem does not depend on a particular reactor. Control-plane only: all
+  wire work stays in libpq.
 email:
 - romanhajdarov@gmail.com
 executables: []
@@ -123,6 +125,11 @@ files:
 - lib/pg_pipeline/pool.rb
 - lib/pg_pipeline/prepared_statement.rb
 - lib/pg_pipeline/request.rb
+- lib/pg_pipeline/runtime.rb
+- lib/pg_pipeline/runtime/notification.rb
+- lib/pg_pipeline/runtime/queue.rb
+- lib/pg_pipeline/runtime/semaphore.rb
+- lib/pg_pipeline/runtime/task.rb
 - lib/pg_pipeline/server_caps.rb
 - lib/pg_pipeline/session.rb
 - lib/pg_pipeline/session_guard.rb
@@ -152,5 +159,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.7
 specification_version: 4
-summary: Async-native PostgreSQL pipeline multiplexing on top of ruby-pg
+summary: Fiber-scheduler PostgreSQL pipeline multiplexing on top of ruby-pg
 test_files: []