root/trunk/rp/trac/infocard_acct/0.11/infocard_acct/session.py @ 1213

#  Copyright (c) 2007 Novell, Inc.
#  All Rights Reserved.
 
#  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; version 2.1 of the license.
 
#  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.
 
#  You should have received a copy of the GNU Lesser General Public License
#  along with this library; if not, contact Novell, Inc.
 
#  To contact Novell about this file by physical or electronic mail,
#  you may find current contact information at www.novell.com
#

import re

from trac.core import *
from trac.web.chrome import ITemplateProvider
from trac.web.main import IRequestHandler

class SecTokenChangeListener(Interface):
    """Extension point interface for components that require notification when
    security tokens are used for authentication"""

    def login(req, secToken):
        """Called when an security token was used to authenticate succesfully"""

    def logout(req):
        """Called when an logging out"""


class SecTokenSessionModule(Component):
        """Manage the Security Token Listeners"""

        listeners = ExtensionPoint(SecTokenChangeListener)

        def login(self, req, secToken, options = None):
                """called on succesful login"""
                for listener in self.listeners:
#                       self.log.debug('SecTokenSessionModule login : ' + listener.__class__.__name__)
                        listener.login(req, secToken)

        def logout(self, req, options=None):
                """called during logout, cleanup any transitory settings"""
                for listener in self.listeners:
                        listener.logout(req)


class SecTokenPreferences(Component):
        """An example of proper checking for claims and settig a few select session
        attributes.   Useful for using security tokens to setup the prefrences for
        full name and email address"""
        
        implements(SecTokenChangeListener)

        def __init__(self):
                self.overrideSession = self.config.getbool('infocard_acct', 'override_session', True)

        def login(self, req, secToken):
                """ on login set the email address and name on the session"""

#               self.log.debug('SecTokenPreferences setup %s %s' % (req, req.session))
                if secToken and req.session:
                        email = secToken.getAssertion('http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress')
                        fullname = secToken.getAssertion('http://schemas.xmlsoap.org/ws/2005/05/identity/claims/givenname')
                        last =  secToken.getAssertion('http://schemas.xmlsoap.org/ws/2005/05/identity/claims/surname')

                        if not fullname:
                                fullname = ''
                        if last:
                                fullname += ' ' + last

#                       self.log.debug('SecTokenPreferences login:  %s, %s' % (email, fullname))

                        #visit should we override or update the email or just set if not set?
                        if email and (self.overrideSession or not req.session.has_key('email')):
                                req.session['email'] = email
                        if fullname and (self.overrideSession or not req.session.has_key('name')):
                                req.session['name'] = fullname

        def logout(self, req):
                """On logout we don't attempt to cleanup or change anything,
                leaving these attributes in place for notification, administration and
                subsequent authentications which don't use a security token"""
                pass


class SecTokenInfo(Component):
        """An example of lazy setting of session vars for all claims and metadata 
        found in the security token."""
        
        implements(SecTokenChangeListener, ITemplateProvider, IRequestHandler)

        #SecTokenChangeListner functions
        def login(self, req, secToken):
                if secToken and req.session:
                        metaData = secToken.getMetaData()
                        if metaData:
                                for key in metaData.keys():
                                        req.session['tok_meta_'+key] = metaData[key]
                                req.session['tok_meta'] = ''.join("tok_meta_%s " \
                                        % (key) for key in metaData.keys())
                        claims = secToken.getAssertion()
                        if claims and claims.keys():
                                for key in claims.keys():
                                        req.session['tok_claim_'+key] = claims[key]
                                req.session['tok_claims'] =''.join("tok_claim_%s " \
                                        % (key) for key in claims.keys())

        def logout(self, req):
                """On logout we should cleanup all of the garbage so that subsequent 
                sessions don't end up with incorrect data"""
                meta = req.session.get('tok_meta')
#               if meta:
#                       for key in meta.rsplit(' '):
#                               del req.session[key]
#                       del req.session['tok_meta']
#               if req.session.has_key('tok_claims'):
#                       for key in req.session.get('tok_claims').rsplit(' '):
#                               del req.session[key]
#                       del req.session['tok_claims']

    # IRequestHandler methods
        def match_request(self, req):
                if re.match(r'/iinfo/?$', req.path_info) is not None:
                        return True

                return False

        def process_request(self, req):
                data = {
                        'title': 'Infocard Session Debug',
                        'session': req.session,
                        'tok_claims': req.session.get('tok_claims'),
                        'tok_meta': req.session.get('tok_meta')
                }
                return 'infocard-session-detail.html', data, None

        #ITemplateProvider functions
        def get_htdocs_dirs(self):
                """Return the absolute path of a directory containing additional
                static resources (such as images, style sheets, etc).
                """
                from pkg_resources import resource_filename
                return [('infocard_acct', resource_filename(__name__, 'htdocs')),
                   ('site', self.env.get_htdocs_dir())]

        def get_templates_dirs(self):
                """Return the absolute path of the directory containing the provided
                templates.
                """
                from pkg_resources import resource_filename
                return [resource_filename(__name__, 'templates')]