Removed usage of the "as" identifier to work with the newer pythons "…

…as" keyword. Updated Pinger.py testcode to use sqlite3 modules.

lib/mixminion/server/Pinger.py

@@ -47,7 +47,7 @@
      succeedingMidnight, UIError, writePickled
 
 try:
-    import sqlite
+    import sqlite3
 except ImportError:
     sqlite = None
 
@@ -111,7 +111,7 @@ def __init__(self, location):
         """Create a SQLite database storing its data in the file 'location'."""
         parent = os.path.split(location)[0]
         createPrivateDir(parent)
-        self._theConnection = sqlite.connect(location, autocommit=0)
+        self._theConnection = sqlite3.connect(location, isolation_level=None)
         self._theCursor = self._theConnection.cursor()
 
     def close(self):
@@ -1506,7 +1506,7 @@ def getPingGenerator(config):
 def canRunPinger():
     """Return true iff we have the required libraries installed to run a pinger.
     """
-    return sys.version_info[:2] >= (2,2) and sqlite is not None
+    return sys.version_info[:2] >= (2,2) and sqlite3 is not None
 
 # Map from database type name to databae implementation class.
 DATABASE_CLASSES = { 'sqlite' : SQLiteDatabase }

lib/mixminion/server/ServerQueue.py

@@ -617,16 +617,16 @@ def _rebuildNextAttempt(self, now=None):
         try:
             for ds in self.store._metadata_cache.values():
                 if not self.addressStateDB.has_key(str(ds.address)):
-                    as = _AddressState(ds.address)
-                    self.addressStateDB[str(ds.address)] = as
+                    as_ = _AddressState(ds.address)
+                    self.addressStateDB[str(ds.address)] = as_
             if not self.retrySchedule:
                 rs = [3600]
                 self.totalLifetime = 3600
             else:
                 rs = self.retrySchedule
                 self.totalLifetime = reduce(operator.add,self.retrySchedule,0)
-            for as in self.addressStateDB.values():
-                as.setNextAttempt(rs, now)
+            for addr_state in self.addressStateDB.values():
+                addr_state.setNextAttempt(rs, now)
             self._repOK()
         finally:
             self._lock.release()
@@ -643,10 +643,10 @@ def removeExpiredMessages(self, now=None):
                 else:
                     have[ds.address]=1
 
-            for k, as in self.addressStateDB.items():
-                if have.has_key(as.address):
+            for k, addr_state in self.addressStateDB.items():
+                if have.has_key(addr_state.address):
                     continue
-                lastActivity = as.getLastActivity()
+                lastActivity = addr_state.getLastActivity()
                 if lastActivity and (
                     lastActivity + self.totalLifetime < now):
                     del self.addressStateDB[k]
@@ -655,11 +655,11 @@ def removeExpiredMessages(self, now=None):
 
     def _getAddressState(self, address, now=None):
         try:
-            as = self.addressStateDB[str(address)]
+            addr_state = self.addressStateDB[str(address)]
         except KeyError:
-            as = self.addressStateDB[str(address)] = _AddressState(address)
-            as.setNextAttempt(self.retrySchedule, now)
-        return as
+            addr_state = self.addressStateDB[str(address)] = _AddressState(address)
+            addr_state.setNextAttempt(self.retrySchedule, now)
+        return addr_state
 
     def queueDeliveryMessage(self, msg, address, now=None):
         self._getAddressState(address, now=now)
@@ -767,8 +767,8 @@ def _inspect(self,handle):
         self._repOK()
         o = self.store.getObject(handle)
         ds = self.store.getMetadata(handle)
-        as = self._getAddressState(ds.address)
-        return (o, ds, as)
+        addr_state = self._getAddressState(ds.address)
+        return (o, ds, addr_state)
 
     def _repOK(self):
         """Raise an assertion error if the internal state of this object is
@@ -780,8 +780,8 @@ def _repOK(self):
             DeliveryQueue._repOK(self)
             for h in self.store._metadata_cache.keys():
                 ds = self.store._metadata_cache[h]
-                as = self._getAddressState(ds.address)
-                assert as.address == ds.address
+                addr_state = self._getAddressState(ds.address)
+                assert addr_state.address == ds.address
         finally:
             self._lock.release()
 

lib/mixminion/test.py

@@ -3470,16 +3470,16 @@ def testPerAddressDeliveryQueue(self):
         msgs[h3].failed(now=start+40, retriable=1)
         self.assert_(not q._inspect(h3)[1].isPending())
 
-        as = q.addressStateDB[str(A1)]
-        self.assertIEquals(as.lastSuccess-start, 30)
-        self.assertIEquals(as.firstFailure-start, 10)
-        self.assertIEquals(as.lastFailure-start, 10)
-        self.assertIEquals(as.nextAttempt-start, 10+HOUR)
-        as = q.addressStateDB[str(A2)]
-        self.assertIEquals(as.lastSuccess-start, 20)
-        self.assertEquals(as.firstFailure, None)
-        self.assertEquals(as.lastFailure, None)
-        self.assertIEquals(as.nextAttempt-start, 20)
+        addr_state = q.addressStateDB[str(A1)]
+        self.assertIEquals(addr_state.lastSuccess-start, 30)
+        self.assertIEquals(addr_state.firstFailure-start, 10)
+        self.assertIEquals(addr_state.lastFailure-start, 10)
+        self.assertIEquals(addr_state.nextAttempt-start, 10+HOUR)
+        addr_state = q.addressStateDB[str(A2)]
+        self.assertIEquals(addr_state.lastSuccess-start, 20)
+        self.assertEquals(addr_state.firstFailure, None)
+        self.assertEquals(addr_state.lastFailure, None)
+        self.assertIEquals(addr_state.nextAttempt-start, 20)
 
         # Queue two more messages; the one on A2 gets tried; the ones on
         # A1 doesn't get tried for a while.
@@ -3495,13 +3495,13 @@ def testPerAddressDeliveryQueue(self):
         q.sendReadyMessages(start+HOUR+MIN)
         msgs = self._pendingMsgDict(q._msgs)
         self.assertUnorderedEq(msgs.keys(), [h3, h4])
-        as = q.addressStateDB[str(A1)]
+        addr_state = q.addressStateDB[str(A1)]
         msgs[h3].failed(now=start+HOUR+MIN+5, retriable=1)
         msgs[h4].failed(now=start+HOUR+MIN+5, retriable=1)
 
-        self.assertIEquals(as.firstFailure-start, 10)
-        self.assertIEquals(as.lastFailure-start, HOUR+MIN)
-        self.assertIEquals(as.nextAttempt-start, 10+2*HOUR)
+        self.assertIEquals(addr_state.firstFailure-start, 10)
+        self.assertIEquals(addr_state.lastFailure-start, HOUR+MIN)
+        self.assertIEquals(addr_state.nextAttempt-start, 10+2*HOUR)
 
         h6 = q.queueDeliveryMessage("The sixth message", A1,
                                     now=start+HOUR*17-MIN)
@@ -3525,13 +3525,13 @@ def testPerAddressDeliveryQueue(self):
         self.assertUnorderedEq(q.addressStateDB.keys(), [str(A1)])
 
         # Make sure that messages keep getting retried...
-        as = q.addressStateDB[str(A1)]
+        addr_state = q.addressStateDB[str(A1)]
         # (Reset nextDelivery on A1, since not all the delivery attempts
         # have really happened.)
         q.sendReadyMessages(now=start+HOUR*17+MIN*15)
         msgs = self._pendingMsgDict(q._msgs)
         msgs[h6].failed(now=start+HOUR*17+MIN*16, retriable=0)
-        self.assertEquals(as.nextAttempt - start, 25*HOUR+10)
+        self.assertEquals(addr_state.nextAttempt - start, 25*HOUR+10)
         self.assertEquals([], q.store.getAllMessages())
 
         # Test reloading.