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

Changeset 938

Show
Ignore:
Timestamp:
01/25/06 10:17:37
Author:
rdelon
Message:

Fixed silly mistake from previous changeset in sessionfilter. pep8-ified code

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/cherrypy/filters/sessionfilter.py

    r937 r938  
    1010 
    1111Variables used to store temporary variables: 
    12     - sess.sessionStorage (instance of the class implementing the backend) 
     12    - sess.session_storage (instance of the class implementing the backend) 
    1313 
    1414 
    1515Variables used to store the session for the current request: 
    16     - sess.sessionData: dictionary containing the actual session data 
     16    - sess.session_data: dictionary containing the actual session data 
    1717    - sess.sessionID: current session ID 
    18     - sess.expirationTime: date/time when the current session will expire 
     18    - sess.expiration_time: date/time when the current session will expire 
    1919 
    2020Global variables (RAM backend only): 
    …… 
    6969        if ((not conf('session_filter.on', False)) 
    7070              or conf('static_filter.on', False)): 
    71             sess.sessionStorage = None 
     71            sess.session_storage = None 
    7272            return 
    7373         
    …… 
    106106        # People can set their own custom class 
    107107        #   through session_filter.storage_class 
    108         sess.sessionStorage = conf('session_filter.storage_class', None) 
    109         if sess.sessionStorage is None: 
    110             sess.sessionStorage = globals()[storage + 'Storage']() 
     108        sess.session_storage = conf('session_filter.storage_class', None) 
     109        if sess.session_storage is None: 
     110            sess.session_storage = globals()[storage + 'Storage']() 
    111111        else: 
    112             sess.sessionStorage = sess.sessionStorage() 
     112            sess.session_storage = sess.session_storage() 
    113113         
    114114        # Check if we need to clean up old sessions 
    115115        if cherrypy._session_last_clean_up_time + cleanUpDelay < now: 
    116             sess.sessionStorage.clean_up() 
     116            sess.session_storage.clean_up() 
    117117         
    118118        # Check if request came with a session ID 
    …… 
    123123            # If using implicit locking, acquire lock 
    124124            if sess.sessionLocking == 'implicit': 
    125                 sess.sessionData = {'_id': sess.sessionID} 
    126                 sess.sessionStorage.acquire_lock() 
     125                sess.session_data = {'_id': sess.sessionID} 
     126                sess.session_storage.acquire_lock() 
    127127             
    128             data = sess.sessionStorage.load(sess.sessionID) 
    129             # data is either None or a tuple (sessionData, expirationTime) 
     128            data = sess.session_storage.load(sess.sessionID) 
     129            # data is either None or a tuple (session_data, expiration_time) 
    130130            if data is None or data[1] < now: 
    131131                # Expired session: 
    132132                # flush session data (but keep the same sessionID) 
    133                 sess.sessionData = {'_id': sess.sessionID} 
     133                sess.session_data = {'_id': sess.sessionID} 
    134134            else: 
    135                 sess.sessionData = data[0] 
     135                sess.session_data = data[0] 
    136136        else: 
    137137            # No sessionID yet 
    138138            sess.sessionID = sess.generate_session_id() 
    139             sess.sessionData = {'_id': sess.sessionID} 
    140             sess.onCreateSession(sess.sessionData) 
     139            sess.session_data = {'_id': sess.sessionID} 
     140            sess.onCreateSession(sess.session_data) 
    141141        # Set response cookie 
    142142        cookie = cherrypy.response.simpleCookie 
    …… 
    160160            # Save session data 
    161161            t = datetime.timedelta(seconds = sess.sessionTimeout * 60) 
    162             expirationTime = datetime.datetime.now() + t 
    163             sess.sessionStorage.save(sess.sessionID, sess.sessionData, 
    164                                      expirationTime) 
     162            expiration_time = datetime.datetime.now() + t 
     163            sess.session_storage.save(sess.sessionID, sess.session_data, 
     164                                     expiration_time) 
    165165            if sess.locked: 
    166166                # Always release the lock if the user didn't release it 
    167                 sess.sessionStorage.release_lock() 
     167                sess.session_storage.release_lock() 
    168168             
    169169            # If the body is not a generator, we save the data 
    …… 
    174174         
    175175        sess = cherrypy.request._session 
    176         if not getattr(sess, 'sessionStorage', None): 
     176        if not getattr(sess, 'session_storage', None): 
    177177            # Sessions are not enabled: do nothing 
    178178            return 
    …… 
    184184    def on_end_request(self): 
    185185        sess = cherrypy.request._session 
    186         if not getattr(sess, 'sessionStorage', None): 
     186        if not getattr(sess, 'session_storage', None): 
    187187            # Sessions are not enabled: do nothing 
    188188            return 
    189189        if getattr(sess, 'locked', None): 
    190190            # If the session is still locked we release the lock 
    191             sess.sessionStorage.release_lock() 
    192         if getattr(sess, 'sessionStorage', None): 
    193             del sess.sessionStorage 
     191            sess.session_storage.release_lock() 
     192        if getattr(sess, 'session_storage', None): 
     193            del sess.session_storage 
    194194 
    195195 
    …… 
    200200        return cherrypy._session_data_holder.get(id) 
    201201     
    202     def save(self, id, data, expirationTime): 
    203         cherrypy._session_data_holder[id] = (data, expirationTime) 
     202    def save(self, id, data, expiration_time): 
     203        cherrypy._session_data_holder[id] = (data, expiration_time) 
    204204     
    205205    def acquire_lock(self): 
    …… 
    227227    def clean_up(self): 
    228228        sess = cherrypy.request._session 
    229         toBeDeleted = [] 
     229        to_be_deleted = [] 
    230230        now = datetime.datetime.now() 
    231         for id, (data, expirationTime) in cherrypy._session_data_holder.iteritems(): 
    232             if expirationTime < now: 
    233                 toBeDeleted.append(id) 
    234         for id in toBeDeleted: 
     231        for id, (data, expiration_time) in cherrypy._session_data_holder.iteritems(): 
     232            if expiration_time < now: 
     233                to_be_deleted.append(id) 
     234        for id in to_be_deleted: 
    235235            try: 
     236                deleted_session = cherrypy._session_data_holder[id] 
    236237                del cherrypy._session_data_holder[id] 
    237                 sess.onDeleteSession(cherrypy._session_data_holder[id]) 
     238                sess.onDeleteSession(deleted_session) 
    238239            except KeyError: 
    239240                # The session probably got deleted by a concurrent thread 
    …… 
    258259            return None 
    259260     
    260     def save(self, id, data, expirationTime): 
     261    def save(self, id, data, expiration_time): 
    261262        filePath = self._getFilePath(id) 
    262263        f = open(filePath, "wb") 
    263         pickle.dump((data, expirationTime), f) 
     264        pickle.dump((data, expiration_time), f) 
    264265        f.close() 
    265266     
    …… 
    292293                try: 
    293294                    f = open(filePath, "rb") 
    294                     data, expirationTime = pickle.load(f) 
     295                    data, expiration_time = pickle.load(f) 
    295296                    f.close() 
    296                     if expirationTime < now: 
     297                    if expiration_time < now: 
    297298                        # Session expired: deleting it 
    298299                        id = fname[len(self.SESSION_PREFIX):] 
    …… 
    355356        if not rows: 
    356357            return None 
    357         pickled_data, expirationTime = rows[0] 
     358        pickled_data, expiration_time = rows[0] 
    358359        # Unpickle data 
    359360        data = pickle.loads(pickled_data) 
    360         return (data, expirationTime) 
    361      
    362     def save(self, id, data, expirationTime): 
     361        return (data, expiration_time) 
     362     
     363    def save(self, id, data, expiration_time): 
    363364        # Try to delete session if it was already there 
    364365        self.cursor.execute( 
    …… 
    370371        self.cursor.execute( 
    371372            'insert into session (id, data, expiration_time) values (%s, %s, %s)', 
    372             (id, pickled_data, expirationTime)) 
     373            (id, pickled_data, expiration_time)) 
    373374     
    374375    def acquire_lock(self): 
    …… 
    406407#   to be thread-specific so we use a special wrapper that forwards 
    407408#   calls to cherrypy.session to a thread-specific dictionary called 
    408 #   cherrypy.request._session.sessionData 
     409#   cherrypy.request._session.session_data 
    409410class SessionWrapper: 
    410411     
    411412    def __getattr__(self, name): 
    412413        sess = cherrypy.request._session 
    413         if sess.sessionStorage is None: 
     414        if sess.session_storage is None: 
    414415            raise SessionNotEnabledError() 
    415416        # Create thread-specific dictionary if needed 
    416         sess.sessionData = getattr(sess, 'sessionData', {}) 
     417        sess.session_data = getattr(sess, 'session_data', {}) 
    417418        if name == 'acquire_lock': 
    418             return sess.sessionStorage.acquire_lock 
     419            return sess.session_storage.acquire_lock 
    419420        elif name == 'release_lock': 
    420             return sess.sessionStorage.release_lock 
    421         return getattr(sess.sessionData, name) 
    422  
     421            return sess.session_storage.release_lock 
     422        return getattr(sess.session_data, name) 
     423 

Hosted by WebFaction

Log in as guest/cpguest to create tickets