em-pg-client 0.3.0 → 0.3.1

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

@@ -17,9 +17,7 @@ module PG
             @timer = ::EM::Timer.new(timeout) do
               detach
               @deferrable.protect do
-                error = ConnectionBad.new("timeout expired (async)")
-                error.instance_variable_set(:@connection, @client)
-                raise error
+                @client.raise_error ConnectionBad, "timeout expired (async)"
               end
             end
           end
@@ -45,11 +43,7 @@ module PG
           @timer.cancel if @timer
           detach
           @deferrable.protect_and_succeed do
-            unless polling_ok
-              error = ConnectionBad.new(@client.error_message)
-              error.instance_variable_set(:@connection, @client)
-              raise error
-            end
+            @client.raise_error ConnectionBad unless polling_ok
             @client.set_default_encoding unless reconnecting?
             @client
           end

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

@@ -17,17 +17,31 @@ module PG
           @is_connected
         end
 
-        def watch_query(deferrable, send_proc)
-          self.notify_readable = true
+        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
-          @timer.cancel if @timer
-          if (timeout = @client.query_timeout) > 0
-            @notify_timestamp = Time.now
-            setup_timer timeout
+          cancel_timer
+          if @client.is_busy
+            if @client.status == PG::CONNECTION_OK
+              self.notify_readable = true
+              if (timeout = @client.query_timeout) > 0
+                @notify_timestamp = Time.now
+                setup_timer timeout
+              end
+            else
+              @deferrable.protect do
+                @client.raise_error ConnectionBad
+              end
+            end
           else
-            @timer = nil
+            self.notify_readable = true
+            fetch_results
           end
           self
         end
@@ -39,9 +53,7 @@ module PG
               self.notify_readable = false
               @client.async_command_aborted = true
               @deferrable.protect do
-                error = ConnectionBad.new("query timeout expired (async)")
-                error.instance_variable_set(:@connection, @client)
-                raise error
+                @client.raise_error ConnectionBad, "query timeout expired (async)"
               end
             else
               setup_timer timeout, last_interval
@@ -56,20 +68,20 @@ module PG
           end
         end
 
-        # Carefully extract the last result without
+        # Carefully extract results without
         # blocking the EventMachine reactor.
-        def notify_readable
+        def fetch_results
           result = false
           @client.consume_input
           until @client.is_busy
-            if (single_result = @client.get_result).nil?
-              if (result = @last_result).nil?
-                error = Error.new(@client.error_message)
-                error.instance_variable_set(:@connection, @client)
-                raise error
+            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
-              result.check
-              cancel_timer
               break
             end
             @last_result.clear if @last_result
@@ -78,22 +90,34 @@ module PG
         rescue Exception => e
           self.notify_readable = false
           cancel_timer
+          send_proc = @send_proc
+          @send_proc = nil
+          df = @deferrable
+          # prevent unbind error on auto re-connect
+          @deferrable = false
           if e.is_a?(PG::Error)
-            @client.async_autoreconnect!(@deferrable, e, &@send_proc)
+            @client.async_autoreconnect!(df, e, &send_proc)
           else
-            @deferrable.fail(e)
+            df.fail(e)
           end
         else
           if result == false
             @notify_timestamp = Time.now if @timer
           else
             self.notify_readable = false
+            cancel_timer
+            @send_proc = nil
             @deferrable.succeed(result)
           end
         end
 
+        alias_method :notify_readable, :fetch_results
+
         def unbind
           @is_connected = false
+          @deferrable.protect do
+            @client.raise_error ConnectionBad, "connection reset"
+          end if @deferrable
         end
       end
 

data/spec/em_client_autoreconnect.rb

@@ -5,8 +5,10 @@ require 'date'
 require 'eventmachine'
 require 'pg/em'
 
-$pgserver_cmd_stop = %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" stop -s -m fast]
-$pgserver_cmd_start = %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" start -s -w]
+$pgserver_cmd_stop = ENV['PG_CTL_STOP_CMD'] || %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" stop -s -m fast]
+$pgserver_cmd_start = ENV['PG_CTL_START_CMD'] || %Q[sudo -i -u postgres pg_ctl -D "#{ENV['PGDATA']}" start -s -w]
+
+DISCONNECTED_ERROR = ENV['PGHOST'].include?('/') ? PG::UnableToSend : PG::ConnectionBad
 
 shared_context 'pg-em common' do
   around(:each) do |testcase|
@@ -67,7 +69,7 @@ describe 'pg-em default autoreconnect' do
   it "should not get database size using query after server shutdown" do
     system($pgserver_cmd_stop).should be_true
     @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
-      ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+      ex.should be_an_instance_of DISCONNECTED_ERROR
       EM.stop
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
@@ -92,12 +94,47 @@ describe 'pg-em default autoreconnect' do
       system($pgserver_cmd_stop).should be_true
       system($pgserver_cmd_start).should be_true
       @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
-        ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+        ex.should be_an_instance_of DISCONNECTED_ERROR
         @tested_proc.call
       end.should be_a_kind_of ::EM::DefaultDeferrable
     end
   end
 
+  it "should fail to get last result asynchronously after server restart" do
+    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @client.get_last_result_defer do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_OK
+      @client.get_last_result_defer do |result|
+        result.should be_nil
+        EM.stop
+      end
+    end.should be_a_kind_of EM::DefaultDeferrable
+  end
+
+  it "should fail to get each result asynchronously after server restart" do
+    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @client.get_result_defer do |result|
+      result.should be_an_instance_of PG::Result
+      expect do
+        result.check
+      end.to raise_error PG::Error
+      @client.status.should be PG::CONNECTION_OK
+      @client.get_result_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_OK
+        @client.get_result_defer do |result|
+          result.should be_nil
+          EM.stop
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of EM::DefaultDeferrable
+    end
+  end
+
   before(:all) do
     @tested_proc = proc do
       @client.query_defer('SELECT pg_database_size(current_database());') do |result|
@@ -148,7 +185,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
       system($pgserver_cmd_stop).should be_true
       system($pgserver_cmd_start).should be_true
       @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
-        ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+        ex.should be_an_instance_of DISCONNECTED_ERROR
         @tested_proc.call
       end.should be_a_kind_of ::EM::DefaultDeferrable
     end
@@ -159,7 +196,7 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
-      ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+      ex.should be_an_instance_of DISCONNECTED_ERROR
       EM.stop
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
@@ -209,6 +246,45 @@ describe 'pg-em autoreconnect with on_autoreconnect' do
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
 
+  it "should fail to get last result asynchronously after server restart" do
+    @client.on_autoreconnect = proc { true }
+    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @client.get_last_result_defer do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_OK
+      @client.get_last_result_defer do |result|
+        result.should be_nil
+        EM.stop
+      end
+    end.should be_a_kind_of EM::DefaultDeferrable
+  end
+
+  it "should fail to get each result asynchronously after server restart" do
+    @client.on_autoreconnect = proc {
+      EM::DefaultDeferrable.new.tap {|df| df.succeed }
+    }
+    @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    @client.get_result_defer do |result|
+      result.should be_an_instance_of PG::Result
+      expect do
+        result.check
+      end.to raise_error PG::Error
+      @client.status.should be PG::CONNECTION_OK
+      @client.get_result_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_OK
+        @client.get_result_defer do |result|
+          result.should be_nil
+          EM.stop
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of EM::DefaultDeferrable
+    end
+  end
+
   before(:all) do
     @tested_proc = proc do
       @client.exec_prepared_defer('get_db_size') do |result|
@@ -240,20 +316,76 @@ describe 'pg-em with autoreconnect disabled' do
     system($pgserver_cmd_stop).should be_true
     system($pgserver_cmd_start).should be_true
     @client.query_defer('SELECT pg_database_size(current_database());') do |ex|
-      ex.should be_an_instance_of @client.host.include?('/') ? PG::UnableToSend : PG::ConnectionBad
+      ex.should be_an_instance_of DISCONNECTED_ERROR
+      @client.status.should be PG::CONNECTION_BAD
       EM.stop
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
 
   it "should get database size using query after async manual connection reset" do
     @client.status.should be PG::CONNECTION_BAD
-    @client.async_reset do |conn|
+    @client.reset_defer do |conn|
       conn.should be @client
       @client.status.should be PG::CONNECTION_OK
       @tested_proc.call
     end.should be_a_kind_of ::EM::DefaultDeferrable
   end
 
+  it "should fail to get last result asynchronously after server restart" do
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    begin
+      @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    rescue PG::UnableToSend
+    end
+    @client.get_last_result_defer do |ex|
+      ex.should be_an_instance_of PG::ConnectionBad
+      @client.status.should be PG::CONNECTION_BAD
+      @client.get_last_result_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.reset_defer do |conn|
+          conn.should be @client
+          @client.status.should be PG::CONNECTION_OK
+          EM.stop
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      end
+    end.should be_a_kind_of EM::DefaultDeferrable
+  end
+
+  it "should fail to get each result asynchronously after server restart" do
+    check_get_result = proc do
+      @client.get_result_defer do |ex|
+        ex.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_BAD
+        @client.reset_defer do |conn|
+          conn.should be @client
+          @client.status.should be PG::CONNECTION_OK
+          EM.stop
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      end.should be_a_kind_of EM::DefaultDeferrable
+    end
+    system($pgserver_cmd_stop).should be_true
+    system($pgserver_cmd_start).should be_true
+    begin
+      @client.send_query('SELECT pg_sleep(5); SELECT pg_database_size(current_database());')
+    rescue PG::UnableToSend
+      @client.get_result_defer do |result|
+        result.should be_an_instance_of PG::ConnectionBad
+        @client.status.should be PG::CONNECTION_BAD
+        check_get_result.call
+      end
+    else
+      @client.get_result_defer do |result|
+        result.should be_an_instance_of PG::Result
+        expect do
+          result.check
+        end.to raise_error PG::Error
+        @client.status.should be PG::CONNECTION_OK
+        check_get_result.call
+      end
+    end
+  end
+
   before(:all) do
     @tested_proc = proc do
       @client.query_defer('SELECT pg_database_size(current_database());') do |result|

data/spec/em_client_common.rb

@@ -106,6 +106,43 @@ end
 
 shared_context 'em-pg common after' do
 
+  if described_class.single_row_mode?
+
+    it "should get each result in single row mode" do
+      @client.single_row_mode?.should be_true
+      @client.get_result_defer do |result|
+        result.should be_nil
+        @client.send_query('SELECT data, id FROM foo order by id')
+        @client.set_single_row_mode
+        EM::Iterator.new(@values, 1).map(proc{ |(data, id), iter|
+          @client.get_result_defer do |result|
+            result.should be_an_instance_of PG::Result
+            result.check
+            result.result_status.should eq PG::PGRES_SINGLE_TUPLE
+            value = result.to_a
+            value.should eq [{'data' => data, 'id' => id.to_s}]
+            result.clear
+            iter.return value
+          end.should be_a_kind_of ::EM::DefaultDeferrable
+        }, proc{ |results|
+          results.length.should eq @values.length
+          @client.get_result_defer do |result|
+            result.should be_an_instance_of PG::Result
+            result.check
+            result.result_status.should eq PG::PGRES_TUPLES_OK
+            result.to_a.should eq []
+            result.clear
+            @client.get_result_defer do |result|
+              result.should be_nil
+              EM.stop
+            end.should be_a_kind_of ::EM::DefaultDeferrable
+          end.should be_a_kind_of ::EM::DefaultDeferrable
+        })
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end
+
+  end
+
   it_should_execute("create prepared statement",
       :prepare_defer, 'get_foo', 'SELECT * FROM foo order by id')
 
@@ -282,4 +319,44 @@ shared_context 'em-pg common after' do
       end
     end
   end
+
+  it "should get last result asynchronously" do
+    @client.get_last_result_defer do |result|
+      result.should be_nil
+      @client.send_query('SELECT 1; SELECT 2; SELECT 3')
+      @client.get_last_result_defer do |result|
+        result.should be_an_instance_of PG::Result
+        result.getvalue(0,0).should eq '3'
+        result.clear
+        @client.get_last_result_defer do |result|
+          result.should be_nil
+          EM.stop
+        end
+      end.should be_a_kind_of ::EM::DefaultDeferrable
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
+  it "should get each result asynchronously" do
+    @client.get_result_defer do |result|
+      result.should be_nil
+      @client.send_query('SELECT 4; SELECT 5; SELECT 6')
+      EM::Iterator.new(%w[4 5 6], 1).map(proc{ |value, iter|
+        @client.get_result_defer do |result|
+          result.should be_an_instance_of PG::Result
+          result.check
+          result.result_status.should eq PG::PGRES_TUPLES_OK
+          result.getvalue(0,0).should eq value
+          result.clear
+          iter.return value
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      }, proc{ |results|
+        results.should eq %w[4 5 6]
+        @client.get_result_defer do |result|
+          result.should be_nil
+          EM.stop
+        end.should be_a_kind_of ::EM::DefaultDeferrable
+      })
+    end.should be_a_kind_of ::EM::DefaultDeferrable
+  end
+
 end

data/spec/em_synchrony_client.rb

@@ -113,6 +113,33 @@ describe PG::EM::Client do
     ).should be_an_instance_of PG::Result
   end
 
+  if described_class.single_row_mode?
+
+    it "should get each result in single row mode" do
+      @client.single_row_mode?.should be_true
+      @client.send_query('SELECT data, id FROM foo order by id')
+      @client.set_single_row_mode
+      @values.each do |data, id|
+        result = @client.get_result
+        result.should be_an_instance_of PG::Result
+        result.result_status.should eq PG::PGRES_SINGLE_TUPLE
+        result.check
+        value = result.to_a
+        result.clear
+        value.should eq [{'data' => data, 'id' => id.to_s}]
+      end
+      result = @client.get_result
+      result.should be_an_instance_of PG::Result
+      result.check
+      result.result_status.should eq PG::PGRES_TUPLES_OK
+      result.to_a.should eq []
+      result.clear
+      @client.get_result.should be_nil
+      EM.stop
+    end
+
+  end
+
   it "should connect to database asynchronously" do
     this = :first
     Encoding.default_internal = Encoding::ISO_8859_1
@@ -149,12 +176,12 @@ describe PG::EM::Client do
     f = Fiber.current
     Fiber.new do
       begin
-        described_class.new do |conn|
-          this = :second
-          Encoding.default_internal = nil
-          conn.should be_an_instance_of described_class
-          conn.external_encoding.should be conn.internal_encoding
-        end
+        conn = described_class.new
+        this = :second
+        Encoding.default_internal = nil
+        conn.should be_an_instance_of described_class
+        conn.external_encoding.should be conn.internal_encoding
+        conn.finish
       ensure
         f.resume
       end
@@ -256,18 +283,59 @@ describe PG::EM::Client do
 
   it "should not expire after executing erraneous query" do
     @client.query_timeout.should eq 0
-    @client.query_timeout = 0.1
-    @client.query_timeout.should eq 0.1
+    @client.query_timeout = 1
+    @client.query_timeout.should eq 1
     expect {
       @client.query('SELLECT 1')
     }.to raise_error(PG::SyntaxError, /syntax error/)
     @client.async_command_aborted.should be_false
     @client.status.should be PG::CONNECTION_OK
-    ::EM::Synchrony.sleep 0.11
+    ::EM::Synchrony.sleep 1.5
     @client.async_command_aborted.should be_false
     @client.status.should be PG::CONNECTION_OK
   end
 
+  it "should get last result asynchronously" do
+    result = @client.get_last_result
+    result.should be_nil
+    @client.get_last_result.should be_nil
+    @client.send_query('SELECT 1; SELECT 2; SELECT 3')
+    asynchronous = false
+    EM.next_tick { asynchronous = true }
+    result = @client.get_last_result
+    result.should be_an_instance_of PG::Result
+    result.getvalue(0,0).should eq '3'
+    result.clear
+    @client.get_last_result.should be_nil
+    asynchronous.should be true
+  end
+
+  it "should get each result asynchronously" do
+    result = @client.get_result
+    result.should be_nil
+    @client.get_result do |result|
+      result.should be_nil
+    end.should be_nil
+    @client.send_query('SELECT 4,pg_sleep(0.1); SELECT 5; SELECT 6')
+    asynchronous = false
+    EM.next_tick { asynchronous = true }
+    %w[4 5 6].map do |value|
+      result = @client.get_result do |result|
+        result.should be_an_instance_of PG::Result
+        result.check
+        result.result_status.should eq PG::PGRES_TUPLES_OK
+        result.getvalue(0,0).should eq value
+        result
+      end
+      expect do
+        result.clear
+      end.to raise_error PG::Error, /cleared/
+      value
+    end.should eq %w[4 5 6]
+    @client.get_result.should be_nil
+    asynchronous.should be true
+  end
+
   describe 'PG::EM::Client#transaction' do
 
     it "should raise ArgumentError when there is no block" do