Ticket #1: locking-shelves.diff

session.py

@@ -45 +45 @@
-           'SessionStore',
-           'MemorySessionStore',
-           'ShelveSessionStore',
+           'LockingShelveSessionStore',
-           'DiskSessionStore',
-           'SessionMiddleware']
-
@@ -395 +396 @@
-    def _shutdown(self):
-        self._secondaryStore.close()
-
+# LockingShelveSessionStore contributed by Julian Cigar <jcigar@ulb.ac.be>
+
+LOCK_TIMEOUT = 60
+
+class FileLock(object):
+
+    def __init__(self, lock_file):
+        self._lock_file = lock_file
+
+    def acquireLock(self, timeout=LOCK_TIMEOUT):
+
+        for i in xrange(1, timeout*10):
+            try:
+                os.open(self._lock_file, os.O_WRONLY | os.O_CREAT | os.O_EXCL,
+                        0660)
+                return True
+            except:
+                time.sleep(0.1)
+                continue
+
+        try:
+            self.isStale() and self.releaseLock()
+        except:
+            pass
+
+        return False
+    
+    def isStale(self):
+        try:
+            return os.stat(self._lock_file).st_mtime < time.time() - 3600
+        except OSError:
+            return False
+
+    def releaseLock(self):
+        os.path.isfile(self._lock_file) and os.unlink(self._lock_file)
+
+    def withLock(self, self_, fct, args):
+        if self.acquireLock():
+            try:
+                return fct(self_, *args)
+            finally:
+                self.releaseLock()
+        else:
+            raise IOError('Cannot acquire lock')
+
+def with_lock(fct):
+    return lambda self, *args: self.lock.withLock(self, fct, args)
+
+class LockingShelveSessionStore(SessionStore):
+    def __init__(self, storeFile='sessions', *a, **kw):
+        super(LockingShelveSessionStore, self).__init__(*a, **kw)
+
+        self.storeFile = storeFile
+        lock_file = os.path.join(os.path.dirname(self.storeFile), '.lock')
+        self.lock = FileLock(lock_file)
+
+    def _createSession(self, identifier):
+        secondaryStore = shelve.open(self.storeFile)
+        try:
+            if secondaryStore.has_key(identifier):
+                return None
+            sess = self._sessionClass(identifier)
+            secondaryStore[sess.identifier] = sess
+            return sess
+        finally:
+            secondaryStore.close()
+    _createSession = with_lock(_createSession)
+
+    def _loadSession(self, identifier):
+        secondaryStore = shelve.open(self.storeFile)
+        try:
+            return secondaryStore.get(identifier, None)
+        finally:
+            secondaryStore.close()
+    _loadSession = with_lock(_loadSession)
+
+    def _saveSession(self, session):
+        secondaryStore = shelve.open(self.storeFile)
+        try:
+            secondaryStore[session.identifier] = session
+        finally:
+            secondaryStore.close()
+    _saveSession = with_lock(_saveSession)
+
+    def _deleteSession(self, identifier):
+        secondaryStore = shelve.open(self.storeFile)
+        try:
+            if secondaryStore.has_key(identifier):
+                del secondaryStore[identifier]
+        finally:
+            secondaryStore.close()
+    _deleteSession = with_lock(_deleteSession)
+
+    def _periodic(self):
+        secondaryStore = shelve.open(self.storeFile)
+        try:
+            now = time.time()
+            for key,sess in secondaryStore.items():
+                if self._isSessionTimedout(sess, now):
+                    del secondaryStore[key]
+        finally:
+            secondaryStore.close()
+    _periodic = with_lock(_periodic)
+
+    def _shutdown(self):
+        pass
+
-class DiskSessionStore(SessionStore):
-    """
-    Disk-based session store that stores each session as its own file
@@ -766 +874 @@
-
-if __name__ == '__main__':
-    mss = MemorySessionStore(timeout=5)
+    sss = LockingShelveSessionStore(timeout=5)
-#    sss = ShelveSessionStore(timeout=5)
-
+#