Synnefo

API_GETSERVICES = join_urls(ACCOUNTS_PREFIX, "get_services")

TOKENS_ENDPOINTS = join_urls(API_TOKENS, "endpoints")

    # do a GET to ``API_TOKENS``/<user_token>/``TOKENS_ENDPOINTS``

    def get_endpoints(self, token, belongs_to=None, marker=None, limit=None):

        """Request registered endpoints from astakos

        keyword arguments:

        token       -- user's token (string)

        belongs_to  -- user's uuid (string)

        marker      -- return endpoints whose ID is higher than marker's (int)

        limit       -- maximum number of endpoints to return (int)

        Return a json formatted dictionary containing information

        about registered endpoints.

        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

        get_user_info_with_endpoints instead.

        """

        params = {}

        if belongs_to is not None:

            params['belongsTo'] = str(belongs_to)

        if marker is not None:

            params['marker'] = str(marker)

        if limit is not None:

            params['limit'] = str(limit)

        path = API_TOKENS + "/" + token + "/" + \

            TOKENS_ENDPOINTS + "?" + urllib.urlencode(params)

        return self._call_astakos(token, path)

    # ----------------------------------

    def get_user_info_with_endpoints(self, token, uuid=None):

    if url.startswith(astakosclient.API_AUTHENTICATE):

    elif url.startswith(astakosclient.API_USERCATALOGS):

    elif url.startswith(astakosclient.API_RESOURCES):

    elif url.startswith(astakosclient.API_QUOTAS):

    elif url.startswith(astakosclient.API_COMMISSIONS):

    elif url.startswith(astakosclient.API_TOKENS):

        if url == astakosclient.API_COMMISSIONS:

        if url == astakosclient.API_COMMISSIONS:

            serial = url[25:]

    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)

    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)

endpoints = {

    "endpoints": [

        {"name": "cyclades",

         "region": "cyclades",

         "internalURL": "https://node1.example.com/ui/",

         "adminURL": "https://node1.example.com/v1/",

         "type": None,

         "id": 5,

         "publicURL": "https://node1.example.com/ui/"},

        {"name": "pithos",

         "region": "pithos",

         "internalURL": "https://node2.example.com/ui/",

         "adminURL": "https://node2.example.com/v1",

         "type": None,

         "id": 6,

         "publicURL": "https://node2.example.com/ui/"}],

    "endpoint_links": [

        {"href": "/astakos/api/tokens/0000/endpoints?marker=4&limit=10000",

         "rel": "next"}]}

        global token_1, endpoints

        _mock_request([_request_ok])

        try:

            client = AstakosClient("https://example.com")

            response = client.get_endpoints(token_1)

        except Exception as err:

            self.fail("Shouldn't raise Exception %s" % err)

        self.assertEqual(response, endpoints)

    # ----------------------------------

    def test_get_endpoints_wrong_token(self):

        """Test function call of get_endpoints with wrong token"""

        global token_2, endpoints

        _mock_request([_request_ok])

        try:

            client = AstakosClient("https://example.com")

            client.get_endpoints(token_2, marker=2, limit=100)

        except Unauthorized:

            pass

        except Exception as err:

            self.fail("Shouldn't raise Exception %s" % err)

        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"""

            response = client.get_user_info_with_endpoints(token_1)

    **get_endpoints(**\ token, belongs_to, marker, limit\ **)**

        Given a user's authentication token, request registered

        endpoints from astakos service. If belongs_to is given (uuid)

        check that the token belongs to this user. If marker is given

        (int) return endpoints (ordered by ID) whose ID is higher than

        the marker. Limit (int) specifies the maximum number of

        endpoints to return. Return a json formatted dictionary containing

        information about registered endpoints.

        .. 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). Use

            get_user_info_with_endpoints instead.

    **get_user_info_with_endpoints(**\ token, uuid=None\ **)**