Changeset 1736

Timestamp:

10/04/07 03:10:31

Author:

fumanchu

Message:

New MemcachedSession? class. The Session class API had to change a bit: 'setup' must now be a classmethod.

Files:

• trunk/cherrypy/lib/sessions.py (modified) (5 diffs)
• trunk/cherrypy/test/test_session.py (modified) (2 diffs)

trunk/cherrypy/lib/sessions.py

@@ -243 +243 @@
-    LOCK_SUFFIX = '.lock'
-    
-self
+cls, **kwargs
-        """Set up the storage system for file-based sessions.
-        
@@ -249 +249 @@
-        automatically when using sessions.init (as the built-in Tool does).
-        """
+        for k, v in kwargs.iteritems():
+            setattr(cls, k, v)
+        
-        # Warn if any lock files exist at startup.
-self
-self
-self
+cls
+cls
+cls
-        if lockfiles:
-            plural = ('', 's')[len(lockfiles) > 1]
@@ -259 +262 @@
-                 "manually delete the lockfiles found at %r."
-                 % (len(lockfiles), plural,
-
+
+
-    
-    def _get_file_path(self):
@@ -397 +401 @@
-
-
+class MemcachedSession(Session):
+    
+    locks = {}
+    servers = ['127.0.0.1:11211']
+    
+    def setup(cls, **kwargs):
+        """Set up the storage system for memcached-based sessions.
+        
+        This should only be called once per process; this will be done
+        automatically when using sessions.init (as the built-in Tool does).
+        """
+        for k, v in kwargs.iteritems():
+            setattr(cls, k, v)
+        
+        import memcache
+        cls.cache = memcache.Client(cls.servers)
+    setup = classmethod(setup)
+    
+    def _load(self):
+        return self.cache.get(self.id)
+    
+    def _save(self, expiration_time):
+        # Send the expiration time as "Unix time" (seconds since 1/1/1970)
+        zeroday = datetime.datetime(1970, 1, 1, tzinfo=expiration_time.tzinfo)
+        td = expiration_time - zeroday
+        td = (td.days * 86400) + td.seconds
+        if not self.cache.set(self.id, (self._data, expiration_time), td):
+            raise AssertionError("Session data for id %r not set." % self.id)
+    
+    def _delete(self):
+        self.cache.delete(self.id)
+    
+    def acquire_lock(self):
+        """Acquire an exclusive lock on the currently-loaded session data."""
+        self.locked = True
+        self.locks.setdefault(self.id, threading.RLock()).acquire()
+    
+    def release_lock(self):
+        """Release the lock on the currently-loaded session data."""
+        self.locks[self.id].release()
+        self.locked = False
+
+
-# Hook functions (for CherryPy tools)
-
@@ -466 +513 @@
-        id = request.cookie[name].value
-    
+    # Find the storage class and call setup (first time only).
+    storage_class = storage_type.title() + 'Session'
+    storage_class = globals()[storage_class]
+    if not hasattr(cherrypy, "session"):
+        if hasattr(storage_class, "setup"):
+            storage_class.setup(**kwargs)
+    
-    # Create and attach a new Session instance to cherrypy.serving.
-    # It will possess a reference to (and lock, and lazily load)
-    # the requested session data.
-    storage_class = storage_type.title() + 'Session'
-    kwargs['timeout'] = timeout
-    kwargs['clean_freq'] = clean_freq
-globals()[storage_class]
+storage_class
-    
-    # Create cherrypy.session which will proxy to cherrypy.serving.session
-    if not hasattr(cherrypy, "session"):
-        cherrypy.session = cherrypy._ThreadLocalProxy('session')
-        if hasattr(sess, "setup"):
-            sess.setup()
-    
-    # Set response cookie

trunk/cherrypy/test/test_session.py

@@ -44 +44 @@
-        def setsessiontype(self, newtype):
-            self.__class__._cp_config.update({'tools.sessions.storage_type': newtype})
+            if hasattr(cherrypy, "session"):
+                del cherrypy.session
-        setsessiontype.exposed = True
+        setsessiontype._cp_config = {'tools.sessions.on': False}
-        
-        def index(self):
@@ -202 +205 @@
-
-
+try:
+    import memcache
+except ImportError:
+    pass
+else:
+    class MemcachedSessionTest(helper.CPWebCase):
+        
+        def test_0_Session(self):
+            self.getPage('/setsessiontype/memcached')
+            
+            self.getPage('/testStr')
+            self.assertBody('1')
+            self.getPage('/testGen', self.cookies)
+            self.assertBody('2')
+            self.getPage('/testStr', self.cookies)
+            self.assertBody('3')
+            self.getPage('/delkey?key=counter', self.cookies)
+            self.assertStatus(200)
+            
+            # Wait for the session.timeout (1.02 secs)
+            time.sleep(1.25)
+            self.getPage('/')
+            self.assertBody('1')
+            
+            # Test session __contains__
+            self.getPage('/keyin?key=counter', self.cookies)
+            self.assertBody("True")
+            
+            # Test session delete
+            self.getPage('/delete', self.cookies)
+            self.assertBody("done")
+        
+        def test_1_Concurrency(self):
+            client_thread_count = 5
+            request_count = 30
+            
+            # Get initial cookie
+            self.getPage("/")
+            self.assertBody("1")
+            cookies = self.cookies
+            
+            data_dict = {}
+            
+            def request(index):
+                for i in xrange(request_count):
+                    self.getPage("/", cookies)
+                    # Uncomment the following line to prove threads overlap.
+##                    print index,
+                if not self.body.isdigit():
+                    self.fail(self.body)
+                data_dict[index] = v = int(self.body)
+            
+            # Start <request_count> concurrent requests from
+            # each of <client_thread_count> clients
+            ts = []
+            for c in xrange(client_thread_count):
+                data_dict[c] = 0
+                t = threading.Thread(target=request, args=(c,))
+                ts.append(t)
+                t.start()
+            
+            for t in ts:
+                t.join()
+            
+            hitcount = max(data_dict.values())
+            expected = 1 + (client_thread_count * request_count)
+            self.assertEqual(hitcount, expected)
+        
+        def test_3_Redirect(self):
+            # Start a new session
+            self.getPage('/testStr')
+            self.getPage('/iredir', self.cookies)
+            self.assertBody("memcached")
+        
+        def test_5_Error_paths(self):
+            self.getPage('/unknown/page')
+            self.assertErrorPage(404, "The path '/unknown/page' was not found.")
+            
+            # Note: this path is *not* the same as above. The above
+            # takes a normal route through the session code; this one
+            # skips the session code's before_handler and only calls
+            # before_finalize (save) and on_end (close). So the session
+            # code has to survive calling save/close without init.
+            self.getPage('/restricted', self.cookies, method='POST')
+            self.assertErrorPage(405, "Specified method is invalid for this server.")
+
+
+
+
-if __name__ == "__main__":
-    setup_server()