Python astakosclient.AstakosClient类代码示例

def retrieve_uuids(token, displaynames, return_dict=False, fail_silently=True):
    astakos = AstakosClient(token, ASTAKOS_AUTH_URL, retry=2, use_pool=True, logger=logger)
    catalog = astakos.get_uuids(displaynames) or {}
    missing = list(set(displaynames) - set(catalog))
    if missing and not fail_silently:
        raise ItemNotExists("Unknown uuids: %s" % ", ".join(missing))
    return catalog if return_dict else [catalog.get(i) for i in displaynames]

 def test_reject_commission(self):
     """Test function call of reject_commission"""
     global token, auth_url
     try:
         client = AstakosClient(token['id'], auth_url)
         client.reject_commission(57)
     except Exception as err:
         self.fail("Shouldn't raise Exception %s" % err)

def get_pithos_usage(token):
    """Get Pithos Usage from astakos."""
    astakos = AstakosClient(ASTAKOS_BASE_URL, retry=2, use_pool=True,
                            logger=logger)
    quotas = astakos.get_quotas(token)['system']
    pithos_resources = [r['name'] for r in resources]
    map(quotas.pop, filter(lambda k: k not in pithos_resources, quotas.keys()))
    return quotas.popitem()[-1] # assume only one resource

 def _auth_user(self, pool):
     global token, endpoints_with_info, auth_url
     try:
         client = AstakosClient(token['id'], auth_url, use_pool=pool)
         auth_info = client.authenticate()
     except Exception as err:
         self.fail("Shouldn't raise an Exception: %s" % err)
     self.assertEqual(endpoints_with_info, auth_info)

def retrieve_displaynames(token, uuids, return_dict=False, fail_silently=True):
    astakos = AstakosClient(ASTAKOS_BASE_URL, retry=2, use_pool=True,
                            logger=logger)
    catalog = astakos.get_usernames(token, uuids) or {}
    missing = list(set(uuids) - set(catalog))
    if missing and not fail_silently:
        raise ItemNotExists('Unknown displaynames: %s' % ', '.join(missing))
    return catalog if return_dict else [catalog.get(i) for i in uuids]

 def _invalid_url(self, pool):
     global token, auth_url
     try:
         client = AstakosClient(token['id'], auth_url, use_pool=pool)
         client._call_astakos("/astakos/api/misspelled")
     except NotFound:
         pass
     except Exception, e:
         self.fail("Got \"%s\" instead of 404" % e)

 def test_get_resources(self):
     """Test function call of get_resources"""
     global resources, auth_url, token
     try:
         client = AstakosClient(token['id'], auth_url, retry=1)
         result = client.get_resources()
     except Exception as err:
         self.fail("Shouldn't raise Exception %s" % err)
     self.assertEqual(resources, result)

 def test_get_quotas(self):
     """Test function call of get_quotas"""
     global quotas, token, auth_url
     try:
         client = AstakosClient(token['id'], auth_url)
         result = client.get_quotas()
     except Exception as err:
         self.fail("Shouldn't raise Exception %s" % err)
     self.assertEqual(quotas, result)

 def test_get_pending_commissions(self):
     """Test function call of get_pending_commissions"""
     global token, pending_commissions, auth_url
     try:
         client = AstakosClient(token['id'], auth_url)
         response = client.get_pending_commissions()
     except Exception as err:
         self.fail("Shouldn't raise Exception %s" % err)
     self.assertEqual(response, pending_commissions)

 def test_resolve_commissions(self):
     """Test function call of resolve_commissions"""
     global token, auth_url
     try:
         client = AstakosClient(token['id'], auth_url)
         result = client.resolve_commissions([56, 57], [56, 58, 59])
     except Exception as err:
         self.fail("Shouldn't raise Exception %s" % err)
     self.assertEqual(result, resolve_commissions_rep)

 def test_username(self):
     """Test get_username"""
     global token, user, auth_url
     try:
         client = AstakosClient(token['id'], auth_url,
                                use_pool=False, retry=2)
         info = client.get_username(user['id'])
     except Exception, e:
         self.fail("Shouldn't raise an Exception: %s" % e)

 def test_get_uuid(self):
     """Test get_uuid"""
     global token, user, auth_url
     try:
         client = AstakosClient(token['id'], auth_url, retry=1)
         catalog = client.get_uuids([user['name']])
     except:
         self.fail("Shouldn't raise an Exception")
     self.assertEqual(catalog[user['name']], user['id'])

def user_for_token(token, astakos_auth_url, logger=None):
    if token is None:
        return None
    client = AstakosClient(token, astakos_auth_url,
                           retry=2, use_pool=True, logger=logger)
    try:
        return client.authenticate()
    except Unauthorized:
        return None

def retrieve_uuid(token, displayname):
    if is_uuid(displayname):
        return displayname

    astakos = AstakosClient(token, ASTAKOS_AUTH_URL, retry=2, use_pool=True, logger=logger)
    try:
        uuid = astakos.get_uuid(displayname)
    except NoUUID:
        raise ItemNotExists(displayname)
    return uuid

 def test_get_commission_info(self):
     """Test function call of get_commission_info"""
     global token, commission_description, auth_url
     try:
         client = AstakosClient(token['id'], auth_url,
                                use_pool=True, pool_size=2)
         response = client.get_commission_info(57)
     except Exception as err:
         self.fail("Shouldn't raise Exception %s" % err)
     self.assertEqual(response, commission_description)