X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FNBI.git;a=blobdiff_plain;f=osm_nbi%2Fadmin_topics.py;h=3c3249c62000c2bb14181c87080dbaf2c7d2d598;hp=7d1e85dd03079c06ba65eeac464ae0c00f19de66;hb=d010e3e44d9b06012dc741aca98054e3a87c5f22;hpb=1546f2a46d99a4741b23857e6ceb4b813223e297 diff --git a/osm_nbi/admin_topics.py b/osm_nbi/admin_topics.py index 7d1e85d..3c3249c 100644 --- a/osm_nbi/admin_topics.py +++ b/osm_nbi/admin_topics.py @@ -18,16 +18,15 @@ from uuid import uuid4 from hashlib import sha256 from http import HTTPStatus from time import time -from validation import user_new_schema, user_edit_schema, project_new_schema, project_edit_schema -from validation import vim_account_new_schema, vim_account_edit_schema, sdn_new_schema, sdn_edit_schema -from validation import wim_account_new_schema, wim_account_edit_schema, roles_new_schema, roles_edit_schema -from validation import validate_input -from validation import ValidationError -from validation import is_valid_uuid # To check that User/Project Names don't look like UUIDs -from base_topic import BaseTopic, EngineException +from osm_nbi.validation import user_new_schema, user_edit_schema, project_new_schema, project_edit_schema, \ + vim_account_new_schema, vim_account_edit_schema, sdn_new_schema, sdn_edit_schema, \ + wim_account_new_schema, wim_account_edit_schema, roles_new_schema, roles_edit_schema, \ + k8scluster_new_schema, k8scluster_edit_schema, k8srepo_new_schema, k8srepo_edit_schema, \ + osmrepo_new_schema, osmrepo_edit_schema, \ + validate_input, ValidationError, is_valid_uuid # To check that User/Project Names don't look like UUIDs +from osm_nbi.base_topic import BaseTopic, EngineException +from osm_nbi.authconn import AuthconnNotFoundException, AuthconnConflictException from osm_common.dbbase import deep_update_rfc7396 -from authconn import AuthconnNotFoundException, AuthconnConflictException -# from authconn_keystone import AuthconnKeystone __author__ = "Alfonso Tierno " @@ -39,8 +38,8 @@ class UserTopic(BaseTopic): schema_edit = user_edit_schema multiproject = False - def __init__(self, db, fs, msg): - BaseTopic.__init__(self, db, fs, msg) + def __init__(self, db, fs, msg, auth): + BaseTopic.__init__(self, db, fs, msg, auth) @staticmethod def _get_project_filter(session): @@ -133,8 +132,8 @@ class ProjectTopic(BaseTopic): schema_edit = project_edit_schema multiproject = False - def __init__(self, db, fs, msg): - BaseTopic.__init__(self, db, fs, msg) + def __init__(self, db, fs, msg, auth): + BaseTopic.__init__(self, db, fs, msg, auth) @staticmethod def _get_project_filter(session): @@ -201,7 +200,7 @@ class ProjectTopic(BaseTopic): class CommonVimWimSdn(BaseTopic): """Common class for VIM, WIM SDN just to unify methods that are equal to all of them""" - config_to_encrypt = () # what keys at config must be encrypted because contains passwords + config_to_encrypt = {} # what keys at config must be encrypted because contains passwords password_to_encrypt = "" # key that contains a password @staticmethod @@ -250,6 +249,7 @@ class CommonVimWimSdn(BaseTopic): :param edit_content: user requested update content :return: operation id """ + super().format_on_edit(final_content, edit_content) # encrypt passwords schema_version = final_content.get("schema_version") @@ -258,8 +258,10 @@ class CommonVimWimSdn(BaseTopic): final_content[self.password_to_encrypt] = self.db.encrypt(edit_content[self.password_to_encrypt], schema_version=schema_version, salt=final_content["_id"]) - if edit_content.get("config") and self.config_to_encrypt: - for p in self.config_to_encrypt: + config_to_encrypt_keys = self.config_to_encrypt.get(schema_version) or self.config_to_encrypt.get("default") + if edit_content.get("config") and config_to_encrypt_keys: + + for p in config_to_encrypt_keys: if edit_content["config"].get(p): final_content["config"][p] = self.db.encrypt(edit_content["config"][p], schema_version=schema_version, @@ -278,15 +280,16 @@ class CommonVimWimSdn(BaseTopic): :return: op_id: operation id on asynchronous operation, None otherwise. In addition content is modified """ super().format_on_new(content, project_id=project_id, make_public=make_public) - content["schema_version"] = schema_version = "1.1" + content["schema_version"] = schema_version = "1.11" # encrypt passwords if content.get(self.password_to_encrypt): content[self.password_to_encrypt] = self.db.encrypt(content[self.password_to_encrypt], schema_version=schema_version, salt=content["_id"]) - if content.get("config") and self.config_to_encrypt: - for p in self.config_to_encrypt: + config_to_encrypt_keys = self.config_to_encrypt.get(schema_version) or self.config_to_encrypt.get("default") + if content.get("config") and config_to_encrypt_keys: + for p in config_to_encrypt_keys: if content["config"].get(p): content["config"][p] = self.db.encrypt(content["config"][p], schema_version=schema_version, @@ -300,12 +303,13 @@ class CommonVimWimSdn(BaseTopic): return "{}:0".format(content["_id"]) - def delete(self, session, _id, dry_run=False): + def delete(self, session, _id, dry_run=False, not_send_msg=None): """ Delete item by its internal _id :param session: contains "username", "admin", "force", "public", "project_id", "set_project" :param _id: server internal id :param dry_run: make checking but do not delete + :param not_send_msg: To not send message (False) or store content (list) instead :return: operation id if it is ordered to delete. None otherwise """ @@ -317,34 +321,33 @@ class CommonVimWimSdn(BaseTopic): if dry_run: return None - # remove reference from project_read. If not last delete - if session["project_id"]: - for project_id in session["project_id"]: - if project_id in db_content["_admin"]["projects_read"]: - db_content["_admin"]["projects_read"].remove(project_id) - if project_id in db_content["_admin"]["projects_write"]: - db_content["_admin"]["projects_write"].remove(project_id) - else: - db_content["_admin"]["projects_read"].clear() - db_content["_admin"]["projects_write"].clear() - - update_dict = {"_admin.projects_read": db_content["_admin"]["projects_read"], - "_admin.projects_write": db_content["_admin"]["projects_write"] - } - - # check if there are projects referencing it (apart from ANY that means public).... - if db_content["_admin"]["projects_read"] and (len(db_content["_admin"]["projects_read"]) > 1 or - db_content["_admin"]["projects_read"][0] != "ANY"): - self.db.set_one(self.topic, filter_q, update_dict=update_dict) # remove references but not delete - return None + # remove reference from project_read if there are more projects referencing it. If it last one, + # do not remove reference, but order via kafka to delete it + if session["project_id"] and session["project_id"]: + other_projects_referencing = next((p for p in db_content["_admin"]["projects_read"] + if p not in session["project_id"] and p != "ANY"), None) + + # check if there are projects referencing it (apart from ANY, that means, public).... + if other_projects_referencing: + # remove references but not delete + update_dict_pull = {"_admin.projects_read": session["project_id"], + "_admin.projects_write": session["project_id"]} + self.db.set_one(self.topic, filter_q, update_dict=None, pull_list=update_dict_pull) + return None + else: + can_write = next((p for p in db_content["_admin"]["projects_write"] if p == "ANY" or + p in session["project_id"]), None) + if not can_write: + raise EngineException("You have not write permission to delete it", + http_code=HTTPStatus.UNAUTHORIZED) # It must be deleted if session["force"]: self.db.del_one(self.topic, {"_id": _id}) op_id = None - self._send_msg("deleted", {"_id": _id, "op_id": op_id}) + self._send_msg("deleted", {"_id": _id, "op_id": op_id}, not_send_msg=not_send_msg) else: - update_dict["_admin.to_delete"] = True + update_dict = {"_admin.to_delete": True} self.db.set_one(self.topic, {"_id": _id}, update_dict=update_dict, push={"_admin.operations": self._create_operation("delete")} @@ -352,7 +355,7 @@ class CommonVimWimSdn(BaseTopic): # the number of operations is the operation_id. db_content does not contains the new operation inserted, # so the -1 is not needed op_id = "{}:{}".format(db_content["_id"], len(db_content["_admin"]["operations"])) - self._send_msg("delete", {"_id": _id, "op_id": op_id}) + self._send_msg("delete", {"_id": _id, "op_id": op_id}, not_send_msg=not_send_msg) return op_id @@ -363,7 +366,23 @@ class VimAccountTopic(CommonVimWimSdn): schema_edit = vim_account_edit_schema multiproject = True password_to_encrypt = "vim_password" - config_to_encrypt = ("admin_password", "nsx_password", "vcenter_password") + config_to_encrypt = {"1.1": ("admin_password", "nsx_password", "vcenter_password"), + "default": ("admin_password", "nsx_password", "vcenter_password", "vrops_password")} + + def check_conflict_on_del(self, session, _id, db_content): + """ + Check if deletion can be done because of dependencies if it is not force. To override + :param session: contains "username", "admin", "force", "public", "project_id", "set_project" + :param _id: internal _id + :param db_content: The database content of this item _id + :return: None if ok or raises EngineException with the conflict + """ + if session["force"]: + return + # check if used by VNF + if self.db.get_list("vnfrs", {"vim-account-id": _id}): + raise EngineException("There is at least one VNF using this VIM account", http_code=HTTPStatus.CONFLICT) + super().check_conflict_on_del(session, _id, db_content) class WimAccountTopic(CommonVimWimSdn): @@ -373,17 +392,143 @@ class WimAccountTopic(CommonVimWimSdn): schema_edit = wim_account_edit_schema multiproject = True password_to_encrypt = "wim_password" - config_to_encrypt = () + config_to_encrypt = {} class SdnTopic(CommonVimWimSdn): topic = "sdns" topic_msg = "sdn" + quota_name = "sdn_controllers" schema_new = sdn_new_schema schema_edit = sdn_edit_schema multiproject = True password_to_encrypt = "password" - config_to_encrypt = () + config_to_encrypt = {} + + def _obtain_url(self, input, create): + if input.get("ip") or input.get("port"): + if not input.get("ip") or not input.get("port") or input.get('url'): + raise ValidationError("You must provide both 'ip' and 'port' (deprecated); or just 'url' (prefered)") + input['url'] = "http://{}:{}/".format(input["ip"], input["port"]) + del input["ip"] + del input["port"] + elif create and not input.get('url'): + raise ValidationError("You must provide 'url'") + return input + + def _validate_input_new(self, input, force=False): + input = super()._validate_input_new(input, force) + return self._obtain_url(input, True) + + def _validate_input_edit(self, input, content, force=False): + input = super()._validate_input_edit(input, content, force) + return self._obtain_url(input, False) + + +class K8sClusterTopic(CommonVimWimSdn): + topic = "k8sclusters" + topic_msg = "k8scluster" + schema_new = k8scluster_new_schema + schema_edit = k8scluster_edit_schema + multiproject = True + password_to_encrypt = None + config_to_encrypt = {} + + def format_on_new(self, content, project_id=None, make_public=False): + oid = super().format_on_new(content, project_id, make_public) + self.db.encrypt_decrypt_fields(content["credentials"], 'encrypt', ['password', 'secret'], + schema_version=content["schema_version"], salt=content["_id"]) + # Add Helm/Juju Repo lists + repos = {"helm-chart": [], "juju-bundle": []} + for proj in content["_admin"]["projects_read"]: + if proj != 'ANY': + for repo in self.db.get_list("k8srepos", {"_admin.projects_read": proj}): + if repo["_id"] not in repos[repo["type"]]: + repos[repo["type"]].append(repo["_id"]) + for k in repos: + content["_admin"][k.replace('-', '_')+"_repos"] = repos[k] + return oid + + def format_on_edit(self, final_content, edit_content): + if final_content.get("schema_version") and edit_content.get("credentials"): + self.db.encrypt_decrypt_fields(edit_content["credentials"], 'encrypt', ['password', 'secret'], + schema_version=final_content["schema_version"], salt=final_content["_id"]) + deep_update_rfc7396(final_content["credentials"], edit_content["credentials"]) + oid = super().format_on_edit(final_content, edit_content) + return oid + + def check_conflict_on_edit(self, session, final_content, edit_content, _id): + super(CommonVimWimSdn, self).check_conflict_on_edit(session, final_content, edit_content, _id) + super().check_conflict_on_edit(session, final_content, edit_content, _id) + # Update Helm/Juju Repo lists + repos = {"helm-chart": [], "juju-bundle": []} + for proj in session.get("set_project", []): + if proj != 'ANY': + for repo in self.db.get_list("k8srepos", {"_admin.projects_read": proj}): + if repo["_id"] not in repos[repo["type"]]: + repos[repo["type"]].append(repo["_id"]) + for k in repos: + rlist = k.replace('-', '_') + "_repos" + if rlist not in final_content["_admin"]: + final_content["_admin"][rlist] = [] + final_content["_admin"][rlist] += repos[k] + + def check_conflict_on_del(self, session, _id, db_content): + """ + Check if deletion can be done because of dependencies if it is not force. To override + :param session: contains "username", "admin", "force", "public", "project_id", "set_project" + :param _id: internal _id + :param db_content: The database content of this item _id + :return: None if ok or raises EngineException with the conflict + """ + if session["force"]: + return + # check if used by VNF + filter_q = {"kdur.k8s-cluster.id": _id} + if session["project_id"]: + filter_q["_admin.projects_read.cont"] = session["project_id"] + if self.db.get_list("vnfrs", filter_q): + raise EngineException("There is at least one VNF using this k8scluster", http_code=HTTPStatus.CONFLICT) + super().check_conflict_on_del(session, _id, db_content) + + +class K8sRepoTopic(CommonVimWimSdn): + topic = "k8srepos" + topic_msg = "k8srepo" + schema_new = k8srepo_new_schema + schema_edit = k8srepo_edit_schema + multiproject = True + password_to_encrypt = None + config_to_encrypt = {} + + def format_on_new(self, content, project_id=None, make_public=False): + oid = super().format_on_new(content, project_id, make_public) + # Update Helm/Juju Repo lists + repo_list = content["type"].replace('-', '_')+"_repos" + for proj in content["_admin"]["projects_read"]: + if proj != 'ANY': + self.db.set_list("k8sclusters", + {"_admin.projects_read": proj, "_admin."+repo_list+".ne": content["_id"]}, {}, + push={"_admin."+repo_list: content["_id"]}) + return oid + + def delete(self, session, _id, dry_run=False, not_send_msg=None): + type = self.db.get_one("k8srepos", {"_id": _id})["type"] + oid = super().delete(session, _id, dry_run, not_send_msg) + if oid: + # Remove from Helm/Juju Repo lists + repo_list = type.replace('-', '_') + "_repos" + self.db.set_list("k8sclusters", {"_admin."+repo_list: _id}, {}, pull={"_admin."+repo_list: _id}) + return oid + + +class OsmRepoTopic(BaseTopic): + topic = "osmrepos" + topic_msg = "osmrepos" + schema_new = osmrepo_new_schema + schema_edit = osmrepo_edit_schema + multiproject = True + # TODO: Implement user/password class UserTopicAuth(UserTopic): @@ -393,8 +538,8 @@ class UserTopicAuth(UserTopic): schema_edit = user_edit_schema def __init__(self, db, fs, msg, auth): - UserTopic.__init__(self, db, fs, msg) - self.auth = auth + UserTopic.__init__(self, db, fs, msg, auth) + # self.auth = auth def check_conflict_on_new(self, session, indata): """ @@ -529,29 +674,30 @@ class UserTopicAuth(UserTopic): rollback.append({"topic": self.topic, "_id": _id}) # del content["password"] - # self._send_msg("create", content) + # self._send_msg("created", content, not_send_msg=not_send_msg) return _id, None except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) - def show(self, session, _id): + def show(self, session, _id, api_req=False): """ Get complete information on an topic :param session: contains "username", "admin", "force", "public", "project_id", "set_project" - :param _id: server internal id + :param _id: server internal id or username + :param api_req: True if this call is serving an external API request. False if serving internal request. :return: dictionary, raise exception if not found. """ # Allow _id to be a name or uuid - filter_q = {self.id_field(self.topic, _id): _id} - users = self.auth.get_user_list(filter_q) - + filter_q = {"username": _id} + # users = self.auth.get_user_list(filter_q) + users = self.list(session, filter_q) # To allow default filtering (Bug 853) if len(users) == 1: return users[0] elif len(users) > 1: - raise EngineException("Too many users found", HTTPStatus.CONFLICT) + raise EngineException("Too many users found for '{}'".format(_id), HTTPStatus.CONFLICT) else: - raise EngineException("User not found", HTTPStatus.NOT_FOUND) + raise EngineException("User '{}' not found".format(_id), HTTPStatus.NOT_FOUND) def edit(self, session, _id, indata=None, kwargs=None, content=None): """ @@ -570,10 +716,9 @@ class UserTopicAuth(UserTopic): if kwargs: BaseTopic._update_input_with_kwargs(indata, kwargs) try: - indata = self._validate_input_edit(indata, force=session["force"]) - if not content: content = self.show(session, _id) + indata = self._validate_input_edit(indata, content, force=session["force"]) self.check_conflict_on_edit(session, content, indata, _id=_id) # self.format_on_edit(content, indata) @@ -668,18 +813,21 @@ class UserTopicAuth(UserTopic): except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) - def list(self, session, filter_q=None): + def list(self, session, filter_q=None, api_req=False): """ Get a list of the topic that matches a filter :param session: contains "username", "admin", "force", "public", "project_id", "set_project" :param filter_q: filter of data to be applied + :param api_req: True if this call is serving an external API request. False if serving internal request. :return: The list, it can be empty if no one match the filter. """ - users = self.auth.get_user_list(filter_q) - - return users + user_list = self.auth.get_user_list(filter_q) + if not session["allow_show_user_project_role"]: + # Bug 853 - Default filtering + user_list = [usr for usr in user_list if usr["username"] == session["username"]] + return user_list - def delete(self, session, _id, dry_run=False): + def delete(self, session, _id, dry_run=False, not_send_msg=None): """ Delete item by its internal _id @@ -687,6 +835,7 @@ class UserTopicAuth(UserTopic): :param _id: server internal id :param force: indicates if deletion must be forced in case of conflict :param dry_run: make checking but do not delete + :param not_send_msg: To not send message (False) or store content (list) instead :return: dictionary with deleted item _id. It raises EngineException on error: not found, conflict, ... """ # Allow _id to be a name or uuid @@ -706,8 +855,8 @@ class ProjectTopicAuth(ProjectTopic): schema_edit = project_edit_schema def __init__(self, db, fs, msg, auth): - ProjectTopic.__init__(self, db, fs, msg) - self.auth = auth + ProjectTopic.__init__(self, db, fs, msg, auth) + # self.auth = auth def check_conflict_on_new(self, session, indata): """ @@ -741,14 +890,14 @@ class ProjectTopicAuth(ProjectTopic): project_name = edit_content.get("name") if project_name != final_content["name"]: # It is a true renaming if is_valid_uuid(project_name): - raise EngineException("project name '{}' cannot have an uuid format".format(project_name), + raise EngineException("project name '{}' cannot have an uuid format".format(project_name), HTTPStatus.UNPROCESSABLE_ENTITY) if final_content["name"] == "admin": raise EngineException("You cannot rename project 'admin'", http_code=HTTPStatus.CONFLICT) # Check that project name is not used, regardless keystone already checks this - if self.auth.get_project_list(filter_q={"name": project_name}): + if project_name and self.auth.get_project_list(filter_q={"name": project_name}): raise EngineException("project '{}' is already used".format(project_name), HTTPStatus.CONFLICT) def check_conflict_on_del(self, session, _id, db_content): @@ -811,23 +960,24 @@ class ProjectTopicAuth(ProjectTopic): self.format_on_new(content, project_id=session["project_id"], make_public=session["public"]) _id = self.auth.create_project(content) rollback.append({"topic": self.topic, "_id": _id}) - # self._send_msg("create", content) + # self._send_msg("created", content, not_send_msg=not_send_msg) return _id, None except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) - def show(self, session, _id): + def show(self, session, _id, api_req=False): """ Get complete information on an topic :param session: contains "username", "admin", "force", "public", "project_id", "set_project" :param _id: server internal id + :param api_req: True if this call is serving an external API request. False if serving internal request. :return: dictionary, raise exception if not found. """ # Allow _id to be a name or uuid filter_q = {self.id_field(self.topic, _id): _id} - projects = self.auth.get_project_list(filter_q=filter_q) - + # projects = self.auth.get_project_list(filter_q=filter_q) + projects = self.list(session, filter_q) # To allow default filtering (Bug 853) if len(projects) == 1: return projects[0] elif len(projects) > 1: @@ -835,7 +985,7 @@ class ProjectTopicAuth(ProjectTopic): else: raise EngineException("Project not found", HTTPStatus.NOT_FOUND) - def list(self, session, filter_q=None): + def list(self, session, filter_q=None, api_req=False): """ Get a list of the topic that matches a filter @@ -843,15 +993,22 @@ class ProjectTopicAuth(ProjectTopic): :param filter_q: filter of data to be applied :return: The list, it can be empty if no one match the filter. """ - return self.auth.get_project_list(filter_q) + project_list = self.auth.get_project_list(filter_q) + if not session["allow_show_user_project_role"]: + # Bug 853 - Default filtering + user = self.auth.get_user(session["username"]) + projects = [prm["project"] for prm in user["project_role_mappings"]] + project_list = [proj for proj in project_list if proj["_id"] in projects] + return project_list - def delete(self, session, _id, dry_run=False): + def delete(self, session, _id, dry_run=False, not_send_msg=None): """ Delete item by its internal _id :param session: contains "username", "admin", "force", "public", "project_id", "set_project" :param _id: server internal id :param dry_run: make checking but do not delete + :param not_send_msg: To not send message (False) or store content (list) instead :return: dictionary with deleted item _id. It raises EngineException on error: not found, conflict, ... """ # Allow _id to be a name or uuid @@ -880,15 +1037,13 @@ class ProjectTopicAuth(ProjectTopic): if kwargs: BaseTopic._update_input_with_kwargs(indata, kwargs) try: - indata = self._validate_input_edit(indata, force=session["force"]) - if not content: content = self.show(session, _id) + indata = self._validate_input_edit(indata, content, force=session["force"]) self.check_conflict_on_edit(session, content, indata, _id=_id) self.format_on_edit(content, indata) - if "name" in indata: - content["name"] = indata["name"] + deep_update_rfc7396(content, indata) self.auth.update_project(content["_id"], content) except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) @@ -901,10 +1056,10 @@ class RoleTopicAuth(BaseTopic): schema_edit = roles_edit_schema multiproject = False - def __init__(self, db, fs, msg, auth, ops): - BaseTopic.__init__(self, db, fs, msg) - self.auth = auth - self.operations = ops + def __init__(self, db, fs, msg, auth): + BaseTopic.__init__(self, db, fs, msg, auth) + # self.auth = auth + self.operations = auth.role_permissions # self.topic = "roles_operations" if isinstance(auth, AuthconnKeystone) else "roles" @staticmethod @@ -926,9 +1081,9 @@ class RoleTopicAuth(BaseTopic): if role_def[-1] == ":": raise ValidationError("Operation cannot end with ':'") - role_def_matches = [op for op in operations if op.startswith(role_def)] + match = next((op for op in operations if op == role_def or op.startswith(role_def + ":")), None) - if len(role_def_matches) == 0: + if not match: raise ValidationError("Invalid permission '{}'".format(role_def)) def _validate_input_new(self, input, force=False): @@ -945,7 +1100,7 @@ class RoleTopicAuth(BaseTopic): return input - def _validate_input_edit(self, input, force=False): + def _validate_input_edit(self, input, content, force=False): """ Validates input user content for updating an entry. @@ -967,6 +1122,11 @@ class RoleTopicAuth(BaseTopic): :param indata: data to be inserted :return: None or raises EngineException """ + # check name is not uuid + role_name = indata.get("name") + if is_valid_uuid(role_name): + raise EngineException("role name '{}' cannot have an uuid format".format(role_name), + HTTPStatus.UNPROCESSABLE_ENTITY) # check name not exists name = indata["name"] # if self.db.get_one(self.topic, {"name": indata.get("name")}, fail_on_empty=False, fail_on_more=False): @@ -988,6 +1148,17 @@ class RoleTopicAuth(BaseTopic): if "admin" not in final_content["permissions"]: final_content["permissions"]["admin"] = False + # check name is not uuid + role_name = edit_content.get("name") + if is_valid_uuid(role_name): + raise EngineException("role name '{}' cannot have an uuid format".format(role_name), + HTTPStatus.UNPROCESSABLE_ENTITY) + + # Check renaming of admin roles + role = self.auth.get_role(_id) + if role["name"] in ["system_admin", "project_admin"]: + raise EngineException("You cannot rename role '{}'".format(role["name"]), http_code=HTTPStatus.FORBIDDEN) + # check name not exists if "name" in edit_content: role_name = edit_content["name"] @@ -1010,11 +1181,12 @@ class RoleTopicAuth(BaseTopic): raise EngineException("You cannot delete role '{}'".format(role["name"]), http_code=HTTPStatus.FORBIDDEN) # If any user is using this role, raise CONFLICT exception - for user in self.auth.get_user_list(): - for prm in user.get("project_role_mappings"): - if prm["role"] == _id: - raise EngineException("Role '{}' ({}) is being used by user '{}'" - .format(role["name"], _id, user["username"]), HTTPStatus.CONFLICT) + if not session["force"]: + for user in self.auth.get_user_list(): + for prm in user.get("project_role_mappings"): + if prm["role"] == _id: + raise EngineException("Role '{}' ({}) is being used by user '{}'" + .format(role["name"], _id, user["username"]), HTTPStatus.CONFLICT) @staticmethod def format_on_new(content, project_id=None, make_public=False): # TO BE REMOVED ? @@ -1062,23 +1234,25 @@ class RoleTopicAuth(BaseTopic): final_content["permissions"]["admin"] = False return None - def show(self, session, _id): + def show(self, session, _id, api_req=False): """ Get complete information on an topic :param session: contains "username", "admin", "force", "public", "project_id", "set_project" :param _id: server internal id + :param api_req: True if this call is serving an external API request. False if serving internal request. :return: dictionary, raise exception if not found. """ filter_q = {BaseTopic.id_field(self.topic, _id): _id} - roles = self.auth.get_role_list(filter_q) + # roles = self.auth.get_role_list(filter_q) + roles = self.list(session, filter_q) # To allow default filtering (Bug 853) if not roles: raise AuthconnNotFoundException("Not found any role with filter {}".format(filter_q)) elif len(roles) > 1: raise AuthconnConflictException("Found more than one role with filter {}".format(filter_q)) return roles[0] - def list(self, session, filter_q=None): + def list(self, session, filter_q=None, api_req=False): """ Get a list of the topic that matches a filter @@ -1086,7 +1260,13 @@ class RoleTopicAuth(BaseTopic): :param filter_q: filter of data to be applied :return: The list, it can be empty if no one match the filter. """ - return self.auth.get_role_list(filter_q) + role_list = self.auth.get_role_list(filter_q) + if not session["allow_show_user_project_role"]: + # Bug 853 - Default filtering + user = self.auth.get_user(session["username"]) + roles = [prm["role"] for prm in user["project_role_mappings"]] + role_list = [role for role in role_list if role["_id"] in roles] + return role_list def new(self, rollback, session, indata=None, kwargs=None, headers=None): """ @@ -1112,18 +1292,19 @@ class RoleTopicAuth(BaseTopic): content["_id"] = rid # _id = self.db.create(self.topic, content) rollback.append({"topic": self.topic, "_id": rid}) - # self._send_msg("create", content) + # self._send_msg("created", content, not_send_msg=not_send_msg) return rid, None except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) - def delete(self, session, _id, dry_run=False): + def delete(self, session, _id, dry_run=False, not_send_msg=None): """ Delete item by its internal _id :param session: contains "username", "admin", "force", "public", "project_id", "set_project" :param _id: server internal id :param dry_run: make checking but do not delete + :param not_send_msg: To not send message (False) or store content (list) instead :return: dictionary with deleted item _id. It raises EngineException on error: not found, conflict, ... """ filter_q = {BaseTopic.id_field(self.topic, _id): _id} @@ -1156,9 +1337,9 @@ class RoleTopicAuth(BaseTopic): if kwargs: self._update_input_with_kwargs(indata, kwargs) try: - indata = self._validate_input_edit(indata, force=session["force"]) if not content: content = self.show(session, _id) + indata = self._validate_input_edit(indata, content, force=session["force"]) deep_update_rfc7396(content, indata) self.check_conflict_on_edit(session, content, indata, _id=_id) self.format_on_edit(content, indata)