Added (still experimental) flup session support

1 files changed, 91 insertions, 0 deletions

diff --git a/paste/flup_session.py b/paste/flup_session.py
new file mode 100644
index 0000000..b4b4caf
--- /dev/null
+++ b/paste/flup_session.py
@@ -0,0 +1,91 @@
+"""
+Creates a session object; then in your application, use::
+
+    environ['paste.flup_session_service'].session
+
+This will return a dictionary.  The contents of this dictionary will
+be saved to disk when the request is completed.  The session will be
+created when you first fetch the session dictionary, and a cookie will
+be sent in that case.  There's current no way to use sessions without
+cookies, and there's no way to delete a session except to clear its
+data.
+"""
+
+import httpexceptions
+import wsgilib
+from paste.util import thirdparty
+thirdparty.add_package('flup')
+import flup.middleware.session
+flup_session = flup.middleware.session
+
+# This is a dictionary of existing stores, keyed by a tuple of
+# store type and parameters
+store_cache = {}
+
+class SessionMiddleware(object):
+
+    session_classes = {
+        'memory': (flup_session.MemorySessionStore,
+                   [('session_timeout', 'timeout', int, 60)]),
+        'disk': (flup_session.DiskSessionStore,
+                 [('session_timeout', 'timeout', int, 60),
+                  ('session_dir', 'storeDir', str, '/tmp/sessions')]),
+        'shelve': (flup_session.ShelveSessionStore,
+                   [('session_timeout', 'timeout', int, 60),
+                    ('session_file', 'storeFile', str,
+                     '/tmp/session.shelve')]),
+        }
+
+
+    def __init__(self, application):
+        self.application = application
+        
+    def __call__(self, environ, start_response):
+        conf = environ['paste.config']
+
+        session_type = conf.get('session_type', 'disk')
+        try:
+            store_class, store_args = self.session_classes[session_type]
+        except KeyError:
+            raise KeyError(
+                "The session_type %s is unknown (I know about %s)"
+                % (session_type,
+                   ', '.join(self.session_classes.keys())))
+        kw = {}
+        param_tuple = [session_type]
+        for config_name, kw_name, coercer, default in store_args:
+            value = coercer(conf.get(config_name, default))
+            param_tuple.append(value)
+            kw[kw_name] = value
+        param_tuple = tuple(param_tuple)
+        if param_tuple in store_cache:
+            store = store_cache[param_tuple]
+        else:
+            store = store_cache[param_tuple] = store_class(**kw)
+
+        cookie_name = conf.get('session_cookie', '_SID_')
+
+        service = flup_session.SessionService(
+            store, environ, cookieName=cookie_name,
+            fieldName=cookie_name)
+        environ['paste.flup_session_service'] = service
+
+        def cookie_start_response(status, headers, exc_info=None):
+            service.addCookie(headers)
+            print "Added headers:", headers
+            return start_response(status, headers, exc_info)
+
+        try:
+            app_iter = self.application(environ, cookie_start_response)
+        except httpexceptions.HTTPException, e:
+            headers = (e.headers or {}).items()
+            service.addCookie(headers)
+            e.headers = dict(headers)
+            service.close()
+            raise
+        except:
+            service.close()
+            raise
+
+        return wsgilib.add_close(app_iter, service.close)
+