3 # Copyright 2016 RIFT.IO Inc
5 # Licensed under the Apache License, Version 2.0 (the "License");
6 # you may not use this file except in compliance with the License.
7 # You may obtain a copy of the License at
9 # http://www.apache.org/licenses/LICENSE-2.0
11 # Unless required by applicable law or agreed to in writing, software
12 # distributed under the License is distributed on an "AS IS" BASIS,
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 # See the License for the specific language governing permissions and
15 # limitations under the License.
25 gi
.require_version('RwDts', '1.0')
26 gi
.require_version('RwVnfrYang', '1.0')
27 from gi
.repository
import (
32 import rift
.openmano
.rift2openmano
as rift2openmano
33 import rift
.openmano
.openmano_client
as openmano_client
34 from . import rwnsmplugin
40 if sys
.version_info
< (3, 4, 4):
41 asyncio
.ensure_future
= asyncio
.async
44 DUMP_OPENMANO_DIR
= os
.path
.join(
45 os
.environ
["RIFT_ARTIFACTS"],
46 "openmano_descriptors"
50 def dump_openmano_descriptor(name
, descriptor_str
):
51 filename
= "{}_{}.yaml".format(
52 time
.strftime("%Y%m%d-%H%M%S"),
56 filepath
= os
.path
.join(
62 if not os
.path
.exists(DUMP_OPENMANO_DIR
):
63 os
.makedirs(DUMP_OPENMANO_DIR
)
65 with
open(filepath
, 'w') as hdl
:
66 hdl
.write(descriptor_str
)
69 print("Failed to dump openmano descriptor: %s" % str(e
))
73 class VnfrConsoleOperdataDtsHandler(object):
74 """ registers 'D,/vnfr:vnfr-console/vnfr:vnfr[id]/vdur[id]' and handles CRUD from DTS"""
76 def vnfr_vdu_console_xpath(self
):
77 """ path for resource-mgr"""
78 return ("D,/rw-vnfr:vnfr-console/rw-vnfr:vnfr[rw-vnfr:id='{}']/rw-vnfr:vdur[vnfr:id='{}']".format(self
._vnfr
_id
,self
._vdur
_id
))
80 def __init__(self
, dts
, log
, loop
, nsr
, vnfr_id
, vdur_id
, vdu_id
):
87 self
._vnfr
_id
= vnfr_id
88 self
._vdur
_id
= vdur_id
93 """ Register for VNFR VDU Operational Data read from dts """
96 def on_prepare(xact_info
, action
, ks_path
, msg
):
97 """ prepare callback from dts """
98 xpath
= ks_path
.to_xpath(RwVnfrYang
.get_schema())
100 "Got VNFR VDU Opdata xact_info: %s, action: %s): %s:%s",
101 xact_info
, action
, xpath
, msg
104 if action
== rwdts
.QueryAction
.READ
:
105 schema
= RwVnfrYang
.YangData_RwVnfr_VnfrConsole_Vnfr_Vdur
.schema()
106 path_entry
= schema
.keyspec_to_entry(ks_path
)
109 console_url
= yield from self
._loop
.run_in_executor(
111 self
._nsr
._http
_api
.get_instance_vm_console_url
,
116 self
._log
.debug("Got console response: %s for NSR ID %s vdur ID %s",
121 vdur_console
= RwVnfrYang
.YangData_RwVnfr_VnfrConsole_Vnfr_Vdur()
122 vdur_console
.id = self
._vdur
_id
124 vdur_console
.console_url
= console_url
126 vdur_console
.console_url
= 'none'
127 self
._log
.debug("Recevied console URL for vdu {} is {}".format(self
._vdu
_id
,vdur_console
))
128 except openmano_client
.InstanceStatusError
as e
:
129 self
._log
.error("Could not get NS instance console URL: %s",
131 vdur_console
= RwVnfrYang
.YangData_RwVnfr_VnfrConsole_Vnfr_Vdur()
132 vdur_console
.id = self
._vdur
_id
133 vdur_console
.console_url
= 'none'
135 xact_info
.respond_xpath(rsp_code
=rwdts
.XactRspCode
.ACK
,
136 xpath
=self
.vnfr_vdu_console_xpath
,
139 #raise VnfRecordError("Not supported operation %s" % action)
140 self
._log
.error("Not supported operation %s" % action
)
141 xact_info
.respond_xpath(rsp_code
=rwdts
.XactRspCode
.ACK
)
144 self
._log
.debug("Registering for VNFR VDU using xpath: %s",
145 self
.vnfr_vdu_console_xpath
)
146 hdl
= rift
.tasklets
.DTS
.RegistrationHandler(on_prepare
=on_prepare
,)
147 with self
._dts
.group_create() as group
:
148 self
._regh
= group
.register(xpath
=self
.vnfr_vdu_console_xpath
,
150 flags
=rwdts
.Flag
.PUBLISHER
,
155 class OpenmanoVnfr(object):
156 def __init__(self
, log
, loop
, cli_api
, vnfr
):
159 self
._cli
_api
= cli_api
161 self
._vnfd
_id
= vnfr
.vnfd
.id
165 self
._created
= False
169 return rift2openmano
.RiftVNFD(self
._vnfr
.vnfd
)
176 def rift_vnfd_id(self
):
180 def openmano_vnfd_id(self
):
184 def openmano_vnfd(self
):
185 self
._log
.debug("Converting vnfd %s from rift to openmano", self
.vnfd
.id)
186 openmano_vnfd
= rift2openmano
.rift2openmano_vnfd(self
.vnfd
)
190 def openmano_vnfd_yaml(self
):
191 return yaml
.safe_dump(self
.openmano_vnfd
, default_flow_style
=False)
195 self
._log
.debug("Creating openmano vnfd")
196 openmano_vnfd
= self
.openmano_vnfd
197 name
= openmano_vnfd
["vnf"]["name"]
199 # If the name already exists, get the openmano vnfd id
200 name_uuid_map
= yield from self
._loop
.run_in_executor(
202 self
._cli
_api
.vnf_list
,
205 if name
in name_uuid_map
:
206 vnf_id
= name_uuid_map
[name
]
207 self
._log
.debug("Vnf already created. Got existing openmano vnfd id: %s", vnf_id
)
208 self
._vnf
_id
= vnf_id
211 self
._vnf
_id
, _
= yield from self
._loop
.run_in_executor(
213 self
._cli
_api
.vnf_create
,
214 self
.openmano_vnfd_yaml
,
217 fpath
= dump_openmano_descriptor(
218 "{}_vnf".format(name
),
219 self
.openmano_vnfd_yaml
222 self
._log
.debug("Dumped Openmano VNF descriptor to: %s", fpath
)
228 if not self
._created
:
231 self
._log
.debug("Deleting openmano vnfd")
232 if self
._vnf
_id
is None:
233 self
._log
.warning("Openmano vnf id not set. Cannot delete.")
236 yield from self
._loop
.run_in_executor(
238 self
._cli
_api
.vnf_delete
,
243 class OpenmanoNSRecordState(Enum
):
244 """ Network Service Record State """
246 INSTANTIATION_PENDING
= 102
258 class OpenmanoNsr(object):
261 def __init__(self
, dts
, log
, loop
, publisher
, cli_api
, http_api
, nsd_msg
, nsr_config_msg
,key_pairs
):
265 self
._publisher
= publisher
266 self
._cli
_api
= cli_api
267 self
._http
_api
= http_api
269 self
._nsd
_msg
= nsd_msg
270 self
._nsr
_config
_msg
= nsr_config_msg
274 self
._vdur
_console
_handler
= {}
275 self
._key
_pairs
= key_pairs
277 self
._nsd
_uuid
= None
278 self
._nsr
_uuid
= None
282 self
._created
= False
284 self
._monitor
_task
= None
285 self
._state
= OpenmanoNSRecordState
.INIT
289 return rift2openmano
.RiftNSD(self
._nsd
_msg
)
293 return {v
.rift_vnfd_id
: v
.vnfd
for v
in self
._vnfrs
}
297 return {v
.rift_vnfd_id
: v
.openmano_vnfd_id
for v
in self
._vnfrs
}
304 def openmano_nsd_yaml(self
):
305 self
._log
.debug("Converting nsd %s from rift to openmano", self
.nsd
.id)
306 openmano_nsd
= rift2openmano
.rift2openmano_nsd(self
.nsd
, self
.vnfds
,self
.vnfr_ids
)
307 return yaml
.safe_dump(openmano_nsd
, default_flow_style
=False)
309 def get_ssh_key_pairs(self
):
312 for authorized_key
in self
._nsr
_config
_msg
.ssh_authorized_key
:
313 self
._log
.debug("Key pair ref present is %s",authorized_key
.key_pair_ref
)
314 if authorized_key
.key_pair_ref
in self
._key
_pairs
:
315 key_pairs
.append(self
._key
_pairs
[authorized_key
.key_pair_ref
].key
)
317 for authorized_key
in self
._nsd
_msg
.key_pair
:
318 self
._log
.debug("Key pair NSD is %s",authorized_key
)
319 key_pairs
.append(authorized_key
.key
)
322 cloud_config
["key-pairs"] = key_pairs
325 for user_entry
in self
._nsr
_config
_msg
.user
:
326 self
._log
.debug("User present is %s",user_entry
)
328 user
["name"] = user_entry
.name
329 user
["key-pairs"] = list()
330 for ssh_key
in user_entry
.ssh_authorized_key
:
331 if ssh_key
.key_pair_ref
in self
._key
_pairs
:
332 user
["key-pairs"].append(self
._key
_pairs
[ssh_key
.key_pair_ref
].key
)
335 for user_entry
in self
._nsd
_msg
.user
:
336 self
._log
.debug("User present in NSD is %s",user_entry
)
338 user
["name"] = user_entry
.name
339 user
["key-pairs"] = list()
340 for ssh_key
in user_entry
.key_pair
:
341 user
["key-pairs"].append(ssh_key
.key
)
345 cloud_config
["users"] = users
347 self
._log
.debug("Cloud config formed is %s",cloud_config
)
352 def openmano_instance_create_yaml(self
):
353 self
._log
.debug("Creating instance-scenario-create input file for nsd %s with name %s", self
.nsd
.id, self
._nsr
_config
_msg
.name
)
354 openmano_instance_create
= {}
355 openmano_instance_create
["name"] = self
._nsr
_config
_msg
.name
356 openmano_instance_create
["description"] = self
._nsr
_config
_msg
.description
357 openmano_instance_create
["scenario"] = self
._nsd
_uuid
359 cloud_config
= self
.get_ssh_key_pairs()
361 openmano_instance_create
["cloud-config"] = cloud_config
362 if self
._nsr
_config
_msg
.has_field("om_datacenter"):
363 openmano_instance_create
["datacenter"] = self
._nsr
_config
_msg
.om_datacenter
364 openmano_instance_create
["vnfs"] = {}
365 for vnfr
in self
._vnfrs
:
366 if "om_datacenter" in vnfr
.vnfr
.vnfr_msg
:
367 vnfr_name
= vnfr
.vnfr
.vnfd
.name
+ "__" + str(vnfr
.vnfr
.vnfr_msg
.member_vnf_index_ref
)
368 openmano_instance_create
["vnfs"][vnfr_name
] = {"datacenter": vnfr
.vnfr
.vnfr_msg
.om_datacenter
}
369 openmano_instance_create
["networks"] = {}
370 for vld_msg
in self
._nsd
_msg
.vld
:
371 openmano_instance_create
["networks"][vld_msg
.name
] = {}
372 openmano_instance_create
["networks"][vld_msg
.name
]["sites"] = list()
373 for vlr
in self
._vlrs
:
374 if vlr
.vld_msg
.name
== vld_msg
.name
:
375 self
._log
.debug("Received VLR name %s, VLR DC: %s for VLD: %s",vlr
.vld_msg
.name
,
376 vlr
.om_datacenter_name
,vld_msg
.name
)
377 #network["vim-network-name"] = vld_msg.name
380 if vld_msg
.vim_network_name
:
381 network
["netmap-use"] = vld_msg
.vim_network_name
382 elif vlr
._ip
_profile
and vlr
._ip
_profile
.has_field("ip_profile_params"):
383 ip_profile_params
= vlr
._ip
_profile
.ip_profile_params
384 if ip_profile_params
.ip_version
== "ipv6":
385 ip_profile
['ip-version'] = "IPv6"
387 ip_profile
['ip-version'] = "IPv4"
388 if ip_profile_params
.has_field('subnet_address'):
389 ip_profile
['subnet-address'] = ip_profile_params
.subnet_address
390 if ip_profile_params
.has_field('gateway_address'):
391 ip_profile
['gateway-address'] = ip_profile_params
.gateway_address
392 if ip_profile_params
.has_field('dns_server') and len(ip_profile_params
.dns_server
) > 0:
393 ip_profile
['dns-address'] = ip_profile_params
.dns_server
[0].address
394 if ip_profile_params
.has_field('dhcp_params'):
395 ip_profile
['dhcp'] = {}
396 ip_profile
['dhcp']['enabled'] = ip_profile_params
.dhcp_params
.enabled
397 ip_profile
['dhcp']['start-address'] = ip_profile_params
.dhcp_params
.start_address
398 ip_profile
['dhcp']['count'] = ip_profile_params
.dhcp_params
.count
400 network
["netmap-create"] = vlr
.name
401 if vlr
.om_datacenter_name
:
402 network
["datacenter"] = vlr
.om_datacenter_name
403 elif vld_msg
.has_field("om_datacenter"):
404 network
["datacenter"] = vld_msg
.om_datacenter
405 elif "datacenter" in openmano_instance_create
:
406 network
["datacenter"] = openmano_instance_create
["datacenter"]
408 openmano_instance_create
["networks"][vld_msg
.name
]["sites"].append(network
)
410 openmano_instance_create
["networks"][vld_msg
.name
]['ip-profile'] = ip_profile
412 return yaml
.safe_dump(openmano_instance_create
, default_flow_style
=False,width
=1000)
415 def add_vlr(self
, vlr
):
416 self
._vlrs
.append(vlr
)
417 yield from asyncio
.sleep(1, loop
=self
._loop
)
420 def remove_vlr(self
, vlr
):
421 if vlr
in self
._vlrs
:
422 self
._vlrs
.remove(vlr
)
423 if not vlr
.vld_msg
.vim_network_name
:
424 yield from self
._loop
.run_in_executor(
426 self
._cli
_api
.ns_vim_network_delete
,
428 vlr
.om_datacenter_name
)
429 yield from asyncio
.sleep(1, loop
=self
._loop
)
432 def add_vnfr(self
, vnfr
):
433 vnfr
= OpenmanoVnfr(self
._log
, self
._loop
, self
._cli
_api
, vnfr
)
434 yield from vnfr
.create()
435 self
._vnfrs
.append(vnfr
)
439 if not self
._created
:
440 self
._log
.debug("NSD wasn't created. Skipping delete.")
443 self
._log
.debug("Deleting openmano nsr")
445 yield from self
._loop
.run_in_executor(
447 self
._cli
_api
.ns_delete
,
451 self
._log
.debug("Deleting openmano vnfrs")
452 for vnfr
in self
._vnfrs
:
453 yield from vnfr
.delete()
458 self
._log
.debug("Creating openmano scenario")
459 name_uuid_map
= yield from self
._loop
.run_in_executor(
461 self
._cli
_api
.ns_list
,
464 if self
._nsd
_msg
.name
in name_uuid_map
:
465 self
._log
.debug("Found existing openmano scenario")
466 self
._nsd
_uuid
= name_uuid_map
[self
._nsd
_msg
.name
]
470 # Use the nsd uuid as the scenario name to rebind to existing
471 # scenario on reload or to support muliple instances of the name
473 self
._nsd
_uuid
, _
= yield from self
._loop
.run_in_executor(
475 self
._cli
_api
.ns_create
,
476 self
.openmano_nsd_yaml
,
479 fpath
= dump_openmano_descriptor(
480 "{}_nsd".format(self
._nsd
_msg
.name
),
481 self
.openmano_nsd_yaml
,
484 self
._log
.debug("Dumped Openmano NS descriptor to: %s", fpath
)
489 def instance_monitor_task(self
):
490 self
._log
.debug("Starting Instance monitoring task")
492 start_time
= time
.time()
496 yield from asyncio
.sleep(1, loop
=self
._loop
)
499 instance_resp_json
= yield from self
._loop
.run_in_executor(
501 self
._http
_api
.get_instance
,
505 self
._log
.debug("Got instance response: %s for NSR ID %s",
509 except openmano_client
.InstanceStatusError
as e
:
510 self
._log
.error("Could not get NS instance status: %s", str(e
))
513 def all_vms_active(vnf
):
514 for vm
in vnf
["vms"]:
515 vm_status
= vm
["status"]
517 if vm_status
!= "ACTIVE":
518 self
._log
.debug("VM is not yet active: %s (status: %s)", vm_uuid
, vm_status
)
523 def any_vm_active_nomgmtip(vnf
):
524 for vm
in vnf
["vms"]:
525 vm_status
= vm
["status"]
527 if vm_status
!= "ACTIVE":
528 self
._log
.debug("VM is not yet active: %s (status: %s)", vm_uuid
, vm_status
)
533 def any_vms_error(vnf
):
534 for vm
in vnf
["vms"]:
535 vm_status
= vm
["status"]
536 vm_vim_info
= vm
["vim_info"]
538 if vm_status
== "ERROR":
539 self
._log
.error("VM Error: %s (vim_info: %s)", vm_uuid
, vm_vim_info
)
544 def get_vnf_ip_address(vnf
):
545 if "ip_address" in vnf
:
546 return vnf
["ip_address"].strip()
549 def get_vnf_mac_address(vnf
):
550 if "mac_address" in vnf
:
551 return vnf
["mac_address"].strip()
554 def get_ext_cp_info(vnf
):
556 for vm
in vnf
["vms"]:
557 if "interfaces" not in vm
:
560 for intf
in vm
["interfaces"]:
561 if "external_name" not in intf
:
564 if not intf
["external_name"]:
567 ip_address
= intf
["ip_address"]
568 if ip_address
is None:
569 ip_address
= "0.0.0.0"
571 mac_address
= intf
["mac_address"]
572 if mac_address
is None:
573 mac_address
="00:00:00:00:00:00"
575 cp_info_list
.append((intf
["external_name"], ip_address
, mac_address
))
579 def get_vnf_status(vnfr
):
580 # When we create an openmano descriptor we use <name>__<idx>
581 # to come up with openmano constituent VNF name. Use this
582 # knowledge to map the vnfr back.
583 openmano_vnfr_suffix
= "__{}".format(
584 vnfr
.vnfr
.vnfr_msg
.member_vnf_index_ref
587 for vnf
in instance_resp_json
["vnfs"]:
588 if vnf
["vnf_name"].endswith(openmano_vnfr_suffix
):
591 self
._log
.warning("Could not find vnf status with name that ends with: %s",
592 openmano_vnfr_suffix
)
595 for vnfr
in self
._vnfrs
:
596 if vnfr
in active_vnfs
:
597 # Skipping, so we don't re-publish the same VNF message.
600 vnfr_msg
= vnfr
.vnfr
.vnfr_msg
.deep_copy()
601 vnfr_msg
.operational_status
= "init"
604 vnf_status
= get_vnf_status(vnfr
)
605 self
._log
.debug("Found VNF status: %s", vnf_status
)
606 if vnf_status
is None:
607 self
._log
.error("Could not find VNF status from openmano")
608 self
._state
= OpenmanoNSRecordState
.FAILED
609 vnfr_msg
.operational_status
= "failed"
610 yield from self
._publisher
.publish_vnfr(None, vnfr_msg
)
613 # If there was a VNF that has a errored VM, then just fail the VNF and stop monitoring.
614 if any_vms_error(vnf_status
):
615 self
._log
.debug("VM was found to be in error state. Marking as failed.")
616 self
._state
= OpenmanoNSRecordState
.FAILED
617 vnfr_msg
.operational_status
= "failed"
618 yield from self
._publisher
.publish_vnfr(None, vnfr_msg
)
621 if all_vms_active(vnf_status
):
622 vnf_ip_address
= get_vnf_ip_address(vnf_status
)
623 vnf_mac_address
= get_vnf_mac_address(vnf_status
)
625 if vnf_ip_address
is None:
626 self
._log
.warning("No IP address obtained "
627 "for VNF: {}, will retry.".format(
628 vnf_status
['vnf_name']))
631 self
._log
.debug("All VMs in VNF are active. Marking as running.")
632 vnfr_msg
.operational_status
= "running"
634 self
._log
.debug("Got VNF ip address: %s, mac-address: %s", vnf_ip_address
, vnf_mac_address
)
635 vnfr_msg
.mgmt_interface
.ip_address
= vnf_ip_address
636 vnfr_msg
.vnf_configuration
.config_access
.mgmt_ip_address
= vnf_ip_address
639 for vm
in vnf_status
["vms"]:
640 if vm
["uuid"] not in self
._vdur
_console
_handler
:
641 vdur_console_handler
= VnfrConsoleOperdataDtsHandler(self
._dts
, self
._log
, self
._loop
,
642 self
, vnfr_msg
.id,vm
["uuid"],vm
["name"])
643 yield from vdur_console_handler
.register()
644 self
._vdur
_console
_handler
[vm
["uuid"]] = vdur_console_handler
646 vdur_msg
= vnfr_msg
.vdur
.add()
647 vdur_msg
.vim_id
= vm
["vim_vm_id"]
648 vdur_msg
.id = vm
["uuid"]
650 # Add connection point information for the config manager
651 cp_info_list
= get_ext_cp_info(vnf_status
)
652 for (cp_name
, cp_ip
, cp_mac_addr
) in cp_info_list
:
653 cp
= vnfr_msg
.connection_point
.add()
655 cp
.short_name
= cp_name
656 cp
.ip_address
= cp_ip
657 cp
.mac_address
= cp_mac_addr
659 yield from self
._publisher
.publish_vnfr(None, vnfr_msg
)
660 active_vnfs
.append(vnfr
)
662 if (time
.time() - start_time
) > OpenmanoNsr
.TIMEOUT_SECS
:
663 self
._log
.error("NSR timed out before reaching running state")
664 self
._state
= OpenmanoNSRecordState
.FAILED
665 vnfr_msg
.operational_status
= "failed"
666 yield from self
._publisher
.publish_vnfr(None, vnfr_msg
)
669 except Exception as e
:
670 vnfr_msg
.operational_status
= "failed"
671 self
._state
= OpenmanoNSRecordState
.FAILED
672 yield from self
._publisher
.publish_vnfr(None, vnfr_msg
)
673 self
._log
.exception("Caught exception publishing vnfr info: %s", str(e
))
676 if len(active_vnfs
) == len(self
._vnfrs
):
677 self
._state
= OpenmanoNSRecordState
.RUNNING
678 self
._log
.info("All VNF's are active. Exiting NSR monitoring task")
682 def deploy(self
,nsr_msg
):
683 if self
._nsd
_uuid
is None:
684 raise ValueError("Cannot deploy an uncreated nsd")
686 self
._log
.debug("Deploying openmano scenario")
688 name_uuid_map
= yield from self
._loop
.run_in_executor(
690 self
._cli
_api
.ns_instance_list
,
693 if self
._nsr
_config
_msg
.name
in name_uuid_map
:
694 self
._log
.debug("Found existing instance with nsr name: %s", self
._nsr
_config
_msg
.name
)
695 self
._nsr
_uuid
= name_uuid_map
[self
._nsr
_config
_msg
.name
]
697 self
._nsr
_msg
= nsr_msg
698 fpath
= dump_openmano_descriptor(
699 "{}_instance_sce_create".format(self
._nsr
_config
_msg
.name
),
700 self
.openmano_instance_create_yaml
,
702 self
._log
.debug("Dumped Openmano NS Scenario Cretae to: %s", fpath
)
704 self
._nsr
_uuid
= yield from self
._loop
.run_in_executor(
706 self
._cli
_api
.ns_instance_scenario_create
,
707 self
.openmano_instance_create_yaml
)
709 self
._state
= OpenmanoNSRecordState
.INSTANTIATION_PENDING
711 self
._monitor
_task
= asyncio
.ensure_future(
712 self
.instance_monitor_task(), loop
=self
._loop
718 for _
,handler
in self
._vdur
_console
_handler
.items():
719 handler
._regh
.deregister()
721 if self
._nsr
_uuid
is None:
722 self
._log
.warning("Cannot terminate an un-instantiated nsr")
725 if self
._monitor
_task
is not None:
726 self
._monitor
_task
.cancel()
727 self
._monitor
_task
= None
729 self
._log
.debug("Terminating openmano nsr")
730 yield from self
._loop
.run_in_executor(
732 self
._cli
_api
.ns_terminate
,
737 def create_vlr(self
,vlr
):
738 self
._log
.debug("Creating openmano vim network VLR name %s, VLR DC: %s",vlr
.vld_msg
.name
,
739 vlr
.om_datacenter_name
)
742 net
['name'] = vlr
.name
744 net
['type'] = 'bridge'
745 self
._log
.debug("Received ip profile is %s",vlr
._ip
_profile
)
746 if vlr
._ip
_profile
and vlr
._ip
_profile
.has_field("ip_profile_params"):
747 ip_profile_params
= vlr
._ip
_profile
.ip_profile_params
749 if ip_profile_params
.ip_version
== "ipv6":
750 ip_profile
['ip_version'] = "IPv6"
752 ip_profile
['ip_version'] = "IPv4"
753 if ip_profile_params
.has_field('subnet_address'):
754 ip_profile
['subnet_address'] = ip_profile_params
.subnet_address
755 if ip_profile_params
.has_field('gateway_address'):
756 ip_profile
['gateway_address'] = ip_profile_params
.gateway_address
757 if ip_profile_params
.has_field('dns_server') and len(ip_profile_params
.dns_server
) > 0:
758 ip_profile
['dns_address'] = ip_profile_params
.dns_server
[0].address
759 if ip_profile_params
.has_field('dhcp_params'):
760 ip_profile
['dhcp_enabled'] = ip_profile_params
.dhcp_params
.enabled
761 ip_profile
['dhcp_start_address'] = ip_profile_params
.dhcp_params
.start_address
762 ip_profile
['dhcp_count'] = ip_profile_params
.dhcp_params
.count
763 net
['ip_profile'] = ip_profile
764 net_create
["network"]= net
766 net_create_msg
= yaml
.safe_dump(net_create
,default_flow_style
=False)
767 fpath
= dump_openmano_descriptor(
768 "{}_vim_net_create_{}".format(self
._nsr
_config
_msg
.name
,vlr
.name
),
770 self
._log
.debug("Dumped Openmano VIM Net create to: %s", fpath
)
772 vim_network_uuid
= yield from self
._loop
.run_in_executor(
774 self
._cli
_api
.ns_vim_network_create
,
776 vlr
.om_datacenter_name
)
777 self
._vlrs
.append(vlr
)
781 class OpenmanoNsPlugin(rwnsmplugin
.NsmPluginBase
):
783 RW Implentation of the NsmPluginBase
785 def __init__(self
, dts
, log
, loop
, publisher
, ro_account
):
789 self
._publisher
= publisher
792 self
._http
_api
= None
793 self
._openmano
_nsrs
= {}
795 self
._set
_ro
_account
(ro_account
)
797 def _set_ro_account(self
, ro_account
):
798 self
._log
.debug("Setting openmano plugin cloud account: %s", ro_account
)
799 self
._cli
_api
= openmano_client
.OpenmanoCliAPI(
801 ro_account
.openmano
.host
,
802 ro_account
.openmano
.port
,
803 ro_account
.openmano
.tenant_id
,
806 self
._http
_api
= openmano_client
.OpenmanoHttpAPI(
808 ro_account
.openmano
.host
,
809 ro_account
.openmano
.port
,
810 ro_account
.openmano
.tenant_id
,
813 def create_nsr(self
, nsr_config_msg
, nsd_msg
, key_pairs
=None):
815 Create Network service record
817 openmano_nsr
= OpenmanoNsr(
828 self
._openmano
_nsrs
[nsr_config_msg
.id] = openmano_nsr
831 def deploy(self
, nsr_msg
):
832 self
._log
.debug("Received NSR Deploy msg : %s", nsr_msg
)
833 openmano_nsr
= self
._openmano
_nsrs
[nsr_msg
.ns_instance_config_ref
]
834 yield from openmano_nsr
.create()
835 yield from openmano_nsr
.deploy(nsr_msg
)
838 def instantiate_ns(self
, nsr
, xact
):
840 Instantiate NSR with the passed nsr id
842 yield from nsr
.instantiate(xact
)
845 def instantiate_vnf(self
, nsr
, vnfr
):
847 Instantiate NSR with the passed nsr id
849 openmano_nsr
= self
._openmano
_nsrs
[nsr
.id]
850 yield from openmano_nsr
.add_vnfr(vnfr
)
852 # Mark the VNFR as running
853 # TODO: Create a task to monitor nsr/vnfr status
854 vnfr_msg
= vnfr
.vnfr_msg
.deep_copy()
855 vnfr_msg
.operational_status
= "init"
857 self
._log
.debug("Attempting to publish openmano vnf: %s", vnfr_msg
)
858 with self
._dts
.transaction() as xact
:
859 yield from self
._publisher
.publish_vnfr(xact
, vnfr_msg
)
862 def instantiate_vl(self
, nsr
, vlr
):
864 Instantiate NSR with the passed nsr id
866 self
._log
.debug("Received instantiate VL for NSR {}; VLR {}".format(nsr
.id,vlr
))
867 openmano_nsr
= self
._openmano
_nsrs
[nsr
.id]
868 if openmano_nsr
._state
== OpenmanoNSRecordState
.RUNNING
:
869 yield from openmano_nsr
.create_vlr(vlr
)
871 yield from openmano_nsr
.add_vlr(vlr
)
874 def terminate_ns(self
, nsr
):
876 Terminate the network service
879 openmano_nsr
= self
._openmano
_nsrs
[nsr_id
]
880 yield from openmano_nsr
.terminate()
881 yield from openmano_nsr
.delete()
883 with self
._dts
.transaction() as xact
:
884 for vnfr
in openmano_nsr
.vnfrs
:
885 self
._log
.debug("Unpublishing VNFR: %s", vnfr
.vnfr
.vnfr_msg
)
886 yield from self
._publisher
.unpublish_vnfr(xact
, vnfr
.vnfr
.vnfr_msg
)
888 del self
._openmano
_nsrs
[nsr_id
]
891 def terminate_vnf(self
, vnfr
):
893 Terminate the network service
898 def terminate_vl(self
, vlr
):
900 Terminate the virtual link
902 self
._log
.debug("Received terminate VL for VLR {}".format(vlr
))
903 openmano_nsr
= self
._openmano
_nsrs
[vlr
._nsr
_id
]
904 yield from openmano_nsr
.remove_vlr(vlr
)