/ - Diff - Synnefo - Greek Research and Technology Network's projects

         # ----------------------------------
         @retry
         def _call_astakos(self, token, request_path,
                           headers=None, body=None, method="GET"):
         def _call_astakos(self, token, request_path, headers=None,
                           body=None, method="GET", log_body=True):
             """Make the actual call to Astakos Service"""
             if token is not None:
                 hashed_token = hashlib.sha1()
-...
                 using_token = "without using token"
             self.logger.debug(
                 "Make a %s request to %s %s with headers %s and body %s"
                 % (method, request_path, using_token, headers, body))
                 % (method, request_path, using_token, headers,
                    body if log_body else "(not logged)"))
             # Check Input
             if headers is None:
-...
             WARNING: This api call encodes the user's token inside the url.
             It's thoughs security unsafe to use it (both astakosclient and
             nginx tend to log requested urls).
             Avoid the use of get_endpoints method and use *** instead.
             Avoid the use of get_endpoints method and use
             get_user_info_with_endpoints instead.
             """
             params = {}
-...
             return self._call_astakos(token, path)
         # ----------------------------------
         # do a POST to ``API_TOKENS``
         def get_user_info_with_endpoints(self, token, uuid=None):
             """ Fallback call for authenticate
             Keyword arguments:
             token   -- user's token (string)
             uuid    -- user's uniq id
             It returns back the token as well as information about the token
             holder and the services he/she can acess (in json format).
             In case of error raise an AstakosClientException.
             """
             req_path = copy(API_TOKENS)
             req_headers = {'content-type': 'application/json'}
             body = {'auth': {'token': {'id': token}}}
             if uuid is not None:
                 body['auth']['tenantName'] = uuid
             req_body = parse_request(body, self.logger)
             return self._call_astakos(token, req_path, req_headers,
                                       req_body, "POST", False)
         # ----------------------------------
         # do a GET to ``API_QUOTAS``
         def get_quotas(self, token):
             """Get user's quotas

         # Check input
         if conn.__class__.__name__ != "HTTPSConnection":
             return _request_status_302(conn, method, url, **kwargs)
         if method != "GET":
             return _request_status_400(conn, method, url, **kwargs)
         token_head = kwargs['headers'].get('X-Auth-Token')
         url_split = url[len(astakosclient.API_TOKENS):].split('/')
         token_url = url_split[1]
         if token_head != token_url:
             return _request_status_403(conn, method, url, **kwargs)
         if token_url != token_1:
             return _request_status_401(conn, method, url, **kwargs)
         if url == astakosclient.API_TOKENS:
             if method != "POST":
                 return _request_status_400(conn, method, url, **kwargs)
             body = simplejson.loads(kwargs['body'])
             token = body['auth']['token']['id']
             if token != token_1:
                 return _request_status_401(conn, method, url, **kwargs)
             # Return
             return ("", simplejson.dumps(user_info_endpoints), 200)
         # Return
         return ("", simplejson.dumps(endpoints), 200)
         else:
             if method != "GET":
                 return _request_status_400(conn, method, url, **kwargs)
             url_split = url[len(astakosclient.API_TOKENS):].split('/')
             token_url = url_split[1]
             if token_head != token_url:
                 return _request_status_403(conn, method, url, **kwargs)
             if token_url != token_1:
                 return _request_status_401(conn, method, url, **kwargs)
             # Return
             return ("", simplejson.dumps(endpoints), 200)
     # ----------------------------
-...
             {"href": "/astakos/api/tokens/0000/endpoints?marker=4&limit=10000",
              "rel": "next"}]}
     user_info_endpoints = \
         {'serviceCatalog': [
             {'endpoints': [{
                 'SNF:uiURL': 'https://node1.example.com/ui/',
                 'adminURL': 'https://node1.example.com/v1',
                 'internalUrl': 'https://node1.example.com/v1',
                 'publicURL': 'https://node1.example.com/v1',
                 'region': 'cyclades'}],
              'name': 'cyclades',
              'type': 'compute'},
             {'endpoints': [{
                 'SNF:uiURL': 'https://node2.example.com/ui/',
                 'adminURL': 'https://node2.example.com/v1',
                 'internalUrl': 'https://node2.example.com/v1',
                 'publicURL': 'https://node2.example.com/v1',
                 'region': 'pithos'}],
              'name': 'pithos',
              'type': 'storage'}],
          'token': {
              'expires': '2013-06-19T15:23:59.975572+00:00',
              'id': token_1,
              'tenant': {
                  'id': user_1,
                  'name': 'Firstname Lastname'}},
          'user': {
              'id': user_1,
              'name': 'Firstname Lastname',
              'roles': [{'id': 1, 'name': 'default'}],
              'roles_links': []}}
     quotas = {
         "system": {
             "cyclades.ram": {
-...
             else:
                 self.fail("Should have raised Unauthorized Exception")
         # ----------------------------------
         def test_get_user_info_with_endpoints(self):
             """Test function call of get_user_info_with_endpoints"""
             global token_1, user_info_endpoints
             _mock_request([_request_ok])
             try:
                 client = AstakosClient("https://example.com")
                 response = client.get_user_info_with_endpoints(token_1)
             except Exception as err:
                 self.fail("Shouldn't raise Exception %s" % err)
             self.assertEqual(response, user_info_endpoints)
     # ----------------------------
     # Run tests

             .. warning:: *get_endpoints* api call encodes the user's token inside
                 the url. It's security unsafe to use it (both astakosclient
                 and nginx tend to log requested urls).
                 and nginx tend to log requested urls). Use
                 get_user_info_with_endpoints instead.
         **get_user_info_with_endpoints(**\ token, uuid=None\ **)**
             Fallback call which receives the user token or the user uuid/token
             and returns back the token as well as information about the token
             holder and the services he/seh can access.
             In case of error raise an AstakosClientException exception.
         **get_quotas(**\ token\ **)**
             Given a user's authentication token return user's

Synnefo

Revision 25a04cdd