em-pg-client 0.2.1 → 0.3.0

data/spec/pg_em_featured_deferrable.rb

@@ -0,0 +1,125 @@
+$:.unshift "lib"
+gem 'eventmachine', '~> 1.0.0'
+gem 'pg', ENV['EM_PG_CLIENT_TEST_PG_VERSION']
+require 'date'
+require 'eventmachine'
+require 'pg/em'
+
+describe PG::EM::FeaturedDeferrable do
+  subject           { PG::EM::FeaturedDeferrable }
+  let(:df)          { subject.new }
+  let(:cb)          { Proc.new {} }
+  let(:error)       { RuntimeError.new }
+  let(:pg_error)    {
+    PG::Error.new.tap do |err|
+      err.instance_variable_set :@connection, :connection
+      err.instance_variable_set :@result, :result
+    end
+  }
+
+  it "should set callback with a block " do
+    cb.should_receive(:call).with(:result)
+    df = subject.new(&cb)
+    df.succeed(:result)
+  end
+
+  it "should set errback with a block" do
+    cb.should_receive(:call).with(:err)
+    df = subject.new(&cb)
+    df.fail(:err)
+  end
+
+  it "should execute callbacks and errbacks in setup order" do
+    results = []
+    setup_callbacks = proc do |df|
+      df.callback { results << 1 }
+      df.callback { results << 2 }
+      df.callback { results << 3 }
+      df.errback  { results << 4 }
+      df.errback  { results << 5 }
+      df.errback  { results << 6 }
+    end
+    df = subject.new
+    setup_callbacks.call df
+    df.succeed
+    df.fail
+    df = subject.new
+    setup_callbacks.call df
+    df.fail
+    df.succeed
+    results.should eq [1, 2, 3, 4, 5, 6]
+  end
+
+  it "should set completion with block" do
+    cb.should_receive(:call).with(:err)
+    df = subject.new
+    df.completion(&cb)
+    df.fail(:err)
+    df.succeed(:result)
+
+    cb.should_receive(:call).with(:result)
+    df = subject.new
+    df.completion(&cb)
+    df.succeed(:result)
+    df.fail(:err)
+  end
+
+  it "should bind status to another deferrable" do
+    cb.should_receive(:call).with(:result)
+    df = subject.new(&cb)
+    other_df = subject.new
+    df.bind_status(other_df)
+    other_df.succeed(:result)
+
+    cb.should_receive(:call).with(:err)
+    df = subject.new(&cb)
+    other_df = subject.new
+    df.bind_status(other_df)
+    other_df.fail(:err)
+  end
+
+  shared_context 'shared protect' do
+    it "should call df.fail and return nil" do
+      ::EM.stub(:next_tick) {|&cb| cb.call }
+      df.errback(&cb)
+      cb.should_receive(:call).with(error)
+      df.send(protect_method) do
+        raise error
+      end.should be_nil
+    end
+
+    it "should call df.fail and return custom fail value" do
+      ::EM.stub(:next_tick) {|&cb| cb.call }
+      df.errback(&cb)
+      cb.should_receive(:call).with(error)
+      df.send(protect_method, :fail) do
+        raise error
+      end.should eq :fail
+    end
+  end
+
+  context "#protect" do
+    let(:protect_method) { :protect }
+    it "should return value" do
+      df.protect do
+        :result
+      end.should eq :result
+    end
+
+    include_context 'shared protect'
+  end
+
+  context "#protect_and_succeed" do
+    let(:protect_method) { :protect_and_succeed }
+    it "should call deferrable.succeed and return value" do
+      ::EM.stub(:next_tick) {|&cb| cb.call }
+      df.callback(&cb)
+      cb.should_receive(:call).with(:result)
+      df.protect_and_succeed do
+        :result
+      end.should eq :result
+    end
+
+    include_context 'shared protect'
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: em-pg-client
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,33 +9,43 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-07 00:00:00.000000000 Z
+date: 2013-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &244130120 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.13.2
+        version: 0.17.0
   type: :runtime
   prerelease: false
-  version_requirements: *244130120
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.17.0
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &244129580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.10
+        version: 1.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *244129580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &244128480 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,21 +53,15 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *244128480
-- !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: &244127700 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.0.beta.1
-  type: :development
-  prerelease: false
-  version_requirements: *244127700
+        version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: em-synchrony
-  requirement: &244126900 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,37 +69,58 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *244126900
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: PostgreSQL asynchronous EventMachine client, based on pg interface (PG::Connection)
 email: rafal@yeondir.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
-- BENCHMARKS.rdoc
+- README.md
+- BENCHMARKS.md
+- LICENSE
+- HISTORY.md
 files:
-- BENCHMARKS.rdoc
-- HISTORY.rdoc
-- README.rdoc
+- .yardopts
+- BENCHMARKS.md
+- HISTORY.md
+- LICENSE
+- README.md
 - Rakefile
 - benchmarks/em_pg.rb
 - em-pg-client.gemspec
+- lib/em-pg-client.rb
 - lib/em-synchrony/pg.rb
+- lib/pg/em-version.rb
 - lib/pg/em.rb
+- lib/pg/em/client/connect_watcher.rb
+- lib/pg/em/client/watcher.rb
+- lib/pg/em/connection_pool.rb
+- lib/pg/em/featured_deferrable.rb
+- spec/connection_pool_helpers.rb
+- spec/em_client.rb
 - spec/em_client_autoreconnect.rb
 - spec/em_client_common.rb
-- spec/em_devel_client.rb
-- spec/em_release_client.rb
 - spec/em_synchrony_client.rb
 - spec/em_synchrony_client_autoreconnect.rb
+- spec/pg_em_client_connect_finish.rb
+- spec/pg_em_client_connect_timeout.rb
+- spec/pg_em_client_options.rb
+- spec/pg_em_connection_pool.rb
+- spec/pg_em_featured_deferrable.rb
 homepage: http://github.com/royaltm/ruby-em-pg-client
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options:
 - --title
 - em-pg-client
 - --main
-- README.rdoc
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -103,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.9.1
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -113,14 +138,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements:
 - PostgreSQL server
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: EventMachine PostgreSQL client
 test_files:
+- spec/pg_em_client_connect_timeout.rb
+- spec/em_client.rb
+- spec/connection_pool_helpers.rb
+- spec/pg_em_client_options.rb
 - spec/em_synchrony_client.rb
-- spec/em_devel_client.rb
 - spec/em_client_common.rb
-- spec/em_release_client.rb
 - spec/em_synchrony_client_autoreconnect.rb
+- spec/pg_em_client_connect_finish.rb
+- spec/pg_em_connection_pool.rb
 - spec/em_client_autoreconnect.rb
+- spec/pg_em_featured_deferrable.rb

data/README.rdoc

@@ -1,431 +0,0 @@
-= em-pg-client
-
-Author::    Rafał Michalski  (mailto:rafal@yeondir.com)
-
-* http://github.com/royaltm/ruby-em-pg-client
-
-== DESCRIPTION
-
-*em-pg-client* is the Ruby and EventMachine driver interface to the PostgreSQL
-RDBMS. It is based on ruby-pg[https://bitbucket.org/ged/ruby-pg].
-
-== FEATURES
-
-* Non-blocking / asynchronous processing with EventMachine,
-* fully async auto re-connects on connection losses (e.g.: RDBMS restarts),
-* minimal changes to PG::Connection[http://deveiate.org/code/pg/PG/Connection.html] API,
-* configurable timeouts (connect or execute) of asynchronous processing,
-* additional Fiber-aware version supporting EM-Synchrony[https://github.com/igrigorik/em-synchrony].
-
-== BUGS/LIMITATIONS
-
-* no async support for: COPY commands (+get_copy_data+,  +put_copy_data+),
-  +wait_for_notify+ and +transaction+
-* actually no ActiveRecord nor Sequel support (you are welcome to contribute).
-* doesn't work on Windows (issue #7)
-
-== API Changes between versions
-
-=== 0.1.x -> 0.2.x
-* +on_reconnect+ renamed to more accurate +on_autoreconnect+
-  (well, it's not used by PG::EM::Client#reset call).
-* +async_autoreconnect+ is +false+ by default if +on_autoreconnect+
-  is *not* specified as initialization option.
-
-== TODO:
-
-* implement EM adapted version of +get_copy_data+, +put_copy_data+,
-  +wait_for_notify+ and +transaction+
-* add some fd/socket hackery to get it working on Windows (issue #7)
-* em-synchrony ORM (ActiveRecord, Sequel and maybe Datamapper) support
-  as separate projects
-* present more benchmarks
-
-== REQUIREMENTS
-
-* ruby >= 1.9 (tested: 1.9.3-p194, 1.9.2-p320, 1.9.1-p378)
-* https://bitbucket.org/ged/ruby-pg >= 0.13.2 (>= 0.14 recommended)
-* PostgreSQL[http://www.postgresql.org/ftp/source/] RDBMS >= 8.3
-* http://rubyeventmachine.com >= 0.12.10
-* (optional) EM-Synchrony[https://github.com/igrigorik/em-synchrony]
-
-== INSTALL
-
-  $ [sudo] gem install em-pg-client
-
-==== Gemfile
-
-  # eventmachine
-  gem "em-pg-client", "~> 0.2.1", :require => 'pg/em'
-  # em-synchrony
-  gem "em-pg-client", "~> 0.2.1", :require => ['pg/em', 'em-synchrony/pg']
-
-==== Github
-
-  git clone git://github.com/royaltm/ruby-em-pg-client.git
-
-== WHY?
-
-Because I didn't find any ruby-pg's EM implementation to fit my needs.
-I've found at least 3 other implementations of EM postgres client:
-
-* https://github.com/jzimmek/em-postgresql-sequel
-* https://github.com/leftbee/em-postgresql-adapter
-* https://github.com/jtoy/em-postgres
-
-and (except the EM-bundled one which uses no longer maintained postgres-pr library)
-all of them have similiar flaws:
-
-* 2 of them are designed to support some ORM (ActiveRecord or Sequel),
-  so they are EM-Synchrony only,
-* non-standard API method names,
-* no (nonexistent or non-working) autoreconnect implementation,
-* poor error handling,
-* not fully supporting asynchronous PG::Connection API.
-
-The last one is worth some comment:
-
-They all use blocking methods to retrieve whole result from server
-(PGConn#block[http://deveiate.org/code/pg/PG/Connection.html#method-i-block] or
-PGConn#get_result[http://deveiate.org/code/pg/PG/Connection.html#method-i-get_result] which also
-blocks when there is not enough buffered data on socket).
-
-This implementation makes use of non-blocking:
-PGConn#is_busy[http://deveiate.org/code/pg/PG/Connection.html#method-i-is_busy] and
-PGConn#consume_input[http://deveiate.org/code/pg/PG/Connection.html#method-i-consume_input] methods.
-Depending on the size of queries results and the level of concurrency, the gain in overall speed and
-responsiveness of your application might be actually quite huge. I've done some
-tests[link:BENCHMARKS.rdoc] already.
-
-== Thanks
-
-The greetz go to:
-- Authors[https://bitbucket.org/ged/ruby-pg/wiki/Home#!copying] of +pg+ driver (especially for its async-api)
-- Francis Cianfrocca for great reactor framework (EventMachine[https://github.com/eventmachine/eventmachine])
-- Ilya Grigorik (igrigorik[https://github.com/igrigorik]) for (untangling[http://www.igvita.com/2010/03/22/untangling-evented-code-with-ruby-fibers/]) EM with Fibers
-
-== USAGE
-+em-pg-client+ provides PG::EM::Client class which inherits
-PG::Connection[http://deveiate.org/code/pg/PG/Connection.html].
-You can work with PG::EM::Client almost the same way you would with
-PG::Connection.
-
-The real difference begins when you turn EventMachine reactor on.
-
-=== BASIC
-
-  require 'pg/em'
-  
-  # no async
-  pg = PG::EM::Client.new dbname: 'test'
-  pg.query('select * from foo') do |result|
-    puts Array(result).inspect
-  end
-
-  # asynchronous
-  EM.run do
-    df = pg.query('select * from foo')
-    df.callback { |result|
-      puts Array(result).inspect
-      EM.stop
-    }
-    df.errback {|ex|
-      raise ex
-    }
-    puts "sent"
-  end
-
-  # alternatively
-  EM.run do
-    pg.query('select * from foo') do |result|
-      raise result if result.is_a? ::Exception
-      puts Array(result).inspect
-      EM.stop
-    end
-    puts "sent"
-  end
-
-=== PG::Connection methods adapted to EventMachine
-The list of PG::EM::Client async methods for processing with EventMachine.
-
-==== 1. Async methods (always returning +Deferrable+ object):
-
-* +Client.async_connect+ (singleton)
-* +async_reset+
-* +async_exec+ (alias: +async_query+)
-* +async_prepare+
-* +async_exec_prepared+
-* +async_describe_prepared+
-* +async_describe_portal+
-
-For arguments of theese methods consult their original blocking (without +async_+ prefix)
-counterparts in PG::Connection[http://deveiate.org/code/pg/PG/Connection.html] manual.
-
-Use +callback+ on the returned +Deferrable+ to receive result. 
-The result you receive is PG::EM::Client for PG::EM::Client.async_connect
-and +async_reset+, and PG::Result[http://deveiate.org/code/pg/PG/Result.html] for the rest
-of the methods. The received PG::EM::Client is in a connected state and ready for queries.
-You need to +clear+ obtained PG::Result object yourself or leave it to +gc+.
-
-To detect a failure in an executed method use +errback+ on returned +Deferrable+.
-You should expect an instance of +Exception+ (usually PG::Error) as +errback+
-argument. You may check its +backtrace+ to find origin of the error.
-
-==== 2. Async / blocking methods (returning +Deferrable+ only when EM is running):
-
-* +exec+ (alias: +query+)
-* +prepare+
-* +exec_prepared+
-* +describe_prepared+
-* +describe_portal+
-
-Outside EventMachine's event loop these methods are regular, blocking PG::Connection
-methods.
-
-All the methods (1 & 2) accept block argument which they attach to +callback+ and +errback+
-hooks of returned +Deferrable+.
-
-You may also mix async and blocking methods without closing the connection.
-You only need to start/stop EventMachine in between async calls.
-
-==== Special options
-There are 3 additional connection options and 1 standard +pg+ option used by
-async methods. You may add them as one of the *hash* options to
-PG::EM::Client.new or PG::EM::Client.async_connect or simply use accessor
-methods to change them on the fly. The additional options are not passed to
-+libpq+.
-
-The options are:
-
-- +async_autoreconnect+ (+true+ / +false+ with default +false+ unless
-  +on_autoreconnect+ is specified)
-  allows automatic re-connection when there was a problem with connection
-  to the server,
-- +on_autoreconnect+ (+nil+ / +Proc+ with default +nil+)
-  a hook which is called after auto-reconnecting,
-- +query_timeout+ (+Float+ / +Fixnum+ with default +0+)
-  allows to set timeout for query execution,
-- +connect_timeout+ (+Float+ / +Fixnum+ with default +0+)
-  connection establishing and resetting timeout.
-
-Only +connect_timeout+ is a standard +libpq+ option, although changing it by
-accessor method only affects asynchronous functions.
-
-=== AUTORECONNECTING IN ASYNC MODE
-Autoreconnecting is done in non-blocking manner using +async_reset+ internally.
-
-  EM.run do
-    pg = PG::EM::Client.new dbname: 'test',
-          connect_timeout: 5, query_timeout: 50,
-          async_autoreconnect: true
-    try_query = lambda do |&blk|
-      pg.query('select * from foo') do |result|
-        raise result if result.is_a? ::Exception
-        puts Array(result).inspect
-        blk.call
-      end
-    end
-    try_query.call {
-      system 'pg_ctl stop -m fast'
-      system 'pg_ctl start -w'
-      try_query.call { EM.stop }
-    }
-  end
-
-to enable this feature call:
-
-  pg.async_autoreconnect = true
-
-or
-
-  pg = PG::EM::Client.new dbname: 'test',
-    async_autoreconnect: true
-
-It's also possible to define +on_autoreconnect+ callback to be invoked
-while the connection has been reset. It's called just before the send query
-command is executed:
-
-  EM.run do
-    pg = PG::EM::Client.new dbname: 'test',
-          async_autoreconnect: true
-    pg.prepare('bar', 'select * from foo order by cdate desc') do
-      pg.on_autoreconnect = proc { |c, e|
-        c.prepare('bar', 'select * from foo order by cdate desc')
-      }
-      try_query = lambda do |&blk|
-        pg.exec_prepared('bar') do |result|
-          raise result if result.is_a? ::Exception
-          puts Array(result).inspect
-          blk.call
-        end
-      end
-      try_query.call {
-        system 'pg_ctl stop -m fast'
-        system 'pg_ctl start -w'
-        try_query.call { EM.stop }
-      }
-    end
-  end
-
-As you can see it's possible to send async query from inside +on_autoreconnect+
-proc. However you have to pass +Deferrable+ from the async callback to the
-caller. See PG::EM::Client#on_autoreconnect docs for details.
-
-=== TRUE ASYNC
-For non-blocking connect use PG::EM::Client.async_connect and
-PG::EM::Client#async_reset for asynchronous re-connect. Like other async
-methods they return +Deferrable+ object.
-Use Deferrable's #callback to obtain already connected PG::EM::Client.
-
-  EM.run do
-    pool = (1..10).map {
-      PG::EM::Client.async_connect dbname: 'test',
-          connect_timeout: 5, query_timeout: 50 }
-
-    togo = pool.length
-
-    pool.each_with_index do |df, i|
-      df.callback do |pg|
-        pg.query("select * from foo") do |result|
-          puts "recv: #{i}"
-          EM.stop if (togo-=1).zero?
-        end
-        puts "sent: #{i}"
-      end
-      df.errback { |ex| raise ex }
-    end
-  end
-
-=== Fibers / EM-Synchrony
-There is a special version of PG::EM::Client library with fiber aware methods
-for EM-Synchrony or other implementations of Fiber untangled EventMachine.
-
-The +require+ string is "em-synchrony/pg" instead of "pg/em".
-
-+em-synchrony/pg+ version of PG::EM::Client.new is fully asynchronous and
-blocks only current fiber. This also applies to PG::EM::Client#reset.
-
-  require 'em-synchrony'
-  require 'em-synchrony/pg'
-
-  EM.synchrony do
-    pg = PG::EM::Client.new dbname: 'test'
-    pg.query('select * from foo') do |result|
-      puts Array(result).inspect
-    end
-    EM.stop
-  end
-
-Although em-synchrony[https://github.com/igrigorik/em-synchrony/] provides
-very nice set of tools for untangled EventMachine, you don't really require
-it to fully benefit from this version of PG::EM::Client.
-
-==== PG::Connection methods adapted to EM-Synchrony
-The list of PG::EM::Client fiber aware methods for processing with
-EM-Synchrony / EventMachine.
-
-All +async_*+ methods are exactly the same as in pure EventMachine version
-of PG::EM::Client.
-
-The fiber aware methods are:
-
-* +Client.connect+ (singleton, alias: +new+, +open+, +setdb+, +setdblogin+)
-* +reset+
-* +exec+ (alias: +query+)
-* +prepare+
-* +exec_prepared+
-* +describe_prepared+
-* +describe_portal+
-
-Under the hood, these methods call async counterparts of themselves and +yield+ from current
-fiber awaiting for the result. The PG::Result (or PG::EM::Client for +connect+
-and +reset+) is then returned to the caller. If code block was given, it is
-executed with result as the argument. In that case the value of the block is
-returned instead and PG::Result is cleared (or in case of +connect+ or +reset+
-PG::EM::Client is being closed) after executing block. From single fiber point
-of view, they behave like regular blocking PG::Connection methods.
-
-Each of them is also automatic, detecting if EventMachine is running.
-If called outside EM event loop they are exactly the original methods of
-PG::Connection.
-
-Like in pure EventMachine version you can mix async, fiber aware and
-blocking methods without finishing the connection. You only need to
-start/stop EventMachine in between async calls.
-
-==== Handling errors
-
-  EM.synchrony do
-    begin
-      pg.query('select * from foo') do |result|
-        puts result
-      end
-    rescue PG::Error => e
-      puts "PSQL error: #{e.inspect}"
-    end
-    EM.stop
-  end
-
-==== Parallel async queries
-
-  EM.synchrony do
-    pg = EM::Synchrony::ConnectionPool.new(size: 2) do  
-      PG::EM::Client.new :dbname => 'test'
-    end
-    multi = EventMachine::Synchrony::Multi.new
-    multi.add :foo, pg.aquery('select * from foo') # or #async_query()
-    multi.add :bar, pg.aquery('select * from bar') # #aquery() is just an alias
-    res = multi.perform
-    p res
-    EM.stop
-  end
-
-==== Fiber Concurrency
-
-  EM.synchrony do
-    # use ConnectionPool when more Fibers will be querying at the same time!
-    pg = EM::Synchrony::ConnectionPool.new(size: 5) do  
-      PG::EM::Client.new :dbname => 'test'
-    end
-    counter = 0
-    EM::Synchrony::FiberIterator.new(['select * from foo']*10, 5) do |query|
-      i = counter
-      pg.query(query) do |result|
-        puts "recv: #{i}"
-      end
-      puts "sent: #{i}"
-      counter += 1
-    end
-    EM.stop
-  end
-
-==== Async reconnect with on_autoreconnect callback
-
-  EM.synchrony do
-    on_autoreconnect = proc do |c, e|
-      c.prepare('bar', 'select * from foo order by cdate desc')
-    end
-    pg = EM::Synchrony::ConnectionPool.new(size: 5) do
-      p = PG::EM::Client.new dbname: 'test', on_autoreconnect: on_autoreconnect
-      on_autoreconnect.call p
-      p
-    end
-    try_query = lambda do
-      pg.exec_prepared('bar') do |result|
-        raise result if result.is_a? ::Exception
-        puts Array(result).inspect
-      end
-    end
-    try_query.call
-    system 'pg_ctl stop -m fast'
-    system 'pg_ctl start -w'
-    try_query.call
-    EM.stop
-  end
-
-Specifying +on_autoreconnect+ as PG::EM::Client.new initialization option,
-implicitly enables +async_autoreconnect+.
-
-== LICENCE
-
-The MIT License - Copyright (c) 2012 Rafał Michalski