Changeset 1770


Ignore:
Timestamp:
27/11/06 12:06:27 (13 years ago)
Author:
pjkersha
Message:

www/html/sessionMgr.wsdl: updated connect and reqAuthorisation input message args.
test/SessionMgrClientTest.py: added disconnect methods are started changes for doc/lit style WS
interface + use of WS-Security.
test/AttAuthority/AttAuthorityClientTest.py and common/AttAuthority/init.py: use URI instead of URL
throughout.
common/SessionMgr/init.py: changes for doc/lit style WS interface + use of WS-Security.
common/SessionCookie.py: added sessionID and encrSessionMgrURI read-only attributes.

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

Legend:

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

    r1749 r1770  
    4242    #_________________________________________________________________________ 
    4343    def __init__(self,  
    44                  url=None,  
     44                 uri=None,  
    4545                 aaPubKeyFilePath=None, 
    4646                 clntPubKeyFilePath=None, 
     
    4848                 tracefile=None): 
    4949        """ 
    50         url:                    WSDL URI for Attribute Authority WS.  Setting  
     50        uri:                    WSDL URI for Attribute Authority WS.  Setting  
    5151                                 it will set the Service Proxy 
    5252        aaPubKeyFilePath:        Public key of Attribute Authority used to  
     
    6565 
    6666        self.__srv = None 
    67         self.__url = None 
     67        self.__uri = None 
    6868        self.__aaPubKeyFilePath = None 
    6969        self.__aaPubKeyFilePath = None 
     
    7575         
    7676         
    77         if url: 
    78             self.__setURL(url) 
     77        if uri: 
     78            self.__setURI(uri) 
    7979             
    8080        if aaPubKeyFilePath: 
     
    9797          
    9898        # Instantiate Attribute Authority WS proxy 
    99         if self.__url: 
     99        if self.__uri: 
    100100            self.initService() 
    101101         
    102102 
    103103    #_________________________________________________________________________ 
    104     def __setURL(self, url): 
    105          
    106         if not isinstance(url, basestring): 
     104    def __setURI(self, uri): 
     105         
     106        if not isinstance(uri, basestring): 
    107107            raise AttAuthorityClientError, \ 
    108108                        "Attribute Authority WSDL URI must be a valid string" 
    109109         
    110         self.__url = url 
    111          
    112     url = property(fset=__setURL, doc="Set Attribute Authority WSDL URI") 
     110        self.__uri = uri 
     111         
     112    uri = property(fset=__setURI, doc="Set Attribute Authority WSDL URI") 
    113113 
    114114 
     
    191191         
    192192    #_________________________________________________________________________ 
    193     def initService(self, url=None): 
     193    def initService(self, uri=None): 
    194194        """Set the WS proxy for the Attribute Authority""" 
    195         if url: 
    196             self.__setURL(url) 
     195        if uri: 
     196            self.__setURI(uri) 
    197197 
    198198        try: 
    199199            locator = AttAuthorityServiceLocator() 
    200             self.__srv = locator.getAttAuthority(self.__url,  
     200            self.__srv = locator.getAttAuthority(self.__uri,  
    201201                                                 tracefile=self.__tracefile) 
    202202        except HTTPResponse, e: 
    203203            raise AttAuthorityClientError, \ 
    204204            "Error initialising WSDL Service for \"%s\": %s %s" % \ 
    205                 (self.__url, e.status, e.reason) 
     205                (self.__uri, e.status, e.reason) 
    206206             
    207207        except Exception, e: 
    208208            raise AttAuthorityClientError, \ 
    209209                "Initialising WSDL Service for \"%s\": %s" % \ 
    210                  (self.__url, str(e)) 
     210                 (self.__uri, str(e)) 
    211211 
    212212                                     
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionCookie.py

    r1648 r1770  
    9999         
    100100        try: 
    101             sessID = cookieTagKw['NDG-ID1'] 
    102             encrSessMgrWSDLuri = cookieTagKw['NDG-ID2'] 
     101            sessID = cookieTagKw[SessionCookie.tags[0]] 
     102            encrSessionMgrURI = cookieTagKw[SessionCookie.tags[1]] 
    103103             
    104104        except KeyError: 
     
    112112            SessionCookieError, "Session ID has an invalid length" 
    113113             
    114         if encrSessMgrWSDLuri[:7] == 'http://' or \ 
    115            encrSessMgrWSDLuri[:8] == 'https://': 
     114        if encrSessionMgrURI[:7] == 'http://' or \ 
     115           encrSessionMgrURI[:8] == 'https://': 
    116116            SessionCookieError, "Input Session Manager WSDL URI does not " + \ 
    117117                                "appear to have been encrypted" 
     
    131131            self.__cookie = SimpleCookie() 
    132132              
    133             tagValues = (sessID, encrSessMgrWSDLuri) 
     133            tagValues = (sessID, encrSessionMgrURI) 
    134134            i=0 
    135135            for tag in self.tags: 
     
    181181    cookieDomain = property(fset=__setCookieDomain, doc="Set cookie domain") 
    182182        
     183 
     184    #_________________________________________________________________________ 
     185    def __getSessionID(self): 
     186        """Return the session ID from the cookie""" 
     187        return self.__cookie[SessionCookie.tags[0]]  
     188     
     189    sessionID = property(fget=__getSessionID, doc="Get session ID") 
     190 
     191    #_________________________________________________________________________ 
     192    def __getEncrSessionMgrURI(self): 
     193        """Return the Encrypted Session manager URI from the cookie""" 
     194        return self.__cookie[SessionCookie.tags[1]]  
     195 
     196    encrSessionMgrURI = property(fget=__getEncrSessionMgrURI,  
     197                                 doc="Get encrypted Session Manager URI") 
     198 
    183199     
    184200    #_________________________________________________________________________ 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionMgr/__init__.py

    r1753 r1770  
    1313version 1.0 or later. 
    1414""" 
    15  
    16 from ZSI import ServiceProxy 
    17 from ZSI.wstools.Utility import HTTPResponse 
     15__all__ = ['SessionMgr_services', 'SessionMgr_services_types'] 
     16 
     17from SessionMgr_services import SessionMgrServiceLocator 
    1818 
    1919import sys 
    2020import os 
    21 from Cookie import SimpleCookie 
     21from ndg.security.common.SessionCookie import SessionCookie 
    2222 
    2323# Handle retrieval of public key cert for Session Manager/Attribute Authority 
     
    3232 
    3333#_____________________________________________________________________________ 
    34 class SessionClientError(Exception): 
    35     """Exception handling for SessionClient class""" 
    36     def __init__(self, msg): 
    37         self.__msg = msg 
    38           
    39     def __str__(self): 
    40         return self.__msg 
    41  
     34class SessionMgrClientError(Exception): 
     35    """Exception handling for SessionMgrClient class""" 
    4236 
    4337#_____________________________________________________________________________        
    44 class SessionClient(object): 
     38class SessionMgrClient(object): 
    4539    """Client interface to Session Manager Web Service""" 
    4640     
    4741    #_________________________________________________________________________ 
    4842    def __init__(self,  
    49                  smWSDL=None,  
     43                 uri=None,  
    5044                 smPubKeyFilePath=None, 
    5145                 clntPubKeyFilePath=None, 
     
    5347                 traceFile=None): 
    5448        """ 
    55         smWSDL:                  WSDL URI for Session Manager WS.  Setting it  
     49        uri:                  WSDL URI for Session Manager WS.  Setting it  
    5650                                 will set the Service Proxy 
    5751        smPubKeyFilePath:     
     
    7064 
    7165        self.__smSrv = None 
    72         self.__smWSDL = None 
     66        self.__uri = None 
    7367        self.__smPubKeyFilePath = None 
    7468        self.__smPubKeyFilePath = None 
     
    8074         
    8175         
    82         if smWSDL: 
    83             self.__setSMwsdl(smWSDL) 
     76        if uri: 
     77            self.__setURI(uri) 
    8478             
    8579        if smPubKeyFilePath: 
     
    9185        if clntPubKeyFilePath: 
    9286            if clntPriKeyFilePath is None: 
    93                 raise SessionClientError, \ 
     87                raise SessionMgrClientError, \ 
    9488                    "A Client private key file is required as well a " + \ 
    9589                    "public key" 
     
    10296          
    10397        # Instantiate Session Manager WS proxy 
    104         if self.__smWSDL: 
    105             self.serviceProxy() 
    106          
    107  
    108     #_________________________________________________________________________ 
    109     def __setSMwsdl(self, smWSDL): 
    110          
    111         if not isinstance(smWSDL, basestring): 
    112             raise SessionClientError, \ 
     98        if self.__uri: 
     99            self.initService() 
     100         
     101 
     102    #_________________________________________________________________________ 
     103    def __setURI(self, uri): 
     104         
     105        if not isinstance(uri, basestring): 
     106            raise SessionMgrClientError, \ 
    113107                             "Session Manager WSDL URI must be a valid string" 
    114108         
    115         self.__smWSDL = smWSDL 
    116          
    117     smWSDL = property(fset=__setSMwsdl, doc="Set Session Manager WSDL URI") 
     109        self.__uri = uri 
     110         
     111    uri = property(fset=__setURI, doc="Set Session Manager WSDL URI") 
    118112 
    119113 
     
    122116         
    123117        if not isinstance(smPubKeyFilePath, basestring): 
    124             raise SessionClientError, \ 
     118            raise SessionMgrClientError, \ 
    125119                "Session Manager public key URI must be a valid string" 
    126120         
     
    135129         
    136130        if not isinstance(clntPubKeyFilePath, basestring): 
    137             raise SessionClientError(\ 
     131            raise SessionMgrClientError(\ 
    138132                "Client public key file path must be a valid string") 
    139133         
     
    143137             
    144138        except IOError, (errNo, errMsg): 
    145             raise SessionClientError, "Reading certificate file \"%s\": %s" %\ 
     139            raise SessionMgrClientError, "Reading certificate file \"%s\": %s" %\ 
    146140                                        (self.__clntPubKeyFilePath, errMsg) 
    147141                                
    148142        except Exception, e: 
    149             raise SessionClientError, "Reading certificate file \"%s\": %s" %\ 
     143            raise SessionMgrClientError, "Reading certificate file \"%s\": %s" %\ 
    150144                                        (self.__clntPubKeyFilePath, str(e)) 
    151145         
     
    158152         
    159153        if not isinstance(clntPriKeyFilePath, basestring): 
    160             raise SessionClientError, \ 
     154            raise SessionMgrClientError, \ 
    161155                        "Client public key file path must be a valid string" 
    162156         
     
    185179             
    186180        except IOError, (errNo, errMsg): 
    187             raise SessionClientError, \ 
     181            raise SessionMgrClientError, \ 
    188182                                "Writing public key to temp \"%s\": %s" % \ 
    189183                                (self.__smPubKeyTempFile.name, errMsg)                                                                     
    190184        except Exception, e: 
    191             raise SessionClientError, "Retrieving Session Manager " + \ 
     185            raise SessionMgrClientError, "Retrieving Session Manager " + \ 
    192186                                     "public key: %s" % str(e) 
    193187     
    194188         
    195189    #_________________________________________________________________________ 
    196     def serviceProxy(self, smWSDL=None): 
     190    def initService(self, uri=None): 
    197191        """Set the WS proxy for the Session Manager""" 
    198          
    199         if smWSDL: 
    200             self.__setSMwsdl(smWSDL) 
     192        if uri: 
     193            self.__setURI(uri) 
    201194 
    202195        try: 
    203             self.__smSrv = ServiceProxy(self.__smWSDL,  
    204                                         use_wsdl=True,  
    205                                         tracefile=self.__traceFile) 
     196            locator = SessionMgrServiceLocator() 
     197            self.__srv = locator.getSessionMgr(self.__uri,  
     198                                               tracefile=self.__tracefile) 
    206199        except HTTPResponse, e: 
    207             raise SessionClientError, \ 
    208                 "Error initialising WSDL Service Proxy for \"%s\": %s %s" % \ 
    209                 (self.__smWSDL, e.status, e.reason) 
    210              
    211         except Exception, e: 
    212             raise SessionClientError, \ 
    213                 "Initialising WSDL Service Proxy for \"%s\": %s" % \ 
    214                  (self.__smWSDL, str(e)) 
     200            raise SessionMgrClientError, \ 
     201                "Error initialising WSDL Service for \"%s\": %s %s" % \ 
     202                (self.__uri, e.status, e.reason) 
     203             
     204        except Exception, e: 
     205            raise SessionMgrClientError, \ 
     206                "Initialising WSDL Service for \"%s\": %s" % \ 
     207                 (self.__uri, str(e)) 
    215208 
    216209                                     
     
    237230             
    238231            except Exception, e: 
    239                 raise SessionClientError, "Pass-phrase not defined: " + str(e) 
     232                raise SessionMgrClientError, "Pass-phrase not defined: " + \ 
     233                                            str(e) 
    240234 
    241235 
     
    246240        # Make request for new user 
    247241        try:    
    248             addUserReq = smIO.AddUserReq(userName=userName,  
    249                                 pPhrase=pPhrase, 
    250                                 encrCert=self.__clntPubKey, 
    251                                 encrPubKeyFilePath=self.__smPubKeyFilePath)  
    252  
    253             # Pass encrypted request 
    254             resp = self.__smSrv.addUser(addUserReq=addUserReq()) 
    255                          
    256             addUserResp = smIO.AddUserResp(xmlTxt=resp['addUserResp'], 
    257                                 encrPriKeyFilePath=self.__clntPriKeyFilePath, 
    258                                 encrPriKeyPwd=clntPriKeyPwd)             
    259         except Exception, e: 
    260             raise SessionClientError, "Error adding new user: " + str(e) 
    261    
    262                              
    263         if 'errMsg' in addUserResp and addUserResp['errMsg']: 
    264             raise SessionClientError(addUserResp['errMsg']) 
     242            resp = self.__smSrv.addUser(username, pPhrase) 
     243 
     244        except Exception, e: 
     245            raise SessionMgrClientError, "Error adding new user: " + str(e) 
    265246     
    266247         
     
    303284             
    304285            except Exception, e: 
    305                 raise SessionClientError, "Pass-phrase not defined: " + str(e) 
     286                raise SessionMgrClientError, "Pass-phrase not defined: " + str(e) 
    306287 
    307288 
     
    312293        # Make connection 
    313294        try:  
    314             connectReq = smIO.ConnectReq(userName=userName,  
    315                                 pPhrase=pPhrase, 
    316                                 getCookie=getCookie, 
    317                                 createServerSess=createServerSess, 
    318                                 encrCert=self.__clntPubKey, 
    319                                 encrPubKeyFilePath=self.__smPubKeyFilePath)  
    320      
    321             # Pass encrypted request 
    322             resp = self.__smSrv.connect(connectReq=connectReq()) 
    323              
    324             connectResp = smIO.ConnectResp(xmlTxt=resp['connectResp'], 
    325                                 encrPriKeyFilePath=self.__clntPriKeyFilePath, 
    326                                 encrPriKeyPwd=clntPriKeyPwd) 
    327                              
    328             if 'errMsg' in connectResp and connectResp['errMsg']: 
    329                 raise Exception(connectResp['errMsg']) 
    330              
     295            resp = self.__smSrv.connect(userName,  
     296                                        pPhrase, 
     297                                        getCookie, 
     298                                        createServerSess) 
    331299            if 'sessCookie' in connectResp: 
    332300                return connectResp['sessCookie'] 
     
    336304             
    337305            else: 
    338                raise SessionClientError, \ 
     306               raise SessionMgrClientError, \ 
    339307                   "Neither \"sessCookie\" or \"proxyCert\" found in response" 
    340308                
    341309        except Exception, e: 
    342             raise SessionClientError, \ 
     310            raise SessionMgrClientError, \ 
    343311                            "Error connecting to Session Manager: " + str(e) 
    344312     
     
    349317                         sessCookie=None, 
    350318                         sessID=None, 
    351                          encrSessMgrWSDLuri=None, 
    352                          aaWSDL=None, 
    353                          aaPubKey=None, 
     319                         encrSessionMgrURI=None, 
     320                         attAuthorityURI=None, 
     321                         attAuthorityCert=None, 
    354322                         reqRole=None, 
    355323                         mapFromTrustedHosts=None, 
     
    360328        """Request authorisation from NDG Session Manager Web Service. 
    361329         
    362         reqAuthorisation([sessCookie=s]|[sessID=i, encrSessMgrWSDLuri=e]| 
     330        reqAuthorisation([sessCookie=s]|[sessID=i, encrSessionMgrURI=e]| 
    363331                         [proxyCert=p][key=arg, ...]) 
    364332        proxyCert:             proxy certificate - use as ID instead of  
     
    368336                               SimpleCookie type. 
    369337        sessID:                session ID.  Input this as well as  
    370                                encrSessMgrWSDLuri as an alternative to  
     338                               encrSessionMgrURI as an alternative to  
    371339                               sessCookie in the case of a browser client. 
    372         encrSessMgrWSDLuri:    encrypted Session Manager WSDL URI. 
    373         aaWSDL:                WSDL URI for Attribute Authority WS. 
    374         aaPubKey:              The Session Manager uses the Public key of the 
     340        encrSessionMgrURI:     encrypted Session Manager URI. 
     341        attAuthorityURI:      URI for Attribute Authority WS. 
     342        attAuthorityCert:      The Session Manager uses the Public key of the 
    375343                               Attribute Authority to encrypt requests to it. 
    376344        reqRole:               The required role for access to a data set. 
     
    398366            if isinstance(sessCookie, basestring): 
    399367                try: 
    400                     sessCookie = SimpleCookie(sessCookie) 
     368                    sessCookie = SessionCookie(sessCookie) 
    401369                except Exception, e: 
    402                     raise SessionClientError, \ 
     370                    raise SessionMgrClientError, \ 
    403371                                    "Error parsing session cookie: " + str(e) 
    404372 
    405             sessID = sessCookie['NDG-ID1'].value 
    406             encrSessMgrWSDLuri = sessCookie['NDG-ID2'].value 
    407              
    408         elif not sessID and not encrSessMgrWSDLuri and not proxyCert: 
    409             raise SessionClientError, \ 
     373            sessID = sessCookie.sessionID 
     374            encrSessionMgrURI = sessCookie.encrSessionMgrURI 
     375             
     376        elif not sessID and not encrSessionMgrURI and not proxyCert: 
     377            raise SessionMgrClientError, \ 
    410378                '"proxyCert" or "sessCookie or "sessID" and ' + \ 
    411                 '"encrSessMgrWSDLuri" keywords must be set' 
     379                '"encrSessionMgrURI" keywords must be set' 
    412380 
    413381 
     
    418386        # Make authorisation request 
    419387        try: 
    420             authzReq = smIO.AuthorisationReq(aaWSDL=aaWSDL, 
    421                                  aaPubKey=aaPubKey, 
    422                                  sessID=sessID,  
    423                                  encrSessMgrWSDLuri=encrSessMgrWSDLuri, 
    424                                  proxyCert=proxyCert, 
    425                                  reqRole=reqRole, 
    426                                  mapFromTrustedHosts=mapFromTrustedHosts, 
    427                                  rtnExtAttCertList=rtnExtAttCertList, 
    428                                  extAttCertList=extAttCertList, 
    429                                  extTrustedHostList=extTrustedHostList, 
    430                                  encrCert=self.__clntPubKey, 
    431                                  encrPubKeyFilePath=self.__smPubKeyFilePath)  
    432                                              
    433             resp = self.__smSrv.reqAuthorisation(authorisationReq=authzReq()) 
    434             authzResp = smIO.AuthorisationResp(\ 
    435                                 xmlTxt=resp['authorisationResp'], 
    436                                 encrPriKeyFilePath=self.__clntPriKeyFilePath, 
    437                                 encrPriKeyPwd=clntPriKeyPwd) 
    438             return authzResp 
    439              
    440         except Exception, e: 
    441             raise SessionClientError, \ 
     388            resp = self.__srv.reqAuthorisation(proxyCert, 
     389                                               sessID,  
     390                                               encrSessionMgrURI, 
     391                                               attAuthorityURI, 
     392                                               attAuthorityCert, 
     393                                               reqRole, 
     394                                               mapFromTrustedHosts, 
     395                                               rtnExtAttCertList, 
     396                                               extAttCertList, 
     397                                               extTrustedHostList) 
     398            return resp 
     399             
     400        except Exception, e: 
     401            raise SessionMgrClientError, \ 
    442402                                "Error in authorisation request: " + str(e) 
    443403 
     
    448408         
    449409        try:    
    450             pubKeyReq = smIO.PubKeyReq()  
    451  
    452             # Pass request 
    453             resp = self.__smSrv.getPubKey(pubKeyReq=pubKeyReq()) 
    454                          
    455             pubKeyResp = smIO.PubKeyResp(xmlTxt=resp['pubKeyResp']) 
     410            resp = self.__srv.getPubKey() 
     411            return resp 
     412         
     413        except Exception, e: 
     414            raise SessionMgrClientError, "Error retrieving public key: " + \ 
     415                                        str(e) 
    456416                             
    457             if 'errMsg' in pubKeyResp and pubKeyResp['errMsg']: 
    458                 raise SessionClientError(pubKeyResp['errMsg']) 
    459              
    460             return pubKeyResp['pubKey'] 
    461          
    462         except Exception, e: 
    463             raise SessionClientError, "Error retrieving public key: " + str(e) 
    464                              
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/AttAuthority/AttAuthorityClientTest.py

    r1730 r1770  
    2323        try: 
    2424            # Session Manager WSDL 
    25             self.url = 'http://127.0.0.1:5700/AttributeAuthority' 
     25            self.uri = 'http://127.0.0.1:5700/AttributeAuthority' 
    2626     
    2727            # Instantiate WS proxy 
    28             self.clnt = AttAuthorityClient(self.url,  
     28            self.clnt = AttAuthorityClient(self.uri,  
    2929                                           tracefile=sys.stderr) 
    3030        except Exception, e: 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/SessionMgrClientTest.py

    r1752 r1770  
    8080        # Initialise the Session Manager client connection 
    8181        # Omit traceFile keyword to leave out SOAP debug info 
    82         self.sessClnt = SessionMgrClient(smURI=self.config['smWSDL'], 
     82        self.clnt = SessionMgrClient(smURI=self.config['smWSDL'], 
    8383                        smPubKeyFilePath=self.config['smPubKeyFilePath'], 
    8484                        clntPubKeyFilePath=clntPubKeyFilePath, 
     
    9595        # Note the pass-phrase is read from the file tmp.  To pass 
    9696        # explicitly as a string use the 'pPhrase' keyword instead 
    97         self.sessClnt.addUser(self.config['newUserName'],  
    98                               pPhraseFilePath="./tmp", 
    99                               clntPriKeyPwd=self.__clntPriKeyPwd) 
     97        self.clnt.addUser(self.config['newUserName'],  
     98                          pPhraseFilePath="./tmp", 
     99                          clntPriKeyPwd=self.__clntPriKeyPwd) 
    100100        print "Added user '%s'" % self.config['newUserName'] 
    101101         
     
    107107        # Note the pass-phrase is read from the file tmp.  To pass 
    108108        # explicitly as a string use the 'pPhrase' keyword instead 
    109         sSessCookie = self.sessClnt.connect(self.config['userName'],  
     109        sSessCookie = self.clnt.connect(self.config['userName'],  
    110110                                    pPhraseFilePath="./tmp", 
    111111                                    clntPriKeyPwd=self.__clntPriKeyPwd) 
     
    119119        a proxyCert is returned""" 
    120120              
    121         self.proxyCert = self.sessClnt.connect(self.config['userName'],  
     121        self.proxyCert = self.clnt.connect(self.config['userName'],  
    122122                                      pPhraseFilePath="./tmp", 
    123123                                      createServerSess=True, 
     
    126126        print "User '%s' connected to Session Manager:\n%s" % \ 
    127127            (self.config['userName'], self.proxyCert) 
     128             
     129 
     130    def testCookieDisconnect(self): 
     131        """testCookieDisconnect: disconnect as if acting as a browser client -  
     132        a cookie is returned""" 
     133         
     134        # Note the pass-phrase is read from the file tmp.  To pass 
     135        # explicitly as a string use the 'pPhrase' keyword instead 
     136        self.clnt.disconnect(self.sSessCookie) 
     137        print "User disconnected from Session Manager:\n%s" % \ 
     138            self.sSessCookie 
     139             
     140 
     141    def testProxyCertDisconnect(self): 
     142        """testProxyCertDisconnect: Connect as a command line client -  
     143        a proxyCert is returned""" 
     144              
     145        self.clnt.disconnect(self.proxyCert) 
     146        print "User '%s' connected to Session Manager:\n%s" % self.proxyCert 
    128147 
    129148 
     
    133152         
    134153        self.testCookieConnect() 
    135         authResp = self.sessClnt.reqAuthorisation(\ 
     154        authResp = self.clnt.reqAuthorisation(\ 
    136155                    sessID=self.sessCookie['NDG-ID1'].value,  
    137156                    aaWSDL=self.config['aaWSDL'], 
     
    157176        # Request an attribute certificate from an Attribute Authority  
    158177        # using the proxyCert returned from connect() 
    159         authResp = self.sessClnt.reqAuthorisation(\ 
     178        authResp = self.clnt.reqAuthorisation(\ 
    160179                                     proxyCert=self.proxyCert, 
    161180                                     aaWSDL=self.config['aaWSDL'], 
     
    175194    def testGetPubKey(self): 
    176195        "testGetPubKey: return the Session Manager's public key" 
    177         pubKey = self.sessClnt.getPubKey() 
     196        pubKey = self.clnt.getPubKey() 
    178197                                              
    179198        print "Public Key:\n" + pubKey 
     
    187206                  ( 
    188207                    "testAddUser", 
    189                     "testConnect", 
    190                     "testDisconnect", 
    191                     "testReqAuthorisation", 
     208                    "testCookieConnect", 
     209                    "testProxyCertConnect", 
     210                    "testCookieDisconnect", 
     211                    "testProxyCertDisconnect", 
     212                    "testCookieReqAuthorisation", 
     213                    "testProxyCertReqAuthorisation", 
    192214                    "testGetPubKey", 
    193215                  )) 
  • TI12-security/trunk/python/www/html/sessionMgr.wsdl

    r1747 r1770  
    2929        <xsd:complexType> 
    3030          <xsd:sequence> 
    31             <xsd:element name="username" type="xsd:string" minOccurs="1" maxOccurs="1"/> 
    32             <xsd:element name="passPhrase" type="xsd:string" minOccurs="1" maxOccurs="1"/> 
     31            <xsd:element name="username" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     32            <xsd:element name="passPhrase" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     33                    <xsd:element name="createServerSess" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     34                    <xsd:element name="getCookie" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    3335          </xsd:sequence> 
    3436        </xsd:complexType> 
     
    6062        <xsd:complexType> 
    6163                  <xsd:sequence> 
    62                     <xsd:element name="cookie" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    6364                    <xsd:element name="proxyCert" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
    64                   </xsd:sequence> 
     65                    <xsd:element name="sessID" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     66                    <xsd:element name="encrSessMgrURI" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     67                    <xsd:element name="attAuthorityURI" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     68                    <xsd:element name="attAuthorityCert" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     69                    <xsd:element name="reqRole" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     70                    <xsd:element name="mapFromTrustedHosts" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     71                    <xsd:element name="rtnExtAttCertList" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     72                    <xsd:element name="extAttCertList" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     73                    <xsd:element name="extTrustedHostList" type="xsd:string" minOccurs="0" maxOccurs="1"/> 
     74                  </xsd:sequence> 
    6575                </xsd:complexType> 
    6676      </xsd:element> 
Note: See TracChangeset for help on using the changeset viewer.