2 # Copyright 2016 RIFT.IO Inc
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
17 # vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
20 import ncclient
.asyncio_manager
32 from collections
import deque
33 from collections
import defaultdict
37 gi
.require_version('RwYang', '1.0')
38 gi
.require_version('RwNsdYang', '1.0')
39 gi
.require_version('RwDts', '1.0')
40 gi
.require_version('RwNsmYang', '1.0')
41 gi
.require_version('RwNsrYang', '1.0')
42 gi
.require_version('RwTypes', '1.0')
43 gi
.require_version('RwVlrYang', '1.0')
44 gi
.require_version('RwVnfrYang', '1.0')
45 from gi
.repository
import (
61 import rift
.mano
.ncclient
62 import rift
.mano
.config_data
.config
63 import rift
.mano
.dts
as mano_dts
65 from . import rwnsm_conman
as conman
67 from . import publisher
69 from . import config_value_pool
70 from . import rwvnffgmgr
71 from . import scale_group
74 class NetworkServiceRecordState(Enum
):
75 """ Network Service Record State """
79 VNFFG_INIT_PHASE
= 104
85 VL_TERMINATE_PHASE
= 111
86 VNF_TERMINATE_PHASE
= 112
87 VNFFG_TERMINATE_PHASE
= 113
94 class NetworkServiceRecordError(Exception):
95 """ Network Service Record Error """
99 class NetworkServiceDescriptorError(Exception):
100 """ Network Service Descriptor Error """
104 class VirtualNetworkFunctionRecordError(Exception):
105 """ Virtual Network Function Record Error """
109 class NetworkServiceDescriptorNotFound(Exception):
110 """ Cannot find Network Service Descriptor"""
114 class NetworkServiceDescriptorRefCountExists(Exception):
115 """ Network Service Descriptor reference count exists """
119 class NetworkServiceDescriptorUnrefError(Exception):
120 """ Failed to unref a network service descriptor """
124 class NsrInstantiationFailed(Exception):
125 """ Failed to instantiate network service """
129 class VnfInstantiationFailed(Exception):
130 """ Failed to instantiate virtual network function"""
134 class VnffgInstantiationFailed(Exception):
135 """ Failed to instantiate virtual network function"""
139 class VnfDescriptorError(Exception):
140 """Failed to instantiate virtual network function"""
144 class ScalingOperationError(Exception):
148 class ScaleGroupMissingError(Exception):
152 class PlacementGroupError(Exception):
156 class NsrNsdUpdateError(Exception):
160 class NsrVlUpdateError(NsrNsdUpdateError
):
164 class VlRecordState(Enum
):
165 """ VL Record State """
167 INSTANTIATION_PENDING
= 102
169 TERMINATE_PENDING
= 104
174 class VnffgRecordState(Enum
):
175 """ VNFFG Record State """
177 INSTANTIATION_PENDING
= 102
179 TERMINATE_PENDING
= 104
184 class VnffgRecord(object):
185 """ Vnffg Records class"""
188 def __init__(self
, dts
, log
, loop
, vnffgmgr
, nsr
, nsr_name
, vnffgd_msg
, sdn_account_name
):
193 self
._vnffgmgr
= vnffgmgr
195 self
._nsr
_name
= nsr_name
196 self
._vnffgd
_msg
= vnffgd_msg
197 if sdn_account_name
is None:
198 self
._sdn
_account
_name
= ''
200 self
._sdn
_account
_name
= sdn_account_name
202 self
._vnffgr
_id
= str(uuid
.uuid4())
203 self
._vnffgr
_rsp
_id
= list()
204 self
._vnffgr
_state
= VnffgRecordState
.INIT
209 return self
._vnffgr
_id
213 """ state of this VNF """
214 return self
._vnffgr
_state
216 def fetch_vnffgr(self
):
218 Get VNFFGR message to be published
221 if self
._vnffgr
_state
== VnffgRecordState
.INIT
:
222 vnffgr_dict
= {"id": self
._vnffgr
_id
,
223 "nsd_id": self
._nsr
.nsd_id
,
224 "vnffgd_id_ref": self
._vnffgd
_msg
.id,
225 "vnffgd_name_ref": self
._vnffgd
_msg
.name
,
226 "sdn_account": self
._sdn
_account
_name
,
227 "operational_status": 'init',
229 vnffgr
= NsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_Vnffgr
.from_dict(vnffgr_dict
)
230 elif self
._vnffgr
_state
== VnffgRecordState
.TERMINATED
:
231 vnffgr_dict
= {"id": self
._vnffgr
_id
,
232 "nsd_id": self
._nsr
.nsd_id
,
233 "vnffgd_id_ref": self
._vnffgd
_msg
.id,
234 "vnffgd_name_ref": self
._vnffgd
_msg
.name
,
235 "sdn_account": self
._sdn
_account
_name
,
236 "operational_status": 'terminated',
238 vnffgr
= NsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_Vnffgr
.from_dict(vnffgr_dict
)
241 vnffgr
= self
._vnffgmgr
.fetch_vnffgr(self
._vnffgr
_id
)
243 self
._log
.exception("Fetching VNFFGR for VNFFG with id %s failed", self
._vnffgr
_id
)
244 self
._vnffgr
_state
= VnffgRecordState
.FAILED
245 vnffgr_dict
= {"id": self
._vnffgr
_id
,
246 "nsd_id": self
._nsr
.nsd_id
,
247 "vnffgd_id_ref": self
._vnffgd
_msg
.id,
248 "vnffgd_name_ref": self
._vnffgd
_msg
.name
,
249 "sdn_account": self
._sdn
_account
_name
,
250 "operational_status": 'failed',
252 vnffgr
= NsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_Vnffgr
.from_dict(vnffgr_dict
)
257 def vnffgr_create_msg(self
):
258 """ Virtual Link Record message for Creating VLR in VNS """
259 vnffgr_dict
= {"id": self
._vnffgr
_id
,
260 "nsd_id": self
._nsr
.nsd_id
,
261 "vnffgd_id_ref": self
._vnffgd
_msg
.id,
262 "vnffgd_name_ref": self
._vnffgd
_msg
.name
,
263 "sdn_account": self
._sdn
_account
_name
,
265 vnffgr
= NsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_Vnffgr
.from_dict(vnffgr_dict
)
266 for rsp
in self
._vnffgd
_msg
.rsp
:
267 vnffgr_rsp
= vnffgr
.rsp
.add()
268 vnffgr_rsp
.id = str(uuid
.uuid4())
269 vnffgr_rsp
.name
= self
._nsr
.name
+ '.' + rsp
.name
270 self
._vnffgr
_rsp
_id
.append(vnffgr_rsp
.id)
271 vnffgr_rsp
.vnffgd_rsp_id_ref
= rsp
.id
272 vnffgr_rsp
.vnffgd_rsp_name_ref
= rsp
.name
273 for rsp_cp_ref
in rsp
.vnfd_connection_point_ref
:
274 vnfd
= [vnfr
.vnfd
for vnfr
in self
._nsr
.vnfrs
.values() if vnfr
.vnfd
.id == rsp_cp_ref
.vnfd_id_ref
]
275 self
._log
.debug("VNFD message during VNFFG instantiation is %s",vnfd
)
276 if len(vnfd
) > 0 and vnfd
[0].has_field('service_function_type'):
277 self
._log
.debug("Service Function Type for VNFD ID %s is %s",rsp_cp_ref
.vnfd_id_ref
, vnfd
[0].service_function_type
)
279 self
._log
.error("Service Function Type not available for VNFD ID %s; Skipping in chain",rsp_cp_ref
.vnfd_id_ref
)
282 vnfr_cp_ref
= vnffgr_rsp
.vnfr_connection_point_ref
.add()
283 vnfr_cp_ref
.member_vnf_index_ref
= rsp_cp_ref
.member_vnf_index_ref
284 vnfr_cp_ref
.hop_number
= rsp_cp_ref
.order
285 vnfr_cp_ref
.vnfd_id_ref
=rsp_cp_ref
.vnfd_id_ref
286 vnfr_cp_ref
.service_function_type
= vnfd
[0].service_function_type
287 for nsr_vnfr
in self
._nsr
.vnfrs
.values():
288 if (nsr_vnfr
.vnfd
.id == vnfr_cp_ref
.vnfd_id_ref
and
289 nsr_vnfr
.member_vnf_index
== vnfr_cp_ref
.member_vnf_index_ref
):
290 vnfr_cp_ref
.vnfr_id_ref
= nsr_vnfr
.id
291 vnfr_cp_ref
.vnfr_name_ref
= nsr_vnfr
.name
292 vnfr_cp_ref
.vnfr_connection_point_ref
= rsp_cp_ref
.vnfd_connection_point_ref
294 vnfr
= yield from self
._nsr
.fetch_vnfr(nsr_vnfr
.xpath
)
295 self
._log
.debug(" Received VNFR is %s", vnfr
)
296 while vnfr
.operational_status
!= 'running':
297 self
._log
.info("Received vnf op status is %s; retrying",vnfr
.operational_status
)
298 if vnfr
.operational_status
== 'failed':
299 self
._log
.error("Fetching VNFR for %s failed", vnfr
.id)
300 raise NsrInstantiationFailed("Failed NS %s instantiation due to VNFR %s failure" % (self
.id, vnfr
.id))
301 yield from asyncio
.sleep(2, loop
=self
._loop
)
302 vnfr
= yield from self
._nsr
.fetch_vnfr(nsr_vnfr
.xpath
)
303 self
._log
.debug("Received VNFR is %s", vnfr
)
305 vnfr_cp_ref
.connection_point_params
.mgmt_address
= vnfr
.mgmt_interface
.ip_address
306 for cp
in vnfr
.connection_point
:
307 if cp
.name
== vnfr_cp_ref
.vnfr_connection_point_ref
:
308 vnfr_cp_ref
.connection_point_params
.port_id
= cp
.connection_point_id
309 vnfr_cp_ref
.connection_point_params
.name
= self
._nsr
.name
+ '.' + cp
.name
310 for vdu
in vnfr
.vdur
:
311 for ext_intf
in vdu
.external_interface
:
312 if ext_intf
.name
== vnfr_cp_ref
.vnfr_connection_point_ref
:
313 vnfr_cp_ref
.connection_point_params
.vm_id
= vdu
.vim_id
314 self
._log
.debug("VIM ID for CP %s in VNFR %s is %s",cp
.name
,nsr_vnfr
.id,
315 vnfr_cp_ref
.connection_point_params
.vm_id
)
318 vnfr_cp_ref
.connection_point_params
.address
= cp
.ip_address
319 vnfr_cp_ref
.connection_point_params
.port
= VnffgRecord
.SFF_DP_PORT
321 for vnffgd_classifier
in self
._vnffgd
_msg
.classifier
:
322 _rsp
= [rsp
for rsp
in vnffgr
.rsp
if rsp
.vnffgd_rsp_id_ref
== vnffgd_classifier
.rsp_id_ref
]
324 rsp_id_ref
= _rsp
[0].id
325 rsp_name
= _rsp
[0].name
327 self
._log
.error("RSP with ID %s not found during classifier creation for classifier id %s",vnffgd_classifier
.rsp_id_ref
,vnffgd_classifier
.id)
329 vnffgr_classifier
= vnffgr
.classifier
.add()
330 vnffgr_classifier
.id = vnffgd_classifier
.id
331 vnffgr_classifier
.name
= self
._nsr
.name
+ '.' + vnffgd_classifier
.name
332 _rsp
[0].classifier_name
= vnffgr_classifier
.name
333 vnffgr_classifier
.rsp_id_ref
= rsp_id_ref
334 vnffgr_classifier
.rsp_name
= rsp_name
335 for nsr_vnfr
in self
._nsr
.vnfrs
.values():
336 if (nsr_vnfr
.vnfd
.id == vnffgd_classifier
.vnfd_id_ref
and
337 nsr_vnfr
.member_vnf_index
== vnffgd_classifier
.member_vnf_index_ref
):
338 vnffgr_classifier
.vnfr_id_ref
= nsr_vnfr
.id
339 vnffgr_classifier
.vnfr_name_ref
= nsr_vnfr
.name
340 vnffgr_classifier
.vnfr_connection_point_ref
= vnffgd_classifier
.vnfd_connection_point_ref
342 if nsr_vnfr
.vnfd
.service_function_chain
== 'CLASSIFIER':
343 vnffgr_classifier
.sff_name
= nsr_vnfr
.name
345 vnfr
= yield from self
._nsr
.fetch_vnfr(nsr_vnfr
.xpath
)
346 self
._log
.debug(" Received VNFR is %s", vnfr
)
347 while vnfr
.operational_status
!= 'running':
348 self
._log
.info("Received vnf op status is %s; retrying",vnfr
.operational_status
)
349 if vnfr
.operational_status
== 'failed':
350 self
._log
.error("Fetching VNFR for %s failed", vnfr
.id)
351 raise NsrInstantiationFailed("Failed NS %s instantiation due to VNFR %s failure" % (self
.id, vnfr
.id))
352 yield from asyncio
.sleep(2, loop
=self
._loop
)
353 vnfr
= yield from self
._nsr
.fetch_vnfr(nsr_vnfr
.xpath
)
354 self
._log
.debug("Received VNFR is %s", vnfr
)
356 for cp
in vnfr
.connection_point
:
357 if cp
.name
== vnffgr_classifier
.vnfr_connection_point_ref
:
358 vnffgr_classifier
.port_id
= cp
.connection_point_id
359 vnffgr_classifier
.ip_address
= cp
.ip_address
360 for vdu
in vnfr
.vdur
:
361 for ext_intf
in vdu
.external_interface
:
362 if ext_intf
.name
== vnffgr_classifier
.vnfr_connection_point_ref
:
363 vnffgr_classifier
.vm_id
= vdu
.vim_id
364 self
._log
.debug("VIM ID for CP %s in VNFR %s is %s",cp
.name
,nsr_vnfr
.id,
365 vnfr_cp_ref
.connection_point_params
.vm_id
)
368 self
._log
.info("VNFFGR msg to be sent is %s", vnffgr
)
372 def vnffgr_nsr_sff_list(self
):
373 """ SFF List for VNFR """
375 sf_list
= [nsr_vnfr
.name
for nsr_vnfr
in self
._nsr
.vnfrs
.values() if nsr_vnfr
.vnfd
.service_function_chain
== 'SF']
377 for nsr_vnfr
in self
._nsr
.vnfrs
.values():
378 if (nsr_vnfr
.vnfd
.service_function_chain
== 'CLASSIFIER' or nsr_vnfr
.vnfd
.service_function_chain
== 'SFF'):
379 vnfr
= yield from self
._nsr
.fetch_vnfr(nsr_vnfr
.xpath
)
380 self
._log
.debug(" Received VNFR is %s", vnfr
)
381 while vnfr
.operational_status
!= 'running':
382 self
._log
.info("Received vnf op status is %s; retrying",vnfr
.operational_status
)
383 if vnfr
.operational_status
== 'failed':
384 self
._log
.error("Fetching VNFR for %s failed", vnfr
.id)
385 raise NsrInstantiationFailed("Failed NS %s instantiation due to VNFR %s failure" % (self
.id, vnfr
.id))
386 yield from asyncio
.sleep(2, loop
=self
._loop
)
387 vnfr
= yield from self
._nsr
.fetch_vnfr(nsr_vnfr
.xpath
)
388 self
._log
.debug("Received VNFR is %s", vnfr
)
390 sff
= RwsdnYang
.VNFFGSff()
391 sff_list
[nsr_vnfr
.vnfd
.id] = sff
392 sff
.name
= nsr_vnfr
.name
393 sff
.function_type
= nsr_vnfr
.vnfd
.service_function_chain
395 sff
.mgmt_address
= vnfr
.mgmt_interface
.ip_address
396 sff
.mgmt_port
= VnffgRecord
.SFF_MGMT_PORT
397 for cp
in vnfr
.connection_point
:
398 sff_dp
= sff
.dp_endpoints
.add()
399 sff_dp
.name
= self
._nsr
.name
+ '.' + cp
.name
400 sff_dp
.address
= cp
.ip_address
401 sff_dp
.port
= VnffgRecord
.SFF_DP_PORT
402 if nsr_vnfr
.vnfd
.service_function_chain
== 'SFF':
403 for sf_name
in sf_list
:
404 _sf
= sff
.vnfr_list
.add()
405 _sf
.vnfr_name
= sf_name
410 def instantiate(self
):
411 """ Instantiate this VNFFG """
413 self
._log
.info("Instaniating VNFFGR with vnffgd %s",
417 vnffgr_request
= yield from self
.vnffgr_create_msg()
418 vnffg_sff_list
= yield from self
.vnffgr_nsr_sff_list()
421 vnffgr
= self
._vnffgmgr
.create_vnffgr(vnffgr_request
,self
._vnffgd
_msg
.classifier
,vnffg_sff_list
)
422 except Exception as e
:
423 self
._log
.exception("VNFFG instantiation failed: %s", str(e
))
424 self
._vnffgr
_state
= VnffgRecordState
.FAILED
425 raise NsrInstantiationFailed("Failed NS %s instantiation due to VNFFGR %s failure" % (self
.id, vnffgr_request
.id))
427 self
._vnffgr
_state
= VnffgRecordState
.INSTANTIATION_PENDING
429 self
._log
.info("Instantiated VNFFGR :%s", vnffgr
)
430 self
._vnffgr
_state
= VnffgRecordState
.ACTIVE
432 self
._log
.info("Invoking update_state to update NSR state for NSR ID: %s", self
._nsr
.id)
433 yield from self
._nsr
.update_state()
435 def vnffgr_in_vnffgrm(self
):
436 """ Is there a VNFR record in VNFM """
437 if (self
._vnffgr
_state
== VnffgRecordState
.ACTIVE
or
438 self
._vnffgr
_state
== VnffgRecordState
.INSTANTIATION_PENDING
or
439 self
._vnffgr
_state
== VnffgRecordState
.FAILED
):
446 """ Terminate this VNFFGR """
447 if not self
.vnffgr_in_vnffgrm():
448 self
._log
.error("Ignoring terminate request for id %s in state %s",
449 self
.id, self
._vnffgr
_state
)
452 self
._log
.info("Terminating VNFFGR id:%s", self
.id)
453 self
._vnffgr
_state
= VnffgRecordState
.TERMINATE_PENDING
455 self
._vnffgmgr
.terminate_vnffgr(self
._vnffgr
_id
)
457 self
._vnffgr
_state
= VnffgRecordState
.TERMINATED
458 self
._log
.debug("Terminated VNFFGR id:%s", self
.id)
461 class VirtualLinkRecord(object):
462 """ Virtual Link Records class"""
463 XPATH
= "D,/vlr:vlr-catalog/vlr:vlr"
466 def create_record(dts
, log
, loop
, nsr_name
, vld_msg
, cloud_account_name
, om_datacenter
, ip_profile
, nsr_id
, restart_mode
=False):
467 """Creates a new VLR object based on the given data.
469 If restart mode is enabled, then we look for existing records in the
470 DTS and create a VLR records using the exiting data(ID)
475 vlr_obj
= VirtualLinkRecord(
488 res_iter
= yield from dts
.query_read(
489 "D,/vlr:vlr-catalog/vlr:vlr",
490 rwdts
.XactFlag
.MERGE
)
493 response
= yield from fut
494 vlr
= response
.result
496 # Check if the record is already present, if so use the ID of
497 # the existing record. Since the name of the record is uniquely
498 # formed we can use it as a search key!
499 if vlr
.name
== vlr_obj
.name
:
500 vlr_obj
.reset_id(vlr
.id)
505 def __init__(self
, dts
, log
, loop
, nsr_name
, vld_msg
, cloud_account_name
, om_datacenter
, ip_profile
, nsr_id
):
509 self
._nsr
_name
= nsr_name
510 self
._vld
_msg
= vld_msg
511 self
._cloud
_account
_name
= cloud_account_name
512 self
._om
_datacenter
_name
= om_datacenter
513 self
._assigned
_subnet
= None
514 self
._nsr
_id
= nsr_id
515 self
._ip
_profile
= ip_profile
516 self
._vlr
_id
= str(uuid
.uuid4())
517 self
._state
= VlRecordState
.INIT
518 self
._prev
_state
= None
519 self
._create
_time
= int(time
.time())
523 """ path for this object """
524 return "D,/vlr:vlr-catalog/vlr:vlr[vlr:id = '{}']".format(self
._vlr
_id
)
533 """ Get NSR name for this VL """
538 """ Virtual Link Desciptor """
542 def assigned_subnet(self
):
543 """ Subnet assigned to this VL"""
544 return self
._assigned
_subnet
549 Get the name for this VLR.
550 VLR name is "nsr name:VLD name"
552 if self
.vld_msg
.vim_network_name
:
553 return self
.vld_msg
.vim_network_name
554 elif self
.vld_msg
.name
== "multisite":
555 # This is a temporary hack to identify manually provisioned inter-site network
556 return self
.vld_msg
.name
558 return self
._nsr
_name
+ "." + self
.vld_msg
.name
561 def cloud_account_name(self
):
562 """ Cloud account that this VLR should be created in """
563 return self
._cloud
_account
_name
566 def om_datacenter_name(self
):
567 """ Datacenter that this VLR should be created in """
568 return self
._om
_datacenter
_name
572 """ Get the VLR path from VLR """
573 return (VirtualLinkRecord
.XPATH
+ "[vlr:id = '{}']").format(vlr
.id)
581 def state(self
, value
):
582 """ VLR set state """
586 def prev_state(self
):
587 """ VLR previous state """
588 return self
._prev
_state
591 def prev_state(self
, value
):
592 """ VLR set previous state """
593 self
._prev
_state
= value
597 """ Virtual Link Record message for Creating VLR in VNS """
598 vld_fields
= ["short_name",
606 vld_copy_dict
= {k
: v
for k
, v
in self
.vld_msg
.as_dict().items()
609 vlr_dict
= {"id": self
._vlr
_id
,
610 "nsr_id_ref": self
._nsr
_id
,
611 "vld_ref": self
.vld_msg
.id,
613 "create_time": self
._create
_time
,
614 "cloud_account": self
.cloud_account_name
,
615 "om_datacenter": self
.om_datacenter_name
,
618 if self
._ip
_profile
and self
._ip
_profile
.has_field('ip_profile_params'):
619 vlr_dict
['ip_profile_params' ] = self
._ip
_profile
.ip_profile_params
.as_dict()
621 vlr_dict
.update(vld_copy_dict
)
622 vlr
= RwVlrYang
.YangData_Vlr_VlrCatalog_Vlr
.from_dict(vlr_dict
)
625 def reset_id(self
, vlr_id
):
626 self
._vlr
_id
= vlr_id
628 def create_nsr_vlr_msg(self
, vnfrs
):
629 """ The VLR message"""
630 nsr_vlr
= RwNsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_Vlr()
631 nsr_vlr
.vlr_ref
= self
._vlr
_id
632 nsr_vlr
.assigned_subnet
= self
.assigned_subnet
633 nsr_vlr
.cloud_account
= self
.cloud_account_name
634 nsr_vlr
.om_datacenter
= self
.om_datacenter_name
636 for conn
in self
.vld_msg
.vnfd_connection_point_ref
:
638 if (vnfr
.vnfd
.id == conn
.vnfd_id_ref
and
639 vnfr
.member_vnf_index
== conn
.member_vnf_index_ref
and
640 self
.cloud_account_name
== vnfr
.cloud_account_name
and
641 self
.om_datacenter_name
== vnfr
.om_datacenter_name
):
642 cp_entry
= nsr_vlr
.vnfr_connection_point_ref
.add()
643 cp_entry
.vnfr_id
= vnfr
.id
644 cp_entry
.connection_point
= conn
.vnfd_connection_point_ref
649 def instantiate(self
):
650 """ Instantiate this VL """
651 self
._log
.debug("Instaniating VLR key %s, vld %s",
652 self
.xpath
, self
._vld
_msg
)
654 self
._state
= VlRecordState
.INSTANTIATION_PENDING
655 self
._log
.debug("Executing VL create path:%s msg:%s",
656 self
.xpath
, self
.vlr_msg
)
658 with self
._dts
.transaction(flags
=0) as xact
:
659 block
= xact
.block_create()
660 block
.add_query_create(self
.xpath
, self
.vlr_msg
)
661 self
._log
.debug("Executing VL create path:%s msg:%s",
662 self
.xpath
, self
.vlr_msg
)
663 res_iter
= yield from block
.execute(now
=True)
669 self
._state
= VlRecordState
.FAILED
670 raise NsrInstantiationFailed("Failed NS %s instantiation due to empty response" % self
.id)
672 if vlr
.operational_status
== 'failed':
673 self
._log
.debug("NS Id:%s VL creation failed for vlr id %s", self
.id, vlr
.id)
674 self
._state
= VlRecordState
.FAILED
675 raise NsrInstantiationFailed("Failed VL %s instantiation (%s)" % (vlr
.id, vlr
.operational_status_details
))
677 self
._log
.info("Instantiated VL with xpath %s and vlr:%s",
679 self
._state
= VlRecordState
.ACTIVE
680 self
._assigned
_subnet
= vlr
.assigned_subnet
682 def vlr_in_vns(self
):
683 """ Is there a VLR record in VNS """
684 if (self
._state
== VlRecordState
.ACTIVE
or
685 self
._state
== VlRecordState
.INSTANTIATION_PENDING
or
686 self
._state
== VlRecordState
.TERMINATE_PENDING
or
687 self
._state
== VlRecordState
.FAILED
):
694 """ Terminate this VL """
695 if not self
.vlr_in_vns():
696 self
._log
.debug("Ignoring terminate request for id %s in state %s",
697 self
.id, self
._state
)
700 self
._log
.debug("Terminating VL id:%s", self
.id)
701 self
._state
= VlRecordState
.TERMINATE_PENDING
703 with self
._dts
.transaction(flags
=0) as xact
:
704 block
= xact
.block_create()
705 block
.add_query_delete(self
.xpath
)
706 yield from block
.execute(flags
=0, now
=True)
708 self
._state
= VlRecordState
.TERMINATED
709 self
._log
.debug("Terminated VL id:%s", self
.id)
712 class VnfRecordState(Enum
):
713 """ Vnf Record State """
715 INSTANTIATION_PENDING
= 102
717 TERMINATE_PENDING
= 104
722 class VirtualNetworkFunctionRecord(object):
723 """ Virtual Network Function Record class"""
724 XPATH
= "D,/vnfr:vnfr-catalog/vnfr:vnfr"
728 def create_record(dts
, log
, loop
, vnfd
, const_vnfd_msg
, nsd_id
, nsr_name
,
729 cloud_account_name
, om_datacenter_name
, nsr_id
, group_name
, group_instance_id
,
730 placement_groups
, restart_mode
=False):
731 """Creates a new VNFR object based on the given data.
733 If restart mode is enabled, then we look for existing records in the
734 DTS and create a VNFR records using the exiting data(ID)
737 VirtualNetworkFunctionRecord
739 vnfr_obj
= VirtualNetworkFunctionRecord(
753 restart_mode
=restart_mode
)
756 res_iter
= yield from dts
.query_read(
757 "D,/vnfr:vnfr-catalog/vnfr:vnfr",
758 rwdts
.XactFlag
.MERGE
)
761 response
= yield from fut
762 vnfr
= response
.result
764 if vnfr
.name
== vnfr_obj
.name
:
765 vnfr_obj
.reset_id(vnfr
.id)
782 group_instance_id
=None,
783 placement_groups
= [],
784 restart_mode
= False):
789 self
._const
_vnfd
_msg
= const_vnfd_msg
790 self
._nsd
_id
= nsd_id
791 self
._nsr
_name
= nsr_name
792 self
._nsr
_id
= nsr_id
793 self
._cloud
_account
_name
= cloud_account_name
794 self
._om
_datacenter
_name
= om_datacenter_name
795 self
._group
_name
= group_name
796 self
._group
_instance
_id
= group_instance_id
797 self
._placement
_groups
= placement_groups
798 self
._config
_status
= NsrYang
.ConfigStates
.INIT
800 self
._prev
_state
= VnfRecordState
.INIT
801 self
._state
= VnfRecordState
.INIT
802 self
._state
_failed
_reason
= None
804 self
.config_store
= rift
.mano
.config_data
.config
.ConfigStore(self
._log
)
807 self
._vnfr
_id
= str(uuid
.uuid4())
809 self
._vnfr
_msg
= self
.create_vnfr_msg()
810 self
._log
.debug("Set VNFR {} config type to {}".
811 format(self
.name
, self
.config_type
))
812 self
.restart_mode
= restart_mode
815 if group_name
is None and group_instance_id
is not None:
816 raise ValueError("Group instance id must not be provided with an empty group name")
826 return "D,/vnfr:vnfr-catalog/vnfr:vnfr[vnfr:id = '{}']".format(self
.id)
831 return self
._vnfr
_msg
834 def const_vnfr_msg(self
):
836 return RwNsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_ConstituentVnfrRef(vnfr_id
=self
.id,cloud_account
=self
.cloud_account_name
,om_datacenter
=self
._om
_datacenter
_name
)
844 def cloud_account_name(self
):
845 """ Cloud account that this VNF should be created in """
846 return self
._cloud
_account
_name
849 def om_datacenter_name(self
):
850 """ Datacenter that this VNF should be created in """
851 return self
._om
_datacenter
_name
856 """ Is this VNF actve """
857 return True if self
._state
== VnfRecordState
.ACTIVE
else False
861 """ state of this VNF """
865 def state_failed_reason(self
):
866 """ Error message in case this VNF is in failed state """
867 return self
._state
_failed
_reason
870 def member_vnf_index(self
):
871 """ Member VNF index """
872 return self
._const
_vnfd
_msg
.member_vnf_index
877 return self
._nsr
_name
881 """ Name of this VNFR """
882 if self
._name
is not None:
885 name_tags
= [self
._nsr
_name
]
887 if self
._group
_name
is not None:
888 name_tags
.append(self
._group
_name
)
890 if self
._group
_instance
_id
is not None:
891 name_tags
.append(str(self
._group
_instance
_id
))
893 name_tags
.extend([self
.vnfd
.name
, str(self
.member_vnf_index
)])
895 self
._name
= "__".join(name_tags
)
900 def vnfr_xpath(vnfr
):
901 """ Get the VNFR path from VNFR """
902 return (VirtualNetworkFunctionRecord
.XPATH
+ "[vnfr:id = '{}']").format(vnfr
.id)
905 def config_type(self
):
906 cfg_types
= ['netconf', 'juju', 'script']
907 for method
in cfg_types
:
908 if self
._vnfd
.vnf_configuration
.has_field(method
):
913 def config_status(self
):
914 """Return the config status as YANG ENUM string"""
915 self
._log
.debug("Map VNFR {} config status {} ({})".
916 format(self
.name
, self
._config
_status
, self
.config_type
))
917 if self
.config_type
== 'none':
918 return 'config_not_needed'
919 elif self
._config
_status
== NsrYang
.ConfigStates
.CONFIGURED
:
921 elif self
._config
_status
== NsrYang
.ConfigStates
.FAILED
:
926 def set_state(self
, state
):
927 """ set the state of this object """
928 self
._prev
_state
= self
._state
931 def reset_id(self
, vnfr_id
):
932 self
._vnfr
_id
= vnfr_id
933 self
._vnfr
_msg
= self
.create_vnfr_msg()
936 self
.config_store
.merge_vnfd_config(
939 self
.member_vnf_index
,
942 def create_vnfr_msg(self
):
943 """ VNFR message for this VNFR """
951 vnfd_copy_dict
= {k
: v
for k
, v
in self
._vnfd
.as_dict().items() if k
in vnfd_fields
}
954 "nsr_id_ref": self
._nsr
_id
,
955 "vnfd_ref": self
.vnfd
.id,
957 "cloud_account": self
._cloud
_account
_name
,
958 "om_datacenter": self
._om
_datacenter
_name
,
959 "config_status": self
.config_status
961 vnfr_dict
.update(vnfd_copy_dict
)
963 vnfr
= RwVnfrYang
.YangData_Vnfr_VnfrCatalog_Vnfr
.from_dict(vnfr_dict
)
964 vnfr
.member_vnf_index_ref
= self
.member_vnf_index
965 vnfr
.vnf_configuration
.from_dict(self
._vnfd
.vnf_configuration
.as_dict())
967 if self
._vnfd
.mgmt_interface
.has_field("port"):
968 vnfr
.mgmt_interface
.port
= self
._vnfd
.mgmt_interface
.port
970 for group_info
in self
._placement
_groups
:
971 group
= vnfr
.placement_groups_info
.add()
972 group
.from_dict(group_info
.as_dict())
974 # UI expects the monitoring param field to exist
975 vnfr
.monitoring_param
= []
977 self
._log
.debug("Get vnfr_msg for VNFR {} : {}".format(self
.name
, vnfr
))
981 def update_vnfm(self
):
982 self
._log
.debug("Send an update to VNFM for VNFR {} with {}".
983 format(self
.name
, self
.vnfr_msg
))
984 yield from self
._dts
.query_update(
986 rwdts
.XactFlag
.TRACE
,
990 def get_config_status(self
):
991 """Return the config status as YANG ENUM"""
992 return self
._config
_status
995 def set_config_status(self
, status
):
997 def status_to_string(status
):
999 NsrYang
.ConfigStates
.INIT
: 'init',
1000 NsrYang
.ConfigStates
.CONFIGURING
: 'configuring',
1001 NsrYang
.ConfigStates
.CONFIG_NOT_NEEDED
: 'config_not_needed',
1002 NsrYang
.ConfigStates
.CONFIGURED
: 'configured',
1003 NsrYang
.ConfigStates
.FAILED
: 'failed',
1006 return status_dc
[status
]
1008 self
._log
.debug("Update VNFR {} from {} ({}) to {}".
1009 format(self
.name
, self
._config
_status
,
1010 self
.config_type
, status
))
1011 if self
._config
_status
== NsrYang
.ConfigStates
.CONFIGURED
:
1012 self
._log
.error("Updating already configured VNFR {}".
1016 if self
._config
_status
!= status
:
1018 self
._config
_status
= status
1019 # I don't think this is used. Original implementor can check.
1020 # Caused Exception, so corrected it by status_to_string
1021 # But not sure whats the use of this variable?
1022 self
.vnfr_msg
.config_status
= status_to_string(status
)
1023 except Exception as e
:
1024 self
._log
.error("Exception=%s", str(e
))
1027 self
._log
.debug("Updated VNFR {} status to {}".format(self
.name
, status
))
1029 if self
._config
_status
!= NsrYang
.ConfigStates
.INIT
:
1031 # Publish only after VNFM has the VNFR created
1032 yield from self
.update_vnfm()
1033 except Exception as e
:
1034 self
._log
.error("Exception updating VNFM with new status {} of VNFR {}: {}".
1035 format(status
, self
.name
, e
))
1036 self
._log
.exception(e
)
1038 def is_configured(self
):
1039 if self
.config_type
== 'none':
1042 if self
._config
_status
== NsrYang
.ConfigStates
.CONFIGURED
:
1048 def instantiate(self
, nsr
):
1049 """ Instantiate this VNFR"""
1051 self
._log
.debug("Instaniating VNFR key %s, vnfd %s",
1052 self
.xpath
, self
._vnfd
)
1054 self
._log
.debug("Create VNF with xpath %s and vnfr %s",
1055 self
.xpath
, self
.vnfr_msg
)
1057 self
.set_state(VnfRecordState
.INSTANTIATION_PENDING
)
1059 def find_vlr_for_cp(conn
):
1060 """ Find VLR for the given connection point """
1061 for vlr
in nsr
.vlrs
:
1062 for vnfd_cp
in vlr
.vld_msg
.vnfd_connection_point_ref
:
1063 if (vnfd_cp
.vnfd_id_ref
== self
._vnfd
.id and
1064 vnfd_cp
.vnfd_connection_point_ref
== conn
.name
and
1065 vnfd_cp
.member_vnf_index_ref
== self
.member_vnf_index
and
1066 vlr
.cloud_account_name
== self
.cloud_account_name
):
1067 self
._log
.debug("Found VLR for cp_name:%s and vnf-index:%d",
1068 conn
.name
, self
.member_vnf_index
)
1072 # For every connection point in the VNFD fill in the identifier
1073 for conn_p
in self
._vnfd
.connection_point
:
1074 cpr
= VnfrYang
.YangData_Vnfr_VnfrCatalog_Vnfr_ConnectionPoint()
1075 cpr
.name
= conn_p
.name
1076 cpr
.type_yang
= conn_p
.type_yang
1077 vlr_ref
= find_vlr_for_cp(conn_p
)
1079 msg
= "Failed to find VLR for cp = %s" % conn_p
.name
1080 self
._log
.debug("%s", msg
)
1081 # raise VirtualNetworkFunctionRecordError(msg)
1084 cpr
.vlr_ref
= vlr_ref
.id
1085 self
.vnfr_msg
.connection_point
.append(cpr
)
1086 self
._log
.debug("Connection point [%s] added, vnf id=%s vnfd id=%s",
1087 cpr
, self
.vnfr_msg
.id, self
.vnfr_msg
.vnfd_ref
)
1089 if not self
.restart_mode
:
1090 yield from self
._dts
.query_create(self
.xpath
,
1094 yield from self
._dts
.query_update(self
.xpath
,
1098 self
._log
.info("Created VNF with xpath %s and vnfr %s",
1099 self
.xpath
, self
.vnfr_msg
)
1101 self
._log
.info("Instantiated VNFR with xpath %s and vnfd %s, vnfr %s",
1102 self
.xpath
, self
._vnfd
, self
.vnfr_msg
)
1105 def update_state(self
, vnfr_msg
):
1106 """ Update this VNFR"""
1107 if vnfr_msg
.operational_status
== "running":
1108 if self
.vnfr_msg
.operational_status
!= "running":
1109 yield from self
.is_active()
1110 elif vnfr_msg
.operational_status
== "failed":
1111 yield from self
.instantiation_failed(failed_reason
=vnfr_msg
.operational_status_details
)
1114 def is_active(self
):
1115 """ This VNFR is active """
1116 self
._log
.debug("VNFR %s is active", self
._vnfr
_id
)
1117 self
.set_state(VnfRecordState
.ACTIVE
)
1120 def instantiation_failed(self
, failed_reason
=None):
1121 """ This VNFR instantiation failed"""
1122 self
._log
.error("VNFR %s instantiation failed", self
._vnfr
_id
)
1123 self
.set_state(VnfRecordState
.FAILED
)
1124 self
._state
_failed
_reason
= failed_reason
1126 def vnfr_in_vnfm(self
):
1127 """ Is there a VNFR record in VNFM """
1128 if (self
._state
== VnfRecordState
.ACTIVE
or
1129 self
._state
== VnfRecordState
.INSTANTIATION_PENDING
or
1130 self
._state
== VnfRecordState
.FAILED
):
1136 def terminate(self
):
1137 """ Terminate this VNF """
1138 if not self
.vnfr_in_vnfm():
1139 self
._log
.debug("Ignoring terminate request for id %s in state %s",
1140 self
.id, self
._state
)
1143 self
._log
.debug("Terminating VNF id:%s", self
.id)
1144 self
.set_state(VnfRecordState
.TERMINATE_PENDING
)
1145 with self
._dts
.transaction(flags
=0) as xact
:
1146 block
= xact
.block_create()
1147 block
.add_query_delete(self
.xpath
)
1148 yield from block
.execute(flags
=0)
1149 self
.set_state(VnfRecordState
.TERMINATED
)
1150 self
._log
.debug("Terminated VNF id:%s", self
.id)
1153 class NetworkServiceStatus(object):
1154 """ A class representing the Network service's status """
1155 MAX_EVENTS_RECORDED
= 10
1156 """ Network service Status class"""
1157 def __init__(self
, dts
, log
, loop
):
1162 self
._state
= NetworkServiceRecordState
.INIT
1163 self
._events
= deque([])
1166 def create_notification(self
, evt
, evt_desc
, evt_details
):
1167 xp
= "N,/rw-nsr:nsm-notification"
1168 notif
= RwNsrYang
.YangNotif_RwNsr_NsmNotification()
1170 notif
.description
= evt_desc
1171 notif
.details
= evt_details
if evt_details
is not None else None
1173 yield from self
._dts
.query_create(xp
, rwdts
.XactFlag
.ADVISE
, notif
)
1174 self
._log
.info("Notification called by creating dts query: %s", notif
)
1176 def record_event(self
, evt
, evt_desc
, evt_details
):
1177 """ Record an event """
1178 self
._log
.debug("Recording event - evt %s, evt_descr %s len = %s",
1179 evt
, evt_desc
, len(self
._events
))
1180 if len(self
._events
) >= NetworkServiceStatus
.MAX_EVENTS_RECORDED
:
1181 self
._events
.popleft()
1182 self
._events
.append((int(time
.time()), evt
, evt_desc
,
1183 evt_details
if evt_details
is not None else None))
1185 self
._loop
.create_task(self
.create_notification(evt
,evt_desc
,evt_details
))
1187 def set_state(self
, state
):
1188 """ set the state of this status object """
1192 """ Return the state as a yang enum string """
1193 state_to_str_map
= {"INIT": "init",
1194 "VL_INIT_PHASE": "vl_init_phase",
1195 "VNF_INIT_PHASE": "vnf_init_phase",
1196 "VNFFG_INIT_PHASE": "vnffg_init_phase",
1197 "SCALING_GROUP_INIT_PHASE": "scaling_group_init_phase",
1198 "RUNNING": "running",
1199 "SCALING_OUT": "scaling_out",
1200 "SCALING_IN": "scaling_in",
1201 "TERMINATE_RCVD": "terminate_rcvd",
1202 "TERMINATE": "terminate",
1203 "VL_TERMINATE_PHASE": "vl_terminate_phase",
1204 "VNF_TERMINATE_PHASE": "vnf_terminate_phase",
1205 "VNFFG_TERMINATE_PHASE": "vnffg_terminate_phase",
1206 "TERMINATED": "terminated",
1208 "VL_INSTANTIATE": "vl_instantiate",
1209 "VL_TERMINATE": "vl_terminate",
1211 return state_to_str_map
[self
._state
.name
]
1215 """ State of this status object """
1220 """ Network Service Record as a message"""
1223 for entry
in self
._events
:
1224 event
= RwNsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_OperationalEvents()
1227 event
.timestamp
, event
.event
, event
.description
, event
.details
= entry
1228 event_list
.append(event
)
1232 class NetworkServiceRecord(object):
1233 """ Network service record """
1234 XPATH
= "D,/nsr:ns-instance-opdata/nsr:nsr"
1236 def __init__(self
, dts
, log
, loop
, nsm
, nsm_plugin
, nsr_cfg_msg
, sdn_account_name
, key_pairs
, restart_mode
=False,
1242 self
._nsr
_cfg
_msg
= nsr_cfg_msg
1243 self
._nsm
_plugin
= nsm_plugin
1244 self
._sdn
_account
_name
= sdn_account_name
1245 self
._vlr
_handler
= vlr_handler
1248 self
._nsr
_msg
= None
1249 self
._nsr
_regh
= None
1250 self
._key
_pairs
= key_pairs
1255 self
._param
_pools
= {}
1256 self
._scaling
_groups
= {}
1257 self
._create
_time
= int(time
.time())
1258 self
._op
_status
= NetworkServiceStatus(dts
, log
, loop
)
1259 self
._config
_status
= NsrYang
.ConfigStates
.CONFIGURING
1260 self
._config
_status
_details
= None
1262 self
.restart_mode
= restart_mode
1263 self
.config_store
= rift
.mano
.config_data
.config
.ConfigStore(self
._log
)
1264 self
._debug
_running
= False
1265 self
._is
_active
= False
1266 self
._vl
_phase
_completed
= False
1267 self
._vnf
_phase
_completed
= False
1270 # Initalise the state to init
1271 # The NSR moves through the following transitions
1272 # 1. INIT -> VLS_READY once all the VLs in the NSD are created
1273 # 2. VLS_READY - VNFS_READY when all the VNFs in the NSD are created
1274 # 3. VNFS_READY - READY when the NSR is published
1276 self
.set_state(NetworkServiceRecordState
.INIT
)
1278 self
.substitute_input_parameters
= InputParameterSubstitution(self
._log
)
1281 def nsm_plugin(self
):
1283 return self
._nsm
_plugin
1285 def set_state(self
, state
):
1286 """ Set state for this NSR"""
1287 self
._log
.debug("Setting state to %s", state
)
1288 # We are in init phase and is moving to the next state
1289 # The new state could be a FAILED state or VNF_INIIT_PHASE
1290 if self
.state
== NetworkServiceRecordState
.VL_INIT_PHASE
:
1291 self
._vl
_phase
_completed
= True
1293 if self
.state
== NetworkServiceRecordState
.VNF_INIT_PHASE
:
1294 self
._vnf
_phase
_completed
= True
1296 self
._op
_status
.set_state(state
)
1300 """ Get id for this NSR"""
1301 return self
._nsr
_cfg
_msg
.id
1305 """ Name of this network service record """
1306 return self
._nsr
_cfg
_msg
.name
1309 def cloud_account_name(self
):
1310 return self
._nsr
_cfg
_msg
.cloud_account
1313 def om_datacenter_name(self
):
1314 if self
._nsr
_cfg
_msg
.has_field('om_datacenter'):
1315 return self
._nsr
_cfg
_msg
.om_datacenter
1320 """State of this NetworkServiceRecord"""
1321 return self
._op
_status
.state
1325 """ Is this NSR active ?"""
1326 return True if self
._op
_status
.state
== NetworkServiceRecordState
.RUNNING
else False
1330 """ VLRs associated with this NSR"""
1335 """ VNFRs associated with this NSR"""
1340 """ VNFFGRs associated with this NSR"""
1341 return self
._vnffgrs
1344 def scaling_groups(self
):
1345 """ Scaling groups associated with this NSR """
1346 return self
._scaling
_groups
1349 def param_pools(self
):
1350 """ Parameter value pools associated with this NSR"""
1351 return self
._param
_pools
1354 def nsr_cfg_msg(self
):
1355 return self
._nsr
_cfg
_msg
1358 def nsr_cfg_msg(self
, msg
):
1359 self
._nsr
_cfg
_msg
= msg
1363 """ NSD Protobuf for this NSR """
1364 if self
._nsd
is not None:
1366 self
._nsd
= self
._nsr
_cfg
_msg
.nsd
1371 """ NSD ID for this NSR """
1372 return self
.nsd_msg
.id
1376 ''' Get a new job id for config primitive'''
1381 def config_status(self
):
1382 """ Config status for NSR """
1383 return self
._config
_status
1385 def resolve_placement_group_cloud_construct(self
, input_group
):
1387 Returns the cloud specific construct for placement group
1389 copy_dict
= ['name', 'requirement', 'strategy']
1391 for group_info
in self
._nsr
_cfg
_msg
.nsd_placement_group_maps
:
1392 if group_info
.placement_group_ref
== input_group
.name
:
1393 group
= VnfrYang
.YangData_Vnfr_VnfrCatalog_Vnfr_PlacementGroupsInfo()
1394 group_dict
= {k
:v
for k
,v
in
1395 group_info
.as_dict().items() if k
!= 'placement_group_ref'}
1396 for param
in copy_dict
:
1397 group_dict
.update({param
: getattr(input_group
, param
)})
1398 group
.from_dict(group_dict
)
1404 return "NSR(name={}, nsd_id={}, cloud_account={})".format(
1405 self
.name
, self
.nsd_id
, self
.cloud_account_name
1408 def _get_vnfd(self
, vnfd_id
, config_xact
):
1409 """ Fetch vnfd msg for the passed vnfd id """
1410 return self
._nsm
.get_vnfd(vnfd_id
, config_xact
)
1412 def _get_vnfd_cloud_account(self
, vnfd_member_index
):
1413 """ Fetch Cloud Account for the passed vnfd id """
1414 if self
._nsr
_cfg
_msg
.vnf_cloud_account_map
:
1415 vim_accounts
= [(vnf
.cloud_account
,vnf
.om_datacenter
) for vnf
in self
._nsr
_cfg
_msg
.vnf_cloud_account_map \
1416 if vnfd_member_index
== vnf
.member_vnf_index_ref
]
1417 if vim_accounts
and vim_accounts
[0]:
1418 return vim_accounts
[0]
1419 return (self
.cloud_account_name
,self
.om_datacenter_name
)
1421 def _get_constituent_vnfd_msg(self
, vnf_index
):
1422 for const_vnfd
in self
.nsd_msg
.constituent_vnfd
:
1423 if const_vnfd
.member_vnf_index
== vnf_index
:
1426 raise ValueError("Constituent VNF index %s not found" % vnf_index
)
1428 def record_event(self
, evt
, evt_desc
, evt_details
=None, state
=None):
1429 """ Record an event """
1430 self
._op
_status
.record_event(evt
, evt_desc
, evt_details
)
1431 if state
is not None:
1432 self
.set_state(state
)
1434 def scaling_trigger_str(self
, trigger
):
1435 SCALING_TRIGGER_STRS
= {
1436 NsdYang
.ScalingTrigger
.PRE_SCALE_IN
: 'pre-scale-in',
1437 NsdYang
.ScalingTrigger
.POST_SCALE_IN
: 'post-scale-in',
1438 NsdYang
.ScalingTrigger
.PRE_SCALE_OUT
: 'pre-scale-out',
1439 NsdYang
.ScalingTrigger
.POST_SCALE_OUT
: 'post-scale-out',
1442 return SCALING_TRIGGER_STRS
[trigger
]
1443 except Exception as e
:
1444 self
._log
.error("Scaling trigger mapping error for {} : {}".
1446 self
._log
.exception(e
)
1447 return "Unknown trigger"
1450 def instantiate_vls(self
):
1452 This function instantiates VLs for every VL in this Network Service
1454 self
._log
.debug("Instantiating %d VLs in NSD id %s", len(self
._vlrs
),
1456 for vlr
in self
._vlrs
:
1457 yield from self
.nsm_plugin
.instantiate_vl(self
, vlr
)
1458 vlr
.state
= VlRecordState
.ACTIVE
1459 self
._loop
.create_task(self
.vlr_uptime_update(vlr
))
1462 def vlr_uptime_update(self
, vlr
):
1463 vlr_
= RwVlrYang
.YangData_Vlr_VlrCatalog_Vlr
.from_dict({'id': vlr
.id})
1465 if vlr
.state
not in [VlRecordState
.INIT
, VlRecordState
.INSTANTIATION_PENDING
, VlRecordState
.ACTIVE
]:
1467 vlr_
.uptime
= int(time
.time()) - vlr
._create
_time
1468 yield from self
._vlr
_handler
.update(None, VirtualLinkRecord
.vlr_xpath(vlr
), vlr_
)
1469 yield from asyncio
.sleep(2, loop
=self
._loop
)
1473 def create(self
, config_xact
):
1474 """ Create this network service"""
1475 # Create virtual links for all the external vnf
1476 # connection points in this NS
1477 yield from self
.create_vls()
1479 # Create VNFs in this network service
1480 yield from self
.create_vnfs(config_xact
)
1482 # Create VNFFG for network service
1483 self
.create_vnffgs()
1485 # Create Scaling Groups for each scaling group in NSD
1486 self
.create_scaling_groups()
1488 # Create Parameter Pools
1489 self
.create_param_pools()
1492 def apply_scale_group_config_script(self
, script
, group
, scale_instance
, trigger
, vnfrs
=None):
1493 """ Apply config based on script for scale group """
1496 def add_vnfrs_data(vnfrs_list
):
1497 """ Add as a dict each of the VNFRs data """
1499 for vnfr
in vnfrs_list
:
1500 self
._log
.debug("Add VNFR {} data".format(vnfr
))
1502 vnfr_data
['name'] = vnfr
.name
1503 if trigger
in [NsdYang
.ScalingTrigger
.PRE_SCALE_IN
, NsdYang
.ScalingTrigger
.POST_SCALE_OUT
]:
1504 # Get VNF management and other IPs, etc
1505 opdata
= yield from self
.fetch_vnfr(vnfr
.xpath
)
1506 self
._log
.debug("VNFR {} op data: {}".format(vnfr
.name
, opdata
))
1508 vnfr_data
['rw_mgmt_ip'] = opdata
.mgmt_interface
.ip_address
1509 vnfr_data
['rw_mgmt_port'] = opdata
.mgmt_interface
.port
1510 except Exception as e
:
1511 self
._log
.error("Unable to get management IP for vnfr {}:{}".
1512 format(vnfr
.name
, e
))
1515 vnfr_data
['connection_points'] = []
1516 for cp
in opdata
.connection_point
:
1518 con_pt
['name'] = cp
.name
1519 con_pt
['ip_address'] = cp
.ip_address
1520 vnfr_data
['connection_points'].append(con_pt
)
1521 except Exception as e
:
1522 self
._log
.error("Exception getting connections points for VNFR {}: {}".
1523 format(vnfr
.name
, e
))
1525 vnfrs_data
.append(vnfr_data
)
1526 self
._log
.debug("VNFRs data: {}".format(vnfrs_data
))
1530 def add_nsr_data(nsr
):
1532 nsr_data
['name'] = nsr
.name
1535 if script
is None or len(script
) == 0:
1536 self
._log
.error("Script not provided for scale group config: {}".format(group
.name
))
1539 if script
[0] == '/':
1542 path
= os
.path
.join(os
.environ
['RIFT_INSTALL'], "usr/bin", script
)
1543 if not os
.path
.exists(path
):
1544 self
._log
.error("Config faled for scale group {}: Script does not exist at {}".
1545 format(group
.name
, path
))
1548 # Build a YAML file with all parameters for the script to execute
1549 # The data consists of 5 sections
1551 # 2. Scale group config
1552 # 3. VNFRs in the scale group
1553 # 4. VNFRs outside scale group
1556 data
['trigger'] = group
.trigger_map(trigger
)
1557 data
['config'] = group
.group_msg
.as_dict()
1560 data
["vnfrs_in_group"] = yield from add_vnfrs_data(vnfrs
)
1562 data
["vnfrs_in_group"] = yield from add_vnfrs_data(scale_instance
.vnfrs
)
1564 data
["vnfrs_others"] = yield from add_vnfrs_data(self
.vnfrs
.values())
1565 data
["nsr"] = add_nsr_data(self
)
1568 with tempfile
.NamedTemporaryFile(delete
=False) as tmp_file
:
1569 tmp_file
.write(yaml
.dump(data
, default_flow_style
=True)
1572 self
._log
.debug("Creating a temp file: {} with input data: {}".
1573 format(tmp_file
.name
, data
))
1575 cmd
= "{} {}".format(path
, tmp_file
.name
)
1576 self
._log
.debug("Running the CMD: {}".format(cmd
))
1577 proc
= yield from asyncio
.create_subprocess_shell(cmd
, loop
=self
._loop
)
1578 rc
= yield from proc
.wait()
1580 self
._log
.error("The script {} for scale group {} config returned: {}".
1581 format(script
, group
.name
, rc
))
1589 def apply_scaling_group_config(self
, trigger
, group
, scale_instance
, vnfrs
=None):
1590 """ Apply the config for the scaling group based on trigger """
1591 if group
is None or scale_instance
is None:
1595 def update_config_status(success
=True, err_msg
=None):
1596 self
._log
.debug("Update %s config status to %r : %s",
1597 scale_instance
, success
, err_msg
)
1598 if (scale_instance
.config_status
== "failed"):
1599 # Do not update the config status if it is already in failed state
1602 if scale_instance
.config_status
== "configured":
1603 # Update only to failed state an already configured scale instance
1605 scale_instance
.config_status
= "failed"
1606 scale_instance
.config_err_msg
= err_msg
1607 yield from self
.update_state()
1609 # We are in configuring state
1610 # Only after post scale out mark instance as configured
1611 if trigger
== NsdYang
.ScalingTrigger
.POST_SCALE_OUT
:
1613 scale_instance
.config_status
= "configured"
1615 scale_instance
.config_status
= "failed"
1616 scale_instance
.config_err_msg
= err_msg
1617 yield from self
.update_state()
1619 config
= group
.trigger_config(trigger
)
1623 self
._log
.debug("Scaling group {} config: {}".format(group
.name
, config
))
1624 if config
.has_field("ns_config_primitive_name_ref"):
1625 config_name
= config
.ns_config_primitive_name_ref
1626 nsd_msg
= self
.nsd_msg
1627 config_primitive
= None
1628 for ns_cfg_prim
in nsd_msg
.service_primitive
:
1629 if ns_cfg_prim
.name
== config_name
:
1630 config_primitive
= ns_cfg_prim
1633 if config_primitive
is None:
1634 raise ValueError("Could not find ns_cfg_prim %s in nsr %s" % (config_name
, self
.name
))
1636 self
._log
.debug("Scaling group {} config primitive: {}".format(group
.name
, config_primitive
))
1637 if config_primitive
.has_field("user_defined_script"):
1638 rc
= yield from self
.apply_scale_group_config_script(config_primitive
.user_defined_script
,
1639 group
, scale_instance
, trigger
, vnfrs
)
1642 err_msg
= "Failed config for trigger {} using config script '{}'". \
1643 format(self
.scaling_trigger_str(trigger
),
1644 config_primitive
.user_defined_script
)
1645 yield from update_config_status(success
=rc
, err_msg
=err_msg
)
1648 err_msg
= "Failed config for trigger {} as config script is not specified". \
1649 format(self
.scaling_trigger_str(trigger
))
1650 yield from update_config_status(success
=False, err_msg
=err_msg
)
1651 raise NotImplementedError("Only script based config support for scale group for now: {}".
1654 err_msg
= "Failed config for trigger {} as config primitive is not specified".\
1655 format(self
.scaling_trigger_str(trigger
))
1656 yield from update_config_status(success
=False, err_msg
=err_msg
)
1657 self
._log
.error("Config primitive not specified for config action in scale group %s" %
1661 def create_scaling_groups(self
):
1662 """ This function creates a NSScalingGroup for every scaling
1663 group defined in he NSD"""
1665 for scaling_group_msg
in self
.nsd_msg
.scaling_group_descriptor
:
1666 self
._log
.debug("Found scaling_group %s in nsr id %s",
1667 scaling_group_msg
.name
, self
.id)
1669 group_record
= scale_group
.ScalingGroup(
1674 self
._scaling
_groups
[group_record
.name
] = group_record
1677 def create_scale_group_instance(self
, group_name
, index
, config_xact
, is_default
=False):
1678 group
= self
._scaling
_groups
[group_name
]
1679 scale_instance
= group
.create_instance(index
, is_default
)
1683 self
._log
.debug("Creating %u VNFs associated with NS id %s scaling group %s",
1684 len(self
.nsd_msg
.constituent_vnfd
), self
.id, self
)
1687 for vnf_index
, count
in group
.vnf_index_count_map
.items():
1688 const_vnfd_msg
= self
._get
_constituent
_vnfd
_msg
(vnf_index
)
1689 vnfd_msg
= self
._get
_vnfd
(const_vnfd_msg
.vnfd_id_ref
, config_xact
)
1691 cloud_account_name
, om_datacenter_name
= self
._get
_vnfd
_cloud
_account
(const_vnfd_msg
.member_vnf_index
)
1692 if cloud_account_name
is None:
1693 cloud_account_name
= self
.cloud_account_name
1694 for _
in range(count
):
1695 vnfr
= yield from self
.create_vnf_record(vnfd_msg
, const_vnfd_msg
, cloud_account_name
, om_datacenter_name
, group_name
, index
)
1696 scale_instance
.add_vnfr(vnfr
)
1702 def instantiate_instance():
1703 self
._log
.debug("Creating %s VNFRS", scale_instance
)
1704 vnfrs
= yield from create_vnfs()
1705 yield from self
.publish()
1707 self
._log
.debug("Instantiating %s VNFRS for %s", len(vnfrs
), scale_instance
)
1708 scale_instance
.operational_status
= "vnf_init_phase"
1709 yield from self
.update_state()
1712 rc
= yield from self
.apply_scaling_group_config(NsdYang
.ScalingTrigger
.PRE_SCALE_OUT
,
1713 group
, scale_instance
, vnfrs
)
1715 self
._log
.error("Pre scale out config for scale group {} ({}) failed".
1716 format(group
.name
, index
))
1717 scale_instance
.operational_status
= "failed"
1719 yield from self
.instantiate_vnfs(vnfrs
)
1721 except Exception as e
:
1722 self
._log
.exception("Failed to begin instantiatiation of vnfs for scale group {}: {}".
1723 format(group
.name
, e
))
1724 self
._log
.exception(e
)
1725 scale_instance
.operational_status
= "failed"
1727 yield from self
.update_state()
1729 yield from instantiate_instance()
1732 def delete_scale_group_instance(self
, group_name
, index
):
1733 group
= self
._scaling
_groups
[group_name
]
1734 scale_instance
= group
.get_instance(index
)
1735 if scale_instance
.is_default
:
1736 raise ScalingOperationError("Cannot terminate a default scaling group instance")
1738 scale_instance
.operational_status
= "terminate"
1739 yield from self
.update_state()
1742 def terminate_instance():
1743 self
._log
.debug("Terminating %s VNFRS" % scale_instance
)
1744 rc
= yield from self
.apply_scaling_group_config(NsdYang
.ScalingTrigger
.PRE_SCALE_IN
,
1745 group
, scale_instance
)
1747 self
._log
.error("Pre scale in config for scale group {} ({}) failed".
1748 format(group
.name
, index
))
1750 # Going ahead with terminate, even if there is an error in pre-scale-in config
1751 # as this could be result of scale out failure and we need to cleanup this group
1752 yield from self
.terminate_vnfrs(scale_instance
.vnfrs
)
1753 group
.delete_instance(index
)
1755 scale_instance
.operational_status
= "vnf_terminate_phase"
1756 yield from self
.update_state()
1758 yield from terminate_instance()
1761 def _update_scale_group_instances_status(self
):
1763 def post_scale_out_task(group
, instance
):
1764 # Apply post scale out config once all VNFRs are active
1765 rc
= yield from self
.apply_scaling_group_config(NsdYang
.ScalingTrigger
.POST_SCALE_OUT
,
1767 instance
.operational_status
= "running"
1769 self
._log
.debug("Scale out for group {} and instance {} succeeded".
1770 format(group
.name
, instance
.instance_id
))
1772 self
._log
.error("Post scale out config for scale group {} ({}) failed".
1773 format(group
.name
, instance
.instance_id
))
1775 yield from self
.update_state()
1777 group_instances
= {group
: group
.instances
for group
in self
._scaling
_groups
.values()}
1778 for group
, instances
in group_instances
.items():
1779 self
._log
.debug("Updating %s instance status", group
)
1780 for instance
in instances
:
1781 instance_vnf_state_list
= [vnfr
.state
for vnfr
in instance
.vnfrs
]
1782 self
._log
.debug("Got vnfr instance states: %s", instance_vnf_state_list
)
1783 if instance
.operational_status
== "vnf_init_phase":
1784 if all([state
== VnfRecordState
.ACTIVE
for state
in instance_vnf_state_list
]):
1785 instance
.operational_status
= "running"
1787 # Create a task for post scale out to allow us to sleep before attempting
1788 # to configure newly created VM's
1789 self
._loop
.create_task(post_scale_out_task(group
, instance
))
1791 elif any([state
== VnfRecordState
.FAILED
for state
in instance_vnf_state_list
]):
1792 self
._log
.debug("Scale out for group {} and instance {} failed".
1793 format(group
.name
, instance
.instance_id
))
1794 instance
.operational_status
= "failed"
1796 elif instance
.operational_status
== "vnf_terminate_phase":
1797 if all([state
== VnfRecordState
.TERMINATED
for state
in instance_vnf_state_list
]):
1798 instance
.operational_status
= "terminated"
1799 rc
= yield from self
.apply_scaling_group_config(NsdYang
.ScalingTrigger
.POST_SCALE_IN
,
1802 self
._log
.debug("Scale in for group {} and instance {} succeeded".
1803 format(group
.name
, instance
.instance_id
))
1805 self
._log
.error("Post scale in config for scale group {} ({}) failed".
1806 format(group
.name
, instance
.instance_id
))
1808 def create_vnffgs(self
):
1809 """ This function creates VNFFGs for every VNFFG in the NSD
1810 associated with this NSR"""
1812 for vnffgd
in self
.nsd_msg
.vnffgd
:
1813 self
._log
.debug("Found vnffgd %s in nsr id %s", vnffgd
, self
.id)
1814 vnffgr
= VnffgRecord(self
._dts
,
1817 self
._nsm
._vnffgmgr
,
1821 self
._sdn
_account
_name
1823 self
._vnffgrs
[vnffgr
.id] = vnffgr
1825 def resolve_vld_ip_profile(self
, nsd_msg
, vld
):
1826 self
._log
.debug("Receieved ip profile ref is %s",vld
.ip_profile_ref
)
1827 if not vld
.has_field('ip_profile_ref'):
1829 profile
= [profile
for profile
in nsd_msg
.ip_profiles
if profile
.name
== vld
.ip_profile_ref
]
1830 return profile
[0] if profile
else None
1833 def _create_vls(self
, vld
, cloud_account
,om_datacenter
):
1834 """Create a VLR in the cloud account specified using the given VLD
1838 cloud_account : Cloud account name
1843 vlr
= yield from VirtualLinkRecord
.create_record(
1851 self
.resolve_vld_ip_profile(self
.nsd_msg
, vld
),
1853 restart_mode
=self
.restart_mode
)
1857 def _extract_cloud_accounts_for_vl(self
, vld
):
1859 Extracts the list of cloud accounts from the NS Config obj
1862 1. Cloud accounts based connection point (vnf_cloud_account_map)
1864 vld : VLD yang object
1869 cloud_account_list
= []
1871 if self
._nsr
_cfg
_msg
.vnf_cloud_account_map
:
1872 # Handle case where cloud_account is None
1874 for vnf
in self
._nsr
_cfg
_msg
.vnf_cloud_account_map
:
1875 if vnf
.cloud_account
is not None or vnf
.om_datacenter
is not None:
1876 vnf_cloud_map
[vnf
.member_vnf_index_ref
] = (vnf
.cloud_account
,vnf
.om_datacenter
)
1878 for vnfc
in vld
.vnfd_connection_point_ref
:
1879 cloud_account
= vnf_cloud_map
.get(
1880 vnfc
.member_vnf_index_ref
,
1881 (self
.cloud_account_name
,self
.om_datacenter_name
))
1883 cloud_account_list
.append(cloud_account
)
1885 if self
._nsr
_cfg
_msg
.vl_cloud_account_map
:
1886 for vld_map
in self
._nsr
_cfg
_msg
.vl_cloud_account_map
:
1887 if vld_map
.vld_id_ref
== vld
.id:
1888 for cloud_account
in vld_map
.cloud_accounts
:
1889 cloud_account_list
.extend((cloud_account
,None))
1890 for om_datacenter
in vld_map
.om_datacenters
:
1891 cloud_account_list
.extend((None,om_datacenter
))
1893 # If no config has been provided then fall-back to the default
1895 if not cloud_account_list
:
1896 cloud_account_list
= [(self
.cloud_account_name
,self
.om_datacenter_name
)]
1898 self
._log
.debug("VL {} cloud accounts: {}".
1899 format(vld
.name
, cloud_account_list
))
1900 return set(cloud_account_list
)
1903 def create_vls(self
):
1904 """ This function creates VLs for every VLD in the NSD
1905 associated with this NSR"""
1906 for vld
in self
.nsd_msg
.vld
:
1908 self
._log
.debug("Found vld %s in nsr id %s", vld
, self
.id)
1909 cloud_account_list
= self
._extract
_cloud
_accounts
_for
_vl
(vld
)
1910 for cloud_account
,om_datacenter
in cloud_account_list
:
1911 vlr
= yield from self
._create
_vls
(vld
, cloud_account
,om_datacenter
)
1912 self
._vlrs
.append(vlr
)
1916 def create_vl_instance(self
, vld
):
1917 self
._log
.debug("Create VL for {}: {}".format(self
.id, vld
.as_dict()))
1918 # Check if the VL is already present
1920 for vl
in self
._vlrs
:
1921 if vl
.vld_msg
.id == vld
.id:
1922 self
._log
.debug("The VLD %s already in NSR %s as VLR %s with status %s",
1923 vld
.id, self
.id, vl
.id, vl
.state
)
1925 if vlr
.state
!= VlRecordState
.TERMINATED
:
1926 err_msg
= "VLR for VL %s in NSR %s already instantiated", \
1928 self
._log
.error(err_msg
)
1929 raise NsrVlUpdateError(err_msg
)
1933 cloud_account_list
= self
._extract
_cloud
_accounts
_for
_vl
(vld
)
1934 for account
,om_datacenter
in cloud_account_list
:
1935 vlr
= yield from self
._create
_vls
(vld
, account
,om_datacenter
)
1936 self
._vlrs
.append(vlr
)
1938 vlr
.state
= VlRecordState
.INSTANTIATION_PENDING
1939 yield from self
.update_state()
1942 yield from self
.nsm_plugin
.instantiate_vl(self
, vlr
)
1943 vlr
.state
= VlRecordState
.ACTIVE
1945 except Exception as e
:
1946 err_msg
= "Error instantiating VL for NSR {} and VLD {}: {}". \
1947 format(self
.id, vld
.id, e
)
1948 self
._log
.error(err_msg
)
1949 self
._log
.exception(e
)
1950 vlr
.state
= VlRecordState
.FAILED
1952 yield from self
.update_state()
1955 def delete_vl_instance(self
, vld
):
1956 for vlr
in self
._vlrs
:
1957 if vlr
.vld_msg
.id == vld
.id:
1958 self
._log
.debug("Found VLR %s for VLD %s in NSR %s",
1959 vlr
.id, vld
.id, self
.id)
1960 vlr
.state
= VlRecordState
.TERMINATE_PENDING
1961 yield from self
.update_state()
1964 yield from self
.nsm_plugin
.terminate_vl(vlr
)
1965 vlr
.state
= VlRecordState
.TERMINATED
1966 self
._vlrs
.remove(vlr
)
1968 except Exception as e
:
1969 err_msg
= "Error terminating VL for NSR {} and VLD {}: {}". \
1970 format(self
.id, vld
.id, e
)
1971 self
._log
.error(err_msg
)
1972 self
._log
.exception(e
)
1973 vlr
.state
= VlRecordState
.FAILED
1975 yield from self
.update_state()
1979 def create_vnfs(self
, config_xact
):
1981 This function creates VNFs for every VNF in the NSD
1982 associated with this NSR
1984 self
._log
.debug("Creating %u VNFs associated with this NS id %s",
1985 len(self
.nsd_msg
.constituent_vnfd
), self
.id)
1987 for const_vnfd
in self
.nsd_msg
.constituent_vnfd
:
1988 if not const_vnfd
.start_by_default
:
1989 self
._log
.debug("start_by_default set to False in constituent VNF (%s). Skipping start.",
1990 const_vnfd
.member_vnf_index
)
1993 vnfd_msg
= self
._get
_vnfd
(const_vnfd
.vnfd_id_ref
, config_xact
)
1994 cloud_account_name
,om_datacenter_name
= self
._get
_vnfd
_cloud
_account
(const_vnfd
.member_vnf_index
)
1995 if cloud_account_name
is None:
1996 cloud_account_name
= self
.cloud_account_name
1997 yield from self
.create_vnf_record(vnfd_msg
, const_vnfd
, cloud_account_name
, om_datacenter_name
)
2000 def get_placement_groups(self
, vnfd_msg
, const_vnfd
):
2001 placement_groups
= []
2002 for group
in self
.nsd_msg
.placement_groups
:
2003 for member_vnfd
in group
.member_vnfd
:
2004 if (member_vnfd
.vnfd_id_ref
== vnfd_msg
.id) and \
2005 (member_vnfd
.member_vnf_index_ref
== const_vnfd
.member_vnf_index
):
2006 group_info
= self
.resolve_placement_group_cloud_construct(group
)
2007 if group_info
is None:
2008 self
._log
.error("Could not resolve cloud-construct for placement group: %s", group
.name
)
2009 ### raise PlacementGroupError("Could not resolve cloud-construct for placement group: {}".format(group.name))
2011 self
._log
.info("Successfully resolved cloud construct for placement group: %s for VNF: %s (Member Index: %s)",
2014 const_vnfd
.member_vnf_index
)
2015 placement_groups
.append(group_info
)
2016 return placement_groups
2019 def create_vnf_record(self
, vnfd_msg
, const_vnfd
, cloud_account_name
, om_datacenter_name
, group_name
=None, group_instance_id
=None):
2020 # Fetch the VNFD associated with this VNF
2021 placement_groups
= self
.get_placement_groups(vnfd_msg
, const_vnfd
)
2022 self
._log
.info("Cloud Account for VNF %d is %s",const_vnfd
.member_vnf_index
,cloud_account_name
)
2023 self
._log
.info("Launching VNF: %s (Member Index: %s) in NSD plancement Groups: %s",
2025 const_vnfd
.member_vnf_index
,
2026 [ group
.name
for group
in placement_groups
])
2027 vnfr
= yield from VirtualNetworkFunctionRecord
.create_record(self
._dts
,
2040 restart_mode
=self
.restart_mode
,
2042 if vnfr
.id in self
._vnfrs
:
2043 err
= "VNF with VNFR id %s already in vnf list" % (vnfr
.id,)
2044 raise NetworkServiceRecordError(err
)
2046 self
._vnfrs
[vnfr
.id] = vnfr
2047 self
._nsm
.vnfrs
[vnfr
.id] = vnfr
2049 yield from vnfr
.set_config_status(NsrYang
.ConfigStates
.INIT
)
2051 self
._log
.debug("Added VNFR %s to NSM VNFR list with id %s",
2057 def create_param_pools(self
):
2058 for param_pool
in self
.nsd_msg
.parameter_pool
:
2059 self
._log
.debug("Found parameter pool %s in nsr id %s", param_pool
, self
.id)
2061 start_value
= param_pool
.range.start_value
2062 end_value
= param_pool
.range.end_value
2063 if end_value
< start_value
:
2064 raise NetworkServiceRecordError(
2065 "Parameter pool %s has invalid range (start: {}, end: {})".format(
2066 start_value
, end_value
2070 self
._param
_pools
[param_pool
.name
] = config_value_pool
.ParameterValuePool(
2073 range(start_value
, end_value
)
2077 def fetch_vnfr(self
, vnfr_path
):
2078 """ Fetch VNFR record """
2080 self
._log
.debug("Fetching VNFR with key %s while instantiating %s",
2082 res_iter
= yield from self
._dts
.query_read(vnfr_path
, rwdts
.XactFlag
.MERGE
)
2084 for ent
in res_iter
:
2085 res
= yield from ent
2091 def instantiate_vnfs(self
, vnfrs
):
2093 This function instantiates VNFs for every VNF in this Network Service
2095 self
._log
.debug("Instantiating %u VNFs in NS %s", len(vnfrs
), self
.id)
2097 self
._log
.debug("Instantiating VNF: %s in NS %s", vnf
, self
.id)
2098 yield from self
.nsm_plugin
.instantiate_vnf(self
, vnf
)
2101 def instantiate_vnffgs(self
):
2103 This function instantiates VNFFGs for every VNFFG in this Network Service
2105 self
._log
.debug("Instantiating %u VNFFGs in NS %s",
2106 len(self
.nsd_msg
.vnffgd
), self
.id)
2107 for _
, vnfr
in self
.vnfrs
.items():
2108 while vnfr
.state
in [VnfRecordState
.INSTANTIATION_PENDING
, VnfRecordState
.INIT
]:
2109 self
._log
.debug("Received vnfr state for vnfr %s is %s; retrying",vnfr
.name
,vnfr
.state
)
2110 yield from asyncio
.sleep(2, loop
=self
._loop
)
2111 if vnfr
.state
== VnfRecordState
.ACTIVE
:
2112 self
._log
.debug("Received vnfr state for vnfr %s is %s ",vnfr
.name
,vnfr
.state
)
2115 self
._log
.debug("Received vnfr state for vnfr %s is %s; failing vnffg creation",vnfr
.name
,vnfr
.state
)
2116 self
._vnffgr
_state
= VnffgRecordState
.FAILED
2119 self
._log
.info("Waiting for 90 seconds for VMs to come up")
2120 yield from asyncio
.sleep(90, loop
=self
._loop
)
2121 self
._log
.info("Starting VNFFG orchestration")
2122 for vnffg
in self
._vnffgrs
.values():
2123 self
._log
.debug("Instantiating VNFFG: %s in NS %s", vnffg
, self
.id)
2124 yield from vnffg
.instantiate()
2127 def instantiate_scaling_instances(self
, config_xact
):
2128 """ Instantiate any default scaling instances in this Network Service """
2129 for group
in self
._scaling
_groups
.values():
2130 for i
in range(group
.min_instance_count
):
2131 self
._log
.debug("Instantiating %s default scaling instance %s", group
, i
)
2132 yield from self
.create_scale_group_instance(
2133 group
.name
, i
, config_xact
, is_default
=True
2136 for group_msg
in self
._nsr
_cfg
_msg
.scaling_group
:
2137 if group_msg
.scaling_group_name_ref
!= group
.name
:
2140 for instance
in group_msg
.instance
:
2141 self
._log
.debug("Reloading %s scaling instance %s", group_msg
, instance
.id)
2142 yield from self
.create_scale_group_instance(
2143 group
.name
, instance
.id, config_xact
, is_default
=False
2146 def has_scaling_instances(self
):
2147 """ Return boolean indicating if the network service has default scaling groups """
2148 for group
in self
._scaling
_groups
.values():
2149 if group
.min_instance_count
> 0:
2152 for group_msg
in self
._nsr
_cfg
_msg
.scaling_group
:
2153 if len(group_msg
.instance
) > 0:
2160 """ This function publishes this NSR """
2161 self
._nsr
_msg
= self
.create_msg()
2163 self
._log
.debug("Publishing the NSR with xpath %s and nsr %s",
2167 if self
._debug
_running
:
2168 self
._log
.debug("Publishing NSR in RUNNING state!")
2171 with self
._dts
.transaction() as xact
:
2172 yield from self
._nsm
.nsr_handler
.update(xact
, self
.nsr_xpath
, self
._nsr
_msg
)
2173 if self
._op
_status
.state
== NetworkServiceRecordState
.RUNNING
:
2174 self
._debug
_running
= True
2177 def unpublish(self
, xact
):
2178 """ Unpublish this NSR object """
2179 self
._log
.debug("Unpublishing Network service id %s", self
.id)
2180 yield from self
._nsm
.nsr_handler
.delete(xact
, self
.nsr_xpath
)
2183 def nsr_xpath(self
):
2184 """ Returns the xpath associated with this NSR """
2186 "D,/nsr:ns-instance-opdata" +
2187 "/nsr:nsr[nsr:ns-instance-config-ref = '{}']"
2191 def xpath_from_nsr(nsr
):
2192 """ Returns the xpath associated with this NSR op data"""
2193 return (NetworkServiceRecord
.XPATH
+
2194 "[nsr:ns-instance-config-ref = '{}']").format(nsr
.id)
2197 def nsd_xpath(self
):
2198 """ Return NSD config xpath."""
2200 "C,/nsd:nsd-catalog/nsd:nsd[nsd:id = '{}']"
2201 ).format(self
.nsd_id
)
2204 def instantiate(self
, config_xact
):
2205 """"Instantiates a NetworkServiceRecord.
2207 This function instantiates a Network service
2208 which involves the following steps,
2210 * Instantiate every VL in NSD by sending create VLR request to DTS.
2211 * Instantiate every VNF in NSD by sending create VNF reuqest to DTS.
2212 * Publish the NSR details to DTS
2215 nsr: The NSR configuration request containing nsr-id and nsd
2216 config_xact: The configuration transaction which initiated the instatiation
2219 NetworkServiceRecordError if the NSR creation fails
2225 self
._log
.debug("Instantiating NS - %s xact - %s", self
, config_xact
)
2227 # Move the state to INIITALIZING
2228 self
.set_state(NetworkServiceRecordState
.INIT
)
2230 event_descr
= "Instantiation Request Received NSR Id:%s" % self
.id
2231 self
.record_event("instantiating", event_descr
)
2234 self
._nsd
= self
._nsr
_cfg
_msg
.nsd
2237 # Update ref count if nsd present in catalog
2238 self
._nsm
.get_nsd_ref(self
.nsd_id
)
2240 except NetworkServiceDescriptorError
:
2241 # This could be an NSD not in the nsd-catalog
2244 # Merge any config and initial config primitive values
2245 self
.config_store
.merge_nsd_config(self
.nsd_msg
)
2246 self
._log
.debug("Merged NSD: {}".format(self
.nsd_msg
.as_dict()))
2248 event_descr
= "Fetched NSD with descriptor id %s" % self
.nsd_id
2249 self
.record_event("nsd-fetched", event_descr
)
2251 if self
._nsd
is None:
2252 msg
= "Failed to fetch NSD with nsd-id [%s] for nsr-id %s"
2253 self
._log
.debug(msg
, self
.nsd_id
, self
.id)
2254 raise NetworkServiceRecordError(self
)
2256 self
._log
.debug("Got nsd result %s", self
._nsd
)
2258 # Substitute any input parameters
2259 self
.substitute_input_parameters(self
._nsd
, self
._nsr
_cfg
_msg
)
2262 yield from self
.create(config_xact
)
2264 # Publish the NSR to DTS
2265 yield from self
.publish()
2268 def do_instantiate():
2270 Instantiate network service
2272 self
._log
.debug("Instantiating VLs nsr id [%s] nsd id [%s]",
2273 self
.id, self
.nsd_id
)
2275 # instantiate the VLs
2276 event_descr
= ("Instantiating %s external VLs for NSR id %s" %
2277 (len(self
.nsd_msg
.vld
), self
.id))
2278 self
.record_event("begin-external-vls-instantiation", event_descr
)
2280 self
.set_state(NetworkServiceRecordState
.VL_INIT_PHASE
)
2282 yield from self
.instantiate_vls()
2284 # Publish the NSR to DTS
2285 yield from self
.publish()
2287 event_descr
= ("Finished instantiating %s external VLs for NSR id %s" %
2288 (len(self
.nsd_msg
.vld
), self
.id))
2289 self
.record_event("end-external-vls-instantiation", event_descr
)
2291 self
.set_state(NetworkServiceRecordState
.VNF_INIT_PHASE
)
2293 self
._log
.debug("Instantiating VNFs ...... nsr[%s], nsd[%s]",
2294 self
.id, self
.nsd_id
)
2296 # instantiate the VNFs
2297 event_descr
= ("Instantiating %s VNFS for NSR id %s" %
2298 (len(self
.nsd_msg
.constituent_vnfd
), self
.id))
2300 self
.record_event("begin-vnf-instantiation", event_descr
)
2302 yield from self
.instantiate_vnfs(self
._vnfrs
.values())
2304 self
._log
.debug(" Finished instantiating %d VNFs for NSR id %s",
2305 len(self
.nsd_msg
.constituent_vnfd
), self
.id)
2307 event_descr
= ("Finished instantiating %s VNFs for NSR id %s" %
2308 (len(self
.nsd_msg
.constituent_vnfd
), self
.id))
2309 self
.record_event("end-vnf-instantiation", event_descr
)
2311 if len(self
.vnffgrs
) > 0:
2312 #self.set_state(NetworkServiceRecordState.VNFFG_INIT_PHASE)
2313 event_descr
= ("Instantiating %s VNFFGS for NSR id %s" %
2314 (len(self
.nsd_msg
.vnffgd
), self
.id))
2316 self
.record_event("begin-vnffg-instantiation", event_descr
)
2318 yield from self
.instantiate_vnffgs()
2320 event_descr
= ("Finished instantiating %s VNFFGDs for NSR id %s" %
2321 (len(self
.nsd_msg
.vnffgd
), self
.id))
2322 self
.record_event("end-vnffg-instantiation", event_descr
)
2324 if self
.has_scaling_instances():
2325 event_descr
= ("Instantiating %s Scaling Groups for NSR id %s" %
2326 (len(self
._scaling
_groups
), self
.id))
2328 self
.record_event("begin-scaling-group-instantiation", event_descr
)
2329 yield from self
.instantiate_scaling_instances(config_xact
)
2330 self
.record_event("end-scaling-group-instantiation", event_descr
)
2332 # Give the plugin a chance to deploy the network service now that all
2333 # virtual links and vnfs are instantiated
2334 yield from self
.nsm_plugin
.deploy(self
._nsr
_msg
)
2336 self
._log
.debug("Publishing NSR...... nsr[%s], nsd[%s]",
2337 self
.id, self
.nsd_id
)
2339 # Publish the NSR to DTS
2340 yield from self
.publish()
2342 self
._log
.debug("Published NSR...... nsr[%s], nsd[%s]",
2343 self
.id, self
.nsd_id
)
2345 def on_instantiate_done(fut
):
2346 # If the do_instantiate fails, then publish NSR with failed result
2347 if fut
.exception() is not None:
2348 self
._log
.error("NSR instantiation failed for NSR id %s: %s", self
.id, str(fut
.exception()))
2349 self
._loop
.create_task(self
.instantiation_failed(failed_reason
=str(fut
.exception())))
2351 instantiate_task
= self
._loop
.create_task(do_instantiate())
2352 instantiate_task
.add_done_callback(on_instantiate_done
)
2355 def set_config_status(self
, status
, status_details
=None):
2356 if self
.config_status
!= status
:
2357 self
._log
.debug("Updating NSR {} status for {} to {}".
2358 format(self
.name
, self
.config_status
, status
))
2359 self
._config
_status
= status
2360 self
._config
_status
_details
= status_details
2362 if self
._config
_status
== NsrYang
.ConfigStates
.FAILED
:
2363 self
.record_event("config-failed", "NS configuration failed",
2364 evt_details
=self
._config
_status
_details
)
2366 yield from self
.publish()
2369 def is_active(self
):
2370 """ This NS is active """
2371 self
.set_state(NetworkServiceRecordState
.RUNNING
)
2375 # Publish the NSR to DTS
2376 self
._log
.debug("Network service %s is active ", self
.id)
2377 self
._is
_active
= True
2379 event_descr
= "NSR in running state for NSR id %s" % self
.id
2380 self
.record_event("ns-running", event_descr
)
2382 yield from self
.publish()
2385 def instantiation_failed(self
, failed_reason
=None):
2386 """ The NS instantiation failed"""
2387 self
._log
.error("Network service id:%s, name:%s instantiation failed",
2389 self
.set_state(NetworkServiceRecordState
.FAILED
)
2391 event_descr
= "Instantiation of NS %s failed" % self
.id
2392 self
.record_event("ns-failed", event_descr
, evt_details
=failed_reason
)
2394 # Publish the NSR to DTS
2395 yield from self
.publish()
2398 def terminate_vnfrs(self
, vnfrs
):
2399 """ Terminate VNFRS in this network service """
2400 self
._log
.debug("Terminating VNFs in network service %s", self
.id)
2402 yield from self
.nsm_plugin
.terminate_vnf(vnfr
)
2405 def terminate(self
):
2406 """ Terminate a NetworkServiceRecord."""
2407 def terminate_vnffgrs():
2408 """ Terminate VNFFGRS in this network service """
2409 self
._log
.debug("Terminating VNFFGRs in network service %s", self
.id)
2410 for vnffgr
in self
.vnffgrs
.values():
2411 yield from vnffgr
.terminate()
2413 def terminate_vlrs():
2414 """ Terminate VLRs in this netork service """
2415 self
._log
.debug("Terminating VLs in network service %s", self
.id)
2416 for vlr
in self
.vlrs
:
2417 yield from self
.nsm_plugin
.terminate_vl(vlr
)
2418 vlr
.state
= VlRecordState
.TERMINATED
2420 self
._log
.debug("Terminating network service id %s", self
.id)
2422 # Move the state to TERMINATE
2423 self
.set_state(NetworkServiceRecordState
.TERMINATE
)
2424 event_descr
= "Terminate being processed for NS Id:%s" % self
.id
2425 self
.record_event("terminate", event_descr
)
2427 # Move the state to VNF_TERMINATE_PHASE
2428 self
._log
.debug("Terminating VNFFGs in NS ID: %s", self
.id)
2429 self
.set_state(NetworkServiceRecordState
.VNFFG_TERMINATE_PHASE
)
2430 event_descr
= "Terminating VNFFGS in NS Id:%s" % self
.id
2431 self
.record_event("terminating-vnffgss", event_descr
)
2432 yield from terminate_vnffgrs()
2434 # Move the state to VNF_TERMINATE_PHASE
2435 self
.set_state(NetworkServiceRecordState
.VNF_TERMINATE_PHASE
)
2436 event_descr
= "Terminating VNFS in NS Id:%s" % self
.id
2437 self
.record_event("terminating-vnfs", event_descr
)
2438 yield from self
.terminate_vnfrs(self
.vnfrs
.values())
2440 # Move the state to VL_TERMINATE_PHASE
2441 self
.set_state(NetworkServiceRecordState
.VL_TERMINATE_PHASE
)
2442 event_descr
= "Terminating VLs in NS Id:%s" % self
.id
2443 self
.record_event("terminating-vls", event_descr
)
2444 yield from terminate_vlrs()
2446 yield from self
.nsm_plugin
.terminate_ns(self
)
2448 # Move the state to TERMINATED
2449 self
.set_state(NetworkServiceRecordState
.TERMINATED
)
2450 event_descr
= "Terminated NS Id:%s" % self
.id
2451 self
.record_event("terminated", event_descr
)
2454 """"Enable a NetworkServiceRecord."""
2458 """"Disable a NetworkServiceRecord."""
2461 def map_config_status(self
):
2462 self
._log
.debug("Config status for ns {} is {}".
2463 format(self
.name
, self
._config
_status
))
2464 if self
._config
_status
== NsrYang
.ConfigStates
.CONFIGURING
:
2465 return 'configuring'
2466 if self
._config
_status
== NsrYang
.ConfigStates
.FAILED
:
2470 def vl_phase_completed(self
):
2471 """ Are VLs created in this NS?"""
2472 return self
._vl
_phase
_completed
2474 def vnf_phase_completed(self
):
2475 """ Are VLs created in this NS?"""
2476 return self
._vnf
_phase
_completed
2478 def create_msg(self
):
2479 """ The network serice record as a message """
2480 nsr_dict
= {"ns_instance_config_ref": self
.id}
2481 nsr
= RwNsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr
.from_dict(nsr_dict
)
2482 #nsr.cloud_account = self.cloud_account_name
2483 nsr
.sdn_account
= self
._sdn
_account
_name
2484 nsr
.name_ref
= self
.name
2485 nsr
.nsd_ref
= self
.nsd_id
2486 nsr
.nsd_name_ref
= self
.nsd_msg
.name
2487 nsr
.operational_events
= self
._op
_status
.msg
2488 nsr
.operational_status
= self
._op
_status
.yang_str()
2489 nsr
.config_status
= self
.map_config_status()
2490 nsr
.config_status_details
= self
._config
_status
_details
2491 nsr
.create_time
= self
._create
_time
2492 nsr
.uptime
= int(time
.time()) - self
._create
_time
2494 for cfg_prim
in self
.nsd_msg
.service_primitive
:
2495 cfg_prim
= NsrYang
.YangData_Nsr_NsInstanceOpdata_Nsr_ServicePrimitive
.from_dict(
2497 nsr
.service_primitive
.append(cfg_prim
)
2499 for init_cfg
in self
.nsd_msg
.initial_config_primitive
:
2500 prim
= NsrYang
.NsrInitialConfigPrimitive
.from_dict(
2502 nsr
.initial_config_primitive
.append(prim
)
2504 if self
.vl_phase_completed():
2505 for vlr
in self
.vlrs
:
2506 nsr
.vlr
.append(vlr
.create_nsr_vlr_msg(self
.vnfrs
.values()))
2508 if self
.vnf_phase_completed():
2509 for vnfr_id
in self
.vnfrs
:
2510 nsr
.constituent_vnfr_ref
.append(self
.vnfrs
[vnfr_id
].const_vnfr_msg
)
2511 for vnffgr
in self
.vnffgrs
.values():
2512 nsr
.vnffgr
.append(vnffgr
.fetch_vnffgr())
2513 for scaling_group
in self
._scaling
_groups
.values():
2514 nsr
.scaling_group_record
.append(scaling_group
.create_record_msg())
2518 def all_vnfs_active(self
):
2519 """ Are all VNFS in this NS active? """
2520 for _
, vnfr
in self
.vnfrs
.items():
2521 if vnfr
.active
is not True:
2526 def update_state(self
):
2527 """ Re-evaluate this NS's state """
2528 curr_state
= self
._op
_status
.state
2530 if curr_state
== NetworkServiceRecordState
.TERMINATED
:
2531 self
._log
.debug("NS (%s) in terminated state, not updating state", self
.id)
2534 new_state
= NetworkServiceRecordState
.RUNNING
2535 self
._log
.info("Received update_state for nsr: %s, curr-state: %s",
2536 self
.id, curr_state
)
2538 # Check all the VNFRs are present
2539 for _
, vnfr
in self
.vnfrs
.items():
2540 if vnfr
.state
in [VnfRecordState
.ACTIVE
, VnfRecordState
.TERMINATED
]:
2542 elif vnfr
.state
== VnfRecordState
.FAILED
:
2543 if vnfr
._prev
_state
!= vnfr
.state
:
2544 event_descr
= "Instantiation of VNF %s failed" % vnfr
.id
2545 event_error_details
= vnfr
.state_failed_reason
2546 self
.record_event("vnf-failed", event_descr
, evt_details
=event_error_details
)
2547 vnfr
.set_state(VnfRecordState
.FAILED
)
2549 self
._log
.info("VNF state did not change, curr=%s, prev=%s",
2550 vnfr
.state
, vnfr
._prev
_state
)
2551 new_state
= NetworkServiceRecordState
.FAILED
2554 self
._log
.info("VNF %s in NSR %s is still not active; current state is: %s",
2555 vnfr
.id, self
.id, vnfr
.state
)
2556 new_state
= curr_state
2558 # If new state is RUNNING; check all VLs
2559 if new_state
== NetworkServiceRecordState
.RUNNING
:
2560 for vl
in self
.vlrs
:
2562 if vl
.state
in [VlRecordState
.ACTIVE
, VlRecordState
.TERMINATED
]:
2564 elif vl
.state
== VlRecordState
.FAILED
:
2565 if vl
.prev_state
!= vl
.state
:
2566 event_descr
= "Instantiation of VL %s failed" % vl
.id
2567 event_error_details
= vl
.state_failed_reason
2568 self
.record_event("vl-failed", event_descr
, evt_details
=event_error_details
)
2569 vl
.prev_state
= vl
.state
2571 self
._log
.debug("VL %s already in failed state")
2573 if vl
.state
in [VlRecordState
.INSTANTIATION_PENDING
, VlRecordState
.INIT
]:
2574 new_state
= NetworkServiceRecordState
.VL_INSTANTIATE
2577 if vl
.state
in [VlRecordState
.TERMINATE_PENDING
]:
2578 new_state
= NetworkServiceRecordState
.VL_TERMINATE
2581 # If new state is RUNNING; check VNFFGRs are also active
2582 if new_state
== NetworkServiceRecordState
.RUNNING
:
2583 for _
, vnffgr
in self
.vnffgrs
.items():
2584 self
._log
.info("Checking vnffgr state for nsr %s is: %s",
2585 self
.id, vnffgr
.state
)
2586 if vnffgr
.state
== VnffgRecordState
.ACTIVE
:
2588 elif vnffgr
.state
== VnffgRecordState
.FAILED
:
2589 event_descr
= "Instantiation of VNFFGR %s failed" % vnffgr
.id
2590 self
.record_event("vnffg-failed", event_descr
)
2591 new_state
= NetworkServiceRecordState
.FAILED
2594 self
._log
.info("VNFFGR %s in NSR %s is still not active; current state is: %s",
2595 vnffgr
.id, self
.id, vnffgr
.state
)
2596 new_state
= curr_state
2598 # Update all the scaling group instance operational status to
2599 # reflect the state of all VNFR within that instance
2600 yield from self
._update
_scale
_group
_instances
_status
()
2602 for _
, group
in self
._scaling
_groups
.items():
2603 if group
.state
== scale_group
.ScaleGroupState
.SCALING_OUT
:
2604 new_state
= NetworkServiceRecordState
.SCALING_OUT
2606 elif group
.state
== scale_group
.ScaleGroupState
.SCALING_IN
:
2607 new_state
= NetworkServiceRecordState
.SCALING_IN
2610 if new_state
!= curr_state
:
2611 self
._log
.debug("Changing state of Network service %s from %s to %s",
2612 self
.id, curr_state
, new_state
)
2613 if new_state
== NetworkServiceRecordState
.RUNNING
:
2614 yield from self
.is_active()
2615 elif new_state
== NetworkServiceRecordState
.FAILED
:
2616 # If the NS is already active and we entered scaling_in, scaling_out,
2617 # do not mark the NS as failing if scaling operation failed.
2618 if curr_state
in [NetworkServiceRecordState
.SCALING_OUT
,
2619 NetworkServiceRecordState
.SCALING_IN
] and self
._is
_active
:
2620 new_state
= NetworkServiceRecordState
.RUNNING
2621 self
.set_state(new_state
)
2623 yield from self
.instantiation_failed()
2625 self
.set_state(new_state
)
2627 yield from self
.publish()
2630 class InputParameterSubstitution(object):
2632 This class is responsible for substituting input parameters into an NSD.
2635 def __init__(self
, log
):
2636 """Create an instance of InputParameterSubstitution
2639 log - a logger for this object to use
2644 def __call__(self
, nsd
, nsr_config
):
2645 """Substitutes input parameters from the NSR config into the NSD
2647 This call modifies the provided NSD with the input parameters that are
2648 contained in the NSR config.
2651 nsd - a GI NSD object
2652 nsr_config - a GI NSR config object
2655 if nsd
is None or nsr_config
is None:
2658 # Create a lookup of the xpath elements that this descriptor allows
2660 optional_input_parameters
= set()
2661 for input_parameter
in nsd
.input_parameter_xpath
:
2662 optional_input_parameters
.add(input_parameter
.xpath
)
2664 # Apply the input parameters to the descriptor
2665 if nsr_config
.input_parameter
:
2666 for param
in nsr_config
.input_parameter
:
2667 if param
.xpath
not in optional_input_parameters
:
2668 msg
= "tried to set an invalid input parameter ({})"
2669 self
.log
.error(msg
.format(param
.xpath
))
2673 "input-parameter:{} = {}".format(
2680 xpath
.setxattr(nsd
, param
.xpath
, param
.value
)
2682 except Exception as e
:
2683 self
.log
.exception(e
)
2686 class NetworkServiceDescriptor(object):
2688 Network service descriptor class
2691 def __init__(self
, dts
, log
, loop
, nsd
, nsm
):
2703 """ Returns nsd id """
2708 """ Returns name of nsd """
2709 return self
._nsd
.name
2712 def ref_count(self
):
2713 """ Returns reference count"""
2714 return self
._ref
_count
2717 """ Returns whether nsd is in use or not """
2718 return True if self
.ref_count
> 0 else False
2721 """ Take a reference on this object """
2722 self
._ref
_count
+= 1
2725 """ Release reference on this object """
2726 if self
.ref_count
< 1:
2727 msg
= ("Unref on a NSD object - nsd id %s, ref_count = %s" %
2728 (self
.id, self
.ref_count
))
2729 self
._log
.critical(msg
)
2730 raise NetworkServiceDescriptorError(msg
)
2731 self
._ref
_count
-= 1
2735 """ Return the message associated with this NetworkServiceDescriptor"""
2739 def path_for_id(nsd_id
):
2740 """ Return path for the passed nsd_id"""
2741 return "C,/nsd:nsd-catalog/nsd:nsd[nsd:id = '{}'".format(nsd_id
)
2744 """ Return the message associated with this NetworkServiceDescriptor"""
2745 return NetworkServiceDescriptor
.path_for_id(self
.id)
2747 def update(self
, nsd
):
2748 """ Update the NSD descriptor """
2752 class NsdDtsHandler(object):
2753 """ The network service descriptor DTS handler """
2754 XPATH
= "C,/nsd:nsd-catalog/nsd:nsd"
2756 def __init__(self
, dts
, log
, loop
, nsm
):
2766 """ Return registration handle """
2771 """ Register for Nsd create/update/delete/read requests from dts """
2773 def on_apply(dts
, acg
, xact
, action
, scratch
):
2774 """Apply the configuration"""
2775 is_recovery
= xact
.xact
is None and action
== rwdts
.AppconfAction
.INSTALL
2776 self
._log
.debug("Got nsd apply cfg (xact:%s) (action:%s)",
2778 # Create/Update an NSD record
2779 for cfg
in self
._regh
.get_xact_elements(xact
):
2780 # Only interested in those NSD cfgs whose ID was received in prepare callback
2781 if cfg
.id in scratch
.get('nsds', []) or is_recovery
:
2782 self
._nsm
.update_nsd(cfg
)
2784 scratch
.pop('nsds', None)
2786 return RwTypes
.RwStatus
.SUCCESS
2789 def delete_nsd_libs(nsd_id
):
2790 """ Remove any files uploaded with NSD and stored under $RIFT_ARTIFACTS/libs/<id> """
2792 rift_artifacts_dir
= os
.environ
['RIFT_ARTIFACTS']
2793 nsd_dir
= os
.path
.join(rift_artifacts_dir
, 'launchpad/libs', nsd_id
)
2795 if os
.path
.exists (nsd_dir
):
2796 shutil
.rmtree(nsd_dir
, ignore_errors
=True)
2797 except Exception as e
:
2798 self
._log
.error("Exception in cleaning up NSD libs {}: {}".
2800 self
._log
.excpetion(e
)
2803 def on_prepare(dts
, acg
, xact
, xact_info
, ks_path
, msg
, scratch
):
2804 """ Prepare callback from DTS for NSD config """
2806 self
._log
.info("Got nsd prepare - config received nsd id %s, msg %s",
2809 fref
= ProtobufC
.FieldReference
.alloc()
2810 fref
.goto_whole_message(msg
.to_pbcm())
2812 if fref
.is_field_deleted():
2813 # Delete an NSD record
2814 self
._log
.debug("Deleting NSD with id %s", msg
.id)
2815 if self
._nsm
.nsd_in_use(msg
.id):
2816 self
._log
.debug("Cannot delete NSD in use - %s", msg
.id)
2817 err
= "Cannot delete an NSD in use - %s" % msg
.id
2818 raise NetworkServiceDescriptorRefCountExists(err
)
2820 yield from delete_nsd_libs(msg
.id)
2821 self
._nsm
.delete_nsd(msg
.id)
2823 # Add this NSD to scratch to create/update in apply callback
2824 nsds
= scratch
.setdefault('nsds', [])
2826 # acg._scratch['nsds'].append(msg.id)
2828 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
)
2831 "Registering for NSD config using xpath: %s",
2832 NsdDtsHandler
.XPATH
,
2835 acg_hdl
= rift
.tasklets
.AppConfGroup
.Handler(on_apply
=on_apply
)
2836 with self
._dts
.appconf_group_create(handler
=acg_hdl
) as acg
:
2837 # Need a list in scratch to store NSDs to create/update later
2838 # acg._scratch['nsds'] = list()
2839 self
._regh
= acg
.register(
2840 xpath
=NsdDtsHandler
.XPATH
,
2841 flags
=rwdts
.Flag
.SUBSCRIBER | rwdts
.Flag
.DELTA_READY | rwdts
.Flag
.CACHE
,
2842 on_prepare
=on_prepare
)
2845 class VnfdDtsHandler(object):
2846 """ DTS handler for VNFD config changes """
2847 XPATH
= "C,/vnfd:vnfd-catalog/vnfd:vnfd"
2849 def __init__(self
, dts
, log
, loop
, nsm
):
2858 """ DTS registration handle """
2863 """ Register for VNFD configuration"""
2866 def on_apply(dts
, acg
, xact
, action
, scratch
):
2867 """Apply the configuration"""
2868 self
._log
.debug("Got NSM VNFD apply (xact: %s) (action: %s)(scr: %s)",
2869 xact
, action
, scratch
)
2871 # Create/Update a VNFD record
2872 for cfg
in self
._regh
.get_xact_elements(xact
):
2873 # Only interested in those VNFD cfgs whose ID was received in prepare callback
2874 if cfg
.id in scratch
.get('vnfds', []):
2875 self
._nsm
.update_vnfd(cfg
)
2877 for cfg
in self
._regh
.elements
:
2878 if cfg
.id in scratch
.get('deleted_vnfds', []):
2879 yield from self
._nsm
.delete_vnfd(cfg
.id)
2881 scratch
.pop('vnfds', None)
2882 scratch
.pop('deleted_vnfds', None)
2885 def on_prepare(dts
, acg
, xact
, xact_info
, ks_path
, msg
, scratch
):
2886 """ on prepare callback """
2887 self
._log
.debug("Got on prepare for VNFD (path: %s) (action: %s) (msg: %s)",
2888 ks_path
.to_xpath(RwNsmYang
.get_schema()), xact_info
.query_action
, msg
)
2890 fref
= ProtobufC
.FieldReference
.alloc()
2891 fref
.goto_whole_message(msg
.to_pbcm())
2893 # Handle deletes in prepare_callback, but adds/updates in apply_callback
2894 if fref
.is_field_deleted():
2895 self
._log
.debug("Adding msg to deleted field")
2896 deleted_vnfds
= scratch
.setdefault('deleted_vnfds', [])
2897 deleted_vnfds
.append(msg
.id)
2899 # Add this VNFD to scratch to create/update in apply callback
2900 vnfds
= scratch
.setdefault('vnfds', [])
2901 vnfds
.append(msg
.id)
2903 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
)
2906 "Registering for VNFD config using xpath: %s",
2907 VnfdDtsHandler
.XPATH
,
2909 acg_hdl
= rift
.tasklets
.AppConfGroup
.Handler(on_apply
=on_apply
)
2910 with self
._dts
.appconf_group_create(handler
=acg_hdl
) as acg
:
2911 # Need a list in scratch to store VNFDs to create/update later
2912 # acg._scratch['vnfds'] = list()
2913 # acg._scratch['deleted_vnfds'] = list()
2914 self
._regh
= acg
.register(
2915 xpath
=VnfdDtsHandler
.XPATH
,
2916 flags
=rwdts
.Flag
.SUBSCRIBER | rwdts
.Flag
.DELTA_READY
,
2917 on_prepare
=on_prepare
)
2919 class NsrRpcDtsHandler(object):
2920 """ The network service instantiation RPC DTS handler """
2921 EXEC_NSR_CONF_XPATH
= "I,/nsr:start-network-service"
2922 EXEC_NSR_CONF_O_XPATH
= "O,/nsr:start-network-service"
2923 NETCONF_IP_ADDRESS
= "127.0.0.1"
2925 RESTCONF_PORT
= 8888
2926 NETCONF_USER
= "admin"
2927 NETCONF_PW
= "admin"
2928 REST_BASE_V2_URL
= 'https://{}:{}/v2/api/'.format("127.0.0.1",8888)
2930 def __init__(self
, dts
, log
, loop
, nsm
):
2937 self
._ns
_regh
= None
2939 self
._manager
= None
2940 self
._nsr
_config
_url
= NsrRpcDtsHandler
.REST_BASE_V2_URL
+ 'config/ns-instance-config'
2942 self
._model
= RwYang
.Model
.create_libncx()
2943 self
._model
.load_schema_ypbc(RwNsrYang
.get_schema())
2947 """ Return the NS manager instance """
2951 def wrap_netconf_config_xml(xml
):
2952 xml
= '<config xmlns:xc="urn:ietf:params:xml:ns:netconf:base:1.0">{}</config>'.format(xml
)
2956 def _connect(self
, timeout_secs
=240):
2958 start_time
= time
.time()
2959 while (time
.time() - start_time
) < timeout_secs
:
2962 self
._log
.debug("Attemping NsmTasklet netconf connection.")
2964 manager
= yield from ncclient
.asyncio_manager
.asyncio_connect(
2966 host
=NsrRpcDtsHandler
.NETCONF_IP_ADDRESS
,
2967 port
=NsrRpcDtsHandler
.NETCONF_PORT
,
2968 username
=NsrRpcDtsHandler
.NETCONF_USER
,
2969 password
=NsrRpcDtsHandler
.NETCONF_PW
,
2971 look_for_keys
=False,
2972 hostkey_verify
=False,
2977 except ncclient
.transport
.errors
.SSHError
as e
:
2978 self
._log
.warning("Netconf connection to launchpad %s failed: %s",
2979 NsrRpcDtsHandler
.NETCONF_IP_ADDRESS
, str(e
))
2981 yield from asyncio
.sleep(5, loop
=self
._loop
)
2983 raise NsrInstantiationFailed("Failed to connect to Launchpad within %s seconds" %
2986 def _apply_ns_instance_config(self
,payload_dict
):
2987 #self._log.debug("At apply NS instance config with payload %s",payload_dict)
2988 req_hdr
= {'accept':'application/vnd.yang.data+json','content-type':'application/vnd.yang.data+json'}
2989 response
=requests
.post(self
._nsr
_config
_url
, headers
=req_hdr
, auth
=('admin', 'admin'),data
=payload_dict
,verify
=False)
2994 """ Register for NS monitoring read from dts """
2996 def on_ns_config_prepare(xact_info
, action
, ks_path
, msg
):
2997 """ prepare callback from dts start-network-service"""
2998 assert action
== rwdts
.QueryAction
.RPC
3000 rpc_op
= NsrYang
.YangOutput_Nsr_StartNetworkService
.from_dict({
3001 "nsr_id":str(uuid
.uuid4())
3004 if not ('name' in rpc_ip
and 'nsd_ref' in rpc_ip
and ('cloud_account' in rpc_ip
or 'om_datacenter' in rpc_ip
)):
3005 self
._log
.error("Mandatory parameters name or nsd_ref or cloud account not found in start-network-service {}".format(rpc_ip
))
3008 self
._log
.debug("start-network-service RPC input: {}".format(rpc_ip
))
3011 # Add used value to the pool
3012 self
._log
.debug("RPC output: {}".format(rpc_op
))
3014 nsd_copy
= self
.nsm
.get_nsd(rpc_ip
.nsd_ref
)
3016 #if not self._manager:
3017 # self._manager = yield from self._connect()
3019 self
._log
.debug("Configuring ns-instance-config with name %s nsd-ref: %s",
3020 rpc_ip
.name
, rpc_ip
.nsd_ref
)
3022 ns_instance_config_dict
= {"id":rpc_op
.nsr_id
, "admin_status":"ENABLED"}
3023 ns_instance_config_copy_dict
= {k
:v
for k
, v
in rpc_ip
.as_dict().items()
3024 if k
in RwNsrYang
.YangData_Nsr_NsInstanceConfig_Nsr().fields
}
3025 ns_instance_config_dict
.update(ns_instance_config_copy_dict
)
3027 ns_instance_config
= RwNsrYang
.YangData_Nsr_NsInstanceConfig_Nsr
.from_dict(ns_instance_config_dict
)
3028 ns_instance_config
.nsd
= NsrYang
.YangData_Nsr_NsInstanceConfig_Nsr_Nsd()
3029 ns_instance_config
.nsd
.from_dict(nsd_copy
.msg
.as_dict())
3031 payload_dict
= ns_instance_config
.to_json(self
._model
)
3032 #xml = ns_instance_config.to_xml_v2(self._model)
3033 #netconf_xml = self.wrap_netconf_config_xml(xml)
3035 #self._log.debug("Sending configure ns-instance-config xml to %s: %s",
3036 # netconf_xml, NsrRpcDtsHandler.NETCONF_IP_ADDRESS)
3037 self
._log
.debug("Sending configure ns-instance-config json to %s: %s",
3038 self
._nsr
_config
_url
,ns_instance_config
)
3040 #response = yield from self._manager.edit_config(
3042 # config=netconf_xml,
3044 response
= yield from self
._loop
.run_in_executor(
3046 self
._apply
_ns
_instance
_config
,
3049 response
.raise_for_status()
3050 self
._log
.debug("Received edit config response: %s", response
.json())
3052 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
,
3053 NsrRpcDtsHandler
.EXEC_NSR_CONF_O_XPATH
,
3055 except Exception as e
:
3056 self
._log
.error("Exception processing the "
3057 "start-network-service: {}".format(e
))
3058 self
._log
.exception(e
)
3059 xact_info
.respond_xpath(rwdts
.XactRspCode
.NACK
,
3060 NsrRpcDtsHandler
.EXEC_NSR_CONF_O_XPATH
)
3063 hdl_ns
= rift
.tasklets
.DTS
.RegistrationHandler(on_prepare
=on_ns_config_prepare
,)
3065 with self
._dts
.group_create() as group
:
3066 self
._ns
_regh
= group
.register(xpath
=NsrRpcDtsHandler
.EXEC_NSR_CONF_XPATH
,
3068 flags
=rwdts
.Flag
.PUBLISHER
,
3072 class NsrDtsHandler(object):
3073 """ The network service DTS handler """
3074 NSR_XPATH
= "C,/nsr:ns-instance-config/nsr:nsr"
3075 SCALE_INSTANCE_XPATH
= "C,/nsr:ns-instance-config/nsr:nsr/nsr:scaling-group/nsr:instance"
3076 KEY_PAIR_XPATH
= "C,/nsr:key-pair"
3078 def __init__(self
, dts
, log
, loop
, nsm
):
3084 self
._nsr
_regh
= None
3085 self
._scale
_regh
= None
3086 self
._key
_pair
_regh
= None
3090 """ Return the NS manager instance """
3095 """ Register for Nsr create/update/delete/read requests from dts """
3097 def nsr_id_from_keyspec(ks
):
3098 nsr_path_entry
= NsrYang
.YangData_Nsr_NsInstanceConfig_Nsr
.schema().keyspec_to_entry(ks
)
3099 nsr_id
= nsr_path_entry
.key00
.id
3102 def group_name_from_keyspec(ks
):
3103 group_path_entry
= NsrYang
.YangData_Nsr_NsInstanceConfig_Nsr_ScalingGroup
.schema().keyspec_to_entry(ks
)
3104 group_name
= group_path_entry
.key00
.scaling_group_name_ref
3107 def is_instance_in_reg_elements(nsr_id
, group_name
, instance_id
):
3108 """ Return boolean indicating if scaling group instance was already commited previously.
3110 By looking at the existing elements in this registration handle (elements not part
3111 of this current xact), we can tell if the instance was configured previously without
3112 keeping any application state.
3114 for instance_cfg
, keyspec
in self
._nsr
_regh
.get_xact_elements(include_keyspec
=True):
3115 elem_nsr_id
= nsr_id_from_keyspec(keyspec
)
3116 elem_group_name
= group_name_from_keyspec(keyspec
)
3118 if elem_nsr_id
!= nsr_id
or group_name
!= elem_group_name
:
3121 if instance_cfg
.id == instance_id
:
3126 def get_scale_group_instance_delta(nsr_id
, group_name
, xact
):
3127 delta
= {"added": [], "deleted": []}
3128 for instance_cfg
, keyspec
in self
._scale
_regh
.get_xact_elements(xact
, include_keyspec
=True):
3129 elem_nsr_id
= nsr_id_from_keyspec(keyspec
)
3130 if elem_nsr_id
!= nsr_id
:
3133 elem_group_name
= group_name_from_keyspec(keyspec
)
3134 if elem_group_name
!= group_name
:
3137 delta
["added"].append(instance_cfg
.id)
3139 for instance_cfg
, keyspec
in self
._scale
_regh
.get_xact_elements(include_keyspec
=True):
3140 elem_nsr_id
= nsr_id_from_keyspec(keyspec
)
3141 if elem_nsr_id
!= nsr_id
:
3144 elem_group_name
= group_name_from_keyspec(keyspec
)
3145 if elem_group_name
!= group_name
:
3148 if instance_cfg
.id in delta
["added"]:
3149 delta
["added"].remove(instance_cfg
.id)
3151 delta
["deleted"].append(instance_cfg
.id)
3156 def update_nsr_nsd(nsr_id
, xact
, scratch
):
3159 def get_nsr_vl_delta(nsr_id
, xact
, scratch
):
3160 delta
= {"added": [], "deleted": []}
3161 for instance_cfg
, keyspec
in self
._nsr
_regh
.get_xact_elements(xact
, include_keyspec
=True):
3162 elem_nsr_id
= nsr_id_from_keyspec(keyspec
)
3163 if elem_nsr_id
!= nsr_id
:
3166 if 'vld' in instance_cfg
.nsd
:
3167 for vld
in instance_cfg
.nsd
.vld
:
3168 delta
["added"].append(vld
)
3170 for instance_cfg
, keyspec
in self
._nsr
_regh
.get_xact_elements(include_keyspec
=True):
3171 self
._log
.debug("NSR update: %s", instance_cfg
)
3172 elem_nsr_id
= nsr_id_from_keyspec(keyspec
)
3173 if elem_nsr_id
!= nsr_id
:
3176 if 'vld' in instance_cfg
.nsd
:
3177 for vld
in instance_cfg
.nsd
.vld
:
3178 if vld
in delta
["added"]:
3179 delta
["added"].remove(vld
)
3181 delta
["deleted"].append(vld
)
3185 vl_delta
= yield from get_nsr_vl_delta(nsr_id
, xact
, scratch
)
3186 self
._log
.debug("Got NSR:%s VL instance delta: %s", nsr_id
, vl_delta
)
3188 for vld
in vl_delta
["added"]:
3189 yield from self
._nsm
.nsr_instantiate_vl(nsr_id
, vld
)
3191 for vld
in vl_delta
["deleted"]:
3192 yield from self
._nsm
.nsr_terminate_vl(nsr_id
, vld
)
3194 def get_add_delete_update_cfgs(dts_member_reg
, xact
, key_name
, scratch
):
3195 # Unfortunately, it is currently difficult to figure out what has exactly
3196 # changed in this xact without Pbdelta support (RIFT-4916)
3197 # As a workaround, we can fetch the pre and post xact elements and
3198 # perform a comparison to figure out adds/deletes/updates
3199 xact_cfgs
= list(dts_member_reg
.get_xact_elements(xact
))
3200 curr_cfgs
= list(dts_member_reg
.elements
)
3202 xact_key_map
= {getattr(cfg
, key_name
): cfg
for cfg
in xact_cfgs
}
3203 curr_key_map
= {getattr(cfg
, key_name
): cfg
for cfg
in curr_cfgs
}
3206 added_keys
= set(xact_key_map
) - set(curr_key_map
)
3207 added_cfgs
= [xact_key_map
[key
] for key
in added_keys
]
3210 deleted_keys
= set(curr_key_map
) - set(xact_key_map
)
3211 deleted_cfgs
= [curr_key_map
[key
] for key
in deleted_keys
]
3214 updated_keys
= set(curr_key_map
) & set(xact_key_map
)
3215 updated_cfgs
= [xact_key_map
[key
] for key
in updated_keys
3216 if xact_key_map
[key
] != curr_key_map
[key
]]
3218 return added_cfgs
, deleted_cfgs
, updated_cfgs
3220 def get_nsr_key_pairs(dts_member_reg
, xact
):
3222 for instance_cfg
, keyspec
in dts_member_reg
.get_xact_elements(xact
, include_keyspec
=True):
3223 self
._log
.debug("Key pair received is {} KS: {}".format(instance_cfg
, keyspec
))
3224 xpath
= keyspec
.to_xpath(RwNsrYang
.get_schema())
3225 key_pairs
[instance_cfg
.name
] = instance_cfg
3228 def on_apply(dts
, acg
, xact
, action
, scratch
):
3229 """Apply the configuration"""
3230 self
._log
.debug("Got nsr apply (xact: %s) (action: %s)(scr: %s)",
3231 xact
, action
, scratch
)
3233 def handle_create_nsr(msg
, key_pairs
=None, restart_mode
=False):
3234 # Handle create nsr requests """
3235 # Do some validations
3236 if not msg
.has_field("nsd"):
3237 err
= "NSD not provided"
3238 self
._log
.error(err
)
3239 raise NetworkServiceRecordError(err
)
3241 self
._log
.debug("Creating NetworkServiceRecord %s from nsr config %s",
3242 msg
.id, msg
.as_dict())
3243 nsr
= self
.nsm
.create_nsr(msg
, key_pairs
=key_pairs
, restart_mode
=restart_mode
)
3246 def handle_delete_nsr(msg
):
3248 def delete_instantiation(ns_id
):
3249 """ Delete instantiation """
3250 with self
._dts
.transaction() as xact
:
3251 yield from self
._nsm
.terminate_ns(ns_id
, xact
)
3253 # Handle delete NSR requests
3254 self
._log
.info("Delete req for NSR Id: %s received", msg
.id)
3255 # Terminate the NSR instance
3256 nsr
= self
._nsm
.get_ns_by_nsr_id(msg
.id)
3258 nsr
.set_state(NetworkServiceRecordState
.TERMINATE_RCVD
)
3259 event_descr
= "Terminate rcvd for NS Id:%s" % msg
.id
3260 nsr
.record_event("terminate-rcvd", event_descr
)
3262 self
._loop
.create_task(delete_instantiation(msg
.id))
3265 def begin_instantiation(nsr
):
3266 # Begin instantiation
3267 self
._log
.info("Beginning NS instantiation: %s", nsr
.id)
3268 yield from self
._nsm
.instantiate_ns(nsr
.id, xact
)
3270 self
._log
.debug("Got nsr apply (xact: %s) (action: %s)(scr: %s)",
3271 xact
, action
, scratch
)
3273 if action
== rwdts
.AppconfAction
.INSTALL
and xact
.id is None:
3275 for element
in self
._key
_pair
_regh
.elements
:
3276 key_pairs
.append(element
)
3277 for element
in self
._nsr
_regh
.elements
:
3278 nsr
= handle_create_nsr(element
, key_pairs
, restart_mode
=True)
3279 self
._loop
.create_task(begin_instantiation(nsr
))
3282 (added_msgs
, deleted_msgs
, updated_msgs
) = get_add_delete_update_cfgs(self
._nsr
_regh
,
3286 self
._log
.debug("Added: %s, Deleted: %s, Updated: %s", added_msgs
,
3287 deleted_msgs
, updated_msgs
)
3289 for msg
in added_msgs
:
3290 if msg
.id not in self
._nsm
.nsrs
:
3291 self
._log
.info("Create NSR received in on_apply to instantiate NS:%s", msg
.id)
3292 key_pairs
= get_nsr_key_pairs(self
._key
_pair
_regh
, xact
)
3293 nsr
= handle_create_nsr(msg
,key_pairs
)
3294 self
._loop
.create_task(begin_instantiation(nsr
))
3296 for msg
in deleted_msgs
:
3297 self
._log
.info("Delete NSR received in on_apply to terminate NS:%s", msg
.id)
3299 handle_delete_nsr(msg
)
3301 self
._log
.exception("Failed to terminate NS:%s", msg
.id)
3303 for msg
in updated_msgs
:
3304 self
._log
.info("Update NSR received in on_apply: %s", msg
)
3306 self
._nsm
.nsr_update_cfg(msg
.id, msg
)
3309 self
._loop
.create_task(update_nsr_nsd(msg
.id, xact
, scratch
))
3311 for group
in msg
.scaling_group
:
3312 instance_delta
= get_scale_group_instance_delta(msg
.id, group
.scaling_group_name_ref
, xact
)
3313 self
._log
.debug("Got NSR:%s scale group instance delta: %s", msg
.id, instance_delta
)
3315 for instance_id
in instance_delta
["added"]:
3316 self
._nsm
.scale_nsr_out(msg
.id, group
.scaling_group_name_ref
, instance_id
, xact
)
3318 for instance_id
in instance_delta
["deleted"]:
3319 self
._nsm
.scale_nsr_in(msg
.id, group
.scaling_group_name_ref
, instance_id
)
3322 return RwTypes
.RwStatus
.SUCCESS
3325 def on_prepare(dts
, acg
, xact
, xact_info
, ks_path
, msg
, scratch
):
3326 """ Prepare calllback from DTS for NSR """
3328 xpath
= ks_path
.to_xpath(RwNsrYang
.get_schema())
3329 action
= xact_info
.query_action
3331 "Got Nsr prepare callback (xact: %s) (action: %s) (info: %s), %s:%s)",
3332 xact
, action
, xact_info
, xpath
, msg
3336 def delete_instantiation(ns_id
):
3337 """ Delete instantiation """
3338 yield from self
._nsm
.terminate_ns(ns_id
, None)
3340 def handle_delete_nsr():
3341 """ Handle delete NSR requests """
3342 self
._log
.info("Delete req for NSR Id: %s received", msg
.id)
3343 # Terminate the NSR instance
3344 nsr
= self
._nsm
.get_ns_by_nsr_id(msg
.id)
3346 nsr
.set_state(NetworkServiceRecordState
.TERMINATE_RCVD
)
3347 event_descr
= "Terminate rcvd for NS Id:%s" % msg
.id
3348 nsr
.record_event("terminate-rcvd", event_descr
)
3350 self
._loop
.create_task(delete_instantiation(msg
.id))
3352 fref
= ProtobufC
.FieldReference
.alloc()
3353 fref
.goto_whole_message(msg
.to_pbcm())
3355 if action
in [rwdts
.QueryAction
.CREATE
, rwdts
.QueryAction
.UPDATE
, rwdts
.QueryAction
.DELETE
]:
3356 # if this is an NSR create
3357 if action
!= rwdts
.QueryAction
.DELETE
and msg
.id not in self
._nsm
.nsrs
:
3358 # Ensure the Cloud account/datacenter has been specified
3359 if not msg
.has_field("cloud_account") and not msg
.has_field("om_datacenter"):
3360 raise NsrInstantiationFailed("Cloud account or datacenter not specified in NSR")
3362 # Check if nsd is specified
3363 if not msg
.has_field("nsd"):
3364 raise NsrInstantiationFailed("NSD not specified in NSR")
3367 nsr
= self
._nsm
.nsrs
[msg
.id]
3369 if msg
.has_field("nsd"):
3370 if nsr
.state
!= NetworkServiceRecordState
.RUNNING
:
3371 raise NsrVlUpdateError("Unable to update VL when NSR not in running state")
3372 if 'vld' not in msg
.nsd
or len(msg
.nsd
.vld
) == 0:
3373 raise NsrVlUpdateError("NS config NSD should have atleast 1 VLD defined")
3375 if msg
.has_field("scaling_group"):
3376 if nsr
.state
!= NetworkServiceRecordState
.RUNNING
:
3377 raise ScalingOperationError("Unable to perform scaling action when NS is not in running state")
3379 if len(msg
.scaling_group
) > 1:
3380 raise ScalingOperationError("Only a single scaling group can be configured at a time")
3382 for group_msg
in msg
.scaling_group
:
3383 num_new_group_instances
= len(group_msg
.instance
)
3384 if num_new_group_instances
> 1:
3385 raise ScalingOperationError("Only a single scaling instance can be modified at a time")
3387 elif num_new_group_instances
== 1:
3388 scale_group
= nsr
.scaling_groups
[group_msg
.scaling_group_name_ref
]
3389 if action
in [rwdts
.QueryAction
.CREATE
, rwdts
.QueryAction
.UPDATE
]:
3390 if len(scale_group
.instances
) == scale_group
.max_instance_count
:
3391 raise ScalingOperationError("Max instances for %s reached" % scale_group
)
3393 acg
.handle
.prepare_complete_ok(xact_info
.handle
)
3396 self
._log
.debug("Registering for NSR config using xpath: %s",
3397 NsrDtsHandler
.NSR_XPATH
)
3399 acg_hdl
= rift
.tasklets
.AppConfGroup
.Handler(on_apply
=on_apply
)
3400 with self
._dts
.appconf_group_create(handler
=acg_hdl
) as acg
:
3401 self
._nsr
_regh
= acg
.register(xpath
=NsrDtsHandler
.NSR_XPATH
,
3402 flags
=rwdts
.Flag
.SUBSCRIBER | rwdts
.Flag
.DELTA_READY | rwdts
.Flag
.CACHE
,
3403 on_prepare
=on_prepare
)
3405 self
._scale
_regh
= acg
.register(
3406 xpath
=NsrDtsHandler
.SCALE_INSTANCE_XPATH
,
3407 flags
=rwdts
.Flag
.SUBSCRIBER | rwdts
.Flag
.DELTA_READY| rwdts
.Flag
.CACHE
,
3410 self
._key
_pair
_regh
= acg
.register(
3411 xpath
=NsrDtsHandler
.KEY_PAIR_XPATH
,
3412 flags
=rwdts
.Flag
.SUBSCRIBER | rwdts
.Flag
.DELTA_READY | rwdts
.Flag
.CACHE
,
3416 class NsrOpDataDtsHandler(object):
3417 """ The network service op data DTS handler """
3418 XPATH
= "D,/nsr:ns-instance-opdata/nsr:nsr"
3420 def __init__(self
, dts
, log
, loop
, nsm
):
3429 """ Return the registration handle"""
3434 """ Return the NS manager instance """
3439 """ Register for Nsr op data publisher registration"""
3440 self
._log
.debug("Registering Nsr op data path %s as publisher",
3441 NsrOpDataDtsHandler
.XPATH
)
3443 hdl
= rift
.tasklets
.DTS
.RegistrationHandler()
3444 handlers
= rift
.tasklets
.Group
.Handler()
3445 with self
._dts
.group_create(handler
=handlers
) as group
:
3446 self
._regh
= group
.register(xpath
=NsrOpDataDtsHandler
.XPATH
,
3448 flags
=rwdts
.Flag
.PUBLISHER | rwdts
.Flag
.NO_PREP_READ | rwdts
.Flag
.DATASTORE
)
3451 def create(self
, path
, msg
):
3453 Create an NS record in DTS with the path and message
3455 self
._log
.debug("Creating NSR %s:%s", path
, msg
)
3456 self
.regh
.create_element(path
, msg
)
3457 self
._log
.debug("Created NSR, %s:%s", path
, msg
)
3460 def update(self
, path
, msg
, flags
=rwdts
.XactFlag
.REPLACE
):
3462 Update an NS record in DTS with the path and message
3464 self
._log
.debug("Updating NSR, %s:%s regh = %s", path
, msg
, self
.regh
)
3465 self
.regh
.update_element(path
, msg
, flags
)
3466 self
._log
.debug("Updated NSR, %s:%s", path
, msg
)
3469 def delete(self
, path
):
3471 Update an NS record in DTS with the path and message
3473 self
._log
.debug("Deleting NSR path:%s", path
)
3474 self
.regh
.delete_element(path
)
3475 self
._log
.debug("Deleted NSR path:%s", path
)
3478 class VnfrDtsHandler(object):
3479 """ The virtual network service DTS handler """
3480 XPATH
= "D,/vnfr:vnfr-catalog/vnfr:vnfr"
3482 def __init__(self
, dts
, log
, loop
, nsm
):
3492 """ Return registration handle """
3497 """ Return the NS manager instance """
3502 """ Register for vnfr create/update/delete/ advises from dts """
3504 def on_commit(xact_info
):
3505 """ The transaction has been committed """
3506 self
._log
.debug("Got vnfr commit (xact_info: %s)", xact_info
)
3507 return rwdts
.MemberRspCode
.ACTION_OK
3510 def on_prepare(xact_info
, action
, ks_path
, msg
):
3511 """ prepare callback from dts """
3512 xpath
= ks_path
.to_xpath(RwNsrYang
.get_schema())
3514 "Got vnfr on_prepare cb (xact_info: %s, action: %s): %s:%s",
3515 xact_info
, action
, ks_path
, msg
3518 schema
= VnfrYang
.YangData_Vnfr_VnfrCatalog_Vnfr
.schema()
3519 path_entry
= schema
.keyspec_to_entry(ks_path
)
3520 if path_entry
.key00
.id not in self
._nsm
._vnfrs
:
3521 self
._log
.error("%s request for non existent record path %s",
3523 xact_info
.respond_xpath(rwdts
.XactRspCode
.NA
, xpath
)
3527 self
._log
.debug("Deleting VNFR with id %s", path_entry
.key00
.id)
3528 if action
== rwdts
.QueryAction
.CREATE
or action
== rwdts
.QueryAction
.UPDATE
:
3529 yield from self
._nsm
.update_vnfr(msg
)
3530 elif action
== rwdts
.QueryAction
.DELETE
:
3531 self
._log
.debug("Deleting VNFR with id %s", path_entry
.key00
.id)
3532 self
._nsm
.delete_vnfr(path_entry
.key00
.id)
3534 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
, xpath
)
3536 self
._log
.debug("Registering for VNFR using xpath: %s",
3537 VnfrDtsHandler
.XPATH
,)
3539 hdl
= rift
.tasklets
.DTS
.RegistrationHandler(on_commit
=on_commit
,
3540 on_prepare
=on_prepare
,)
3541 with self
._dts
.group_create() as group
:
3542 self
._regh
= group
.register(xpath
=VnfrDtsHandler
.XPATH
,
3544 flags
=(rwdts
.Flag
.SUBSCRIBER
),)
3547 class NsdRefCountDtsHandler(object):
3548 """ The NSD Ref Count DTS handler """
3549 XPATH
= "D,/nsr:ns-instance-opdata/rw-nsr:nsd-ref-count"
3551 def __init__(self
, dts
, log
, loop
, nsm
):
3561 """ Return registration handle """
3566 """ Return the NS manager instance """
3571 """ Register for NSD ref count read from dts """
3574 def on_prepare(xact_info
, action
, ks_path
, msg
):
3575 """ prepare callback from dts """
3576 xpath
= ks_path
.to_xpath(RwNsrYang
.get_schema())
3578 if action
== rwdts
.QueryAction
.READ
:
3579 schema
= RwNsrYang
.YangData_Nsr_NsInstanceOpdata_NsdRefCount
.schema()
3580 path_entry
= schema
.keyspec_to_entry(ks_path
)
3581 nsd_list
= yield from self
._nsm
.get_nsd_refcount(path_entry
.key00
.nsd_id_ref
)
3582 for xpath
, msg
in nsd_list
:
3583 xact_info
.respond_xpath(rsp_code
=rwdts
.XactRspCode
.MORE
,
3586 xact_info
.respond_xpath(rwdts
.XactRspCode
.ACK
)
3588 raise NetworkServiceRecordError("Not supported operation %s" % action
)
3590 hdl
= rift
.tasklets
.DTS
.RegistrationHandler(on_prepare
=on_prepare
,)
3591 with self
._dts
.group_create() as group
:
3592 self
._regh
= group
.register(xpath
=NsdRefCountDtsHandler
.XPATH
,
3594 flags
=rwdts
.Flag
.PUBLISHER
,)
3597 class NsManager(object):
3598 """ The Network Service Manager class"""
3599 def __init__(self
, dts
, log
, loop
,
3600 nsr_handler
, vnfr_handler
, vlr_handler
, ro_plugin_selector
,
3601 vnffgmgr
, vnfd_pub_handler
, cloud_account_handler
):
3605 self
._nsr
_handler
= nsr_handler
3606 self
._vnfr
_pub
_handler
= vnfr_handler
3607 self
._vlr
_pub
_handler
= vlr_handler
3608 self
._vnffgmgr
= vnffgmgr
3609 self
._vnfd
_pub
_handler
= vnfd_pub_handler
3610 self
._cloud
_account
_handler
= cloud_account_handler
3612 self
._ro
_plugin
_selector
= ro_plugin_selector
3613 self
._ncclient
= rift
.mano
.ncclient
.NcClient(
3625 self
.cfgmgr_obj
= conman
.ROConfigManager(log
, loop
, dts
, self
)
3627 # TODO: All these handlers should move to tasklet level.
3628 # Passing self is often an indication of bad design
3629 self
._nsd
_dts
_handler
= NsdDtsHandler(dts
, log
, loop
, self
)
3630 self
._vnfd
_dts
_handler
= VnfdDtsHandler(dts
, log
, loop
, self
)
3631 self
._dts
_handlers
= [self
._nsd
_dts
_handler
,
3632 VnfrDtsHandler(dts
, log
, loop
, self
),
3633 NsdRefCountDtsHandler(dts
, log
, loop
, self
),
3634 NsrDtsHandler(dts
, log
, loop
, self
),
3635 ScalingRpcHandler(log
, dts
, loop
, self
.scale_rpc_callback
),
3636 NsrRpcDtsHandler(dts
,log
,loop
,self
),
3637 self
._vnfd
_dts
_handler
,
3658 def nsr_handler(self
):
3659 """" NSR handler """
3660 return self
._nsr
_handler
3664 """" So Obj handler """
3669 """ NSRs in this NSM"""
3674 """ NSDs in this NSM"""
3679 """ VNFDs in this NSM"""
3684 """ VNFRs in this NSM"""
3688 def nsr_pub_handler(self
):
3689 """ NSR publication handler """
3690 return self
._nsr
_handler
3693 def vnfr_pub_handler(self
):
3694 """ VNFR publication handler """
3695 return self
._vnfr
_pub
_handler
3698 def vlr_pub_handler(self
):
3699 """ VLR publication handler """
3700 return self
._vlr
_pub
_handler
3703 def vnfd_pub_handler(self
):
3704 return self
._vnfd
_pub
_handler
3708 """ Register all static DTS handlers """
3709 for dts_handle
in self
._dts
_handlers
:
3710 yield from dts_handle
.register()
3713 def get_ns_by_nsr_id(self
, nsr_id
):
3714 """ get NSR by nsr id """
3715 if nsr_id
not in self
._nsrs
:
3716 raise NetworkServiceRecordError("NSR id %s not found" % nsr_id
)
3718 return self
._nsrs
[nsr_id
]
3720 def scale_nsr_out(self
, nsr_id
, scale_group_name
, instance_id
, config_xact
):
3721 self
.log
.debug("Scale out NetworkServiceRecord (nsr_id: %s) (scaling group: %s) (instance_id: %s)",
3726 nsr
= self
._nsrs
[nsr_id
]
3727 if nsr
.state
!= NetworkServiceRecordState
.RUNNING
:
3728 raise ScalingOperationError("Cannot perform scaling operation if NSR is not in running state")
3730 self
._loop
.create_task(nsr
.create_scale_group_instance(scale_group_name
, instance_id
, config_xact
))
3732 def scale_nsr_in(self
, nsr_id
, scale_group_name
, instance_id
):
3733 self
.log
.debug("Scale in NetworkServiceRecord (nsr_id: %s) (scaling group: %s) (instance_id: %s)",
3738 nsr
= self
._nsrs
[nsr_id
]
3739 if nsr
.state
!= NetworkServiceRecordState
.RUNNING
:
3740 raise ScalingOperationError("Cannot perform scaling operation if NSR is not in running state")
3742 self
._loop
.create_task(nsr
.delete_scale_group_instance(scale_group_name
, instance_id
))
3744 def scale_rpc_callback(self
, xact
, msg
, action
):
3745 """Callback handler for RPC calls
3747 xact : Transaction Handler
3749 action : Scaling Action
3751 ScalingGroupInstance
= NsrYang
.YangData_Nsr_NsInstanceConfig_Nsr_ScalingGroup_Instance
3752 ScalingGroup
= NsrYang
.YangData_Nsr_NsInstanceConfig_Nsr_ScalingGroup
3754 xpath
= ('C,/nsr:ns-instance-config/nsr:nsr[nsr:id="{}"]').format(
3756 instance
= ScalingGroupInstance
.from_dict({"id": msg
.instance_id
})
3759 def get_nsr_scaling_group():
3760 results
= yield from self
._dts
.query_read(xpath
, rwdts
.XactFlag
.MERGE
)
3762 for result
in results
:
3763 res
= yield from result
3764 nsr_config
= res
.result
3766 for scaling_group
in nsr_config
.scaling_group
:
3767 if scaling_group
.scaling_group_name_ref
== msg
.scaling_group_name_ref
:
3770 scaling_group
= nsr_config
.scaling_group
.add()
3771 scaling_group
.scaling_group_name_ref
= msg
.scaling_group_name_ref
3773 return (nsr_config
, scaling_group
)
3776 def update_config(nsr_config
):
3777 xml
= self
._ncclient
.convert_to_xml(RwNsrYang
, nsr_config
)
3778 xml
= '<config xmlns:xc="urn:ietf:params:xml:ns:netconf:base:1.0">{}</config>'.format(xml
)
3779 yield from self
._ncclient
.connect()
3780 yield from self
._ncclient
.manager
.edit_config(target
="running", config
=xml
, default_operation
="replace")
3784 nsr_config
, scaling_group
= yield from get_nsr_scaling_group()
3785 scaling_group
.instance
.append(instance
)
3786 yield from update_config(nsr_config
)
3790 nsr_config
, scaling_group
= yield from get_nsr_scaling_group()
3791 scaling_group
.instance
.remove(instance
)
3792 yield from update_config(nsr_config
)
3794 if action
== ScalingRpcHandler
.ACTION
.SCALE_OUT
:
3795 self
._loop
.create_task(scale_out())
3797 self
._loop
.create_task(scale_in())
3799 # Opdata based calls, disabled for now!
3800 # if action == ScalingRpcHandler.ACTION.SCALE_OUT:
3801 # self.scale_nsr_out(
3803 # msg.scaling_group_name_ref,
3807 # self.scale_nsr_in(
3809 # msg.scaling_group_name_ref,
3812 def nsr_update_cfg(self
, nsr_id
, msg
):
3813 nsr
= self
._nsrs
[nsr_id
]
3814 nsr
.nsr_cfg_msg
= msg
3816 def nsr_instantiate_vl(self
, nsr_id
, vld
):
3817 self
.log
.debug("NSR {} create VL {}".format(nsr_id
, vld
))
3818 nsr
= self
._nsrs
[nsr_id
]
3819 if nsr
.state
!= NetworkServiceRecordState
.RUNNING
:
3820 raise NsrVlUpdateError("Cannot perform VL instantiate if NSR is not in running state")
3822 # Not calling in a separate task as this is called from a separate task
3823 yield from nsr
.create_vl_instance(vld
)
3825 def nsr_terminate_vl(self
, nsr_id
, vld
):
3826 self
.log
.debug("NSR {} delete VL {}".format(nsr_id
, vld
.id))
3827 nsr
= self
._nsrs
[nsr_id
]
3828 if nsr
.state
!= NetworkServiceRecordState
.RUNNING
:
3829 raise NsrVlUpdateError("Cannot perform VL terminate if NSR is not in running state")
3831 # Not calling in a separate task as this is called from a separate task
3832 yield from nsr
.delete_vl_instance(vld
)
3834 def create_nsr(self
, nsr_msg
, key_pairs
=None,restart_mode
=False):
3835 """ Create an NSR instance """
3836 if nsr_msg
.id in self
._nsrs
:
3837 msg
= "NSR id %s already exists" % nsr_msg
.id
3838 self
._log
.error(msg
)
3839 raise NetworkServiceRecordError(msg
)
3841 self
._log
.info("Create NetworkServiceRecord nsr id %s from nsd_id %s",
3845 nsm_plugin
= self
._ro
_plugin
_selector
.ro_plugin
3846 sdn_account_name
= self
._cloud
_account
_handler
.get_cloud_account_sdn_name(nsr_msg
.cloud_account
)
3848 nsr
= NetworkServiceRecord(self
._dts
,
3856 restart_mode
=restart_mode
,
3857 vlr_handler
=self
._ro
_plugin
_selector
._records
_publisher
._vlr
_pub
_hdlr
3859 self
._nsrs
[nsr_msg
.id] = nsr
3860 nsm_plugin
.create_nsr(nsr_msg
, nsr_msg
.nsd
, key_pairs
)
3864 def delete_nsr(self
, nsr_id
):
3866 Delete NSR with the passed nsr id
3868 del self
._nsrs
[nsr_id
]
3871 def instantiate_ns(self
, nsr_id
, config_xact
):
3872 """ Instantiate an NS instance """
3873 self
._log
.debug("Instantiating Network service id %s", nsr_id
)
3874 if nsr_id
not in self
._nsrs
:
3875 err
= "NSR id %s not found " % nsr_id
3876 self
._log
.error(err
)
3877 raise NetworkServiceRecordError(err
)
3879 nsr
= self
._nsrs
[nsr_id
]
3880 yield from nsr
.nsm_plugin
.instantiate_ns(nsr
, config_xact
)
3883 def update_vnfr(self
, vnfr
):
3884 """Create/Update an VNFR """
3886 vnfr_state
= self
._vnfrs
[vnfr
.id].state
3887 self
._log
.debug("Updating VNFR with state %s: vnfr %s", vnfr_state
, vnfr
)
3889 yield from self
._vnfrs
[vnfr
.id].update_state(vnfr
)
3890 nsr
= self
.find_nsr_for_vnfr(vnfr
.id)
3891 yield from nsr
.update_state()
3893 def find_nsr_for_vnfr(self
, vnfr_id
):
3894 """ Find the NSR which )has the passed vnfr id"""
3895 for nsr
in list(self
.nsrs
.values()):
3896 for vnfr
in list(nsr
.vnfrs
.values()):
3897 if vnfr
.id == vnfr_id
:
3901 def delete_vnfr(self
, vnfr_id
):
3902 """ Delete VNFR with the passed id"""
3903 del self
._vnfrs
[vnfr_id
]
3905 def get_nsd_ref(self
, nsd_id
):
3906 """ Get network service descriptor for the passed nsd_id
3908 nsd
= self
.get_nsd(nsd_id
)
3913 def get_nsr_config(self
, nsd_id
):
3914 xpath
= "C,/nsr:ns-instance-config"
3915 results
= yield from self
._dts
.query_read(xpath
, rwdts
.XactFlag
.MERGE
)
3917 for result
in results
:
3918 entry
= yield from result
3919 ns_instance_config
= entry
.result
3921 for nsr
in ns_instance_config
.nsr
:
3922 if nsr
.nsd
.id == nsd_id
:
3928 def nsd_unref_by_nsr_id(self
, nsr_id
):
3929 """ Unref the network service descriptor based on NSR id """
3930 self
._log
.debug("NSR Unref called for Nsr Id:%s", nsr_id
)
3931 if nsr_id
in self
._nsrs
:
3932 nsr
= self
._nsrs
[nsr_id
]
3935 nsd
= self
.get_nsd(nsr
.nsd_id
)
3936 self
._log
.debug("Releasing ref on NSD %s held by NSR %s - Curr %d",
3937 nsd
.id, nsr
.id, nsd
.ref_count
)
3939 except NetworkServiceDescriptorError
:
3940 # We store a copy of NSD in NSR and the NSD in nsd-catalog
3945 self
._log
.error("Cannot find NSR with id %s", nsr_id
)
3946 raise NetworkServiceDescriptorUnrefError("No NSR with id" % nsr_id
)
3949 def nsd_unref(self
, nsd_id
):
3950 """ Unref the network service descriptor associated with the id """
3951 nsd
= self
.get_nsd(nsd_id
)
3954 def get_nsd(self
, nsd_id
):
3955 """ Get network service descriptor for the passed nsd_id"""
3956 if nsd_id
not in self
._nsds
:
3957 self
._log
.error("Cannot find NSD id:%s", nsd_id
)
3958 raise NetworkServiceDescriptorError("Cannot find NSD id:%s", nsd_id
)
3960 return self
._nsds
[nsd_id
]
3962 def create_nsd(self
, nsd_msg
):
3963 """ Create a network service descriptor """
3964 self
._log
.debug("Create network service descriptor - %s", nsd_msg
)
3965 if nsd_msg
.id in self
._nsds
:
3966 self
._log
.error("Cannot create NSD %s -NSD ID already exists", nsd_msg
)
3967 raise NetworkServiceDescriptorError("NSD already exists-%s", nsd_msg
.id)
3969 nsd
= NetworkServiceDescriptor(
3976 self
._nsds
[nsd_msg
.id] = nsd
3980 def update_nsd(self
, nsd
):
3981 """ update the Network service descriptor """
3982 self
._log
.debug("Update network service descriptor - %s", nsd
)
3983 if nsd
.id not in self
._nsds
:
3984 self
._log
.debug("No NSD found - creating NSD id = %s", nsd
.id)
3985 self
.create_nsd(nsd
)
3987 self
._log
.debug("Updating NSD id = %s, nsd = %s", nsd
.id, nsd
)
3988 self
._nsds
[nsd
.id].update(nsd
)
3990 def delete_nsd(self
, nsd_id
):
3991 """ Delete the Network service descriptor with the passed id """
3992 self
._log
.debug("Deleting the network service descriptor - %s", nsd_id
)
3993 if nsd_id
not in self
._nsds
:
3994 self
._log
.debug("Delete NSD failed - cannot find nsd-id %s", nsd_id
)
3995 raise NetworkServiceDescriptorNotFound("Cannot find %s", nsd_id
)
3997 if nsd_id
not in self
._nsds
:
3998 self
._log
.debug("Cannot delete NSD id %s reference exists %s",
4000 self
._nsds
[nsd_id
].ref_count
)
4001 raise NetworkServiceDescriptorRefCountExists(
4002 "Cannot delete :%s, ref_count:%s",
4004 self
._nsds
[nsd_id
].ref_count
)
4006 del self
._nsds
[nsd_id
]
4008 def get_vnfd_config(self
, xact
):
4009 vnfd_dts_reg
= self
._vnfd
_dts
_handler
.regh
4010 for cfg
in vnfd_dts_reg
.get_xact_elements(xact
):
4011 if cfg
.id not in self
._vnfds
:
4012 self
.create_vnfd(cfg
)
4014 def get_vnfd(self
, vnfd_id
, xact
):
4015 """ Get virtual network function descriptor for the passed vnfd_id"""
4016 if vnfd_id
not in self
._vnfds
:
4017 self
._log
.error("Cannot find VNFD id:%s", vnfd_id
)
4018 self
.get_vnfd_config(xact
)
4020 if vnfd_id
not in self
._vnfds
:
4021 self
._log
.error("Cannot find VNFD id:%s", vnfd_id
)
4022 raise VnfDescriptorError("Cannot find VNFD id:%s", vnfd_id
)
4024 return self
._vnfds
[vnfd_id
]
4026 def create_vnfd(self
, vnfd
):
4027 """ Create a virtual network function descriptor """
4028 self
._log
.debug("Create virtual network function descriptor - %s", vnfd
)
4029 if vnfd
.id in self
._vnfds
:
4030 self
._log
.error("Cannot create VNFD %s -VNFD ID already exists", vnfd
)
4031 raise VnfDescriptorError("VNFD already exists-%s", vnfd
.id)
4033 self
._vnfds
[vnfd
.id] = vnfd
4034 return self
._vnfds
[vnfd
.id]
4036 def update_vnfd(self
, vnfd
):
4037 """ Update the virtual network function descriptor """
4038 self
._log
.debug("Update virtual network function descriptor- %s", vnfd
)
4041 if vnfd
.id not in self
._vnfds
:
4042 self
._log
.debug("No VNFD found - creating VNFD id = %s", vnfd
.id)
4043 self
.create_vnfd(vnfd
)
4045 self
._log
.debug("Updating VNFD id = %s, vnfd = %s", vnfd
.id, vnfd
)
4046 self
._vnfds
[vnfd
.id] = vnfd
4049 def delete_vnfd(self
, vnfd_id
):
4050 """ Delete the virtual network function descriptor with the passed id """
4051 self
._log
.debug("Deleting the virtual network function descriptor - %s", vnfd_id
)
4052 if vnfd_id
not in self
._vnfds
:
4053 self
._log
.debug("Delete VNFD failed - cannot find vnfd-id %s", vnfd_id
)
4054 raise VnfDescriptorError("Cannot find %s", vnfd_id
)
4056 del self
._vnfds
[vnfd_id
]
4058 def nsd_in_use(self
, nsd_id
):
4059 """ Is the NSD with the passed id in use """
4060 self
._log
.debug("Is this NSD in use - msg:%s", nsd_id
)
4061 if nsd_id
in self
._nsds
:
4062 return self
._nsds
[nsd_id
].in_use()
4066 def publish_nsr(self
, xact
, path
, msg
):
4067 """ Publish a NSR """
4068 self
._log
.debug("Publish NSR with path %s, msg %s",
4070 yield from self
.nsr_handler
.update(xact
, path
, msg
)
4073 def unpublish_nsr(self
, xact
, path
):
4074 """ Un Publish an NSR """
4075 self
._log
.debug("Publishing delete NSR with path %s", path
)
4076 yield from self
.nsr_handler
.delete(path
, xact
)
4078 def vnfr_is_ready(self
, vnfr_id
):
4079 """ VNFR with the id is ready """
4080 self
._log
.debug("VNFR id %s ready", vnfr_id
)
4081 if vnfr_id
not in self
._vnfds
:
4082 err
= "Did not find VNFR ID with id %s" % vnfr_id
4083 self
._log
.critical("err")
4084 raise VirtualNetworkFunctionRecordError(err
)
4085 self
._vnfrs
[vnfr_id
].is_ready()
4088 def get_nsd_refcount(self
, nsd_id
):
4089 """ Get the nsd_list from this NSM"""
4091 def nsd_refcount_xpath(nsd_id
):
4092 """ xpath for ref count entry """
4093 return (NsdRefCountDtsHandler
.XPATH
+
4094 "[rw-nsr:nsd-id-ref = '{}']").format(nsd_id
)
4097 if nsd_id
is None or nsd_id
== "":
4098 for nsd
in self
._nsds
.values():
4099 nsd_msg
= RwNsrYang
.YangData_Nsr_NsInstanceOpdata_NsdRefCount()
4100 nsd_msg
.nsd_id_ref
= nsd
.id
4101 nsd_msg
.instance_ref_count
= nsd
.ref_count
4102 nsd_list
.append((nsd_refcount_xpath(nsd
.id), nsd_msg
))
4103 elif nsd_id
in self
._nsds
:
4104 nsd_msg
= RwNsrYang
.YangData_Nsr_NsInstanceOpdata_NsdRefCount()
4105 nsd_msg
.nsd_id_ref
= self
._nsds
[nsd_id
].id
4106 nsd_msg
.instance_ref_count
= self
._nsds
[nsd_id
].ref_count
4107 nsd_list
.append((nsd_refcount_xpath(nsd_id
), nsd_msg
))
4112 def terminate_ns(self
, nsr_id
, xact
):
4114 Terminate network service for the given NSR Id
4117 # Terminate the instances/networks assocaited with this nw service
4118 self
._log
.debug("Terminating the network service %s", nsr_id
)
4119 yield from self
._nsrs
[nsr_id
].terminate()
4122 yield from self
.nsd_unref_by_nsr_id(nsr_id
)
4124 # Unpublish the NSR record
4125 self
._log
.debug("Unpublishing the network service %s", nsr_id
)
4126 yield from self
._nsrs
[nsr_id
].unpublish(xact
)
4128 # Finaly delete the NS instance from this NS Manager
4129 self
._log
.debug("Deletng the network service %s", nsr_id
)
4130 self
.delete_nsr(nsr_id
)
4133 class NsmRecordsPublisherProxy(object):
4134 """ This class provides a publisher interface that allows plugin objects
4135 to publish NSR/VNFR/VLR"""
4137 def __init__(self
, dts
, log
, loop
, nsr_pub_hdlr
, vnfr_pub_hdlr
, vlr_pub_hdlr
):
4141 self
._nsr
_pub
_hdlr
= nsr_pub_hdlr
4142 self
._vlr
_pub
_hdlr
= vlr_pub_hdlr
4143 self
._vnfr
_pub
_hdlr
= vnfr_pub_hdlr
4146 def publish_nsr(self
, xact
, nsr
):
4147 """ Publish an NSR """
4148 path
= NetworkServiceRecord
.xpath_from_nsr(nsr
)
4149 return (yield from self
._nsr
_pub
_hdlr
.update(xact
, path
, nsr
))
4152 def unpublish_nsr(self
, xact
, nsr
):
4153 """ Unpublish an NSR """
4154 path
= NetworkServiceRecord
.xpath_from_nsr(nsr
)
4155 return (yield from self
._nsr
_pub
_hdlr
.delete(xact
, path
))
4158 def publish_vnfr(self
, xact
, vnfr
):
4159 """ Publish an VNFR """
4160 path
= VirtualNetworkFunctionRecord
.vnfr_xpath(vnfr
)
4161 return (yield from self
._vnfr
_pub
_hdlr
.update(xact
, path
, vnfr
))
4164 def unpublish_vnfr(self
, xact
, vnfr
):
4165 """ Unpublish a VNFR """
4166 path
= VirtualNetworkFunctionRecord
.vnfr_xpath(vnfr
)
4167 return (yield from self
._vnfr
_pub
_hdlr
.delete(xact
, path
))
4170 def publish_vlr(self
, xact
, vlr
):
4171 """ Publish a VLR """
4172 path
= VirtualLinkRecord
.vlr_xpath(vlr
)
4173 return (yield from self
._vlr
_pub
_hdlr
.update(xact
, path
, vlr
))
4176 def unpublish_vlr(self
, xact
, vlr
):
4177 """ Unpublish a VLR """
4178 path
= VirtualLinkRecord
.vlr_xpath(vlr
)
4179 return (yield from self
._vlr
_pub
_hdlr
.delete(xact
, path
))
4182 class ScalingRpcHandler(mano_dts
.DtsHandler
):
4183 """ The Network service Monitor DTS handler """
4184 SCALE_IN_INPUT_XPATH
= "I,/nsr:exec-scale-in"
4185 SCALE_IN_OUTPUT_XPATH
= "O,/nsr:exec-scale-in"
4187 SCALE_OUT_INPUT_XPATH
= "I,/nsr:exec-scale-out"
4188 SCALE_OUT_OUTPUT_XPATH
= "O,/nsr:exec-scale-out"
4190 ACTION
= Enum('ACTION', 'SCALE_IN SCALE_OUT')
4192 def __init__(self
, log
, dts
, loop
, callback
=None):
4193 super().__init
__(log
, dts
, loop
)
4194 self
.callback
= callback
4195 self
.last_instance_id
= defaultdict(int)
4201 def on_scale_in_prepare(xact_info
, action
, ks_path
, msg
):
4202 assert action
== rwdts
.QueryAction
.RPC
4206 self
.callback(xact_info
.xact
, msg
, self
.ACTION
.SCALE_IN
)
4208 rpc_op
= NsrYang
.YangOutput_Nsr_ExecScaleIn
.from_dict({
4209 "instance_id": msg
.instance_id
})
4211 xact_info
.respond_xpath(
4212 rwdts
.XactRspCode
.ACK
,
4213 self
.__class
__.SCALE_IN_OUTPUT_XPATH
,
4216 except Exception as e
:
4217 self
.log
.exception(e
)
4218 xact_info
.respond_xpath(
4219 rwdts
.XactRspCode
.NACK
,
4220 self
.__class
__.SCALE_IN_OUTPUT_XPATH
)
4223 def on_scale_out_prepare(xact_info
, action
, ks_path
, msg
):
4224 assert action
== rwdts
.QueryAction
.RPC
4227 scaling_group
= msg
.scaling_group_name_ref
4228 if not msg
.instance_id
:
4229 last_instance_id
= self
.last_instance_id
[scale_group
]
4230 msg
.instance_id
= last_instance_id
+ 1
4231 self
.last_instance_id
[scale_group
] += 1
4234 self
.callback(xact_info
.xact
, msg
, self
.ACTION
.SCALE_OUT
)
4236 rpc_op
= NsrYang
.YangOutput_Nsr_ExecScaleOut
.from_dict({
4237 "instance_id": msg
.instance_id
})
4239 xact_info
.respond_xpath(
4240 rwdts
.XactRspCode
.ACK
,
4241 self
.__class
__.SCALE_OUT_OUTPUT_XPATH
,
4244 except Exception as e
:
4245 self
.log
.exception(e
)
4246 xact_info
.respond_xpath(
4247 rwdts
.XactRspCode
.NACK
,
4248 self
.__class
__.SCALE_OUT_OUTPUT_XPATH
)
4250 scale_in_hdl
= rift
.tasklets
.DTS
.RegistrationHandler(
4251 on_prepare
=on_scale_in_prepare
)
4252 scale_out_hdl
= rift
.tasklets
.DTS
.RegistrationHandler(
4253 on_prepare
=on_scale_out_prepare
)
4255 with self
.dts
.group_create() as group
:
4257 xpath
=self
.__class
__.SCALE_IN_INPUT_XPATH
,
4258 handler
=scale_in_hdl
,
4259 flags
=rwdts
.Flag
.PUBLISHER
)
4261 xpath
=self
.__class
__.SCALE_OUT_INPUT_XPATH
,
4262 handler
=scale_out_hdl
,
4263 flags
=rwdts
.Flag
.PUBLISHER
)
4266 class NsmTasklet(rift
.tasklets
.Tasklet
):
4268 The network service manager tasklet
4270 def __init__(self
, *args
, **kwargs
):
4271 super(NsmTasklet
, self
).__init
__(*args
, **kwargs
)
4272 self
.rwlog
.set_category("rw-mano-log")
4273 self
.rwlog
.set_subcategory("nsm")
4278 self
._ro
_plugin
_selector
= None
4279 self
._vnffgmgr
= None
4281 self
._nsr
_handler
= None
4282 self
._vnfr
_pub
_handler
= None
4283 self
._vlr
_pub
_handler
= None
4284 self
._vnfd
_pub
_handler
= None
4285 self
._scale
_cfg
_handler
= None
4287 self
._records
_publisher
_proxy
= None
4290 """ The task start callback """
4291 super(NsmTasklet
, self
).start()
4292 self
.log
.info("Starting NsmTasklet")
4294 self
.log
.debug("Registering with dts")
4295 self
._dts
= rift
.tasklets
.DTS(self
.tasklet_info
,
4296 RwNsmYang
.get_schema(),
4298 self
.on_dts_state_change
)
4300 self
.log
.debug("Created DTS Api GI Object: %s", self
._dts
)
4306 print("Caught Exception in NSM stop:", sys
.exc_info()[0])
4309 def on_instance_started(self
):
4310 """ Task instance started callback """
4311 self
.log
.debug("Got instance started callback")
4315 """ Task init callback """
4316 self
.log
.debug("Got instance started callback")
4318 self
.log
.debug("creating config account handler")
4320 self
._nsr
_pub
_handler
= publisher
.NsrOpDataDtsHandler(self
._dts
, self
.log
, self
.loop
)
4321 yield from self
._nsr
_pub
_handler
.register()
4323 self
._vnfr
_pub
_handler
= publisher
.VnfrPublisherDtsHandler(self
._dts
, self
.log
, self
.loop
)
4324 yield from self
._vnfr
_pub
_handler
.register()
4326 self
._vlr
_pub
_handler
= publisher
.VlrPublisherDtsHandler(self
._dts
, self
.log
, self
.loop
)
4327 yield from self
._vlr
_pub
_handler
.register()
4329 manifest
= self
.tasklet_info
.get_pb_manifest()
4330 use_ssl
= manifest
.bootstrap_phase
.rwsecurity
.use_ssl
4331 ssl_cert
= manifest
.bootstrap_phase
.rwsecurity
.cert
4332 ssl_key
= manifest
.bootstrap_phase
.rwsecurity
.key
4334 self
._vnfd
_pub
_handler
= publisher
.VnfdPublisher(use_ssl
, ssl_cert
, ssl_key
, self
.loop
)
4336 self
._records
_publisher
_proxy
= NsmRecordsPublisherProxy(
4340 self
._nsr
_pub
_handler
,
4341 self
._vnfr
_pub
_handler
,
4342 self
._vlr
_pub
_handler
,
4345 # Register the NSM to receive the nsm plugin
4346 # when cloud account is configured
4347 self
._ro
_plugin
_selector
= cloud
.ROAccountPluginSelector(
4351 self
._records
_publisher
_proxy
,
4353 yield from self
._ro
_plugin
_selector
.register()
4355 self
._cloud
_account
_handler
= cloud
.CloudAccountConfigSubscriber(
4360 yield from self
._cloud
_account
_handler
.register()
4362 self
._vnffgmgr
= rwvnffgmgr
.VnffgMgr(self
._dts
, self
.log
, self
.log_hdl
, self
.loop
)
4363 yield from self
._vnffgmgr
.register()
4365 self
._nsm
= NsManager(
4369 self
._nsr
_pub
_handler
,
4370 self
._vnfr
_pub
_handler
,
4371 self
._vlr
_pub
_handler
,
4372 self
._ro
_plugin
_selector
,
4374 self
._vnfd
_pub
_handler
,
4375 self
._cloud
_account
_handler
4378 yield from self
._nsm
.register()
4382 """ Task run callback """
4386 def on_dts_state_change(self
, state
):
4387 """Take action according to current dts state to transition
4388 application into the corresponding application state
4391 state - current dts state
4394 rwdts
.State
.INIT
: rwdts
.State
.REGN_COMPLETE
,
4395 rwdts
.State
.CONFIG
: rwdts
.State
.RUN
,
4399 rwdts
.State
.INIT
: self
.init
,
4400 rwdts
.State
.RUN
: self
.run
,
4403 # Transition application to next state
4404 handler
= handlers
.get(state
, None)
4405 if handler
is not None:
4406 yield from handler()
4408 # Transition dts to next state
4409 next_state
= switch
.get(state
, None)
4410 if next_state
is not None:
4411 self
.log
.debug("Changing state to %s", next_state
)
4412 self
._dts
.handle
.set_state(next_state
)