Changeset 597

Timestamp:

09/03/05 05:43:19

Author:

rdelon

Message:

More session improvements: support cleaning up old sessions, support notifying users when a session is created/deleted, new PostgreSQL backend

Files:

• trunk/cherrypy/__init__.py (modified) (2 diffs)
• trunk/cherrypy/lib/filter/sessionfilter.py (modified) (4 diffs)
• trunk/cherrypy/test/test_session_filter.py (modified) (3 diffs)

trunk/cherrypy/__init__.py

@@ -33 +33 @@
-__version__ = '2.1.0-beta'
-
+import datetime
+
-from _cperror import *
-
-import config
-import server
@@ -60 +61 @@
-threadData = local()
-
+# Create variables needed for session (see lib/sessionfilter.py for more info)
-from lib.filter import sessionfilter
-session = sessionfilter.SessionWrapper()
+_sessionDataHolder = {} # Needed for RAM sessions only
+_sessionLockDict = {} # Needed for RAM sessions only
+_sessionLastCleanUpTime = datetime.datetime.now()
-
-# decorator function for exposing methods

trunk/cherrypy/lib/filter/sessionfilter.py

@@ -28 +28 @@
-
-""" Session implementation for CherryPy.
-
-
+
+
+
+
-
-Variables used to store config options:
-td._
-td._
+sess.
+sess.
-
-Variables used to store temporary variables:
-td._
+sess.
-
-
-Variables used to store the session for the current request:
-td._sessionData: diction
-td._
-td._expirationTime: 
+sess.sessionData: dictio
+sess.
+sess.expirationTime: date/
-
-Global variables (RAM backend only):
-n
-n
+
+
-
-"""
-
+import datetime
-import sha
-import os
-import pickle
-import random
+import StringIO
+import time
-import threading
-ime
+ypes
-
-import basefilter
-
-
-
+
+
+
+
+
+
+
+
+
-
-class SessionFilter(basefilter.BaseFilter):
@@ -66 +78 @@
-        # We have to dynamically import cherrypy because Python can't handle
-        #   circular module imports :-(
-, td
+
-        import cherrypy
-
-
-
+
+
+
+
+
+
+
+
-            return
-
+        sess.locked = False # Not locked by default
+
-        # Read config options
-td._
+sess.
-            cherrypy.config.get('sessionFilter.timeout', 60)
-
-td._
+sess.
-            cherrypy.config.get('sessionFilter.locking', 'implicit')
+
+        sess.onCreateSession = \
+            cherrypy.config.get('sessionFilter.onCreateSession',
+                lambda data: None)
+
+        sess.onDeleteSession = \
+            cherrypy.config.get('sessionFilter.onDeleteSession',
+                lambda data: None)
+
+        cleanUpDelay = \
+            cherrypy.config.get('sessionFilter.cleanUpDelay', 5)
-
-        cookieName = \
-            cherrypy.config.get('sessionFilter.cookieName', 'sessionID')
-
+        sess.deadlockTimeout = \
+            cherrypy.config.get('sessionFilter.deadlockTimeout', 30)
+
-        storage = cherrypy.config.get('sessionFilter.storageType', 'Ram')
-
-
-
+
+
+
+
+
+
+
+
+
-
-        # Check if request came with a session ID
-        if cookieName in cherrypy.request.simpleCookie:
-            # It did: we try to load the session data
-
-
+
+
+
+
+
+
-            # data is either None or a tuple (sessionData, expirationTime)
-time.time()
+now
-                # Expired session: flush session data (but keep the same
-                #   sessionID)
-td._sessionData = {
+sess.sessionData = {'_id': sess.sessionID
-            else:
-td._
+sess.
-        else:
-            # No sessionID yet
-td._
-td._sessionData = {
-td._sessionData['_id'] = td._sessionID
+sess.
+sess.sessionData = {'_id': sess.sessionID
+    sess.onCreateSession(sess.sessionData)
-        # Set response cookie
-td._
+sess.
-        cherrypy.response.simpleCookie[cookieName]['path'] = '/'
-        cherrypy.response.simpleCookie[cookieName]['max-age'] = \
-td._
+sess.
-        cherrypy.response.simpleCookie[cookieName]['version'] = 1
-
-        # If using implicit locking, acquire lock
-        if td._sessionLocking == 'implicit':
-            td._sessionStorage.acquireLock()
-
-    def beforeFinalize(self):
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-            return
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-
-    def onEndResource(self):
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
-
-class RamStorage:
-    """ Implementation of the RAM backend for sessions """
-    def __init__(self):
-        try:
-            cherrypy._sessionDataHolder
-        except:
-            cherrypy._sessionDataHolder = {}
-        try:
-            cherrypy._sessionLockDict
-        except:
-            cherrypy._sessionLockDict = {}
-
-    def load(self, id):
-        return cherrypy._sessionDataHolder.get(id)
-
-data
+, expirationTime
+(data, expirationTime)
-    def acquireLock(self):
+        sess = cherrypy.threadData._session
-        id = cherrypy.session['_id']
-        lock = cherrypy._sessionLockDict.get(id)
@@ -160 +212 @@
-            lock = threading.Lock()
-            cherrypy._sessionLockDict[id] = lock
-
+
+
+
+
+
+
+
-    def releaseLock(self):
+        sess = cherrypy.threadData._session
-        id = cherrypy.session['_id']
-        cherrypy._sessionLockDict[id].release()
+        sess.locked = False
+    def cleanUp(self):
+        sess = cherrypy.threadData._session
+        toBeDeleted = []
+        now = datetime.datetime.now()
+        for id, (data, expirationTime) in cherrypy._sessionDataHolder.iteritems():
+            if expirationTime < now:
+                toBeDeleted.append(id)
+        for id in toBeDeleted:
+            sess.onDeleteSession(cherrypy._sessionDataHolder[id])
+            del cherrypy._sessionDataHolder[id]
-
-class FileStorage:
-    """ Implementation of the File backend for sessions """
+    SESSION_PREFIX = 'session-'
+    LOCK_SUFFIX = '.lock'
-    def load(self, id):
-        filePath = self._getFilePath(id)
@@ -174 +246 @@
-            f.close()
-            return data
-
-(None, None)
-
+ IOError
+None
+, expirationTime
-        filePath = self._getFilePath(id)
-        f = open(filePath, "wb")
-data
+(data, expirationTime)
-        f.close()
-    def acquireLock(self):
-
-
-
+
-        filePath = self._getFilePath(cherrypy.session['_id'])
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        while True:
-            try:
-lockFileP
+p
-            except OSError:
-
+
+
-            else:
-                os.close(lockfd) 
-                break
+    def _unlockFile(self, path):
+        os.unlink(path)
+
+class PostgreSQLStorage:
+    """ Implementation of the PostgreSQL backend for sessions. It assumes
+        a table like this:
+
+            create table session (
+                id varchar(40),
+                data text,
+                expiration_time timestamp
+            )
+    """
+    def __init__(self):
+        self.db = cherrypy.config.get('sessionFilter.getDB')()
+        self.cursor = self.db.cursor()
+    def __del__(self):
+        if self.cursor:
+            self.cursor.close()
+        self.db.commit()
+    def load(self, id):
+        # Select session data from table
+        self.cursor.execute(
+            'select data, expiration_time from session where id=%s',
+            (id,))
+        rows = self.cursor.fetchall()
+        if not rows:
+            return None
+        data, expirationTime = rows[0]
+        # Unpickle data
+        f = StringIO.StringIO(data)
+        data = pickle.load(f)
+        return (data, expirationTime)
+    def save(self, id, data, expirationTime):
+        # Try to delete session if it was already there
+        self.cursor.execute(
+            'delete from session where id=%s',
+            (id,))
+        # Pickle data
+        f = StringIO.StringIO()
+        pickle.dump(data, f)
+        # Insert new session data
+        self.cursor.execute(
+            'insert into session (id, data, expiration_time) values (%s, %s, %s)',
+            (id, f.getvalue(), expirationTime))
+
+    def acquireLock(self):
+        # We use the "for update" clause to lock the row
+        self.cursor.execute(
+            'select id from session where id=%s for update',
+            (cherrypy.session['_id'],))
-
-    def releaseLock(self):
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-def generateSessionID():
-Function to r
+R
-        return sha.new('%s' % random.random()).hexdigest()
-
-# Users access sessions through cherrypy.session, but we want this
-#   to be thread-specific so we use a special wrapper that forwards
-n
-
+
+.session
-class SessionWrapper(object):
-    def __getattribute__(self, name):
-
-
-
-
-
+
+
+
-        if name == 'acquireLock':
-td._
+sess.
-        elif name == 'releaseLock':
-td._
-td._
+sess.
+sess.
-    def __getitem__(self, *a, **b):
-
+
+
-    def __setitem__(self, *a, **b):
-
+
+
+
+
+

trunk/cherrypy/test/test_session_filter.py

@@ -27 +27 @@
-"""
-
-
+, time, os
-
-class Root:
-index
+testGen
-        counter = cherrypy.session.get('counter', 0) + 1
-        cherrypy.session['counter'] = counter
-        yield str(counter)
-
+
+
+
+
+
+
-    
-cherrypy.root = Root()
@@ -41 +46 @@
-        'server.environment': 'production',
-        'sessionFilter.on': True,
+        'sessionFilter.storageType' : 'file',
+        'sessionFilter.storagePath' : '.',
-})
-
@@ -48 +55 @@
-    
-    def testSessionFilter(self):
-
+testStr
-        self.assertBody('1')
-
+testGen
-        self.assertBody('2')
-
+testStr
-        self.assertBody('3')
+        cherrypy.config.update({
+            'sessionFilter.storageType' : 'file',
+        })
+        self.getPage('/testStr')
+        self.assertBody('1')
+        self.getPage('/testGen', self.cookies)
+        self.assertBody('2')
+        self.getPage('/testStr', self.cookies)
+        self.assertBody('3')
+
+        # Clean up session files
+        for fname in os.listdir('.'):
+            if fname.startswith('session-'):
+                os.unlink(fname)
+        
-        
-if __name__ == "__main__":