pg_pipeline 0.2.4 → 0.3.0

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.rb

@@ -4,6 +4,8 @@ require_relative "errors"
 
 module PgPipeline
   class Session
+    EMPTY_PARAMS = [].freeze
+
     attr_reader :owner_fiber
 
     def initialize(conn)
@@ -12,10 +14,10 @@ module PgPipeline
       @owner_fiber = Fiber.current
     end
 
-    def query(sql, params = []) = SessionOps.query(self, sql, params)
+    def query(sql, params = EMPTY_PARAMS) = SessionOps.query(self, sql, params)
     def exec(sql, params = nil) = SessionOps.exec(self, sql, params)
     def prepare(name, sql, param_types = nil) = SessionOps.prepare(self, name, sql, param_types)
-    def exec_prepared(name, params = []) = SessionOps.exec_prepared(self, name, params)
+    def exec_prepared(name, params = EMPTY_PARAMS) = SessionOps.exec_prepared(self, name, params)
     def active? = @active
 
     private

data/lib/pg_pipeline/session_guard.rb

@@ -29,6 +29,11 @@ module PgPipeline
       "pg_export_snapshot" => /\bpg_export_snapshot\s*\(/i
     }.freeze
 
+    PATTERN_PREFILTER = /\binto\b/i
+    NEEDS_MASK = /['"]|--|\/\*|\$[A-Za-z_0-9]*\$/
+    LEADING_KEYWORD = /\A\s*([a-zA-Z_]+)/
+    WHITESPACE_BYTES = [9, 10, 11, 12, 13, 32].freeze
+
     def assert_multiplexable!(sql, mode: :default)
       assert_multiplexable_normalized!(sql, mode: normalize_mode!(mode))
     end
@@ -45,6 +50,7 @@ module PgPipeline
     end
 
     GUARD_CACHE_LIMIT = 2048
+    SAFE = :safe
 
     def unsafe_reason(sql, mode: :default)
       unsafe_reason_normalized(sql, mode: normalize_mode!(mode))
@@ -53,11 +59,12 @@ module PgPipeline
     def unsafe_reason_normalized(sql, mode:)
       key = sql.to_s
       cache = guard_cache.fetch(mode)
-      return cache[key] if cache.key?(key)
+      cached = cache[key]
+      return (cached.equal?(SAFE) ? nil : cached) if cached
 
       reason = compute_unsafe_reason(key, mode)
-      cache.clear if cache.size >= GUARD_CACHE_LIMIT
-      cache[key] = reason
+      cache.shift if cache.size >= GUARD_CACHE_LIMIT
+      cache[key] = reason || SAFE
       reason
     end
 
@@ -66,12 +73,13 @@ module PgPipeline
     end
 
     def compute_unsafe_reason(sql, mode)
-      code = code_only(sql)
-      lead = code[/\A\s*([a-zA-Z_]+)/, 1]&.downcase
+      code = NEEDS_MASK.match?(sql) ? code_only(sql) : sql
+      lead = code[LEADING_KEYWORD, 1]&.downcase
 
       return "empty" unless lead
       return "leading:#{lead}" unless ALLOWED_LEADING.include?(lead)
       return "multiple-statements" if multiple_statements?(code)
+      return nil unless code.include?("(") || code.match?(PATTERN_PREFILTER)
 
       FORBIDDEN_PATTERNS.each do |name, pattern|
         return name if code.match?(pattern)
@@ -95,47 +103,50 @@ module PgPipeline
 
     def code_only(sql)
       source = sql.to_s.b
-      output = String.new(capacity: source.bytesize, encoding: Encoding::BINARY)
+      size = source.bytesize
+      output = String.new(capacity: size, encoding: Encoding::BINARY)
       index = 0
       block_depth = 0
 
-      while index < source.bytesize
+      while index < size
+        byte = source.getbyte(index)
+        nxt = index + 1 < size ? source.getbyte(index + 1) : nil
+
         if block_depth.positive?
-          if source.byteslice(index, 2) == "/*"
+          if byte == 47 && nxt == 42
             block_depth += 1
             output << "  "
             index += 2
-          elsif source.byteslice(index, 2) == "*/"
+          elsif byte == 42 && nxt == 47
             block_depth -= 1
             output << "  "
             index += 2
           else
-            output << (source.getbyte(index) == 10 ? "\n" : " ")
+            output << (byte == 10 ? 10 : 32)
             index += 1
           end
           next
         end
 
-        if source.byteslice(index, 2) == "--"
+        if byte == 45 && nxt == 45
           newline = source.index("\n", index + 2)
           if newline
-            output << " " * (newline - index) << "\n"
+            output << (" " * (newline - index)) << "\n"
             index = newline + 1
           else
-            output << " " * (source.bytesize - index)
+            output << (" " * (size - index))
             break
           end
           next
         end
 
-        if source.byteslice(index, 2) == "/*"
+        if byte == 47 && nxt == 42
           block_depth = 1
           output << "  "
           index += 2
           next
         end
 
-        byte = source.getbyte(index)
         if byte == 39
           index = mask_quoted(source, output, index, 39, escape_backslash: escape_string_prefix?(source, index))
           next
@@ -147,18 +158,18 @@ module PgPipeline
         end
 
         if byte == 36
-          remainder = source.byteslice(index, source.bytesize - index)
+          remainder = source.byteslice(index, size - index)
           tag = remainder.match(/\A\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/)&.[](0)
           if tag
             closing = source.index(tag, index + tag.bytesize)
-            finish = closing ? closing + tag.bytesize : source.bytesize
-            output << " " * (finish - index)
+            finish = closing ? closing + tag.bytesize : size
+            output << (" " * (finish - index))
             index = finish
             next
           end
         end
 
-        output << source.getbyte(index)
+        output << byte
         index += 1
       end
 
@@ -209,12 +220,17 @@ module PgPipeline
     private_class_method :escape_string_prefix?
 
     def multiple_statements?(code)
-      semicolons = []
-      code.each_char.with_index { |char, i| semicolons << i if char == ";" }
-      return false if semicolons.empty?
+      first = code.index(";")
+      return false unless first
+
+      index = first + 1
+      size = code.bytesize
+      while index < size
+        return true unless WHITESPACE_BYTES.include?(code.getbyte(index))
 
-      last_non_space = code.rstrip.length - 1
-      semicolons.length > 1 || semicolons.first != last_non_space
+        index += 1
+      end
+      false
     end
   end
 end

data/lib/pg_pipeline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PgPipeline
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 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.4
+  version: 0.3.0
 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: []