Added support for helm version
[osm/NBI.git] / osm_nbi / instance_topics.py
index 6121ff2..ace7f8e 100644 (file)
@@ -18,8 +18,9 @@ from uuid import uuid4
 from http import HTTPStatus
 from time import time
 from copy import copy, deepcopy
-from osm_nbi.validation import validate_input, ValidationError, ns_instantiate, ns_action, ns_scale, nsi_instantiate
-from osm_nbi.base_topic import BaseTopic, EngineException, get_iterable, deep_get
+from osm_nbi.validation import validate_input, ValidationError, ns_instantiate, ns_terminate, ns_action, ns_scale,\
+    nsi_instantiate
+from osm_nbi.base_topic import BaseTopic, EngineException, get_iterable, deep_get, increment_ip_mac
 # from descriptor_topics import DescriptorTopic
 from yaml import safe_dump
 from osm_common.dbbase import DbException
@@ -33,6 +34,7 @@ __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
 class NsrTopic(BaseTopic):
     topic = "nsrs"
     topic_msg = "ns"
+    quota_name = "ns_instances"
     schema_new = ns_instantiate
 
     def __init__(self, db, fs, msg, auth):
@@ -112,6 +114,9 @@ class NsrTopic(BaseTopic):
                 if not nsrs_list:
                     self.db.set_one("vnfds", {"_id": used_vnfd_id}, {"_admin.usageState": "NOT_IN_USE"})
 
+        # delete extra ro_nsrs used for internal RO module
+        self.db.del_one("ro_nsrs", q_filter={"_id": _id}, fail_on_empty=False)
+
     @staticmethod
     def _format_ns_request(ns_request):
         formated_request = copy(ns_request)
@@ -120,15 +125,16 @@ class NsrTopic(BaseTopic):
         return formated_request
 
     @staticmethod
-    def _format_addional_params(ns_request, member_vnf_index=None, vdu_id=None, kdu_name=None, descriptor=None):
+    def _format_additional_params(ns_request, member_vnf_index=None, vdu_id=None, kdu_name=None, descriptor=None):
         """
         Get and format user additional params for NS or VNF
         :param ns_request: User instantiation additional parameters
         :param member_vnf_index: None for extract NS params, or member_vnf_index to extract VNF params
         :param descriptor: If not None it check that needed parameters of descriptor are supplied
-        :return: a formatted copy of additional params or None if not supplied
+        :return: tuple with a formatted copy of additional params or None if not supplied, plus other parameters
         """
         additional_params = None
+        other_params = None
         if not member_vnf_index:
             additional_params = copy(ns_request.get("additionalParamsForNs"))
             where_ = "additionalParamsForNs"
@@ -137,9 +143,12 @@ class NsrTopic(BaseTopic):
             item = next((x for x in ns_request["additionalParamsForVnf"] if x["member-vnf-index"] == member_vnf_index),
                         None)
             if item:
+                if not vdu_id and not kdu_name:
+                    other_params = item
                 additional_params = copy(item.get("additionalParams")) or {}
                 if vdu_id and item.get("additionalParamsForVdu"):
                     item_vdu = next((x for x in item["additionalParamsForVdu"] if x["vdu_id"] == vdu_id), None)
+                    other_params = item_vdu
                     if item_vdu and item_vdu.get("additionalParams"):
                         where_ += ".additionalParamsForVdu[vdu_id={}]".format(vdu_id)
                         additional_params = item_vdu["additionalParams"]
@@ -147,6 +156,7 @@ class NsrTopic(BaseTopic):
                     additional_params = {}
                     if item.get("additionalParamsForKdu"):
                         item_kdu = next((x for x in item["additionalParamsForKdu"] if x["kdu_name"] == kdu_name), None)
+                        other_params = item_kdu
                         if item_kdu and item_kdu.get("additionalParams"):
                             where_ += ".additionalParamsForKdu[kdu_name={}]".format(kdu_name)
                             additional_params = item_kdu["additionalParams"]
@@ -191,7 +201,7 @@ class NsrTopic(BaseTopic):
                                                   format(param["value"], descriptor["id"],
                                                          initial_primitive["name"]))
 
-        return additional_params or None
+        return additional_params or None, other_params or None
 
     def new(self, rollback, session, indata=None, kwargs=None, headers=None):
         """
@@ -216,17 +226,32 @@ class NsrTopic(BaseTopic):
             self._update_input_with_kwargs(ns_request, kwargs)
             self._validate_input_new(ns_request, session["force"])
 
-            # look for nsr
+            # look for nsd
             step = "getting nsd id='{}' from database".format(ns_request.get("nsdId"))
             _filter = self._get_project_filter(session)
             _filter["_id"] = ns_request["nsdId"]
             nsd = self.db.get_one("nsds", _filter)
             del _filter["_id"]
 
+            # check NSD is not disabled
+            step = "checking nsdOperationalState"
+            if nsd["_admin"]["operationalState"] == "DISABLED":
+                raise EngineException("nsd with id '{}' is DISABLED, and thus cannot be used to create "
+                                      "a network service".format(ns_request["nsdId"]), http_code=HTTPStatus.CONFLICT)
+
             nsr_id = str(uuid4())
 
             now = time()
             step = "filling nsr from input data"
+            additional_params, _ = self._format_additional_params(ns_request, descriptor=nsd)
+
+            # use for k8s-namespace from ns_request or additionalParamsForNs. By default, the project_id
+            ns_k8s_namespace = session["project_id"][0] if session["project_id"] else None
+            if ns_request and ns_request.get("k8s-namespace"):
+                ns_k8s_namespace = ns_request["k8s-namespace"]
+            if additional_params and additional_params.get("k8s-namespace"):
+                ns_k8s_namespace = additional_params["k8s-namespace"]
+
             nsr_descriptor = {
                 "name": ns_request["nsName"],
                 "name-ref": ns_request["nsName"],
@@ -240,7 +265,8 @@ class NsrTopic(BaseTopic):
                 "deploymentStatus": None,
                 "configurationStatus": None,
                 "vcaStatus": None,
-                "nsd": nsd,
+                "nsd": {k: v for k, v in nsd.items() if k in ("vld", "_id", "id", "constituent-vnfd", "name",
+                                                              "ns-configuration")},
                 "datacenter": ns_request["vimAccountId"],
                 "resource-orchestrator": "osmopenmano",
                 "description": ns_request.get("nsDescription", ""),
@@ -260,20 +286,23 @@ class NsrTopic(BaseTopic):
                 "nsd-id": nsd["_id"],
                 "vnfd-id": [],
                 "instantiate_params": self._format_ns_request(ns_request),
-                "additionalParamsForNs": self._format_addional_params(ns_request, descriptor=nsd),
+                "additionalParamsForNs": additional_params,
                 "ns-instance-config-ref": nsr_id,
                 "id": nsr_id,
                 "_id": nsr_id,
                 # "input-parameter": xpath, value,
                 "ssh-authorized-key": ns_request.get("ssh_keys"),  # TODO remove
+                "vld": nsd.get("vld") or [],
+                "flavor": [],
+                "image": [],
             }
             ns_request["nsr_id"] = nsr_id
+            if ns_request and ns_request.get("config-units"):
+                nsr_descriptor["config-units"] = ns_request["config-units"]
+
             # Create vld
             if nsd.get("vld"):
-                nsr_descriptor["vld"] = []
-                for nsd_vld in nsd.get("vld"):
-                    nsr_descriptor["vld"].append(
-                        {key: nsd_vld[key] for key in ("id", "vim-network-name", "vim-network-id") if key in nsd_vld})
+                nsr_descriptor["vld"] = nsd["vld"]
 
             # Create VNFR
             needed_vnfds = {}
@@ -294,13 +323,15 @@ class NsrTopic(BaseTopic):
                 step = "filling vnfr  vnfd-id='{}' constituent-vnfd='{}'".format(
                     member_vnf["vnfd-id-ref"], member_vnf["member-vnf-index"])
                 vnfr_id = str(uuid4())
+                additional_params, vnf_params = self._format_additional_params(ns_request,
+                                                                               member_vnf["member-vnf-index"],
+                                                                               descriptor=vnfd)
                 vnfr_descriptor = {
                     "id": vnfr_id,
                     "_id": vnfr_id,
                     "nsr-id-ref": nsr_id,
                     "member-vnf-index-ref": member_vnf["member-vnf-index"],
-                    "additionalParamsForVnf": self._format_addional_params(ns_request, member_vnf["member-vnf-index"],
-                                                                           descriptor=vnfd),
+                    "additionalParamsForVnf": additional_params,
                     "created-time": now,
                     # "vnfd": vnfd,        # at OSM model.but removed to avoid data duplication TODO: revise
                     "vnfd-ref": vnfd_id,
@@ -310,6 +341,12 @@ class NsrTopic(BaseTopic):
                     "connection-point": [],
                     "ip-address": None,  # mgmt-interface filled by LCM
                 }
+                vnf_k8s_namespace = ns_k8s_namespace
+                if vnf_params:
+                    if vnf_params.get("k8s-namespace"):
+                        vnf_k8s_namespace = vnf_params["k8s-namespace"]
+                    if vnf_params.get("config-units"):
+                        vnfr_descriptor["config-units"] = vnf_params["config-units"]
 
                 # Create vld
                 if vnfd.get("internal-vld"):
@@ -356,18 +393,37 @@ class NsrTopic(BaseTopic):
                                 break
                 # update kdus
                 for kdu in get_iterable(vnfd.get("kdu")):
-                    kdur = {x: kdu[x] for x in kdu if x in ("helm-chart", "juju-bundle")}
-                    kdur["kdu-name"] = kdu["name"]
-                    # TODO      "name": ""     Name of the VDU in the VIM
-                    kdur["ip-address"] = None  # mgmt-interface filled by LCM
-                    kdur["k8s-cluster"] = {}
-                    kdur["additionalParams"] = self._format_addional_params(ns_request, member_vnf["member-vnf-index"],
-                                                                            kdu_name=kdu["name"], descriptor=vnfd)
+                    additional_params, kdu_params = self._format_additional_params(ns_request,
+                                                                                   member_vnf["member-vnf-index"],
+                                                                                   kdu_name=kdu["name"],
+                                                                                   descriptor=vnfd)
+                    kdu_k8s_namespace = vnf_k8s_namespace
+                    kdu_model = kdu_params.get("kdu_model") if kdu_params else None
+                    if kdu_params and kdu_params.get("k8s-namespace"):
+                        kdu_k8s_namespace = kdu_params["k8s-namespace"]
+
+                    kdur = {
+                        "additionalParams": additional_params,
+                        "k8s-namespace": kdu_k8s_namespace,
+                        "kdu-name": kdu["name"],
+                        # TODO      "name": ""     Name of the VDU in the VIM
+                        "ip-address": None,  # mgmt-interface filled by LCM
+                        "k8s-cluster": {},
+                    }
+                    if kdu_params and kdu_params.get("config-units"):
+                        kdur["config-units"] = kdu_params["config-units"]
+                    if kdu.get("helm-version"):
+                        kdur["helm-version"] = kdu["helm-version"]
+                    for k8s_type in ("helm-chart", "juju-bundle"):
+                        if kdu.get(k8s_type):
+                            kdur[k8s_type] = kdu_model or kdu[k8s_type]
                     if not vnfr_descriptor.get("kdur"):
                         vnfr_descriptor["kdur"] = []
                     vnfr_descriptor["kdur"].append(kdur)
 
                 for vdu in vnfd.get("vdu", ()):
+                    additional_params, vdu_params = self._format_additional_params(
+                        ns_request, member_vnf["member-vnf-index"], vdu_id=vdu["id"], descriptor=vnfd)
                     vdur = {
                         "vdu-id-ref": vdu["id"],
                         # TODO      "name": ""     Name of the VDU in the VIM
@@ -375,31 +431,65 @@ class NsrTopic(BaseTopic):
                         # "vim-id", "flavor-id", "image-id", "management-ip" # filled by LCM
                         "internal-connection-point": [],
                         "interfaces": [],
-                        "additionalParams": self._format_addional_params(ns_request, member_vnf["member-vnf-index"],
-                                                                         vdu_id=vdu["id"], descriptor=vnfd)
+                        "additionalParams": additional_params,
+                        "vdu-name": vdu["name"],
                     }
+                    if vdu_params and vdu_params.get("config-units"):
+                        vdur["config-units"] = vdu_params["config-units"]
+                    if deep_get(vdu, ("supplemental-boot-data", "boot-data-drive")):
+                        vdur["boot-data-drive"] = vdu["supplemental-boot-data"]["boot-data-drive"]
                     if vdu.get("pdu-type"):
                         vdur["pdu-type"] = vdu["pdu-type"]
+                        vdur["name"] = vdu["pdu-type"]
+
+                    # flavor
+                    flavor_data = copy(vdu.get("vm-flavor", {}))
+                    flavor_data["guest-epa"] = vdu.get("guest-epa")
+                    f = next((f for f in nsr_descriptor["flavor"] if
+                              all(f.get(k) == flavor_data[k] for k in flavor_data)), None)
+                    if not f:
+                        flavor_data["vim_info"] = []
+                        flavor_data["name"] = vdu["id"][:56] + "-flv"
+                        flavor_data["id"] = str(len(nsr_descriptor["flavor"]))
+                        nsr_descriptor["flavor"].append(flavor_data)
+                        f = flavor_data
+                    vdur["ns-flavor-id"] = f["id"]
+
+                    # image
+                    if vdu.get("image"):
+                        image_data = {"image": vdu["image"], "image_checksum": vdu.get("image_checksum")}
+                    img = next((f for f in nsr_descriptor["image"] if
+                                all(f.get(k) == image_data[k] for k in image_data)), None)
+                    if not img:
+                        image_data["vim_info"] = []
+                        image_data["id"] = str(len(nsr_descriptor["image"]))
+                        nsr_descriptor["image"].append(image_data)
+                        img = image_data
+                    vdur["ns-image-id"] = img["id"]
+
                     # TODO volumes: name, volume-id
                     for icp in vdu.get("internal-connection-point", ()):
                         vdu_icp = {
                             "id": icp["id"],
                             "connection-point-id": icp["id"],
                             "name": icp.get("name"),
-                            # "ip-address", "mac-address" # filled by LCM
-                            # vim-id  # TODO it would be nice having a vim port id
                         }
                         vdur["internal-connection-point"].append(vdu_icp)
                     for iface in vdu.get("interface", ()):
                         vdu_iface = {
-                            "name": iface.get("name"),
-                            # "ip-address", "mac-address" # filled by LCM
-                            # vim-id  # TODO it would be nice having a vim port id
-                        }
+                            x: iface[x] for x in ("name", "ip-address", "mac-address", "internal-connection-point-ref",
+                                                  "external-connection-point-ref") if iface.get(x) is not None}
                         if vnfd_mgmt_cp and iface.get("external-connection-point-ref") == vnfd_mgmt_cp:
                             vdu_iface["mgmt-vnf"] = True
                         if iface.get("mgmt-interface"):
                             vdu_iface["mgmt-interface"] = True  # TODO change to mgmt-vdu
+                        if iface.get("virtual-interface"):
+                            if iface["virtual-interface"].get("type"):
+                                iface["type"] = iface["virtual-interface"]["type"]
+                            if iface["virtual-interface"].get("vpci"):
+                                iface["vpci"] = iface["virtual-interface"]["vpci"]
+                            if iface["virtual-interface"].get("bandwidth"):
+                                iface["bandwidth"] = iface["virtual-interface"]["bandwidth"]
 
                         # look for network where this interface is connected
                         if iface.get("external-connection-point-ref"):
@@ -418,12 +508,16 @@ class NsrTopic(BaseTopic):
                                 for vnfd_ivld_icp in get_iterable(vnfd_ivld.get("internal-connection-point")):
                                     if vnfd_ivld_icp.get("id-ref") == iface["internal-connection-point-ref"]:
                                         vdu_iface["vnf-vld-id"] = vnfd_ivld["id"]
+                                        if vnfd_ivld_icp.get("ip-address"):
+                                            vdu_iface["ip-address"] = vnfd_ivld_icp["ip-address"]
                                         break
                                 else:
                                     continue
                                 break
-
-                        vdur["interfaces"].append(vdu_iface)
+                        if iface.get("position") is not None:
+                            vdur["interfaces"].insert(iface["position"], vdu_iface)
+                        else:
+                            vdur["interfaces"].append(vdu_iface)
                     count = vdu.get("count", 1)
                     if count is None:
                         count = 1
@@ -431,8 +525,15 @@ class NsrTopic(BaseTopic):
                     for index in range(0, count):
                         if index:
                             vdur = deepcopy(vdur)
+                            for iface in vdur["interfaces"]:
+                                if iface.get("ip-address"):
+                                    iface["ip-address"] = increment_ip_mac(iface["ip-address"])
+                                if iface.get("mac-address"):
+                                    iface["mac-address"] = increment_ip_mac(iface["mac-address"])
+
                         vdur["_id"] = str(uuid4())
                         vdur["count-index"] = index
+                        vdur["id"] = "{}-{}".format(vdur["vdu-id-ref"], index)
                         vnfr_descriptor["vdur"].append(vdur)
 
                 step = "creating vnfr vnfd-id='{}' constituent-vnfd='{}' at database".format(
@@ -454,7 +555,7 @@ class NsrTopic(BaseTopic):
 
             return nsr_id, None
         except (ValidationError, EngineException, DbException, MsgException, FsException) as e:
-            raise type(e)("{} while '{}".format(e, step), http_code=e.http_code)
+            raise type(e)("{} while '{}'".format(e, step), http_code=e.http_code)
 
     def edit(self, session, _id, indata=None, kwargs=None, content=None):
         raise EngineException("Method edit called directly", HTTPStatus.INTERNAL_SERVER_ERROR)
@@ -485,7 +586,7 @@ class NsLcmOpTopic(BaseTopic):
         "instantiate": ns_instantiate,
         "action": ns_action,
         "scale": ns_scale,
-        "terminate": None,
+        "terminate": ns_terminate,
     }
 
     def __init__(self, db, fs, msg, auth):
@@ -565,7 +666,7 @@ class NsLcmOpTopic(BaseTopic):
 
             for in_ivld in get_iterable(in_vnfd.get("internal-vld")):
                 for ivld in get_iterable(vnfd.get("internal-vld")):
-                    if in_ivld["name"] == ivld["name"] or in_ivld["name"] == ivld["id"]:
+                    if in_ivld["name"] in (ivld["id"], ivld.get("name")):
                         for in_icp in get_iterable(in_ivld.get("internal-connection-point")):
                             for icp in ivld["internal-connection-point"]:
                                 if in_icp["id-ref"] == icp["id-ref"]:
@@ -575,7 +676,7 @@ class NsLcmOpTopic(BaseTopic):
                                                       "='{}']:internal-connection-point[id-ref:'{}'] is not present at "
                                                       "vnfd:internal-vld:name/id:internal-connection-point"
                                                       .format(in_vnf["member-vnf-index"], in_ivld["name"],
-                                                              in_icp["id-ref"], vnfd["id"]))
+                                                              in_icp["id-ref"]))
                         break
                 else:
                     raise EngineException("Invalid parameter vnf[member-vnf-index='{}']:internal-vld:name='{}'"
@@ -765,6 +866,7 @@ class NsLcmOpTopic(BaseTopic):
                             if vdur_interface.get("mgmt-vnf"):
                                 vnfr_update_rollback["ip-address"] = vnfr.get("ip-address")
                                 vnfr_update["ip-address"] = pdu_interface["ip-address"]
+                                vnfr_update[vdu_text + ".ip-address"] = pdu_interface["ip-address"]
                         if pdu_interface.get("vim-network-name") or pdu_interface.get("vim-network-id"):
                             ifaces_forcing_vim_network.append({
                                 "name": vdur_interface.get("vnf-vld-id") or vdur_interface.get("ns-vld-id"),
@@ -880,6 +982,56 @@ class NsLcmOpTopic(BaseTopic):
                 if vnf_inst_params.get("vimAccountId"):
                     vim_account = vnf_inst_params.get("vimAccountId")
 
+                # get vnf.vdu.interface instantiation params to update vnfr.vdur.interfaces ip, mac
+                for vdu_inst_param in get_iterable(vnf_inst_params.get("vdu")):
+                    for vdur_index, vdur in enumerate(vnfr["vdur"]):
+                        if vdu_inst_param["id"] != vdur["vdu-id-ref"]:
+                            continue
+                        for iface_inst_param in get_iterable(vdu_inst_param.get("interface")):
+                            iface_index, _ = next(i for i in enumerate(vdur["interfaces"])
+                                                  if i[1]["name"] == iface_inst_param["name"])
+                            vnfr_update_text = "vdur.{}.interfaces.{}".format(vdur_index, iface_index)
+                            if iface_inst_param.get("ip-address"):
+                                vnfr_update[vnfr_update_text + ".ip-address"] = increment_ip_mac(
+                                    iface_inst_param.get("ip-address"), vdur.get("count-index", 0))
+                            if iface_inst_param.get("mac-address"):
+                                vnfr_update[vnfr_update_text + ".mac-address"] = increment_ip_mac(
+                                    iface_inst_param.get("mac-address"), vdur.get("count-index", 0))
+                # get vnf.internal-vld.internal-conection-point instantiation params to update vnfr.vdur.interfaces
+                # TODO update vld with the ip-profile
+                for ivld_inst_param in get_iterable(vnf_inst_params.get("internal-vld")):
+                    for icp_inst_param in get_iterable(ivld_inst_param.get("internal-connection-point")):
+                        # look for iface
+                        for vdur_index, vdur in enumerate(vnfr["vdur"]):
+                            for iface_index, iface in enumerate(vdur["interfaces"]):
+                                if iface.get("internal-connection-point-ref") == icp_inst_param["id-ref"]:
+                                    vnfr_update_text = "vdur.{}.interfaces.{}".format(vdur_index, iface_index)
+                                    if icp_inst_param.get("ip-address"):
+                                        vnfr_update[vnfr_update_text + ".ip-address"] = increment_ip_mac(
+                                            icp_inst_param.get("ip-address"), vdur.get("count-index", 0))
+                                    if icp_inst_param.get("mac-address"):
+                                        vnfr_update[vnfr_update_text + ".mac-address"] = increment_ip_mac(
+                                            icp_inst_param.get("mac-address"), vdur.get("count-index", 0))
+                                    break
+            # get ip address from instantiation parameters.vld.vnfd-connection-point-ref
+            for vld_inst_param in get_iterable(indata.get("vld")):
+                for vnfcp_inst_param in get_iterable(vld_inst_param.get("vnfd-connection-point-ref")):
+                    if vnfcp_inst_param["member-vnf-index-ref"] != member_vnf_index:
+                        continue
+                    # look for iface
+                    for vdur_index, vdur in enumerate(vnfr["vdur"]):
+                        for iface_index, iface in enumerate(vdur["interfaces"]):
+                            if iface.get("external-connection-point-ref") == \
+                                    vnfcp_inst_param["vnfd-connection-point-ref"]:
+                                vnfr_update_text = "vdur.{}.interfaces.{}".format(vdur_index, iface_index)
+                                if vnfcp_inst_param.get("ip-address"):
+                                    vnfr_update[vnfr_update_text + ".ip-address"] = increment_ip_mac(
+                                        vnfcp_inst_param.get("ip-address"), vdur.get("count-index", 0))
+                                if vnfcp_inst_param.get("mac-address"):
+                                    vnfr_update[vnfr_update_text + ".mac-address"] = increment_ip_mac(
+                                        vnfcp_inst_param.get("mac-address"), vdur.get("count-index", 0))
+                                break
+
             vnfr_update["vim-account-id"] = vim_account
             vnfr_update_rollback["vim-account-id"] = vnfr.get("vim-account-id")
 
@@ -978,12 +1130,12 @@ class NsLcmOpTopic(BaseTopic):
             db_filter["_admin.nsrs-detailed-list.ANYINDEX.nsrId"] = nsr_id
             nsis = self.db.get_one("nsis", db_filter, fail_on_empty=False, fail_on_more=False)
             if nsis:
-                raise EngineException("The NS instance {} cannot be terminate because is used by the slice {}".format(
+                raise EngineException("The NS instance {} cannot be terminated because is used by the slice {}".format(
                                       nsr_id, nsis["_id"]), http_code=HTTPStatus.CONFLICT)
 
         try:
             # Override descriptor with query string kwargs
-            self._update_input_with_kwargs(indata, kwargs)
+            self._update_input_with_kwargs(indata, kwargs, yaml_format=True)
             operation = indata["lcmOperationType"]
             nsInstanceId = indata["nsInstanceId"]
 
@@ -1038,6 +1190,7 @@ class NsLcmOpTopic(BaseTopic):
 class NsiTopic(BaseTopic):
     topic = "nsis"
     topic_msg = "nsi"
+    quota_name = "slice_instances"
 
     def __init__(self, db, fs, msg, auth):
         BaseTopic.__init__(self, db, fs, msg, auth)
@@ -1215,8 +1368,19 @@ class NsiTopic(BaseTopic):
             _filter = self._get_project_filter(session)
             _filter["_id"] = slice_request["nstId"]
             nstd = self.db.get_one("nsts", _filter)
+            # check NST is not disabled
+            step = "checking NST operationalState"
+            if nstd["_admin"]["operationalState"] == "DISABLED":
+                raise EngineException("nst with id '{}' is DISABLED, and thus cannot be used to create a netslice "
+                                      "instance".format(slice_request["nstId"]), http_code=HTTPStatus.CONFLICT)
             del _filter["_id"]
 
+            # check NSD is not disabled
+            step = "checking operationalState"
+            if nstd["_admin"]["operationalState"] == "DISABLED":
+                raise EngineException("nst with id '{}' is DISABLED, and thus cannot be used to create "
+                                      "a network slice".format(slice_request["nstId"]), http_code=HTTPStatus.CONFLICT)
+
             nstd.pop("_admin", None)
             nstd_id = nstd.pop("_id", None)
             nsi_id = str(uuid4())
@@ -1388,7 +1552,9 @@ class NsiLcmOpTopic(BaseTopic):
                 if nstId == netslice_subnet["id"]:
                     nsd_id = netslice_subnet["nsd-ref"]
                     if nsd_id not in nsds:
-                        nsds[nsd_id] = self.db.get_one("nsds", {"id": nsd_id})
+                        _filter = self._get_project_filter(session)
+                        _filter["id"] = nsd_id
+                        nsds[nsd_id] = self.db.get_one("nsds", _filter)
                     return nsds[nsd_id]
             else:
                 raise EngineException("Invalid parameter nstId='{}' is not one of the "
@@ -1456,6 +1622,7 @@ class NsiLcmOpTopic(BaseTopic):
             _filter = self._get_project_filter(session)
             _filter["_id"] = netsliceInstanceId
             nsir = self.db.get_one("nsis", _filter)
+            logging_prefix = "nsi={} {} ".format(netsliceInstanceId, operation)
             del _filter["_id"]
 
             # initial checking
@@ -1477,52 +1644,56 @@ class NsiLcmOpTopic(BaseTopic):
             nslcmops = []
             # nslcmops_item = None
             for index, nsr_item in enumerate(nsrs_list):
-                nsi = None
+                nsr_id = nsr_item["nsrId"]
                 if nsr_item.get("shared"):
                     _filter["_admin.nsrs-detailed-list.ANYINDEX.shared"] = True
-                    _filter["_admin.nsrs-detailed-list.ANYINDEX.nsrId"] = nsr_item["nsrId"]
+                    _filter["_admin.nsrs-detailed-list.ANYINDEX.nsrId"] = nsr_id
                     _filter["_admin.nsrs-detailed-list.ANYINDEX.nslcmop_instantiate.ne"] = None
                     _filter["_id.ne"] = netsliceInstanceId
                     nsi = self.db.get_one("nsis", _filter, fail_on_empty=False, fail_on_more=False)
                     if operation == "terminate":
                         _update = {"_admin.nsrs-detailed-list.{}.nslcmop_instantiate".format(index): None}
                         self.db.set_one("nsis", {"_id": nsir["_id"]}, _update)
-                        
-                    # looks the first nsi fulfilling the conditions but not being the current NSIR
-                    if nsi:
-                        nsi_admin_shared = nsi["_admin"]["nsrs-detailed-list"]
-                        for nsi_nsr_item in nsi_admin_shared:
-                            if nsi_nsr_item["nsd-id"] == nsr_item["nsd-id"] and nsi_nsr_item["shared"]:
-                                self.add_shared_nsr_2vld(nsir, nsr_item)
-                                nslcmops.append(nsi_nsr_item["nslcmop_instantiate"])
-                                _update = {"_admin.nsrs-detailed-list.{}".format(index): nsi_nsr_item}
-                                self.db.set_one("nsis", {"_id": nsir["_id"]}, _update)
-                                break
-                        # continue to not create nslcmop since nsrs is shared and nsrs was created
-                        continue
-                    else:
-                        self.add_shared_nsr_2vld(nsir, nsr_item)
+                        if nsi:  # other nsi is using this nsr and it needs this nsr instantiated
+                            continue  # do not create nsilcmop
+                    else:  # instantiate
+                        # looks the first nsi fulfilling the conditions but not being the current NSIR
+                        if nsi:
+                            nsi_nsr_item = next(n for n in nsi["_admin"]["nsrs-detailed-list"] if
+                                                n["nsrId"] == nsr_id and n["shared"] and
+                                                n["nslcmop_instantiate"])
+                            self.add_shared_nsr_2vld(nsir, nsr_item)
+                            nslcmops.append(nsi_nsr_item["nslcmop_instantiate"])
+                            _update = {"_admin.nsrs-detailed-list.{}".format(index): nsi_nsr_item}
+                            self.db.set_one("nsis", {"_id": nsir["_id"]}, _update)
+                            # continue to not create nslcmop since nsrs is shared and nsrs was created
+                            continue
+                        else:
+                            self.add_shared_nsr_2vld(nsir, nsr_item)
 
+                # create operation
                 try:
-                    service = self.db.get_one("nsrs", {"_id": nsr_item["nsrId"]})
-                    indata_ns = {}
-                    indata_ns = service["instantiate_params"]
-                    indata_ns["lcmOperationType"] = operation
-                    indata_ns["nsInstanceId"] = service["_id"]
-                    # Including netslice_id in the ns instantiate Operation
-                    indata_ns["netsliceInstanceId"] = netsliceInstanceId
+                    indata_ns = {
+                        "lcmOperationType": operation,
+                        "nsInstanceId": nsr_id,
+                        # Including netslice_id in the ns instantiate Operation
+                        "netsliceInstanceId": netsliceInstanceId,
+                    }
+                    if operation == "instantiate":
+                        service = self.db.get_one("nsrs", {"_id": nsr_id})
+                        indata_ns.update(service["instantiate_params"])
+
                     # Creating NS_LCM_OP with the flag slice_object=True to not trigger the service instantiation
                     # message via kafka bus
-                    nslcmop, _ = self.nsi_NsLcmOpTopic.new(rollback, session, indata_ns, kwargs, headers,
+                    nslcmop, _ = self.nsi_NsLcmOpTopic.new(rollback, session, indata_ns, None, headers,
                                                            slice_object=True)
                     nslcmops.append(nslcmop)
-                    if operation == "terminate":
-                        nslcmop = None
-                    _update = {"_admin.nsrs-detailed-list.{}.nslcmop_instantiate".format(index): nslcmop}
-                    self.db.set_one("nsis", {"_id": nsir["_id"]}, _update)
+                    if operation == "instantiate":
+                        _update = {"_admin.nsrs-detailed-list.{}.nslcmop_instantiate".format(index): nslcmop}
+                        self.db.set_one("nsis", {"_id": nsir["_id"]}, _update)
                 except (DbException, EngineException) as e:
                     if e.http_code == HTTPStatus.NOT_FOUND:
-                        self.logger.info("HTTPStatus.NOT_FOUND")
+                        self.logger.info(logging_prefix + "skipping NS={} because not found".format(nsr_id))
                         pass
                     else:
                         raise