Changeset 4526


Ignore:
Timestamp:
03/12/08 13:55:25 (11 years ago)
Author:
pjkersha
Message:

Integrated OpenID provider into WSGI stack together with Session Manager and Attribute Authority WSGI filters for Combined Services tests.

  • refactored ndg.security.server.wsgi.openid_provider.RenderingInterface? separating out e.g. code into separate DemoRenderingInterface? code
  • Updated ndg.security.server.pylons.cpntainer.lib.openid_provider_util Buffet rendering class so that it is independent of Pylons project structure. More work to be done to set Kid rendering input vars.

TODO: Add Authentication interface to OpenID Provider to enable integration with Session Manager based authentication.

Location:
TI12-security/trunk/python
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/Tests/openid-provider/op/op/lib/rendering.py

    r4123 r4526  
    5454    """Provide Kid Templating for OpenID Provider Middleware""" 
    5555     
    56     def renderLogin(self, environ, success_to=None, fail_to=None): 
     56    def login(self, environ, success_to=None, fail_to=None): 
    5757        """Set-up Kid template for OpenID Provider Login""" 
    5858        c = State(urls=self.urls, session=self.session) 
     
    6464         
    6565         
    66     def renderMainPage(self, environ): 
     66    def mainPage(self, environ): 
    6767        """Set-up Kid template for OpenID Provider Login""" 
    6868        c = State(urls=self.urls, session=self.session) 
     
    7474 
    7575 
    76     def renderIdentityPage(self, environ): 
     76    def identityPage(self, environ): 
    7777        """Identity page""" 
    7878        path = environ['PATH_INFO'] 
     
    9797                       c=c, g=config['pylons.g'], h=h)     
    9898     
    99     def renderDecidePage(self, environ, oidRequest): 
     99    def decidePage(self, environ, oidRequest): 
    100100        """Handle user interaction required before final submit back to Relying 
    101101        Party""" 
     
    108108 
    109109         
    110     def renderErrorPage(self, environ, msg): 
     110    def errorPage(self, environ, msg): 
    111111        c = State(urls=self.urls, session=self.session) 
    112112        c.title = 'Error with OpenID Provider' 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/pylons/container/lib/openid_provider_util.py

    r4404 r4526  
    2121 
    2222# Boiler plate to create renderer 
    23 class MyBuffet(Buffet): 
     23class OpenIDProviderRenderingBuffet(Buffet): 
    2424    def _update_names(self, ns): 
    2525        return ns 
    2626 
    27 def_eng = config['buffet.template_engines'][0] 
    28 buffet = MyBuffet( 
    29     def_eng['engine'], 
    30     template_root=def_eng['template_root'], 
    31     **def_eng['template_options'] 
    32 ) 
    33  
    34 for e in config['buffet.template_engines'][1:]: 
    35     buffet.prepare( 
    36         e['engine'], 
    37         template_root=e['template_root'], 
    38         alias=e['alias'], 
    39         **e['template_options'] 
     27try: 
     28    def_eng = config['buffet.template_engines'][0] 
     29    buffet = OpenIDProviderRenderingBuffet( 
     30        def_eng['engine'], 
     31        template_root=def_eng['template_root'], 
     32        **def_eng['template_options'] 
    4033    ) 
     34     
     35    for e in config['buffet.template_engines'][1:]: 
     36        buffet.prepare( 
     37            e['engine'], 
     38            template_root=e['template_root'], 
     39            alias=e['alias'], 
     40            **e['template_options'] 
     41        ) 
     42except: 
     43    templateRoot = 'ndg.security.server.pylons.container.templates' 
     44    buffet = OpenIDProviderRenderingBuffet('kid', template_root=templateRoot) 
     45#{'mako.directories': ['/home/pjkersha/workspace/security/python/ndg.security.server/ndg/security/server/pylons/container/templates'],  
     46#'myghty.component_root': [{'templates': '/home/pjkersha/workspace/security/python/ndg.security.server/ndg/security/server/pylons/container/templates'}],  
     47#'myghty.data_dir': '/home/pjkersha/workspace/security/python/ndg.security.server/ndg/security/server/pylons/data/templates',  
     48#'kid.encoding': 'utf-8',  
     49#'kid.assume_encoding': 'utf-8',  
     50#'mako.module_directory': '/home/pjkersha/workspace/security/python/ndg.security.server/ndg/security/server/pylons/data/templates',  
     51#'myghty.allow_globals': ['c', 'g', 'h', 'render', 'request', 'session', 'translator', 'ungettext', '_', 'N_'],  
     52#'myghty.output_encoding': 'utf-8',  
     53#'myghty.raise_error': True,  
     54#'mako.output_encoding': 'utf-8',  
     55#'mako.filesystem_checks': True} 
     56 
    4157 
    4258class State: 
     
    5167        self.urls = urls 
    5268 
    53 def _render(templateName, **kw): 
    54     '''Wrapper for Buffet.render''' 
    55     rendering = buffet.render(template_name=templateName, namespace=kw) 
    56     return rendering 
    57  
     69import httplib 
    5870 
    5971# Rendering classes for OpenID Provider must derive from generic render  
     
    6274 
    6375class OpenIDProviderKidRendering(RenderingInterface): 
    64     """Provide Kid Templating for OpenID Provider Middleware""" 
    65      
    66     def renderLogin(self, environ, success_to=None, fail_to=None, msg=''): 
     76    """Provide Kid Templating for OpenID Provider Middleware via Buffet 
     77    class""" 
     78     
     79    @staticmethod 
     80    def _render(templateName, **kw): 
     81        '''Wrapper for Buffet.render''' 
     82        rendering = buffet.render(template_name=templateName, namespace=kw) 
     83        return rendering 
     84     
     85    def login(self, environ, start_response, success_to=None, fail_to=None,  
     86              msg=''): 
    6787        """Set-up Kid template for OpenID Provider Login""" 
    6888        c = State(urls=self.urls, session=self.session) 
     
    7191        c.fail_to = fail_to or self.urls['url_mainpage']  
    7292        c.xml = msg 
    73         return _render('ndg.security.login', c=c, g=config, h=h) 
    74          
    75          
    76     def renderMainPage(self, environ): 
     93         
     94        response = OpenIDProviderKidRendering._render('ndg.security.login',  
     95                                                      c=c, g=config, h=h) 
     96        start_response('200 OK',  
     97                       [('Content-type', 'text/html'+self.charset), 
     98                        ('Content-length', str(len(response)))]) 
     99        return response 
     100        
     101         
     102    def mainPage(self, environ, start_response): 
    77103        """Set-up Kid template for OpenID Provider Login""" 
    78104        c = State(urls=self.urls, session=self.session) 
     
    81107                        self.urls['url_serveryadis'] 
    82108     
    83         return _render('ndg.security.mainPage', c=c, g=config, h=h) 
    84  
    85  
    86     def renderIdentityPage(self, environ): 
    87         """Identity page""" 
     109        response = OpenIDProviderKidRendering._render('ndg.security.mainPage',  
     110                                                      c=c, g=config, h=h) 
     111        start_response('200 OK',  
     112                       [('Content-type', 'text/html'+self.charset), 
     113                        ('Content-length', str(len(response)))]) 
     114        return response 
     115 
     116    def identityPage(self, environ, start_response): 
     117        """Render the user's Identity page""" 
    88118        path = environ['PATH_INFO'].rstrip('/') 
    89119        idPath = self.urls['url_id'].replace(self.base_url, '') 
     
    105135        c.xml = "<b><pre>%s</pre></b>" % identityURL 
    106136         
    107         return _render('ndg.security.identityPage', c=c, g=config, h=h)     
     137        response = OpenIDProviderKidRendering._render( 
     138                                                'ndg.security.identityPage',  
     139                                                c=c, g=config, h=h)     
     140        start_response("200 OK",  
     141                       [('Content-type', 'text/html'+self.charset), 
     142                        ('Content-length', str(len(response)))]) 
     143        return response 
    108144 
    109145    
    110     def renderDecidePage(self, environ, oidRequest): 
     146    def decidePage(self, environ, start_response, oidRequest): 
    111147        """Handle user interaction required before final submit back to Relying 
    112148        Party""" 
     
    116152        c.oidRequest = oidRequest 
    117153         
    118         return _render('ndg.security.decidePage', c=c,g=config,h=h) 
    119  
    120          
    121     def renderErrorPage(self, environ, msg): 
     154        response=OpenIDProviderKidRendering._render('ndg.security.decidePage',  
     155                                                    c=c, g=config, h=h) 
     156        start_response("200 OK",  
     157                       [('Content-type', 'text/html'+self.charset), 
     158                        ('Content-length', str(len(response)))]) 
     159        return response 
     160 
     161         
     162    def errorPage(self, environ, start_response, msg, code=500): 
    122163        c = State(urls=self.urls, session=self.session) 
    123164        c.title = 'Error with OpenID Provider' 
    124165        c.xml = msg 
    125         return _render('ndg.security.error', c=c, g=config, h=h) 
    126  
     166        start_response('%d %s' % (code, httplib.responses[code]),  
     167                       [('Content-type', 'text/html'+self.charset), 
     168                        ('Content-length', str(len(response)))]) 
     169        response = OpenIDProviderKidRendering._render('ndg.security.error',  
     170                                                      c=c, g=config, h=h) 
     171        return response 
     172     
    127173# Earth System Grid interoperability tests 
    128174 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid_provider.py

    r4525 r4526  
    1313__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1414__revision__ = "$Id$" 
    15  
     15import httplib 
     16import sys 
     17import cgi 
     18import os 
    1619import logging 
    1720log = logging.getLogger(__name__) 
     
    2831from openid.consumer import discover 
    2932 
    30 import httplib 
    31 import sys 
    32 import cgi 
    3333quoteattr = lambda s: '"%s"' % cgi.escape(s, 1) 
    34 getInvalidKw = lambda kw: [k for k in kw if k not in \ 
    35                            OpenIDProviderMiddleware.defKw] 
    3634 
    3735class OpenIDProviderMiddlewareError(Exception): 
     
    4442    """WSGI Middleware to implement an OpenID Provider 
    4543     
    46     @cvar defKw: keywords to __init__ and their default values.  Input 
    47     keywords must match these 
    48     @type defKw: dict 
    49      
    50     @cvar defPaths: subset of defKw.  These are keyword items corresponding 
     44    @cvar defOpt: app_conf options / keywords to __init__ and their default  
     45    values.  Input keywords must match these 
     46    @type defOpt: dict 
     47     
     48    @cvar defPaths: subset of defOpt.  These are keyword items corresponding 
    5149    to the URL paths to be set for the individual OpenID Provider functions 
    5250    @type: defPaths: dict 
     
    7371</html>""" 
    7472 
    75     defKw = dict(path_openidserver='/openidserver', 
    76                path_login='/login', 
    77                path_loginsubmit='/loginsubmit', 
    78                path_id='/id', 
    79                path_yadis='/yadis', 
    80                path_serveryadis='/serveryadis', 
    81                path_allow='/allow', 
    82                path_decide='/decide', 
    83                path_mainpage='/', 
    84                session_middleware='beaker.session',  
    85                base_url='', 
    86                consumer_store_dirpath='./', 
    87                charset=None, 
    88                trace=False, 
    89                renderingClass=None, 
    90                sregResponseHandler=None, 
    91                axResponseHandler=None, 
    92                usercreds=None) 
    93      
    94     defPaths=dict([(k,v) for k,v in defKw.items() if k.startswith('path_')]) 
     73    defOpt = dict( 
     74        path_openidserver='/openidserver', 
     75        path_login='/login', 
     76        path_loginsubmit='/loginsubmit', 
     77        path_id='/id', 
     78        path_yadis='/yadis', 
     79        path_serveryadis='/serveryadis', 
     80        path_allow='/allow', 
     81        path_decide='/decide', 
     82        path_mainpage='/', 
     83        session_middleware='beaker.session',  
     84        base_url='', 
     85        consumer_store_dirpath='./', 
     86        charset=None, 
     87        trace=False, 
     88        renderingClass=None, 
     89        sregResponseHandler=None, 
     90        axResponseHandler=None, 
     91        usercreds=None) 
     92     
     93    defPaths=dict([(k,v) for k,v in defOpt.items() if k.startswith('path_')]) 
    9594      
    96     def __init__(self, app, app_conf=None, prefix='openid_provider.', **kw): 
     95    def __init__(self, app, app_conf=None, prefix='openid.provider.', **kw): 
    9796        ''' 
    9897        @type app: callable following WSGI interface 
     
    103102        @param prefix: prefix for OpenID Provider configuration items 
    104103        @type kw: dict 
    105         @param kw: keyword dictionary - must follow format of defKw  
     104        @param kw: keyword dictionary - must follow format of defOpt  
    106105        class variable     
    107106        ''' 
    108107 
    109         opt = OpenIDProviderMiddleware.defKw.copy() 
    110         kw2AppConfOpt = {} 
     108        opt = OpenIDProviderMiddleware.defOpt.copy() 
    111109        if app_conf is not None: 
    112110            # Update from application config dictionary - filter from using 
    113111            # prefix 
    114             opt, kw2AppConfOpt = OpenIDProviderMiddleware._filterOpts( 
    115                                                                 app_conf, 
    116                                                                 prefix=prefix) 
    117 #            for k,v in app_conf.items(): 
    118 #                if k.startswith(prefix): 
    119 #                    subK = k.replace(prefix, '')                     
    120 #                    filtK = '_'.join(subK.split('.'))                     
    121 #                    opt[filtK] = v 
    122 #                    kw2AppConfOpt[filtK] = k 
    123                      
    124             invalidOpt = getInvalidKw(opt) 
    125             if len(invalidOpt) > 0: 
    126                 raise TypeError("Unexpected app_conf option(s): %s" %  
    127                         (", ".join([kw2AppConfOpt[i] for i in invalidOpt]))) 
    128              
    129                            
    130         kw, kw2Orig = OpenIDProviderMiddleware._filterOpts(kw, prefix=prefix) 
    131         invalidKw = getInvalidKw(kw) 
    132         if len(invalidKw) > 0: 
    133             raise TypeError("Unexpected keyword(s): %s" %  
    134                             (", ".join([kw2Orig[i] for i in invalidKw]))) 
    135          
     112            OpenIDProviderMiddleware._filterOpts(opt, app_conf, prefix=prefix) 
     113                         
     114        # Similarly, filter keyword input                  
     115        OpenIDProviderMiddleware._filterOpts(opt, kw, prefix=prefix) 
     116        
    136117        # Update options from keywords - matching app_conf ones will be  
    137118        # overwritten 
     
    148129        sregResponseHandlerVal = opt.get('sregResponseHandler', None)   
    149130        if sregResponseHandlerVal: 
    150             opt['sregResponseHandler']=eval_import(sregResponseHandlerVal)   
     131            opt['sregResponseHandler'] = eval_import(sregResponseHandlerVal)   
    151132        else: 
    152              opt['sregResponseHandler'] = None 
     133            opt['sregResponseHandler'] = None 
    153134 
    154135        axResponseHandlerVal = opt.get('axResponseHandler', None)   
     
    210191 
    211192        try: 
    212             self._renderer = renderingClass(self.base_url, self.urls) 
     193            self._render = renderingClass(self.base_url, self.urls) 
    213194        except Exception, e: 
    214195            log.error("Error instantiating rendering interface...") 
    215196            raise 
    216          
    217         self.__userRoles = instantiateClass(self.__prop['userRolesModName'], 
    218                      self.__prop['userRolesClassName'], 
    219                      moduleFilePath=self.__prop.get('userRolesModFilePath'), 
    220                      objectType=AAUserRoles, 
    221                      classProperties=self.__prop.get('userRolesPropFile')) 
    222              
     197                     
    223198        # Callable for setting of Simple Registration attributes in HTTP header 
    224199        # of response to Relying Party 
     
    227202            raise OpenIDProviderMiddlewareError("Expecting callable for " 
    228203                                                "sregResponseHandler keyword, " 
    229                                                 "got %r" % \ 
     204                                                "got %r" % 
    230205                                                self.sregResponseHandler) 
    231206             
     
    236211            raise OpenIDProviderMiddlewareError("Expecting callable for " 
    237212                                                "axResponseHandler keyword, " 
    238                                                 "got %r" % \ 
     213                                                "got %r" % 
    239214                                                self.axResponseHandler) 
    240215         
     
    244219        # were connecting to a database, you would create the database 
    245220        # connection and instantiate an appropriate store here. 
    246         store = FileOpenIDStore(opt['consumer_store_dirpath']) 
     221        store = FileOpenIDStore( 
     222                            os.path.expandvars(opt['consumer_store_dirpath'])) 
    247223        self.oidserver = server.Server(store, self.urls['url_openidserver']) 
    248224 
    249     @staticmethod 
    250     def _filterOpts(opts, prefix=None): 
    251         opt = {} 
    252         optLookBack = {} 
    253         for k,v in opts.items(): 
     225    @classmethod 
     226    def _filterOpts(cls, opt, newOpt, prefix=None): 
     227        '''Convenience utility to filter input options set in __init__ via 
     228        app_conf or keywords 
     229         
     230        @type opt: dict 
     231        @param opt: existing options set.  These will be updated by this 
     232        method based on the content of newOpt 
     233        @type newOpt: dict 
     234        @param newOpt: new options to update opt with 
     235        @type prefix: basestring  
     236        @param prefix: if set, remove the given prefix from the input options 
     237        @raise KeyError: if an option is set that is not in the classes 
     238        defOpt class variable 
     239        ''' 
     240         
     241        badOpt = [] 
     242        for k,v in newOpt.items(): 
    254243            if k.startswith(prefix): 
    255244                subK = k.replace(prefix, '')                     
    256                 filtK = '_'.join(subK.split('.'))                     
    257                 opt[filtK] = v 
     245                filtK = '_'.join(subK.split('.'))    
     246                if filtK not in cls.defOpt: 
     247                    badOpt += [k]                 
     248                else: 
     249                    opt[filtK] = v 
    258250                 
    259                 # Make a look-up dict to enable look-ups from translated  
    260                 # keyword back to it's original form 
    261                 optLookBack[filtK] = k 
    262                  
    263         return opt, optLookBack 
     251        if len(badOpt) > 0: 
     252            raise TypeError("Invalid input option(s) set: %s" %  
     253                            (", ".join(badOpt))) 
     254             
    264255 
    265256     
     
    285276        self.start_response = start_response 
    286277        self.session = environ[self.session_middleware] 
    287         self._renderer.session = self.session 
     278        self._render.session = self.session 
    288279         
    289280        if self.path in (self.paths['path_id'], self.paths['path_yadis']): 
     
    332323        
    333324        ''' 
    334         response = self._renderer.renderIdentityPage(environ) 
    335  
    336         start_response("200 OK",  
    337                        [('Content-type', 'text/html'+self.charset), 
    338                         ('Content-length', str(len(response)))]) 
     325        response = self._render.identityPage(environ, start_response) 
    339326        return response 
    340327 
     
    351338 
    352339        """ 
    353         response = self._renderer.renderYadis(environ) 
    354       
    355         start_response('200 OK', 
    356                        [('Content-type', 'application/xrds+xml'+self.charset), 
    357                         ('Content-length', str(len(response)))]) 
     340        response = self._render.yadis(environ, start_response) 
    358341        return response 
    359342 
     
    409392            log.error("Suspected do_allow called from stale request") 
    410393            #return self.app(environ, start_response) 
    411             response = self._renderer.renderErrorPage(environ,  
    412                                                       "Invalid request") 
    413             start_response("400 Bad Request",  
    414                            [('Content-type', 'text/html'), 
    415                             ('Content-length', str(len(response)))]) 
     394            response = self._render.errorPage(environ, start_response, 
     395                                              "Invalid request", 
     396                                              code=400) 
    416397         
    417398        if 'Yes' in self.query: 
     
    430411            except Exception, e: 
    431412                log.error("Setting response following ID Approval: %s" % e) 
    432                 response = self._renderer.renderErrorPage(environ,  
     413                response = self._render.errorPage(environ, start_response, 
    433414                    'Error setting response.  Please report the error to your ' 
    434415                    'site administrator.') 
    435                 start_response("500 Internal Server Error",  
    436                                [('Content-type', 'text/html'), 
    437                                 ('Content-length', str(len(response)))]) 
    438416                return response 
    439417                           
     
    446424            oidResponse = oidRequest.answer(False) 
    447425            #response = self._displayResponse(oidResponse) 
    448             response = self._renderer.renderMainPage(environ)             
    449             start_response("200 OK",  
    450                            [('Content-type', 'text/html'), 
    451                             ('Content-length', str(len(response)))]) 
     426            response = self._render.mainPage(environ, start_response)             
    452427        else: 
    453             response = self._renderer.renderErrorPage(environ,  
    454                                                       'Expecting yes/no in ' 
    455                                                       'allow post.  %r' % \ 
    456                                                       self.query) 
    457             start_response("400 Bad Request",  
    458                            [('Content-type', 'text/html'), 
    459                             ('Content-length', str(len(response)))]) 
     428            response = self._render.errorPage(environ, start_response, 
     429                                              'Expecting yes/no in allow ' 
     430                                              'post. %r' % self.query, 
     431                                              code=400) 
    460432         
    461433        return response 
     
    473445 
    474446        """ 
    475         response = self._renderer.renderServerYadis(environ) 
    476         start_response("200 OK",  
    477                        [('Content-type', 'application/xrds+xml'), 
    478                         ('Content-length', str(len(response)))]) 
     447        response = self._render.serverYadis(environ, start_response) 
    479448        return response 
    480449 
     
    496465            kw['fail_to'] = self.urls['url_login'] 
    497466             
    498         response = self._renderer.renderLogin(environ, **kw) 
    499         start_response('200 OK',  
    500                        [('Content-type', 'text/html'+self.charset), 
    501                         ('Content-length', str(len(response)))]) 
     467        response = self._render.login(environ, start_response, **kw) 
    502468        return response 
    503469 
     
    534500                            "Please try again or if the problems persists " + \ 
    535501                            "contact your system administrator.</p>" 
    536                         response = self._renderer.renderLogin(environ,  
     502                        response = self._render.login(environ, start_response, 
    537503                                          msg=msg, 
    538504                                          success_to=self.urls['url_decide']) 
    539                         start_response('200 OK',  
    540                                [('Content-type', 'text/html'+self.charset), 
    541                                 ('Content-length', str(len(response)))]) 
    542505                        return response 
    543506                        
     
    573536        @rtype: basestring 
    574537        @return: WSGI response 
    575         ''' 
    576          
    577         response = self._renderer.renderMainPage(environ) 
    578         start_response('200 OK',  
    579                        [('Content-type', 'text/html'+self.charset), 
    580                         ('Content-length', str(len(response)))]) 
     538        '''     
     539        response = self._render.mainPage(environ, start_response) 
    581540        return response 
    582541 
     
    608567            except Exception, e: 
    609568                log.error("Setting response following ID Approval: %s" % e) 
    610                 response = self._renderer.renderErrorPage(environ,  
     569                response = self._render.errorPage(environ, start_response, 
    611570                    'Error setting response.  Please report the error to your ' 
    612571                    'site administrator.') 
    613                  
    614                 start_response("500 Internal Server Error",  
    615                                [('Content-type', 'text/html'), 
    616                                 ('Content-length', str(len(response)))]) 
     572 
    617573                return response 
    618574 
    619575            return self._displayResponse(response) 
    620576        else: 
    621             response = self._renderer.renderDecidePage(environ, oidRequest) 
    622              
    623             start_response('200 OK',  
    624                            [('Content-type', 'text/html'+self.charset), 
    625                             ('Content-length', str(len(response)))]) 
    626             return response 
     577            return self._render.decidePage(environ, start_response, oidRequest) 
    627578         
    628579         
     
    786737                except Exception, e: 
    787738                    log.error("Setting response following ID Approval: %s" % e) 
    788                     response = self._renderer.renderErrorPage(environ,  
     739                    response = self._render.errorPage(environ, start_response, 
    789740                        'Error setting response.  Please report the error to ' 
    790741                        'your site administrator.') 
    791                     start_response("500 Internal Server Error",  
    792                                    [('Content-type', 'text/html'), 
    793                                     ('Content-length', str(len(response)))]) 
    794742                    return response 
    795743                 
     
    883831        """ 
    884832         
    885         response = self._renderer.renderErrorPage(self.environ,cgi.escape(msg)) 
    886         self.start_response('%d %s' % (code, httplib.responses[code]),  
    887                             [('Content-type', 'text/html'+self.charset), 
    888                              ('Content-length', str(len(msg)))]) 
     833        response = self._render.errorPage(self.environ, start_response, 
     834                                          cgi.escape(msg), code=code) 
    889835        return response 
    890836     
    891837     
    892838class RenderingInterface(object): 
    893     """Interface class for rendering of OpenID Provider pages.  Create a 
    894     derivative from this class to override the default look and feel and  
    895     behaviour of these pages.  Pass the new class name via the renderClass 
    896     keyword to OpenIDProviderMiddleware.__init__ 
     839    """Interface class for rendering of OpenID Provider pages.  It implements 
     840    methods for handling Yadis requests only.  All other interface methods 
     841    return a 404 error response.  Create a derivative from this class to  
     842    implement the other rendering methods as required.  DemoRenderingInterface 
     843    provides an example of how to do this.  To apply a custom  
     844    RenderingInterface class pass it's name in the OpenIDProviderMiddleware 
     845    app_conf dict or as a keyword argument using the option name  
     846    renderingClass. 
    897847     
    898848    @cvar tmplServerYadis: template for returning Yadis document to Relying  
    899849    Party.  Derived classes can reset this or completely override the  
    900     renderServerYadis method. 
     850    serverYadis method. 
    901851     
    902852    @type tmplServerYadis: basestring 
     
    904854    @cvar tmplYadis: template for returning Yadis document containing user 
    905855    URL to Relying Party.  Derived classes can reset this or completely  
    906     override the renderYadis method. 
     856    override the yadis method. 
    907857     
    908858    @type tmplYadis: basestring""" 
     
    941891</xrds:XRDS>"""     
    942892    
    943     def __init__(self, base_url, urls): 
     893    def __init__(self, base_url, urls, **opt): 
    944894        """ 
    945895        @type base_url: basestring 
     
    949899        @param urls: full urls for all the paths used by all the exposed  
    950900        methods - keyed by method name - see OpenIDProviderMiddleware.paths 
     901        @type opt: dict 
     902        @param opt: additional custom options passed from the  
     903        OpenIDProviderMiddleware config 
    951904        """ 
    952905        self.base_url = base_url 
    953906        self.urls = urls 
    954  
    955  
    956     def renderIdentityPage(self, environ): 
    957         """Render the identity page. 
    958          
    959         @type environ: dict 
    960         @param environ: dictionary of environment variables 
    961         @rtype: basestring 
    962         @return: WSGI response 
    963         """ 
    964         path = environ.get('PATH_INFO').rstrip('/') 
    965         username = path[len(self.paths['path_id'])+1:] 
    966          
    967         link_tag = '<link rel="openid.server" href="%s">' % \ 
    968               self.urls['url_openidserver'] 
    969                
    970         yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">' % \ 
    971             (self.urls['url_yadis']+'/'+path[4:]) 
    972              
    973         disco_tags = link_tag + yadis_loc_tag 
    974         ident = self.base_url + path 
    975  
    976         msg = '' 
    977         return self._showPage(environ,  
    978                               'Identity Page',  
    979                               head_extras=disco_tags,  
    980                               msg='''<p>This is the identity page for %s.</p> 
    981                                 %s 
    982                                 ''' % (ident, msg)) 
    983      
    984      
    985     def renderServerYadis(self, environ): 
     907        self.charset = '' 
     908     
     909     
     910    def serverYadis(self, environ, start_response): 
    986911        '''Render Yadis info 
    987912         
    988913        @type environ: dict 
    989914        @param environ: dictionary of environment variables 
     915        @type start_response: callable 
     916        @param start_response: WSGI start response function.  Should be called 
     917        from this method to set the response code and HTTP header content 
    990918        @rtype: basestring 
    991919        @return: WSGI response 
    992920        ''' 
    993921        endpoint_url = self.urls['url_openidserver'] 
    994         return RenderingInterface.tmplServerYadis % \ 
    995             {'openid20type': discover.OPENID_IDP_2_0_TYPE,  
    996              'endpoint_url': endpoint_url}     
    997  
    998  
    999     def renderYadis(self, environ): 
     922        response = RenderingInterface.tmplServerYadis % \ 
     923                                {'openid20type': discover.OPENID_IDP_2_0_TYPE,  
     924                                 'endpoint_url': endpoint_url} 
     925              
     926        start_response("200 OK",  
     927                       [('Content-type', 'application/xrds+xml'), 
     928                        ('Content-length', str(len(response)))]) 
     929        return response 
     930 
     931 
     932    def yadis(self, environ, start_response): 
    1000933        """Render Yadis document containing user URL 
    1001934         
    1002935        @type environ: dict 
    1003936        @param environ: dictionary of environment variables 
    1004         @rtype: basestring 
    1005         @return: WSGI response 
    1006         """ 
    1007          
     937        @type start_response: callable 
     938        @param start_response: WSGI start response function.  Should be called 
     939        from this method to set the response code and HTTP header content 
     940        @rtype: basestring 
     941        @return: WSGI response 
     942        """ 
     943        # Override this method to implement an alternate means to derive the  
     944        # username identifier 
    1008945        username = environ['PATH_INFO'].rstrip('/').split('/')[-1] 
    1009946         
     
    1016953                         user_url=user_url) 
    1017954         
    1018         return RenderingInterface.tmplYadis % yadisDict 
    1019  
    1020          
    1021     def renderLogin(self, environ, success_to=None, fail_to=None, msg=''): 
     955        response = RenderingInterface.tmplYadis % yadisDict 
     956      
     957        start_response('200 OK', 
     958                       [('Content-type', 'application/xrds+xml'+self.charset), 
     959                        ('Content-length', str(len(response)))]) 
     960        return response 
     961     
     962 
     963    def identityPage(self, environ, start_response): 
     964        """Render the identity page. 
     965         
     966        @type environ: dict 
     967        @param environ: dictionary of environment variables 
     968        @type start_response: callable 
     969        @param start_response: WSGI start response function.  Should be called 
     970        from this method to set the response code and HTTP header content 
     971        @rtype: basestring 
     972        @return: WSGI response 
     973        """ 
     974        response = "Page is not implemented" 
     975        start_response('%d %s' % (404, httplib.responses[code]),  
     976                       [('Content-type', 'text/html'+self.charset), 
     977                        ('Content-length', str(len(response)))]) 
     978        return response 
     979     
     980         
     981    def login(self, environ, start_response,  
     982              success_to=None, fail_to=None, msg=''): 
    1022983        """Render the login form. 
    1023984         
    1024985        @type environ: dict 
    1025986        @param environ: dictionary of environment variables 
     987        @type start_response: callable 
     988        @param start_response: WSGI start response function.  Should be called 
     989        from this method to set the response code and HTTP header content 
    1026990        @type success_to: basestring 
    1027991        @param success_to: URL put into hidden field telling   
     
    10391003        """ 
    10401004         
     1005        response = "Page is not implemented" 
     1006        start_response('%d %s' % (404, httplib.responses[code]),  
     1007                       [('Content-type', 'text/html'+self.charset), 
     1008                        ('Content-length', str(len(response)))]) 
     1009        return response 
     1010 
     1011 
     1012    def mainPage(self, environ, start_response): 
     1013        """Rendering the main page. 
     1014         
     1015        @type environ: dict 
     1016        @param environ: dictionary of environment variables 
     1017        @type start_response: callable 
     1018        @param start_response: WSGI start response function.  Should be called 
     1019        from this method to set the response code and HTTP header content 
     1020        @rtype: basestring 
     1021        @return: WSGI response 
     1022        """    
     1023        response = "Page is not implemented" 
     1024        start_response('%d %s' % (404, httplib.responses[code]),  
     1025                       [('Content-type', 'text/html'+self.charset), 
     1026                        ('Content-length', str(len(response)))]) 
     1027        return response 
     1028     
     1029 
     1030    def decidePage(self, environ, start_response, oidRequest): 
     1031        """Show page giving the user the option to approve the return of their 
     1032        credentials to the Relying Party.  This page is also displayed for 
     1033        ID select mode if the user is already logged in at the OpenID Provider. 
     1034        This enables them to confirm the OpenID to be sent back to the  
     1035        Relying Party 
     1036         
     1037        @type environ: dict 
     1038        @param environ: dictionary of environment variables 
     1039        @type start_response: callable 
     1040        @param start_response: WSGI start response function.  Should be called 
     1041        from this method to set the response code and HTTP header content 
     1042        @type oidRequest: openid.server.server.CheckIDRequest 
     1043        @param oidRequest: OpenID Check ID Request object 
     1044        @rtype: basestring 
     1045        @return: WSGI response 
     1046        """ 
     1047        response = "Page is not implemented" 
     1048        start_response('%d %s' % (404, httplib.responses[code]),  
     1049                       [('Content-type', 'text/html'+self.charset), 
     1050                        ('Content-length', str(len(response)))]) 
     1051        return response 
     1052 
     1053 
     1054    def errorPage(self, environ, start_response, msg, code=500): 
     1055        """Display error page  
     1056         
     1057        @type environ: dict 
     1058        @param environ: dictionary of environment variables 
     1059        @type start_response: callable 
     1060        @param start_response: WSGI start response function.  Should be called 
     1061        from this method to set the response code and HTTP header content 
     1062        @type msg: basestring 
     1063        @param msg: optional message for page body 
     1064        @type code: int 
     1065        @param code: HTTP Error code to return 
     1066        @rtype: basestring 
     1067        @return: WSGI response 
     1068        """      
     1069        response = "Page is not implemented" 
     1070        start_response('%d %s' % (404, httplib.responses[code]),  
     1071                       [('Content-type', 'text/html'+self.charset), 
     1072                        ('Content-length', str(len(response)))]) 
     1073        return response 
     1074         
     1075     
     1076class DemoRenderingInterface(RenderingInterface): 
     1077    """Example rendering interface class for demonstration purposes""" 
     1078    
     1079    def __init__(self, base_url, urls): 
     1080        """ 
     1081        @type base_url: basestring 
     1082        @param base_url: base URL for OpenID Provider to which individual paths 
     1083        are appended 
     1084        @type urls: dict 
     1085        @param urls: full urls for all the paths used by all the exposed  
     1086        methods - keyed by method name - see OpenIDProviderMiddleware.paths 
     1087        """ 
     1088        self.base_url = base_url 
     1089        self.urls = urls 
     1090        self.charset = '' 
     1091 
     1092 
     1093    def identityPage(self, environ, start_response): 
     1094        """Render the identity page. 
     1095         
     1096        @type environ: dict 
     1097        @param environ: dictionary of environment variables 
     1098        @type start_response: callable 
     1099        @param start_response: WSGI start response function.  Should be called 
     1100        from this method to set the response code and HTTP header content 
     1101        @rtype: basestring 
     1102        @return: WSGI response 
     1103        """ 
     1104        path = environ.get('PATH_INFO').rstrip('/') 
     1105        username = path.split('/')[-1] 
     1106         
     1107        link_tag = '<link rel="openid.server" href="%s">' % \ 
     1108              self.urls['url_openidserver'] 
     1109               
     1110        yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">' % \ 
     1111            (self.urls['url_yadis']+'/'+username) 
     1112             
     1113        disco_tags = link_tag + yadis_loc_tag 
     1114        ident = self.base_url + path 
     1115 
     1116        response = self._showPage(environ,  
     1117                              'Identity Page',  
     1118                              head_extras=disco_tags,  
     1119                              msg='<p>This is the identity page for %s.</p>' %  
     1120                                  ident) 
     1121         
     1122        start_response("200 OK",  
     1123                       [('Content-type', 'text/html'+self.charset), 
     1124                        ('Content-length', str(len(response)))]) 
     1125        return response 
     1126     
     1127         
     1128    def login(self, environ, start_response,  
     1129              success_to=None, fail_to=None, msg=''): 
     1130        """Render the login form. 
     1131         
     1132        @type environ: dict 
     1133        @param environ: dictionary of environment variables 
     1134        @type success_to: basestring 
     1135        @param success_to: URL put into hidden field telling   
     1136        OpenIDProviderMiddleware.do_loginsubmit() where to forward to on  
     1137        successful login 
     1138        @type fail_to: basestring 
     1139        @param fail_to: URL put into hidden field telling   
     1140        OpenIDProviderMiddleware.do_loginsubmit() where to forward to on  
     1141        login error 
     1142        @type msg: basestring 
     1143        @param msg: display (error) message below login form e.g. following 
     1144        previous failed login attempt. 
     1145        @rtype: basestring 
     1146        @return: WSGI response 
     1147        """ 
     1148         
    10411149        if success_to is None: 
    10421150            success_to = self.urls['url_mainpage'] 
     
    10451153            fail_to = self.urls['url_mainpage'] 
    10461154         
    1047         return self._showPage(environ, 
    1048                               'Login Page', form='''\ 
    1049             <h2>Login</h2> 
    1050             <form method="GET" action="%s"> 
    1051               <input type="hidden" name="success_to" value="%s" /> 
    1052               <input type="hidden" name="fail_to" value="%s" /> 
    1053               <input type="text" name="username" value="" /> 
    1054               <input type="submit" name="submit" value="Log In" /> 
    1055               <input type="submit" name="cancel" value="Cancel" /> 
    1056             </form> 
    1057             %s 
    1058             ''' % (self.urls['url_loginsubmit'], success_to, fail_to, msg)) 
    1059  
    1060  
    1061     def renderMainPage(self, environ): 
     1155        form = '''\ 
     1156<h2>Login</h2> 
     1157<form method="GET" action="%s"> 
     1158  <input type="hidden" name="success_to" value="%s" /> 
     1159  <input type="hidden" name="fail_to" value="%s" /> 
     1160  <table cellspacing="0" border="0" cellpadding="5"> 
     1161    <tr> 
     1162        <td>Username:</td>  
     1163        <td><input type="text" name="username" value=""/></td> 
     1164    </tr><tr> 
     1165        <td>Password:</td> 
     1166        <td><input type="password" name="password"/></td> 
     1167    </tr><tr> 
     1168        <td colspan="2" align="right"> 
     1169            <input type="submit" name="submit" value="Login"/> 
     1170            <input type="submit" name="cancel" value="Cancel"/> 
     1171        </td> 
     1172    </tr> 
     1173  </table> 
     1174</form> 
     1175%s 
     1176''' % (self.urls['url_loginsubmit'], success_to, fail_to, msg) 
     1177 
     1178        response = self._showPage(environ, 'Login Page', form=form) 
     1179        start_response('200 OK',  
     1180                       [('Content-type', 'text/html'+self.charset), 
     1181                        ('Content-length', str(len(response)))]) 
     1182        return response 
     1183 
     1184 
     1185    def mainPage(self, environ, start_response): 
    10621186        """Rendering the main page. 
    10631187         
    10641188        @type environ: dict 
    10651189        @param environ: dictionary of environment variables 
     1190        @type start_response: callable 
     1191        @param start_response: WSGI start response function.  Should be called 
     1192        from this method to set the response code and HTTP header content 
    10661193        @rtype: basestring 
    10671194        @return: WSGI response 
     
    10701197        yadis_tag = '<meta http-equiv="x-xrds-location" content="%s">' % \ 
    10711198                    self.urls['url_serveryadis'] 
    1072         username = environ['beaker.session']['username']     
     1199        username = environ['beaker.session'].get('username')     
    10731200        if username: 
    10741201            openid_url = self.urls['url_id'] + '/' + username 
     
    10821209                            self.urls['url_login'] 
    10831210 
    1084         return self._showPage(environ, 
    1085                               'Main Page', head_extras=yadis_tag, msg='''\ 
    1086             <p>OpenID server</p> 
    1087      
    1088             %s 
    1089      
    1090             <p>The URL for this server is <a href=%s><tt>%s</tt></a>.</p> 
    1091         ''' % (user_message, quoteattr(self.base_url), self.base_url)) 
    1092      
    1093     def renderDecidePage(self, environ, oidRequest): 
     1211        msg = '''\ 
     1212<p>OpenID server</p> 
     1213 
     1214%s 
     1215 
     1216<p>The URL for this server is <a href=%s><tt>%s</tt></a>.</p> 
     1217''' % (user_message, quoteattr(self.base_url), self.base_url) 
     1218        response = self._showPage(environ, 
     1219                                  'Main Page',  
     1220                                  head_extras=yadis_tag,  
     1221                                  msg=msg) 
     1222     
     1223        start_response('200 OK',  
     1224                       [('Content-type', 'text/html'+self.charset), 
     1225                        ('Content-length', str(len(response)))]) 
     1226        return response 
     1227     
     1228 
     1229    def decidePage(self, environ, start_response, oidRequest): 
    10941230        """Show page giving the user the option to approve the return of their 
    10951231        credentials to the Relying Party.  This page is also displayed for 
     
    11001236        @type environ: dict 
    11011237        @param environ: dictionary of environment variables 
     1238        @type start_response: callable 
     1239        @param start_response: WSGI start response function.  Should be called 
     1240        from this method to set the response code and HTTP header content 
    11021241        @type oidRequest: openid.server.server.CheckIDRequest 
    11031242        @param oidRequest: OpenID Check ID Request object 
     
    11361275                } 
    11371276            form = '''\ 
    1138             <form method="POST" action="%(path_allow)s"> 
    1139             <table> 
    1140               <tr><td>Identity:</td> 
    1141                  <td>%(id_url_base)s<input type='text' name='identifier'></td></tr> 
    1142               <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
    1143             </table> 
    1144             <p>Allow this authentication to proceed?</p> 
    1145             <input type="checkbox" id="remember" name="remember" value="yes" 
    1146                 /><label for="remember">Remember this 
    1147                 decision</label><br /> 
    1148             <input type="submit" name="yes" value="yes" /> 
    1149             <input type="submit" name="no" value="no" /> 
    1150             </form> 
    1151             '''%fdata 
     1277<form method="POST" action="%(path_allow)s"> 
     1278<table> 
     1279  <tr><td>Identity:</td> 
     1280     <td>%(id_url_base)s<input type='text' name='identifier'></td></tr> 
     1281  <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
     1282</table> 
     1283<p>Allow this authentication to proceed?</p> 
     1284<input type="checkbox" id="remember" name="remember" value="yes" 
     1285    /><label for="remember">Remember this 
     1286    decision</label><br /> 
     1287<input type="submit" name="Yes" value="Yes" /> 
     1288<input type="submit" name="No" value="No" /> 
     1289</form> 
     1290''' % fdata 
    11521291             
    11531292        elif expected_user == username: 
     
    11651304                } 
    11661305            form = '''\ 
    1167             <table> 
    1168               <tr><td>Identity:</td><td>%(identity)s</td></tr> 
    1169               <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
    1170             </table> 
    1171             <p>Allow this authentication to proceed?</p> 
    1172             <form method="POST" action="%(path_allow)s"> 
    1173               <input type="checkbox" id="remember" name="remember" value="yes" 
    1174                   /><label for="remember">Remember this 
    1175                   decision</label><br /> 
    1176               <input type="submit" name="yes" value="yes" /> 
    1177               <input type="submit" name="no" value="no" /> 
    1178             </form>''' % fdata 
     1306<table> 
     1307  <tr><td>Identity:</td><td>%(identity)s</td></tr> 
     1308  <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
     1309</table> 
     1310<p>Allow this authentication to proceed?</p> 
     1311<form method="POST" action="%(path_allow)s"> 
     1312  <input type="checkbox" id="remember" name="remember" value="yes" 
     1313      /><label for="remember">Remember this 
     1314      decision</label><br /> 
     1315  <input type="submit" name="yes" value="yes" /> 
     1316  <input type="submit" name="no" value="no" /> 
     1317</form>''' % fdata 
    11791318        else: 
    11801319            mdata = { 
     
    11961335                } 
    11971336            form = '''\ 
    1198             <table> 
    1199               <tr><td>Identity:</td><td>%(identity)s</td></tr> 
    1200               <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
    1201             </table> 
    1202             <p>Allow this authentication to proceed?</p> 
    1203             <form method="POST" action="%(path_allow)s"> 
    1204               <input type="checkbox" id="remember" name="remember" value="yes" 
    1205                   /><label for="remember">Remember this 
    1206                   decision</label><br /> 
    1207               <input type="hidden" name="login_as" value="%(expected_user)s"/> 
    1208               <input type="submit" name="yes" value="yes" /> 
    1209               <input type="submit" name="no" value="no" /> 
    1210             </form>''' % fdata 
    1211  
    1212         return self._showPage(environ, 
    1213                               'Approve OpenID request?',  
    1214                               msg=msg, form=form) 
    1215          
    1216  
    1217     def _showPage(self, environ,  
    1218                   title, head_extras='', msg=None, err=None, form=None): 
     1337<table> 
     1338  <tr><td>Identity:</td><td>%(identity)s</td></tr> 
     1339  <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
     1340</table> 
     1341<p>Allow this authentication to proceed?</p> 
     1342<form method="POST" action="%(path_allow)s"> 
     1343  <input type="checkbox" id="remember" name="remember" value="yes" 
     1344      /><label for="remember">Remember this 
     1345      decision</label><br /> 
     1346  <input type="hidden" name="login_as" value="%(expected_user)s"/> 
     1347  <input type="submit" name="yes" value="yes" /> 
     1348  <input type="submit" name="no" value="no" /> 
     1349</form>''' % fdata 
     1350 
     1351        response = self._showPage(environ, 'Approve OpenID request?',  
     1352                                  msg=msg, form=form)             
     1353        start_response('200 OK',  
     1354                       [('Content-type', 'text/html'+self.charset), 
     1355                        ('Content-length', str(len(response)))]) 
     1356        return response 
     1357     
     1358 
     1359    def _showPage(self,  
     1360                  environ,  
     1361                  title,  
     1362                  head_extras='',  
     1363                  msg=None,  
     1364                  err=None,  
     1365                  form=None): 
    12191366        """Generic page rendering method.  Derived classes may ignore this. 
    12201367         
     
    12701417 
    12711418        contents = { 
    1272             'title': 'Python OpenID Server - ' + title, 
     1419            'title': 'Python OpenID Provider - ' + title, 
    12731420            'head_extras': head_extras, 
    12741421            'body': body, 
     
    13411488      <tr> 
    13421489        <td class="leftbanner"> 
    1343           <h1><a href="/">Python OpenID Server</a></h1> 
     1490          <h1><a href="/">Python OpenID Provider</a></h1> 
    13441491        </td> 
    13451492        <td class="rightbanner"> 
     
    13551502        return response 
    13561503 
    1357     def renderErrorPage(self, environ, msg): 
     1504    def errorPage(self, environ, start_response, msg, code=500): 
    13581505        """Display error page  
    13591506         
    13601507        @type environ: dict 
    13611508        @param environ: dictionary of environment variables 
     1509        @type start_response: callable 
     1510        @param start_response: WSGI start response function.  Should be called 
     1511        from this method to set the response code and HTTP header content 
    13621512        @type msg: basestring 
    13631513        @param msg: optional message for page body 
     
    14011551        ''' % msg) 
    14021552         
    1403         return response 
     1553        start_response('%d %s' % (code, httplib.responses[code]),  
     1554                       [('Content-type', 'text/html'+self.charset), 
     1555                        ('Content-length', str(len(response)))]) 
     1556        return response 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/combinedservices/services.ini

    r4525 r4526  
    157157           wsseSignatureFilter  
    158158           httpBasicAuthFilter  
     159           SessionMiddlewareFilter 
    159160           OpenIDProviderFilter 
    160            SessionMiddlewareFilter 
    161161           mainApp 
    162162 
     
    257257wsseSignatureVerificationFilterID = ndg.security.server.wsgi.wsseSignatureVerificationFilter01 
    258258 
    259 # Last filter in chain SOAP handlers writes the response 
     259# Last filter in chain of SOAP handlers writes the response 
    260260writeResponse = True 
    261261 
     
    278278[filter:OpenIDProviderFilter] 
    279279paste.filter_app_factory=ndg.security.server.wsgi.openid_provider:OpenIDProviderMiddleware 
    280 openid_provider.path.openidserver=/openid/openidserver 
    281 openid_provider.path.login=/openid/login 
    282 openid_provider.path.loginsubmit=/openid/loginsubmit 
    283 openid_provider.path.id=/openid/id 
    284 openid_provider.path.yadis=/openid/yadis 
    285 openid_provider.path.serveryadis=/openid/serveryadis 
    286 openid_provider.path.allow=/openid/allow 
    287 openid_provider.path.decide=/openid/decide 
    288 openid_provider.path.mainpage=/openid 
    289 openid_provider.session_middleware=beaker.session  
    290 openid_provider.base_url=http://localhost:8000 
    291 #openid_provider.consumer_store_dirpath=./ 
    292 openid_provider.trace=False 
    293 openid_provider.renderingClass=ndg.security.server.pylons.container.lib.openid_provider_util.OpenIDProviderKidRendering 
    294 openid_provider.sregResponseHandler=ndg.security.server.pylons.container.lib.openid_provider_util:esgSRegResponseHandler 
    295 openid_provider.axResponseHandler=ndg.security.server.pylons.container.lib.openid_provider_util:esgAXResponseHandler 
     280openid.provider.path.openidserver=/openid/openidserver 
     281openid.provider.path.login=/openid/login 
     282openid.provider.path.loginsubmit=/openid/loginsubmit 
     283openid.provider.path.id=/openid/id 
     284openid.provider.path.yadis=/openid/yadis 
     285openid.provider.path.serveryadis=/openid/serveryadis 
     286openid.provider.path.allow=/openid/allow 
     287openid.provider.path.decide=/openid/decide 
     288openid.provider.path.mainpage=/openid 
     289openid.provider.session_middleware=beaker.session  
     290openid.provider.base_url=http://localhost:8000 
     291#openid.provider.consumer_store_dirpath=./ 
     292openid.provider.trace=False 
     293#openid.provider.renderingClass=ndg.security.server.pylons.container.lib.openid_provider_util.OpenIDProviderKidRendering 
     294openid.provider.renderingClass=ndg.security.server.wsgi.openid_provider.DemoRenderingInterface 
     295openid.provider.sregResponseHandler=ndg.security.server.pylons.container.lib.openid_provider_util:esgSRegResponseHandler 
     296openid.provider.axResponseHandler=ndg.security.server.pylons.container.lib.openid_provider_util:esgAXResponseHandler 
    296297 
    297298# Basic authentication for testing/admin - comma delimited list of  
    298299# <username>:<password> pairs 
    299 openid_provider.usercreds=pjk:test, luca:esgndgtest 
     300openid.provider.usercreds=pjk:test 
    300301 
    301302#______________________________________________________________________________ 
Note: See TracChangeset for help on using the changeset viewer.