view MoinMoin/web/ @ 5576:6b94d284ad11

avoid writing key/value to session dict if value doesn't change
author Thomas Waldmann <tw AT waldmann-edv DOT de>
date Tue, 23 Feb 2010 03:41:30 +0100
parents 17cf01154e12
children 092ce221f03a
line wrap: on
line source

# -*- coding: iso-8859-1 -*-
    MoinMoin - WSGI session handling

    To provide sessions, the MoinMoin WSGI application interacts with an
    object implementing the `SessionService` API. The interface is quite
    straight forward. For documentation of the expected methods, refer
    to the documentation of `SessionService` in this module.

    @copyright: 2008 MoinMoin:FlorianKrupicka,
                2009 MoinMoin:ThomasWaldmann
    @license: GNU GPL, see COPYING for details.
import sys, os
from os import path
import time
import tempfile
import re
    from cPickle import load, dump, HIGHEST_PROTOCOL
except ImportError:
    from pickle import load, dump, HIGHEST_PROTOCOL

from werkzeug.contrib.sessions import SessionStore, ModificationTrackingDict

from MoinMoin import config
from MoinMoin.util import filesys
rename = filesys.rename # use MoinMoin's rename until we have it in werkzeug 0.6.1

from MoinMoin import log
logging = log.getLogger(__name__)

# start copy from werkzeug 0.6 - directly import this, if we require >= 0.6:

class Session(ModificationTrackingDict):
    """Subclass of a dict that keeps track of direct object changes.  Changes
    in mutable structures are not tracked, for those you have to set
    `modified` to `True` by hand.
    __slots__ = ModificationTrackingDict.__slots__ + ('sid', 'new')

    def __init__(self, data, sid, new=False):
        ModificationTrackingDict.__init__(self, data)
        self.sid = sid = new

    def should_save(self):
        """True if the session should be saved.

        .. versionchanged:: 0.6
           By default the session is now only saved if the session is
           modified, not if it is new like it was before.
        return self.modified

    def __repr__(self):
        return '<%s %s %s%s>' % (
            self.should_save and '*' or ''

#: used for temporary files by the filesystem session store
_fs_transaction_suffix = '.__wz_sess'

class FilesystemSessionStore(SessionStore):
    """Simple example session store that saves sessions on the filesystem.
    This store works best on POSIX systems and Windows Vista / Windows
    Server 2008 and newer.

    .. versionchanged:: 0.6
       `renew_missing` was added.  Previously this was considered `True`,
       now the default changed to `False` and it can be explicitly

    :param path: the path to the folder used for storing the sessions.
                 If not provided the default temporary directory is used.
    :param filename_template: a string template used to give the session
                              a filename.  ``%s`` is replaced with the
                              session id.
    :param session_class: The session class to use.  Defaults to
    :param renew_missing: set to `True` if you want the store to
                          give the user a new sid if the session was
                          not yet saved.

    def __init__(self, path=None, filename_template='werkzeug_%s.sess',
                 session_class=None, renew_missing=False, mode=0644):
        SessionStore.__init__(self, session_class)
        if path is None:
            path = tempfile.gettempdir()
        self.path = path
        if isinstance(filename_template, unicode):
            filename_template = filename_template.encode(
                sys.getfilesystemencoding() or 'utf-8')
        assert not filename_template.endswith(_fs_transaction_suffix), \
            'filename templates may not end with %s' % _fs_transaction_suffix
        self.filename_template = filename_template
        self.renew_missing = renew_missing
        self.mode = mode

    def get_session_filename(self, sid):
        # out of the box, this should be a strict ASCII subset but
        # you might reconfigure the session object to have a more
        # arbitrary string.
        if isinstance(sid, unicode):
            sid = sid.encode(sys.getfilesystemencoding() or 'utf-8')
        return path.join(self.path, self.filename_template % sid)

    def save(self, session):
        fn = self.get_session_filename(session.sid)
        fd, tmp = tempfile.mkstemp(suffix=_fs_transaction_suffix,
        f = os.fdopen(fd, 'wb')
            dump(dict(session), f, HIGHEST_PROTOCOL)
            rename(tmp, fn)
            os.chmod(fn, self.mode)
        except (IOError, OSError):

    def delete(self, session):
        fn = self.get_session_filename(session.sid)
        except OSError:

    def get(self, sid):
        if not self.is_valid_key(sid):
            f = open(self.get_session_filename(sid), 'rb')
        except IOError:
            if self.renew_missing:
            data = {}
                    data = load(f)
                except Exception:
                    data = {}
        return self.session_class(data, sid, False)

    def list(self):
        """Lists all sessions in the store.

        .. versionadded:: 0.6
        before, after = self.filename_template.split('%s', 1)
        filename_re = re.compile(r'%s(.{5,})%s$' % (re.escape(before),
        result = []
        for filename in os.listdir(self.path):
            #: this is a session that is still being saved.
            if filename.endswith(_fs_transaction_suffix):
            match = filename_re.match(filename)
            if match is not None:
        return result

# end copy of werkzeug 0.6 code

class MoinSession(Session):
    """ Compatibility interface to Werkzeug-sessions for old Moin-code.

        is_new is DEPRECATED and will go away soon.
    def _get_is_new(self):
        logging.warning("Deprecated use of MoinSession.is_new, please use .new")
    is_new = property(_get_is_new)

class SessionService(object):
    A session service returns a session object given a request object and
    provides services like persisting sessions and cleaning up occasionally.
    def get_session(self, request, sid=None):
        """ Return a session object pertaining to the particular request."""
        raise NotImplementedError

    def destroy_session(self, request, session):
        """ Destroy an existing session (make it unusable). """
        raise NotImplementedError

    def finalize(self, request, session):
        If the service needs to do anything to the session and/or request,
        before it is sent back to the client, he can chose to do so here.
        Typical examples would be setting cookies for the client.
        raise NotImplementedError

    def get_all_session_ids(self, request):
        Return a list of all session ids known to the SessionService.
        raise NotImplementedError

def _get_session_lifetime(request, userobj):
    """ Get session lifetime for the user object userobj
    Cookie lifetime in hours, can be fractional. First tuple element is for anonymous sessions,
    second tuple element is for logged-in sessions. For anonymous sessions,
    t=0 means that they are disabled, t>0 means that many hours.
    For logged-in sessions, t>0 means that many hours,
    or forever if user checked 'remember_me', t<0 means -t hours and
    ignore user 'remember_me' setting - you usually don't want to use t=0, it disables logged-in sessions."""
    lifetime = int(float(request.cfg.cookie_lifetime[userobj and userobj.valid]) * 3600)
    forever = 10 * 365 * 24 * 3600 # 10 years

    if userobj and userobj.valid and userobj.remember_me and lifetime > 0:
        return forever
    return abs(lifetime)

def get_cookie_name(request, name, usage, software='MOIN'):
    Determine the full cookie name for some software (usually 'MOIN') using
    it for some usage (e.g. 'SESSION') for some wiki (or group of wikis)
    determined by name.

    We do not use the path=... information in the cookie any more, because it can
    easily cause confusion if there are multiple cookies with same name, but
    different pathes (like e.g. / and /foo).

    Instead of using the cookie path, we use differently named cookies, so we get
    the right cookie no matter at what URL the wiki currently is "mounted".

    If name is None, we use some URL components to make up some name.
    For example the cookie name for the default desktop wiki: MOIN_SESSION_8080_ROOT

    If name is siteidmagic, we just use cfg.siteid, which is unique within a wiki farm
    created by a single farmconfig. If you only run ONE(!) wikiconfig wiki, it
    is also unique, of course, but not if you run multiple wikiconfig wikis under
    same domain.

    If name is not None (and not 'siteidmagic'), we just use the given name (you
    want to use that to share stuff between several wikis - just give same name
    and it will use the same cookie. same thing if you don't want to share, just
    give a different name then [e.g. if cfg.siteid or 'siteidmagic' doesn't work
    for you]).

    Moving a wiki to a different URL will break all sessions. Exchanging URLs
    of wikis might lead to confusion (requiring the client to purge the cookies).
    if name is None:
        url_components = [
            # cookies do not store the port, thus we add it to the cookie name:
            # we always store path=/ into cookie, thus we add the path to the name:
            ('ROOT' + request.script_root).replace('/', '_'),
        name = '_'.join(url_components)

    elif name is 'siteidmagic':
        name = request.cfg.siteid  # == config name, unique per farm

    return "%s_%s_%s" % (software, usage, name)

class FileSessionService(SessionService):
    This sample session service stores session information in a temporary
    directory and identifies the session via a cookie in the request/response
    cycle. It is based on werkzeug's FilesystemSessionStore, that implements
    the whole logic for creating the actual session objects (which are
    inherited from the builtin `dict`)
    def __init__(self, cookie_usage='SESSION'):
        self.cookie_usage = cookie_usage

    def _store_get(self, request):
        path = request.cfg.session_dir
        except OSError:
        return FilesystemSessionStore(path=path, filename_template='%s',
                                      session_class=MoinSession, mode=0666 & config.umask)

    def get_session(self, request, sid=None):
        if sid is None:
            cookie_name = get_cookie_name(request, name=request.cfg.cookie_name, usage=self.cookie_usage)
            sid = request.cookies.get(cookie_name, None)
        logging.debug("get_session for sid %r" % sid)
        store = self._store_get(request)
        if sid is None:
            session =
            session = store.get(sid)
        logging.debug("get_session returns session %r" % session)
        return session

    def get_all_session_ids(self, request):
        store = self._store_get(request)
        return store.list()

    def destroy_session(self, request, session):
        store = self._store_get(request)

    def finalize(self, request, session):
        def update_session(key, val):
            """ put key/val into session, avoid writing if it is unchanged """
                current_val = session[key]
            except KeyError:
                session[key] = val
                if val != current_val:
                    session[key] = val

        if request.user.auth_method == 'setuid':
            userobj = request._setuid_real_user
            setuid =
            userobj = request.user
            setuid = None
        logging.debug("finalize userobj = %r, setuid = %r" % (userobj, setuid))
        cfg = request.cfg
        # we use different cookie names for different wikis:
        cookie_name = get_cookie_name(request, name=request.cfg.cookie_name, usage=self.cookie_usage)
        # we always use path='/' except if explicitly overridden by configuration,
        # which is usually not needed and not recommended:
        cookie_path = cfg.cookie_path or '/'
        if userobj and userobj.valid:
            update_session('user.auth_method', userobj.auth_method)
            update_session('user.auth_attribs', userobj.auth_attribs)
            if setuid:
                update_session('setuid', setuid)
            elif 'setuid' in session:
                del session['setuid']
            logging.debug("after auth: storing valid user into session: %r" %
            logging.debug("after auth: user is invalid")
            if '' in session:
                logging.debug("after auth: destroying session: %r" % session)
                self.destroy_session(request, session)
                logging.debug("after auth: deleting session cookie!")
                request.delete_cookie(cookie_name, path=cookie_path, domain=cfg.cookie_domain)

        cookie_lifetime = _get_session_lifetime(request, userobj)
        if cookie_lifetime:
            # we use 60s granularity, so we don't trigger session storage updates too often
            cookie_expires = int(time.time() / 60) * 60 + cookie_lifetime
            # a secure cookie is not transmitted over unsecure connections:
            cookie_secure = (cfg.cookie_secure or  # True means: force secure cookies
                             cfg.cookie_secure is None and request.is_secure)  # None means: https -> secure cookie
            logging.debug("user: %r, setting session cookie: %r" % (userobj, session.sid))
            request.set_cookie(cookie_name, session.sid,
                               max_age=cookie_lifetime, expires=cookie_expires,
                               path=cookie_path, domain=cfg.cookie_domain,
                               secure=cookie_secure, httponly=cfg.cookie_httponly)

            # add some info about expiry to the sessions, so we can purge them:
            update_session('expires', cookie_expires)

            if ((not userobj.valid and not  # anon users with a cookie (not first request)
                 userobj.valid) # logged-in users, even if THIS was the first request (no cookie yet)
                                # XXX if UA doesn't support cookies, this creates 1 session file per request
                session.should_save): # only if we really have something to save
                store = self._store_get(request)
                logging.debug("saving session: %r" % session)