+ vim_2_RO = {}
+ RO = ROclient.ROClient(self.loop, **self.ro_config)
+ nsi_vld_instantiationi_params = {}
+
+ def ip_profile_2_RO(ip_profile):
+ RO_ip_profile = deepcopy((ip_profile))
+ if "dns-server" in RO_ip_profile:
+ if isinstance(RO_ip_profile["dns-server"], list):
+ RO_ip_profile["dns-address"] = []
+ for ds in RO_ip_profile.pop("dns-server"):
+ RO_ip_profile["dns-address"].append(ds["address"])
+ else:
+ RO_ip_profile["dns-address"] = RO_ip_profile.pop("dns-server")
+ if RO_ip_profile.get("ip-version") == "ipv4":
+ RO_ip_profile["ip-version"] = "IPv4"
+ if RO_ip_profile.get("ip-version") == "ipv6":
+ RO_ip_profile["ip-version"] = "IPv6"
+ if "dhcp-params" in RO_ip_profile:
+ RO_ip_profile["dhcp"] = RO_ip_profile.pop("dhcp-params")
+ return RO_ip_profile
+
+ def vim_account_2_RO(vim_account):
+ """
+ Translate a RO vim_account from OSM vim_account params
+ :param ns_params: OSM instantiate params
+ :return: The RO ns descriptor
+ """
+ if vim_account in vim_2_RO:
+ return vim_2_RO[vim_account]
+
+ db_vim = self.db.get_one("vim_accounts", {"_id": vim_account})
+ if db_vim["_admin"]["operationalState"] != "ENABLED":
+ raise LcmException(
+ "VIM={} is not available. operationalState={}".format(
+ vim_account, db_vim["_admin"]["operationalState"]
+ )
+ )
+ RO_vim_id = db_vim["_admin"]["deployed"]["RO"]
+ vim_2_RO[vim_account] = RO_vim_id
+ return RO_vim_id
+
+ async def netslice_scenario_create(
+ self, vld_item, nsir_id, db_nsir, db_nsir_admin, db_nsir_update
+ ):
+ """
+ Create a network slice VLD through RO Scenario
+ :param vld_id The VLD id inside nsir to be created
+ :param nsir_id The nsir id
+ """
+ nonlocal nsi_vld_instantiationi_params
+ ip_vld = None
+ mgmt_network = False
+ RO_vld_sites = []
+ vld_id = vld_item["id"]
+ netslice_vld = vld_item
+ # logging_text = "Task netslice={} instantiate_vld={} ".format(nsir_id, vld_id)
+ # self.logger.debug(logging_text + "Enter")
+
+ vld_shared = None
+ for shared_nsrs_item in get_iterable(vld_item, "shared-nsrs-list"):
+ _filter = {
+ "_id.ne": nsir_id,
+ "_admin.nsrs-detailed-list.ANYINDEX.nsrId": shared_nsrs_item,
+ }
+ shared_nsi = self.db.get_one(
+ "nsis", _filter, fail_on_empty=False, fail_on_more=False
+ )
+ if shared_nsi:
+ for vlds in get_iterable(shared_nsi["_admin"]["deployed"], "RO"):
+ if vld_id == vlds["vld_id"]:
+ vld_shared = {
+ "instance_scenario_id": vlds["netslice_scenario_id"],
+ "osm_id": vld_id,
+ }
+ break
+ break
+
+ # Creating netslice-vld at RO
+ RO_nsir = deep_get(db_nsir, ("_admin", "deployed", "RO"), [])
+
+ if vld_id in RO_nsir:
+ db_nsir_update["_admin.deployed.RO"] = RO_nsir
+
+ # If netslice-vld doesn't exists then create it
+ else:
+ # TODO: Check VDU type in all descriptors finding SRIOV / PT
+ # Updating network names and datacenters from instantiation parameters for each VLD
+ for instantiation_params_vld in get_iterable(
+ db_nsir["instantiation_parameters"], "netslice-vld"
+ ):
+ if instantiation_params_vld.get("name") == netslice_vld["name"]:
+ ip_vld = deepcopy(instantiation_params_vld)
+ ip_vld.pop("name")
+ nsi_vld_instantiationi_params[netslice_vld["name"]] = ip_vld
+
+ db_nsir_update_RO = {}
+ db_nsir_update_RO["vld_id"] = netslice_vld["name"]
+ if self.ro_config["ng"]:
+ db_nsir_update_RO["netslice_scenario_id"] = (
+ vld_shared.get("instance_scenario_id")
+ if vld_shared
+ else "nsir:{}:vld.{}".format(nsir_id, netslice_vld["name"])
+ )
+ else: # if not self.ro_config["ng"]:
+ if netslice_vld.get("mgmt-network"):
+ mgmt_network = True
+ RO_ns_params = {}
+ RO_ns_params["name"] = netslice_vld["name"]
+ RO_ns_params["datacenter"] = vim_account_2_RO(
+ db_nsir["instantiation_parameters"]["vimAccountId"]
+ )
+
+ # Creating scenario if vim-network-name / vim-network-id are present as instantiation parameter
+ # Use vim-network-id instantiation parameter
+ vim_network_option = None
+ if ip_vld:
+ if ip_vld.get("vim-network-id"):
+ vim_network_option = "vim-network-id"
+ elif ip_vld.get("vim-network-name"):
+ vim_network_option = "vim-network-name"
+ if ip_vld.get("ip-profile"):
+ populate_dict(
+ RO_ns_params,
+ ("networks", netslice_vld["name"], "ip-profile"),
+ ip_profile_2_RO(ip_vld["ip-profile"]),
+ )
+
+ if vim_network_option:
+ if ip_vld.get(vim_network_option):
+ if isinstance(ip_vld.get(vim_network_option), list):
+ for vim_net_id in ip_vld.get(vim_network_option):
+ for vim_account, vim_net in vim_net_id.items():
+ RO_vld_sites.append(
+ {
+ "netmap-use": vim_net,
+ "datacenter": vim_account_2_RO(
+ vim_account
+ ),
+ }
+ )
+ elif isinstance(ip_vld.get(vim_network_option), dict):
+ for vim_account, vim_net in ip_vld.get(
+ vim_network_option
+ ).items():
+ RO_vld_sites.append(
+ {
+ "netmap-use": vim_net,
+ "datacenter": vim_account_2_RO(vim_account),
+ }
+ )
+ else:
+ RO_vld_sites.append(
+ {
+ "netmap-use": ip_vld[vim_network_option],
+ "datacenter": vim_account_2_RO(
+ netslice_vld["vimAccountId"]
+ ),
+ }
+ )
+
+ # Use default netslice vim-network-name from template
+ else:
+ for nss_conn_point_ref in get_iterable(
+ netslice_vld, "nss-connection-point-ref"
+ ):
+ if nss_conn_point_ref.get("vimAccountId"):
+ if (
+ nss_conn_point_ref["vimAccountId"]
+ != netslice_vld["vimAccountId"]
+ ):
+ RO_vld_sites.append(
+ {
+ "netmap-create": None,
+ "datacenter": vim_account_2_RO(
+ nss_conn_point_ref["vimAccountId"]
+ ),
+ }
+ )
+
+ if vld_shared:
+ populate_dict(
+ RO_ns_params,
+ ("networks", netslice_vld["name"], "use-network"),
+ vld_shared,
+ )
+
+ if RO_vld_sites:
+ populate_dict(
+ RO_ns_params,
+ ("networks", netslice_vld["name"], "sites"),
+ RO_vld_sites,
+ )
+
+ RO_ns_params["scenario"] = {
+ "nets": [
+ {
+ "name": netslice_vld["name"],
+ "external": mgmt_network,
+ "type": "bridge",
+ }
+ ]
+ }
+
+ # self.logger.debug(logging_text + step)
+ desc = await RO.create("ns", descriptor=RO_ns_params)
+ db_nsir_update_RO["netslice_scenario_id"] = desc["uuid"]
+ db_nsir_update["_admin.deployed.RO"].append(db_nsir_update_RO)
+
+ def overwrite_nsd_params(self, db_nsir, nslcmop):
+ nonlocal nsi_vld_instantiationi_params
+ nonlocal db_nsir_update
+ vld_op_list = []
+ vld = None
+ nsr_id = nslcmop.get("nsInstanceId")
+ # Overwrite instantiation parameters in netslice runtime
+ RO_list = db_nsir_admin["deployed"]["RO"]
+
+ for ro_item_index, RO_item in enumerate(RO_list):
+ netslice_vld = next(
+ (
+ n
+ for n in get_iterable(db_nsir["_admin"], "netslice-vld")
+ if RO_item.get("vld_id") == n.get("id")
+ ),
+ None,
+ )
+ if not netslice_vld:
+ continue
+ # if is equal vld of _admin with vld of netslice-vld then go for the CPs
+ # Search the cp of netslice-vld that match with nst:netslice-subnet
+ for nss_cp_item in get_iterable(
+ netslice_vld, "nss-connection-point-ref"
+ ):
+ # Search the netslice-subnet of nst that match
+ nss = next(
+ (
+ nss
+ for nss in get_iterable(
+ db_nsir["_admin"], "netslice-subnet"
+ )
+ if nss_cp_item["nss-ref"] == nss["nss-id"]
+ ),
+ None,
+ )
+ # Compare nss-ref equal nss from nst
+ if not nss:
+ continue
+ db_nsds = self.db.get_one("nsds", {"_id": nss["nsdId"]})
+ # Go for nsd, and search the CP that match with nst:CP to get vld-id-ref
+ for cp_nsd in db_nsds.get("sapd", ()):
+ if cp_nsd["id"] == nss_cp_item["nsd-connection-point-ref"]:
+ if nslcmop.get("operationParams"):
+ if (
+ nslcmop["operationParams"].get("nsName")
+ == nss["nsName"]
+ ):
+ vld_id = RO_item["vld_id"]
+ netslice_scenario_id = RO_item[
+ "netslice_scenario_id"
+ ]
+ nslcmop_vld = {}
+ nslcmop_vld["name"] = cp_nsd["virtual-link-desc"]
+ for vld in get_iterable(
+ nslcmop["operationParams"], "vld"
+ ):
+ if vld["name"] == cp_nsd["virtual-link-desc"]:
+ nslcmop_vld.update(vld)
+ if self.ro_config["ng"]:
+ nslcmop_vld["common_id"] = netslice_scenario_id
+ nslcmop_vld.update(
+ nsi_vld_instantiationi_params.get(
+ RO_item["vld_id"], {}
+ )
+ )
+ else:
+ nslcmop_vld["ns-net"] = {
+ vld_id: netslice_scenario_id
+ }
+ vld_op_list.append(nslcmop_vld)
+ nslcmop["operationParams"]["vld"] = vld_op_list
+ self.update_db_2(
+ "nslcmops", nslcmop["_id"], {"operationParams.vld": vld_op_list}
+ )
+ return nsr_id, nslcmop