pg 0.15.0.pre.432 → 0.15.0.pre.454

data/ext/extconf.rb

@@ -74,6 +74,7 @@ have_func 'rb_enc_alias'
 have_func 'rb_thread_call_without_gvl'
 have_func 'rb_thread_call_with_gvl'
 have_func 'rb_thread_fd_select'
+have_func 'rb_w32_wrap_io_handle'
 
 have_const 'PGRES_COPY_BOTH', 'libpq-fe.h'
 have_const 'PGRES_SINGLE_TUPLE', 'libpq-fe.h'

data/ext/pg.c

@@ -1,6 +1,6 @@
 /*
  * pg.c - Toplevel extension
- * $Id: pg.c,v d0c5d5f7f1e8 2012/12/26 21:09:28 kanis $
+ * $Id$
  *
  * Author/s:
  *

data/ext/pg_connection.c

@@ -1,6 +1,6 @@
 /*
  * pg_connection.c - PG::Connection class extension
- * $Id: pg_connection.c,v 7c313c2355b7 2013/02/03 18:37:06 ged $
+ * $Id$
  *
  */
 
@@ -63,6 +63,29 @@ pg_get_pgconn( VALUE self )
 }
 
 
+/*
+ * Close the associated socket IO object if there is one.
+ */
+void
+pgconn_close_socket_io( VALUE self )
+{
+	VALUE socket_io = rb_iv_get( self, "@socket_io" );
+	int ruby_sd;
+
+	if ( RTEST(socket_io) ) {
+#if defined(_WIN32) && defined(HAVE_RB_W32_WRAP_IO_HANDLE)
+		ruby_sd = NUM2INT(rb_funcall( socket_io, rb_intern("fileno"), 0 ));
+		if( rb_w32_unwrap_io_handle(ruby_sd) ){
+			rb_raise(rb_ePGerror, "Could not unwrap win32 socket handle");
+		}
+#endif
+		rb_funcall( socket_io, rb_intern("close"), 0 );
+	}
+
+	rb_iv_set( self, "@socket_io", Qnil );
+}
+
+
 /*
  * Allocation/
  */
@@ -388,7 +411,7 @@ pgconn_s_encrypt_password(VALUE self, VALUE password, VALUE username)
  *
  * Example:
  *   conn = PG::Connection.connect_start("dbname=mydatabase")
- *   socket = IO.for_fd(conn.socket)
+ *   socket = conn.socket_io
  *   status = conn.connect_poll
  *   while(status != PG::PGRES_POLLING_OK) do
  *     # do some work while waiting for the connection to complete
@@ -421,10 +444,11 @@ pgconn_connect_poll(VALUE self)
  * Closes the backend connection.
  */
 static VALUE
-pgconn_finish(VALUE self)
+pgconn_finish( VALUE self )
 {
-	PQfinish(pg_get_pgconn(self));
-	DATA_PTR(self) = NULL;
+	pgconn_close_socket_io( self );
+	PQfinish( pg_get_pgconn(self) );
+	DATA_PTR( self ) = NULL;
 	return Qnil;
 }
 
@@ -451,9 +475,10 @@ pgconn_finished_p( VALUE self )
  * backend connection and tries to re-connect.
  */
 static VALUE
-pgconn_reset(VALUE self)
+pgconn_reset( VALUE self )
 {
-	PQreset(pg_get_pgconn(self));
+	pgconn_close_socket_io( self );
+	PQreset( pg_get_pgconn(self) );
 	return self;
 }
 
@@ -470,6 +495,7 @@ pgconn_reset(VALUE self)
 static VALUE
 pgconn_reset_start(VALUE self)
 {
+	pgconn_close_socket_io( self );
 	if(PQresetStart(pg_get_pgconn(self)) == 0)
 		rb_raise(rb_ePGerror, "reset has failed");
 	return Qnil;
@@ -715,6 +741,55 @@ pgconn_socket(VALUE self)
 }
 
 
+#if !defined(_WIN32) || defined(HAVE_RB_W32_WRAP_IO_HANDLE)
+
+/*
+ * call-seq:
+ *    conn.socket_io() -> IO
+ *
+ * Fetch a memoized IO object created from the Connection's underlying socket.
+ * This object can be used for IO.select to wait for events while running
+ * asynchronous API calls.
+ *
+ * Using this instead of #socket avoids the problem of the underlying connection
+ * being closed by Ruby when an IO created using <tt>IO.for_fd(conn.socket)</tt>
+ * goes out of scope.
+ *
+ * This method can also be used on Windows but requires Ruby-2.0+.
+ */
+static VALUE
+pgconn_socket_io(VALUE self)
+{
+	int sd;
+	int ruby_sd;
+	int id_autoclose = rb_intern("autoclose=");
+	VALUE socket_io = rb_iv_get( self, "@socket_io" );
+
+	if ( !RTEST(socket_io) ) {
+		if( (sd = PQsocket(pg_get_pgconn(self))) < 0)
+			rb_raise(rb_ePGerror, "Can't get socket descriptor");
+
+		#ifdef _WIN32
+			ruby_sd = rb_w32_wrap_io_handle((HANDLE)(intptr_t)sd, O_RDWR|O_BINARY|O_NOINHERIT);
+		#else
+			ruby_sd = sd;
+		#endif
+
+		socket_io = rb_funcall( rb_cIO, rb_intern("for_fd"), 1, INT2NUM(ruby_sd) );
+
+		/* Disable autoclose feature, when supported */
+		if( rb_respond_to(socket_io, id_autoclose) ){
+			rb_funcall( socket_io, id_autoclose, 1, Qfalse );
+		}
+
+		rb_iv_set( self, "@socket_io", socket_io );
+	}
+
+	return socket_io;
+}
+
+#endif
+
 /*
  * call-seq:
  *    conn.backend_pid() -> Fixnum
@@ -797,7 +872,7 @@ pgconn_exec(int argc, VALUE *argv, VALUE self)
 		}
 		return rb_pgresult;
 	}
-	
+
 	/* Otherwise, just call #exec_params instead for backward-compatibility */
 	else {
 		return pgconn_exec_params( argc, argv, self );
@@ -2174,9 +2249,13 @@ wait_socket_readable( PGconn *conn, struct timeval *ptimeout, void *(*is_readabl
 			return NULL;
 		} else if ( wait_ret == WAIT_OBJECT_0 ) {
 			/* The event we were waiting for. */
+		} else if ( wait_ret == WAIT_OBJECT_0 + 1) {
+			/* This indicates interruption from timer thread, GC, exception
+			 * from other threads etc... */
+			rb_thread_check_ints();
 		} else if ( wait_ret == WAIT_FAILED ) {
 			WSACloseEvent( hEvent );
-			rb_raise( rb_ePGerror, "Wait on socket error (WaitForMultipleObjects): %d", GetLastError() );
+			rb_raise( rb_ePGerror, "Wait on socket error (WaitForMultipleObjects): %lu", GetLastError() );
 		} else {
 			WSACloseEvent( hEvent );
 			rb_raise( rb_ePGerror, "Wait on socket abandoned (WaitForMultipleObjects)" );
@@ -2884,6 +2963,7 @@ pgconn_get_last_result(VALUE self)
 	return rb_pgresult;
 }
 
+#if !defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
 
 /*
  * call-seq:
@@ -2891,10 +2971,14 @@ pgconn_get_last_result(VALUE self)
  *    conn.async_exec(sql [, params, result_format ] ) {|pg_result| block }
  *
  * This function has the same behavior as #exec,
- * except that it's implemented using asynchronous command
- * processing and ruby's +rb_thread_select+ in order to
- * allow other threads to process while waiting for the
- * server to complete the request.
+ * but ensures that other threads can process while
+ * waiting for the server to complete the request.
+ *
+ * On Ruby platforms with native threads (MRI-1.9+ and all others)
+ * this method is an alias to #exec.
+ *
+ * On MRI-1.8 it's implemented using asynchronous command
+ * processing and ruby's +rb_thread_select+ .
  */
 static VALUE
 pgconn_async_exec(int argc, VALUE *argv, VALUE self)
@@ -2915,6 +2999,7 @@ pgconn_async_exec(int argc, VALUE *argv, VALUE self)
 	return rb_pgresult;
 }
 
+#endif
 
 /**************************************************************************
  * LARGE OBJECT SUPPORT
@@ -3394,6 +3479,9 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "server_version", pgconn_server_version, 0);
 	rb_define_method(rb_cPGconn, "error_message", pgconn_error_message, 0);
 	rb_define_method(rb_cPGconn, "socket", pgconn_socket, 0);
+#if !defined(_WIN32) || defined(HAVE_RB_W32_WRAP_IO_HANDLE)
+	rb_define_method(rb_cPGconn, "socket_io", pgconn_socket_io, 0);
+#endif
 	rb_define_method(rb_cPGconn, "backend_pid", pgconn_backend_pid, 0);
 	rb_define_method(rb_cPGconn, "connection_needs_password", pgconn_connection_needs_password, 0);
 	rb_define_method(rb_cPGconn, "connection_used_password", pgconn_connection_used_password, 0);
@@ -3465,7 +3553,11 @@ init_pg_connection()
 	rb_define_method(rb_cPGconn, "wait_for_notify", pgconn_wait_for_notify, -1);
 	rb_define_alias(rb_cPGconn, "notifies_wait", "wait_for_notify");
 	rb_define_method(rb_cPGconn, "quote_ident", pgconn_s_quote_ident, 1);
+#if defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL)
+	rb_define_alias(rb_cPGconn, "async_exec", "exec");
+#else
 	rb_define_method(rb_cPGconn, "async_exec", pgconn_async_exec, -1);
+#endif
 	rb_define_alias(rb_cPGconn, "async_query", "async_exec");
 	rb_define_method(rb_cPGconn, "get_last_result", pgconn_get_last_result, 0);
 

data/ext/pg_result.c

@@ -1,6 +1,6 @@
 /*
  * pg_result.c - PG::Result class extension
- * $Id: pg_result.c,v fe820dfcc7a6 2013/01/29 21:55:34 aaron $
+ * $Id$
  *
  */
 

data/lib/pg.rb

@@ -19,10 +19,10 @@ end
 module PG
 
 	# Library version
-	VERSION = '0.15.0'
+	VERSION = '0.15.0.pre.454'
 
 	# VCS revision
-	REVISION = %q$Revision: ef533f731814 $
+	REVISION = %q$Revision$
 
 
 	### Get the PG library version. If +include_buildnum+ is +true+, include the build ID.

data/lib/pg/connection.rb

@@ -64,20 +64,6 @@ class PG::Connection
 	class << self
 		define_method( :isthreadsafe, &PG.method(:isthreadsafe) )
 	end
-
-
-	### Fetch a memoized IO object created from the Connection's underlying socket.
-	### Using this avoids the problem of the underlying connection being closed by
-	### Ruby when an IO created using <tt>IO.for_fd(conn.socket)</tt> goes out of scope.
-	def socket_io
-		unless @socket_io
-			@socket_io = IO.for_fd( self.socket )
-			@socket_io.autoclose = false if @socket_io.respond_to?( :autoclose= )
-		end
-
-		return @socket_io
-	end
-
 end # class PG::Connection
 
 # Backward-compatible alias

data/sample/disk_usage_report.rb

@@ -24,7 +24,7 @@ rescue LoadError # 1.8 support
 	raise
 end
 
-SCRIPT_VERSION = %q$Id: disk_usage_report.rb,v 36ca5b412583 2012/04/17 23:32:25 mahlon $
+SCRIPT_VERSION = %q$Id$
 
 
 ### Gather data and output it to $stdout.

data/sample/pg_statistics.rb

@@ -32,7 +32,7 @@ end
 ### Optionally run in a continuous loop, displaying deltas.
 ###
 class Stats
-	VERSION = %q$Id: pg_statistics.rb,v 36ca5b412583 2012/04/17 23:32:25 mahlon $
+	VERSION = %q$Id$
 
 	def initialize( opts )
 		@opts = opts

data/sample/replication_monitor.rb

@@ -36,7 +36,7 @@ end
 ###
 class PGMonitor
 
-	VERSION = %q$Id: replication_monitor.rb,v 36ca5b412583 2012/04/17 23:32:25 mahlon $
+	VERSION = %q$Id$
 
 	# When to consider a slave as 'behind', measured in WAL segments.
 	# The default WAL segment size is 16, so we'll alert after

data/spec/lib/helpers.rb

@@ -181,7 +181,7 @@ module PG::TestingHelpers
 		require 'pg'
 		stop_existing_postmasters()
 
-		puts "Setting up test database for #{description} tests"
+		puts "Setting up test database for #{description}"
 		@test_pgdata = TEST_DIRECTORY + 'data'
 		@test_pgdata.mkpath
 
@@ -218,7 +218,7 @@ module PG::TestingHelpers
 
 		conn = PG.connect( @conninfo )
 		conn.set_notice_processor do |message|
-			$stderr.puts( message ) if $DEBUG
+			$stderr.puts( description + ':' + message ) if $DEBUG
 		end
 
 		return conn
@@ -227,9 +227,27 @@ module PG::TestingHelpers
 
 	def teardown_testing_db( conn )
 		puts "Tearing down test database"
-		conn.finish if conn
+
+		if conn
+			check_for_lingering_connections( conn )
+			conn.finish
+		end
+
 		log_and_run @logfile, 'pg_ctl', '-D', @test_pgdata.to_s, 'stop'
 	end
+
+
+	def check_for_lingering_connections( conn )
+		conn.exec( "SELECT * FROM pg_stat_activity" ) do |res|
+			conns = res.find_all {|row| row['pid'].to_i != conn.backend_pid }
+			unless conns.empty?
+				puts "Lingering connections remain:"
+				conns.each do |row|
+					puts "  [%d] {%s} %s -- %s" % row.values_at( 'pid', 'state', 'application_name', 'query' )
+				end
+			end
+		end
+	end
 end
 
 
@@ -241,7 +259,13 @@ RSpec.configure do |config|
 
 	config.mock_with :rspec
 	config.filter_run_excluding :ruby_19 if ruby_version_vec <= [1,9,1].pack( "N*" )
-	config.filter_run_excluding :unix if RUBY_PLATFORM =~ /mingw|mswin/
+	if RUBY_PLATFORM =~ /mingw|mswin/
+		config.filter_run_excluding :unix
+	else
+		config.filter_run_excluding :windows
+	end
+	config.filter_run_excluding :socket_io unless
+		PG::Connection.instance_methods.map( &:to_sym ).include?( :socket_io )
 
 	config.filter_run_excluding :postgresql_90 unless
 		PG::Connection.instance_methods.map( &:to_sym ).include?( :escape_literal )

data/spec/pg/connection_spec.rb

@@ -20,11 +20,15 @@ require 'pg'
 describe PG::Connection do
 
 	before( :all ) do
-		@conn = setup_testing_db( "PG_Connection" )
+		@conn = setup_testing_db( described_class.name )
 	end
 
 	before( :each ) do
 		@conn.exec( 'BEGIN' ) unless example.metadata[:without_transaction]
+		if PG.respond_to?( :library_version )
+			@conn.exec_params %Q{SET application_name TO '%s'} %
+				[@conn.escape_string(example.description[0,60])]
+		end
 	end
 
 	after( :each ) do
@@ -123,7 +127,7 @@ describe PG::Connection do
 		}.to raise_error( ArgumentError, /extra positional parameter/i )
 	end
 
-	it "can connect asynchronously", :unix do
+	it "can connect asynchronously", :socket_io do
 		tmpconn = described_class.connect_start( @conninfo )
 		tmpconn.should be_a( described_class )
 		socket = tmpconn.socket_io
@@ -145,7 +149,7 @@ describe PG::Connection do
 		tmpconn.finish
 	end
 
-	it "can connect asynchronously for the duration of a block", :unix do
+	it "can connect asynchronously for the duration of a block", :socket_io do
 		conn = nil
 
 		described_class.connect_start(@conninfo) do |tmpconn|
@@ -212,8 +216,7 @@ describe PG::Connection do
 		From backend> T
 		}.gsub( /^\t{2}/, '' ).lstrip
 
-	unless RUBY_PLATFORM =~ /mswin|mingw/
-		it "trace and untrace client-server communication" do
+	it "trace and untrace client-server communication", :unix do
 			# be careful to explicitly close files so that the
 			# directory can be removed and we don't have to wait for
 			# the GC to run.
@@ -242,7 +245,6 @@ describe PG::Connection do
 
 			trace_data.should == expected_trace_output
 		end
-	end
 
 	it "allows a query to be cancelled" do
 		error = false
@@ -255,7 +257,7 @@ describe PG::Connection do
 		error.should == true
 	end
 
-	it "automatically rolls back a transaction started with described_class#transaction if an exception " +
+	it "automatically rolls back a transaction started with Connection#transaction if an exception " +
 	   "is raised" do
 		# abort the per-example transaction so we can test our own
 		@conn.exec( 'ROLLBACK' )
@@ -515,7 +517,7 @@ describe PG::Connection do
 	end
 
 
-	it "can connect asynchronously", :unix do
+	it "can connect asynchronously", :socket_io do
 		serv = TCPServer.new( '127.0.0.1', 54320 )
 		conn = described_class.connect_start( '127.0.0.1', 54320, "", "", "me", "xxxx", "somedb" )
 		[PG::PGRES_POLLING_WRITING, PG::CONNECTION_OK].should include conn.connect_poll
@@ -544,6 +546,23 @@ describe PG::Connection do
 		expect { conn.finish }.to raise_error( PG::Error, /connection is closed/i )
 	end
 
+	it "closes the IO fetched from #socket_io when the connection is closed", :without_transaction, :socket_io do
+		conn = PG.connect( @conninfo )
+		io = conn.socket_io
+		conn.finish
+		io.should be_closed()
+		expect { conn.socket_io }.to raise_error( PG::Error, /connection is closed/i )
+	end
+
+	it "closes the IO fetched from #socket_io when the connection is reset", :without_transaction, :socket_io do
+		conn = PG.connect( @conninfo )
+		io = conn.socket_io
+		conn.reset
+		io.should be_closed()
+		conn.socket_io.should_not equal( io )
+		conn.finish
+	end
+
 
 	context "under PostgreSQL 9", :postgresql_90 do