Feature-9904: Enhancing NG-UI to enable Juju operational view dashboard
[osm/NBI.git] / osm_nbi / engine.py
index 14dab56..cb27414 100644 (file)
 # limitations under the License.
 
 import logging
-from osm_common import dbmongo, dbmemory, fslocal, msglocal, msgkafka, version as common_version
+
+# import yaml
+from osm_common import (
+    dbmongo,
+    dbmemory,
+    fslocal,
+    fsmongo,
+    msglocal,
+    msgkafka,
+    version as common_version,
+)
 from osm_common.dbbase import DbException
 from osm_common.fsbase import FsException
 from osm_common.msgbase import MsgException
 from http import HTTPStatus
-from base_topic import EngineException, versiontuple
-from admin_topics import UserTopic, ProjectTopic, VimAccountTopic, SdnTopic
-from descriptor_topics import VnfdTopic, NsdTopic, PduTopic, NstTopic
-from instance_topics import NsrTopic, VnfrTopic, NsLcmOpTopic, NsiTopic, NsiLcmOpTopic
+
+from osm_nbi.authconn_keystone import AuthconnKeystone
+from osm_nbi.authconn_internal import AuthconnInternal
+from osm_nbi.authconn_tacacs import AuthconnTacacs
+from osm_nbi.base_topic import EngineException, versiontuple
+from osm_nbi.admin_topics import VimAccountTopic, WimAccountTopic, SdnTopic
+from osm_nbi.admin_topics import K8sClusterTopic, K8sRepoTopic, OsmRepoTopic
+from osm_nbi.admin_topics import VcaTopic
+from osm_nbi.admin_topics import UserTopicAuth, ProjectTopicAuth, RoleTopicAuth
+from osm_nbi.descriptor_topics import (
+    VnfdTopic,
+    NsdTopic,
+    PduTopic,
+    NstTopic,
+    VnfPkgOpTopic,
+)
+from osm_nbi.instance_topics import (
+    NsrTopic,
+    VnfrTopic,
+    NsLcmOpTopic,
+    NsiTopic,
+    NsiLcmOpTopic,
+)
+from osm_nbi.pmjobs_topics import PmJobsTopic
+from osm_nbi.subscription_topics import NslcmSubscriptionsTopic
 from base64 import b64encode
-from os import urandom
+from os import urandom  # , path
+from threading import Lock
 
 __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
-min_common_version = "0.1.8"
+min_common_version = "0.1.16"
 
 
 class Engine(object):
@@ -40,21 +72,42 @@ class Engine(object):
         "vnfrs": VnfrTopic,
         "nslcmops": NsLcmOpTopic,
         "vim_accounts": VimAccountTopic,
+        "wim_accounts": WimAccountTopic,
         "sdns": SdnTopic,
-        "users": UserTopic,
-        "projects": ProjectTopic,
+        "k8sclusters": K8sClusterTopic,
+        "vca": VcaTopic,
+        "k8srepos": K8sRepoTopic,
+        "osmrepos": OsmRepoTopic,
+        "users": UserTopicAuth,  # Valid for both internal and keystone authentication backends
+        "projects": ProjectTopicAuth,  # Valid for both internal and keystone authentication backends
+        "roles": RoleTopicAuth,  # Valid for both internal and keystone authentication backends
         "nsis": NsiTopic,
-        "nsilcmops": NsiLcmOpTopic
+        "nsilcmops": NsiLcmOpTopic,
+        "vnfpkgops": VnfPkgOpTopic,
+        "nslcm_subscriptions": NslcmSubscriptionsTopic,
         # [NEW_TOPIC]: add an entry here
+        # "pm_jobs": PmJobsTopic will be added manually because it needs other parameters
+    }
+
+    map_target_version_to_int = {
+        "1.0": 1000,
+        "1.1": 1001,
+        "1.2": 1002,
+        # Add new versions here
     }
 
-    def __init__(self):
+    def __init__(self, authenticator):
         self.db = None
         self.fs = None
         self.msg = None
+        self.authconn = None
         self.config = None
+        # self.operations = None
         self.logger = logging.getLogger("nbi.engine")
         self.map_topic = {}
+        self.write_lock = None
+        # self.token_cache = token_cache
+        self.authenticator = authenticator
 
     def start(self, config):
         """
@@ -65,8 +118,11 @@ class Engine(object):
         self.config = config
         # check right version of common
         if versiontuple(common_version) < versiontuple(min_common_version):
-            raise EngineException("Not compatible osm/common version '{}'. Needed '{}' or higher".format(
-                common_version, min_common_version))
+            raise EngineException(
+                "Not compatible osm/common version '{}'. Needed '{}' or higher".format(
+                    common_version, min_common_version
+                )
+            )
 
         try:
             if not self.db:
@@ -77,15 +133,24 @@ class Engine(object):
                     self.db = dbmemory.DbMemory()
                     self.db.db_connect(config["database"])
                 else:
-                    raise EngineException("Invalid configuration param '{}' at '[database]':'driver'".format(
-                        config["database"]["driver"]))
+                    raise EngineException(
+                        "Invalid configuration param '{}' at '[database]':'driver'".format(
+                            config["database"]["driver"]
+                        )
+                    )
             if not self.fs:
                 if config["storage"]["driver"] == "local":
                     self.fs = fslocal.FsLocal()
                     self.fs.fs_connect(config["storage"])
+                elif config["storage"]["driver"] == "mongo":
+                    self.fs = fsmongo.FsMongo()
+                    self.fs.fs_connect(config["storage"])
                 else:
-                    raise EngineException("Invalid configuration param '{}' at '[storage]':'driver'".format(
-                        config["storage"]["driver"]))
+                    raise EngineException(
+                        "Invalid configuration param '{}' at '[storage]':'driver'".format(
+                            config["storage"]["driver"]
+                        )
+                    )
             if not self.msg:
                 if config["message"]["driver"] == "local":
                     self.msg = msglocal.MsgLocal()
@@ -94,12 +159,69 @@ class Engine(object):
                     self.msg = msgkafka.MsgKafka()
                     self.msg.connect(config["message"])
                 else:
-                    raise EngineException("Invalid configuration param '{}' at '[message]':'driver'".format(
-                        config["storage"]["driver"]))
+                    raise EngineException(
+                        "Invalid configuration param '{}' at '[message]':'driver'".format(
+                            config["message"]["driver"]
+                        )
+                    )
+            if not self.authconn:
+                if config["authentication"]["backend"] == "keystone":
+                    self.authconn = AuthconnKeystone(
+                        config["authentication"],
+                        self.db,
+                        self.authenticator.role_permissions,
+                    )
+                elif config["authentication"]["backend"] == "tacacs":
+                    self.authconn = AuthconnTacacs(
+                        config["authentication"],
+                        self.db,
+                        self.authenticator.role_permissions,
+                    )
+                else:
+                    self.authconn = AuthconnInternal(
+                        config["authentication"],
+                        self.db,
+                        self.authenticator.role_permissions,
+                    )
+            # if not self.operations:
+            #     if "resources_to_operations" in config["rbac"]:
+            #         resources_to_operations_file = config["rbac"]["resources_to_operations"]
+            #     else:
+            #         possible_paths = (
+            #             __file__[:__file__.rfind("engine.py")] + "resources_to_operations.yml",
+            #             "./resources_to_operations.yml"
+            #         )
+            #         for config_file in possible_paths:
+            #             if path.isfile(config_file):
+            #                 resources_to_operations_file = config_file
+            #                 break
+            #         if not resources_to_operations_file:
+            #             raise EngineException("Invalid permission configuration:"
+            #                 "resources_to_operations file missing")
+            #
+            #     with open(resources_to_operations_file, 'r') as f:
+            #         resources_to_operations = yaml.load(f, Loader=yaml.Loader)
+            #
+            #     self.operations = []
+            #
+            #     for _, value in resources_to_operations["resources_to_operations"].items():
+            #         if value not in self.operations:
+            #             self.operations += [value]
 
+            self.write_lock = Lock()
             # create one class per topic
             for topic, topic_class in self.map_from_topic_to_class.items():
-                self.map_topic[topic] = topic_class(self.db, self.fs, self.msg)
+                # if self.auth and topic_class in (UserTopicAuth, ProjectTopicAuth):
+                #     self.map_topic[topic] = topic_class(self.db, self.fs, self.msg, self.auth)
+                self.map_topic[topic] = topic_class(
+                    self.db, self.fs, self.msg, self.authconn
+                )
+
+            self.map_topic["pm_jobs"] = PmJobsTopic(
+                self.db,
+                config["prometheus"].get("host"),
+                config["prometheus"].get("port"),
+            )
         except (DbException, FsException, MsgException) as e:
             raise EngineException(str(e), http_code=e.http_code)
 
@@ -109,29 +231,34 @@ class Engine(object):
                 self.db.db_disconnect()
             if self.fs:
                 self.fs.fs_disconnect()
-            if self.fs:
-                self.fs.fs_disconnect()
+            if self.msg:
+                self.msg.disconnect()
+            self.write_lock = None
         except (DbException, FsException, MsgException) as e:
             raise EngineException(str(e), http_code=e.http_code)
 
-    def new_item(self, rollback, session, topic, indata=None, kwargs=None, headers=None, force=False):
+    def new_item(
+        self, rollback, session, topic, indata=None, kwargs=None, headers=None
+    ):
         """
         Creates a new entry into database. For nsds and vnfds it creates an almost empty DISABLED  entry,
         that must be completed with a call to method upload_content
         :param rollback: list to append created items at database in case a rollback must to be done
-        :param session: contains the used login username and working project
+        :param session: contains the used login username and working project, force to avoid checkins, public
         :param topic: it can be: users, projects, vim_accounts, sdns, nsrs, nsds, vnfds
         :param indata: data to be inserted
         :param kwargs: used to override the indata descriptor
         :param headers: http request headers
-        :param force: If True avoid some dependence checks
         :return: _id: identity of the inserted data.
         """
         if topic not in self.map_topic:
-            raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].new(rollback, session, indata, kwargs, headers, force)
+            raise EngineException(
+                "Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR
+            )
+        with self.write_lock:
+            return self.map_topic[topic].new(rollback, session, indata, kwargs, headers)
 
-    def upload_content(self, session, topic, _id, indata, kwargs, headers, force=False):
+    def upload_content(self, session, topic, _id, indata, kwargs, headers):
         """
         Upload content for an already created entry (_id)
         :param session: contains the used login username and working project
@@ -140,36 +267,43 @@ class Engine(object):
         :param indata: data to be inserted
         :param kwargs: used to override the indata descriptor
         :param headers: http request headers
-        :param force: If True avoid some dependence checks
         :return: _id: identity of the inserted data.
         """
         if topic not in self.map_topic:
-            raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].upload_content(session, _id, indata, kwargs, headers, force)
+            raise EngineException(
+                "Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR
+            )
+        with self.write_lock:
+            return self.map_topic[topic].upload_content(
+                session, _id, indata, kwargs, headers
+            )
 
-    def get_item_list(self, session, topic, filter_q=None):
+    def get_item_list(self, session, topic, filter_q=None, api_req=False):
         """
         Get a list of items
         :param session: contains the used login username and working project
         :param topic: it can be: users, projects, vnfds, nsds, ...
         :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_q.
         """
         if topic not in self.map_topic:
             raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].list(session, filter_q)
+        return self.map_topic[topic].list(session, filter_q, api_req)
 
-    def get_item(self, session, topic, _id):
+    def get_item(self, session, topic, _id, filter_q=None, api_req=False):
         """
         Get complete information on an item
         :param session: contains the used login username and working project
         :param topic: it can be: users, projects, vnfds, nsds,
         :param _id: server id of the item
+        :param filter_q: other arguments
+        :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.
         """
         if topic not in self.map_topic:
             raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].show(session, _id)
+        return self.map_topic[topic].show(session, _id, filter_q, api_req)
 
     def get_file(self, session, topic, _id, path=None, accept_header=None):
         """
@@ -182,7 +316,9 @@ class Engine(object):
         :return: opened file plus Accept format or raises an exception
         """
         if topic not in self.map_topic:
-            raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
+            raise EngineException(
+                "Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR
+            )
         return self.map_topic[topic].get_file(session, _id, path, accept_header)
 
     def del_item_list(self, session, topic, _filter=None):
@@ -194,23 +330,31 @@ class Engine(object):
         :return: The deleted list, it can be empty if no one match the _filter.
         """
         if topic not in self.map_topic:
-            raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].delete_list(session, _filter)
+            raise EngineException(
+                "Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR
+            )
+        with self.write_lock:
+            return self.map_topic[topic].delete_list(session, _filter)
 
-    def del_item(self, session, topic, _id, force=False):
+    def del_item(self, session, topic, _id, not_send_msg=None):
         """
         Delete item by its internal id
         :param session: contains the used login username and working project
         :param topic: it can be: users, projects, vnfds, nsds, ...
         :param _id: server id of the item
-        :param force: indicates if deletion must be forced in case of conflict
+        :param not_send_msg: If False, message will not be sent to kafka.
+            If a list, message is not sent, but content is stored in this variable so that the caller can send this
+            message using its own loop. If None, message is sent
         :return: dictionary with deleted item _id. It raises exception if not found.
         """
         if topic not in self.map_topic:
-            raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].delete(session, _id, force)
+            raise EngineException(
+                "Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR
+            )
+        with self.write_lock:
+            return self.map_topic[topic].delete(session, _id, not_send_msg=not_send_msg)
 
-    def edit_item(self, session, topic, _id, indata=None, kwargs=None, force=False):
+    def edit_item(self, session, topic, _id, indata=None, kwargs=None):
         """
         Update an existing entry at database
         :param session: contains the used login username and working project
@@ -218,53 +362,65 @@ class Engine(object):
         :param _id: identifier to be updated
         :param indata: data to be inserted
         :param kwargs: used to override the indata descriptor
-        :param force: If True avoid some dependence checks
-        :return: dictionary, raise exception if not found.
+        :return: dictionary with edited item _id, raise exception if not found.
         """
         if topic not in self.map_topic:
-            raise EngineException("Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR)
-        return self.map_topic[topic].edit(session, _id, indata, kwargs, force)
-
-    def create_admin(self):
-        """
-        Creates a new user admin/admin into database if database is empty. Useful for initialization
-        :return: _id identity of the inserted data, or None
-        """
-        users = self.db.get_one("users", fail_on_empty=False, fail_on_more=False)
-        if users:
-            return None
-            # raise EngineException("Unauthorized. Database users is not empty", HTTPStatus.UNAUTHORIZED)
-        user_desc = {"username": "admin", "password": "admin", "projects": ["admin"]}
-        fake_session = {"project_id": "admin", "username": "admin", "admin": True}
-        roolback_list = []
-        _id = self.map_topic["users"].new(roolback_list, fake_session, user_desc, force=True)
-        return _id
+            raise EngineException(
+                "Unknown topic {}!!!".format(topic), HTTPStatus.INTERNAL_SERVER_ERROR
+            )
+        with self.write_lock:
+            return self.map_topic[topic].edit(session, _id, indata, kwargs)
 
     def upgrade_db(self, current_version, target_version):
-        if not target_version or current_version == target_version:
+        if target_version not in self.map_target_version_to_int.keys():
+            raise EngineException(
+                "Cannot upgrade to version '{}' with this version of code".format(
+                    target_version
+                ),
+                http_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
+
+        if current_version == target_version:
             return
-        if target_version == '1.0':
-            if not current_version:
-                # create database version
-                serial = urandom(32)
-                version_data = {
-                    "_id": 'version',               # Always 'version'
-                    "version_int": 1000,            # version number
-                    "version": '1.0',               # version text
-                    "date": "2018-10-25",           # version date
-                    "description": "added serial",  # changes in this version
-                    'status': 'ENABLED',            # ENABLED, DISABLED (migration in process), ERROR,
-                    'serial': b64encode(serial)
-                }
-                self.db.create("admin", version_data)
-                self.db.set_secret_key(serial)
-            # TODO add future migrations here
 
-        raise EngineException("Wrong database version '{}'. Expected '{}'"
-                              ". It cannot be up/down-grade".format(current_version, target_version),
-                              http_code=HTTPStatus.INTERNAL_SERVER_ERROR)
+        target_version_int = self.map_target_version_to_int[target_version]
+
+        if not current_version:
+            # create database version
+            serial = urandom(32)
+            version_data = {
+                "_id": "version",  # Always "version"
+                "version_int": 1000,  # version number
+                "version": "1.0",  # version text
+                "date": "2018-10-25",  # version date
+                "description": "added serial",  # changes in this version
+                "status": "ENABLED",  # ENABLED, DISABLED (migration in process), ERROR,
+                "serial": b64encode(serial),
+            }
+            self.db.create("admin", version_data)
+            self.db.set_secret_key(serial)
+            current_version = "1.0"
+
+        if (
+            current_version in ("1.0", "1.1")
+            and target_version_int >= self.map_target_version_to_int["1.2"]
+        ):
+            if self.config["authentication"]["backend"] == "internal":
+                self.db.del_list("roles")
+
+            version_data = {
+                "_id": "version",
+                "version_int": 1002,
+                "version": "1.2",
+                "date": "2019-06-11",
+                "description": "set new format for roles_operations",
+            }
+
+            self.db.set_one("admin", {"_id": "version"}, version_data)
+            current_version = "1.2"
+            # TODO add future migrations here
 
-    def init_db(self, target_version='1.0'):
+    def init_db(self, target_version="1.0"):
         """
         Init database if empty. If not empty it checks that database version and migrates if needed
         If empty, it creates a new user admin/admin at 'users' and a new entry at 'version'
@@ -272,17 +428,19 @@ class Engine(object):
         :return: None if ok, exception if error or if the version is different.
         """
 
-        version_data = self.db.get_one("admin", {"_id": "version"}, fail_on_empty=False, fail_on_more=True)
+        version_data = self.db.get_one(
+            "admin", {"_id": "version"}, fail_on_empty=False, fail_on_more=True
+        )
         # check database status is ok
-        if version_data and version_data.get("status") != 'ENABLED':
-            raise EngineException("Wrong database status '{}'".format(
-                version_data["status"]), HTTPStatus.INTERNAL_SERVER_ERROR)
+        if version_data and version_data.get("status") != "ENABLED":
+            raise EngineException(
+                "Wrong database status '{}'".format(version_data["status"]),
+                HTTPStatus.INTERNAL_SERVER_ERROR,
+            )
 
         # check version
         db_version = None if not version_data else version_data.get("version")
         if db_version != target_version:
             self.upgrade_db(db_version, target_version)
 
-        # create user admin if not exist
-        self.create_admin()
         return