if self._vnffgr_state == VnffgRecordState.INIT:
vnffgr_dict = {"id": self._vnffgr_id,
- "nsd_id": self._nsr.nsd_id,
"vnffgd_id_ref": self._vnffgd_msg.id,
"vnffgd_name_ref": self._vnffgd_msg.name,
"sdn_account": self._sdn_account_name,
vnffgr = NsrYang.YangData_Nsr_NsInstanceOpdata_Nsr_Vnffgr.from_dict(vnffgr_dict)
elif self._vnffgr_state == VnffgRecordState.TERMINATED:
vnffgr_dict = {"id": self._vnffgr_id,
- "nsd_id": self._nsr.nsd_id,
"vnffgd_id_ref": self._vnffgd_msg.id,
"vnffgd_name_ref": self._vnffgd_msg.name,
"sdn_account": self._sdn_account_name,
self._log.exception("Fetching VNFFGR for VNFFG with id %s failed", self._vnffgr_id)
self._vnffgr_state = VnffgRecordState.FAILED
vnffgr_dict = {"id": self._vnffgr_id,
- "nsd_id": self._nsr.nsd_id,
"vnffgd_id_ref": self._vnffgd_msg.id,
"vnffgd_name_ref": self._vnffgd_msg.name,
"sdn_account": self._sdn_account_name,
def vnffgr_create_msg(self):
""" Virtual Link Record message for Creating VLR in VNS """
vnffgr_dict = {"id": self._vnffgr_id,
- "nsd_id": self._nsr.nsd_id,
"vnffgd_id_ref": self._vnffgd_msg.id,
"vnffgd_name_ref": self._vnffgd_msg.name,
"sdn_account": self._sdn_account_name,
self._group_instance_id = group_instance_id
self._placement_groups = placement_groups
self._config_status = NsrYang.ConfigStates.INIT
+ self._create_time = int(time.time())
self._prev_state = VnfRecordState.INIT
self._state = VnfRecordState.INIT
vnfr_dict = {
"id": self.id,
"nsr_id_ref": self._nsr_id,
- "vnfd_ref": self.vnfd.id,
"name": self.name,
"cloud_account": self._cloud_account_name,
"om_datacenter": self._om_datacenter_name,
vnfr_dict.update(vnfd_copy_dict)
vnfr = RwVnfrYang.YangData_Vnfr_VnfrCatalog_Vnfr.from_dict(vnfr_dict)
+ vnfr.vnfd = VnfrYang.YangData_Vnfr_VnfrCatalog_Vnfr_Vnfd.from_dict(self.vnfd.as_dict(),
+ ignore_missing_keys=True)
vnfr.member_vnf_index_ref = self.member_vnf_index
vnfr.vnf_configuration.from_dict(self._vnfd.vnf_configuration.as_dict())
cpr = VnfrYang.YangData_Vnfr_VnfrCatalog_Vnfr_ConnectionPoint()
cpr.name = conn_p.name
cpr.type_yang = conn_p.type_yang
+ if conn_p.has_field('port_security_enabled'):
+ cpr.port_security_enabled = conn_p.port_security_enabled
+
vlr_ref = find_vlr_for_cp(conn_p)
if vlr_ref is None:
msg = "Failed to find VLR for cp = %s" % conn_p.name
cpr.vlr_ref = vlr_ref.id
self.vnfr_msg.connection_point.append(cpr)
self._log.debug("Connection point [%s] added, vnf id=%s vnfd id=%s",
- cpr, self.vnfr_msg.id, self.vnfr_msg.vnfd_ref)
+ cpr, self.vnfr_msg.id, self.vnfr_msg.vnfd.id)
if not self.restart_mode:
yield from self._dts.query_create(self.xpath,
self._is_active = False
self._vl_phase_completed = False
self._vnf_phase_completed = False
+ self.vlr_uptime_tasks = {}
# Initalise the state to init
self._vnf_phase_completed = True
self._op_status.set_state(state)
+ self._nsm_plugin.set_state(self.id, state)
@property
def id(self):
for vlr in self._vlrs:
yield from self.nsm_plugin.instantiate_vl(self, vlr)
vlr.state = VlRecordState.ACTIVE
- self._loop.create_task(self.vlr_uptime_update(vlr))
+ self.vlr_uptime_tasks[vlr.id] = self._loop.create_task(self.vlr_uptime_update(vlr))
def vlr_uptime_update(self, vlr):
- vlr_ = RwVlrYang.YangData_Vlr_VlrCatalog_Vlr.from_dict({'id': vlr.id})
- while True:
- if vlr.state not in [VlRecordState.INIT, VlRecordState.INSTANTIATION_PENDING, VlRecordState.ACTIVE]:
- return
- vlr_.uptime = int(time.time()) - vlr._create_time
- yield from self._vlr_handler.update(None, VirtualLinkRecord.vlr_xpath(vlr), vlr_)
- yield from asyncio.sleep(2, loop=self._loop)
+ try:
+
+ vlr_ = RwVlrYang.YangData_Vlr_VlrCatalog_Vlr.from_dict({'id': vlr.id})
+ while True:
+ vlr_.uptime = int(time.time()) - vlr._create_time
+ yield from self._vlr_handler.update(None, VirtualLinkRecord.vlr_xpath(vlr), vlr_)
+ yield from asyncio.sleep(2, loop=self._loop)
+ except asyncio.CancelledError:
+ self._log.debug("Received cancellation request for vlr_uptime_update task")
+ yield from self._vlr_handler.delete(None, VirtualLinkRecord.vlr_xpath(vlr))
@asyncio.coroutine
vnfr = yield from self.create_vnf_record(vnfd_msg, const_vnfd_msg, cloud_account_name, om_datacenter_name, group_name, index)
scale_instance.add_vnfr(vnfr)
vnfrs.append(vnfr)
-
return vnfrs
@asyncio.coroutine
format(group.name, index))
scale_instance.operational_status = "failed"
else:
- yield from self.instantiate_vnfs(vnfrs)
+ yield from self.instantiate_vnfs(vnfrs, scaleout=True)
+
except Exception as e:
self._log.exception("Failed to begin instantiatiation of vnfs for scale group {}: {}".
return vnfr
@asyncio.coroutine
- def instantiate_vnfs(self, vnfrs):
+ def instantiate_vnfs(self, vnfrs, scaleout=False):
"""
This function instantiates VNFs for every VNF in this Network Service
"""
self._log.debug("Instantiating %u VNFs in NS %s", len(vnfrs), self.id)
for vnf in vnfrs:
self._log.debug("Instantiating VNF: %s in NS %s", vnf, self.id)
- yield from self.nsm_plugin.instantiate_vnf(self, vnf)
+ yield from self.nsm_plugin.instantiate_vnf(self, vnf,scaleout)
@asyncio.coroutine
def instantiate_vnffgs(self):
def on_instantiate_done(fut):
# If the do_instantiate fails, then publish NSR with failed result
- if fut.exception() is not None:
- self._log.error("NSR instantiation failed for NSR id %s: %s", self.id, str(fut.exception()))
- self._loop.create_task(self.instantiation_failed(failed_reason=str(fut.exception())))
+ e = fut.exception()
+ if e is not None:
+ import traceback, sys
+ print(traceback.format_exception(None,e, e.__traceback__), file=sys.stderr, flush=True)
+ self._log.error("NSR instantiation failed for NSR id %s: %s", self.id, str(e))
+ self._loop.create_task(self.instantiation_failed(failed_reason=str(e)))
instantiate_task = self._loop.create_task(do_instantiate())
instantiate_task.add_done_callback(on_instantiate_done)
for vlr in self.vlrs:
yield from self.nsm_plugin.terminate_vl(vlr)
vlr.state = VlRecordState.TERMINATED
+ if vlr.id in self.vlr_uptime_tasks:
+ self.vlr_uptime_tasks[vlr.id].cancel()
self._log.debug("Terminating network service id %s", self.id)
raise NsrVlUpdateError("NS config NSD should have atleast 1 VLD defined")
if msg.has_field("scaling_group"):
+ self._log.debug("ScaleMsg %s", msg)
+ self._log.debug("NSSCALINGSTATE %s", nsr.state)
if nsr.state != NetworkServiceRecordState.RUNNING:
raise ScalingOperationError("Unable to perform scaling action when NS is not in running state")
def create_nsr(self, nsr_msg, key_pairs=None,restart_mode=False):
""" Create an NSR instance """
+ self._log.debug("NSRMSG %s", nsr_msg)
if nsr_msg.id in self._nsrs:
msg = "NSR id %s already exists" % nsr_msg.id
self._log.error(msg)
# Terminate the instances/networks assocaited with this nw service
self._log.debug("Terminating the network service %s", nsr_id)
- yield from self._nsrs[nsr_id].terminate()
+ try :
+ yield from self._nsrs[nsr_id].terminate()
+ except Exception as e:
+ self.log.exception("Failed to terminate NSR[id=%s]", nsr_id)
# Unref the NSD
yield from self.nsd_unref_by_nsr_id(nsr_id)