rwlaunchpad/plugins/rwnsm/rift/tasklets/rwnsmtasklet/openmano_nsm.py

   1
   2 #
   3 #   Copyright 2016 RIFT.IO Inc
   4 #
   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
   8 #
   9 #       http://www.apache.org/licenses/LICENSE-2.0
  10 #
  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.
  16 #
  17
  18 import asyncio
  19 import os
  20 import sys
  21 import time
  22 import yaml
  23
  24 import gi
  25 gi.require_version('RwDts', '1.0')
  26 gi.require_version('RwVnfrYang', '1.0')
  27 from gi.repository import (
  28     RwDts as rwdts,
  29     RwVnfrYang,
  30 )
  31
  32 import rift.openmano.rift2openmano as rift2openmano
  33 import rift.openmano.openmano_client as openmano_client
  34 from . import rwnsmplugin
  35
  36 import rift.tasklets
  37
  38 if sys.version_info < (3, 4, 4):
  39     asyncio.ensure_future = asyncio.async
  40
  41
  42 DUMP_OPENMANO_DIR = os.path.join(
  43         os.environ["RIFT_ARTIFACTS"],
  44         "openmano_descriptors"
  45         )
  46
  47
  48 def dump_openmano_descriptor(name, descriptor_str):
  49     filename = "{}_{}.yaml".format(
  50         time.strftime("%Y%m%d-%H%M%S"),
  51         name
  52         )
  53
  54     filepath = os.path.join(
  55             DUMP_OPENMANO_DIR,
  56             filename
  57             )
  58
  59     try:
  60         if not os.path.exists(DUMP_OPENMANO_DIR):
  61             os.makedirs(DUMP_OPENMANO_DIR)
  62
  63         with open(filepath, 'w') as hdl:
  64             hdl.write(descriptor_str)
  65
  66     except OSError as e:
  67         print("Failed to dump openmano descriptor: %s" % str(e))
  68
  69     return filepath
  70
  71 class VnfrConsoleOperdataDtsHandler(object):
  72     """ registers 'D,/vnfr:vnfr-console/vnfr:vnfr[id]/vdur[id]' and handles CRUD from DTS"""
  73     @property
  74     def vnfr_vdu_console_xpath(self):
  75         """ path for resource-mgr"""
  76         return ("D,/rw-vnfr:vnfr-console/rw-vnfr:vnfr[rw-vnfr:id='{}']/rw-vnfr:vdur[vnfr:id='{}']".format(self._vnfr_id,self._vdur_id))
  77
  78     def __init__(self, dts, log, loop, nsr, vnfr_id, vdur_id, vdu_id):
  79         self._dts = dts
  80         self._log = log
  81         self._loop = loop
  82         self._regh = None
  83         self._nsr = nsr
  84
  85         self._vnfr_id = vnfr_id
  86         self._vdur_id = vdur_id
  87         self._vdu_id = vdu_id
  88
  89     @asyncio.coroutine
  90     def register(self):
  91         """ Register for VNFR VDU Operational Data read from dts """
  92
  93         @asyncio.coroutine
  94         def on_prepare(xact_info, action, ks_path, msg):
  95             """ prepare callback from dts """
  96             xpath = ks_path.to_xpath(RwVnfrYang.get_schema())
  97             self._log.debug(
  98                 "Got VNFR VDU Opdata xact_info: %s, action: %s): %s:%s",
  99                 xact_info, action, xpath, msg
 100                 )
 101
 102             if action == rwdts.QueryAction.READ:
 103                 schema = RwVnfrYang.YangData_RwVnfr_VnfrConsole_Vnfr_Vdur.schema()
 104                 path_entry = schema.keyspec_to_entry(ks_path)
 105                 self._log.debug("VDU Opdata path is {}".format(path_entry))
 106
 107                 try:
 108                     console_url = yield from self._loop.run_in_executor(
 109                             None,
 110                             self._nsr._http_api.get_instance_vm_console_url,
 111                             self._nsr._nsr_uuid,
 112                             self._vdur_id
 113                             )
 114
 115                     self._log.debug("Got console response: %s for NSR ID %s vdur ID %s",
 116                                         console_url,
 117                                         self._nsr._nsr_uuid,
 118                                         self._vdur_id
 119                                        )
 120                     vdur_console = RwVnfrYang.YangData_RwVnfr_VnfrConsole_Vnfr_Vdur()
 121                     vdur_console.id = self._vdur_id
 122                     if console_url:
 123                         vdur_console.console_url = console_url
 124                     else:
 125                         vdur_console.console_url = 'none'
 126                     self._log.debug("Recevied console URL for vdu {} is {}".format(self._vdu_id,vdur_console))
 127                 except openmano_client.InstanceStatusError as e:
 128                     self._log.error("Could not get NS instance console URL: %s",
 129                                         str(e))
 130                     vdur_console = RwVnfrYang.YangData_RwVnfr_VnfrConsole_Vnfr_Vdur()
 131                     vdur_console.id = self._vdur_id
 132                     vdur_console.console_url = 'none'
 133
 134                 xact_info.respond_xpath(rsp_code=rwdts.XactRspCode.ACK,
 135                                             xpath=self.vnfr_vdu_console_xpath,
 136                                             msg=vdur_console)
 137             else:
 138                 #raise VnfRecordError("Not supported operation %s" % action)
 139                 self._log.error("Not supported operation %s" % action)
 140                 xact_info.respond_xpath(rsp_code=rwdts.XactRspCode.ACK)
 141                 return
 142
 143         self._log.debug("Registering for VNFR VDU using xpath: %s",
 144                         self.vnfr_vdu_console_xpath)
 145         hdl = rift.tasklets.DTS.RegistrationHandler(on_prepare=on_prepare,)
 146         with self._dts.group_create() as group:
 147             self._regh = group.register(xpath=self.vnfr_vdu_console_xpath,
 148                                         handler=hdl,
 149                                         flags=rwdts.Flag.PUBLISHER,
 150                                         )
 151
 152
 153
 154 class OpenmanoVnfr(object):
 155     def __init__(self, log, loop, cli_api, vnfr):
 156         self._log = log
 157         self._loop = loop
 158         self._cli_api = cli_api
 159         self._vnfr = vnfr
 160         self._vnfd_id = vnfr.vnfd.id
 161
 162         self._vnf_id = None
 163
 164         self._created = False
 165
 166     @property
 167     def vnfd(self):
 168         return rift2openmano.RiftVNFD(self._vnfr.vnfd)
 169
 170     @property
 171     def vnfr(self):
 172         return self._vnfr
 173
 174     @property
 175     def rift_vnfd_id(self):
 176         return self._vnfd_id
 177
 178     @property
 179     def openmano_vnfd_id(self):
 180         return self._vnf_id
 181
 182     @property
 183     def openmano_vnfd(self):
 184         self._log.debug("Converting vnfd %s from rift to openmano", self.vnfd.id)
 185         openmano_vnfd = rift2openmano.rift2openmano_vnfd(self.vnfd)
 186         return openmano_vnfd
 187
 188     @property
 189     def openmano_vnfd_yaml(self):
 190         return yaml.safe_dump(self.openmano_vnfd, default_flow_style=False)
 191
 192     @asyncio.coroutine
 193     def create(self):
 194         self._log.debug("Creating openmano vnfd")
 195         openmano_vnfd = self.openmano_vnfd
 196         name = openmano_vnfd["vnf"]["name"]
 197
 198         # If the name already exists, get the openmano vnfd id
 199         name_uuid_map = yield from self._loop.run_in_executor(
 200                     None,
 201                     self._cli_api.vnf_list,
 202                     )
 203
 204         if name in name_uuid_map:
 205             vnf_id = name_uuid_map[name]
 206             self._log.debug("Vnf already created.  Got existing openmano vnfd id: %s", vnf_id)
 207             self._vnf_id = vnf_id
 208             return
 209
 210         self._vnf_id, _ = yield from self._loop.run_in_executor(
 211                 None,
 212                 self._cli_api.vnf_create,
 213                 self.openmano_vnfd_yaml,
 214                 )
 215
 216         fpath = dump_openmano_descriptor(
 217            "{}_vnf".format(name),
 218            self.openmano_vnfd_yaml
 219            )
 220
 221         self._log.debug("Dumped Openmano VNF descriptor to: %s", fpath)
 222
 223         self._created = True
 224
 225     @asyncio.coroutine
 226     def delete(self):
 227         if not self._created:
 228             return
 229
 230         self._log.debug("Deleting openmano vnfd")
 231         if self._vnf_id is None:
 232             self._log.warning("Openmano vnf id not set.  Cannot delete.")
 233             return
 234
 235         yield from self._loop.run_in_executor(
 236                 None,
 237                 self._cli_api.vnf_delete,
 238                 self._vnf_id,
 239                 )
 240
 241
 242 class OpenmanoNsr(object):
 243     TIMEOUT_SECS = 120
 244
 245     def __init__(self, dts, log, loop, publisher, cli_api, http_api, nsd_msg, nsr_config_msg):
 246         self._dts = dts
 247         self._log = log
 248         self._loop = loop
 249         self._publisher = publisher
 250         self._cli_api = cli_api
 251         self._http_api = http_api
 252
 253         self._nsd_msg = nsd_msg
 254         self._nsr_config_msg = nsr_config_msg
 255
 256         self._vnfrs = []
 257         self._vdur_console_handler = {}
 258
 259         self._nsd_uuid = None
 260         self._nsr_uuid = None
 261
 262         self._created = False
 263
 264         self._monitor_task = None
 265
 266     @property
 267     def nsd(self):
 268         return rift2openmano.RiftNSD(self._nsd_msg)
 269
 270     @property
 271     def vnfds(self):
 272         return {v.rift_vnfd_id: v.vnfd for v in self._vnfrs}
 273
 274     @property
 275     def vnfrs(self):
 276         return self._vnfrs
 277
 278     @property
 279     def openmano_nsd_yaml(self):
 280         self._log.debug("Converting nsd %s from rift to openmano", self.nsd.id)
 281         openmano_nsd = rift2openmano.rift2openmano_nsd(self.nsd, self.vnfds)
 282         return yaml.safe_dump(openmano_nsd, default_flow_style=False)
 283
 284
 285     @property
 286     def openmano_instance_create_yaml(self):
 287         self._log.debug("Creating instance-scenario-create input file for nsd %s with name %s", self.nsd.id, self._nsr_config_msg.name)
 288         openmano_instance_create = {}
 289         openmano_instance_create["name"] = self._nsr_config_msg.name
 290         openmano_instance_create["description"] = self._nsr_config_msg.description
 291         openmano_instance_create["scenario"] = self._nsd_uuid
 292         if self._nsr_config_msg.has_field("om_datacenter"):
 293             openmano_instance_create["datacenter"] = self._nsr_config_msg.om_datacenter
 294         openmano_instance_create["networks"] = {}
 295         for vld_msg in self._nsd_msg.vld:
 296             if vld_msg.vim_network_name:
 297                 network = {}
 298                 network["name"] = vld_msg.name
 299                 network["netmap-use"] = vld_msg.vim_network_name
 300                 #network["datacenter"] = vld_msg.om_datacenter
 301                 openmano_instance_create["networks"][vld_msg.name] = network
 302
 303         return yaml.safe_dump(openmano_instance_create, default_flow_style=False)
 304
 305
 306     @asyncio.coroutine
 307     def add_vnfr(self, vnfr):
 308         vnfr = OpenmanoVnfr(self._log, self._loop, self._cli_api, vnfr)
 309         yield from vnfr.create()
 310         self._vnfrs.append(vnfr)
 311
 312     @asyncio.coroutine
 313     def delete(self):
 314         if not self._created:
 315             self._log.debug("NSD wasn't created.  Skipping delete.")
 316             return
 317
 318         self._log.debug("Deleting openmano nsr")
 319
 320         yield from self._loop.run_in_executor(
 321                None,
 322                self._cli_api.ns_delete,
 323                self._nsd_uuid,
 324                )
 325
 326         self._log.debug("Deleting openmano vnfrs")
 327         for vnfr in self._vnfrs:
 328             yield from vnfr.delete()
 329
 330     @asyncio.coroutine
 331     def create(self):
 332         self._log.debug("Creating openmano scenario")
 333         name_uuid_map = yield from self._loop.run_in_executor(
 334                 None,
 335                 self._cli_api.ns_list,
 336                 )
 337
 338         if self._nsd_msg.name in name_uuid_map:
 339             self._log.debug("Found existing openmano scenario")
 340             self._nsd_uuid = name_uuid_map[self._nsd_msg.name]
 341             return
 342
 343
 344         # Use the nsd uuid as the scenario name to rebind to existing
 345         # scenario on reload or to support muliple instances of the name
 346         # nsd
 347         self._nsd_uuid, _ = yield from self._loop.run_in_executor(
 348                 None,
 349                 self._cli_api.ns_create,
 350                 self.openmano_nsd_yaml,
 351                 self._nsd_msg.name
 352                 )
 353         fpath = dump_openmano_descriptor(
 354            "{}_nsd".format(self._nsd_msg.name),
 355            self.openmano_nsd_yaml,
 356            )
 357
 358         self._log.debug("Dumped Openmano NS descriptor to: %s", fpath)
 359
 360         self._created = True
 361
 362     @asyncio.coroutine
 363     def instance_monitor_task(self):
 364         self._log.debug("Starting Instance monitoring task")
 365
 366         start_time = time.time()
 367         active_vnfs = []
 368
 369         while True:
 370             yield from asyncio.sleep(1, loop=self._loop)
 371
 372             try:
 373                 instance_resp_json = yield from self._loop.run_in_executor(
 374                         None,
 375                         self._http_api.get_instance,
 376                         self._nsr_uuid,
 377                         )
 378
 379                 self._log.debug("Got instance response: %s for NSR ID %s",
 380                         instance_resp_json,
 381                         self._nsr_uuid)
 382
 383             except openmano_client.InstanceStatusError as e:
 384                 self._log.error("Could not get NS instance status: %s", str(e))
 385                 continue
 386
 387             def all_vms_active(vnf):
 388                 for vm in vnf["vms"]:
 389                     vm_status = vm["status"]
 390                     vm_uuid = vm["uuid"]
 391                     if vm_status != "ACTIVE":
 392                         self._log.debug("VM is not yet active: %s (status: %s)", vm_uuid, vm_status)
 393                         return False
 394
 395                 return True
 396
 397             def any_vm_active_nomgmtip(vnf):
 398                 for vm in vnf["vms"]:
 399                     vm_status = vm["status"]
 400                     vm_uuid = vm["uuid"]
 401                     if vm_status != "ACTIVE":
 402                         self._log.debug("VM is not yet active: %s (status: %s)", vm_uuid, vm_status)
 403                         return False
 404
 405                 return True
 406
 407             def any_vms_error(vnf):
 408                 for vm in vnf["vms"]:
 409                     vm_status = vm["status"]
 410                     vm_vim_info = vm["vim_info"]
 411                     vm_uuid = vm["uuid"]
 412                     if vm_status == "ERROR":
 413                         self._log.error("VM Error: %s (vim_info: %s)", vm_uuid, vm_vim_info)
 414                         return True
 415
 416                 return False
 417
 418             def get_vnf_ip_address(vnf):
 419                 if "ip_address" in vnf:
 420                     return vnf["ip_address"].strip()
 421                 return None
 422
 423             def get_ext_cp_info(vnf):
 424                 cp_info_list = []
 425                 for vm in vnf["vms"]:
 426                     if "interfaces" not in vm:
 427                         continue
 428
 429                     for intf in vm["interfaces"]:
 430                         if "external_name" not in intf:
 431                             continue
 432
 433                         if not intf["external_name"]:
 434                             continue
 435
 436                         ip_address = intf["ip_address"]
 437                         if ip_address is None:
 438                             ip_address = "0.0.0.0"
 439
 440                         cp_info_list.append((intf["external_name"], ip_address))
 441
 442                 return cp_info_list
 443
 444             def get_vnf_status(vnfr):
 445                 # When we create an openmano descriptor we use <name>__<idx>
 446                 # to come up with openmano constituent VNF name.  Use this
 447                 # knowledge to map the vnfr back.
 448                 openmano_vnfr_suffix = "__{}".format(
 449                         vnfr.vnfr.vnfr_msg.member_vnf_index_ref
 450                         )
 451
 452                 for vnf in instance_resp_json["vnfs"]:
 453                     if vnf["vnf_name"].endswith(openmano_vnfr_suffix):
 454                         return vnf
 455
 456                 self._log.warning("Could not find vnf status with name that ends with: %s",
 457                                   openmano_vnfr_suffix)
 458                 return None
 459
 460             for vnfr in self._vnfrs:
 461                 if vnfr in active_vnfs:
 462                     # Skipping, so we don't re-publish the same VNF message.
 463                     continue
 464
 465                 vnfr_msg = vnfr.vnfr.vnfr_msg.deep_copy()
 466                 vnfr_msg.operational_status = "init"
 467
 468                 try:
 469                     vnf_status = get_vnf_status(vnfr)
 470                     self._log.debug("Found VNF status: %s", vnf_status)
 471                     if vnf_status is None:
 472                         self._log.error("Could not find VNF status from openmano")
 473                         vnfr_msg.operational_status = "failed"
 474                         yield from self._publisher.publish_vnfr(None, vnfr_msg)
 475                         return
 476
 477                     # If there was a VNF that has a errored VM, then just fail the VNF and stop monitoring.
 478                     if any_vms_error(vnf_status):
 479                         self._log.debug("VM was found to be in error state.  Marking as failed.")
 480                         vnfr_msg.operational_status = "failed"
 481                         yield from self._publisher.publish_vnfr(None, vnfr_msg)
 482                         return
 483
 484                     if all_vms_active(vnf_status):
 485                         vnf_ip_address = get_vnf_ip_address(vnf_status)
 486
 487                         if vnf_ip_address is None:
 488                             self._log.warning("No IP address obtained "
 489                                     "for VNF: {}, will retry.".format(
 490                                         vnf_status['vnf_name']))
 491                             continue
 492
 493                         self._log.debug("All VMs in VNF are active.  Marking as running.")
 494                         vnfr_msg.operational_status = "running"
 495
 496                         self._log.debug("Got VNF ip address: %s", vnf_ip_address)
 497                         vnfr_msg.mgmt_interface.ip_address = vnf_ip_address
 498                         vnfr_msg.vnf_configuration.config_access.mgmt_ip_address = vnf_ip_address
 499
 500
 501                         for vm in vnf_status["vms"]:
 502                             if vm["uuid"] not in self._vdur_console_handler:
 503                                 vdur_console_handler = VnfrConsoleOperdataDtsHandler(self._dts, self._log, self._loop,
 504                                                     self, vnfr_msg.id,vm["uuid"],vm["name"])
 505                                 yield from vdur_console_handler.register()
 506                                 self._vdur_console_handler[vm["uuid"]] = vdur_console_handler
 507
 508                             vdur_msg = vnfr_msg.vdur.add()
 509                             vdur_msg.vim_id = vm["vim_vm_id"]
 510                             vdur_msg.id = vm["uuid"]
 511
 512                         # Add connection point information for the config manager
 513                         cp_info_list = get_ext_cp_info(vnf_status)
 514                         for (cp_name, cp_ip) in cp_info_list:
 515                             cp = vnfr_msg.connection_point.add()
 516                             cp.name = cp_name
 517                             cp.short_name = cp_name
 518                             cp.ip_address = cp_ip
 519
 520                         yield from self._publisher.publish_vnfr(None, vnfr_msg)
 521                         active_vnfs.append(vnfr)
 522
 523                     if (time.time() - start_time) > OpenmanoNsr.TIMEOUT_SECS:
 524                         self._log.error("NSR timed out before reaching running state")
 525                         vnfr_msg.operational_status = "failed"
 526                         yield from self._publisher.publish_vnfr(None, vnfr_msg)
 527                         return
 528
 529                 except Exception as e:
 530                     vnfr_msg.operational_status = "failed"
 531                     yield from self._publisher.publish_vnfr(None, vnfr_msg)
 532                     self._log.exception("Caught exception publishing vnfr info: %s", str(e))
 533                     return
 534
 535             if len(active_vnfs) == len(self._vnfrs):
 536                 self._log.info("All VNF's are active.  Exiting NSR monitoring task")
 537                 return
 538
 539     @asyncio.coroutine
 540     def deploy(self):
 541         if self._nsd_uuid is None:
 542             raise ValueError("Cannot deploy an uncreated nsd")
 543
 544         self._log.debug("Deploying openmano scenario")
 545
 546         name_uuid_map = yield from self._loop.run_in_executor(
 547                 None,
 548                 self._cli_api.ns_instance_list,
 549                 )
 550
 551         if self._nsr_config_msg.name in name_uuid_map:
 552             self._log.debug("Found existing instance with nsr name: %s", self._nsr_config_msg.name)
 553             self._nsr_uuid = name_uuid_map[self._nsr_config_msg.name]
 554         else:
 555             self._nsr_uuid = yield from self._loop.run_in_executor(
 556                     None,
 557                     self._cli_api.ns_instance_scenario_create,
 558                     self.openmano_instance_create_yaml)
 559
 560             fpath = dump_openmano_descriptor(
 561                "{}_instance_sce_create".format(self._nsr_config_msg.name),
 562                self.openmano_instance_create_yaml,
 563                )
 564
 565             self._log.debug("Dumped Openmano NS Scenario Cretae to: %s", fpath)
 566
 567
 568         self._monitor_task = asyncio.ensure_future(
 569                 self.instance_monitor_task(), loop=self._loop
 570                 )
 571
 572     @asyncio.coroutine
 573     def terminate(self):
 574
 575         for _,handler in  self._vdur_console_handler.items():
 576             handler._regh.deregister()
 577
 578         if self._nsr_uuid is None:
 579             self._log.warning("Cannot terminate an un-instantiated nsr")
 580             return
 581
 582         if self._monitor_task is not None:
 583             self._monitor_task.cancel()
 584             self._monitor_task = None
 585
 586         self._log.debug("Terminating openmano nsr")
 587         yield from self._loop.run_in_executor(
 588                None,
 589                self._cli_api.ns_terminate,
 590                self._nsr_uuid,
 591                )
 592
 593
 594 class OpenmanoNsPlugin(rwnsmplugin.NsmPluginBase):
 595     """
 596         RW Implentation of the NsmPluginBase
 597     """
 598     def __init__(self, dts, log, loop, publisher, ro_account):
 599         self._dts = dts
 600         self._log = log
 601         self._loop = loop
 602         self._publisher = publisher
 603
 604         self._cli_api = None
 605         self._http_api = None
 606         self._openmano_nsrs = {}
 607
 608         self._set_ro_account(ro_account)
 609
 610     def _set_ro_account(self, ro_account):
 611         self._log.debug("Setting openmano plugin cloud account: %s", ro_account)
 612         self._cli_api = openmano_client.OpenmanoCliAPI(
 613                 self.log,
 614                 ro_account.openmano.host,
 615                 ro_account.openmano.port,
 616                 ro_account.openmano.tenant_id,
 617                 )
 618
 619         self._http_api = openmano_client.OpenmanoHttpAPI(
 620                 self.log,
 621                 ro_account.openmano.host,
 622                 ro_account.openmano.port,
 623                 ro_account.openmano.tenant_id,
 624                 )
 625
 626     def create_nsr(self, nsr_config_msg, nsd_msg):
 627         """
 628         Create Network service record
 629         """
 630         openmano_nsr = OpenmanoNsr(
 631                 self._dts,
 632                 self._log,
 633                 self._loop,
 634                 self._publisher,
 635                 self._cli_api,
 636                 self._http_api,
 637                 nsd_msg,
 638                 nsr_config_msg
 639                 )
 640         self._openmano_nsrs[nsr_config_msg.id] = openmano_nsr
 641
 642     @asyncio.coroutine
 643     def deploy(self, nsr_msg):
 644         openmano_nsr = self._openmano_nsrs[nsr_msg.ns_instance_config_ref]
 645         yield from openmano_nsr.create()
 646         yield from openmano_nsr.deploy()
 647
 648     @asyncio.coroutine
 649     def instantiate_ns(self, nsr, xact):
 650         """
 651         Instantiate NSR with the passed nsr id
 652         """
 653         yield from nsr.instantiate(xact)
 654
 655     @asyncio.coroutine
 656     def instantiate_vnf(self, nsr, vnfr):
 657         """
 658         Instantiate NSR with the passed nsr id
 659         """
 660         openmano_nsr = self._openmano_nsrs[nsr.id]
 661         yield from openmano_nsr.add_vnfr(vnfr)
 662
 663         # Mark the VNFR as running
 664         # TODO: Create a task to monitor nsr/vnfr status
 665         vnfr_msg = vnfr.vnfr_msg.deep_copy()
 666         vnfr_msg.operational_status = "init"
 667
 668         self._log.debug("Attempting to publish openmano vnf: %s", vnfr_msg)
 669         with self._dts.transaction() as xact:
 670             yield from self._publisher.publish_vnfr(xact, vnfr_msg)
 671
 672     @asyncio.coroutine
 673     def instantiate_vl(self, nsr, vlr):
 674         """
 675         Instantiate NSR with the passed nsr id
 676         """
 677         pass
 678
 679     @asyncio.coroutine
 680     def terminate_ns(self, nsr):
 681         """
 682         Terminate the network service
 683         """
 684         nsr_id = nsr.id
 685         openmano_nsr = self._openmano_nsrs[nsr_id]
 686         yield from openmano_nsr.terminate()
 687         yield from openmano_nsr.delete()
 688
 689         with self._dts.transaction() as xact:
 690             for vnfr in openmano_nsr.vnfrs:
 691                 self._log.debug("Unpublishing VNFR: %s", vnfr.vnfr.vnfr_msg)
 692                 yield from self._publisher.unpublish_vnfr(xact, vnfr.vnfr.vnfr_msg)
 693
 694         del self._openmano_nsrs[nsr_id]
 695
 696     @asyncio.coroutine
 697     def terminate_vnf(self, vnfr):
 698         """
 699         Terminate the network service
 700         """
 701         pass
 702
 703     @asyncio.coroutine
 704     def terminate_vl(self, vlr):
 705         """
 706         Terminate the virtual link
 707         """
 708         pass
 709