em-pg-client 0.3.2 → 0.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 94c88a93f1492f98d885d96bc35fafbbe7dbf88f
+  data.tar.gz: 2e58b30703259d32a712c71502c3a6de66280672
+SHA512:
+  metadata.gz: 7d50ddbe83812b62fe3364192c03e493f61fa70900f040fc89abc4d3b94c85def6933129e0d1aa3457e1fc74b3b5fba71c6d6f2322535fabdb9744f5b96f3c32
+  data.tar.gz: a3968e95cb4af73791a818af4ec1542aac9a5b1287b901915d627acc88ba31a5476925988684bef31318f654747237f033bb55b8d810cc75504a3ddbffef85c4

data/.travis.yml

@@ -3,10 +3,11 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
+  - 2.1.0
 env:
-  - PGVERSION=9.3 PGBUILD=9.3.2-1-linux-x64
-  - PGVERSION=9.0 PGBUILD=9.0.15-1-linux-x64
-  - PGVERSION=8.4 PGBUILD=8.4.19-1-linux-x64
+  - PGVERSION=9.3 PGBUILD=9.3.4-1-linux-x64
+  - PGVERSION=9.0 PGBUILD=9.0.17-1-linux-x64
+  - PGVERSION=8.4 PGBUILD=8.4.21-1-linux-x64
 before_install:
   - sudo /etc/init.d/postgresql stop
   - export PGPREFIX=/opt/PostgreSQL/$PGVERSION

data/HISTORY.md

@@ -1,3 +1,14 @@
+0.3.3
+
+- rake: console for debugging
+- added on_connect callback
+- given block to ConnectionPool.new set as on_connect option fallback
+- spec: connection pool database tests
+- spec: on_connect tests
+- spec: on_connect + on_autoreconnect auto re-connect tests
+- spec: added travis rvm 2.1.0 and updated postgres server versions
+- sugar: on_connect and on_autoreconnect block setters
+
 0.3.2
 
 - fix: asynchronous get_result performance

data/README.md

@@ -96,7 +96,7 @@ Install
 #### Gemfile
 
 ```ruby
-  gem "em-pg-client", "~> 0.3.2"
+  gem "em-pg-client", "~> 0.3.3"
 ```
 
 #### Github
@@ -181,6 +181,7 @@ The options are:
 * `query_timeout`
 * `async_autoreconnect`
 * `on_autoreconnect`
+* `on_connect`
 
 Only `connect_timeout` is a standard `libpq` option, although changing it with
 the accessor method affects asynchronous functions only.

data/Rakefile

@@ -40,9 +40,27 @@ namespace :test do
   end
 
   desc "Run safe tests only"
-  task :safe  => [:warn, :spec, :async, :fiber]
+  task :safe  => [:warn, :spec, :async, :fiber, :on_connect, :pool]
   task :async => [:async_inet, :async_unix]
   task :fiber => [:fiber_inet, :fiber_unix]
+  task :on_connect => [:on_connect_inet, :on_connect_unix]
+  task :pool => [:pool_inet, :pool_unix]
+
+  task :pool_inet do
+    sh env_inet.merge('COVNAME'=>'pool:inet'), "rspec spec/em_connection_pool.rb"
+  end
+
+  task :pool_unix do
+    sh env_unix.merge('COVNAME'=>'pool:unix'), "rspec spec/em_connection_pool.rb" unless windows_os?
+  end
+
+  task :on_connect_inet do
+    sh env_inet.merge('COVNAME'=>'on_connect:inet'), "rspec spec/em_client_on_connect.rb"
+  end
+
+  task :on_connect_unix do
+    sh env_unix.merge('COVNAME'=>'on_connect:unix'), "rspec spec/em_client_on_connect.rb" unless windows_os?
+  end
 
   task :async_inet do
     sh env_inet.merge('COVNAME'=>'async:inet'), "rspec spec/em_client.rb"
@@ -126,3 +144,14 @@ task :benchmark do
     benchmark(i)
   end
 end
+
+desc "Console"
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'em-synchrony'
+  require 'em-pg-client'
+  require 'pg/em/connection_pool'
+  ARGV.clear
+  IRB.start
+end

data/benchmarks/single_row_mode.rb

@@ -33,22 +33,22 @@ end
 
 def threads(repeat, concurrency)
   db = Hash.new { |pool, id| pool[id] = PG::Connection.new }
-  (repeat/concurrency).times do
-    (0...concurrency).map do |i|
-      Thread.new do
+  (0...concurrency).map do |i|
+    Thread.new do
+      (repeat/concurrency).times do
         stream_results(db[i])
       end
-    end.each(&:join)
-  end
+    end
+  end.each(&:join)
   db.each_value(&:finish).clear
 end
 
 def fibers(repeat, concurrency)
   EM.synchrony do
     db = PG::EM::ConnectionPool.new size: concurrency, lazy: true
-    (repeat/concurrency).times do
-      FiberIterator.new((0...concurrency), concurrency).each do
-        db.hold do |pg|
+    FiberIterator.new((0...concurrency), concurrency).each do
+      db.hold do |pg|
+        (repeat/concurrency).times do
           stream_results(pg)
         end
       end

data/lib/pg/em-version.rb

@@ -1,5 +1,5 @@
 module PG
   module EM
-    VERSION = '0.3.2'
+    VERSION = '0.3.3'
   end
 end

data/lib/pg/em.rb

@@ -18,6 +18,7 @@ require 'pg/em/client/connect_watcher'
 
 module PG
   module EM
+    ROOT_FIBER = Fiber.current
 
     # == PostgreSQL EventMachine client
     #
@@ -96,24 +97,23 @@ module PG
     #
     # {#describe_prepared} and {#exec_prepared} after
     # {#prepare} should only be invoked on the *same* connection.
-    # If you are using a connection pool, make sure to acquire a single
-    # connection first.
+    # If you are using a {ConnectionPool}, make sure to acquire a single
+    # connection first or execute +prepare+ command on every connection
+    # using +#on_connect+ hook.
     #
     class Client < PG::Connection
 
-      ROOT_FIBER = Fiber.current
-
       # @!attribute connect_timeout
       #   @return [Float] connection timeout in seconds
       #   Connection timeout. Affects {#reset} and {#reset_defer}.
       #
-      #   Changing this property does not affect thread-blocking {#reset}.
-      #
-      #   However if passed as initialization option, it also affects blocking
-      #   {#reset}.
+      #   Changing this property does not affect thread-blocking {#reset} unless
+      #   passed as a +connection_hash+.
       #
       #   To enable it set to some positive value. To disable it: set to 0.
-      #   You can also specify this as an option to {new} or {connect_defer}.
+      #
+      #   You may set +:connect_timeout+ in a +connection_hash+ argument
+      #   passed to {new} or {connect_defer}.
       attr_accessor :connect_timeout
 
       # @!attribute query_timeout
@@ -123,57 +123,141 @@ module PG
       #   {#reset} and {#reset_defer}.
       #
       #   To enable it set to some positive value. To disable it: set to 0.
-      #   You can also specify this as an option to {new} or {connect_defer}.
+      #
+      #   You may set +:query_timeout+ in a +connection_hash+ argument
+      #   passed to {new} or {connect_defer}.
       attr_accessor :query_timeout
 
       # @!attribute async_autoreconnect
       #   @return [Boolean] asynchronous auto re-connect status
       #   Enable/disable auto re-connect feature (+true+/+false+).
       #   Defaults to +false+ unless {#on_autoreconnect} is specified
-      #   as an initialization option.
+      #   in a +connection_hash+.
       #
       #   Changing {#on_autoreconnect} with accessor method doesn't change
       #   the state of {#async_autoreconnect}.
       #
-      #   You can also specify this as an option to {new} or {connect_defer}.
+      #   You may set +:async_autoreconnect+ in a +connection_hash+ argument
+      #   passed to {new} or {connect_defer}.
       attr_accessor :async_autoreconnect
 
       # @!attribute on_autoreconnect
       #   @return [Proc<Client, Error>] auto re-connect hook
-      #   Proc that is called after a connection with the server has been
-      #   automatically re-established. It's being invoked just before the
-      #   pending command is sent to the server.
+      #   A proc like object that is being called after a connection with the
+      #   server has been automatically re-established. It's being invoked
+      #   just before the pending command is sent to the server.
       #
-      #   The first argument it receives is the +connection+ instance.
-      #   The second is the original +exception+ that caused the reconnecting
+      #   @yieldparam pg [Client] re-connected client instance
+      #   @yieldparam error [Exception] an error after which the auto re-connect
+      #                              process began.
+      #   @yieldreturn [false|true|Exception|EM::Deferrable|*]
+      #
+      #   The first argument it receives is the connected {Client} instance.
+      #   The second is the original +error+ that caused the reconnecting
       #   process.
       #
-      #   The proc can control the later action with its return value:
+      #   It's possible to execute queries from the +on_autoreconnect+ hook.
+      #   Code is being executed in a fiber context, so both deferrable and
+      #   fiber-synchronized query commands may be used.
+      #
+      #   If exception is raised during execution of the +on_autoreconnect+
+      #   hook the reset operation will fail with that exception.
+      #
+      #   The hook can control later actions with its return value:
       #
       #   - +false+ (explicitly, +nil+ is ignored) - the original +exception+
       #     is raised/passed back and the pending query command is not sent
       #     again to the server.
       #   - +true+ (explicitly, truish values are ignored), the pending command
       #     is called regardless of the connection's last transaction status.
-      #   - Exception object - is raised/passed back and the pending command
+      #   - +Exception+ object - is raised/passed back and the pending command
       #     is not sent.
-      #   - Deferrable object - the chosen action will depend on the deferred
-      #     status.
+      #   - +Deferrable+ object - the chosen action will depend on the returned
+      #     deferrable status.
       #   - Other values are ignored and the pending query command is
-      #     immediately sent to the server unless there was a pending
-      #     transaction before the connection was reset.
-      #
-      #   It's possible to execute queries from inside of the proc.
-      #
-      #   You may pass this proc as an option to {new} or {connect_defer}.
+      #     immediately sent to the server unless there was a transaction in
+      #     progress before the connection was reset.
+      #
+      #   If both +on_connect+ and +on_autoreconnect+ hooks are set,
+      #   the +on_connect+ is being called first and +on_autoreconnect+ is
+      #   called only when +on_connect+ succeeds.
+      #
+      #   You may set +:on_autoreconnect+ hook in a +connection_hash+ argument
+      #   passed to {new} or {connect_defer}.
+      #
+      #   @example How to use deferrable in on_autoreconnect hook
+      #     pg.on_autoreconnect do |pg, e|
+      #       logger.warn "PG connection was reset: #{e.inspect}, delaying 1 sec."
+      #       EM::DefaultDeferrable.new.tap do |df|
+      #         EM.add_timer(1) { df.succeed }
+      #       end
+      #     end
       #
-      #   @example How to use prepare in on_autoreconnect hook
-      #     pg.on_autoreconnect = proc do |conn, ex|
-      #       conn.prepare("species_by_name", 
+      attr_writer :on_autoreconnect
+
+      def on_autoreconnect(&hook)
+        if block_given?
+          @on_autoreconnect = hook
+        else
+          @on_autoreconnect
+        end
+      end
+
+      # @!attribute on_connect
+      #   @return [Proc<Client,is_async,is_reset>] connect hook
+      #   A proc like object that is being called after a connection with
+      #   the server has been established.
+      #
+      #   @yieldparam pg [Client] connected client instance
+      #   @yieldparam is_async [Boolean] flag indicating if the connection
+      #               was established asynchronously
+      #   @yieldparam is_reset [Boolean] flag indicating if the connection
+      #               client was reset
+      #   @yieldreturn [EM::Deferrable|*]
+      #
+      #   The first argument it receives is the connected {Client} instance.
+      #   The second argument is +true+ if the connection was established in
+      #   asynchronous manner, +false+ otherwise.
+      #   The third argument is +true+ when the connection has been reset or
+      #   +false+ on new connection.
+      #
+      #   It's possible to execute queries from the +on_connect+ hook.
+      #   Code is being executed in a fiber context, so both deferrable and
+      #   fiber-synchronized query commands may be used.
+      #   However deferrable commands will work only if eventmachine reactor
+      #   is running, so check if +is_async+ is +true+.
+      #
+      #   If exception is raised during execution of the +on_connect+ hook
+      #   the connecting/reset operation will fail with that exception.
+      #
+      #   The hook can control later actions with its return value:
+      #
+      #   - +Deferrable+ object - the connection establishing status will depend
+      #     on the returned deferrable status (only in asynchronous mode).
+      #   - Other values are ignored.
+      #
+      #   If both +on_connect+ and +on_autoreconnect+ hooks are set,
+      #   the +on_connect+ is being called first and +on_autoreconnect+ is
+      #   called only when +on_connect+ succeeds.
+      #
+      #   You may set +:on_connect+ hook in a +connection_hash+ argument
+      #   passed to {new} or {connect_defer}.
+      #
+      #   @example How to use prepare in on_connect hook
+      #     PG::EM::Client.new(on_connect: proc {|pg|
+      #       pg.prepare("species_by_name",
       #        "select id, name from animals where species=$1 order by name")
-      #     end
+      #     })
       #
-      attr_accessor :on_autoreconnect
+      attr_writer :on_connect
+
+      def on_connect(&hook)
+        if block_given?
+          @on_connect = hook
+        else
+          @on_connect
+        end
+      end
 
       # @!visibility private
       # Used internally for marking connection as aborted on query timeout.
@@ -201,6 +285,7 @@ module PG
         :@async_autoreconnect => nil,
         :@connect_timeout => nil,
         :@query_timeout => 0,
+        :@on_connect => nil,
         :@on_autoreconnect => nil,
         :@async_command_aborted => false,
       }.freeze
@@ -214,6 +299,13 @@ module PG
             when :async_autoreconnect
               options[:@async_autoreconnect] = value
               true
+            when :on_connect
+              if value.respond_to? :call
+                options[:@on_connect] = value
+              else
+                raise ArgumentError, "on_connect must respond to `call'"
+              end
+              true
             when :on_reconnect
               raise ArgumentError, "on_reconnect is no longer supported, use on_autoreconnect"
             when :on_autoreconnect
@@ -253,8 +345,8 @@ module PG
       # hooks of the returned deferrable.
       #
       # Special {Client} options (e.g.: {#async_autoreconnect}) must be
-      # provided as +connection_hash+ argument variant. They will be ignored
-      # if passed as a +connection_string+.
+      # provided in a +connection_hash+ argument variant. They will be ignored
+      # if passed in a +connection_string+.
       #
       # +client_encoding+ *will* be set according to +Encoding.default_internal+.
       #
@@ -292,7 +384,6 @@ module PG
         df = FeaturedDeferrable.new(&blk)
         # there can be only one watch handler over the socket
         # apparently eventmachine has hard time dealing with more than one
-        # for blocking reset this is not needed
         if @watcher
           @watcher.detach if @watcher.watching?
           @watcher = nil
@@ -338,6 +429,8 @@ module PG
             @watcher = nil
           end
           super
+          @on_connect.call(self, false, true) if @on_connect
+          self
         end
       end
 
@@ -354,8 +447,8 @@ module PG
       # @raise [PG::Error]
       #
       # Special {Client} options (e.g.: {#async_autoreconnect}) must be
-      # provided as +connection_hash+ argument variant. They will be ignored
-      # if passed as a +connection_string+.
+      # provided in a +connection_hash+ argument variant. They will be ignored
+      # if passed in a +connection_string+.
       #
       # +client_encoding+ *will* be set according to +Encoding.default_internal+.
       #
@@ -376,7 +469,11 @@ module PG
             conn
           end
         else
-          super(*args)
+          conn = super(*args)
+          if on_connect = conn.on_connect
+            on_connect.call(conn, false, false)
+          end
+          conn
         end
       end
 
@@ -397,8 +494,8 @@ module PG
 
       # Closes the backend connection.
       #
-      # Detaches watch handler to prevent memory leak then
-      # calls parent PG::Connection#finish[http://deveiate.org/code/pg/PG/Connection.html#method-i-finish].
+      # Detaches watch handler to prevent memory leak after
+      # calling parent PG::Connection#finish[http://deveiate.org/code/pg/PG/Connection.html#method-i-finish].
       # @see http://deveiate.org/code/pg/PG/Connection.html#method-i-finish PG::Connection#finish
       def finish
         super

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

@@ -42,10 +42,40 @@ module PG
           end
           @timer.cancel if @timer
           detach
-          @deferrable.protect_and_succeed do
+          @deferrable.protect do
             @client.raise_error ConnectionBad unless polling_ok
             @client.set_default_encoding unless reconnecting?
-            @client
+            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