Friendsnippets

1. session support in werkzeug with sqlalchemy

   view plain - save this

   session object for werkzeug with sqlalchemy. This one use SessionStore object distributed with werkzeug

     1 # -*- coding: utf-8 -*-
     2 """"
     3 example of session support on werkzeug with sqlachemy
     4 all session data are saved in database. It override
     5 SessionStore object from werkzeug.contrib.sessions
     6 
     7  Setup :
     8 you have to set these settings :
     9 SESSION_COOKIE_NAME = 'SID'
    10 SESSION_COOKIE_AGE = 60 * 60 * 24 * 7 * 2
    11 SESSION_COOKIE_DOMAIN = None
    12 SESSION_COOKIE_PATH = '/'
    13 SESSION_COOKIE_SECURE = False
    14 
    15 DBSession is a basic sqlalchemy session
    16 related to your wsgi application.
    17 
    18     store and session object directly in the application dispatching::
    19 
    20         session_store = FilesystemSessionStore()
    21 
    22         def application(environ, start_response):
    23             request = Request(environ)
    24             sid = request.cookie.get('cookie_name')
    25             if sid is None:
    26                 request.session = session_store.new()
    27             else:
    28                 request.session = session_store.get(sid)
    29             response = get_the_response_object(request)
    30             if request.session.should_save:
    31                max_age = settings.SESSION_COOKIE_AGE
    32                expires = time.time() + settings.SESSION_COOKIE_AGE
    33                session_store.save(request.session)
    34                response.set_cookie(settings.SESSION_COOKIE_NAME, 
    35                         request.session.sid, 
    36                         expires=expires, max_age = max_age,
    37                         path=settings.SESSION_COOKIE_PATH, 
    38                         domain=settings.SESSION_COOKIE_DOMAIN, 
    39                         secure=settings.SESSION_COOKIE_SECURE)
    40 
    41             return response(environ, start_response)
    42 """"
    43 
    44 
    45 
    46 from datetime import datetime, timedelta
    47 import base64
    48 import md5
    49 import random
    50 import cPickle as pickle
    51 
    52 from sqlalchemy.orm import synonym
    53 
    54 from werkzeug.contrib.sessions import Session,SessionStore
    55 
    56 from database import DBSession
    57 import settings
    58 
    59 session_table = Table('session', metadata,
    60         Column('session_key', Unicode(40), primary_key=True),
    61         Column('session_data', Binary),
    62         Column('expire_date', DateTime)
    63 )
    64 
    65 class SuspiciousOperation(Exception):
    66     pass
    67 
    68 class SessionModel(object):
    69     def __init__(self, session_key, session_data=None, expire_date=None):
    70         self.session_key = session_key
    71         self.session_data = session_data
    72         self.expire_date = expire_date
    73 
    74     def __repr__(self):
    75         return "<%s(%s)>" % (self.__class__.__name__ , self.session_key)
    76 
    77     def _encode(self, session_data):
    78         pickled = pickle.dumps(session_data)
    79         pickled_md5 = md5.new(pickled + settings.SECRET_KEY).hexdigest()
    80         self._session_data = base64.encodestring(pickled + pickled_md5)
    81 
    82     def _decode(self):
    83         encoded_data = base64.decodestring(self._session_data)
    84         pickled, tamper_check = encoded_data[:-32], encoded_data[-32:]
    85         if md5.new(pickled + settings.SECRET_KEY).hexdigest() != tamper_check:
    86             raise SuspiciousOperation, "User tampered with session cookie."
    87         try:
    88             return pickle.loads(pickled)
    89         # Unpickling can cause a variety of exceptions. If something happens,
    90         # just return an empty dictionary (an empty session).
    91         except:
    92             return {}
    93 
    94     session_data = property(_decode, _encode)
    95 
    96 DBSession.mapper(SessionModel, session_table, properties = {
    97     'session_data':synonym('_session_data', map_column=True)
    98 })
    99 
   100 class DatabaseSessionStore(SessionStore):
   101     def __init__(self, session_class=Session):
   102         SessionStore.__init__(self, session_class)
   103 
   104     def save(self, session):
   105         s = DBSession.query(SessionModel).get(session.sid)
   106         if s:
   107             s.session_data = dict(session)
   108             expire_date = datetime.now() + timedelta(seconds=settings.SESSION_COOKIE_AGE)
   109         else:
   110             s=SessionModel(
   111                 session_key=session.sid, 
   112                 session_data=dict(session),
   113                 expire_date = datetime.now() + timedelta(seconds=settings.SESSION_COOKIE_AGE)
   114             )
   115         DBSession.expunge(s)
   116         DBSession.save_or_update(s)
   117         DBSession.commit()
   118 
   119     def delete(self, session):
   120         try:
   121             DBSession.delete(DBSession.query(SessionModel).get(session_key=session.sid))
   122         except:
   123             pass
   124         return {}
   125 
   126     def get(self, sid):
   127         s=DBSession.query(SessionModel).filter(SessionModel.session_key==sid).first()
   128         if not s or not self.is_valid_key(sid):
   129             return self.new()
   130 
   131         return self.session_class(s.session_data, sid, False)
   

   Posted by benoitc to python session werkzeug sqlalchemy database ... saved by 1 person ... 0 comments ... 8 months, 1 week

Pages : 1