X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FNBI.git;a=blobdiff_plain;f=osm_nbi%2Fadmin_topics.py;h=786d237ec4fba7435e8e6cf1fd0a39f35d1e3517;hp=ada9c7b11502fc5ce67dc78cf9a663f40d8f467b;hb=refs%2Fchanges%2F69%2F10469%2F6;hpb=79e40f41887cbc1e56f4b7c3518314952985fa51 diff --git a/osm_nbi/admin_topics.py b/osm_nbi/admin_topics.py index ada9c7b..786d237 100644 --- a/osm_nbi/admin_topics.py +++ b/osm_nbi/admin_topics.py @@ -18,14 +18,35 @@ from uuid import uuid4 from hashlib import sha256 from http import HTTPStatus from time import time -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, \ - validate_input, ValidationError, is_valid_uuid # To check that User/Project Names don't look like UUIDs +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, + vca_new_schema, + vca_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 +import copy __author__ = "Alfonso Tierno " @@ -55,15 +76,28 @@ class UserTopic(BaseTopic): def check_conflict_on_new(self, session, indata): # check username not exists - if self.db.get_one(self.topic, {"username": indata.get("username")}, fail_on_empty=False, fail_on_more=False): - raise EngineException("username '{}' exists".format(indata["username"]), HTTPStatus.CONFLICT) + if self.db.get_one( + self.topic, + {"username": indata.get("username")}, + fail_on_empty=False, + fail_on_more=False, + ): + raise EngineException( + "username '{}' exists".format(indata["username"]), HTTPStatus.CONFLICT + ) # check projects if not session["force"]: for p in indata.get("projects") or []: # To allow project addressing by Name as well as ID - if not self.db.get_one("projects", {BaseTopic.id_field("projects", p): p}, fail_on_empty=False, - fail_on_more=False): - raise EngineException("project '{}' does not exist".format(p), HTTPStatus.CONFLICT) + if not self.db.get_one( + "projects", + {BaseTopic.id_field("projects", p): p}, + fail_on_empty=False, + fail_on_more=False, + ): + raise EngineException( + "project '{}' does not exist".format(p), HTTPStatus.CONFLICT + ) def check_conflict_on_del(self, session, _id, db_content): """ @@ -74,7 +108,9 @@ class UserTopic(BaseTopic): :return: None if ok or raises EngineException with the conflict """ if _id == session["username"]: - raise EngineException("You cannot delete your own user", http_code=HTTPStatus.CONFLICT) + raise EngineException( + "You cannot delete your own user", http_code=HTTPStatus.CONFLICT + ) @staticmethod def format_on_new(content, project_id=None, make_public=False): @@ -84,9 +120,13 @@ class UserTopic(BaseTopic): salt = uuid4().hex content["_admin"]["salt"] = salt if content.get("password"): - content["password"] = sha256(content["password"].encode('utf-8') + salt.encode('utf-8')).hexdigest() + content["password"] = sha256( + content["password"].encode("utf-8") + salt.encode("utf-8") + ).hexdigest() if content.get("project_role_mappings"): - projects = [mapping["project"] for mapping in content["project_role_mappings"]] + projects = [ + mapping["project"] for mapping in content["project_role_mappings"] + ] if content.get("projects"): content["projects"] += projects @@ -99,29 +139,42 @@ class UserTopic(BaseTopic): if edit_content.get("password"): salt = uuid4().hex final_content["_admin"]["salt"] = salt - final_content["password"] = sha256(edit_content["password"].encode('utf-8') + - salt.encode('utf-8')).hexdigest() + final_content["password"] = sha256( + edit_content["password"].encode("utf-8") + salt.encode("utf-8") + ).hexdigest() return None def edit(self, session, _id, indata=None, kwargs=None, content=None): if not session["admin"]: - raise EngineException("needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED) + raise EngineException( + "needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED + ) # Names that look like UUIDs are not allowed name = (indata if indata else kwargs).get("username") if is_valid_uuid(name): - raise EngineException("Usernames that look like UUIDs are not allowed", - http_code=HTTPStatus.UNPROCESSABLE_ENTITY) - return BaseTopic.edit(self, session, _id, indata=indata, kwargs=kwargs, content=content) + raise EngineException( + "Usernames that look like UUIDs are not allowed", + http_code=HTTPStatus.UNPROCESSABLE_ENTITY, + ) + return BaseTopic.edit( + self, session, _id, indata=indata, kwargs=kwargs, content=content + ) def new(self, rollback, session, indata=None, kwargs=None, headers=None): if not session["admin"]: - raise EngineException("needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED) + raise EngineException( + "needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED + ) # Names that look like UUIDs are not allowed name = indata["username"] if indata else kwargs["username"] if is_valid_uuid(name): - raise EngineException("Usernames that look like UUIDs are not allowed", - http_code=HTTPStatus.UNPROCESSABLE_ENTITY) - return BaseTopic.new(self, rollback, session, indata=indata, kwargs=kwargs, headers=headers) + raise EngineException( + "Usernames that look like UUIDs are not allowed", + http_code=HTTPStatus.UNPROCESSABLE_ENTITY, + ) + return BaseTopic.new( + self, rollback, session, indata=indata, kwargs=kwargs, headers=headers + ) class ProjectTopic(BaseTopic): @@ -151,8 +204,15 @@ class ProjectTopic(BaseTopic): if not indata.get("name"): raise EngineException("missing 'name'") # check name not exists - if self.db.get_one(self.topic, {"name": indata.get("name")}, fail_on_empty=False, fail_on_more=False): - raise EngineException("name '{}' exists".format(indata["name"]), HTTPStatus.CONFLICT) + if self.db.get_one( + self.topic, + {"name": indata.get("name")}, + fail_on_empty=False, + fail_on_more=False, + ): + raise EngineException( + "name '{}' exists".format(indata["name"]), HTTPStatus.CONFLICT + ) @staticmethod def format_on_new(content, project_id=None, make_public=False): @@ -169,38 +229,58 @@ class ProjectTopic(BaseTopic): :return: None if ok or raises EngineException with the conflict """ if _id in session["project_id"]: - raise EngineException("You cannot delete your own project", http_code=HTTPStatus.CONFLICT) + raise EngineException( + "You cannot delete your own project", http_code=HTTPStatus.CONFLICT + ) if session["force"]: return _filter = {"projects": _id} if self.db.get_list("users", _filter): - raise EngineException("There is some USER that contains this project", http_code=HTTPStatus.CONFLICT) + raise EngineException( + "There is some USER that contains this project", + http_code=HTTPStatus.CONFLICT, + ) def edit(self, session, _id, indata=None, kwargs=None, content=None): if not session["admin"]: - raise EngineException("needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED) + raise EngineException( + "needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED + ) # Names that look like UUIDs are not allowed name = (indata if indata else kwargs).get("name") if is_valid_uuid(name): - raise EngineException("Project names that look like UUIDs are not allowed", - http_code=HTTPStatus.UNPROCESSABLE_ENTITY) - return BaseTopic.edit(self, session, _id, indata=indata, kwargs=kwargs, content=content) + raise EngineException( + "Project names that look like UUIDs are not allowed", + http_code=HTTPStatus.UNPROCESSABLE_ENTITY, + ) + return BaseTopic.edit( + self, session, _id, indata=indata, kwargs=kwargs, content=content + ) def new(self, rollback, session, indata=None, kwargs=None, headers=None): if not session["admin"]: - raise EngineException("needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED) + raise EngineException( + "needed admin privileges", http_code=HTTPStatus.UNAUTHORIZED + ) # Names that look like UUIDs are not allowed name = indata["name"] if indata else kwargs["name"] if is_valid_uuid(name): - raise EngineException("Project names that look like UUIDs are not allowed", - http_code=HTTPStatus.UNPROCESSABLE_ENTITY) - return BaseTopic.new(self, rollback, session, indata=indata, kwargs=kwargs, headers=headers) + raise EngineException( + "Project names that look like UUIDs are not allowed", + http_code=HTTPStatus.UNPROCESSABLE_ENTITY, + ) + return BaseTopic.new( + self, rollback, session, indata=indata, kwargs=kwargs, headers=headers + ) 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 - password_to_encrypt = "" # key that contains a password + + config_to_encrypt = ( + {} + ) # what keys at config must be encrypted because contains passwords + password_to_encrypt = "" # key that contains a password @staticmethod def _create_operation(op_type, params=None): @@ -241,6 +321,8 @@ class CommonVimWimSdn(BaseTopic): if not session["force"] and edit_content.get("name"): self.check_unique_name(session, edit_content["name"], _id=_id) + return final_content + def format_on_edit(self, final_content, edit_content): """ Modifies final_content inserting admin information upon edition @@ -254,21 +336,29 @@ class CommonVimWimSdn(BaseTopic): schema_version = final_content.get("schema_version") if schema_version: if edit_content.get(self.password_to_encrypt): - final_content[self.password_to_encrypt] = self.db.encrypt(edit_content[self.password_to_encrypt], - schema_version=schema_version, - salt=final_content["_id"]) - config_to_encrypt_keys = self.config_to_encrypt.get(schema_version) or self.config_to_encrypt.get("default") + final_content[self.password_to_encrypt] = self.db.encrypt( + edit_content[self.password_to_encrypt], + schema_version=schema_version, + salt=final_content["_id"], + ) + 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, - salt=final_content["_id"]) + final_content["config"][p] = self.db.encrypt( + edit_content["config"][p], + schema_version=schema_version, + salt=final_content["_id"], + ) # create edit operation final_content["_admin"]["operations"].append(self._create_operation("edit")) - return "{}:{}".format(final_content["_id"], len(final_content["_admin"]["operations"]) - 1) + return "{}:{}".format( + final_content["_id"], len(final_content["_admin"]["operations"]) - 1 + ) def format_on_new(self, content, project_id=None, make_public=False): """ @@ -283,16 +373,22 @@ class CommonVimWimSdn(BaseTopic): # 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"]) - config_to_encrypt_keys = self.config_to_encrypt.get(schema_version) or self.config_to_encrypt.get("default") + content[self.password_to_encrypt] = self.db.encrypt( + content[self.password_to_encrypt], + schema_version=schema_version, + salt=content["_id"], + ) + 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, - salt=content["_id"]) + content["config"][p] = self.db.encrypt( + content["config"][p], + schema_version=schema_version, + salt=content["_id"], + ) content["_admin"]["operationalState"] = "PROCESSING" @@ -302,12 +398,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 """ @@ -319,42 +416,67 @@ 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 - self.db.set_one(self.topic, {"_id": _id}, - update_dict=update_dict, - push={"_admin.operations": self._create_operation("delete")} - ) + 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")}, + ) # 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}) + op_id = "{}:{}".format( + db_content["_id"], len(db_content["_admin"]["operations"]) + ) + self._send_msg( + "delete", {"_id": _id, "op_id": op_id}, not_send_msg=not_send_msg + ) return op_id @@ -365,8 +487,33 @@ class VimAccountTopic(CommonVimWimSdn): schema_edit = vim_account_edit_schema multiproject = True password_to_encrypt = "vim_password" - config_to_encrypt = {"1.1": ("admin_password", "nsx_password", "vcenter_password"), - "default": ("admin_password", "nsx_password", "vcenter_password", "vrops_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): @@ -382,12 +529,34 @@ class WimAccountTopic(CommonVimWimSdn): 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 = {} + 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" @@ -400,18 +569,136 @@ class K8sClusterTopic(CommonVimWimSdn): 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"]) + 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"]) + 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): + final_content = super(CommonVimWimSdn, self).check_conflict_on_edit( + session, final_content, edit_content, _id + ) + final_content = 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] + return final_content + + 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 VcaTopic(CommonVimWimSdn): + topic = "vca" + topic_msg = "vca" + schema_new = vca_new_schema + schema_edit = vca_edit_schema + multiproject = True + password_to_encrypt = None + + def format_on_new(self, content, project_id=None, make_public=False): + oid = super().format_on_new(content, project_id, make_public) + content["schema_version"] = schema_version = "1.11" + for key in ["secret", "cacert"]: + content[key] = self.db.encrypt( + content[key], schema_version=schema_version, salt=content["_id"] + ) + return oid + + def format_on_edit(self, final_content, edit_content): + oid = super().format_on_edit(final_content, edit_content) + schema_version = final_content.get("schema_version") + for key in ["secret", "cacert"]: + if key in edit_content: + final_content[key] = self.db.encrypt( + edit_content[key], + schema_version=schema_version, + salt=final_content["_id"], + ) + return oid + + 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 = {"vca": _id} + if session["project_id"]: + filter_q["_admin.projects_read.cont"] = session["project_id"] + if self.db.get_list("vim_accounts", filter_q): + raise EngineException( + "There is at least one VIM account using this vca", + http_code=HTTPStatus.CONFLICT, + ) + super().check_conflict_on_del(session, _id, db_content) + class K8sRepoTopic(CommonVimWimSdn): topic = "k8srepos" @@ -422,10 +709,50 @@ class K8sRepoTopic(CommonVimWimSdn): 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): # topic = "users" - # topic_msg = "users" + topic_msg = "users" schema_new = user_new_schema schema_edit = user_edit_schema @@ -443,12 +770,16 @@ class UserTopicAuth(UserTopic): """ username = indata.get("username") if is_valid_uuid(username): - raise EngineException("username '{}' cannot have a uuid format".format(username), - HTTPStatus.UNPROCESSABLE_ENTITY) + raise EngineException( + "username '{}' cannot have a uuid format".format(username), + HTTPStatus.UNPROCESSABLE_ENTITY, + ) # Check that username is not used, regardless keystone already checks this if self.auth.get_user_list(filter_q={"name": username}): - raise EngineException("username '{}' is already used".format(username), HTTPStatus.CONFLICT) + raise EngineException( + "username '{}' is already used".format(username), HTTPStatus.CONFLICT + ) if "projects" in indata.keys(): # convert to new format project_role_mappings @@ -456,7 +787,9 @@ class UserTopicAuth(UserTopic): if not role: role = self.auth.get_role_list() if not role: - raise AuthconnNotFoundException("Can't find default role for user '{}'".format(username)) + raise AuthconnNotFoundException( + "Can't find default role for user '{}'".format(username) + ) rid = role[0]["_id"] if not indata.get("project_role_mappings"): indata["project_role_mappings"] = [] @@ -482,19 +815,31 @@ class UserTopicAuth(UserTopic): if "username" in edit_content: username = edit_content.get("username") if is_valid_uuid(username): - raise EngineException("username '{}' cannot have an uuid format".format(username), - HTTPStatus.UNPROCESSABLE_ENTITY) + raise EngineException( + "username '{}' cannot have an uuid format".format(username), + HTTPStatus.UNPROCESSABLE_ENTITY, + ) # Check that username is not used, regardless keystone already checks this if self.auth.get_user_list(filter_q={"name": username}): - raise EngineException("username '{}' is already used".format(username), HTTPStatus.CONFLICT) + raise EngineException( + "username '{}' is already used".format(username), + HTTPStatus.CONFLICT, + ) if final_content["username"] == "admin": for mapping in edit_content.get("remove_project_role_mappings", ()): - if mapping["project"] == "admin" and mapping.get("role") in (None, "system_admin"): + if mapping["project"] == "admin" and mapping.get("role") in ( + None, + "system_admin", + ): # TODO make this also available for project id and role id - raise EngineException("You cannot remove system_admin role from admin user", - http_code=HTTPStatus.FORBIDDEN) + raise EngineException( + "You cannot remove system_admin role from admin user", + http_code=HTTPStatus.FORBIDDEN, + ) + + return final_content def check_conflict_on_del(self, session, _id, db_content): """ @@ -505,7 +850,9 @@ class UserTopicAuth(UserTopic): :return: None if ok or raises EngineException with the conflict """ if db_content["username"] == session["username"]: - raise EngineException("You cannot delete your own login user ", http_code=HTTPStatus.CONFLICT) + raise EngineException( + "You cannot delete your own login user ", http_code=HTTPStatus.CONFLICT + ) # TODO: Check that user is not logged in ? How? (Would require listing current tokens) @staticmethod @@ -519,10 +866,14 @@ class UserTopicAuth(UserTopic): if "projects" in content: for project in content["projects"]: for role in project["roles"]: - project_role_mappings.append({"project": project["_id"], - "project_name": project["name"], - "role": role["_id"], - "role_name": role["name"]}) + project_role_mappings.append( + { + "project": project["_id"], + "project_name": project["name"], + "role": role["_id"], + "role_name": role["name"], + } + ) del content["projects"] content["project_role_mappings"] = project_role_mappings @@ -566,29 +917,35 @@ class UserTopicAuth(UserTopic): rollback.append({"topic": self.topic, "_id": _id}) # del content["password"] - # self._send_msg("created", content) + self._send_msg("created", content, not_send_msg=None) return _id, None except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) - def show(self, session, _id): + def show(self, session, _id, filter_q=None, 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 filter_q: dict: query parameter + :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} + filter_q = {"username": _id} # users = self.auth.get_user_list(filter_q) - users = self.list(session, filter_q) # To allow default filtering (Bug 853) + 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): """ @@ -607,29 +964,42 @@ 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) - self.check_conflict_on_edit(session, content, indata, _id=_id) + indata = self._validate_input_edit(indata, content, force=session["force"]) + content = self.check_conflict_on_edit(session, content, indata, _id=_id) # self.format_on_edit(content, indata) - if not ("password" in indata or "username" in indata or indata.get("remove_project_role_mappings") or - indata.get("add_project_role_mappings") or indata.get("project_role_mappings") or - indata.get("projects") or indata.get("add_projects")): + if not ( + "password" in indata + or "username" in indata + or indata.get("remove_project_role_mappings") + or indata.get("add_project_role_mappings") + or indata.get("project_role_mappings") + or indata.get("projects") + or indata.get("add_projects") + ): return _id - if indata.get("project_role_mappings") \ - and (indata.get("remove_project_role_mappings") or indata.get("add_project_role_mappings")): - raise EngineException("Option 'project_role_mappings' is incompatible with 'add_project_role_mappings" - "' or 'remove_project_role_mappings'", http_code=HTTPStatus.BAD_REQUEST) + if indata.get("project_role_mappings") and ( + indata.get("remove_project_role_mappings") + or indata.get("add_project_role_mappings") + ): + raise EngineException( + "Option 'project_role_mappings' is incompatible with 'add_project_role_mappings" + "' or 'remove_project_role_mappings'", + http_code=HTTPStatus.BAD_REQUEST, + ) if indata.get("projects") or indata.get("add_projects"): role = self.auth.get_role_list({"name": "project_admin"}) if not role: role = self.auth.get_role_list() if not role: - raise AuthconnNotFoundException("Can't find a default role for user '{}'" - .format(content["username"])) + raise AuthconnNotFoundException( + "Can't find a default role for user '{}'".format( + content["username"] + ) + ) rid = role[0]["_id"] if "add_project_role_mappings" not in indata: indata["add_project_role_mappings"] = [] @@ -639,12 +1009,18 @@ class UserTopicAuth(UserTopic): # backward compatible for k, v in indata["projects"].items(): if k.startswith("$") and v is None: - indata["remove_project_role_mappings"].append({"project": k[1:]}) + indata["remove_project_role_mappings"].append( + {"project": k[1:]} + ) elif k.startswith("$+"): - indata["add_project_role_mappings"].append({"project": v, "role": rid}) + indata["add_project_role_mappings"].append( + {"project": v, "role": rid} + ) del indata["projects"] for proj in indata.get("projects", []) + indata.get("add_projects", []): - indata["add_project_role_mappings"].append({"project": proj, "role": rid}) + indata["add_project_role_mappings"].append( + {"project": proj, "role": rid} + ) # user = self.show(session, _id) # Already in 'content' original_mapping = content["project_role_mappings"] @@ -655,17 +1031,28 @@ class UserTopicAuth(UserTopic): # remove for to_remove in indata.get("remove_project_role_mappings", ()): for mapping in original_mapping: - if to_remove["project"] in (mapping["project"], mapping["project_name"]): - if not to_remove.get("role") or to_remove["role"] in (mapping["role"], mapping["role_name"]): + if to_remove["project"] in ( + mapping["project"], + mapping["project_name"], + ): + if not to_remove.get("role") or to_remove["role"] in ( + mapping["role"], + mapping["role_name"], + ): mappings_to_remove.append(mapping) # add for to_add in indata.get("add_project_role_mappings", ()): for mapping in original_mapping: - if to_add["project"] in (mapping["project"], mapping["project_name"]) and \ - to_add["role"] in (mapping["role"], mapping["role_name"]): - - if mapping in mappings_to_remove: # do not remove + if to_add["project"] in ( + mapping["project"], + mapping["project_name"], + ) and to_add["role"] in ( + mapping["role"], + mapping["role_name"], + ): + + if mapping in mappings_to_remove: # do not remove mappings_to_remove.remove(mapping) break # do not add, it is already at user else: @@ -677,9 +1064,14 @@ class UserTopicAuth(UserTopic): if indata.get("project_role_mappings"): for to_set in indata["project_role_mappings"]: for mapping in original_mapping: - if to_set["project"] in (mapping["project"], mapping["project_name"]) and \ - to_set["role"] in (mapping["role"], mapping["role_name"]): - if mapping in mappings_to_remove: # do not remove + if to_set["project"] in ( + mapping["project"], + mapping["project_name"], + ) and to_set["role"] in ( + mapping["role"], + mapping["role_name"], + ): + if mapping in mappings_to_remove: # do not remove mappings_to_remove.remove(mapping) break # do not add, it is already at user else: @@ -688,37 +1080,52 @@ class UserTopicAuth(UserTopic): mappings_to_add.append({"project": pid, "role": rid}) for mapping in original_mapping: for to_set in indata["project_role_mappings"]: - if to_set["project"] in (mapping["project"], mapping["project_name"]) and \ - to_set["role"] in (mapping["role"], mapping["role_name"]): + if to_set["project"] in ( + mapping["project"], + mapping["project_name"], + ) and to_set["role"] in ( + mapping["role"], + mapping["role_name"], + ): break else: # delete - if mapping not in mappings_to_remove: # do not remove + if mapping not in mappings_to_remove: # do not remove mappings_to_remove.append(mapping) - self.auth.update_user({"_id": _id, "username": indata.get("username"), "password": indata.get("password"), - "add_project_role_mappings": mappings_to_add, - "remove_project_role_mappings": mappings_to_remove - }) + self.auth.update_user( + { + "_id": _id, + "username": indata.get("username"), + "password": indata.get("password"), + "add_project_role_mappings": mappings_to_add, + "remove_project_role_mappings": mappings_to_remove, + } + ) + data_to_send = {"_id": _id, "changes": indata} + self._send_msg("edited", data_to_send, not_send_msg=None) # return _id 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. """ 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"]] + 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 @@ -726,6 +1133,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 @@ -734,13 +1142,14 @@ class UserTopicAuth(UserTopic): self.check_conflict_on_del(session, uid, user) if not dry_run: v = self.auth.delete_user(uid) + self._send_msg("deleted", user, not_send_msg=not_send_msg) return v return None class ProjectTopicAuth(ProjectTopic): # topic = "projects" - # topic_msg = "projects" + topic_msg = "project" schema_new = project_new_schema schema_edit = project_edit_schema @@ -758,13 +1167,17 @@ class ProjectTopicAuth(ProjectTopic): """ project_name = indata.get("name") if is_valid_uuid(project_name): - raise EngineException("project name '{}' cannot have an uuid format".format(project_name), - HTTPStatus.UNPROCESSABLE_ENTITY) + raise EngineException( + "project name '{}' cannot have an uuid format".format(project_name), + HTTPStatus.UNPROCESSABLE_ENTITY, + ) project_list = self.auth.get_project_list(filter_q={"name": project_name}) if project_list: - raise EngineException("project '{}' exists".format(project_name), HTTPStatus.CONFLICT) + raise EngineException( + "project '{}' exists".format(project_name), HTTPStatus.CONFLICT + ) def check_conflict_on_edit(self, session, final_content, edit_content, _id): """ @@ -780,15 +1193,25 @@ 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), - HTTPStatus.UNPROCESSABLE_ENTITY) + 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) + raise EngineException( + "You cannot rename project 'admin'", http_code=HTTPStatus.CONFLICT + ) # Check that project name is not used, regardless keystone already checks this - 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) + 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, + ) + return final_content def check_conflict_on_del(self, session, _id, db_content): """ @@ -802,23 +1225,39 @@ class ProjectTopicAuth(ProjectTopic): def check_rw_projects(topic, title, id_field): for desc in self.db.get_list(topic): - if _id in desc["_admin"]["projects_read"] + desc["_admin"]["projects_write"]: - raise EngineException("Project '{}' ({}) is being used by {} '{}'" - .format(db_content["name"], _id, title, desc[id_field]), HTTPStatus.CONFLICT) + if ( + _id + in desc["_admin"]["projects_read"] + + desc["_admin"]["projects_write"] + ): + raise EngineException( + "Project '{}' ({}) is being used by {} '{}'".format( + db_content["name"], _id, title, desc[id_field] + ), + HTTPStatus.CONFLICT, + ) if _id in session["project_id"]: - raise EngineException("You cannot delete your own project", http_code=HTTPStatus.CONFLICT) + raise EngineException( + "You cannot delete your own project", http_code=HTTPStatus.CONFLICT + ) if db_content["name"] == "admin": - raise EngineException("You cannot delete project 'admin'", http_code=HTTPStatus.CONFLICT) + raise EngineException( + "You cannot delete project 'admin'", http_code=HTTPStatus.CONFLICT + ) # If any user is using this project, raise CONFLICT exception if not session["force"]: for user in self.auth.get_user_list(): for prm in user.get("project_role_mappings"): if prm["project"] == _id: - raise EngineException("Project '{}' ({}) is being used by user '{}'" - .format(db_content["name"], _id, user["username"]), HTTPStatus.CONFLICT) + raise EngineException( + "Project '{}' ({}) is being used by user '{}'".format( + db_content["name"], _id, user["username"] + ), + HTTPStatus.CONFLICT, + ) # If any VNFD, NSD, NST, PDU, etc. is using this project, raise CONFLICT exception if not session["force"]: @@ -847,26 +1286,30 @@ class ProjectTopicAuth(ProjectTopic): BaseTopic._update_input_with_kwargs(content, kwargs) content = self._validate_input_new(content, session["force"]) self.check_conflict_on_new(session, content) - self.format_on_new(content, project_id=session["project_id"], make_public=session["public"]) + 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("created", content) + self._send_msg("created", content, not_send_msg=None) return _id, None except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) - def show(self, session, _id): + def show(self, session, _id, filter_q=None, 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 filter_q: dict: query parameter + :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.list(session, filter_q) # To allow default filtering (Bug 853) + projects = self.list(session, filter_q) # To allow default filtering (Bug 853) if len(projects) == 1: return projects[0] elif len(projects) > 1: @@ -874,7 +1317,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 @@ -890,13 +1333,14 @@ class ProjectTopicAuth(ProjectTopic): 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 @@ -905,6 +1349,7 @@ class ProjectTopicAuth(ProjectTopic): self.check_conflict_on_del(session, pid, proj) if not dry_run: v = self.auth.delete_project(pid) + self._send_msg("deleted", proj, not_send_msg=None) return v return None @@ -925,30 +1370,31 @@ 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) - self.check_conflict_on_edit(session, content, indata, _id=_id) + indata = self._validate_input_edit(indata, content, force=session["force"]) + content = self.check_conflict_on_edit(session, content, indata, _id=_id) self.format_on_edit(content, indata) - + content_original = copy.deepcopy(content) deep_update_rfc7396(content, indata) self.auth.update_project(content["_id"], content) + proj_data = {"_id": _id, "changes": indata, "original": content_original} + self._send_msg("edited", proj_data, not_send_msg=None) except ValidationError as e: raise EngineException(e, HTTPStatus.UNPROCESSABLE_ENTITY) class RoleTopicAuth(BaseTopic): topic = "roles" - topic_msg = None # "roles" + topic_msg = None # "roles" schema_new = roles_new_schema schema_edit = roles_edit_schema multiproject = False - def __init__(self, db, fs, msg, auth, ops): + def __init__(self, db, fs, msg, auth): BaseTopic.__init__(self, db, fs, msg, auth) # self.auth = auth - self.operations = ops + self.operations = auth.role_permissions # self.topic = "roles_operations" if isinstance(auth, AuthconnKeystone) else "roles" @staticmethod @@ -970,9 +1416,16 @@ 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): @@ -989,7 +1442,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. @@ -1014,13 +1467,17 @@ class RoleTopicAuth(BaseTopic): # 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) + 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): if self.auth.get_role_list({"name": name}): - raise EngineException("role name '{}' exists".format(name), HTTPStatus.CONFLICT) + raise EngineException( + "role name '{}' exists".format(name), HTTPStatus.CONFLICT + ) def check_conflict_on_edit(self, session, final_content, edit_content, _id): """ @@ -1040,13 +1497,18 @@ class RoleTopicAuth(BaseTopic): # 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) + 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) + raise EngineException( + "You cannot rename role '{}'".format(role["name"]), + http_code=HTTPStatus.FORBIDDEN, + ) # check name not exists if "name" in edit_content: @@ -1054,7 +1516,11 @@ class RoleTopicAuth(BaseTopic): # if self.db.get_one(self.topic, {"name":role_name,"_id.ne":_id}, fail_on_empty=False, fail_on_more=False): roles = self.auth.get_role_list({"name": role_name}) if roles and roles[0][BaseTopic.id_field("roles", _id)] != _id: - raise EngineException("role name '{}' exists".format(role_name), HTTPStatus.CONFLICT) + raise EngineException( + "role name '{}' exists".format(role_name), HTTPStatus.CONFLICT + ) + + return final_content def check_conflict_on_del(self, session, _id, db_content): """ @@ -1067,17 +1533,25 @@ class RoleTopicAuth(BaseTopic): """ role = self.auth.get_role(_id) if role["name"] in ["system_admin", "project_admin"]: - raise EngineException("You cannot delete role '{}'".format(role["name"]), http_code=HTTPStatus.FORBIDDEN) + 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 ? + def format_on_new(content, project_id=None, make_public=False): # TO BE REMOVED ? """ Modifies content descriptor to include _admin @@ -1122,24 +1596,30 @@ class RoleTopicAuth(BaseTopic): final_content["permissions"]["admin"] = False return None - def show(self, session, _id): + def show(self, session, _id, filter_q=None, 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 filter_q: dict: query parameter + :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.list(session, filter_q) # To allow default filtering (Bug 853) + 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)) + 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)) + 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 @@ -1173,32 +1653,39 @@ class RoleTopicAuth(BaseTopic): self._update_input_with_kwargs(content, kwargs) content = self._validate_input_new(content, session["force"]) self.check_conflict_on_new(session, content) - self.format_on_new(content, project_id=session["project_id"], make_public=session["public"]) + self.format_on_new( + content, project_id=session["project_id"], make_public=session["public"] + ) # role_name = content["name"] rid = self.auth.create_role(content) content["_id"] = rid # _id = self.db.create(self.topic, content) rollback.append({"topic": self.topic, "_id": rid}) - # self._send_msg("created", 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} roles = self.auth.get_role_list(filter_q) if not roles: - raise AuthconnNotFoundException("Not found any role with filter {}".format(filter_q)) + 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)) + raise AuthconnConflictException( + "Found more than one role with filter {}".format(filter_q) + ) rid = roles[0]["_id"] self.check_conflict_on_del(session, rid, None) # filter_q = {"_id": _id} @@ -1223,11 +1710,11 @@ 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) + content = self.check_conflict_on_edit(session, content, indata, _id=_id) self.format_on_edit(content, indata) self.auth.update_role(content) except ValidationError as e: