Download Install Tutorial Docs FAQ Tools Wiki ∇ License Team IRC Planet Involvement Shop Book

Changeset 200

Show
Ignore:
Timestamp:
05/20/05 16:15:39
Author:
mikerobi
Message:

ram sessions might be threadsafe

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/ticket-132/cherrypy/_cpsession.py

    r183 r200  
    3131""" 
    3232 
    33 from lib.session.ramsession import RamSession, compatibleRamSession 
     33from lib.session.ramsession import RamSession  
    3434import cpg 
    3535import re 
    …… 
    4848    registerSession=staticmethod(registerSession) 
    4949     
    50 _sessionHelper.registerSession('backwardsRam', compatibleRamSession) 
    5150_sessionHelper.registerSession('ram', RamSession) 

  • branches/ticket-132/cherrypy/lib/session/ramsession.py

    r194 r200  
    2929import time 
    3030from basesession import BaseSession  
    31 from sessionmap import SessionMapClass 
    3231import cherrypy.cpg 
     32import mrow 
    3333 
    3434class RamSession(BaseSession): 
    …… 
    4040            if isinstance(self.dataKeys, list): 
    4141                self.dataKeys = dict.fromkeys(keys, None) 
     42            elif not isinstance(self.dataKeys, dict): 
     43                self.dataKeys = {} 
    4244        except: 
    4345            self.dataKeys = {} 
    44  
     46    __lock = mrow.RWLock() 
     47    def sessionReader(sessionFunc): 
     48        """Decorates a function as being a reader of the sessionMap. 
     49     
     50        Acquires a read lock on the sessionMap before calling `sessionFunc`, then 
     51        releases the lock after the call completes. 
     52         
     53        `sessionFunc` will also be called with a named argument, `sessionMap`, as a 
     54        convenience, set to `cpg.request.sessionMap`. 
     55     
     56        Example:: 
     57     
     58            @cpg.expose 
     59            @sessionReader 
     60            def index(self, sessionMap): 
     61                # Do stuff... 
     62        """ 
     63        def _inner(self, *args, **kw): 
     64            lock = self.__lock.reader() 
     65            try: 
     66                return sessionFunc(self, *args, **kw) 
     67            finally: 
     68                lock.release() 
     69        return _inner 
     70     
     71     
     72    def sessionWriter(sessionFunc): 
     73        """Same as sessionReader, except obtains an exclusive write lock.""" 
     74        def _inner(self, sessionKey, sessionValue): 
     75            lock = self.__lock.writer() 
     76            try: 
     77                return sessionFunc(self, sessionKey, sessionValue) 
     78            finally: 
     79                lock.release() 
     80        return _inner 
     81     
    4582    def newSession(self): 
    46         newSessionData = self.dataKeys.copy() 
    47         newSessionData.update({  
    48                                'createdAt'  : time.time(), 
    49                                'timeout'    : cherrypy.cpg.getConfig('session', 'timeout') * 60, 
    50                                'maxAge'     : None, 
    51                                'lastAccess' : time.time(), 
    52                                'sessionKey' : self.generateSessionId() 
    53                               }) 
    54         return SessionMapClass(newSessionData) 
     83        ns = self.dataKeys.copy() 
     84        ns.update({  
     85                   'createdAt'  : time.time(), 
     86                   'timeout'    : cherrypy.cpg.getConfig('session', 'timeout') * 60, 
     87                   'maxAge'     : None, 
     88                   'lastAccess' : time.time(), 
     89                   'sessionKey' : self.generateSessionId() 
     90                  }) 
     91        return ns.copy() 
    5592  
    5693    def __getitem__(self, sessionKey): 
    5794        return self.__data[sessionKey] 
    58  
     95    __getitem__ = sessionReader(__getitem__) 
     96     
    5997    def __setitem__(self, sessionKey, value): 
    6098        self.__data[sessionKey] = value 
     99    __setitem__ = sessionWriter(__setitem__) 
    61100 
    62     def __delete__(self, sessionKey): 
    63         del self.__data[sessionKey] 
     101    def __delitem__(self, sessionKey): 
     102        lock = self.__lock.writer() 
     103        try: 
     104            del self.__data[sessionKey] 
     105        finally: 
     106            lock.release() 
    64107     
    65108    def cleanUpOldSessions(self): 
    …… 
    70113            sessionAge  =  self['lastAccess'] -self['createdAt'] 
    71114            if (timeout and timeout < sessionAge) or (maxAge and  maxAge < sessionAge): 
    72                 del self.__data[sessionKey] 
     115                self.__delitem__(sessionKey) 
    73116 
    74 class compatibleRamSession(BaseSession): 
    75     __data = {} 
    76     class sessionMap(dict): 
    77         def __init__(self): 
    78             self['expirationTime'] = time.time() + cherrypy.cpg.getConfig('session', 'timeout') * 60 
    79      
    80     def newSession(self): 
    81         return {} 
    82      
    83     def get(self, sessionKey, default = None): 
    84         return self.__data.get(sessionKey, default) 
    85  
    86     def __getitem__(self, sessionKey): 
    87         return self.__data[sessionKey] 
    88  
    89     def __setitem__(self, sessionKey, value): 
    90         value['expirationTime'] = time.time() + cherrypy.cpg.getConfig('session', 'timeout') * 60 
    91         self.__data[sessionKey] = value 
    92  
    93     def __delete__(self, sessionKey): 
    94         del self.__data[sessionKey] 
    95      
    96     def cleanUpOldSessions(self): 
    97         now = time.time() 
    98         for key in __data: 
    99             if __data[key]['expirationTime']: 
    100                 pass 
    101                 del __data[key] 
    102  

  • branches/ticket-132/cherrypy/lib/session/sessionmap.py

    r194 r200  
    6969        if key == 'sessionKey' or key == 'createdAt': 
    7070            raise SessionImmutableError(key) 
    71         if self.__sessionData.has_key(key): 
    72             self.__sessionData[key] = value 
    73         else: 
    74             raise KeyError 
    75  
     71        self.__sessionData[key] = value 
     72     
    7673    def __iter__(self): 
    7774        return self.__sessionData.__iter__() 

  • branches/ticket-132/cherrypy/tutorial/08_sessions.py

    r182 r200  
    1515    def index(self): 
    1616        # Increase the silly hit counter 
    17         count = cpg.request.sessionMap['count'] + 1 
     17        count = cpg.request.sessionMap.get('count', 0) + 1 
    1818 
    1919        # Store the new value in the session dictionary 

Hosted by WebFaction

Log in as guest/cpguest to create tickets