Use the errno's that are *not* fatal to identify the fatal ones.

James William Pye · James William Pye · commit a151f99c1f05 · 2010-03-20T19:54:51.000-07:00
The fatal list was far too long. Also, use os.strerror to get the error's string rather than writing our own. fixes #41
diff --git a/postgresql/exceptions.py b/postgresql/exceptions.py
@@ -1,6 +1,5 @@
 ##
-# copyright 2009, James William Pye
-# http://python.projects.postgresql.org
+# .exceptions - Exception hierarchy for PostgreSQL database ERRORs.
 ##
 """
 PostgreSQL exceptions and warnings with associated state codes.
diff --git a/postgresql/python/socket.py b/postgresql/python/socket.py
@@ -1,11 +1,8 @@
 ##
-# copyright 2009, James William Pye
-# http://python.projects.postgresql.org
+# .python.socket - additional tools for working with sockets
 ##
-"""
-socket tools
-"""
 import sys
+import os
 import random
 import socket
 import math
@@ -23,46 +20,38 @@ class SocketFactory(object):
 	Additionally, it provides methods and attributes for abstracting
 	exception management on socket operation.
 	"""
-	fatal_exception_messages = {
-		errno.ECONNRESET : 'server explicitly closed the connection',
-		errno.EPIPE : 'broken connection detected on send',
-		errno.ECONNREFUSED : 'server refused connection',
-		errno.EHOSTUNREACH : 'server is not reachable',
-		errno.EBADF : 'bad file descriptor',
-	}
-	if sys.platform in ('win32', 'win64'):
-		fatal_exception_messages.update({
-			errno.WSAECONNABORTED : 'server aborted the connection',
-		})
 
 	timeout_exception = socket.timeout
 	fatal_exception = socket.error
 	try_again_exception = socket.error
 
 	def timed_out(self, err) -> bool:
-		return type(err) is self.timeout_exception
+		return err.__class__ is self.timeout_exception
 
-	def try_again(self, err) -> bool:
+	@staticmethod
+	def try_again(err, codes = (errno.EAGAIN, errno.EINTR, errno.EWOULDBLOCK, errno.ETIMEDOUT)) -> bool:
 		"""
-		Does the error indicate that the operation should be
-		tried again?
-		"""
-		return getattr(err, 'errno', 0) == errno.EINTR
+		Does the error indicate that the operation should be tried again?
 
-	def connection_refused(self, err) -> bool:
-		"""
-		Does the error indicate that the connection was explicitly
-		refused by the server?
+		More importantly, the connection is *not* dead.
 		"""
-		return getattr(err, 'errno', 0) == errno.ECONNREFUSED
+		errno = getattr(err, 'errno', None)
+		if errno is None:
+			return False
+		return errno in codes
 
 	@classmethod
 	def fatal_exception_message(typ, err) -> (str, None):
 		"""
 		If the exception was fatal to the connection,
 		what message should be given to the user?
 		"""
-		return typ.fatal_exception_messages.get(err.errno)
+		if typ.try_again(err):
+			return None
+		strerr = getattr(err, 'strerror', None)
+		if strerr is not None:
+			return str(strerr)
+		return os.strerror(err.errno)
 
 	def secure(self, socket : socket.socket) -> ssl.SSLSocket:
 		"secure a socket with SSL"
diff --git a/postgresql/test/test_driver.py b/postgresql/test/test_driver.py
@@ -1694,5 +1694,28 @@ def testNamedTuples(self):
 		self.failUnlessEqual(r[2], "hello")
 		self.failUnlessEqual(r.param, "hello")
 
+	@pg_tmp
+	def testBadFD(self):
+		db.pq.socket.close()
+		# bad fd now.
+		self.failUnlessRaises(
+			pg_exc.ConnectionFailureError,
+			sqlexec, "SELECT 1"
+		)
+		self.failUnless(issubclass(pg_exc.ConnectionFailureError, pg_exc.Disconnection))
+
+	@pg_tmp
+	def testAdminTerminated(self):
+		killer = new()
+		killer.sys.terminate_backends()
+		# hoping that this will guarantee that the terminate is complete
+		killer.close()
+
+		self.failUnlessRaises(
+			pg_exc.AdminShutdownError,
+			sqlexec, "SELECT 1"
+		)
+		self.failUnless(issubclass(pg_exc.AdminShutdownError, pg_exc.Disconnection))
+
 if __name__ == '__main__':
 	unittest.main()
