Merge "RBAC permission storage in MongoDB"

[osm/NBI.git] / osm_nbi / instance_topics.py

diff --git a/osm_nbi/instance_topics.py b/osm_nbi/instance_topics.py
index b6e025f..36b6a42 100644 (file)
--- a/osm_nbi/instance_topics.py
+++ b/osm_nbi/instance_topics.py
@@ -21,6 +21,7 @@ from copy import copy, deepcopy
 from validation import validate_input, ValidationError, ns_instantiate, ns_action, ns_scale, nsi_instantiate
 from base_topic import BaseTopic, EngineException, get_iterable
 from descriptor_topics import DescriptorTopic
 from validation import validate_input, ValidationError, ns_instantiate, ns_action, ns_scale, nsi_instantiate
 from base_topic import BaseTopic, EngineException, get_iterable
 from descriptor_topics import DescriptorTopic

+from yaml import safe_dump

 
 __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
 
 
 __author__ = "Alfonso Tierno <alfonso.tiernosepulveda@telefonica.com>"
 


@@ -74,6 +75,7 @@ class NsrTopic(BaseTopic):
         if dry_run:
             return
 
         if dry_run:
             return
 

+        self.fs.file_delete(_id, ignore_non_exist=True)

         v = self.db.del_one("nsrs", {"_id": _id})
         self.db.del_list("nslcmops", {"nsInstanceId": _id})
         self.db.del_list("vnfrs", {"nsr-id-ref": _id})
         v = self.db.del_one("nsrs", {"_id": _id})
         self.db.del_list("nslcmops", {"nsInstanceId": _id})
         self.db.del_list("vnfrs", {"nsr-id-ref": _id})


@@ -83,6 +85,61 @@ class NsrTopic(BaseTopic):
         self._send_msg("deleted", {"_id": _id})
         return v
 
         self._send_msg("deleted", {"_id": _id})
         return v
 

+    @staticmethod
+    def _format_ns_request(ns_request):
+        formated_request = copy(ns_request)
+        formated_request.pop("additionalParamsForNs", None)
+        formated_request.pop("additionalParamsForVnf", None)
+        return formated_request
+
+    @staticmethod
+    def _format_addional_params(ns_request, member_vnf_index=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 formated copy of additional params or None if not supplied
+        """
+        additional_params = None
+        if not member_vnf_index:
+            additional_params = copy(ns_request.get("additionalParamsForNs"))
+            where_ = "additionalParamsForNs"
+        elif ns_request.get("additionalParamsForVnf"):
+            for additionalParamsForVnf in get_iterable(ns_request.get("additionalParamsForVnf")):
+                if additionalParamsForVnf["member-vnf-index"] == member_vnf_index:
+                    additional_params = copy(additionalParamsForVnf.get("additionalParams"))
+                    where_ = "additionalParamsForVnf[member-vnf-index={}]".format(
+                        additionalParamsForVnf["member-vnf-index"])
+                    break
+        if additional_params:
+            for k, v in additional_params.items():
+                if not isinstance(k, str):
+                    raise EngineException("Invalid param at {}:{}. Only string keys are allowed".format(where_, k))
+                if "." in k or "$" in k:
+                    raise EngineException("Invalid param at {}:{}. Keys must not contain dots or $".format(where_, k))
+                if isinstance(v, (dict, tuple, list)):
+                    additional_params[k] = "!!yaml " + safe_dump(v)
+
+        if descriptor:
+            # check that enough parameters are supplied for the initial-config-primitive
+            # TODO: check for cloud-init
+            if member_vnf_index:
+                if descriptor.get("vnf-configuration"):
+                    for initial_primitive in get_iterable(
+                            descriptor["vnf-configuration"].get("initial-config-primitive")):
+                        for param in get_iterable(initial_primitive.get("parameter")):
+                            if param["value"].startswith("<") and param["value"].endswith(">"):
+                                if param["value"] in ("<rw_mgmt_ip>", "<VDU_SCALE_INFO>"):
+                                    continue
+                                if not additional_params or param["value"][1:-1] not in additional_params:
+                                    raise EngineException("Parameter '{}' needed for vnfd[id={}]:vnf-configuration:"
+                                                          "initial-config-primitive[name={}] not supplied".
+                                                          format(param["value"], descriptor["id"],
+                                                                 initial_primitive["name"]))
+
+        return additional_params
+

     def new(self, rollback, session, indata=None, kwargs=None, headers=None, force=False, make_public=False):
         """
         Creates a new nsr into database. It also creates needed vnfrs
     def new(self, rollback, session, indata=None, kwargs=None, headers=None, force=False, make_public=False):
         """
         Creates a new nsr into database. It also creates needed vnfrs


@@ -110,6 +167,7 @@ class NsrTopic(BaseTopic):
             nsd = self.db.get_one("nsds", _filter)
 
             nsr_id = str(uuid4())
             nsd = self.db.get_one("nsds", _filter)
 
             nsr_id = str(uuid4())

+

             now = time()
             step = "filling nsr from input data"
             nsr_descriptor = {
             now = time()
             step = "filling nsr from input data"
             nsr_descriptor = {


@@ -134,7 +192,8 @@ class NsrTopic(BaseTopic):
                 "nsd-name-ref": nsd["name"],
                 "operational-events": [],   # "id", "timestamp", "description", "event",
                 "nsd-ref": nsd["id"],
                 "nsd-name-ref": nsd["name"],
                 "operational-events": [],   # "id", "timestamp", "description", "event",
                 "nsd-ref": nsd["id"],

-                "instantiate_params": ns_request,
+                "instantiate_params": self._format_ns_request(ns_request),
+                "additionalParamsForNs": self._format_addional_params(ns_request),

                 "ns-instance-config-ref": nsr_id,
                 "id": nsr_id,
                 "_id": nsr_id,
                 "ns-instance-config-ref": nsr_id,
                 "id": nsr_id,
                 "_id": nsr_id,


@@ -147,7 +206,7 @@ class NsrTopic(BaseTopic):
                 nsr_descriptor["vld"] = []
                 for nsd_vld in nsd.get("vld"):
                     nsr_descriptor["vld"].append(
                 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") if key in nsd_vld})
+                        {key: nsd_vld[key] for key in ("id", "vim-network-name", "vim-network-id") if key in nsd_vld})

 
             # Create VNFR
             needed_vnfds = {}
 
             # Create VNFR
             needed_vnfds = {}


@@ -170,6 +229,8 @@ class NsrTopic(BaseTopic):
                     "_id": vnfr_id,
                     "nsr-id-ref": nsr_id,
                     "member-vnf-index-ref": member_vnf["member-vnf-index"],
                     "_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"],
+                                                                           vnfd),

                     "created-time": now,
                     # "vnfd": vnfd,        # at OSM model.but removed to avoid data duplication TODO: revise
                     "vnfd-ref": vnfd_id,
                     "created-time": now,
                     # "vnfd": vnfd,        # at OSM model.but removed to avoid data duplication TODO: revise
                     "vnfd-ref": vnfd_id,


@@ -185,7 +246,8 @@ class NsrTopic(BaseTopic):
                     vnfr_descriptor["vld"] = []
                     for vnfd_vld in vnfd.get("internal-vld"):
                         vnfr_descriptor["vld"].append(
                     vnfr_descriptor["vld"] = []
                     for vnfd_vld in vnfd.get("internal-vld"):
                         vnfr_descriptor["vld"].append(

-                            {key: vnfd_vld[key] for key in ("id", "vim-network-name") if key in vnfd_vld})
+                            {key: vnfd_vld[key] for key in ("id", "vim-network-name", "vim-network-id") if key in
+                             vnfd_vld})

 
                 vnfd_mgmt_cp = vnfd["mgmt-interface"].get("cp")
                 for cp in vnfd.get("connection-point", ()):
 
                 vnfd_mgmt_cp = vnfd["mgmt-interface"].get("cp")
                 for cp in vnfd.get("connection-point", ()):


@@ -276,6 +338,10 @@ class NsrTopic(BaseTopic):
             self.format_on_new(nsr_descriptor, session["project_id"], make_public=make_public)
             self.db.create("nsrs", nsr_descriptor)
             rollback.append({"topic": "nsrs", "_id": nsr_id})
             self.format_on_new(nsr_descriptor, session["project_id"], make_public=make_public)
             self.db.create("nsrs", nsr_descriptor)
             rollback.append({"topic": "nsrs", "_id": nsr_id})

+
+            step = "creating nsr temporal folder"
+            self.fs.mkdir(nsr_id)
+

             return nsr_id
         except Exception as e:
             self.logger.exception("Exception {} at NsrTopic.new()".format(e), exc_info=True)
             return nsr_id
         except Exception as e:
             self.logger.exception("Exception {} at NsrTopic.new()".format(e), exc_info=True)


@@ -516,10 +582,10 @@ class NsLcmOpTopic(BaseTopic):
             }
             self.db.set_one("pdus", {"_id": pdu["_id"]},
                             {"_admin.usageState": "IN_USE",
             }
             self.db.set_one("pdus", {"_id": pdu["_id"]},
                             {"_admin.usageState": "IN_USE",

-                             "_admin.usage.vnfr_id": vnfr["_id"],
-                             "_admin.usage.nsr_id": vnfr["nsr-id-ref"],
-                             "_admin.usage.vdur": vdur["vdu-id-ref"]}
-                            )
+                             "_admin.usage": {"vnfr_id": vnfr["_id"],
+                                              "nsr_id": vnfr["nsr-id-ref"],
+                                              "vdur": vdur["vdu-id-ref"]}
+                             })

             rollback.append({"topic": "pdus", "_id": pdu["_id"], "operation": "set", "content": rollback_pdu})
 
             # step 3. Fill vnfr info by filling vdur
             rollback.append({"topic": "pdus", "_id": pdu["_id"], "operation": "set", "content": rollback_pdu})
 
             # step 3. Fill vnfr info by filling vdur


@@ -541,13 +607,17 @@ 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"]
                             if vdur_interface.get("mgmt-vnf"):
                                 vnfr_update_rollback["ip-address"] = vnfr.get("ip-address")
                                 vnfr_update["ip-address"] = pdu_interface["ip-address"]

-                        if pdu_interface.get("vim-network-name"):  # or pdu_interface.get("vim-network-id"):
+                        if pdu_interface.get("vim-network-name") or pdu_interface.get("vim-network-id"):

                             ifaces_forcing_vim_network.append({
                             ifaces_forcing_vim_network.append({

-                                # "vim-network-id": pdu_interface.get("vim-network-id"),
-                                "vim-network-name": pdu_interface.get("vim-network-name"),

                                 "name": vdur_interface.get("vnf-vld-id") or vdur_interface.get("ns-vld-id"),
                                 "vnf-vld-id": vdur_interface.get("vnf-vld-id"),
                                 "ns-vld-id": vdur_interface.get("ns-vld-id")})
                                 "name": vdur_interface.get("vnf-vld-id") or vdur_interface.get("ns-vld-id"),
                                 "vnf-vld-id": vdur_interface.get("vnf-vld-id"),
                                 "ns-vld-id": vdur_interface.get("ns-vld-id")})

+                            if pdu_interface.get("vim-network-id"):
+                                ifaces_forcing_vim_network.append({
+                                    "vim-network-id": pdu_interface.get("vim-network-id")})
+                            if pdu_interface.get("vim-network-name"):
+                                ifaces_forcing_vim_network.append({
+                                    "vim-network-name": pdu_interface.get("vim-network-name")})

                         break
 
         return ifaces_forcing_vim_network
                         break
 
         return ifaces_forcing_vim_network


@@ -663,7 +733,7 @@ class NsLcmOpTopic(BaseTopic):
             if not nsr["_admin"].get("nsState") or nsr["_admin"]["nsState"] == "NOT_INSTANTIATED":
                 if operation == "terminate" and indata.get("autoremove"):
                     # NSR must be deleted
             if not nsr["_admin"].get("nsState") or nsr["_admin"]["nsState"] == "NOT_INSTANTIATED":
                 if operation == "terminate" and indata.get("autoremove"):
                     # NSR must be deleted

-                    return self.delete(session, nsInstanceId)
+                    return None    # a none in this case is used to indicate not instantiated. It can be removed

                 if operation != "instantiate":
                     raise EngineException("ns_instance '{}' cannot be '{}' because it is not instantiated".format(
                         nsInstanceId, operation), HTTPStatus.CONFLICT)
                 if operation != "instantiate":
                     raise EngineException("ns_instance '{}' cannot be '{}' because it is not instantiated".format(
                         nsInstanceId, operation), HTTPStatus.CONFLICT)


@@ -701,6 +771,33 @@ class NsiTopic(BaseTopic):
 
     def __init__(self, db, fs, msg):
         BaseTopic.__init__(self, db, fs, msg)
 
     def __init__(self, db, fs, msg):
         BaseTopic.__init__(self, db, fs, msg)

+        self.nsrTopic = NsrTopic(db, fs, msg)
+
+    @staticmethod
+    def _format_ns_request(ns_request):
+        formated_request = copy(ns_request)
+        # TODO: Add request params
+        return formated_request
+
+    @staticmethod
+    def _format_addional_params(slice_request):
+        """
+        Get and format user additional params for NS or VNF
+        :param slice_request: User instantiation additional parameters
+        :return: a formatted copy of additional params or None if not supplied
+        """
+        additional_params = copy(slice_request.get("additionalParamsForNsi"))
+        if additional_params:
+            for k, v in additional_params.items():
+                if not isinstance(k, str):
+                    raise EngineException("Invalid param at additionalParamsForNsi:{}. Only string keys are allowed".
+                                          format(k))
+                if "." in k or "$" in k:
+                    raise EngineException("Invalid param at additionalParamsForNsi:{}. Keys must not contain dots or $".
+                                          format(k))
+                if isinstance(v, (dict, tuple, list)):
+                    additional_params[k] = "!!yaml " + safe_dump(v)
+        return additional_params

 
     def _check_descriptor_dependencies(self, session, descriptor):
         """
 
     def _check_descriptor_dependencies(self, session, descriptor):
         """


@@ -757,7 +854,7 @@ class NsiTopic(BaseTopic):
             _filter = {"_id": id_item}
             nslcmop = self.db.get_one("nslcmops", _filter)
             nsr_id = nslcmop["operationParams"]["nsr_id"]
             _filter = {"_id": id_item}
             nslcmop = self.db.get_one("nslcmops", _filter)
             nsr_id = nslcmop["operationParams"]["nsr_id"]

-            NsrTopic.delete(self, session, nsr_id, force=False, dry_run=False)
+            self.nsrTopic.delete(session, nsr_id, force=False, dry_run=False)

         self._send_msg("deleted", {"_id": _id})
         return v
 
         self._send_msg("deleted", {"_id": _id})
         return v
 


@@ -782,9 +879,8 @@ class NsiTopic(BaseTopic):
 
             step = ""
             # look for nstd
 
             step = ""
             # look for nstd

-            self.logger.info(str(slice_request))
-            step = "getting nstd id='{}' from database".format(slice_request.get("nstdId"))
-            _filter = {"id": slice_request["nstdId"]}
+            step = "getting nstd id='{}' from database".format(slice_request.get("nstId"))
+            _filter = {"_id": slice_request["nstId"]}

             _filter.update(BaseTopic._get_project_filter(session, write=False, show_all=True))
             nstd = self.db.get_one("nsts", _filter)
             nstd.pop("_admin", None)
             _filter.update(BaseTopic._get_project_filter(session, write=False, show_all=True))
             nstd = self.db.get_one("nsts", _filter)
             nstd.pop("_admin", None)


@@ -792,21 +888,74 @@ class NsiTopic(BaseTopic):
             nsi_id = str(uuid4())
             step = "filling nsi_descriptor with input data"
 
             nsi_id = str(uuid4())
             step = "filling nsi_descriptor with input data"
 

-            # "instantiation-parameters.netslice-subnet": []
-            # TODO: Equal as template for now
+            # Creating the NSIR

             nsi_descriptor = {
                 "id": nsi_id,
             nsi_descriptor = {
                 "id": nsi_id,

+                "name": slice_request["nsiName"],
+                "description": slice_request.get("nsiDescription", ""),
+                "datacenter": slice_request["vimAccountId"],

                 "nst-ref": nstd["id"],
                 "nst-ref": nstd["id"],

-                "instantiation-parameters": {
-                    "netslice-subnet": []
-                },
+                "instantiation_parameters": slice_request,

                 "network-slice-template": nstd,
                 "network-slice-template": nstd,

+                "nsr-ref-list": [],
+                "vlr-list": [],

                 "_id": nsi_id,
                 "_id": nsi_id,

+                "additionalParamsForNsi": self._format_addional_params(slice_request)

             }
 
             }
 

+            step = "creating nsi at database"
+            self.format_on_new(nsi_descriptor, session["project_id"], make_public=make_public)
+            nsi_descriptor["_admin"]["nsiState"] = "NOT_INSTANTIATED"
+            nsi_descriptor["_admin"]["netslice-subnet"] = None
+            
+            # Creating netslice-vld for the RO.
+            step = "creating netslice-vld at database"
+            instantiation_parameters = slice_request
+
+            # Building the vlds list to be deployed
+            # From netslice descriptors, creating the initial list
+            nsi_vlds = []           
+            if nstd.get("netslice-vld"):
+                # Building VLDs from NST
+                for netslice_vlds in nstd["netslice-vld"]:
+                    nsi_vld = {}
+                    # Adding nst vld name and global vimAccountId for netslice vld creation
+                    nsi_vld["name"] = netslice_vlds["name"]
+                    nsi_vld["vimAccountId"] = slice_request["vimAccountId"]
+                    # Getting template Instantiation parameters from NST
+                    for netslice_vld in netslice_vlds["nss-connection-point-ref"]:
+                        for netslice_subnet in nstd["netslice-subnet"]:
+                            nsi_vld["nsd-ref"] = netslice_subnet["nsd-ref"]
+                            nsi_vld["nsd-connection-point-ref"] = netslice_vld["nsd-connection-point-ref"]
+                            # Obtaining the vimAccountId from template instantiation parameter            
+                            if netslice_subnet.get("instantiation-parameters"):
+                                # Taking the vimAccountId from NST netslice-subnet instantiation parameters
+                                if netslice_subnet["instantiation-parameters"].get("vimAccountId"):
+                                    netsn = netslice_subnet["instantiation-parameters"]["vimAccountId"]
+                                    nsi_vld["vimAccountId"] = netsn
+                            # Obtaining the vimAccountId from user instantiation parameter
+                            if instantiation_parameters.get("netslice-subnet"):
+                                for ins_param in instantiation_parameters["netslice-subnet"]:
+                                    if ins_param.get("id") == netslice_vld["nss-ref"]:
+                                        if ins_param.get("vimAccountId"):
+                                            nsi_vld["vimAccountId"] = ins_param["vimAccountId"]
+                    # Adding vim-network-name / vim-network-id defined by the user to vld
+                    if instantiation_parameters.get("netslice-vld"):
+                        for ins_param in instantiation_parameters["netslice-vld"]:
+                            if ins_param["name"] == netslice_vlds["name"]:
+                                if ins_param.get("vim-network-name"):
+                                    nsi_vld["vim-network-name"] = ins_param.get("vim-network-name")
+                                if ins_param.get("vim-network-id"):
+                                    nsi_vld["vim-network-id"] = ins_param.get("vim-network-id")
+                    if netslice_vlds.get("mgmt-network"):
+                        nsi_vld["mgmt-network"] = netslice_vlds.get("mgmt-network")
+                    nsi_vlds.append(nsi_vld)
+
+            nsi_descriptor["_admin"]["netslice-vld"] = nsi_vlds

             # Creating netslice-subnet_record. 
             needed_nsds = {}
             services = []
             # Creating netslice-subnet_record. 
             needed_nsds = {}
             services = []

+

             for member_ns in nstd["netslice-subnet"]:
                 nsd_id = member_ns["nsd-ref"]
                 step = "getting nstd id='{}' constituent-nsd='{}' from database".format(
             for member_ns in nstd["netslice-subnet"]:
                 nsd_id = member_ns["nsd-ref"]
                 step = "getting nstd id='{}' constituent-nsd='{}' from database".format(


@@ -826,34 +975,90 @@ class NsiTopic(BaseTopic):
                 step = "filling nsir nsd-id='{}' constituent-nsd='{}' from database".format(
                     member_ns["nsd-ref"], member_ns["id"])
 
                 step = "filling nsir nsd-id='{}' constituent-nsd='{}' from database".format(
                     member_ns["nsd-ref"], member_ns["id"])
 

-            step = "creating nsi at database"
-            self.format_on_new(nsi_descriptor, session["project_id"], make_public=make_public)
-            nsi_descriptor["_admin"]["nsiState"] = "NOT_INSTANTIATED"          
+            # check additionalParamsForSubnet contains a valid id
+            if slice_request.get("additionalParamsForSubnet"):
+                for additional_params_subnet in get_iterable(slice_request.get("additionalParamsForSubnet")):
+                    for service in services:
+                        if additional_params_subnet["id"] == service["id"]:
+                            break
+                    else:
+                        raise EngineException("Error at additionalParamsForSubnet:id='{}' not match any "
+                                              "netslice-subnet:id".format(additional_params_subnet["id"]))

 
 

-            ns_params = indata.get("ns")
-            

             # creates Network Services records (NSRs)
             step = "creating nsrs at database using NsrTopic.new()"
             # creates Network Services records (NSRs)
             step = "creating nsrs at database using NsrTopic.new()"

+            ns_params = slice_request.get("netslice-subnet")
+

             nsrs_list = []
             nsrs_list = []

+            nsi_netslice_subnet = []

             for service in services:
                 indata_ns = {}
                 indata_ns["nsdId"] = service["_id"]
             for service in services:
                 indata_ns = {}
                 indata_ns["nsdId"] = service["_id"]

-                indata_ns["nsName"] = service["id"]
-                indata_ns["vimAccountId"] = indata.get("vimAccountId")
+                indata_ns["nsName"] = slice_request.get("nsiName") + "." + service["id"]
+                indata_ns["vimAccountId"] = slice_request.get("vimAccountId")

                 indata_ns["nsDescription"] = service["description"]
                 indata_ns["key-pair-ref"] = None
                 indata_ns["nsDescription"] = service["description"]
                 indata_ns["key-pair-ref"] = None

+                for additional_params_subnet in get_iterable(slice_request.get("additionalParamsForSubnet")):
+                    if additional_params_subnet["id"] == service["id"]:
+                        if additional_params_subnet.get("additionalParamsForNs"):
+                            indata_ns["additionalParamsForNs"] = additional_params_subnet["additionalParamsForNs"]
+                        if additional_params_subnet.get("additionalParamsForVnf"):
+                            indata_ns["additionalParamsForVnf"] = additional_params_subnet["additionalParamsForVnf"]
+                        break
+

                 # NsrTopic(rollback, session, indata_ns, kwargs, headers, force)
                 # Overwriting ns_params filtering by nsName == netslice-subnet.id
                 # NsrTopic(rollback, session, indata_ns, kwargs, headers, force)
                 # Overwriting ns_params filtering by nsName == netslice-subnet.id

+

                 if ns_params:
                     for ns_param in ns_params:
                 if ns_params:
                     for ns_param in ns_params:

-                        if ns_param["nsName"] == service["id"]:
-                            indata_ns.update(ns_param)
-                _id_nsr = NsrTopic.new(self, rollback, session, indata_ns, kwargs, headers, force)
+                        if ns_param.get("id") == service["id"]:
+                            copy_ns_param = deepcopy(ns_param)
+                            del copy_ns_param["id"]
+                            indata_ns.update(copy_ns_param)
+                # TODO: Improve network selection via networkID
+                # Override the instantiation parameters for netslice-vld provided by user
+                if nsi_vlds:
+                    indata_ns_list = []
+                    for nsi_vld in nsi_vlds:
+                        nsd = self.db.get_one("nsds", {"id": nsi_vld["nsd-ref"]})
+                        if nsd["connection-point"]:
+                            for cp_item in nsd["connection-point"]:
+                                if cp_item["name"] == nsi_vld["nsd-connection-point-ref"]:
+                                    vld_id_ref = cp_item["vld-id-ref"]
+                                    # Mapping the vim-network-name or vim-network-id instantiation parameters
+                                    if nsi_vld.get("vim-network-id"):
+                                        vnid = nsi_vld.get("vim-network-id")
+                                        if type(vnid) is not dict:
+                                            vim_network_id = {slice_request.get("vimAccountId"): vnid}
+                                        else:  # is string
+                                            vim_network_id = vnid
+                                        indata_ns_list.append({"name": vld_id_ref, "vim-network-id": vim_network_id})
+                                    # Case not vim-network-name instantiation parameter
+                                    elif nsi_vld.get("vim-network-name"):
+                                        vnm = nsi_vld.get("vim-network-name")
+                                        if type(vnm) is not dict:
+                                            vim_network_name = {slice_request.get("vimAccountId"): vnm}
+                                        else:  # is string
+                                            vim_network_name = vnm
+                                        indata_ns_list.append({"name": vld_id_ref,
+                                                              "vim-network-name": vim_network_name})
+                                    # Case neither vim-network-name nor vim-network-id provided
+                                    else:
+                                        indata_ns_list.append({"name": vld_id_ref})
+                    if indata_ns_list:
+                        indata_ns["vld"] = indata_ns_list
+
+                # Creates Nsr objects
+                _id_nsr = self.nsrTopic.new(rollback, session, indata_ns, kwargs, headers, force)

                 nsrs_item = {"nsrId": _id_nsr}
                 nsrs_list.append(nsrs_item)
                 nsrs_item = {"nsrId": _id_nsr}
                 nsrs_list.append(nsrs_item)

+                nsi_netslice_subnet.append(indata_ns)
+                nsr_ref = {"nsr-ref": _id_nsr}
+                nsi_descriptor["nsr-ref-list"].append(nsr_ref)

 
             # Adding the nsrs list to the nsi
             nsi_descriptor["_admin"]["nsrs-detailed-list"] = nsrs_list
 
             # Adding the nsrs list to the nsi
             nsi_descriptor["_admin"]["nsrs-detailed-list"] = nsrs_list

+            nsi_descriptor["_admin"]["netslice-subnet"] = nsi_netslice_subnet

             # Creating the entry in the database
             self.db.create("nsis", nsi_descriptor)
             rollback.append({"topic": "nsis", "_id": nsi_id})
             # Creating the entry in the database
             self.db.create("nsis", nsi_descriptor)
             rollback.append({"topic": "nsis", "_id": nsi_id})


@@ -890,21 +1095,21 @@ class NsiLcmOpTopic(BaseTopic):
         nsds = {}
         nstd = nsir["network-slice-template"]
 
         nsds = {}
         nstd = nsir["network-slice-template"]
 

-        def check_valid_netslice_subnet_id(nsId):
+        def check_valid_netslice_subnet_id(nstId):

             # TODO change to vnfR (??)
             # TODO change to vnfR (??)

-            for ns in nstd["netslice-subnet"]:
-                if nsId == ns["id"]:
-                    nsd_id = ns["nsd-ref"]
+            for netslice_subnet in nstd["netslice-subnet"]:
+                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})
                     return nsds[nsd_id]
             else:
                     if nsd_id not in nsds:
                         nsds[nsd_id] = self.db.get_one("nsds", {"id": nsd_id})
                     return nsds[nsd_id]
             else:

-                raise EngineException("Invalid parameter nsId='{}' is not one of the "
-                                      "nst:netslice-subnet".format(nsId))
+                raise EngineException("Invalid parameter nstId='{}' is not one of the "
+                                      "nst:netslice-subnet".format(nstId))

         if operation == "instantiate":
             # check the existance of netslice-subnet items
         if operation == "instantiate":
             # check the existance of netslice-subnet items

-            for in_nst in get_iterable(indata.get("netslice-subnet")):           
-                nstd = check_valid_netslice_subnet_id(in_nst["nsdId"])
+            for in_nst in get_iterable(indata.get("netslice-subnet")):   
+                check_valid_netslice_subnet_id(in_nst["id"])

 
     def _create_nsilcmop(self, session, netsliceInstanceId, operation, params):
         now = time()
 
     def _create_nsilcmop(self, session, netsliceInstanceId, operation, params):
         now = time()


@@ -957,7 +1162,7 @@ class NsiLcmOpTopic(BaseTopic):
             if not nsir["_admin"].get("nsiState") or nsir["_admin"]["nsiState"] == "NOT_INSTANTIATED":
                 if operation == "terminate" and indata.get("autoremove"):
                     # NSIR must be deleted
             if not nsir["_admin"].get("nsiState") or nsir["_admin"]["nsiState"] == "NOT_INSTANTIATED":
                 if operation == "terminate" and indata.get("autoremove"):
                     # NSIR must be deleted

-                    return self.delete(session, nsiInstanceId)
+                    return None    # a none in this case is used to indicate not instantiated. It can be removed

                 if operation != "instantiate":
                     raise EngineException("netslice_instance '{}' cannot be '{}' because it is not instantiated".format(
                         nsiInstanceId, operation), HTTPStatus.CONFLICT)
                 if operation != "instantiate":
                     raise EngineException("netslice_instance '{}' cannot be '{}' because it is not instantiated".format(
                         nsiInstanceId, operation), HTTPStatus.CONFLICT)