diff --git a/astakosclient/astakosclient/__init__.py b/astakosclient/astakosclient/__init__.py index 8e5f32f72d07b72d804e025b38fe25ca2c074e5f..6e34793d23b5e3666ec0997980d215c0f43a9aba 100644 --- a/astakosclient/astakosclient/__init__.py +++ b/astakosclient/astakosclient/__init__.py @@ -31,6 +31,10 @@ # interpreted as representing official policies, either expressed # or implied, of GRNET S.A. +""" +Simple and minimal client for the Astakos authentication service +""" + import logging import urlparse import urllib @@ -39,45 +43,10 @@ from copy import copy import simplejson from astakosclient.utils import \ - retry, scheme_to_class, parse_request, check_input + retry_dec, scheme_to_class, parse_request, check_input, join_urls from astakosclient.errors import \ AstakosClientException, Unauthorized, BadRequest, NotFound, Forbidden, \ - NoUserName, NoUUID, BadValue, QuotaLimit, InvalidResponse -from .keypath import get_path -from .services import astakos_services - - -# Customize astakos_services here? - - -def join_urls(a, b): - """join_urls from synnefo.lib""" - return a.rstrip("/") + "/" + b.lstrip("/") - -# -------------------------------------------------------------------- -# Astakos API urls -UI_PREFIX = get_path(astakos_services, 'astakos_ui.prefix') -ACCOUNTS_PREFIX = get_path(astakos_services, 'astakos_account.prefix') -ACCOUNTS_PREFIX = join_urls(ACCOUNTS_PREFIX, 'v1.0') -API_AUTHENTICATE = join_urls(ACCOUNTS_PREFIX, "authenticate") -API_USERCATALOGS = join_urls(ACCOUNTS_PREFIX, "user_catalogs") -API_SERVICE_USERCATALOGS = join_urls(ACCOUNTS_PREFIX, "service/user_catalogs") -API_GETSERVICES = join_urls(UI_PREFIX, "get_services") -API_RESOURCES = join_urls(ACCOUNTS_PREFIX, "resources") -API_QUOTAS = join_urls(ACCOUNTS_PREFIX, "quotas") -API_SERVICE_QUOTAS = join_urls(ACCOUNTS_PREFIX, "service_quotas") -API_COMMISSIONS = join_urls(ACCOUNTS_PREFIX, "commissions") -API_COMMISSIONS_ACTION = join_urls(API_COMMISSIONS, "action") -API_FEEDBACK = join_urls(ACCOUNTS_PREFIX, "feedback") -API_PROJECTS = join_urls(ACCOUNTS_PREFIX, "projects") -API_APPLICATIONS = join_urls(API_PROJECTS, "apps") -API_MEMBERSHIPS = join_urls(API_PROJECTS, "memberships") - -# -------------------------------------------------------------------- -# Astakos Keystone API urls -IDENTITY_PREFIX = get_path(astakos_services, 'astakos_identity.prefix') -IDENTITY_PREFIX = join_urls(IDENTITY_PREFIX, "v2.0") -API_TOKENS = join_urls(IDENTITY_PREFIX, "tokens") + NoUserName, NoUUID, BadValue, QuotaLimit, InvalidResponse, NoEndpoints # -------------------------------------------------------------------- @@ -94,80 +63,149 @@ def get_token_from_cookie(request, cookie_name): try: cookie_content = urllib.unquote(request.COOKIE.get(cookie_name, None)) return cookie_content.split("|")[1] - except: + except BaseException: return None -class AstakosClient(): +# Too many instance attributes. pylint: disable-msg=R0902 +# Too many public methods. pylint: disable-msg=R0904 +class AstakosClient(object): """AstakosClient Class Implementation""" # ---------------------------------- - def __init__(self, astakos_url, retry=0, - use_pool=False, pool_size=8, logger=None): + # Initialize AstakosClient Class + # Too many arguments. pylint: disable-msg=R0913 + # Too many local variables. pylint: disable-msg=R0914 + # Too many statements. pylint: disable-msg=R0915 + def __init__(self, token, auth_url, + retry=0, use_pool=False, pool_size=8, logger=None): """Initialize AstakosClient Class Keyword arguments: - astakos_url -- i.e https://accounts.example.com (string) - use_pool -- use objpool for http requests (boolean) + token -- user's/service's token (string) + auth_url -- i.e https://accounts.example.com/identity/v2.0 retry -- how many time to retry (integer) + use_pool -- use objpool for http requests (boolean) + pool_size -- if using pool, define the pool size logger -- pass a different logger """ + + # Get logger if logger is None: logging.basicConfig( format='%(asctime)s [%(levelname)s] %(name)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO) logger = logging.getLogger("astakosclient") - logger.debug("Intialize AstakosClient: astakos_url = %s, " - "use_pool = %s" % (astakos_url, use_pool)) + logger.debug("Intialize AstakosClient: auth_url = %s, " + "use_pool = %s, pool_size = %s", + auth_url, use_pool, pool_size) - check_input("__init__", logger, astakos_url=astakos_url) + # Check that token and auth_url (mandatory options) are given + check_input("__init__", logger, token=token, auth_url=auth_url) - # Check for supported scheme - p = urlparse.urlparse(astakos_url) - conn_class = scheme_to_class(p.scheme, use_pool, pool_size) + # Initialize connection class + parsed_auth_url = urlparse.urlparse(auth_url) + conn_class = \ + scheme_to_class(parsed_auth_url.scheme, use_pool, pool_size) if conn_class is None: - m = "Unsupported scheme: %s" % p.scheme - logger.error(m) - raise BadValue(m) + msg = "Unsupported scheme: %s" % parsed_auth_url.scheme + logger.error(msg) + raise BadValue(msg) - # Save astakos_url etc. in our class + # Save astakos base url, logger, connection class etc in our class self.retry = retry self.logger = logger - self.netloc = p.netloc - self.scheme = p.scheme - self.path = p.path.rstrip('/') + self.token = token + self.astakos_base_url = parsed_auth_url.netloc + self.scheme = parsed_auth_url.scheme self.conn_class = conn_class + # Initialize astakos api prefixes + # API urls under auth_url + self.auth_prefix = parsed_auth_url.path + self.api_tokens = join_urls(self.auth_prefix, "tokens") + + # ------------------------------ + # API urls under account_url + # Get account_url from get_endpoints + # get_endpoints needs self.api_tokens + endpoints = self.get_endpoints(non_authentication=True) + account_service_catalog = parse_endpoints( + endpoints, ep_name="astakos_account", ep_version_id="v1.0") + self.account_url = \ + account_service_catalog[0]['endpoints'][0]['publicURL'] + parsed_account_url = urlparse.urlparse(self.account_url) + + self.account_prefix = parsed_account_url.path + self.logger.debug("Got account_prefix \"%s\"" % self.account_prefix) + + self.api_authenticate = join_urls( + self.account_prefix, "authenticate") + self.api_usercatalogs = join_urls( + self.account_prefix, "user_catalogs") + self.api_service_usercatalogs = join_urls( + self.account_prefix, "service/user_catalogs") + self.api_resources = join_urls( + self.account_prefix, "resources") + self.api_quotas = join_urls( + self.account_prefix, "quotas") + self.api_service_quotas = join_urls( + self.account_prefix, "service_quotas") + self.api_commissions = join_urls( + self.account_prefix, "commissions") + self.api_commissions_action = join_urls( + self.api_commissions, "action") + self.api_feedback = join_urls( + self.account_prefix, "feedback") + self.api_projects = join_urls( + self.account_prefix, "projects") + self.api_applications = join_urls( + self.api_projects, "apps") + self.api_memberships = join_urls( + self.api_projects, "memberships") + + # ------------------------------ + # API urls under ui_url + # Get ui url from get_endpoints + # get_endpoints needs self.api_tokens + ui_service_catalog = parse_endpoints( + endpoints, ep_name="astakos_account", ep_version_id="v1.0") + parsed_ui_url = urlparse.urlparse( + ui_service_catalog[0]['endpoints'][0]['SNF:uiURL']) + self.ui_url = \ + ui_service_catalog[0]['endpoints'][0]['SNF:uiURL'] + parsed_ui_url = urlparse.urlparse(self.ui_url) + + self.ui_prefix = parsed_ui_url.path + self.logger.debug("Got ui_prefix \"%s\"" % self.ui_prefix) + + self.api_getservices = join_urls(self.ui_prefix, "get_services") + # ---------------------------------- - @retry - def _call_astakos(self, token, request_path, headers=None, + @retry_dec + def _call_astakos(self, 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() - hashed_token.update(token) - using_token = "using token %s" % (hashed_token.hexdigest()) - else: - using_token = "without using token" + hashed_token = hashlib.sha1() + hashed_token.update(self.token) self.logger.debug( - "Make a %s request to %s %s with headers %s and body %s" - % (method, request_path, using_token, headers, - body if log_body else "(not logged)")) + "Make a %s request to %s, using token with hash %s, " + "with headers %s and body %s", + method, request_path, hashed_token.hexdigest(), headers, + body if log_body else "(not logged)") # Check Input if headers is None: headers = {} if body is None: body = {} - path = self.path + "/" + request_path.strip('/') # Build request's header and body kwargs = {} kwargs['headers'] = copy(headers) - if token is not None: - kwargs['headers']['X-Auth-Token'] = token + kwargs['headers']['X-Auth-Token'] = self.token if body: kwargs['body'] = copy(body) kwargs['headers'].setdefault( @@ -177,10 +215,11 @@ class AstakosClient(): try: # Get the connection object - with self.conn_class(self.netloc) as conn: + with self.conn_class(self.astakos_base_url) as conn: # Send request + # Used * or ** magic. pylint: disable-msg=W0142 (message, data, status) = \ - _do_request(conn, method, path, **kwargs) + _do_request(conn, method, request_path, **kwargs) except Exception as err: self.logger.error("Failed to send request: %s" % repr(err)) raise AstakosClientException(str(err)) @@ -210,11 +249,10 @@ class AstakosClient(): # ------------------------ # do a GET to ``API_AUTHENTICATE`` - def get_user_info(self, token, usage=False): + def get_user_info(self, usage=False): """Authenticate user and get user's info as a dictionary Keyword arguments: - token -- user's token (string) usage -- return usage information for user (boolean) In case of success return user information (json parsed format). @@ -222,59 +260,57 @@ class AstakosClient(): """ # Send request - auth_path = copy(API_AUTHENTICATE) + auth_path = self.api_authenticate if usage: auth_path += "?usage=1" - return self._call_astakos(token, auth_path) + return self._call_astakos(auth_path) # ---------------------------------- # do a POST to ``API_USERCATALOGS`` (or ``API_SERVICE_USERCATALOGS``) # with {'uuids': uuids} - def _uuid_catalog(self, token, uuids, req_path): + def _uuid_catalog(self, uuids, req_path): + """Helper function to retrieve uuid catalog""" req_headers = {'content-type': 'application/json'} req_body = parse_request({'uuids': uuids}, self.logger) - data = self._call_astakos( - token, req_path, req_headers, req_body, "POST") + data = self._call_astakos(req_path, headers=req_headers, + body=req_body, method="POST") if "uuid_catalog" in data: return data.get("uuid_catalog") else: - m = "_uuid_catalog request returned %s. No uuid_catalog found" \ - % data - self.logger.error(m) - raise AstakosClientException(m) + msg = "_uuid_catalog request returned %s. No uuid_catalog found" \ + % data + self.logger.error(msg) + raise AstakosClientException(msg) - def get_usernames(self, token, uuids): + def get_usernames(self, uuids): """Return a uuid_catalog dictionary for the given uuids Keyword arguments: - token -- user's token (string) uuids -- list of user ids (list of strings) The returned uuid_catalog is a dictionary with uuids as keys and the corresponding user names as values """ - req_path = copy(API_USERCATALOGS) - return self._uuid_catalog(token, uuids, req_path) + return self._uuid_catalog(uuids, self.api_usercatalogs) - def get_username(self, token, uuid): + def get_username(self, uuid): """Return the user name of a uuid (see get_usernames)""" check_input("get_username", self.logger, uuid=uuid) - uuid_dict = self.get_usernames(token, [uuid]) + uuid_dict = self.get_usernames([uuid]) if uuid in uuid_dict: return uuid_dict.get(uuid) else: raise NoUserName(uuid) - def service_get_usernames(self, token, uuids): + def service_get_usernames(self, uuids): """Return a uuid_catalog dict using a service's token""" - req_path = copy(API_SERVICE_USERCATALOGS) - return self._uuid_catalog(token, uuids, req_path) + return self._uuid_catalog(uuids, self.api_service_usercatalogs) - def service_get_username(self, token, uuid): + def service_get_username(self, uuid): """Return the displayName of a uuid using a service's token""" check_input("service_get_username", self.logger, uuid=uuid) - uuid_dict = self.service_get_usernames(token, [uuid]) + uuid_dict = self.service_get_usernames([uuid]) if uuid in uuid_dict: return uuid_dict.get(uuid) else: @@ -283,51 +319,51 @@ class AstakosClient(): # ---------------------------------- # do a POST to ``API_USERCATALOGS`` (or ``API_SERVICE_USERCATALOGS``) # with {'displaynames': display_names} - def _displayname_catalog(self, token, display_names, req_path): + def _displayname_catalog(self, display_names, req_path): + """Helper function to retrieve display names catalog""" req_headers = {'content-type': 'application/json'} req_body = parse_request({'displaynames': display_names}, self.logger) - data = self._call_astakos( - token, req_path, req_headers, req_body, "POST") + data = self._call_astakos(req_path, headers=req_headers, + body=req_body, method="POST") if "displayname_catalog" in data: return data.get("displayname_catalog") else: - m = "_displayname_catalog request returned %s. " \ - "No displayname_catalog found" % data - self.logger.error(m) - raise AstakosClientException(m) + msg = "_displayname_catalog request returned %s. " \ + "No displayname_catalog found" % data + self.logger.error(msg) + raise AstakosClientException(msg) - def get_uuids(self, token, display_names): + def get_uuids(self, display_names): """Return a displayname_catalog for the given names Keyword arguments: - token -- user's token (string) display_names -- list of user names (list of strings) The returned displayname_catalog is a dictionary with the names as keys and the corresponding uuids as values """ - req_path = copy(API_USERCATALOGS) - return self._displayname_catalog(token, display_names, req_path) + return self._displayname_catalog( + display_names, self.api_usercatalogs) - def get_uuid(self, token, display_name): + def get_uuid(self, display_name): """Return the uuid of a name (see getUUIDs)""" check_input("get_uuid", self.logger, display_name=display_name) - name_dict = self.get_uuids(token, [display_name]) + name_dict = self.get_uuids([display_name]) if display_name in name_dict: return name_dict.get(display_name) else: raise NoUUID(display_name) - def service_get_uuids(self, token, display_names): + def service_get_uuids(self, display_names): """Return a display_name catalog using a service's token""" - req_path = copy(API_SERVICE_USERCATALOGS) - return self._displayname_catalog(token, display_names, req_path) + return self._displayname_catalog( + display_names, self.api_service_usercatalogs) - def service_get_uuid(self, token, display_name): + def service_get_uuid(self, display_name): """Return the uuid of a name using a service's token""" check_input("service_get_uuid", self.logger, display_name=display_name) - name_dict = self.service_get_uuids(token, [display_name]) + name_dict = self.service_get_uuids([display_name]) if display_name in name_dict: return name_dict.get(display_name) else: @@ -337,21 +373,20 @@ class AstakosClient(): # do a GET to ``API_GETSERVICES`` def get_services(self): """Return a list of dicts with the registered services""" - return self._call_astakos(None, copy(API_GETSERVICES)) + return self._call_astakos(self.api_getservices) # ---------------------------------- # do a GET to ``API_RESOURCES`` def get_resources(self): """Return a dict of dicts with the available resources""" - return self._call_astakos(None, copy(API_RESOURCES)) + return self._call_astakos(self.api_resources) # ---------------------------------- # do a POST to ``API_FEEDBACK`` - def send_feedback(self, token, message, data): + def send_feedback(self, message, data): """Send feedback to astakos service keyword arguments: - token -- user's token (string) message -- Feedback message data -- Additional information about service client status @@ -360,55 +395,63 @@ class AstakosClient(): """ check_input("send_feedback", self.logger, message=message, data=data) - path = copy(API_FEEDBACK) req_body = urllib.urlencode( {'feedback_msg': message, 'feedback_data': data}) - self._call_astakos(token, path, None, req_body, "POST") + self._call_astakos(self.api_feedback, headers=None, + body=req_body, method="POST") # ---------------------------------- # do a POST to ``API_TOKENS`` - def get_endpoints(self, token, uuid=None): - """ Fallback call for authenticate + def get_endpoints(self, tenant_name=None, non_authentication=False): + """ Authenticate and get services' endpoints Keyword arguments: - token -- user's token (string) - uuid -- user's uniq id + tenant_name -- user's uniq id (optional) + non_authentication -- get only non authentication protected info + It returns back the token as well as information about the token holder and the services he/she can acess (in json format). + + The tenant_name is optional and if it is given it must match the + user's uuid. + + In case on of the `name', `type', `region', `version_id' parameters + is given, return only the endpoints that match all of these criteria. + If no match is found then raise NoEndpoints exception. + 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) + if non_authentication: + req_body = None + else: + body = {'auth': {'token': {'id': self.token}}} + if tenant_name is not None: + body['auth']['tenantName'] = tenant_name + req_body = parse_request(body, self.logger) + return self._call_astakos(self.api_tokens, headers=req_headers, + body=req_body, method="POST", + log_body=False) # ---------------------------------- # do a GET to ``API_QUOTAS`` - def get_quotas(self, token): + def get_quotas(self): """Get user's quotas - Keyword arguments: - token -- user's token (string) - In case of success return a dict of dicts with user's current quotas. Otherwise raise an AstakosClientException """ - return self._call_astakos(token, copy(API_QUOTAS)) + return self._call_astakos(self.api_quotas) # ---------------------------------- # do a GET to ``API_SERVICE_QUOTAS`` - def service_get_quotas(self, token, user=None): + def service_get_quotas(self, user=None): """Get all quotas for resources associated with the service Keyword arguments: - token -- service's token (string) user -- optionally, the uuid of a specific user In case of success return a dict of dicts of dicts with current quotas @@ -416,18 +459,17 @@ class AstakosClient(): Otherwise raise an AstakosClientException """ - query = copy(API_SERVICE_QUOTAS) + query = self.api_service_quotas if user is not None: query += "?user=" + user - return self._call_astakos(token, query) + return self._call_astakos(query) # ---------------------------------- # do a POST to ``API_COMMISSIONS`` - def issue_commission(self, token, request): + def issue_commission(self, request): """Issue a commission Keyword arguments: - token -- service's token (string) request -- commision request (dict) In case of success return commission's id (int). @@ -437,8 +479,10 @@ class AstakosClient(): req_headers = {'content-type': 'application/json'} req_body = parse_request(request, self.logger) try: - response = self._call_astakos(token, copy(API_COMMISSIONS), - req_headers, req_body, "POST") + response = self._call_astakos(self.api_commissions, + headers=req_headers, + body=req_body, + method="POST") except AstakosClientException as err: if err.status == 413: raise QuotaLimit(err.message, err.details) @@ -448,17 +492,16 @@ class AstakosClient(): if "serial" in response: return response['serial'] else: - m = "issue_commission_core request returned %s. No serial found" \ - % response - self.logger.error(m) - raise AstakosClientException(m) + msg = "issue_commission_core request returned %s. " + \ + "No serial found" % response + self.logger.error(msg) + raise AstakosClientException(msg) - def issue_one_commission(self, token, holder, source, provisions, + def issue_one_commission(self, holder, source, provisions, name="", force=False, auto_accept=False): """Issue one commission (with specific holder and source) keyword arguments: - token -- service's token (string) holder -- user's id (string) source -- commission's source (ex system) (string) provisions -- resources with their quantity (dict from string to int) @@ -482,36 +525,32 @@ class AstakosClient(): try: request["provisions"] = [] for resource, quantity in provisions.iteritems(): - t = {"holder": holder, "source": source, - "resource": resource, "quantity": quantity} - request["provisions"].append(t) + prov = {"holder": holder, "source": source, + "resource": resource, "quantity": quantity} + request["provisions"].append(prov) except Exception as err: self.logger.error(str(err)) raise BadValue(str(err)) - return self.issue_commission(token, request) + return self.issue_commission(request) # ---------------------------------- # do a GET to ``API_COMMISSIONS`` - def get_pending_commissions(self, token): + def get_pending_commissions(self): """Get Pending Commissions - Keyword arguments: - token -- service's token (string) - In case of success return a list of pending commissions' ids (list of integers) """ - return self._call_astakos(token, copy(API_COMMISSIONS)) + return self._call_astakos(self.api_commissions) # ---------------------------------- # do a GET to ``API_COMMISSIONS``/ - def get_commission_info(self, token, serial): + def get_commission_info(self, serial): """Get Description of a Commission Keyword arguments: - token -- service's token (string) serial -- commission's id (int) In case of success return a dict of dicts containing @@ -520,16 +559,15 @@ class AstakosClient(): """ check_input("get_commission_info", self.logger, serial=serial) - path = API_COMMISSIONS + "/" + str(serial) - return self._call_astakos(token, path) + path = self.api_commissions.rstrip('/') + "/" + str(serial) + return self._call_astakos(path) # ---------------------------------- # do a POST to ``API_COMMISSIONS``//action" - def commission_action(self, token, serial, action): + def commission_action(self, serial, action): """Perform a commission action Keyword arguments: - token -- service's token (string) serial -- commission's id (int) action -- action to perform, currently accept/reject (string) @@ -539,26 +577,26 @@ class AstakosClient(): check_input("commission_action", self.logger, serial=serial, action=action) - path = API_COMMISSIONS + "/" + str(serial) + "/action" + path = self.api_commissions.rstrip('/') + "/" + str(serial) + "/action" req_headers = {'content-type': 'application/json'} req_body = parse_request({str(action): ""}, self.logger) - self._call_astakos(token, path, req_headers, req_body, "POST") + self._call_astakos(path, headers=req_headers, + body=req_body, method="POST") - def accept_commission(self, token, serial): + def accept_commission(self, serial): """Accept a commission (see commission_action)""" - self.commission_action(token, serial, "accept") + self.commission_action(serial, "accept") - def reject_commission(self, token, serial): + def reject_commission(self, serial): """Reject a commission (see commission_action)""" - self.commission_action(token, serial, "reject") + self.commission_action(serial, "reject") # ---------------------------------- # do a POST to ``API_COMMISSIONS_ACTION`` - def resolve_commissions(self, token, accept_serials, reject_serials): + def resolve_commissions(self, accept_serials, reject_serials): """Resolve multiple commissions at once Keyword arguments: - token -- service's token (string) accept_serials -- commissions to accept (list of ints) reject_serials -- commissions to reject (list of ints) @@ -571,27 +609,26 @@ class AstakosClient(): accept_serials=accept_serials, reject_serials=reject_serials) - path = copy(API_COMMISSIONS_ACTION) req_headers = {'content-type': 'application/json'} req_body = parse_request({"accept": accept_serials, "reject": reject_serials}, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(self.api_commissions_action, + headers=req_headers, body=req_body, + method="POST") # ---------------------------- # do a GET to ``API_PROJECTS`` - def get_projects(self, token, name=None, state=None, owner=None): + def get_projects(self, name=None, state=None, owner=None): """Retrieve all accessible projects Arguments: - token -- user's token (string) name -- filter by name (optional) state -- filter by state (optional) owner -- filter by owner (optional) In case of success, return a list of project descriptions. """ - path = API_PROJECTS filters = {} if name is not None: filters["name"] = name @@ -602,62 +639,61 @@ class AstakosClient(): req_headers = {'content-type': 'application/json'} req_body = (parse_request({"filter": filters}, self.logger) if filters else None) - return self._call_astakos(token, path, req_headers, req_body) + return self._call_astakos(self.api_projects, + headers=req_headers, body=req_body) # ----------------------------------------- # do a GET to ``API_PROJECTS``/ - def get_project(self, token, project_id): + def get_project(self, project_id): """Retrieve project description, if accessible Arguments: - token -- user's token (string) project_id -- project identifier In case of success, return project description. """ - path = join_urls(API_PROJECTS, str(project_id)) - return self._call_astakos(token, path) + path = join_urls(self.api_projects, str(project_id)) + return self._call_astakos(path) # ----------------------------- # do a POST to ``API_PROJECTS`` - def create_project(self, token, specs): + def create_project(self, specs): """Submit application to create a new project Arguments: - token -- user's token (string) specs -- dict describing a project In case of success, return project and application identifiers. """ - path = API_PROJECTS req_headers = {'content-type': 'application/json'} req_body = parse_request(specs, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(self.api_projects, + headers=req_headers, body=req_body, + method="POST") # ------------------------------------------ # do a POST to ``API_PROJECTS``/ - def modify_project(self, token, project_id, specs): + def modify_project(self, project_id, specs): """Submit application to modify an existing project Arguments: - token -- user's token (string) project_id -- project identifier specs -- dict describing a project In case of success, return project and application identifiers. """ - path = join_urls(API_PROJECTS, str(project_id)) + path = join_urls(self.api_projects, str(project_id)) req_headers = {'content-type': 'application/json'} req_body = parse_request(specs, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(path, headers=req_headers, + body=req_body, method="POST") # ------------------------------------------------- # do a POST to ``API_PROJECTS``//action - def project_action(self, token, project_id, action, reason=""): + def project_action(self, project_id, action, reason=""): """Perform action on a project Arguments: - token -- user's token (string) project_id -- project identifier action -- action to perform, one of "suspend", "unsuspend", "terminate", "reinstate" @@ -665,50 +701,48 @@ class AstakosClient(): In case of success, return nothing. """ - path = join_urls(API_PROJECTS, str(project_id)) + path = join_urls(self.api_projects, str(project_id)) path = join_urls(path, "action") req_headers = {'content-type': 'application/json'} req_body = parse_request({action: reason}, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(path, headers=req_headers, + body=req_body, method="POST") # -------------------------------- # do a GET to ``API_APPLICATIONS`` - def get_applications(self, token, project=None): + def get_applications(self, project=None): """Retrieve all accessible applications Arguments: - token -- user's token (string) project -- filter by project (optional) In case of success, return a list of application descriptions. """ - path = API_APPLICATIONS req_headers = {'content-type': 'application/json'} body = {"project": project} if project is not None else None req_body = parse_request(body, self.logger) if body else None - return self._call_astakos(token, path, req_headers, req_body) + return self._call_astakos(self.api_applications, + headers=req_headers, body=req_body) # ----------------------------------------- # do a GET to ``API_APPLICATIONS``/ - def get_application(self, token, app_id): + def get_application(self, app_id): """Retrieve application description, if accessible Arguments: - token -- user's token (string) app_id -- application identifier In case of success, return application description. """ - path = join_urls(API_APPLICATIONS, str(app_id)) - return self._call_astakos(token, path) + path = join_urls(self.api_applications, str(app_id)) + return self._call_astakos(path) # ------------------------------------------------- # do a POST to ``API_APPLICATIONS``//action - def application_action(self, token, app_id, action, reason=""): + def application_action(self, app_id, action, reason=""): """Perform action on an application Arguments: - token -- user's token (string) app_id -- application identifier action -- action to perform, one of "approve", "deny", "dismiss", "cancel" @@ -716,50 +750,48 @@ class AstakosClient(): In case of success, return nothing. """ - path = join_urls(API_APPLICATIONS, str(app_id)) + path = join_urls(self.api_applications, str(app_id)) path = join_urls(path, "action") req_headers = {'content-type': 'application/json'} req_body = parse_request({action: reason}, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(path, headers=req_headers, + body=req_body, method="POST") # ------------------------------- # do a GET to ``API_MEMBERSHIPS`` - def get_memberships(self, token, project=None): + def get_memberships(self, project=None): """Retrieve all accessible memberships Arguments: - token -- user's token (string) project -- filter by project (optional) In case of success, return a list of membership descriptions. """ - path = API_MEMBERSHIPS req_headers = {'content-type': 'application/json'} body = {"project": project} if project is not None else None req_body = parse_request(body, self.logger) if body else None - return self._call_astakos(token, path, req_headers, req_body) + return self._call_astakos(self.api_memberships, + headers=req_headers, body=req_body) # ----------------------------------------- # do a GET to ``API_MEMBERSHIPS``/ - def get_membership(self, token, memb_id): + def get_membership(self, memb_id): """Retrieve membership description, if accessible Arguments: - token -- user's token (string) memb_id -- membership identifier In case of success, return membership description. """ - path = join_urls(API_MEMBERSHIPS, str(memb_id)) - return self._call_astakos(token, path) + path = join_urls(self.api_memberships, str(memb_id)) + return self._call_astakos(path) # ------------------------------------------------- # do a POST to ``API_MEMBERSHIPS``//action - def membership_action(self, token, memb_id, action, reason=""): + def membership_action(self, memb_id, action, reason=""): """Perform action on a membership Arguments: - token -- user's token (string) memb_id -- membership identifier action -- action to perform, one of "leave", "cancel", "accept", "reject", "remove" @@ -767,46 +799,96 @@ class AstakosClient(): In case of success, return nothing. """ - path = join_urls(API_MEMBERSHIPS, str(memb_id)) + path = join_urls(self.api_memberships, str(memb_id)) path = join_urls(path, "action") req_headers = {'content-type': 'application/json'} req_body = parse_request({action: reason}, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(path, headers=req_headers, + body=req_body, method="POST") # -------------------------------- # do a POST to ``API_MEMBERSHIPS`` - def join_project(self, token, project_id): + def join_project(self, project_id): """Join a project Arguments: - token -- user's token (string) project_id -- project identifier In case of success, return membership identifier. """ - path = API_MEMBERSHIPS req_headers = {'content-type': 'application/json'} body = {"join": {"project": project_id}} req_body = parse_request(body, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(self.api_memberships, headers=req_headers, + body=req_body, method="POST") # -------------------------------- # do a POST to ``API_MEMBERSHIPS`` - def enroll_member(self, token, project_id, email): + def enroll_member(self, project_id, email): """Enroll a user in a project Arguments: - token -- user's token (string) project_id -- project identifier email -- user identified by email In case of success, return membership identifier. """ - path = API_MEMBERSHIPS req_headers = {'content-type': 'application/json'} body = {"enroll": {"project": project_id, "user": email}} req_body = parse_request(body, self.logger) - return self._call_astakos(token, path, req_headers, req_body, "POST") + return self._call_astakos(self.api_memberships, headers=req_headers, + body=req_body, method="POST") + + +# -------------------------------------------------------------------- +# parse endpoints +def parse_endpoints(endpoints, ep_name=None, ep_type=None, + ep_region=None, ep_version_id=None): + """Parse endpoints server response and extract the ones needed + + Keyword arguments: + endpoints -- the endpoints (json response from get_endpoints) + ep_name -- return only endpoints with this name (optional) + ep_type -- return only endpoints with this type (optional) + ep_region -- return only endpoints with this region (optional) + ep_version_id -- return only endpoints with this versionId (optional) + + In case on of the `name', `type', `region', `version_id' parameters + is given, return only the endpoints that match all of these criteria. + If no match is found then raise NoEndpoints exception. + + """ + try: + catalog = endpoints['access']['serviceCatalog'] + if ep_name is not None: + catalog = \ + [c for c in catalog if c['name'] == ep_name] + if ep_type is not None: + catalog = \ + [c for c in catalog if c['type'] == ep_type] + if ep_region is not None: + for c in catalog: + c['endpoints'] = [e for e in c['endpoints'] + if e['region'] == ep_region] + # Remove catalog entries with no endpoints + catalog = \ + [c for c in catalog if c['endpoints']] + if ep_version_id is not None: + for c in catalog: + c['endpoints'] = [e for e in c['endpoints'] + if e['versionId'] == ep_version_id] + # Remove catalog entries with no endpoints + catalog = \ + [c for c in catalog if c['endpoints']] + + if not catalog: + raise NoEndpoints(ep_name, ep_type, + ep_region, ep_version_id) + else: + return catalog + except KeyError: + raise NoEndpoints() + # -------------------------------------------------------------------- # Private functions diff --git a/astakosclient/astakosclient/errors.py b/astakosclient/astakosclient/errors.py index a5f66beff3fdbfd4cf99fdf951ad22f84229720c..a85d38da02da784637ea4316565f10a1e45fe83f 100644 --- a/astakosclient/astakosclient/errors.py +++ b/astakosclient/astakosclient/errors.py @@ -31,8 +31,13 @@ # interpreted as representing official policies, either expressed # or implied, of GRNET S.A. +""" +Astakos Client Exceptions +""" + class AstakosClientException(Exception): + """Base AstakosClientException Class""" def __init__(self, message='', details='', status=500): self.message = message self.details = details @@ -43,47 +48,65 @@ class AstakosClientException(Exception): class BadValue(AstakosClientException): + """Re-define ValueError Exception under AstakosClientException""" def __init__(self, details): - """Re-define ValueError Exception under AstakosClientException""" message = "ValueError" super(BadValue, self).__init__(message, details) class InvalidResponse(AstakosClientException): + """Return simplejson parse Exception as AstakosClient one""" def __init__(self, message, details): - """Return simplejson parse Exception as AstakosClient one""" super(InvalidResponse, self).__init__(message, details) class BadRequest(AstakosClientException): + """BadRequest Exception""" status = 400 class Unauthorized(AstakosClientException): + """Unauthorized Exception""" status = 401 class Forbidden(AstakosClientException): + """Forbidden Exception""" status = 403 class NotFound(AstakosClientException): + """NotFound Exception""" status = 404 class QuotaLimit(AstakosClientException): + """QuotaLimit Exception""" status = 413 class NoUserName(AstakosClientException): + """No display name for the given uuid""" def __init__(self, uuid): - """No display name for the given uuid""" message = "No display name for the given uuid: %s" % uuid super(NoUserName, self).__init__(message) class NoUUID(AstakosClientException): + """No uuid for the given display name""" def __init__(self, display_name): - """No uuid for the given display name""" message = "No uuid for the given display name: %s" % display_name super(NoUUID, self).__init__(message) + + +class NoEndpoints(AstakosClientException): + """No endpoints found matching the criteria given""" + def __init__(self, ep_name, ep_type, ep_region, ep_version_id): + message = "No endpoints found matching" + \ + (", name = %s" % ep_name) if ep_name is not None else "" + \ + (", type = %s" % ep_type) if ep_type is not None else "" + \ + (", region = %s" % ep_region) \ + if ep_region is not None else "" + \ + (", version_id = %s" % ep_version_id) \ + if ep_version_id is not None else "." + super(NoEndpoints, self).__init__(message) diff --git a/astakosclient/astakosclient/keypath.py b/astakosclient/astakosclient/keypath.py deleted file mode 100644 index 883a40c8d3f7785444c12dff74f7f14fbc3619f3..0000000000000000000000000000000000000000 --- a/astakosclient/astakosclient/keypath.py +++ /dev/null @@ -1,216 +0,0 @@ -# Copyright 2012, 2013 GRNET S.A. All rights reserved. -# -# Redistribution and use in source and binary forms, with or -# without modification, are permitted provided that the following -# conditions are met: -# -# 1. Redistributions of source code must retain the above -# copyright notice, this list of conditions and the following -# disclaimer. -# -# 2. Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following -# disclaimer in the documentation and/or other materials -# provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS -# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR -# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED -# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN -# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# -# The views and conclusions contained in the software and -# documentation are those of the authors and should not be -# interpreted as representing official policies, either expressed -# or implied, of GRNET S.A. -import copy - - -def dict_merge(a, b): - """ - http://www.xormedia.com/recursively-merge-dictionaries-in-python/ - """ - if not isinstance(b, dict): - return b - result = copy.deepcopy(a) - for k, v in b.iteritems(): - if k in result and isinstance(result[k], dict): - result[k] = dict_merge(result[k], v) - else: - result[k] = copy.deepcopy(v) - return result - - -def lookup_path(container, path, sep='.', createpath=False): - """ - return (['a','b'], - [container['a'], container['a']['b']], - 'c') where path=sep.join(['a','b','c']) - - """ - names = path.split(sep) - dirnames = names[:-1] - basename = names[-1] - - node = container - name_path = [] - node_path = [node] - for name in dirnames: - name_path.append(name) - if name not in node: - if not createpath: - m = "'{0}': path not found".format(sep.join(name_path)) - raise KeyError(m) - node[name] = {} - try: - node = node[name] - except TypeError as e: - m = "'{0}': cannot traverse path beyond this node: {1}" - m = m.format(sep.join(name_path), str(e)) - raise ValueError(m) - node_path.append(node) - - return name_path, node_path, basename - - -def walk_paths(container): - for name, node in container.iteritems(): - if not hasattr(node, 'items'): - yield [name], [node] - else: - for names, nodes in walk_paths(node): - yield [name] + names, [node] + nodes - - -def list_paths(container, sep='.'): - """ - >>> sorted(list_paths({'a': {'b': {'c': 'd'}}})) - [('a.b.c', 'd')] - >>> sorted(list_paths({'a': {'b': {'c': 'd'}, 'e': 3}})) - [('a.b.c', 'd'), ('a.e', 3)] - >>> sorted(list_paths({'a': {'b': {'c': 'd'}, 'e': {'f': 3}}})) - [('a.b.c', 'd'), ('a.e.f', 3)] - >>> list_paths({}) - [] - - """ - return [(sep.join(name_path), node_path[-1]) - for name_path, node_path in walk_paths(container)] - - -def del_path(container, path, sep='.', collect=True): - """ - del container['a']['b']['c'] where path=sep.join(['a','b','c']) - - >>> d = {'a': {'b': {'c': 'd'}}}; del_path(d, 'a.b.c'); d - {} - >>> d = {'a': {'b': {'c': 'd'}}}; del_path(d, 'a.b.c', collect=False); d - {'a': {'b': {}}} - >>> d = {'a': {'b': {'c': 'd'}}}; del_path(d, 'a.b.c.d') - Traceback (most recent call last): - ValueError: 'a.b.c': cannot traverse path beyond this node:\ - 'str' object does not support item deletion - """ - - name_path, node_path, basename = \ - lookup_path(container, path, sep=sep, createpath=False) - - lastnode = node_path.pop() - try: - if basename in lastnode: - del lastnode[basename] - except (TypeError, KeyError) as e: - m = "'{0}': cannot traverse path beyond this node: {1}" - m = m.format(sep.join(name_path), str(e)) - raise ValueError(m) - - if collect: - while node_path and not lastnode: - basename = name_path.pop() - lastnode = node_path.pop() - del lastnode[basename] - - -def get_path(container, path, sep='.'): - """ - return container['a']['b']['c'] where path=sep.join(['a','b','c']) - - >>> get_path({'a': {'b': {'c': 'd'}}}, 'a.b.c.d') - Traceback (most recent call last): - ValueError: 'a.b.c.d': cannot traverse path beyond this node:\ - string indices must be integers, not str - >>> get_path({'a': {'b': {'c': 1}}}, 'a.b.c.d') - Traceback (most recent call last): - ValueError: 'a.b.c.d': cannot traverse path beyond this node:\ - 'int' object is unsubscriptable - >>> get_path({'a': {'b': {'c': 1}}}, 'a.b.c') - 1 - >>> get_path({'a': {'b': {'c': 1}}}, 'a.b') - {'c': 1} - - """ - name_path, node_path, basename = \ - lookup_path(container, path, sep=sep, createpath=False) - name_path.append(basename) - node = node_path[-1] - - try: - return node[basename] - except TypeError as e: - m = "'{0}': cannot traverse path beyond this node: {1}" - m = m.format(sep.join(name_path), str(e)) - raise ValueError(m) - except KeyError as e: - m = "'{0}': path not found: {1}" - m = m.format(sep.join(name_path), str(e)) - raise KeyError(m) - - -def set_path(container, path, value, sep='.', - createpath=False, overwrite=True): - """ - container['a']['b']['c'] = value where path=sep.join(['a','b','c']) - - >>> set_path({'a': {'b': {'c': 'd'}}}, 'a.b.c.d', 1) - Traceback (most recent call last): - ValueError: 'a.b.c.d': cannot traverse path beyond this node:\ - 'str' object does not support item assignment - >>> set_path({'a': {'b': {'c': 'd'}}}, 'a.b.x.d', 1) - Traceback (most recent call last): - KeyError: "'a.b.x': path not found" - >>> set_path({'a': {'b': {'c': 'd'}}}, 'a.b.x.d', 1, createpath=True) - - >>> set_path({'a': {'b': {'c': 'd'}}}, 'a.b.c', 1) - - >>> set_path({'a': {'b': {'c': 'd'}}}, 'a.b.c', 1, overwrite=False) - Traceback (most recent call last): - ValueError: will not overwrite path 'a.b.c' - - """ - name_path, node_path, basename = \ - lookup_path(container, path, sep=sep, createpath=createpath) - name_path.append(basename) - node = node_path[-1] - - if basename in node and not overwrite: - m = "will not overwrite path '{0}'".format(path) - raise ValueError(m) - - try: - node[basename] = value - except TypeError as e: - m = "'{0}': cannot traverse path beyond this node: {1}" - m = m.format(sep.join(name_path), str(e)) - raise ValueError(m) - - -if __name__ == '__main__': - import doctest - doctest.testmod() diff --git a/astakosclient/astakosclient/services.py b/astakosclient/astakosclient/services.py deleted file mode 100644 index 98fa6b144ba23e554ad269ab1c9af965f429f02b..0000000000000000000000000000000000000000 --- a/astakosclient/astakosclient/services.py +++ /dev/null @@ -1,88 +0,0 @@ -# Copyright (C) 2013 GRNET S.A. All rights reserved. -# -# Redistribution and use in source and binary forms, with or -# without modification, are permitted provided that the following -# conditions are met: -# -# 1. Redistributions of source code must retain the above -# copyright notice, this list of conditions and the following -# disclaimer. -# -# 2. Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following -# disclaimer in the documentation and/or other materials -# provided with the distribution. -# -# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS -# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR -# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED -# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN -# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE -# POSSIBILITY OF SUCH DAMAGE. -# -# The views and conclusions contained in the software and -# documentation are those of the authors and should not be -# interpreted as representing official policies, either expressed -# or implied, of GRNET S.A. - - -astakos_services = { - 'astakos_account': { - 'type': 'account', - 'component': 'astakos', - 'prefix': 'account', - 'public': True, - 'endpoints': [ - {'versionId': 'v1.0', - 'publicURL': None}, - ], - 'resources': { - 'pending_app': { - 'desc': "Number of pending project applications", - 'name': "astakos.pending_app", - 'service_type': "account", - 'service_origin': "astakos_account", - 'allow_in_projects': False}, - }, - }, - - 'astakos_identity': { - 'type': 'identity', - 'component': 'astakos', - 'prefix': 'identity', - 'public': True, - 'endpoints': [ - {'versionId': 'v2.0', - 'publicURL': None}, - ], - 'resources': {}, - }, - - 'astakos_weblogin': { - 'type': 'astakos_weblogin', - 'component': 'astakos', - 'prefix': 'weblogin', - 'public': True, - 'endpoints': [ - {'versionId': '', - 'publicURL': None}, - ], - }, - - 'astakos_ui': { - 'type': 'astakos_ui', - 'component': 'astakos', - 'prefix': 'ui', - 'public': False, - 'endpoints': [ - {'versionId': '', - 'publicURL': None}, - ], - }, -} diff --git a/astakosclient/astakosclient/utils.py b/astakosclient/astakosclient/utils.py index 22919cc4a5f445864488654cf1ae74f14f6305ec..70cd87e82a81e405b58f917a651ec6c92874fed3 100644 --- a/astakosclient/astakosclient/utils.py +++ b/astakosclient/astakosclient/utils.py @@ -31,6 +31,10 @@ # interpreted as representing official policies, either expressed # or implied, of GRNET S.A. +""" +Astakos Client utility module +""" + from httplib import HTTPConnection, HTTPSConnection from contextlib import closing @@ -39,8 +43,10 @@ from objpool.http import PooledHTTPConnection from astakosclient.errors import AstakosClientException, BadValue -def retry(func): +def retry_dec(func): + """Class Method Decorator""" def decorator(self, *args, **kwargs): + """Retry `self.retry' times if connection fails""" attemps = 0 while True: try: @@ -64,13 +70,16 @@ def retry(func): def scheme_to_class(scheme, use_pool, pool_size): """Return the appropriate conn class for given scheme""" def _objpool(netloc): + """Helper function to return a PooledHTTPConnection object""" return PooledHTTPConnection( netloc=netloc, scheme=scheme, size=pool_size) def _http_connection(netloc): + """Helper function to return an HTTPConnection object""" return closing(HTTPConnection(netloc)) def _https_connection(netloc): + """Helper function to return an HTTPSConnection object""" return closing(HTTPSConnection(netloc)) if scheme == "http": @@ -92,16 +101,22 @@ def parse_request(request, logger): try: return simplejson.dumps(request) except Exception as err: - m = "Cannot parse request \"%s\" with simplejson: %s" \ - % (request, str(err)) - logger.error(m) - raise BadValue(m) + msg = "Cannot parse request \"%s\" with simplejson: %s" \ + % (request, str(err)) + logger.error(msg) + raise BadValue(msg) def check_input(function_name, logger, **kwargs): """Check if given arguments are not None""" for i in kwargs: if kwargs[i] is None: - m = "in " + function_name + ": " + str(i) + " parameter not given" - logger.error(m) - raise BadValue(m) + msg = "in " + function_name + ": " + \ + str(i) + " parameter not given" + logger.error(msg) + raise BadValue(msg) + + +def join_urls(url_a, url_b): + """Join_urls from synnefo.lib""" + return url_a.rstrip("/") + "/" + url_b.lstrip("/")