X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FNBI.git;a=blobdiff_plain;f=osm_nbi%2Fauthconn_keystone.py;h=748b2e700c16da6b809f0bb96d14787e00909c84;hp=bb693815afc042b4d5bf561b4ea5f9f3739cb7f1;hb=6486f7485862dc51758864e6cf7d5d2523751873;hpb=cf042d30e8b7a1a9cbd1b2064e83c5d20ffcec9b diff --git a/osm_nbi/authconn_keystone.py b/osm_nbi/authconn_keystone.py index bb69381..748b2e7 100644 --- a/osm_nbi/authconn_keystone.py +++ b/osm_nbi/authconn_keystone.py @@ -25,10 +25,12 @@ it for OSM. """ -__author__ = "Eduardo Sousa " +__author__ = "Eduardo Sousa , " \ + "Pedro de la Cruz Ramos " __date__ = "$27-jul-2018 23:59:59$" -from authconn import Authconn, AuthException, AuthconnOperationException, AuthconnNotFoundException +from osm_nbi.authconn import Authconn, AuthException, AuthconnOperationException, AuthconnNotFoundException, \ + AuthconnConflictException import logging import requests @@ -39,21 +41,28 @@ from keystoneauth1.exceptions.base import ClientException from keystoneauth1.exceptions.http import Conflict from keystoneclient.v3 import client from http import HTTPStatus -from validation import is_valid_uuid +from osm_nbi.validation import is_valid_uuid class AuthconnKeystone(Authconn): - def __init__(self, config): - Authconn.__init__(self, config) + def __init__(self, config, db): + Authconn.__init__(self, config, db) self.logger = logging.getLogger("nbi.authenticator.keystone") self.auth_url = "http://{0}:{1}/v3".format(config.get("auth_url", "keystone"), config.get("auth_port", "5000")) - self.user_domain_name = config.get("user_domain_name", "default") + self.user_domain_name_list = config.get("user_domain_name", "default") + self.user_domain_name_list = self.user_domain_name_list.split(",") self.admin_project = config.get("service_project", "service") self.admin_username = config.get("service_username", "nbi") self.admin_password = config.get("service_password", "nbi") - self.project_domain_name = config.get("project_domain_name", "default") + self.project_domain_name_list = config.get("project_domain_name", "default") + self.project_domain_name_list = self.project_domain_name_list.split(",") + if len(self.user_domain_name_list) != len(self.project_domain_name_list): + raise ValueError("Invalid configuration parameter fo authenticate. 'project_domain_name' and " + "'user_domain_name' must be a comma-separated list with the same size. Revise " + "configuration or/and 'OSMNBI_AUTHENTICATION_PROJECT_DOMAIN_NAME', " + "'OSMNBI_AUTHENTICATION_USER_DOMAIN_NAME' Variables") # Waiting for Keystone to be up available = None @@ -68,22 +77,26 @@ class AuthconnKeystone(Authconn): if counter == 0: raise AuthException("Keystone not available after 300s timeout") - self.auth = v3.Password(user_domain_name=self.user_domain_name, + self.auth = v3.Password(user_domain_name=self.user_domain_name_list[0], username=self.admin_username, password=self.admin_password, - project_domain_name=self.project_domain_name, + project_domain_name=self.project_domain_name_list[0], project_name=self.admin_project, auth_url=self.auth_url) self.sess = session.Session(auth=self.auth) self.keystone = client.Client(session=self.sess) - def authenticate(self, user, password, project=None, token=None): - """ - Authenticate a user using username/password or token, plus project - :param user: user: name, id or None - :param password: password or None - :param project: name, id, or None. If None first found project will be used to get an scope token - :param token: previous token to obtain authorization + def authenticate(self, credentials, token_info=None): + """ + Authenticate a user using username/password or token_info, plus project + :param credentials: dictionary that contains: + username: name, id or None + password: password or None + project_id: name, id, or None. If None first found project will be used to get an scope token + project_domain_name: (Optional) To use a concrete domain for the project + user_domain_name: (Optional) To use a concrete domain for the project + other items are allowed and ignored + :param token_info: previous token_info to obtain authorization :return: the scoped token info or raises an exception. The token is a dictionary with: _id: token string id, username: username, @@ -92,113 +105,117 @@ class AuthconnKeystone(Authconn): expires: epoch time when it expires, """ - try: - username = None - user_id = None - project_id = None - project_name = None - - if user: - if is_valid_uuid(user): - user_id = user + username = None + user_id = None + project_id = None + project_name = None + if credentials.get("project_domain_name"): + project_domain_name_list = (credentials["project_domain_name"], ) + else: + project_domain_name_list = self.project_domain_name_list + if credentials.get("user_domain_name"): + user_domain_name_list = (credentials["user_domain_name"], ) + else: + user_domain_name_list = self.user_domain_name_list + + for index, project_domain_name in enumerate(project_domain_name_list): + user_domain_name = user_domain_name_list[index] + try: + if credentials.get("username"): + if is_valid_uuid(credentials["username"]): + user_id = credentials["username"] + else: + username = credentials["username"] + + # get an unscoped token firstly + unscoped_token = self.keystone.get_raw_token_from_identity_service( + auth_url=self.auth_url, + user_id=user_id, + username=username, + password=credentials.get("password"), + user_domain_name=user_domain_name, + project_domain_name=project_domain_name) + elif token_info: + unscoped_token = self.keystone.tokens.validate(token=token_info.get("_id")) else: - username = user - - # get an unscoped token firstly - unscoped_token = self.keystone.get_raw_token_from_identity_service( - auth_url=self.auth_url, - user_id=user_id, - username=username, - password=password, - user_domain_name=self.user_domain_name, - project_domain_name=self.project_domain_name) - elif token: - unscoped_token = self.keystone.tokens.validate(token=token) - else: - raise AuthException("Provide credentials: username/password or Authorization Bearer token", - http_code=HTTPStatus.UNAUTHORIZED) - - if not project: - # get first project for the user - project_list = self.keystone.projects.list(user=unscoped_token["user"]["id"]) - if not project_list: - raise AuthException("The user {} has not any project and cannot be used for authentication". - format(user), http_code=HTTPStatus.UNAUTHORIZED) - project_id = project_list[0].id - else: - if is_valid_uuid(project): - project_id = project + raise AuthException("Provide credentials: username/password or Authorization Bearer token", + http_code=HTTPStatus.UNAUTHORIZED) + + if not credentials.get("project_id"): + # get first project for the user + project_list = self.keystone.projects.list(user=unscoped_token["user"]["id"]) + if not project_list: + raise AuthException("The user {} has not any project and cannot be used for authentication". + format(credentials.get("username")), http_code=HTTPStatus.UNAUTHORIZED) + project_id = project_list[0].id else: - project_name = project - - scoped_token = self.keystone.get_raw_token_from_identity_service( - auth_url=self.auth_url, - project_name=project_name, - project_id=project_id, - user_domain_name=self.user_domain_name, - project_domain_name=self.project_domain_name, - token=unscoped_token["auth_token"]) - - auth_token = { - "_id": scoped_token.auth_token, - "username": scoped_token.username, - "project_id": scoped_token.project_id, - "project_name": scoped_token.project_name, - "expires": scoped_token.expires.timestamp(), - } + if is_valid_uuid(credentials["project_id"]): + project_id = credentials["project_id"] + else: + project_name = credentials["project_id"] - return auth_token - except ClientException as e: - self.logger.exception("Error during user authentication using keystone. Method: basic: {}".format(e)) - raise AuthException("Error during user authentication using Keystone: {}".format(e), - http_code=HTTPStatus.UNAUTHORIZED) - - # def authenticate_with_token(self, token, project=None): - # """ - # Authenticate a user using a token. Can be used to revalidate the token - # or to get a scoped token. - # - # :param token: a valid token. - # :param project: (optional) project for a scoped token. - # :return: return a revalidated token, scoped if a project was passed or - # the previous token was already scoped. - # """ - # try: - # token_info = self.keystone.tokens.validate(token=token) - # projects = self.keystone.projects.list(user=token_info["user"]["id"]) - # project_names = [project.name for project in projects] - # - # new_token = self.keystone.get_raw_token_from_identity_service( - # auth_url=self.auth_url, - # token=token, - # project_name=project, - # project_id=None, - # user_domain_name=self.user_domain_name, - # project_domain_name=self.project_domain_name) - # - # return new_token["auth_token"], project_names - # except ClientException as e: - # self.logger.exception("Error during user authentication using keystone. Method: bearer: {}".format(e)) - # raise AuthException("Error during user authentication using Keystone: {}".format(e), - # http_code=HTTPStatus.UNAUTHORIZED) + scoped_token = self.keystone.get_raw_token_from_identity_service( + auth_url=self.auth_url, + project_name=project_name, + project_id=project_id, + user_domain_name=user_domain_name, + project_domain_name=project_domain_name, + token=unscoped_token["auth_token"]) + + auth_token = { + "_id": scoped_token.auth_token, + "id": scoped_token.auth_token, + "user_id": scoped_token.user_id, + "username": scoped_token.username, + "project_id": scoped_token.project_id, + "project_name": scoped_token.project_name, + "project_domain_name": scoped_token.project_domain_name, + "user_domain_name": scoped_token.user_domain_name, + "expires": scoped_token.expires.timestamp(), + "issued_at": scoped_token.issued.timestamp() + } + + return auth_token + except ClientException as e: + if index >= len(user_domain_name_list)-1 or index >= len(project_domain_name_list)-1: + # if last try, launch exception + # self.logger.exception("Error during user authentication using keystone: {}".format(e)) + raise AuthException("Error during user authentication using Keystone: {}".format(e), + http_code=HTTPStatus.UNAUTHORIZED) def validate_token(self, token): """ Check if the token is valid. - :param token: token to validate - :return: dictionary with information associated with the token. If the - token is not valid, returns None. + :param token: token id to be validated + :return: dictionary with information associated with the token: + "expires": + "_id": token_id, + "project_id": project_id, + "username": , + "roles": list with dict containing {name, id} + If the token is not valid an exception is raised. """ if not token: return try: token_info = self.keystone.tokens.validate(token=token) + ses = { + "_id": token_info["auth_token"], + "id": token_info["auth_token"], + "project_id": token_info["project"]["id"], + "project_name": token_info["project"]["name"], + "user_id": token_info["user"]["id"], + "username": token_info["user"]["name"], + "roles": token_info["roles"], + "expires": token_info.expires.timestamp(), + "issued_at": token_info.issued.timestamp() + } - return token_info + return ses except ClientException as e: - self.logger.exception("Error during token validation using keystone: {}".format(e)) + # self.logger.exception("Error during token validation using keystone: {}".format(e)) raise AuthException("Error during token validation using Keystone: {}".format(e), http_code=HTTPStatus.UNAUTHORIZED) @@ -214,89 +231,63 @@ class AuthconnKeystone(Authconn): return True except ClientException as e: - self.logger.exception("Error during token revocation using keystone: {}".format(e)) + # self.logger.exception("Error during token revocation using keystone: {}".format(e)) raise AuthException("Error during token revocation using Keystone: {}".format(e), http_code=HTTPStatus.UNAUTHORIZED) - def get_user_project_list(self, token): - """ - Get all the projects associated with a user. - - :param token: valid token - :return: list of projects - """ - try: - token_info = self.keystone.tokens.validate(token=token) - projects = self.keystone.projects.list(user=token_info["user"]["id"]) - project_names = [project.name for project in projects] - - return project_names - except ClientException as e: - self.logger.exception("Error during user project listing using keystone: {}".format(e)) - raise AuthException("Error during user project listing using Keystone: {}".format(e), - http_code=HTTPStatus.UNAUTHORIZED) - - def get_user_role_list(self, token): - """ - Get role list for a scoped project. - - :param token: scoped token. - :return: returns the list of roles for the user in that project. If - the token is unscoped it returns None. - """ - try: - token_info = self.keystone.tokens.validate(token=token) - roles_info = self.keystone.roles.list(user=token_info["user"]["id"], project=token_info["project"]["id"]) - - roles = [role.name for role in roles_info] - - return roles - except ClientException as e: - self.logger.exception("Error during user role listing using keystone: {}".format(e)) - raise AuthException("Error during user role listing using Keystone: {}".format(e), - http_code=HTTPStatus.UNAUTHORIZED) - - def create_user(self, user, password): + def create_user(self, user_info): """ Create a user. - :param user: username. - :param password: password. + :param user_info: full user info. :raises AuthconnOperationException: if user creation failed. :return: returns the id of the user in keystone. """ try: - new_user = self.keystone.users.create(user, password=password, domain=self.user_domain_name) + new_user = self.keystone.users.create( + user_info["username"], password=user_info["password"], + domain=user_info.get("user_domain_name", self.user_domain_name_list[0]), + _admin=user_info["_admin"]) + if "project_role_mappings" in user_info.keys(): + for mapping in user_info["project_role_mappings"]: + self.assign_role_to_user(new_user.id, mapping["project"], mapping["role"]) return {"username": new_user.name, "_id": new_user.id} except Conflict as e: # self.logger.exception("Error during user creation using keystone: {}".format(e)) raise AuthconnOperationException(e, http_code=HTTPStatus.CONFLICT) except ClientException as e: - self.logger.exception("Error during user creation using keystone: {}".format(e)) + # self.logger.exception("Error during user creation using keystone: {}".format(e)) raise AuthconnOperationException("Error during user creation using Keystone: {}".format(e)) - def update_user(self, user, new_name=None, new_password=None): + def update_user(self, user_info): """ Change the user name and/or password. - :param user: username or user_id - :param new_name: new name - :param new_password: new password. + :param user_info: user info modifications :raises AuthconnOperationException: if change failed. """ try: + user = user_info.get("_id") or user_info.get("username") if is_valid_uuid(user): - user_id = user + user_obj_list = [self.keystone.users.get(user)] else: user_obj_list = self.keystone.users.list(name=user) - if not user_obj_list: - raise AuthconnNotFoundException("User '{}' not found".format(user)) - user_id = user_obj_list[0].id - - self.keystone.users.update(user_id, password=new_password, name=new_name) + if not user_obj_list: + raise AuthconnNotFoundException("User '{}' not found".format(user)) + user_obj = user_obj_list[0] + user_id = user_obj.id + if user_info.get("password") or user_info.get("username") \ + or user_info.get("add_project_role_mappings") or user_info.get("remove_project_role_mappings"): + ctime = user_obj._admin.get("created", 0) if hasattr(user_obj, "_admin") else 0 + self.keystone.users.update(user_id, password=user_info.get("password"), name=user_info.get("username"), + _admin={"created": ctime, "modified": time.time()}) + for mapping in user_info.get("remove_project_role_mappings", []): + self.remove_role_from_user(user_id, mapping["project"], mapping["role"]) + for mapping in user_info.get("add_project_role_mappings", []): + self.assign_role_to_user(user_id, mapping["project"], mapping["role"]) except ClientException as e: - self.logger.exception("Error during user password/name update using keystone: {}".format(e)) - raise AuthconnOperationException("Error during user password/name update using Keystone: {}".format(e)) + # self.logger.exception("Error during user password/name update using keystone: {}".format(e)) + raise AuthconnOperationException("Error during user update using Keystone: {}".format(e)) def delete_user(self, user_id): """ @@ -306,17 +297,12 @@ class AuthconnKeystone(Authconn): :raises AuthconnOperationException: if user deletion failed. """ try: - # users = self.keystone.users.list() - # user_obj = [user for user in users if user.id == user_id][0] - # result, _ = self.keystone.users.delete(user_obj) - result, detail = self.keystone.users.delete(user_id) if result.status_code != 204: raise ClientException("error {} {}".format(result.status_code, detail)) - return True except ClientException as e: - self.logger.exception("Error during user deletion using keystone: {}".format(e)) + # self.logger.exception("Error during user deletion using keystone: {}".format(e)) raise AuthconnOperationException("Error during user deletion using Keystone: {}".format(e)) def get_user_list(self, filter_q=None): @@ -334,70 +320,79 @@ class AuthconnKeystone(Authconn): users = [{ "username": user.name, "_id": user.id, - "id": user.id + "id": user.id, + "_admin": user.to_dict().get("_admin", {}) # TODO: REVISE } for user in users if user.name != self.admin_username] if filter_q and filter_q.get("_id"): users = [user for user in users if filter_q["_id"] == user["_id"]] for user in users: + user["project_role_mappings"] = [] + user["projects"] = [] projects = self.keystone.projects.list(user=user["_id"]) - projects = [{ - "name": project.name, - "_id": project.id, - "id": project.id - } for project in projects] - for project in projects: - roles = self.keystone.roles.list(user=user["_id"], project=project["_id"]) - roles = [{ - "name": role.name, - "_id": role.id, - "id": role.id - } for role in roles] - project["roles"] = roles - - user["projects"] = projects + user["projects"].append(project.name) + + roles = self.keystone.roles.list(user=user["_id"], project=project.id) + for role in roles: + prm = { + "project": project.id, + "project_name": project.name, + "role_name": role.name, + "role": role.id, + } + user["project_role_mappings"].append(prm) return users except ClientException as e: - self.logger.exception("Error during user listing using keystone: {}".format(e)) + # self.logger.exception("Error during user listing using keystone: {}".format(e)) raise AuthconnOperationException("Error during user listing using Keystone: {}".format(e)) - def get_role_list(self): + def get_role_list(self, filter_q=None): """ Get role list. + :param filter_q: dictionary to filter role list by _id and/or name. :return: returns the list of roles. """ try: - roles_list = self.keystone.roles.list() + filter_name = None + if filter_q: + filter_name = filter_q.get("name") + roles_list = self.keystone.roles.list(name=filter_name) roles = [{ "name": role.name, - "_id": role.id + "_id": role.id, + "_admin": role.to_dict().get("_admin", {}), + "permissions": role.to_dict().get("permissions", {}) } for role in roles_list if role.name != "service"] + if filter_q and filter_q.get("_id"): + roles = [role for role in roles if filter_q["_id"] == role["_id"]] + return roles except ClientException as e: - self.logger.exception("Error during user role listing using keystone: {}".format(e)) + # self.logger.exception("Error during user role listing using keystone: {}".format(e)) raise AuthException("Error during user role listing using Keystone: {}".format(e), http_code=HTTPStatus.UNAUTHORIZED) - def create_role(self, role): + def create_role(self, role_info): """ Create a role. - :param role: role name. + :param role_info: full role info. :raises AuthconnOperationException: if role creation failed. """ try: - result = self.keystone.roles.create(role) - return {"name": result.name, "_id": result.id} + result = self.keystone.roles.create(role_info["name"], permissions=role_info.get("permissions"), + _admin=role_info.get("_admin")) + return result.id except Conflict as ex: - self.logger.info("Duplicate entry: %s", str(ex)) + raise AuthconnConflictException(str(ex)) except ClientException as e: - self.logger.exception("Error during role creation using keystone: {}".format(e)) + # self.logger.exception("Error during role creation using keystone: {}".format(e)) raise AuthconnOperationException("Error during role creation using Keystone: {}".format(e)) def delete_role(self, role_id): @@ -408,18 +403,35 @@ class AuthconnKeystone(Authconn): :raises AuthconnOperationException: if role deletion failed. """ try: - roles = self.keystone.roles.list() - role_obj = [role for role in roles if role.id == role_id][0] - result, detail = self.keystone.roles.delete(role_obj) + result, detail = self.keystone.roles.delete(role_id) if result.status_code != 204: raise ClientException("error {} {}".format(result.status_code, detail)) return True except ClientException as e: - self.logger.exception("Error during role deletion using keystone: {}".format(e)) + # self.logger.exception("Error during role deletion using keystone: {}".format(e)) raise AuthconnOperationException("Error during role deletion using Keystone: {}".format(e)) + def update_role(self, role_info): + """ + Change the name of a role + :param role_info: full role info + :return: None + """ + try: + rid = role_info["_id"] + if not is_valid_uuid(rid): # Is this required? + role_obj_list = self.keystone.roles.list(name=rid) + if not role_obj_list: + raise AuthconnNotFoundException("Role '{}' not found".format(rid)) + rid = role_obj_list[0].id + self.keystone.roles.update(rid, name=role_info["name"], permissions=role_info.get("permissions"), + _admin=role_info.get("_admin")) + except ClientException as e: + # self.logger.exception("Error during role update using keystone: {}".format(e)) + raise AuthconnOperationException("Error during role updating using Keystone: {}".format(e)) + def get_project_list(self, filter_q=None): """ Get all the projects. @@ -435,7 +447,9 @@ class AuthconnKeystone(Authconn): projects = [{ "name": project.name, - "_id": project.id + "_id": project.id, + "_admin": project.to_dict().get("_admin", {}), # TODO: REVISE + "quotas": project.to_dict().get("quotas", {}), # TODO: REVISE } for project in projects] if filter_q and filter_q.get("_id"): @@ -444,23 +458,28 @@ class AuthconnKeystone(Authconn): return projects except ClientException as e: - self.logger.exception("Error during user project listing using keystone: {}".format(e)) + # self.logger.exception("Error during user project listing using keystone: {}".format(e)) raise AuthException("Error during user project listing using Keystone: {}".format(e), http_code=HTTPStatus.UNAUTHORIZED) - def create_project(self, project): + def create_project(self, project_info): """ Create a project. - :param project: project name. + :param project_info: full project info. :return: the internal id of the created project :raises AuthconnOperationException: if project creation failed. """ try: - result = self.keystone.projects.create(project, self.project_domain_name) + result = self.keystone.projects.create( + project_info["name"], + project_info.get("project_domain_name", self.project_domain_name_list[0]), + _admin=project_info["_admin"], + quotas=project_info.get("quotas", {}) + ) return result.id except ClientException as e: - self.logger.exception("Error during project creation using keystone: {}".format(e)) + # self.logger.exception("Error during project creation using keystone: {}".format(e)) raise AuthconnOperationException("Error during project creation using Keystone: {}".format(e)) def delete_project(self, project_id): @@ -481,21 +500,24 @@ class AuthconnKeystone(Authconn): return True except ClientException as e: - self.logger.exception("Error during project deletion using keystone: {}".format(e)) + # self.logger.exception("Error during project deletion using keystone: {}".format(e)) raise AuthconnOperationException("Error during project deletion using Keystone: {}".format(e)) - def update_project(self, project_id, new_name): + def update_project(self, project_id, project_info): """ Change the name of a project :param project_id: project to be changed - :param new_name: new name + :param project_info: full project info :return: None """ try: - self.keystone.projects.update(project_id, name=new_name) + self.keystone.projects.update(project_id, name=project_info["name"], + _admin=project_info["_admin"], + quotas=project_info.get("quotas", {}) + ) except ClientException as e: - self.logger.exception("Error during project update using keystone: {}".format(e)) - raise AuthconnOperationException("Error during project deletion using Keystone: {}".format(e)) + # self.logger.exception("Error during project update using keystone: {}".format(e)) + raise AuthconnOperationException("Error during project update using Keystone: {}".format(e)) def assign_role_to_user(self, user, project, role): """ @@ -533,7 +555,7 @@ class AuthconnKeystone(Authconn): self.keystone.roles.grant(role_obj, user=user_obj, project=project_obj) except ClientException as e: - self.logger.exception("Error during user role assignment using keystone: {}".format(e)) + # self.logger.exception("Error during user role assignment using keystone: {}".format(e)) raise AuthconnOperationException("Error during role '{}' assignment to user '{}' and project '{}' using " "Keystone: {}".format(role, user, project, e)) @@ -574,6 +596,6 @@ class AuthconnKeystone(Authconn): self.keystone.roles.revoke(role_obj, user=user_obj, project=project_obj) except ClientException as e: - self.logger.exception("Error during user role revocation using keystone: {}".format(e)) + # self.logger.exception("Error during user role revocation using keystone: {}".format(e)) raise AuthconnOperationException("Error during role '{}' revocation to user '{}' and project '{}' using " "Keystone: {}".format(role, user, project, e))