Changeset 5870 for TI12-security


Ignore:
Timestamp:
23/10/09 14:46:26 (10 years ago)
Author:
pjkersha
Message:
  • added an SQLAlchemy based AX interface for the OpenID Provider
  • Modified the openid_dbinterface egg to enable creation of a unique OpenID identifier based on a given database user table key
Location:
TI12-security/trunk/python
Files:
1 added
5 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security_common/ndg/security/common/utils/__init__.py

    r5589 r5870  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
     11 
     12# Interpret a string as a boolean 
     13str2Bool = lambda str: str.lower() in ("yes", "true", "t", "1") 
    1114 
    1215class UniqList(list): 
  • TI12-security/trunk/python/ndg_security_common_utils_openid_dbinterface/ndg/security/common/utils/openid/dbinterface.py

    r5723 r5870  
    22"""NDG Security ndg.security.common.utils.openid package 
    33 
    4 NERC DataGrid Project  
     4NERC DataGrid Project 
    55""" 
    66__author__ = "P J Kershaw" 
     
    3838 
    3939    @staticmethod 
    40     def none2String(str): 
    41         if str is None: 
     40    def none2String(s): 
     41        """Convert None type to an empty string 
     42         
     43        @type s: basestring/None 
     44        @param s: string to be converted 
     45        @rtype: basestring 
     46        @return: converted string  
     47        """ 
     48        if s is None: 
    4249            return '' 
    4350        else: 
    44             return str 
     51            return s 
    4552 
    4653    # Split surnames allowing for spaces, hyphenation and ' for e.g. O'Connor 
     
    4956    @staticmethod 
    5057    def sentenceCase(s, preserveCaps=False): 
     58        """Convert string to sentence case - first letter of first word is  
     59        capitalised 
     60        @type s: basestring 
     61        @param s: string to be converted 
     62        @type preserveCaps: bool 
     63        @param preserveCaps: set to True to leave uppercase strings such as  
     64        acronyms alone 
     65        @rtype: basestring 
     66        @return: converted string  
     67        """ 
    5168        if s is None: 
    5269            return '' 
     
    6582 
    6683    getFirstName = staticmethod(lambda s: UserIdentifiers.camelCase( 
    67                                             UserIdentifiers.none2String(s.strip()).split()[0])) 
     84                            UserIdentifiers.none2String(s.strip()).split()[0])) 
    6885 
    6986    @staticmethod 
    7087    def mcFilter(s): 
    71         '''Allow for surnames starting with Mc e.g. McDonald''' 
     88        '''Allow for surnames starting with Mc e.g. McDonald 
     89        @type s: basestring 
     90        @param s: string to be converted 
     91        @rtype: basestring 
     92        @return: converted string  
     93        ''' 
    7294        if s.startswith('Mc'): 
    7395            return 'Mc' + s[2].upper() + s[3:] 
     
    82104    @staticmethod 
    83105    def makeIdentifier(firstNames, surname): 
    84         """Make an OpenID identifier based on the users first name joined to  
     106        """Make an OpenID identifier based on the users first name joined to 
    85107        their last name with a dot separator""" 
    86108        if not firstNames: 
     
    123145    """Configuration error for DatabaseUserIdentifiers instance""" 
    124146 
     147 
    125148class DatabaseUserIdentifiers(UserIdentifiers): 
    126149    """Generate a list of OpenID identifiers from a query 
     
    128151 
    129152    SECTION_NAME = "DatabaseOpenIDUserIdentifiers" 
    130     HOST_OPTION_NAME = "host" 
    131     DBNAME_OPTION_NAME = "dbName" 
    132     USERNAME_OPTION_NAME = "username" 
    133     PWD_OPTION_NAME = "pwd" 
    134     QUERY_GENERATE_OPTION_NAME = "query.generate" 
    135     QUERY_UNIQ_IDENTIFIER_OPTION_NAME = "query.uniqIdentifier" 
     153    HOST_OPTNAME = "host" 
     154    DBNAME_OPTNAME = "dbName" 
     155    USERNAME_OPTNAME = "username" 
     156    PWD_OPTNAME = "pwd" 
     157    QUERY_GENERATE_OPTNAME = "query.generate" 
     158    QUERY_GENERATE_FROM_USERKEY_OPTNAME = "query.generateFromUserKey" 
     159    QUERY_UNIQ_IDENTIFIER_OPTNAME = "query.uniqIdentifier" 
     160    QUERY_GET_IDENTIFIERS_OPTNAME = "query.getIdentifiers" 
    136161    UNIQ_IDENTIFIER_FIELD_NAME = "openIdUserComponent" 
     162    USERKEY_FIELD_NAME = "userKey" 
    137163 
    138164    def __init__(self, propertiesFilePath=None): 
    139165        """Connect to Postgres database""" 
     166        super(DatabaseUserIdentifiers, self).__init__() 
     167         
    140168        if _psycopg2Unavailable: 
    141169            log.warning("psycopg2 package is required for this class") 
    142              
     170 
    143171        self.__con = None 
    144172        self.__host = None 
     
    146174        self.__username = None 
    147175        self.__pwd = None 
    148  
     176        self.__generateQuery = None 
     177        self.__generateFromUserKeyQuery = None 
     178        self.__getIdentifiersQuery = None 
     179        self.__uniqIdentifierQuery = None 
     180        self.__cursor = None 
     181        self.__db = None 
     182         
    149183        if propertiesFilePath is None: 
    150184            raise AttributeError("No Configuration file was set") 
     
    170204 
    171205        self.__host = cfg.get( 
    172                         DatabaseUserIdentifiers.SECTION_NAME,  
    173                         DatabaseUserIdentifiers.HOST_OPTION_NAME) 
     206                        DatabaseUserIdentifiers.SECTION_NAME, 
     207                        DatabaseUserIdentifiers.HOST_OPTNAME) 
    174208        self.__dbName = cfg.get( 
    175                         DatabaseUserIdentifiers.SECTION_NAME,  
    176                         DatabaseUserIdentifiers.DBNAME_OPTION_NAME) 
     209                        DatabaseUserIdentifiers.SECTION_NAME, 
     210                        DatabaseUserIdentifiers.DBNAME_OPTNAME) 
    177211        self.__username = cfg.get( 
    178                         DatabaseUserIdentifiers.SECTION_NAME,  
    179                         DatabaseUserIdentifiers.USERNAME_OPTION_NAME) 
     212                        DatabaseUserIdentifiers.SECTION_NAME, 
     213                        DatabaseUserIdentifiers.USERNAME_OPTNAME) 
    180214        self.__pwd = cfg.get( 
    181                         DatabaseUserIdentifiers.SECTION_NAME,  
    182                         DatabaseUserIdentifiers.PWD_OPTION_NAME) 
     215                        DatabaseUserIdentifiers.SECTION_NAME, 
     216                        DatabaseUserIdentifiers.PWD_OPTNAME) 
    183217 
    184218        self.__generateQuery = cfg.get( 
    185                         DatabaseUserIdentifiers.SECTION_NAME,  
    186                         DatabaseUserIdentifiers.QUERY_GENERATE_OPTION_NAME) 
     219                        DatabaseUserIdentifiers.SECTION_NAME, 
     220                        DatabaseUserIdentifiers.QUERY_GENERATE_OPTNAME) 
     221 
     222        self.__generateFromUserKeyQuery = cfg.get( 
     223                    DatabaseUserIdentifiers.SECTION_NAME, 
     224                    DatabaseUserIdentifiers.QUERY_GENERATE_FROM_USERKEY_OPTNAME) 
     225 
     226        self.__getIdentifiersQuery = cfg.get( 
     227                    DatabaseUserIdentifiers.SECTION_NAME, 
     228                    DatabaseUserIdentifiers.QUERY_GET_IDENTIFIERS_OPTNAME) 
    187229 
    188230        self.__uniqIdentifierQuery = cfg.get( 
    189                     DatabaseUserIdentifiers.SECTION_NAME,  
    190                     DatabaseUserIdentifiers.QUERY_UNIQ_IDENTIFIER_OPTION_NAME) 
     231                    DatabaseUserIdentifiers.SECTION_NAME, 
     232                    DatabaseUserIdentifiers.QUERY_UNIQ_IDENTIFIER_OPTNAME) 
    191233 
    192234    def connect(self, 
     
    230272 
    231273        try: 
    232             self.__db = connect("host=%s dbname=%s user=%s password=%s" %  
     274            self.__db = connect("host=%s dbname=%s user=%s password=%s" % 
    233275                                (host, dbName, username, pwd)) 
    234276            self.__cursor = self.__db.cursor() 
    235              
     277 
    236278        except NameError, e: 
    237279            raise DatabaseUserIdentifiersConfigError( 
     
    239281                    "Postgres Python package psycopg2 is installed; error is: " 
    240282                    "%s" % e) 
    241              
     283 
    242284        except Exception, e: 
    243285            log.error("Error connecting to database \"%s\": %s" % (dbName, e)) 
    244             raise  
     286            raise 
    245287 
    246288    def close(self): 
     
    256298        again but incrementing the counter to give a new id. 
    257299        Make recursive calls until a unique id is arrived at 
     300         
     301        @type ids: list 
     302        @param ids: list of existing OpenID identifiers 
     303        @type idBase: basestring 
     304        @param idBase: base string from which to construct a new identifier 
     305        @type newId: basestring 
     306        @param newId: candidate identifier to add in 
     307        @type counter: int 
     308        @param counter: number to append to an existing identifier in order to 
     309        make it into a new unique one 
     310        @rtype: basestring 
     311        @return: new unique identifier 
    258312        """ 
    259313        if newId is None: 
     
    271325        """Generate a list of OpenID identifiers from the configured 
    272326        query 
     327        @rtype: list  
     328        @return: list of username/OpenID user identifiers tuples 
    273329        """ 
    274330 
     
    284340            for res in queryRes: 
    285341                accountIds += [res[0]] 
    286                 id = DatabaseUserIdentifiers.makeIdentifier(*res[1:3]) 
    287                 id = DatabaseUserIdentifiers.makeUniqId(ids, id) 
    288                 ids += [id] 
     342                identifier = DatabaseUserIdentifiers.makeIdentifier(*res[1:3]) 
     343                identifier = DatabaseUserIdentifiers.makeUniqId(ids, identifier) 
     344                ids += [identifier] 
    289345        finally: 
    290346            self.close() 
     
    293349        return zip(accountIds, ids) 
    294350 
     351    def getIdentifiers(self): 
     352        """Get all OpenID identifiers currently held in the database 
     353        @rtype: list 
     354        @return: list of OpenID user identifiers 
     355        """ 
     356        try: 
     357            self.connect() 
     358 
     359            self.__cursor.execute(self.__getIdentifiersQuery) 
     360            queryRes = self.__cursor.fetchall() 
     361 
     362            identifiers = [res[0] for res in queryRes] 
     363        finally: 
     364            self.close() 
     365 
     366        return identifiers 
     367 
     368    def generateFromUserKey(self, userKey): 
     369        """Generate a single OpenID identifier from a single user key configured 
     370        in the given query 
     371        @type userKey: basestring 
     372        @param userKey: database user table primary key 
     373        @rtype: string 
     374        @return: OpenID user identifier 
     375        """ 
     376        queryTmpl = Template(self.__generateFromUserKeyQuery) 
     377        userKeyKw = { 
     378            DatabaseUserIdentifiers.USERKEY_FIELD_NAME: userKey 
     379        } 
     380        query = queryTmpl.substitute(userKeyKw) 
     381 
     382        try: 
     383            self.connect() 
     384 
     385            self.__cursor.execute(query) 
     386            queryRes = self.__cursor.fetchall() 
     387        finally: 
     388            self.close() 
     389 
     390        # Create OpenID URL snippet 
     391        res = queryRes[0] 
     392        identifier = DatabaseUserIdentifiers.makeIdentifier(*res[1:3]) 
     393        existingIdentifiers = self.getIdentifiers() 
     394        identifier = DatabaseUserIdentifiers.makeUniqId(existingIdentifiers, 
     395                                                        identifier) 
     396 
     397        # Return the generated identifier 
     398        return identifier 
     399 
    295400    def isUniqIdentifier(self, identifier): 
    296         """Check for the given OpenID User identifier URI snippet in the  
     401        """Check for the given OpenID User identifier URI snippet in the 
    297402        database 
     403        @type identifier: basestring 
     404        @param identifier: OpenID user identifier 
     405        @rtype: bool 
     406        @return: True if input identifier is not present in the database 
    298407        """ 
    299408        queryTmpl = Template(self.__uniqIdentifierQuery) 
     
    301410            DatabaseUserIdentifiers.UNIQ_IDENTIFIER_FIELD_NAME: identifier 
    302411        } 
    303         query = queryTmpl.substitute(**identKw) 
     412        query = queryTmpl.substitute(identKw) 
    304413 
    305414        try: 
     
    323432import os 
    324433 
    325 class Main(object):  
    326     """Wrapper to DatabaseUserIdentifiers class to enable call from the  
     434class Main(object): 
     435    """Wrapper to DatabaseUserIdentifiers class to enable call from the 
    327436    command line 
    328437    """ 
    329         
     438 
    330439    MIN_NARGS = 3 
    331440    GENERATE_CMD_NARGS = '' 
    332     GENERATE_CMD_STR = 'generate' 
    333     QUERY_IDENTIFIER_CMD_STR = "query-identifier" 
    334     CMD_STRS = (GENERATE_CMD_STR, QUERY_IDENTIFIER_CMD_STR) 
     441    GENERATE_CMD_STR = 'generate-identifiers' 
     442    GET_IDENTIFIERS_CMD_STR = 'get-identifiers' 
     443    GENERATE_FROM_USERKEY_CMD_STR = 'generate-identifier-from-userkey' 
     444    QUERY_IDENTIFIER_CMD_STR = "is-uniq-identifier" 
     445 
     446    CMD_STRS = ( 
     447        GENERATE_CMD_STR, 
     448        GET_IDENTIFIERS_CMD_STR, 
     449        GENERATE_FROM_USERKEY_CMD_STR, 
     450        QUERY_IDENTIFIER_CMD_STR 
     451    ) 
    335452    DEBUG_ENVVAR_NAME = 'OPENID_USER_IDENTIFIERS_DEBUG' 
    336      
     453 
    337454    @classmethod 
    338455    def run(cls): 
    339456        """Parse command line arguments and run the query specified""" 
    340          
     457 
    341458        if cls.DEBUG_ENVVAR_NAME in os.environ: 
    342459            import pdb 
    343460            pdb.set_trace() 
    344              
     461 
    345462        parser = optparse.OptionParser() 
    346463        parser.add_option("-c", 
    347464                          "--command", 
    348465                          dest="command", 
    349                           help="Database query to execute [%s]" %  
     466                          help="Database query to execute [%s]" % 
    350467                               '|'.join(cls.CMD_STRS)) 
    351      
     468 
    352469        parser.add_option("-f", 
    353470                          "--config-file", 
    354471                          dest="configFilePath", 
    355472                          help="database configuration file path") 
    356      
     473 
    357474        parser.add_option("-u", 
    358475                          "--user-identifier", 
    359476                          dest="userIdentifier", 
    360                           help="user identifier for %s command only" %  
     477                          help="user identifier for %s command only" % 
    361478                               cls.QUERY_IDENTIFIER_CMD_STR) 
    362      
    363         (opt, args) = parser.parse_args() 
    364      
     479 
     480        parser.add_option("-k", 
     481                          "--user-key", 
     482                          dest="userKey", 
     483                          type="string", 
     484                          help="database user key for %s command only" % 
     485                               cls.GENERATE_FROM_USERKEY_CMD_STR) 
     486 
     487        opt = parser.parse_args()[0] 
     488 
    365489        if not opt.command: 
    366490            msg = "Error, no command set.\n\n" + parser.format_help() 
    367491            raise SystemExit(msg) 
    368492 
     493        if not opt.command: 
     494            msg = "Error, no command set.\n\n" + parser.format_help() 
     495            raise SystemExit(msg) 
     496 
    369497        ids = DatabaseUserIdentifiers(opt.configFilePath) 
    370498 
     
    372500            for i in ids.generate(): 
    373501                print(i) 
    374      
     502        elif opt.command == cls.GET_IDENTIFIERS_CMD_STR: 
     503            identifiers = ids.getIdentifiers() 
     504            print(identifiers) 
     505 
     506        elif opt.command == cls.GENERATE_FROM_USERKEY_CMD_STR: 
     507            if not opt.userKey: 
     508                msg = "Error, no user key set for query command.\n\n" +\ 
     509                    parser.format_help() 
     510                raise SystemExit(msg) 
     511 
     512            identifier = ids.generateFromUserKey(opt.userKey) 
     513            print(identifier) 
     514 
    375515        elif opt.command == cls.QUERY_IDENTIFIER_CMD_STR: 
    376516            if not opt.userIdentifier: 
     
    378518                    parser.format_help() 
    379519                raise SystemExit(msg) 
    380              
     520 
    381521            isUniqIdent = ids.isUniqIdentifier(opt.userIdentifier) 
    382522            print(isUniqIdent) 
    383      
     523 
    384524            # In line with exit status convention 0 status means it 
    385525            # IS NOT currently allocated, 1 means it is 
     
    389529                    parser.format_help() 
    390530            raise SystemExit(msg) 
    391          
     531 
    392532if __name__ == "__main__": 
    393533    logging.basicConfig() 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/__init__.py

    r5786 r5870  
    3030 
    3131from ndg.security.common.utils.classfactory import instantiateClass 
    32 from ndg.security.server.wsgi import NDGSecurityMiddlewareBase         
     32from ndg.security.server.wsgi import NDGSecurityMiddlewareBase   
     33 
     34 
     35class IdentityMapping(object): 
     36    """Utility class to map between user identifiers and OpenID URIs 
     37    The user identifier is the user unique component of an OpenID URI 
     38    """ 
     39    USER_IDENTIFIER_NAME = 'userIdentifier' 
     40     
     41    # Template substitution may or may not contain braces 
     42    USER_IDENTIFIER_RE = re.compile('\$\{?%s\}?' % USER_IDENTIFIER_NAME) 
     43     
     44    @classmethod 
     45    def userIdentifier2IdentityURI(cls, identityUriTmpl, userIdentifier): 
     46        """Convert an OpenID user identifier into an identity URI given a 
     47        template e.g. 
     48         
     49        https://${userIdentifier}.openid.ac.uk + pjk => https://pjk.openid.ac.uk 
     50        """ 
     51        mapping = {cls.USER_IDENTIFIER_NAME: userIdentifier} 
     52        tmpl = Template(identityUriTmpl) 
     53        return tmpl.substitute(mapping) 
     54         
     55    @classmethod 
     56    def identityUri2UserIdentifier(cls, identityUriTmpl, identityUri): 
     57        """Parse an OpenID user identifier from an identity URI given a 
     58        template e.g. 
     59         
     60        https://pjk.openid.ac.uk + https://${userIdentifier}.openid.ac.uk => pjk 
     61        """ 
     62        # Subtract start and end URI snippets from the template 
     63        try: 
     64            uriPrefix, uriSuffix = cls.USER_IDENTIFIER_RE.split(identityUriTmpl) 
     65        except ValueError: 
     66            raise OpenIDProviderConfigError('Error parsing identity URI %r ' 
     67                                            'using template %r' % 
     68                                            (identityUri, identityUriTmpl)) 
     69             
     70        if not identityUri.startswith(uriPrefix):  
     71            raise OpenIDProviderConfigError('Identity URI %r doesn\'t match ' 
     72                                            'the template prefix %r' % 
     73                                            (identityUri, uriPrefix)) 
     74             
     75        suffixIndex = identityUri.rfind(uriSuffix)     
     76        if suffixIndex == -1:  
     77            raise OpenIDProviderConfigError('Identity URI %r doesn\'t match ' 
     78                                            'the template suffix %r' % 
     79                                            (identityUri, uriSuffix)) 
     80         
     81        userIdentifier = identityUri[:suffixIndex].replace(uriPrefix, '', 1) 
     82        return userIdentifier 
     83  
     84# Place here to avoid circular import error with IdentityMapping class      
    3385from ndg.security.server.wsgi.openid.provider.authninterface import \ 
    3486    AbstractAuthNInterface, AuthNInterfaceError 
     
    748800                except Exception, e: 
    749801                    log.error("Unexpected %s type exception raised during " 
    750                               "authentication: %s" %  
    751                               e.__class__.__name__, 
     802                              "authentication: %s", type(e), 
    752803                              traceback.format_exc()) 
    753804                    msg = ("An internal error occurred.  " 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/sqlalchemy_authn.py

    r5869 r5870  
    2222from sqlalchemy import create_engine, exc 
    2323 
     24from ndg.security.common.utils import str2Bool as _str2Bool 
    2425from ndg.security.server.wsgi.openid.provider.authninterface import \ 
    2526    AbstractAuthNInterface, AuthNInterfaceInvalidCredentials, \ 
     
    3233    making use of the SQLAlchemy database package''' 
    3334     
    34     getUserIdentifier = staticmethod(lambda identityURI:  
    35                                      identityURI.rsplit('/')[-1]) 
    36      
    37     _str2Bool = lambda str: str.lower() in ["yes", "true", "t", "1"] 
    3835    str2Bool = staticmethod(_str2Bool) 
    3936     
     
    5350        '''Instantiate object taking in settings from the input 
    5451        properties''' 
     52        log.debug('Initialising SQLAlchemyAuthnInterface instance ...') 
     53         
    5554        self.__connectionString = None 
    5655        self.__logonSqlQuery = None 
     
    5958         
    6059        try: 
    61             self.connectionString = prop.get( 
    62                             SQLAlchemyAuthnInterface.CONNECTION_STRING_OPTNAME) 
     60            self.connectionString = prop[ 
     61                            SQLAlchemyAuthnInterface.CONNECTION_STRING_OPTNAME] 
    6362             
    64             self.logonSqlQuery = prop.get( 
    65                             SQLAlchemyAuthnInterface.LOGON_SQLQUERY_OPTNAME) 
     63            self.logonSqlQuery = prop[ 
     64                            SQLAlchemyAuthnInterface.LOGON_SQLQUERY_OPTNAME] 
    6665                       
    67             self.username2UserIdentifierSqlQuery = prop.get( 
    68             SQLAlchemyAuthnInterface.USERNAME2USERIDENTIFIER_SQLQUERY_OPTNAME) 
     66            self.username2UserIdentifierSqlQuery = prop[ 
     67            SQLAlchemyAuthnInterface.USERNAME2USERIDENTIFIER_SQLQUERY_OPTNAME] 
    6968   
    70             self.isMD5EncodedPwd = prop.get( 
    71                             SQLAlchemyAuthnInterface.IS_MD5_ENCODED_PWD,  
    72                             False) 
    73              
    74         except TypeError, e: 
     69            self.isMD5EncodedPwd = prop[ 
     70                            SQLAlchemyAuthnInterface.IS_MD5_ENCODED_PWD]     
     71        except KeyError, e: 
    7572            raise AuthNInterfaceConfigError("Initialisation from keywords: %s"% 
    7673                                            e) 
     
    8178    def _setConnectionString(self, value): 
    8279        if not isinstance(value, basestring): 
    83             raise TypeError('Expecting string type for "connectionString" ' 
    84                             'attribute; got %r' % type(value)) 
     80            raise TypeError('Expecting string type for "%s" attribute; got %r'% 
     81                            (SQLAlchemyAuthnInterface.CONNECTION_STRING_OPTNAME, 
     82                             type(value))) 
    8583        self.__connectionString = value 
    8684 
     
    9492    def _setLogonSqlQuery(self, value): 
    9593        if not isinstance(value, basestring): 
    96             raise TypeError('Expecting string type for "logonSqlQuery" ' 
    97                             'attribute; got %r' % type(value)) 
     94            raise TypeError('Expecting string type for "%s" ' 
     95                            'attribute; got %r' %  
     96                            (SQLAlchemyAuthnInterface.LOGON_SQLQUERY_OPTNAME, 
     97                             type(value))) 
    9898        self.__logonSqlQuery = value 
    9999 
     
    107107    def _setUsername2UserIdentifierSqlQuery(self, value): 
    108108        if not isinstance(value, basestring): 
    109             raise TypeError('Expecting string type for ' 
    110                             '"username2UserIdentifierSqlQuery" attribute; ' 
    111                             'got %r' % type(value)) 
     109            raise TypeError('Expecting string type for "%s" attribute; got %r'% 
     110                            (SQLAlchemyAuthnInterface. 
     111                             USERNAME2USERIDENTIFIER_SQLQUERY_OPTNAME, 
     112                             type(value))) 
    112113        self.__username2UserIdentifierSqlQuery = value 
    113114 
     
    189190        if result.rowcount != 1: 
    190191            raise AuthNInterfaceInvalidCredentials() 
     192         
     193        log.debug('Logon succeeded for user %r' % username) 
    191194 
    192195    def logout(self): 
     
    242245                                                  username) 
    243246             
    244         return tuple([i[0] for i in result.fetchall()]) 
     247        userIdentifiers = tuple([i[0] for i in result.fetchall()]) 
     248           
     249        log.debug('username %r maps to OpenID identifiers: %r', username, 
     250                  userIdentifiers) 
     251         
     252        return userIdentifiers 
    245253 
    246254    def __getstate__(self): 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/__init__.py

    r5782 r5870  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id$' 
     11from ndg.security.server.wsgi.openid.provider import IdentityMapping 
    1112 
    1213class AXInterfaceError(Exception): 
     
    2829    Requests from a Relying Party""" 
    2930     
     31    userIdentifier2IdentityURI = IdentityMapping.userIdentifier2IdentityURI 
     32    identityUri2UserIdentifier = IdentityMapping.identityUri2UserIdentifier 
     33      
    3034    def __init__(self, **cfg): 
    3135        """Add custom settings from the OpenID Provider's  
Note: See TracChangeset for help on using the changeset viewer.