import traceback
from jinja2 import Environment, Template, meta, TemplateError, TemplateNotFound, TemplateSyntaxError
-import ROclient
-from lcm_utils import LcmException, LcmExceptionNoMgmtIP, LcmBase
+from osm_lcm import ROclient
+from osm_lcm.lcm_utils import LcmException, LcmExceptionNoMgmtIP, LcmBase
from osm_common.dbbase import DbException
from osm_common.fsbase import FsException
def populate_dict(target_dict, key_list, value):
"""
- Upate target_dict creating nested dictionaries with the key_list. Last key_list item is asigned the value.
+ Update target_dict creating nested dictionaries with the key_list. Last key_list item is asigned the value.
Example target_dict={K: J}; key_list=[a,b,c]; target_dict will be {K: J, a: {b: {c: value}}}
:param target_dict: dictionary to be changed
:param key_list: list of keys to insert at target_dict
target_dict[key_list[-1]] = value
+def deep_get(target_dict, key_list):
+ """
+ Get a value from target_dict entering in the nested keys. If keys does not exist, it returns None
+ Example target_dict={a: {b: 5}}; key_list=[a,b] returns 5; both key_list=[a,b,c] and key_list=[f,h] return None
+ :param target_dict: dictionary to be read
+ :param key_list: list of keys to read from target_dict
+ :return: The wanted value if exist, None otherwise
+ """
+ for key in key_list:
+ if not isinstance(target_dict, dict) or key not in target_dict:
+ return None
+ target_dict = target_dict[key]
+ return target_dict
+
+
class NsLcm(LcmBase):
timeout_vca_on_error = 5 * 60 # Time for charm from first time at blocked,error status to mark as failed
total_deploy_timeout = 2 * 3600 # global timeout for deployment
timeout_charm_delete = 10 * 60
timeout_primitive = 10 * 60 # timeout for primitive execution
+ SUBOPERATION_STATUS_NOT_FOUND = -1
+ SUBOPERATION_STATUS_NEW = -2
+ SUBOPERATION_STATUS_SKIP = -3
+
def __init__(self, db, msg, fs, lcm_tasks, ro_config, vca_config, loop):
"""
Init, Connect to database, filesystem storage, and messaging
artifacts=None,
juju_public_key=vca_config.get('pubkey'),
ca_cert=vca_config.get('cacert'),
+ api_proxy=vca_config.get('apiproxy')
)
+ self.RO = ROclient.ROClient(self.loop, **self.ro_config)
def vnfd2RO(self, vnfd, new_id=None, additionalParams=None, nsrId=None):
"""
"wim_account": wim_account_2_RO(ns_params.get("wimAccountId")),
# "scenario": ns_params["nsdId"],
}
- if n2vc_key_list:
- for vnfd_ref, vnfd in vnfd_dict.items():
- vdu_needed_access = []
- mgmt_cp = None
- if vnfd.get("vnf-configuration"):
- if vnfd.get("mgmt-interface"):
- if vnfd["mgmt-interface"].get("vdu-id"):
- vdu_needed_access.append(vnfd["mgmt-interface"]["vdu-id"])
- elif vnfd["mgmt-interface"].get("cp"):
- mgmt_cp = vnfd["mgmt-interface"]["cp"]
-
- for vdu in vnfd.get("vdu", ()):
- if vdu.get("vdu-configuration"):
+ n2vc_key_list = n2vc_key_list or []
+ for vnfd_ref, vnfd in vnfd_dict.items():
+ vdu_needed_access = []
+ mgmt_cp = None
+ if vnfd.get("vnf-configuration"):
+ ssh_required = deep_get(vnfd, ("vnf-configuration", "config-access", "ssh-access", "required"))
+ if ssh_required and vnfd.get("mgmt-interface"):
+ if vnfd["mgmt-interface"].get("vdu-id"):
+ vdu_needed_access.append(vnfd["mgmt-interface"]["vdu-id"])
+ elif vnfd["mgmt-interface"].get("cp"):
+ mgmt_cp = vnfd["mgmt-interface"]["cp"]
+
+ for vdu in vnfd.get("vdu", ()):
+ if vdu.get("vdu-configuration"):
+ ssh_required = deep_get(vdu, ("vdu-configuration", "config-access", "ssh-access", "required"))
+ if ssh_required:
vdu_needed_access.append(vdu["id"])
- elif mgmt_cp:
- for vdu_interface in vdu.get("interface"):
- if vdu_interface.get("external-connection-point-ref") and \
- vdu_interface["external-connection-point-ref"] == mgmt_cp:
- vdu_needed_access.append(vdu["id"])
- mgmt_cp = None
- break
+ elif mgmt_cp:
+ for vdu_interface in vdu.get("interface"):
+ if vdu_interface.get("external-connection-point-ref") and \
+ vdu_interface["external-connection-point-ref"] == mgmt_cp:
+ vdu_needed_access.append(vdu["id"])
+ mgmt_cp = None
+ break
- if vdu_needed_access:
- for vnf_member in nsd.get("constituent-vnfd"):
- if vnf_member["vnfd-id-ref"] != vnfd_ref:
- continue
- for vdu in vdu_needed_access:
- populate_dict(RO_ns_params,
- ("vnfs", vnf_member["member-vnf-index"], "vdus", vdu, "mgmt_keys"),
- n2vc_key_list)
+ if vdu_needed_access:
+ for vnf_member in nsd.get("constituent-vnfd"):
+ if vnf_member["vnfd-id-ref"] != vnfd_ref:
+ continue
+ for vdu in vdu_needed_access:
+ populate_dict(RO_ns_params,
+ ("vnfs", vnf_member["member-vnf-index"], "vdus", vdu, "mgmt_keys"),
+ n2vc_key_list)
if ns_params.get("vduImage"):
RO_ns_params["vduImage"] = ns_params["vduImage"]
populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "networks",
internal_vld_params["name"], "ip-profile"),
ip_profile_2_RO(internal_vld_params["ip-profile"]))
+ if internal_vld_params.get("provider-network"):
+
+ populate_dict(RO_ns_params, ("vnfs", vnf_params["member-vnf-index"], "networks",
+ internal_vld_params["name"], "provider-network"),
+ internal_vld_params["provider-network"].copy())
for icp_params in get_iterable(internal_vld_params, "internal-connection-point"):
# look for interface
populate_dict(RO_ns_params, ("networks", vld_params["name"], "ip-profile"),
ip_profile_2_RO(vld_params["ip-profile"]))
+ if vld_params.get("provider-network"):
+
+ populate_dict(RO_ns_params, ("networks", vld_params["name"], "provider-network"),
+ vld_params["provider-network"].copy())
+
if "wimAccountId" in vld_params and vld_params["wimAccountId"] is not None:
populate_dict(RO_ns_params, ("networks", vld_params["name"], "wim_account"),
wim_account_2_RO(vld_params["wimAccountId"])),
RO_vld_sites.append({"netmap-use": vld_params["vim-network-name"]})
if RO_vld_sites:
populate_dict(RO_ns_params, ("networks", vld_params["name"], "sites"), RO_vld_sites)
+
if vld_params.get("vim-network-id"):
RO_vld_sites = []
if isinstance(vld_params["vim-network-id"], dict):
for vld_id, instance_scenario_id in vld_params["ns-net"].items():
RO_vld_ns_net = {"instance_scenario_id": instance_scenario_id, "osm_id": vld_id}
if RO_vld_ns_net:
- populate_dict(RO_ns_params, ("networks", vld_params["name"], "use-network"), RO_vld_ns_net)
+ populate_dict(RO_ns_params, ("networks", vld_params["name"], "use-network"), RO_vld_ns_net)
if "vnfd-connection-point-ref" in vld_params:
for cp_params in vld_params["vnfd-connection-point-ref"]:
# look for interface
break
else:
raise LcmException("ns_update_vnfr: Not found member_vnf_index={} vdur={} interface={} "
- "at RO info".format(vnf_index, vdur["vdu-id-ref"], ifacer["name"]))
+ "from VIM info".format(vnf_index, vdur["vdu-id-ref"],
+ ifacer["name"]))
vnfr_update["vdur.{}".format(vdu_index)] = vdur
break
else:
- raise LcmException("ns_update_vnfr: Not found member_vnf_index={} vdur={} count_index={} at "
- "RO info".format(vnf_index, vdur["vdu-id-ref"], vdur["count-index"]))
+ raise LcmException("ns_update_vnfr: Not found member_vnf_index={} vdur={} count_index={} from "
+ "VIM info".format(vnf_index, vdur["vdu-id-ref"], vdur["count-index"]))
for vld_index, vld in enumerate(get_iterable(db_vnfr, "vld")):
for net_RO in get_iterable(nsr_desc_RO, "nets"):
vnfr_update["vld.{}".format(vld_index)] = vld
break
else:
- raise LcmException("ns_update_vnfr: Not found member_vnf_index={} vld={} at RO info".format(
+ raise LcmException("ns_update_vnfr: Not found member_vnf_index={} vld={} from VIM info".format(
vnf_index, vld["id"]))
self.update_db_2("vnfrs", db_vnfr["_id"], vnfr_update)
break
else:
- raise LcmException("ns_update_vnfr: Not found member_vnf_index={} at RO info".format(vnf_index))
+ raise LcmException("ns_update_vnfr: Not found member_vnf_index={} from VIM info".format(vnf_index))
async def instantiate(self, nsr_id, nslcmop_id):
exc = None
try:
# wait for any previous tasks in process
+ step = "Waiting for previous tasks"
await self.lcm_tasks.waitfor_related_HA('ns', 'nslcmops', nslcmop_id)
step = "Getting nslcmop={} from db".format(nslcmop_id)
db_nsr_update["detailed-status"] = "creating"
db_nsr_update["operational-status"] = "init"
- if not db_nsr["_admin"].get("deployed") or not db_nsr["_admin"]["deployed"].get("RO") or \
- not db_nsr["_admin"]["deployed"]["RO"].get("vnfd"):
+ if not isinstance(deep_get(db_nsr, ("_admin", "deployed", "RO", "vnfd")), list):
populate_dict(db_nsr, ("_admin", "deployed", "RO", "vnfd"), [])
db_nsr_update["_admin.deployed.RO.vnfd"] = []
machine_spec = {}
if native_charm:
- machine_spec["username"] = charm_params.get("username"),
+ machine_spec["username"] = charm_params.get("username")
machine_spec["hostname"] = charm_params.get("rw_mgmt_ip")
# Note: The charm needs to exist on disk at the location
if vdu_config["juju"].get("proxy") is False:
# native_charm, will be deployed after VM. Skip
proxy_charm = None
-
if proxy_charm:
if not vca_model_name:
step = "creating VCA model name"
if ns_config["juju"].get("proxy") is False:
# native_charm, will be deployed after VM. Skip
proxy_charm = None
-
if proxy_charm:
step = "deploying proxy charm to configure ns"
# TODO is NS magmt IP address needed?
.format(vca_deployed["member-vnf-index"], vca_deployed["vdu_id"]))
# deploy RO
- RO = ROclient.ROClient(self.loop, **self.ro_config)
# get vnfds, instantiate at RO
for c_vnf in nsd.get("constituent-vnfd", ()):
member_vnf_index = c_vnf["member-vnf-index"]
# look if present
RO_update = {"member-vnf-index": member_vnf_index}
- vnfd_list = await RO.get_list("vnfd", filter_by={"osm_id": vnfd_id_RO})
+ vnfd_list = await self.RO.get_list("vnfd", filter_by={"osm_id": vnfd_id_RO})
if vnfd_list:
RO_update["id"] = vnfd_list[0]["uuid"]
self.logger.debug(logging_text + "vnfd='{}' member_vnf_index='{}' exists at RO. Using RO_id={}".
else:
vnfd_RO = self.vnfd2RO(vnfd, vnfd_id_RO, db_vnfrs[c_vnf["member-vnf-index"]].
get("additionalParamsForVnf"), nsr_id)
- desc = await RO.create("vnfd", descriptor=vnfd_RO)
+ desc = await self.RO.create("vnfd", descriptor=vnfd_RO)
RO_update["id"] = desc["uuid"]
self.logger.debug(logging_text + "vnfd='{}' member_vnf_index='{}' created at RO. RO_id={}".format(
vnfd_ref, member_vnf_index, desc["uuid"]))
RO_osm_nsd_id = "{}.{}.{}".format(nsr_id, RO_descriptor_number, nsd_ref[:23])
RO_descriptor_number += 1
- nsd_list = await RO.get_list("nsd", filter_by={"osm_id": RO_osm_nsd_id})
+ nsd_list = await self.RO.get_list("nsd", filter_by={"osm_id": RO_osm_nsd_id})
if nsd_list:
db_nsr_update["_admin.deployed.RO.nsd_id"] = RO_nsd_uuid = nsd_list[0]["uuid"]
self.logger.debug(logging_text + "nsd={} exists at RO. Using RO_id={}".format(
member_vnf_index = cp["member-vnf-index-ref"]
cp["vnfd-id-ref"] = vnf_index_2_RO_id[member_vnf_index]
- desc = await RO.create("nsd", descriptor=nsd_RO)
+ desc = await self.RO.create("nsd", descriptor=nsd_RO)
db_nsr_update["_admin.nsState"] = "INSTANTIATED"
db_nsr_update["_admin.deployed.RO.nsd_id"] = RO_nsd_uuid = desc["uuid"]
self.logger.debug(logging_text + "nsd={} created at RO. RO_id={}".format(nsd_ref, RO_nsd_uuid))
# Crate ns at RO
# if present use it unless in error status
- RO_nsr_id = db_nsr["_admin"].get("deployed", {}).get("RO", {}).get("nsr_id")
+ RO_nsr_id = deep_get(db_nsr, ("_admin", "deployed", "RO", "nsr_id"))
if RO_nsr_id:
try:
step = db_nsr_update["detailed-status"] = "Looking for existing ns at RO"
# self.logger.debug(logging_text + step + " RO_ns_id={}".format(RO_nsr_id))
- desc = await RO.show("ns", RO_nsr_id)
+ desc = await self.RO.show("ns", RO_nsr_id)
except ROclient.ROClientException as e:
if e.http_code != HTTPStatus.NOT_FOUND:
raise
RO_nsr_id = db_nsr_update["_admin.deployed.RO.nsr_id"] = None
if RO_nsr_id:
- ns_status, ns_status_info = RO.check_ns_status(desc)
+ ns_status, ns_status_info = self.RO.check_ns_status(desc)
db_nsr_update["_admin.deployed.RO.nsr_status"] = ns_status
if ns_status == "ERROR":
step = db_nsr_update["detailed-status"] = "Deleting ns at RO. RO_ns_id={}".format(RO_nsr_id)
self.logger.debug(logging_text + step)
- await RO.delete("ns", RO_nsr_id)
+ await self.RO.delete("ns", RO_nsr_id)
RO_nsr_id = db_nsr_update["_admin.deployed.RO.nsr_id"] = None
if not RO_nsr_id:
step = db_nsr_update["detailed-status"] = "Checking dependencies"
n2vc_key_list.append(n2vc_key)
RO_ns_params = self.ns_params_2_RO(ns_params, nsd, db_vnfds_ref, n2vc_key_list)
- step = db_nsr_update["detailed-status"] = "Creating ns at RO"
- desc = await RO.create("ns", descriptor=RO_ns_params,
- name=db_nsr["name"],
- scenario=RO_nsd_uuid)
+ step = db_nsr_update["detailed-status"] = "Deploying ns at VIM"
+ desc = await self.RO.create("ns", descriptor=RO_ns_params,
+ name=db_nsr["name"],
+ scenario=RO_nsd_uuid)
RO_nsr_id = db_nsr_update["_admin.deployed.RO.nsr_id"] = desc["uuid"]
db_nsr_update["_admin.nsState"] = "INSTANTIATED"
db_nsr_update["_admin.deployed.RO.nsr_status"] = "BUILD"
self.update_db_2("nsrs", nsr_id, db_nsr_update)
# wait until NS is ready
- step = ns_status_detailed = detailed_status = "Waiting ns ready at RO. RO_id={}".format(RO_nsr_id)
+ step = ns_status_detailed = detailed_status = "Waiting VIM to deploy ns. RO_id={}".format(RO_nsr_id)
detailed_status_old = None
self.logger.debug(logging_text + step)
while time() <= start_deploy + self.total_deploy_timeout:
- desc = await RO.show("ns", RO_nsr_id)
- ns_status, ns_status_info = RO.check_ns_status(desc)
+ desc = await self.RO.show("ns", RO_nsr_id)
+ ns_status, ns_status_info = self.RO.check_ns_status(desc)
db_nsr_update["_admin.deployed.RO.nsr_status"] = ns_status
if ns_status == "ERROR":
raise ROclient.ROClientException(ns_status_info)
vnf_config = vnfd.get("vnf-configuration")
if vnf_config and vnf_config.get("juju"):
native_charm = vnf_config["juju"].get("proxy") is False
-
- if native_charm:
+ proxy_charm = vnf_config["juju"]["charm"]
+ if native_charm and proxy_charm:
if not vca_model_name:
step = "creating VCA model name '{}'".format(nsr_id)
self.logger.debug(logging_text + step)
db_nsr_update["_admin.deployed.VCA-model-name"] = nsr_id
self.update_db_2("nsrs", nsr_id, db_nsr_update)
step = "deploying native charm for vnf_member_index={}".format(vnf_index)
+ self.logger.debug(logging_text + step)
+
vnfr_params["rw_mgmt_ip"] = db_vnfrs[vnf_index]["ip-address"]
charm_params = {
"user_values": vnfr_params,
if vdu_config and vdu_config.get("juju"):
native_charm = vdu_config["juju"].get("proxy") is False
-
- if native_charm:
+ proxy_charm = vdu_config["juju"]["charm"]
+ if native_charm and proxy_charm:
if not vca_model_name:
step = "creating VCA model name"
await self.n2vc.CreateNetworkService(nsr_id)
self.update_db_2("nsrs", nsr_id, db_nsr_update)
step = "deploying native charm for vnf_member_index={} vdu_id={}".format(vnf_index,
vdu["id"])
- await self.n2vc.login()
+
+ self.logger.debug(logging_text + step)
+
vdur = db_vnfrs[vnf_index]["vdur"][vdu_index]
+
# TODO for the moment only first vdu_id contains a charm deployed
if vdur["vdu-id-ref"] != vdu["id"]:
raise LcmException("Mismatch vdur {}, vdu {} at index {} for vnf {}"
charm_params["username"] = vdu_config["config-access"]["ssh-access"].get(
"default-user")
+ await self.n2vc.login()
+
deploy_charm(vnf_index, vdu["id"], vdur.get("name"), vdur["count-index"],
charm_params, n2vc_info, native_charm)
number_to_configure += 1
ns_config = nsd.get("ns-configuration")
if ns_config and ns_config.get("juju"):
native_charm = ns_config["juju"].get("proxy") is False
-
- if native_charm:
+ proxy_charm = ns_config["juju"]["charm"]
+ if native_charm and proxy_charm:
step = "deploying native charm to configure ns"
# TODO is NS magmt IP address needed?
}
return nslcmop
+ def _get_terminate_primitive_params(self, seq, vnf_index):
+ primitive = seq.get('name')
+ primitive_params = {}
+ params = {
+ "member_vnf_index": vnf_index,
+ "primitive": primitive,
+ "primitive_params": primitive_params,
+ }
+ desc_params = {}
+ return self._map_primitive_params(seq, params, desc_params)
+
+ # sub-operations
+
+ def _reintent_or_skip_suboperation(self, db_nslcmop, op_index):
+ op = db_nslcmop.get('_admin', {}).get('operations', [])[op_index]
+ if (op.get('operationState') == 'COMPLETED'):
+ # b. Skip sub-operation
+ # _ns_execute_primitive() or RO.create_action() will NOT be executed
+ return self.SUBOPERATION_STATUS_SKIP
+ else:
+ # c. Reintent executing sub-operation
+ # The sub-operation exists, and operationState != 'COMPLETED'
+ # Update operationState = 'PROCESSING' to indicate a reintent.
+ operationState = 'PROCESSING'
+ detailed_status = 'In progress'
+ self._update_suboperation_status(
+ db_nslcmop, op_index, operationState, detailed_status)
+ # Return the sub-operation index
+ # _ns_execute_primitive() or RO.create_action() will be called from scale()
+ # with arguments extracted from the sub-operation
+ return op_index
+
+ # Find a sub-operation where all keys in a matching dictionary must match
+ # Returns the index of the matching sub-operation, or SUBOPERATION_STATUS_NOT_FOUND if no match
+ def _find_suboperation(self, db_nslcmop, match):
+ if (db_nslcmop and match):
+ op_list = db_nslcmop.get('_admin', {}).get('operations', [])
+ for i, op in enumerate(op_list):
+ if all(op.get(k) == match[k] for k in match):
+ return i
+ return self.SUBOPERATION_STATUS_NOT_FOUND
+
+ # Update status for a sub-operation given its index
+ def _update_suboperation_status(self, db_nslcmop, op_index, operationState, detailed_status):
+ # Update DB for HA tasks
+ q_filter = {'_id': db_nslcmop['_id']}
+ update_dict = {'_admin.operations.{}.operationState'.format(op_index): operationState,
+ '_admin.operations.{}.detailed-status'.format(op_index): detailed_status}
+ self.db.set_one("nslcmops",
+ q_filter=q_filter,
+ update_dict=update_dict,
+ fail_on_empty=False)
+
+ # Add sub-operation, return the index of the added sub-operation
+ # Optionally, set operationState, detailed-status, and operationType
+ # Status and type are currently set for 'scale' sub-operations:
+ # 'operationState' : 'PROCESSING' | 'COMPLETED' | 'FAILED'
+ # 'detailed-status' : status message
+ # 'operationType': may be any type, in the case of scaling: 'PRE-SCALE' | 'POST-SCALE'
+ # Status and operation type are currently only used for 'scale', but NOT for 'terminate' sub-operations.
+ def _add_suboperation(self, db_nslcmop, vnf_index, vdu_id, vdu_count_index,
+ vdu_name, primitive, mapped_primitive_params,
+ operationState=None, detailed_status=None, operationType=None,
+ RO_nsr_id=None, RO_scaling_info=None):
+ if not (db_nslcmop):
+ return self.SUBOPERATION_STATUS_NOT_FOUND
+ # Get the "_admin.operations" list, if it exists
+ db_nslcmop_admin = db_nslcmop.get('_admin', {})
+ op_list = db_nslcmop_admin.get('operations')
+ # Create or append to the "_admin.operations" list
+ new_op = {'member_vnf_index': vnf_index,
+ 'vdu_id': vdu_id,
+ 'vdu_count_index': vdu_count_index,
+ 'primitive': primitive,
+ 'primitive_params': mapped_primitive_params}
+ if operationState:
+ new_op['operationState'] = operationState
+ if detailed_status:
+ new_op['detailed-status'] = detailed_status
+ if operationType:
+ new_op['lcmOperationType'] = operationType
+ if RO_nsr_id:
+ new_op['RO_nsr_id'] = RO_nsr_id
+ if RO_scaling_info:
+ new_op['RO_scaling_info'] = RO_scaling_info
+ if not op_list:
+ # No existing operations, create key 'operations' with current operation as first list element
+ db_nslcmop_admin.update({'operations': [new_op]})
+ op_list = db_nslcmop_admin.get('operations')
+ else:
+ # Existing operations, append operation to list
+ op_list.append(new_op)
+
+ db_nslcmop_update = {'_admin.operations': op_list}
+ self.update_db_2("nslcmops", db_nslcmop['_id'], db_nslcmop_update)
+ op_index = len(op_list) - 1
+ return op_index
+
+ # Helper methods for scale() sub-operations
+
+ # pre-scale/post-scale:
+ # Check for 3 different cases:
+ # a. New: First time execution, return SUBOPERATION_STATUS_NEW
+ # b. Skip: Existing sub-operation exists, operationState == 'COMPLETED', return SUBOPERATION_STATUS_SKIP
+ # c. Reintent: Existing sub-operation exists, operationState != 'COMPLETED', return op_index to re-execute
+ def _check_or_add_scale_suboperation(self, db_nslcmop, vnf_index,
+ vnf_config_primitive, primitive_params, operationType,
+ RO_nsr_id=None, RO_scaling_info=None):
+ # Find this sub-operation
+ if (RO_nsr_id and RO_scaling_info):
+ operationType = 'SCALE-RO'
+ match = {
+ 'member_vnf_index': vnf_index,
+ 'RO_nsr_id': RO_nsr_id,
+ 'RO_scaling_info': RO_scaling_info,
+ }
+ else:
+ match = {
+ 'member_vnf_index': vnf_index,
+ 'primitive': vnf_config_primitive,
+ 'primitive_params': primitive_params,
+ 'lcmOperationType': operationType
+ }
+ op_index = self._find_suboperation(db_nslcmop, match)
+ if (op_index == self.SUBOPERATION_STATUS_NOT_FOUND):
+ # a. New sub-operation
+ # The sub-operation does not exist, add it.
+ # _ns_execute_primitive() will be called from scale() as usual, with non-modified arguments
+ # The following parameters are set to None for all kind of scaling:
+ vdu_id = None
+ vdu_count_index = None
+ vdu_name = None
+ if (RO_nsr_id and RO_scaling_info):
+ vnf_config_primitive = None
+ primitive_params = None
+ else:
+ RO_nsr_id = None
+ RO_scaling_info = None
+ # Initial status for sub-operation
+ operationState = 'PROCESSING'
+ detailed_status = 'In progress'
+ # Add sub-operation for pre/post-scaling (zero or more operations)
+ self._add_suboperation(db_nslcmop,
+ vnf_index,
+ vdu_id,
+ vdu_count_index,
+ vdu_name,
+ vnf_config_primitive,
+ primitive_params,
+ operationState,
+ detailed_status,
+ operationType,
+ RO_nsr_id,
+ RO_scaling_info)
+ return self.SUBOPERATION_STATUS_NEW
+ else:
+ # Return either SUBOPERATION_STATUS_SKIP (operationState == 'COMPLETED'),
+ # or op_index (operationState != 'COMPLETED')
+ return self._reintent_or_skip_suboperation(db_nslcmop, op_index)
+
+ # Helper methods for terminate()
+
async def _terminate_action(self, db_nslcmop, nslcmop_id, nsr_id):
""" Create a primitive with params from VNFD
Called from terminate() before deleting instance
Calls action() to execute the primitive """
logging_text = "Task ns={} _terminate_action={} ".format(nsr_id, nslcmop_id)
- db_vnfds = {}
db_vnfrs_list = self.db.get_list("vnfrs", {"nsr-id-ref": nsr_id})
+ db_vnfds = {}
# Loop over VNFRs
for vnfr in db_vnfrs_list:
vnfd_id = vnfr["vnfd-id"]
# Get the primitive's sorted sequence list
seq_list = self._get_terminate_config_primitive_seq_list(vnfd)
for seq in seq_list:
- # For each sequence in list, call terminate action
+ # For each sequence in list, get primitive and call _ns_execute_primitive()
step = "Calling terminate action for vnf_member_index={} primitive={}".format(
vnf_index, seq.get("name"))
self.logger.debug(logging_text + step)
- # Create the primitive for each sequence
- operation = "action"
- # primitive, i.e. "primitive": "touch"
+ # Create the primitive for each sequence, i.e. "primitive": "touch"
primitive = seq.get('name')
- primitive_params = {}
- params = {
- "member_vnf_index": vnf_index,
- "primitive": primitive,
- "primitive_params": primitive_params,
- }
- nslcmop_primitive = self._create_nslcmop(nsr_id, operation, params)
- # Get a copy of db_nslcmop 'admin' part
- db_nslcmop_action = {"_admin": deepcopy(db_nslcmop["_admin"])}
- # Update db_nslcmop with the primitive data
- db_nslcmop_action.update(nslcmop_primitive)
- # Create a new db entry for the created primitive, returns the new ID.
- # (The ID is normally obtained from Kafka.)
- nslcmop_terminate_action_id = self.db.create(
- "nslcmops", db_nslcmop_action)
- # Execute the primitive
- nslcmop_operation_state, nslcmop_operation_state_detail = await self.action(
- nsr_id, nslcmop_terminate_action_id)
+ mapped_primitive_params = self._get_terminate_primitive_params(seq, vnf_index)
+ # The following 3 parameters are currently set to None for 'terminate':
+ # vdu_id, vdu_count_index, vdu_name
+ vdu_id = db_nslcmop["operationParams"].get("vdu_id")
+ vdu_count_index = db_nslcmop["operationParams"].get("vdu_count_index")
+ vdu_name = db_nslcmop["operationParams"].get("vdu_name")
+ # Add sub-operation
+ self._add_suboperation(db_nslcmop,
+ nslcmop_id,
+ vnf_index,
+ vdu_id,
+ vdu_count_index,
+ vdu_name,
+ primitive,
+ mapped_primitive_params)
+ # Sub-operations: Call _ns_execute_primitive() instead of action()
+ db_nsr = self.db.get_one("nsrs", {"_id": nsr_id})
+ nsr_deployed = db_nsr["_admin"]["deployed"]
+ result, result_detail = await self._ns_execute_primitive(
+ nsr_deployed, vnf_index, vdu_id, vdu_name, vdu_count_index, primitive,
+ mapped_primitive_params)
+
+ # nslcmop_operation_state, nslcmop_operation_state_detail = await self.action(
+ # nsr_id, nslcmop_terminate_action_id)
# Launch Exception if action() returns other than ['COMPLETED', 'PARTIALLY_COMPLETED']
- nslcmop_operation_states_ok = ['COMPLETED', 'PARTIALLY_COMPLETED']
- if nslcmop_operation_state not in nslcmop_operation_states_ok:
+ result_ok = ['COMPLETED', 'PARTIALLY_COMPLETED']
+ if result not in result_ok:
raise LcmException(
"terminate_primitive_action for vnf_member_index={}",
" primitive={} fails with error {}".format(
- vnf_index, seq.get("name"), nslcmop_operation_state_detail))
+ vnf_index, seq.get("name"), result_detail))
async def terminate(self, nsr_id, nslcmop_id):
# remove from RO
RO_fail = False
- RO = ROclient.ROClient(self.loop, **self.ro_config)
# Delete ns
RO_nsr_id = RO_delete_action = None
RO_delete_action = nsr_deployed["RO"].get("nsr_delete_action_id")
try:
if RO_nsr_id:
- step = db_nsr_update["detailed-status"] = db_nslcmop_update["detailed-status"] = "Deleting ns at RO"
+ step = db_nsr_update["detailed-status"] = db_nslcmop_update["detailed-status"] = \
+ "Deleting ns from VIM"
self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update)
self.update_db_2("nsrs", nsr_id, db_nsr_update)
self.logger.debug(logging_text + step)
- desc = await RO.delete("ns", RO_nsr_id)
+ desc = await self.RO.delete("ns", RO_nsr_id)
RO_delete_action = desc["action_id"]
db_nsr_update["_admin.deployed.RO.nsr_delete_action_id"] = RO_delete_action
db_nsr_update["_admin.deployed.RO.nsr_id"] = None
delete_timeout = 20 * 60 # 20 minutes
while delete_timeout > 0:
- desc = await RO.show("ns", item_id_name=RO_nsr_id, extra_item="action",
- extra_item_id=RO_delete_action)
- ns_status, ns_status_info = RO.check_action_status(desc)
+ desc = await self.RO.show("ns", item_id_name=RO_nsr_id, extra_item="action",
+ extra_item_id=RO_delete_action)
+ ns_status, ns_status_info = self.RO.check_action_status(desc)
if ns_status == "ERROR":
raise ROclient.ROClientException(ns_status_info)
elif ns_status == "BUILD":
RO_nsd_id = nsr_deployed["RO"]["nsd_id"]
try:
step = db_nsr_update["detailed-status"] = db_nslcmop_update["detailed-status"] =\
- "Deleting nsd at RO"
- await RO.delete("nsd", RO_nsd_id)
+ "Deleting nsd from RO"
+ await self.RO.delete("nsd", RO_nsd_id)
self.logger.debug(logging_text + "RO_nsd_id={} deleted".format(RO_nsd_id))
db_nsr_update["_admin.deployed.RO.nsd_id"] = None
except ROclient.ROClientException as e:
step = db_nsr_update["detailed-status"] = db_nslcmop_update["detailed-status"] =\
"Deleting member_vnf_index={} RO_vnfd_id={} from RO".format(
vnf_deployed["member-vnf-index"], RO_vnfd_id)
- await RO.delete("vnfd", RO_vnfd_id)
+ await self.RO.delete("vnfd", RO_vnfd_id)
self.logger.debug(logging_text + "RO_vnfd_id={} deleted".format(RO_vnfd_id))
db_nsr_update["_admin.deployed.RO.vnfd.{}.id".format(index)] = None
except ROclient.ROClientException as e:
# break
# TODO check if ns is in a proper status
- step = "Sending scale order to RO"
+ step = "Sending scale order to VIM"
nb_scale_op = 0
if not db_nsr["_admin"].get("scaling-group"):
self.update_db_2("nsrs", nsr_id, {"_admin.scaling-group": [{"name": scaling_group, "nb-scale-op": 0}]})
vdu_scaling_info = {"scaling_group_name": scaling_group, "vdu": []}
if scaling_type == "SCALE_OUT":
# count if max-instance-count is reached
- if "max-instance-count" in scaling_descriptor and scaling_descriptor["max-instance-count"] is not None:
- max_instance_count = int(scaling_descriptor["max-instance-count"])
-
- # self.logger.debug("MAX_INSTANCE_COUNT is {}".format(scaling_descriptor["max-instance-count"]))
- if nb_scale_op >= max_instance_count:
- raise LcmException("reached the limit of {} (max-instance-count) "
- "scaling-out operations for the "
- "scaling-group-descriptor '{}'".format(nb_scale_op, scaling_group))
-
+ max_instance_count = scaling_descriptor.get("max-instance-count", 10)
+ # self.logger.debug("MAX_INSTANCE_COUNT is {}".format(max_instance_count))
+ if nb_scale_op >= max_instance_count:
+ raise LcmException("reached the limit of {} (max-instance-count) "
+ "scaling-out operations for the "
+ "scaling-group-descriptor '{}'".format(nb_scale_op, scaling_group))
+
nb_scale_op += 1
vdu_scaling_info["scaling_direction"] = "OUT"
vdu_scaling_info["vdu-create"] = {}
})
vdu_delete = vdu_scaling_info.pop("vdu-delete")
- # execute primitive service PRE-SCALING
+ # PRE-SCALE BEGIN
step = "Executing pre-scale vnf-config-primitive"
if scaling_descriptor.get("scaling-config-action"):
for scaling_config_action in scaling_descriptor["scaling-config-action"]:
- if scaling_config_action.get("trigger") and scaling_config_action["trigger"] == "pre-scale-in" \
- and scaling_type == "SCALE_IN":
+ if (scaling_config_action.get("trigger") == "pre-scale-in" and scaling_type == "SCALE_IN") \
+ or (scaling_config_action.get("trigger") == "pre-scale-out" and scaling_type == "SCALE_OUT"):
vnf_config_primitive = scaling_config_action["vnf-config-primitive-name-ref"]
step = db_nslcmop_update["detailed-status"] = \
"executing pre-scale scaling-config-action '{}'".format(vnf_config_primitive)
vnfr_params = {"VDU_SCALE_INFO": vdu_scaling_info}
if db_vnfr.get("additionalParamsForVnf"):
vnfr_params.update(db_vnfr["additionalParamsForVnf"])
-
scale_process = "VCA"
db_nsr_update["config-status"] = "configuring pre-scaling"
- result, result_detail = await self._ns_execute_primitive(
- nsr_deployed, vnf_index, None, None, None, vnf_config_primitive,
- self._map_primitive_params(config_primitive, {}, vnfr_params))
- self.logger.debug(logging_text + "vnf_config_primitive={} Done with result {} {}".format(
- vnf_config_primitive, result, result_detail))
+ primitive_params = self._map_primitive_params(config_primitive, {}, vnfr_params)
+
+ # Pre-scale reintent check: Check if this sub-operation has been executed before
+ op_index = self._check_or_add_scale_suboperation(
+ db_nslcmop, nslcmop_id, vnf_index, vnf_config_primitive, primitive_params, 'PRE-SCALE')
+ if (op_index == self.SUBOPERATION_STATUS_SKIP):
+ # Skip sub-operation
+ result = 'COMPLETED'
+ result_detail = 'Done'
+ self.logger.debug(logging_text +
+ "vnf_config_primitive={} Skipped sub-operation, result {} {}".format(
+ vnf_config_primitive, result, result_detail))
+ else:
+ if (op_index == self.SUBOPERATION_STATUS_NEW):
+ # New sub-operation: Get index of this sub-operation
+ op_index = len(db_nslcmop.get('_admin', {}).get('operations')) - 1
+ self.logger.debug(logging_text + "vnf_config_primitive={} New sub-operation".
+ format(vnf_config_primitive))
+ else:
+ # Reintent: Get registered params for this existing sub-operation
+ op = db_nslcmop.get('_admin', {}).get('operations', [])[op_index]
+ vnf_index = op.get('member_vnf_index')
+ vnf_config_primitive = op.get('primitive')
+ primitive_params = op.get('primitive_params')
+ self.logger.debug(logging_text + "vnf_config_primitive={} Sub-operation reintent".
+ format(vnf_config_primitive))
+ # Execute the primitive, either with new (first-time) or registered (reintent) args
+ result, result_detail = await self._ns_execute_primitive(
+ nsr_deployed, vnf_index, None, None, None, vnf_config_primitive, primitive_params)
+ self.logger.debug(logging_text + "vnf_config_primitive={} Done with result {} {}".format(
+ vnf_config_primitive, result, result_detail))
+ # Update operationState = COMPLETED | FAILED
+ self._update_suboperation_status(
+ db_nslcmop, op_index, result, result_detail)
+
if result == "FAILED":
raise LcmException(result_detail)
db_nsr_update["config-status"] = old_config_status
scale_process = None
+ # PRE-SCALE END
+ # SCALE RO - BEGIN
+ # Should this block be skipped if 'RO_nsr_id' == None ?
+ # if (RO_nsr_id and RO_scaling_info):
if RO_scaling_info:
scale_process = "RO"
- RO = ROclient.ROClient(self.loop, **self.ro_config)
- RO_desc = await RO.create_action("ns", RO_nsr_id, {"vdu-scaling": RO_scaling_info})
- db_nsr_update["_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index)] = nb_scale_op
- db_nsr_update["_admin.scaling-group.{}.time".format(admin_scale_index)] = time()
- # wait until ready
- RO_nslcmop_id = RO_desc["instance_action_id"]
- db_nslcmop_update["_admin.deploy.RO"] = RO_nslcmop_id
-
- RO_task_done = False
- step = detailed_status = "Waiting RO_task_id={} to complete the scale action.".format(RO_nslcmop_id)
- detailed_status_old = None
- self.logger.debug(logging_text + step)
-
- deployment_timeout = 1 * 3600 # One hour
- while deployment_timeout > 0:
- if not RO_task_done:
- desc = await RO.show("ns", item_id_name=RO_nsr_id, extra_item="action",
- extra_item_id=RO_nslcmop_id)
- ns_status, ns_status_info = RO.check_action_status(desc)
- if ns_status == "ERROR":
- raise ROclient.ROClientException(ns_status_info)
- elif ns_status == "BUILD":
- detailed_status = step + "; {}".format(ns_status_info)
- elif ns_status == "ACTIVE":
- RO_task_done = True
- step = detailed_status = "Waiting ns ready at RO. RO_id={}".format(RO_nsr_id)
- self.logger.debug(logging_text + step)
- else:
- assert False, "ROclient.check_action_status returns unknown {}".format(ns_status)
+ # Scale RO reintent check: Check if this sub-operation has been executed before
+ op_index = self._check_or_add_scale_suboperation(
+ db_nslcmop, vnf_index, None, None, 'SCALE-RO', RO_nsr_id, RO_scaling_info)
+ if (op_index == self.SUBOPERATION_STATUS_SKIP):
+ # Skip sub-operation
+ result = 'COMPLETED'
+ result_detail = 'Done'
+ self.logger.debug(logging_text + "Skipped sub-operation RO, result {} {}".format(
+ result, result_detail))
+ else:
+ if (op_index == self.SUBOPERATION_STATUS_NEW):
+ # New sub-operation: Get index of this sub-operation
+ op_index = len(db_nslcmop.get('_admin', {}).get('operations')) - 1
+ self.logger.debug(logging_text + "New sub-operation RO")
else:
- desc = await RO.show("ns", RO_nsr_id)
- ns_status, ns_status_info = RO.check_ns_status(desc)
- if ns_status == "ERROR":
- raise ROclient.ROClientException(ns_status_info)
- elif ns_status == "BUILD":
- detailed_status = step + "; {}".format(ns_status_info)
- elif ns_status == "ACTIVE":
- step = detailed_status = \
- "Waiting for management IP address reported by the VIM. Updating VNFRs"
- if not vnfr_scaled:
- self.scale_vnfr(db_vnfr, vdu_create=vdu_create, vdu_delete=vdu_delete)
- vnfr_scaled = True
- try:
- desc = await RO.show("ns", RO_nsr_id)
- # nsr_deployed["nsr_ip"] = RO.get_ns_vnf_info(desc)
- self.ns_update_vnfr({db_vnfr["member-vnf-index-ref"]: db_vnfr}, desc)
- break
- except LcmExceptionNoMgmtIP:
- pass
+ # Reintent: Get registered params for this existing sub-operation
+ op = db_nslcmop.get('_admin', {}).get('operations', [])[op_index]
+ RO_nsr_id = op.get('RO_nsr_id')
+ RO_scaling_info = op.get('RO_scaling_info')
+ self.logger.debug(logging_text + "Sub-operation RO reintent".format(
+ vnf_config_primitive))
+
+ RO_desc = await self.RO.create_action("ns", RO_nsr_id, {"vdu-scaling": RO_scaling_info})
+ db_nsr_update["_admin.scaling-group.{}.nb-scale-op".format(admin_scale_index)] = nb_scale_op
+ db_nsr_update["_admin.scaling-group.{}.time".format(admin_scale_index)] = time()
+ # wait until ready
+ RO_nslcmop_id = RO_desc["instance_action_id"]
+ db_nslcmop_update["_admin.deploy.RO"] = RO_nslcmop_id
+
+ RO_task_done = False
+ step = detailed_status = "Waiting RO_task_id={} to complete the scale action.".format(RO_nslcmop_id)
+ detailed_status_old = None
+ self.logger.debug(logging_text + step)
+
+ deployment_timeout = 1 * 3600 # One hour
+ while deployment_timeout > 0:
+ if not RO_task_done:
+ desc = await self.RO.show("ns", item_id_name=RO_nsr_id, extra_item="action",
+ extra_item_id=RO_nslcmop_id)
+ ns_status, ns_status_info = self.RO.check_action_status(desc)
+ if ns_status == "ERROR":
+ raise ROclient.ROClientException(ns_status_info)
+ elif ns_status == "BUILD":
+ detailed_status = step + "; {}".format(ns_status_info)
+ elif ns_status == "ACTIVE":
+ RO_task_done = True
+ step = detailed_status = "Waiting ns ready at RO. RO_id={}".format(RO_nsr_id)
+ self.logger.debug(logging_text + step)
+ else:
+ assert False, "ROclient.check_action_status returns unknown {}".format(ns_status)
else:
- assert False, "ROclient.check_ns_status returns unknown {}".format(ns_status)
- if detailed_status != detailed_status_old:
- detailed_status_old = db_nslcmop_update["detailed-status"] = detailed_status
- self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update)
+ if ns_status == "ERROR":
+ raise ROclient.ROClientException(ns_status_info)
+ elif ns_status == "BUILD":
+ detailed_status = step + "; {}".format(ns_status_info)
+ elif ns_status == "ACTIVE":
+ step = detailed_status = \
+ "Waiting for management IP address reported by the VIM. Updating VNFRs"
+ if not vnfr_scaled:
+ self.scale_vnfr(db_vnfr, vdu_create=vdu_create, vdu_delete=vdu_delete)
+ vnfr_scaled = True
+ try:
+ desc = await self.RO.show("ns", RO_nsr_id)
+ # nsr_deployed["nsr_ip"] = RO.get_ns_vnf_info(desc)
+ self.ns_update_vnfr({db_vnfr["member-vnf-index-ref"]: db_vnfr}, desc)
+ break
+ except LcmExceptionNoMgmtIP:
+ pass
+ else:
+ assert False, "ROclient.check_ns_status returns unknown {}".format(ns_status)
+ if detailed_status != detailed_status_old:
+ self._update_suboperation_status(
+ db_nslcmop, op_index, 'COMPLETED', detailed_status)
+ detailed_status_old = db_nslcmop_update["detailed-status"] = detailed_status
+ self.update_db_2("nslcmops", nslcmop_id, db_nslcmop_update)
- await asyncio.sleep(5, loop=self.loop)
- deployment_timeout -= 5
- if deployment_timeout <= 0:
- raise ROclient.ROClientException("Timeout waiting ns to be ready")
-
- # update VDU_SCALING_INFO with the obtained ip_addresses
- if vdu_scaling_info["scaling_direction"] == "OUT":
- for vdur in reversed(db_vnfr["vdur"]):
- if vdu_scaling_info["vdu-create"].get(vdur["vdu-id-ref"]):
- vdu_scaling_info["vdu-create"][vdur["vdu-id-ref"]] -= 1
- vdu_scaling_info["vdu"].append({
- "name": vdur["name"],
- "vdu_id": vdur["vdu-id-ref"],
- "interface": []
- })
- for interface in vdur["interfaces"]:
- vdu_scaling_info["vdu"][-1]["interface"].append({
- "name": interface["name"],
- "ip_address": interface["ip-address"],
- "mac_address": interface.get("mac-address"),
+ await asyncio.sleep(5, loop=self.loop)
+ deployment_timeout -= 5
+ if deployment_timeout <= 0:
+ self._update_suboperation_status(
+ db_nslcmop, nslcmop_id, op_index, 'FAILED', "Timeout when waiting for ns to get ready")
+ raise ROclient.ROClientException("Timeout waiting ns to be ready")
+
+ # update VDU_SCALING_INFO with the obtained ip_addresses
+ if vdu_scaling_info["scaling_direction"] == "OUT":
+ for vdur in reversed(db_vnfr["vdur"]):
+ if vdu_scaling_info["vdu-create"].get(vdur["vdu-id-ref"]):
+ vdu_scaling_info["vdu-create"][vdur["vdu-id-ref"]] -= 1
+ vdu_scaling_info["vdu"].append({
+ "name": vdur["name"],
+ "vdu_id": vdur["vdu-id-ref"],
+ "interface": []
})
- del vdu_scaling_info["vdu-create"]
+ for interface in vdur["interfaces"]:
+ vdu_scaling_info["vdu"][-1]["interface"].append({
+ "name": interface["name"],
+ "ip_address": interface["ip-address"],
+ "mac_address": interface.get("mac-address"),
+ })
+ del vdu_scaling_info["vdu-create"]
+
+ self._update_suboperation_status(db_nslcmop, op_index, 'COMPLETED', 'Done')
+ # SCALE RO - END
scale_process = None
if db_nsr_update:
self.update_db_2("nsrs", nsr_id, db_nsr_update)
+ # POST-SCALE BEGIN
# execute primitive service POST-SCALING
step = "Executing post-scale vnf-config-primitive"
if scaling_descriptor.get("scaling-config-action"):
for scaling_config_action in scaling_descriptor["scaling-config-action"]:
- if scaling_config_action.get("trigger") and scaling_config_action["trigger"] == "post-scale-out" \
- and scaling_type == "SCALE_OUT":
+ if (scaling_config_action.get("trigger") == "post-scale-in" and scaling_type == "SCALE_IN") \
+ or (scaling_config_action.get("trigger") == "post-scale-out" and scaling_type == "SCALE_OUT"):
vnf_config_primitive = scaling_config_action["vnf-config-primitive-name-ref"]
step = db_nslcmop_update["detailed-status"] = \
"executing post-scale scaling-config-action '{}'".format(vnf_config_primitive)
config_primitive))
scale_process = "VCA"
db_nsr_update["config-status"] = "configuring post-scaling"
+ primitive_params = self._map_primitive_params(config_primitive, {}, vnfr_params)
+
+ # Post-scale reintent check: Check if this sub-operation has been executed before
+ op_index = self._check_or_add_scale_suboperation(
+ db_nslcmop, nslcmop_id, vnf_index, vnf_config_primitive, primitive_params, 'POST-SCALE')
+ if (op_index == self.SUBOPERATION_STATUS_SKIP):
+ # Skip sub-operation
+ result = 'COMPLETED'
+ result_detail = 'Done'
+ self.logger.debug(logging_text +
+ "vnf_config_primitive={} Skipped sub-operation, result {} {}".
+ format(vnf_config_primitive, result, result_detail))
+ else:
+ if (op_index == self.SUBOPERATION_STATUS_NEW):
+ # New sub-operation: Get index of this sub-operation
+ op_index = len(db_nslcmop.get('_admin', {}).get('operations')) - 1
+ self.logger.debug(logging_text + "vnf_config_primitive={} New sub-operation".
+ format(vnf_config_primitive))
+ else:
+ # Reintent: Get registered params for this existing sub-operation
+ op = db_nslcmop.get('_admin', {}).get('operations', [])[op_index]
+ vnf_index = op.get('member_vnf_index')
+ vnf_config_primitive = op.get('primitive')
+ primitive_params = op.get('primitive_params')
+ self.logger.debug(logging_text + "vnf_config_primitive={} Sub-operation reintent".
+ format(vnf_config_primitive))
+ # Execute the primitive, either with new (first-time) or registered (reintent) args
+ result, result_detail = await self._ns_execute_primitive(
+ nsr_deployed, vnf_index, None, None, None, vnf_config_primitive, primitive_params)
+ self.logger.debug(logging_text + "vnf_config_primitive={} Done with result {} {}".format(
+ vnf_config_primitive, result, result_detail))
+ # Update operationState = COMPLETED | FAILED
+ self._update_suboperation_status(
+ db_nslcmop, op_index, result, result_detail)
- result, result_detail = await self._ns_execute_primitive(
- nsr_deployed, vnf_index, None, None, None, vnf_config_primitive,
- self._map_primitive_params(config_primitive, {}, vnfr_params))
- self.logger.debug(logging_text + "vnf_config_primitive={} Done with result {} {}".format(
- vnf_config_primitive, result, result_detail))
if result == "FAILED":
raise LcmException(result_detail)
db_nsr_update["config-status"] = old_config_status
scale_process = None
+ # POST-SCALE END
db_nslcmop_update["operationState"] = nslcmop_operation_state = "COMPLETED"
db_nslcmop_update["statusEnteredTime"] = time()
projects / osm / LCM.git / blobdiff