The __del__() methods of steady connections and cursors not only were of no use, they could even result in infinite lookup recursions if the initialization had failed! Now, they really try to close the objects in question and check whether the objects are really opened. Also, it is now avoided to close things multiple times, and some more small things were improved in this context.

Author: Cito

DBUtils/SteadyDB.py

@@ -114,6 +114,8 @@ def connect(creator, maxusage=0, setsession=None, *args, **kwargs):
 class SteadyDBConnection:
 	"""A "tough" version of DB-API 2 connections."""
 
+	_closed = True
+
 	def __init__(self, creator, maxusage=0, setsession=None, *args, **kwargs):
 		""""Create a "tough" DB-API 2 connection."""
 		try:
@@ -133,13 +135,31 @@ def __init__(self, creator, maxusage=0, setsession=None, *args, **kwargs):
 		self._setsession_sql = setsession
 		self._args, self._kwargs = args, kwargs
 		self._closeable = 1
-		self._usage = 0
 		self._store(self._create())
 
 	def _create(self):
 		"""Create a new connection using the creator function."""
 		con = self._creator(*self._args, **self._kwargs)
-		self._setsession(con)
+		try:
+			try:
+				if self._dbapi.connect != self._creator:
+					raise AttributeError
+			except AttributeError:
+				try:
+					self._dbapi = sys.modules[con.__module__]
+					if not callable(self._dbapi.connect):
+						raise AttributeError
+				except (AttributeError, KeyError):
+					raise TypeError("Cannot determine DB-API 2 module.")
+			self._setsession(con)
+		except Exception, error:
+			# the database module could not be determined
+			# or the session could not be prepared
+			try: # close the connection first
+				con.close()
+			except Exception:
+				pass
+			raise error # reraise the original error again
 		return con
 
 	def _setsession(self, con=None):
@@ -155,16 +175,8 @@ def _setsession(self, con=None):
 	def _store(self, con):
 		"""Store a database connection for subsequent use."""
 		self._con = con
-		try:
-			if self._dbapi.connect != self._creator:
-				raise AttributeError
-		except AttributeError:
-			try:
-				self._dbapi = sys.modules[con.__module__]
-				if not callable(self._dbapi.connect):
-					raise AttributeError
-			except (AttributeError, KeyError):
-				raise TypeError("Cannot determine DB-API 2 module.")
+		self._closed = False
+		self._usage = 0
 
 	def _close(self):
 		"""Close the tough connection.
@@ -173,11 +185,12 @@ def _close(self):
 		and it will not complain if you close it more than once.
 
 		"""
-		try:
-			self._con.close()
-		except Exception:
-			pass
-		self._usage = 0
+		if not self._closed:
+			try:
+				self._con.close()
+			except Exception:
+				pass
+			self._closed = True
 
 	def dbapi(self):
 		"""Return the underlying DB-API 2 module of the connection."""
@@ -223,7 +236,7 @@ def _cursor(self, *args, **kwargs):
 					raise self._dbapi.OperationalError
 			cursor = self._con.cursor(*args, **kwargs) # try to get a cursor
 		except (self._dbapi.OperationalError,
-			self._dbapi.InternalError): # error in getting cursor
+				self._dbapi.InternalError), error: # error in getting cursor
 			try: # try to reopen the connection
 				con2 = self._create()
 			except Exception:
@@ -241,7 +254,7 @@ def _cursor(self, *args, **kwargs):
 					con2.close()
 				except Exception:
 					pass
-			raise # raise the original error again
+			raise error # reraise the original error again
 		return cursor
 
 	def cursor(self, *args, **kwargs):
@@ -250,19 +263,21 @@ def cursor(self, *args, **kwargs):
 
 	def __del__(self):
 		"""Delete the steady connection."""
-		if hasattr(self, '_con'):
-			del self._con
+		self._close() # make sure the connection is closed
 
 
 class SteadyDBCursor:
 	"""A "tough" version of DB-API 2 cursors."""
 
+	_closed = True
+
 	def __init__(self, con, *args, **kwargs):
 		""""Create a "tough" DB-API 2 cursor."""
 		self._con = con
 		self._args, self._kwargs = args, kwargs
 		self._clearsizes()
 		self._cursor = con._cursor(*args, **kwargs)
+		self._closed = False
 
 	def setinputsizes(self, sizes):
 		"""Store input sizes in case cursor needs to be reopened."""
@@ -298,10 +313,12 @@ def close(self):
 		It will not complain if you close it more than once.
 
 		"""
-		try:
-			self._cursor.close()
-		except Exception:
-			pass
+		if not self._closed:
+			try:
+				self._cursor.close()
+			except Exception:
+				pass
+			self._closed = True
 
 	def _get_tough_method(self, name):
 		"""Return a "tough" version of the method."""
@@ -319,7 +336,7 @@ def tough_method(*args, **kwargs):
 				if execute:
 					self._clearsizes()
 			except (self._con._dbapi.OperationalError,
-				self._con._dbapi.InternalError): # execution error
+					self._con._dbapi.InternalError), error: # execution error
 				try:
 					cursor2 = self._con._cursor(
 						*self._args, **self._kwargs) # open new cursor
@@ -379,7 +396,7 @@ def tough_method(*args, **kwargs):
 						con2.close()
 					except Exception:
 						pass
-				raise # raise the original error again
+				raise error # reraise the original error again
 			else:
 				self._con._usage += 1
 				return result
@@ -395,5 +412,4 @@ def __getattr__(self, name):
 
 	def __del__(self):
 		"""Delete the steady cursor."""
-		if hasattr(self, '_cursor'):
-			del self._cursor
+		self.close() # make sure the cursor is closed

DBUtils/SteadyPg.py

@@ -87,6 +87,8 @@ class SteadyPgConnection:
 
 	"""
 
+	_closed = True
+
 	def __init__(self, maxusage=0, setsession=None, *args, **kwargs):
 		"""Create a "tough" PostgreSQL connection.
 
@@ -102,9 +104,10 @@ def __init__(self, maxusage=0, setsession=None, *args, **kwargs):
 		self._maxusage = maxusage
 		self._setsession_sql = setsession
 		self._closeable = 1
-		self._usage = 0
 		self._con = PgConnection(*args, **kwargs)
+		self._closed = False
 		self._setsession()
+		self._usage = 0
 
 	def _setsession(self):
 		"""Execute the SQL commands for session preparation."""
@@ -119,11 +122,12 @@ def _close(self):
 		and it will not complain if you close it more than once.
 
 		"""
-		try:
-			self._con.close()
-			self._usage = 0
-		except Exception:
-			pass
+		if not self._closed:
+			try:
+				self._con.close()
+			except Exception:
+				pass
+			self._closed = True
 
 	def close(self):
 		"""Close the tough connection.
@@ -142,13 +146,17 @@ def close(self):
 	def reopen(self):
 		"""Reopen the tough connection.
 
-		It will not complain if the connection cannot be reopened."""
+		It will not complain if the connection cannot be reopened.
+
+		"""
 		try:
 			self._con.reopen()
-			self._setsession()
-			self._usage = 0
 		except Exception:
 			pass
+		else:
+			self._closed = False
+			self._setsession()
+			self._usage = 0
 
 	def reset(self):
 		"""Reset the tough connection.
@@ -207,5 +215,4 @@ def __getattr__(self, name):
 
 	def __del__(self):
 		"""Delete the steady connection."""
-		if hasattr(self, '_con'):
-			del self._con
+		self._close() # make sure the connection is closed

DBUtils/Testing/TestPersistentDB.py

@@ -138,7 +138,7 @@ def runQueries(i):
 		except TypeError:
 			queryQueue[1].put('close', 1)
 			r = resultQueue[1].get(1)
-		self.assertEqual(r, '1(0): ok - connection closed')
+		self.assertEqual(r, '1(3): ok - connection closed')
 		for j in range(2):
 			try:
 				queryQueue[1].put('select test%d' % j, 1, 0.1)

DBUtils/Testing/TestSteadyDB.py

@@ -25,8 +25,9 @@
 
 class Error(StandardError): pass
 class DatabaseError(Error): pass
-class InternalError(DatabaseError): pass
 class OperationalError(DatabaseError): pass
+class InternalError(DatabaseError): pass
+class ProgrammingError(DatabaseError): pass
 
 def connect(database=None, user=None):
 	return Connection(database, user)
@@ -40,6 +41,9 @@ def __init__(self, database=None, user=None):
 		self.num_uses = 0
 		self.num_queries = 0
 		self.session = []
+		if database == 'error':
+			self.valid = 0
+			raise OperationalError
 		self.valid = 1
 
 	def close(self):
@@ -57,18 +61,21 @@ def commit(self):
 	def rollback(self):
 		self.session.append('rollback')
 
-	def cursor(self):
+	def cursor(self, name=None):
 		if not self.valid:
 			raise InternalError
-		return Cursor(self)
+		return Cursor(self, name)
 
 class Cursor:
 
-	def __init__(self, con):
+	def __init__(self, con, name=None):
 		self.con = con
+		self.result = None
+		if name == 'error':
+			self.valid = 0
+			raise OperationalError
 		con.open_cursors += 1
 		self.valid = 1
-		self.result = None
 
 	def close(self):
 		if not self.valid:
@@ -77,7 +84,7 @@ def close(self):
 		self.valid = 0
 
 	def execute(self, operation):
-		if not self.valid:
+		if not self.valid or not self.con.valid:
 			raise InternalError
 		self.con.num_uses += 1
 		if operation.startswith('select '):
@@ -87,15 +94,17 @@ def execute(self, operation):
 			self.con.session.append(operation[4:])
 			self.result = None
 		else:
-			raise DatabaseError
+			raise ProgrammingError
 
 	def fetchone(self):
+		if not self.valid:
+			raise InternalError
 		result = self.result
 		self.result = None
 		return result
 
 	def callproc(self, procname):
-		if not self.valid:
+		if not self.valid or not self.con.valid:
 			raise InternalError
 		self.con.num_uses += 1
 
@@ -175,7 +184,23 @@ def test1_MockedDBConnection(self):
 		self.assertRaises(InternalError, db.close)
 		self.assertRaises(InternalError, db.cursor)
 
-	def test2_SteadyDBClose(self):
+	def test2_BrokenDBConnection(self):
+		db = SteadyDBconnect(dbapi, database='ok')
+		for i in range(3):
+			db.close()
+		del db
+		self.assertRaises(OperationalError, SteadyDBconnect,
+			dbapi, database='error')
+		db = SteadyDBconnect(dbapi, database='ok')
+		cursor = db.cursor()
+		for i in range(3):
+			cursor.close()
+		cursor = db.cursor('ok')
+		for i in range(3):
+			cursor.close()
+		self.assertRaises(OperationalError, db.cursor, 'error')
+
+	def test3_SteadyDBClose(self):
 		for closeable in (0, 1):
 			db = SteadyDBconnect(dbapi)
 			db._closeable = closeable
@@ -189,7 +214,7 @@ def test2_SteadyDBClose(self):
 			db._close()
 			self.assert_(not db._con.valid)
 
-	def test3_SteadyDBConnection(self):
+	def test4_SteadyDBConnection(self):
 		db = SteadyDBconnect(dbapi, 0, None,
 			'SteadyDBTestDB', user='SteadyDBTestUser')
 		self.assert_(hasattr(db, '_con'))
@@ -257,7 +282,7 @@ def test3_SteadyDBConnection(self):
 		db.close()
 		self.assert_(not db._con.valid)
 		self.assertEqual(db._con.open_cursors, 0)
-		self.assertEqual(db._usage, 0)
+		self.assertEqual(db._usage, 8)
 		self.assertEqual(db._con.num_uses, 0)
 		self.assertEqual(db._con.num_queries, 0)
 		self.assertRaises(InternalError, db._con.close)
@@ -304,7 +329,7 @@ def test3_SteadyDBConnection(self):
 		self.assertEqual(db._con.session,
 			['doit', 'commit', 'dont', 'rollback'])
 
-	def test4_SteadyDBConnectionCreatorFunction(self):
+	def test5_SteadyDBConnectionCreatorFunction(self):
 		db1 = SteadyDBconnect(dbapi, 0, None,
 			'SteadyDBTestDB', user='SteadyDBTestUser')
 		db2 = SteadyDBconnect(connect, 0, None,
@@ -317,7 +342,7 @@ def test4_SteadyDBConnectionCreatorFunction(self):
 		db2.close()
 		db1.close()
 
-	def test5_SteadyDBConnectionMaxUsage(self):
+	def test6_SteadyDBConnectionMaxUsage(self):
 		db = SteadyDBconnect(dbapi, 10)
 		cursor = db.cursor()
 		for i in range(100):
@@ -363,7 +388,7 @@ def test5_SteadyDBConnectionMaxUsage(self):
 		self.assertEqual(db._con.num_uses, 1)
 		self.assertEqual(db._con.num_queries, 1)
 
-	def test6_SteadyDBConnectionSetSession(self):
+	def test7_SteadyDBConnectionSetSession(self):
 		db = SteadyDBconnect(dbapi, 3, ('set time zone', 'set datestyle'))
 		self.assert_(hasattr(db, '_usage'))
 		self.assertEqual(db._usage, 0)