session.py :  » Web-Services » Python-Service-Objects » pso-0.98.D » py » pso » Python Open Source

Home
Python Open Source
1.3.1.2 Python
2.Ajax
3.Aspect Oriented
4.Blog
5.Build
6.Business Application
7.Chart Report
8.Content Management Systems
9.Cryptographic
10.Database
11.Development
12.Editor
13.Email
14.ERP
15.Game 2D 3D
16.GIS
17.GUI
18.IDE
19.Installer
20.IRC
21.Issue Tracker
22.Language Interface
23.Log
24.Math
25.Media Sound Audio
26.Mobile
27.Network
28.Parser
29.PDF
30.Project Management
31.RSS
32.Search
33.Security
34.Template Engines
35.Test
36.UML
37.USB Serial
38.Web Frameworks
39.Web Server
40.Web Services
41.Web Unit
42.Wiki
43.Windows
44.XML
Python Open Source » Web Services » Python Service Objects 
Python Service Objects » pso 0.98.D » py » pso » session.py
#   session.py  - Python Service Objects
#
#   Author: Thanos Vassilakis thanos@0x01.com
#
#     Copyright (c) thanos vassilakis 2000,2001, 2002
#
#  This library is free software; you can redistribute it and/or 
#  modify it under the terms of the GNU Lesser General Public License 
#  as published by the Free Software Foundation; either version 2.1 of the 
#  License, or (at your option) any later version.
#
#  This library is distributed in the hope that it will be useful, but 
#  WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
#  or FITNESS FOR A PARTICULAR PURPOSE.  
#  See the GNU Lesser General Public License for more details.
#
#  See terms of license at gnu.org. 
#
#   $Id: session.py,v 1.15 2004/07/12 03:52:06 thanos Exp $
#
__version__="$Revision: 1.15 $"

from weakref import ref
from time import time,strftime,gmtime
from cPickle import load,dump
from tempfile import mktemp
from util import MixIn,log
import sys, os


try:
  mapClass = dict
except:
  import UserDict 
  mapClass = UserDict.UserDict


class SessionImpl:
  "abstract implementaion class"

  DEFAULTServiceIdKey = "PSOServiceId"
  DEFAULTSessionIdKey = "PSOSessionId"
  DEFAULTServiceIdValue = "SESSION_ID"


  def getServiceId(self,  reqHandler): 
    """session.getServiceId(requestHandler) -> String ~ The service id, set in the HTTP directive, is returned. 
      This will default to the script's name"""
    return reqHandler.getEnviron(self.DEFAULTServiceIdKey, self.getDefaultServiceId())

  def getDefaultServiceId(self):
    return self.DEFAULTServiceIdValue

  def getSessionId(self,  reqHandler): 
    """session.getSessionId(requestHandler) -> String | None ~ The current session id returned.   
      If none return None.
      By default will look for a HTTP directive <i>ServiceId</i>"""
    return reqHandler.getEnviron(self.DEFAULTSessonIdKey)
  def load(self,  reqHandler, session): 
    "session.load(requestHandler) -> Session"
  def save(self,  reqHandler, session): 
    "session.session(requestHandler, self) -> None"
  def revert(self,  reqHandler): 
    "session.revert(requestHandler, self) -> None ~reverts the session to last saved copy."
    
  def expire(self,  reqHandler, when): 
    """
    session.expire(requestHandler, when) -> None ~ if when is evals 
    to a number  will expire the session in when seconds, otherwise will try and parse when as a date.
    For more on this format see <a href="http://www.faqs.org/rfcs/rfc2068.html">RFC2068</a> section 3.3.1 
    [also <a href="http://www.faqs.org/rfcs/rfc822.html">RCF822</a> and  
    <a href="http://www.faqs.org/rfcs/rfc1123.html">RCF1123</a>]
    """
  def newSessionId(self): 
    """ session.newSessionId(self.requestHandler) -> String ~ returns a new sessionId, preferably unique."""
    
class Session(mapClass):
  """Session Bridge"""
  def __init__(self, reqHandler, impl=None):
    """session = Session(requestHandler, SessionImplmentor()) ~ ctor's a session with the given 
    request handler and session implementation instance"""
    mapClass.__init__(self)
    self.init(reqHandler, impl)
    self.setup()
        
  def init(self, reqHandler, impl):
    """ self.init(reqHandler, impl)-> None ~ template init method called by CTOR"""
    self.sessionId=None
    self.serviceId=None
    self.status='new'
    self.impl = impl
    #self.impl.session = ref(self)
    self.reqHandler= ref(reqHandler)
    #self.reqHandler= reqHandler
    self.expiresWhen=None
        
  def setup(self):
    """ self.setup()-> None ~ template method 
    used to define relationship between session and requestHandler"""
    self.serviceId= self.getServiceId()
    self.sessionId= self.getSessionId()
    if not self.isNew():
      self.load()

  def isNew(self):
    """ session.new()-> 1|0 ~ returns 1 if session was created on this request, otherwise 0 
    used to define relationship between session and requestHandler"""
    return self.status=="new"
    
  def getServiceId(self, reqHandler=None): 
    """ session.getServiceId()-> String ~ returns serviceId, request passed on to the implementor."""
    if reqHandler is None:
      reqHandler = self.reqHandler()
    if not self.serviceId:
      self.serviceId = self.impl.getServiceId(reqHandler)
    return self.serviceId

  def getSessionId(self, reqHandler=None): 
    """ session.getSessionId()-> String ~ returns either the current sessionId or a new session id."""
    if reqHandler is None:
      reqHandler = self.reqHandler()
    if not self.sessionId:
      self.sessionId = reqHandler.getEnviron(self.getServiceId(reqHandler))
      if not self.sessionId:
        self.sessionId = self.impl.getSessionId(reqHandler)
        if not self.sessionId:
          self.status = 'new'
          self.sessionId = self.impl.newSessionId(reqHandler)
          self.purge(reqHandler)
        else:
          self.status='open'
    return self.sessionId

  def purge(self, reqHandler=None): 
    self.impl.purge(reqHandler)


      
  def load(self, reqHandler=None): 
    """ session.load()-> None ~ loads a session into its self."""
    if reqHandler is None:
      reqHandler = self.reqHandler()
    try:
      session =  self.impl.load(reqHandler, self)
      if session:
        expires  = session.getExpire()
        if expires is not None and expires < time():
          self.status = "new"
          return 
        self.update(session)
      else:
        self.status = "new"

    except Exception, e:
      import traceback
      traceback.print_exc()
      self.status = "new"
    return {}

  def save(self, reqHandler=None): 
    """ session.save()-> None ~ saves self."""
    if reqHandler is None:
      reqHandler = self.reqHandler()
    self.reqHandler = None
    self.status = 'open'
    self.impl.save(reqHandler, self)
    self.reqHandler= reqHandler

  def getExpire(self):
    """ session.getExpire()-> float ~ returns when it will expire in secs since epoche."""
    return self.expiresWhen
    
  def expire(self, when = None): 
  #def expire(self, when = None): 
    """ session.expire(when)-> None ~ expires session at time.time() + when,   
    if eval(when) evalutes, otherwise tries to parse when and expire session at when. 
    For more on this format see <a href="http://www.faqs.org/rfcs/rfc2068.html">RFC2068</a> section 3.3.1 
    [also <a href="http://www.faqs.org/rfcs/rfc822.html">RCF822</a> and  
    <a href="http://www.faqs.org/rfcs/rfc1123.html">RCF1123</a>]
    """
    self.expireWhen = when
    self.impl.expire(self, self.reqHandler(), when)
    #self.impl.expire(self, self.req(), when)

  def setSession(self, reqHandler=None): 
    """ session.setSession() -> None ~ adds session to request handler. """ 
    if reqHandler is None:
      reqHandler = self.reqHandler()
    self.impl.setSession(self, reqHandler)
  
  




    
  

class FileLoader(MixIn):
  DIRECTIVEtAG='PSOSessionFileLoader_'  
  DIRECTIVES=('Path',)
  PATH = os.path.dirname(mktemp())
  def getFileName(self, reqHandler, session):
    """session.getFileName(requestHandler) -> String ~ returns a fully qualified session file name."""
    path = self.getPath(reqHandler)
    file = session.getSessionId(reqHandler)
    filename =  os.path.join(path, file)
    return filename

  def getPath(self, reqHandler):
    """ session.getPath(requestHandler) -> String ~ returns the path where sessions will be stored."""
    return self.getDirectives(FileLoader, reqHandler).get('Path', self.PATH)
    
  def purge(self, reqHandler=None): pass
    

  def newSessionId(self, reqHandler):
    """session.newSessionId(requestHandler) -> String ~ returns a new sessionId, preferably unique."""
    id =  os.path.basename(mktemp(self.getServiceId( reqHandler)))
    return id

  def load(self, reqHandler, session):
    """session.load(requestHandler) -> session ~ returns session. All thrown expections passed on."""
    return load(open(self.getFileName(reqHandler, session),'r+b'))

  def save(self, reqHandler, session):
    """ session.save(requestHandler) -> None ~ saves session. All thrown expections passed on."""
    file = self.getFileName(reqHandler, session)
    f = open(file,'w+b')
    dump( session, f)

class CookieSession(MixIn):
  DIRECTIVEtAG='PSOCookieSession_'  
  DIRECTIVES=('expires', 'Path','Comment','Domain','Max-Age','secure','Version')

  def getCookie(self, reqHandler):
    """ self.getCookie(requestHandler) -> String | None ~ returns the session cookie if found
    otherwise none"""
    cookie = reqHandler.getEnviron(reqHandler.getCookieKey())
    if cookie:
      try:
        start=0
        look4 = self.getServiceId(reqHandler)+'='
        start = cookie.index(look4)
        start += len(look4)
        end = cookie.find(';', start)
        if end == -1:
          cookie = cookie[start:]
        else:
          cookie = cookie[start:end]
        return cookie.strip()
      except Exception, e:
        import traceback
        traceback.print_exc()
        return None

  def getSessionId(self, reqHandler): 
    """self.getSessionId(requestHandler) -> String | None ~ The current session id returned.   
      If none return None."""
    return self.getCookie(reqHandler)


  def when(self, when):
    """self.when(when) -> None ~ utility method to build the correct cookie expire attributes."""
    if not hasattr(self, 'attrs'):
      self.attrs = {}
    if when is not None:
      try:
        when = eval(str(when))
        when = time() + when 
        #self.attrs['Max-Age']= str(long(when))
        self.attrs['expires'] = strftime("%a, %d %b %Y %H:%M:%S GMT", gmtime(when))
      except:
        self.attrs['expires'] = when
        if self.attrs.has_key('Max-Age'):
          del self.attrs['Max-Age']
        

  
  def expire(self, session, reqHandler, when = None): 
    """ self.expire(session, requestHandler, when)-> None ~ expires session at time.time() + when,   
  if eval(when) evalutes, otherwise tries to parse when and expire session at when. 
  For more on this format see <a href="http://www.faqs.org/rfcs/rfc2068.html">RFC2068</a> section 3.3.1 
  [also <a href="http://www.faqs.org/rfcs/rfc822.html">RCF822</a> and  
  <a href="http://www.faqs.org/rfcs/rfc1123.html">RCF1123</a>]
  """
    self.when(when)
    reqHandler.setSession(session)

  def getAttrs(self):
    """ self.getAttrs() -> Dictionary of cookie attributes ~ utility 
      method for setting up the  session cookie"""
    if hasattr(self, 'attrs'):
      return self.attrs
    else:
      return {}

  def setSession(self, session, reqHandler):
    """ self.setSession(session, reqHandler) -> None ~ adds session to request handler.
      Handles setting the cookie when the session is new.
    """ 
    self.attrs = self.getAttrs()
    self.attrs.update(self.getDirectives(CookieSession, reqHandler))
    value = reqHandler.getEnviron('PSOSessionExpires')
    if value:
      self.when(value)
    reqHandler.setCookie(session.getServiceId(), session.getSessionId(), **self.getAttrs())


class CookieFileImpl(CookieSession, FileLoader, SessionImpl):
  """ Default session implementation, using temporary files to 
      store the session, and using a browser cookie to 
      pass the session id accross requests."""

class FileSession(Session ):
  """ Default session bridge, using CookieFileImpl as the implementaion class"""
        def init(self, reqHandler,imp):
            Session.init(self, reqHandler, CookieFileImpl())
            
      
    
        
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.