db = kwargs.get("db")
target_vdur = {}
+ for vnf in indata.get("vnf", []):
+ for vdur in vnf.get("vdur", []):
+ if vdur.get("ns-flavor-id") == target_flavor.get("id"):
+ target_vdur = vdur
+
+ vim_flavor_id = (
+ target_vdur.get("additionalParams", {}).get("OSM", {}).get("vim_flavor_id")
+ )
+ if vim_flavor_id: # vim-flavor-id was passed so flavor won't be created
+ return {"find_params": {"vim_flavor_id": vim_flavor_id}}
+
flavor_data = {
"disk": int(target_flavor["storage-gb"]),
"ram": int(target_flavor["memory-mb"]),
"vcpus": int(target_flavor["vcpu-count"]),
}
- for vnf in indata.get("vnf", []):
- for vdur in vnf.get("vdur", []):
- if vdur.get("ns-flavor-id") == target_flavor.get("id"):
- target_vdur = vdur
-
if db and isinstance(indata.get("vnf"), list):
vnfd_id = indata.get("vnf")[0].get("vnfd-id")
vnfd = db.get_one("vnfds", {"_id": vnfd_id})
disk_list.append(persistent_root_disk[vsd["id"]])
return persistent_root_disk
+ return persistent_root_disk
@staticmethod
def find_persistent_volumes(
persistent_root_disk: dict,
persistent_ordinary_disk: dict,
disk_list: list,
+ extra_dict: dict,
vnf_id: str = None,
+ nsr_id: str = None,
) -> None:
"""Fill the disk list by adding persistent ordinary disks.
"multiattach": multiattach,
}
disk_list.append(persistent_ordinary_disk[disk["id"]])
+ if multiattach: # VDU creation has to wait for shared volumes
+ extra_dict["depends_on"].append(
+ f"nsrs:{nsr_id}:shared-volumes.{name}"
+ )
@staticmethod
def _prepare_vdu_affinity_group_list(
vnf_preffix = "vnfrs:{}".format(vnfr_id)
ns_preffix = "nsrs:{}".format(nsr_id)
image_text = ns_preffix + ":image." + target_vdu["ns-image-id"]
- extra_dict = {"depends_on": [image_text]}
+ flavor_text = ns_preffix + ":flavor." + target_vdu["ns-flavor-id"]
+ extra_dict = {"depends_on": [image_text, flavor_text]}
net_list = []
persistent_root_disk = {}
persistent_ordinary_disk = {}
vdu_instantiation_volumes_list = []
- vdu_instantiation_flavor_id = None
disk_list = []
vnfd_id = vnfr["vnfd-id"]
vnfd = db.get_one("vnfds", {"_id": vnfd_id})
vdu_instantiation_volumes_list = (
target_vdu.get("additionalParams").get("OSM", {}).get("vdu_volumes")
)
- vdu_instantiation_flavor_id = (
- target_vdu.get("additionalParams").get("OSM", {}).get("vim_flavor_id")
- )
-
- # flavor id
- if vdu_instantiation_flavor_id:
- flavor_id = vdu_instantiation_flavor_id
- else:
- flavor_text = ns_preffix + ":flavor." + target_vdu["ns-flavor-id"]
- flavor_id = "TASK-" + flavor_text
- extra_dict["depends_on"].append(flavor_text)
if vdu_instantiation_volumes_list:
# Find the root volumes and add to the disk_list
persistent_root_disk,
persistent_ordinary_disk,
disk_list,
+ extra_dict,
vnfd["id"],
+ nsr_id,
)
affinity_group_list = Ns._prepare_vdu_affinity_group_list(
"description": target_vdu["vdu-name"],
"start": True,
"image_id": "TASK-" + image_text,
- "flavor_id": flavor_id,
+ "flavor_id": "TASK-" + flavor_text,
"affinity_group_list": affinity_group_list,
"net_list": net_list,
"cloud_config": cloud_config or None,
"size": target_shared_volume["size-of-storage"],
"name": target_shared_volume["id"],
"type": target_shared_volume["type-of-storage"],
+ "keep": Ns.is_volume_keeping_required(target_shared_volume),
}
extra_dict["params"] = shared_volume_data
return extra_dict
"image",
"flavor",
"affinity-or-anti-affinity-group",
- "shared-volumes",
]:
self.logger.debug("process NS={} {}".format(nsr_id, item))
diff_items, task_index = self.calculate_diff_items(
# VNF vlds and vdus
for vnfr_id, vnfr in db_vnfrs.items():
# vnfr_id need to be set as global variable for among others nested method _process_vdu_params
- for item in ["net", "vdu"]:
+ for item in ["net", "vdu", "shared-volumes"]:
self.logger.debug("process VNF={} {}".format(vnfr_id, item))
diff_items, task_index = self.calculate_diff_items(
indata=indata,
extra_dict,
):
self._assign_vim(target_vim)
- target_record = "vnfrs:{}:vdur.{}".format(vnf_id, vdu_index)
+ target_record = "vnfrs:{}:vdur.{}.vim_info.{}".format(
+ vnf_id, vdu_index, target_vim
+ )
target_record_id = "vnfrs:{}:vdur.{}".format(vnf_id, vdu_id)
deployment_info = {
"action_id": action_id,
):
target_vim, vim_info = next(k_v for k_v in vdu["vim_info"].items())
self._assign_vim(target_vim)
- target_record = "vnfrs:{}:vdur.{}".format(vnf["_id"], vdu_index)
+ target_record = "vnfrs:{}:vdur.{}.vim_info.{}".format(
+ vnf["_id"], vdu_index, target_vim
+ )
target_record_id = "vnfrs:{}:vdur.{}".format(vnf["_id"], vdu["id"])
deployment_info = {
"action_id": action_id,
):
target_vim, vim_info = next(k_v for k_v in vdu["vim_info"].items())
self._assign_vim(target_vim)
- target_record = "vnfrs:{}:vdur.{}".format(vnf["_id"], vdu_index)
+ ns_preffix = "nsrs:{}".format(nsr_id)
+ flavor_text = ns_preffix + ":flavor." + vdu["ns-flavor-id"]
+ extra_dict["depends_on"] = [flavor_text]
+ extra_dict["params"].update({"flavor_id": "TASK-" + flavor_text})
+ target_record = "vnfrs:{}:vdur.{}.vim_info.{}".format(
+ vnf["_id"], vdu_index, target_vim
+ )
target_record_id = "vnfrs:{}:vdur.{}".format(vnf["_id"], vdu["id"])
deployment_info = {
"action_id": action_id,
)
return task
+ def verticalscale_flavor_task(
+ self, vdu, vnf, vdu_index, action_id, nsr_id, task_index, extra_dict
+ ):
+ target_vim, vim_info = next(k_v for k_v in vdu["vim_info"].items())
+ self._assign_vim(target_vim)
+ db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
+ target_record = "nsrs:{}:flavor.{}.vim_info.{}".format(
+ nsr_id, len(db_nsr["flavor"]) - 1, target_vim
+ )
+ target_record_id = "nsrs:{}:flavor.{}".format(nsr_id, len(db_nsr["flavor"]) - 1)
+ deployment_info = {
+ "action_id": action_id,
+ "nsr_id": nsr_id,
+ "task_index": task_index,
+ }
+ task = Ns._create_task(
+ deployment_info=deployment_info,
+ target_id=target_vim,
+ item="flavor",
+ action="CREATE",
+ target_record=target_record,
+ target_record_id=target_record_id,
+ extra_dict=extra_dict,
+ )
+ return task
+
def verticalscale(self, session, indata, version, nsr_id, *args, **kwargs):
task_index = 0
extra_dict = {}
+ flavor_extra_dict = {}
now = time()
action_id = indata.get("action_id", str(uuid4()))
step = ""
"vcpus": numVirtualCpu,
"disk": sizeOfStorage,
}
+ flavor_data = {
+ "ram": virtualMemory,
+ "vcpus": numVirtualCpu,
+ "disk": sizeOfStorage,
+ }
+ flavor_extra_dict["find_params"] = {"flavor_data": flavor_data}
+ flavor_extra_dict["params"] = {"flavor_data": flavor_dict}
db_new_tasks = []
step = "Creating Tasks for vertical scaling"
with self.write_lock:
extra_dict["params"] = {
"vim_vm_id": vdu["vim-id"],
"flavor_dict": flavor_dict,
+ "vdu-id-ref": vdu["vdu-id-ref"],
+ "count-index": vdu["count-index"],
+ "vnf_instance_id": vnf_instance_id,
}
+ task = self.verticalscale_flavor_task(
+ vdu,
+ db_vnfr,
+ vdu_index,
+ action_id,
+ nsr_id,
+ task_index,
+ flavor_extra_dict,
+ )
+ db_new_tasks.append(task)
+ task_index += 1
task = self.verticalscale_task(
vdu,
db_vnfr,
projects / osm / RO.git / blobdiff