em-pg-client-12 0.3.4

data/lib/pg/em/client/connect_watcher.rb

@@ -0,0 +1,89 @@
+module PG
+  module EM
+    class Client < PG::Connection
+
+      # This module is used as a handler to ::EM.watch connection socket and
+      # it performs connection handshake with postgres server asynchronously.
+      #
+      # Author:: Rafal Michalski
+      module ConnectWatcher
+
+        def initialize(client, deferrable, is_reset)
+          @client = client
+          @deferrable = deferrable
+          @is_reset = is_reset
+          @poll_method = is_reset ? :reset_poll : :connect_poll
+          if (timeout = client.connect_timeout) > 0
+            @timer = ::EM::Timer.new(timeout) do
+              detach
+              @deferrable.protect do
+                @client.raise_error ConnectionBad, "timeout expired (async)"
+              end
+            end
+          end
+        end
+
+        def reconnecting?
+          @is_reset
+        end
+
+        def poll_connection_and_check
+          case @client.__send__(@poll_method)
+          when PG::PGRES_POLLING_READING
+            self.notify_readable = true
+            self.notify_writable = false
+            return
+          when PG::PGRES_POLLING_WRITING
+            self.notify_writable = true
+            self.notify_readable = false
+            return
+          when PG::PGRES_POLLING_OK
+            polling_ok = true if @client.status == PG::CONNECTION_OK
+          end
+          @timer.cancel if @timer
+          detach
+          @deferrable.protect do
+            @client.raise_error ConnectionBad unless polling_ok
+            @client.set_default_encoding unless reconnecting?
+            if on_connect = @client.on_connect
+              succeed_connection_with_hook(on_connect)
+            else
+              succeed_connection
+            end
+          end
+        end
+
+        def succeed_connection
+          ::EM.next_tick { @deferrable.succeed @client }
+        end
+
+        def succeed_connection_with_hook(on_connect)
+          ::EM.next_tick do
+            Fiber.new do
+              # call on_connect handler and fail if it raises an error
+              begin
+                returned_df = on_connect.call(@client, true, reconnecting?)
+              rescue => ex
+                @deferrable.fail ex
+              else
+                if returned_df.respond_to?(:callback) && returned_df.respond_to?(:errback)
+                  # the handler returned a deferrable
+                  returned_df.callback { @deferrable.succeed @client }
+                  # fail when handler's deferrable fails
+                  returned_df.errback { |ex| @deferrable.fail ex }
+                else
+                  @deferrable.succeed @client
+                end
+              end
+            end.resume
+          end
+        end
+
+        alias_method :notify_writable, :poll_connection_and_check
+        alias_method :notify_readable, :poll_connection_and_check
+
+      end
+
+    end
+  end
+end

data/lib/pg/em/client/watcher.rb

@@ -0,0 +1,204 @@
+module PG
+  module EM
+    class Client < PG::Connection
+
+      # This module is used as a handler to ::EM.watch connection socket and
+      # it extracts query results in a non-blocking manner.
+      #
+      # Author:: Rafal Michalski
+      module Watcher
+
+        def initialize(client)
+          @client = client
+          @is_connected = true
+          @one_result_mode = false
+          @deferrable = nil
+          @notify_deferrable = nil
+          @timer = nil
+          @notify_timer = nil
+        end
+
+        def watching?
+          @is_connected
+        end
+
+        def one_result_mode?
+          @one_result_mode
+        end
+
+        def watch_results(deferrable, send_proc = nil, one_result_mode = false)
+          @one_result_mode = one_result_mode
+          @last_result = nil
+          @deferrable = deferrable
+          @send_proc = send_proc
+          cancel_timer
+          self.notify_readable = true unless notify_readable?
+          if (timeout = @client.query_timeout) > 0
+            @readable_timestamp = Time.now
+            setup_timer timeout
+          end
+          fetch_results
+        end
+
+        def watch_notify(deferrable, timeout = nil)
+          notify_df = @notify_deferrable
+          @notify_deferrable = deferrable
+          cancel_notify_timer
+          self.notify_readable = true unless notify_readable?
+          if timeout
+            @notify_timer = ::EM::Timer.new(timeout) do
+              @notify_timer = nil
+              succeed_notify
+            end
+          end
+          notify_df.fail nil if notify_df
+          check_notify
+        end
+
+        def setup_timer(timeout, adjustment = 0)
+          @timer = ::EM::Timer.new(timeout - adjustment) do
+            if (last_interval = Time.now - @readable_timestamp) >= timeout
+              @timer = nil
+              cancel_notify_timer
+              self.notify_readable = false
+              @client.async_command_aborted = true
+              @send_proc = nil
+              begin
+                @client.raise_error ConnectionBad, "query timeout expired (async)"
+              rescue Exception => e
+                fail_result e
+                # notify should also fail: query timeout is like connection error
+                fail_notify e
+              end
+            else
+              setup_timer timeout, last_interval
+            end
+          end
+        end
+
+        def cancel_notify_timer
+          if @notify_timer
+            @notify_timer.cancel
+            @notify_timer = nil
+          end
+        end
+
+        def cancel_timer
+          if @timer
+            @timer.cancel
+            @timer = nil
+          end
+        end
+
+        def notify_readable
+          @client.consume_input
+        rescue Exception => e
+          handle_error e
+        else
+          fetch_results if @deferrable
+          check_notify if @notify_deferrable
+        end
+
+        def check_notify
+          if notify_hash = @client.notifies
+            cancel_notify_timer
+            succeed_notify notify_hash
+          end
+        end
+
+        # Carefully extract results without
+        # blocking the EventMachine reactor.
+        def fetch_results
+          result = false
+          until @client.is_busy
+            single_result = @client.blocking_get_result
+            if one_result_mode?
+              result = single_result
+              break
+            elsif single_result.nil?
+              if result = @last_result
+                result.check
+              end
+              break
+            end
+            @last_result.clear if @last_result
+            @last_result = single_result
+          end
+        rescue Exception => e
+          handle_error e
+        else
+          if result == false
+            @readable_timestamp = Time.now if @timer
+          else
+            cancel_timer
+            self.notify_readable = false unless @notify_deferrable
+            df = @deferrable
+            @deferrable = @send_proc = nil
+            df.succeed result
+          end
+        end
+
+        def unbind
+          @is_connected = false
+          cancel_timer
+          cancel_notify_timer
+          if @deferrable || @notify_deferrable
+            @client.raise_error ConnectionBad, "connection reset"
+          end
+        rescue Exception => e
+          fail_result e
+          fail_notify e
+        end
+
+        private
+
+        def fail_result(e)
+          df = @deferrable
+          @deferrable = nil
+          df.fail e if df
+        end
+
+        def succeed_notify(notify_hash = nil)
+          self.notify_readable = false unless @deferrable
+          df = @notify_deferrable
+          @notify_deferrable = nil
+          df.succeed notify_hash
+        end
+
+        def fail_notify(e)
+          df = @notify_deferrable
+          @notify_deferrable = nil
+          df.fail e if df
+        end
+
+        def handle_error(e)
+          cancel_timer
+          send_proc = @send_proc
+          @send_proc = nil
+          df = @deferrable || FeaturedDeferrable.new
+          # prevent unbind error on auto re-connect
+          @deferrable = nil
+          notify_df = @notify_deferrable
+          self.notify_readable = false unless notify_df
+          if e.is_a?(PG::Error)
+            @client.async_autoreconnect!(df, e, send_proc) do
+              # there was a connection error so stop any remaining activity
+              if notify_df
+                @notify_deferrable = nil
+                cancel_notify_timer
+                self.notify_readable = false
+                # fail notify_df after deferrable completes
+                # handler might setup listen again then immediately
+                df.completion { notify_df.fail e }
+              end
+            end
+          else
+            df.fail e
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/pg/em/connection_pool.rb

@@ -0,0 +1,480 @@
+require 'pg/em'
+
+module PG
+  module EM
+
+    # Connection pool for PG::EM::Client
+    #
+    # Author:: Rafal Michalski
+    #
+    # The ConnectionPool allocates new connections asynchronously when
+    # there are no free connections left up to the {#max_size} number.
+    #
+    # If {Client#async_autoreconnect} option is not set or the re-connect fails
+    # the failed connection is dropped from the pool.
+    #
+    # @example Basic usage
+    #   pg = PG::EM::ConnectionPool.new size: 10, dbname: 'foo'
+    #   res = pg.query 'select * from bar'
+    #
+    # The list of {Client} command methods that are available in {ConnectionPool}:
+    #
+    # Fiber synchronized methods:
+    #
+    # * {Client#exec}
+    # * {Client#query}
+    # * {Client#async_exec}
+    # * {Client#async_query}
+    # * {Client#exec_params}
+    # * {Client#exec_prepared}
+    # * {Client#prepare}
+    # * {Client#describe_prepared}
+    # * {Client#describe_portal}
+    #
+    # The asynchronous command methods:
+    #
+    # * {Client#exec_defer}
+    # * {Client#query_defer}
+    # * {Client#async_exec_defer}
+    # * {Client#async_query_defer}
+    # * {Client#exec_params_defer}
+    # * {Client#exec_prepared_defer}
+    # * {Client#prepare_defer}
+    # * {Client#describe_prepared_defer}
+    # * {Client#describe_portal_defer}
+    #
+    # The pool will only allow for {#max_size} commands (both deferred and
+    # fiber synchronized) to be performed concurrently. The pending requests
+    # will be queued and executed when connections become available.
+    #
+    # Please keep in mind, that the above methods may send commands to
+    # different clients from the pool each time they are called. You can't
+    # assume anything about which connection is acquired even if the
+    # {#max_size} of the pool is set to one. This is because no connection
+    # will be shared between two concurrent requests and the connections
+    # maight occasionally fail and they will be dropped from the pool.
+    #
+    # This prevents the `*_defer` commands to execute transactions.
+    #
+    # For transactions use {#transaction} and fiber synchronized methods.
+    class ConnectionPool
+
+      DEFAULT_SIZE = 4
+
+      # Maximum number of connections in the connection pool
+      # @return [Integer]
+      attr_reader :max_size
+
+      attr_reader :available, :allocated
+
+      # Creates and initializes a new connection pool.
+      #
+      # The connection pool allocates its first connection upon initialization
+      # unless +lazy: true+ option is given.
+      #
+      # Pass PG::EM::Client +options+ together with ConnectionPool +options+:
+      #
+      # - +:size+ = +4+ - the maximum number of concurrent connections
+      # - +:lazy+ = false - should lazy allocate first connection
+      # - +:connection_class+ = {PG::EM::Client}
+      #
+      # For convenience the given block will be set as the +on_connect+ option.
+      #
+      # @yieldparam pg [Client] connected client instance on each newly
+      #                         created connection
+      # @yieldparam is_async [Boolean] always +true+ in a connection pool
+      #                      context
+      # @yieldparam is_reset [Boolean] always +false+ unless
+      #                      +async_autoreconnect+ options is +true+ and
+      #                      was actually re-connecting
+      #
+      # @raise [PG::Error]
+      # @raise [ArgumentError]
+      # @see Client#on_connect
+      def initialize(options = {}, &on_connect)
+        @available = []
+        @pending = []
+        @allocated = {}
+        @max_size = DEFAULT_SIZE
+        @connection_class = Client
+
+        if block_given?
+          options = {on_connect: on_connect}.merge(options)
+        end
+
+        lazy = false
+        @options = options.reject do |key, value|
+          case key.to_sym
+          when :size, :max_size
+            @max_size = value.to_i
+            true
+          when :connection_class
+            @connection_class = value
+            true
+          when :lazy
+            lazy = value
+            true
+          end
+        end
+
+        raise ArgumentError, "#{self.class}.new: pool size must be >= 1" if @max_size < 1
+
+        # allocate first connection, unless we are lazy
+        hold unless lazy
+      end
+
+      # Creates and initializes new connection pool.
+      #
+      # Attempts to establish the first connection asynchronously.
+      #
+      # @return [FeaturedDeferrable]
+      # @yieldparam pg [Client|PG::Error] new and connected client instance
+      #             on success or a raised PG::Error
+      #
+      # Use the returned deferrable's +callback+ hook to obtain newly created
+      # {ConnectionPool}.
+      # In case of a connection error +errback+ hook is called with
+      # a raised error object as its argument.
+      #
+      # If the block is provided it's bound to both +callback+ and +errback+
+      # hooks of the returned deferrable.
+      #
+      # Pass PG::EM::Client +options+ together with ConnectionPool +options+:
+      #
+      # - +:size+ = +4+ - the maximum number of concurrent connections
+      # - +:connection_class+ = {PG::EM::Client}
+      #
+      # @raise [ArgumentError]
+      def self.connect_defer(options = {}, &blk)
+        pool = new options.merge(lazy: true)
+        pool.__send__(:hold_deferred, blk) do
+          ::EM::DefaultDeferrable.new.tap { |df| df.succeed pool }
+        end
+      end
+
+      class << self
+        alias_method :connect, :new
+        alias_method :async_connect, :connect_defer
+      end
+
+      # Current number of connections in the connection pool
+      #
+      # @return [Integer]
+      def size
+        @available.length + @allocated.length
+      end
+
+      # Finishes all available connections and clears the available pool.
+      #
+      # After call to this method the pool is still usable and will try to
+      # allocate new client connections on subsequent query commands.
+      def finish
+        @available.each { |c| c.finish }
+        @available.clear
+        self
+      end
+
+      alias_method :close, :finish
+
+      class DeferredOptions < Hash
+        def apply(conn)
+          each_pair { |n,v| conn.__send__(n, v) }
+        end
+      end
+      # @!attribute [rw] connect_timeout
+      #   @return [Float] connection timeout in seconds
+      #   Set {Client#connect_timeout} on all present and future connections
+      #   in this pool or read value from options
+      # @!attribute [rw] query_timeout
+      #   @return [Float] query timeout in seconds
+      #   Set {Client#query_timeout}  on all present and future connections
+      #   in this pool or read value from options
+      # @!attribute [rw] async_autoreconnect
+      #   @return [Boolean] asynchronous auto re-connect status
+      #   Set {Client#async_autoreconnect}  on all present and future connections
+      #   in this pool or read value from options
+      # @!attribute [rw] on_connect
+      #   @return [Proc<Client,is_async,is_reset>] connect hook
+      #   Set {Client#on_connect} on all present and future connections
+      #   in this pool or read value from options
+      # @!attribute [rw] on_autoreconnect
+      #   @return [Proc<Client, Error>] auto re-connect hook
+      #   Set {Client#on_autoreconnect} on all present and future connections
+      #   in this pool or read value from options
+      %w[connect_timeout
+         query_timeout
+         async_autoreconnect
+         on_connect
+         on_autoreconnect].each do |name|
+        class_eval <<-EOD, __FILE__, __LINE__
+          def #{name}=(value)
+            @options[:#{name}] = value
+            b = proc { |c| c.#{name} = value }
+            @available.each(&b)
+            @allocated.each_value(&b)
+          end
+        EOD
+        if name.start_with?('on_')
+          class_eval <<-EOD, __FILE__, __LINE__
+            def #{name}(&hook)
+              if block_given?
+                self.#{name} = hook
+              else
+                @options[:#{name}] || @options['#{name}']
+              end
+            end
+          EOD
+        else
+          class_eval <<-EOD, __FILE__, __LINE__
+            def #{name}
+              @options[:#{name}] || @options['#{name}']
+            end
+          EOD
+        end
+        DeferredOptions.class_eval <<-EOD, __FILE__, __LINE__
+          def #{name}=(value)
+            self[:#{name}=] = value
+          end
+        EOD
+      end
+
+      %w(
+        exec
+        query
+        async_exec
+        async_query
+        exec_params
+        exec_prepared
+        prepare
+        describe_prepared
+        describe_portal
+          ).each do |name|
+
+        class_eval <<-EOD, __FILE__, __LINE__
+          def #{name}(*args, &blk)
+            hold { |c| c.#{name}(*args, &blk) }
+          end
+        EOD
+      end
+
+      %w(
+        exec_defer
+        query_defer
+        async_query_defer
+        async_exec_defer
+        exec_params_defer
+        exec_prepared_defer
+        prepare_defer
+        describe_prepared_defer
+        describe_portal_defer
+          ).each do |name|
+
+        class_eval <<-EOD, __FILE__, __LINE__
+          def #{name}(*args, &blk)
+            hold_deferred(blk) { |c| c.#{name}(*args) }
+          end
+        EOD
+      end
+
+      # Executes a BEGIN at the start of the block
+      # and a COMMIT at the end of the block
+      # or ROLLBACK if any exception occurs.
+      # Calls to transaction may be nested,
+      # however without sub-transactions (save points).
+      #
+      # @example Transactions
+      #   pg = PG::EM::ConnectionPool.new size: 10
+      #   pg.transaction do
+      #     pg.exec('insert into animals (family, species) values ($1,$2)',
+      #             [family, species])
+      #     num = pg.query('select count(*) from people where family=$1',
+      #             [family]).get_value(0,0)
+      #     pg.exec('update stats set count = $1 where family=$2',
+      #             [num, family])
+      #   end
+      #
+      # @see Client#transaction
+      # @see #hold
+      def transaction(&blk)
+        hold do |pg|
+          pg.transaction(&blk)
+        end
+      end
+
+      # Acquires {Client} connection and passes it to the given block.
+      #
+      # The connection is allocated to the current fiber and ensures that
+      # any subsequent query from the same fiber will be performed on
+      # the connection.
+      #
+      # It is possible to nest hold calls from the same fiber,
+      # so each time the block will be given the same {Client} instance.
+      # This feature is needed e.g. for nesting transaction calls.
+      # @yieldparam [Client] pg
+      def hold
+        fiber = Fiber.current
+        id = fiber.object_id
+
+        if conn = @allocated[id]
+          skip_release = true
+        else
+          conn = acquire(fiber) until conn
+        end
+
+        begin
+          yield conn if block_given?
+
+        rescue PG::Error
+          if conn.status != PG::CONNECTION_OK
+            conn.finish unless conn.finished?
+            drop_failed(id)
+            skip_release = true
+          end
+          raise
+        ensure
+          release(id) unless skip_release
+        end
+      end
+
+      alias_method :execute, :hold
+
+      def method_missing(*a, &b)
+        hold { |c| c.__send__(*a, &b) }
+      end
+
+      def respond_to_missing?(m, priv = false)
+        hold { |c| c.respond_to?(m, priv) }
+      end
+
+      private
+
+      # Get available connection or create a new one, or put on hold
+      # @return [Client] on success
+      # @return [nil] when dropped connection creates a free slot
+      def acquire(fiber)
+        if conn = @available.pop
+          @allocated[fiber.object_id] = conn
+        else
+          if size < max_size
+            begin
+              id = fiber.object_id
+              # mark allocated pool for proper #size value
+              # the connection is made asynchronously
+              @allocated[id] = opts = DeferredOptions.new
+              conn = @connection_class.new(@options)
+            ensure
+              if conn
+                opts.apply conn
+                @allocated[id] = conn
+              else
+                drop_failed(id)
+              end
+            end
+          else
+            @pending << fiber
+            Fiber.yield
+          end
+        end
+      end
+
+      # Asynchronously acquires {Client} connection and passes it to the
+      # given block on success.
+      #
+      # The block will receive the acquired connection as its argument and
+      # should return a deferrable object which is either returned from
+      # this method or is being status-bound to another deferrable returned
+      # from this method.
+      #
+      # @param blk [Proc] optional block passed to +callback+ and +errback+
+      #               of the returned deferrable object
+      # @yieldparam pg [Client] a connected client instance
+      # @yieldreturn [EM::Deferrable]
+      # @return [EM::Deferrable]
+      def hold_deferred(blk = nil)
+        if conn = @available.pop
+          id = conn.object_id
+          @allocated[id] = conn
+          df = yield conn
+        else
+          df = FeaturedDeferrable.new
+          id = df.object_id
+          acquire_deferred(df) do |nc|
+            @allocated[id] = conn = nc
+            df.bind_status yield conn
+          end
+        end
+        df.callback { release(id) }
+        df.errback do |err|
+          if conn
+            if err.is_a?(PG::Error) &&
+                conn.status != PG::CONNECTION_OK
+              conn.finish unless conn.finished?
+              drop_failed(id)
+            else
+              release(id)
+            end
+          end
+        end
+        df.completion(&blk) if blk
+        df
+      end
+
+      # Asynchronously create a new connection or get the released one
+      #
+      # @param df [EM::Deferrable] - the acquiring object and the one to fail
+      #                         when establishing connection fails
+      # @return [EM::Deferrable] the deferrable that will succeed with either
+      #                          new or released connection
+      def acquire_deferred(df, &blk)
+        id = df.object_id
+        if size < max_size
+          # mark allocated pool for proper #size value
+          # the connection is made asynchronously
+          @allocated[id] = opts = DeferredOptions.new
+          @connection_class.connect_defer(@options).callback {|conn|
+            opts.apply conn
+          }.errback do |err|
+            drop_failed(id)
+            df.fail(err)
+          end
+        else
+          @pending << (conn_df = ::EM::DefaultDeferrable.new)
+          conn_df.errback do
+            # a dropped connection made a free slot
+            acquire_deferred(df, &blk)
+          end
+        end.callback(&blk)
+      end
+
+      # drop a failed connection (or a mark) from the pool and
+      # ensure that the pending requests won't starve
+      def drop_failed(id)
+        @allocated.delete(id)
+        if pending = @pending.shift
+          if pending.is_a?(Fiber)
+            pending.resume
+          else
+            pending.fail
+          end
+        end
+      end
+
+      # release connection and pass it to the next pending
+      # request or back to the free pool
+      def release(id)
+        conn = @allocated.delete(id)
+        if pending = @pending.shift
+          if pending.is_a?(Fiber)
+            @allocated[pending.object_id] = conn
+            pending.resume conn
+          else
+            pending.succeed conn
+          end
+        else
+          @available << conn
+        end
+      end
+
+    end
+  end
+end