osmclient/sol005/ns.py

   1 # Copyright 2018 Telefonica
   2 #
   3 # All Rights Reserved.
   4 #
   5 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   6 #    not use this file except in compliance with the License. You may obtain
   7 #    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, WITHOUT
  13 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  14 #    License for the specific language governing permissions and limitations
  15 #    under the License.
  16
  17 """
  18 OSM ns API handling
  19 """
  20
  21 from osmclient.common import utils
  22 from osmclient.common import wait as WaitForStatus
  23 from osmclient.common.exceptions import ClientException
  24 from osmclient.common.exceptions import NotFound
  25 import yaml
  26 import json
  27 import logging
  28
  29
  30 class Ns(object):
  31     def __init__(self, http=None, client=None):
  32         self._http = http
  33         self._client = client
  34         self._logger = logging.getLogger("osmclient")
  35         self._apiName = "/nslcm"
  36         self._apiVersion = "/v1"
  37         self._apiResource = "/ns_instances_content"
  38         self._apiBase = "{}{}{}".format(
  39             self._apiName, self._apiVersion, self._apiResource
  40         )
  41
  42     # NS '--wait' option
  43     def _wait(self, id, wait_time, deleteFlag=False):
  44         self._logger.debug("")
  45         # Endpoint to get operation status
  46         apiUrlStatus = "{}{}{}".format(
  47             self._apiName, self._apiVersion, "/ns_lcm_op_occs"
  48         )
  49         # Wait for status for NS instance creation/update/deletion
  50         if isinstance(wait_time, bool):
  51             wait_time = WaitForStatus.TIMEOUT_NS_OPERATION
  52         WaitForStatus.wait_for_status(
  53             "NS",
  54             str(id),
  55             wait_time,
  56             apiUrlStatus,
  57             self._http.get2_cmd,
  58             deleteFlag=deleteFlag,
  59         )
  60
  61     def list(self, filter=None):
  62         """Returns a list of NS"""
  63         self._logger.debug("")
  64         self._client.get_token()
  65         filter_string = ""
  66         if filter:
  67             filter_string = "?{}".format(filter)
  68         _, resp = self._http.get2_cmd("{}{}".format(self._apiBase, filter_string))
  69         if resp:
  70             return json.loads(resp)
  71         return list()
  72
  73     def get(self, name):
  74         """Returns an NS based on name or id"""
  75         self._logger.debug("")
  76         self._client.get_token()
  77         if utils.validate_uuid4(name):
  78             for ns in self.list():
  79                 if name == ns["_id"]:
  80                     return ns
  81         else:
  82             for ns in self.list():
  83                 if name == ns["name"]:
  84                     return ns
  85         raise NotFound("ns '{}' not found".format(name))
  86
  87     def get_individual(self, name):
  88         self._logger.debug("")
  89         self._client.get_token()
  90         ns_id = name
  91         if not utils.validate_uuid4(name):
  92             for ns in self.list():
  93                 if name == ns["name"]:
  94                     ns_id = ns["_id"]
  95                     break
  96         try:
  97             _, resp = self._http.get2_cmd("{}/{}".format(self._apiBase, ns_id))
  98             # resp = self._http.get_cmd('{}/{}/nsd_content'.format(self._apiBase, ns_id))
  99             # print(yaml.safe_dump(resp))
 100             if resp:
 101                 return json.loads(resp)
 102         except NotFound:
 103             raise NotFound("ns '{}' not found".format(name))
 104         raise NotFound("ns '{}' not found".format(name))
 105
 106     def delete(self, name, force=False, config=None, wait=False):
 107         """
 108         Deletes a Network Service (NS)
 109         :param name: name of network service
 110         :param force: set force. Direct deletion without cleaning at VIM
 111         :param config: parameters of deletion, as:
 112              autoremove: Bool (default True)
 113              timeout_ns_terminate: int
 114              skip_terminate_primitives: Bool (default False) to not exec the terminate primitives
 115         :param wait: Make synchronous. Wait until deletion is completed:
 116             False to not wait (by default), True to wait a standard time, or int (time to wait)
 117         :return: None. Exception if fail
 118         """
 119         self._logger.debug("")
 120         ns = self.get(name)
 121         querystring_list = []
 122         querystring = ""
 123         if config:
 124             ns_config = yaml.safe_load(config)
 125             querystring_list += ["{}={}".format(k, v) for k, v in ns_config.items()]
 126         if force:
 127             querystring_list.append("FORCE=True")
 128         if querystring_list:
 129             querystring = "?" + "&".join(querystring_list)
 130         http_code, resp = self._http.delete_cmd(
 131             "{}/{}{}".format(self._apiBase, ns["_id"], querystring)
 132         )
 133         # TODO change to use a POST self._http.post_cmd('{}/{}/terminate{}'.format(_apiBase, ns['_id'], querystring),
 134         #                                               postfields_dict=ns_config)
 135         # seting autoremove as True by default
 136         # print('HTTP CODE: {}'.format(http_code))
 137         # print('RESP: {}'.format(resp))
 138         if http_code == 202:
 139             if wait and resp:
 140                 resp = json.loads(resp)
 141                 # For the 'delete' operation, '_id' is used
 142                 self._wait(resp.get("_id"), wait, deleteFlag=True)
 143             else:
 144                 print("Deletion in progress")
 145         elif http_code == 204:
 146             print("Deleted")
 147         else:
 148             msg = resp or ""
 149             # if resp:
 150             #     try:
 151             #         msg = json.loads(resp)
 152             #     except ValueError:
 153             #         msg = resp
 154             raise ClientException("failed to delete ns {} - {}".format(name, msg))
 155
 156     def create(
 157         self,
 158         nsd_name,
 159         nsr_name,
 160         account,
 161         config=None,
 162         ssh_keys=None,
 163         description="default description",
 164         admin_status="ENABLED",
 165         wait=False,
 166         timeout=None,
 167     ):
 168         self._logger.debug("")
 169         self._client.get_token()
 170         nsd = self._client.nsd.get(nsd_name)
 171
 172         vim_account_id = {}
 173         wim_account_id = {}
 174
 175         def get_vim_account_id(vim_account):
 176             self._logger.debug("")
 177             if vim_account_id.get(vim_account):
 178                 return vim_account_id[vim_account]
 179             vim = self._client.vim.get(vim_account)
 180             if vim is None:
 181                 raise NotFound("cannot find vim account '{}'".format(vim_account))
 182             vim_account_id[vim_account] = vim["_id"]
 183             return vim["_id"]
 184
 185         def get_wim_account_id(wim_account):
 186             self._logger.debug("")
 187             # wim_account can be False (boolean) to indicate not use wim account
 188             if not isinstance(wim_account, str):
 189                 return wim_account
 190             if wim_account_id.get(wim_account):
 191                 return wim_account_id[wim_account]
 192             wim = self._client.wim.get(wim_account)
 193             if wim is None:
 194                 raise NotFound("cannot find wim account '{}'".format(wim_account))
 195             wim_account_id[wim_account] = wim["_id"]
 196             return wim["_id"]
 197
 198         vim_id = get_vim_account_id(account)
 199         ns = {}
 200         ns["nsdId"] = nsd["_id"]
 201         ns["nsName"] = nsr_name
 202         ns["nsDescription"] = description
 203         ns["vimAccountId"] = vim_id
 204         # ns['userdata'] = {}
 205         # ns['userdata']['key1']='value1'
 206         # ns['userdata']['key2']='value2'
 207
 208         if ssh_keys is not None:
 209             ns["ssh_keys"] = []
 210             for pubkeyfile in ssh_keys.split(","):
 211                 with open(pubkeyfile, "r") as f:
 212                     ns["ssh_keys"].append(f.read())
 213         if timeout:
 214             ns["timeout_ns_deploy"] = timeout
 215         if config:
 216             ns_config = yaml.safe_load(config)
 217             if "vim-network-name" in ns_config:
 218                 ns_config["vld"] = ns_config.pop("vim-network-name")
 219             if "vld" in ns_config:
 220                 if not isinstance(ns_config["vld"], list):
 221                     raise ClientException(
 222                         "Error at --config 'vld' must be a list of dictionaries"
 223                     )
 224                 for vld in ns_config["vld"]:
 225                     if not isinstance(vld, dict):
 226                         raise ClientException(
 227                             "Error at --config 'vld' must be a list of dictionaries"
 228                         )
 229                     if vld.get("vim-network-name"):
 230                         if isinstance(vld["vim-network-name"], dict):
 231                             vim_network_name_dict = {}
 232                             for vim_account, vim_net in vld["vim-network-name"].items():
 233                                 vim_network_name_dict[
 234                                     get_vim_account_id(vim_account)
 235                                 ] = vim_net
 236                             vld["vim-network-name"] = vim_network_name_dict
 237                     if "wim_account" in vld and vld["wim_account"] is not None:
 238                         vld["wimAccountId"] = get_wim_account_id(vld.pop("wim_account"))
 239             if "vnf" in ns_config:
 240                 for vnf in ns_config["vnf"]:
 241                     if vnf.get("vim_account"):
 242                         vnf["vimAccountId"] = get_vim_account_id(vnf.pop("vim_account"))
 243
 244             if "additionalParamsForNs" in ns_config:
 245                 if not isinstance(ns_config["additionalParamsForNs"], dict):
 246                     raise ClientException(
 247                         "Error at --config 'additionalParamsForNs' must be a dictionary"
 248                     )
 249             if "additionalParamsForVnf" in ns_config:
 250                 if not isinstance(ns_config["additionalParamsForVnf"], list):
 251                     raise ClientException(
 252                         "Error at --config 'additionalParamsForVnf' must be a list"
 253                     )
 254                 for additional_param_vnf in ns_config["additionalParamsForVnf"]:
 255                     if not isinstance(additional_param_vnf, dict):
 256                         raise ClientException(
 257                             "Error at --config 'additionalParamsForVnf' items must be dictionaries"
 258                         )
 259                     if not additional_param_vnf.get("member-vnf-index"):
 260                         raise ClientException(
 261                             "Error at --config 'additionalParamsForVnf' items must contain "
 262                             "'member-vnf-index'"
 263                         )
 264             if "wim_account" in ns_config:
 265                 wim_account = ns_config.pop("wim_account")
 266                 if wim_account is not None:
 267                     ns["wimAccountId"] = get_wim_account_id(wim_account)
 268             # rest of parameters without any transformation or checking
 269             # "timeout_ns_deploy"
 270             # "placement-engine"
 271             ns.update(ns_config)
 272
 273         # print(yaml.safe_dump(ns))
 274         try:
 275             self._apiResource = "/ns_instances_content"
 276             self._apiBase = "{}{}{}".format(
 277                 self._apiName, self._apiVersion, self._apiResource
 278             )
 279             headers = self._client._headers
 280             headers["Content-Type"] = "application/yaml"
 281             self._http.set_http_header(headers)
 282             http_code, resp = self._http.post_cmd(
 283                 endpoint=self._apiBase, postfields_dict=ns
 284             )
 285             # print('HTTP CODE: {}'.format(http_code))
 286             # print('RESP: {}'.format(resp))
 287             # if http_code in (200, 201, 202, 204):
 288             if resp:
 289                 resp = json.loads(resp)
 290             if not resp or "id" not in resp:
 291                 raise ClientException(
 292                     "unexpected response from server - {} ".format(resp)
 293                 )
 294             if wait:
 295                 # Wait for status for NS instance creation
 296                 self._wait(resp.get("nslcmop_id"), wait)
 297             print(resp["id"])
 298             return resp["id"]
 299             # else:
 300             #    msg = ""
 301             #    if resp:
 302             #        try:
 303             #            msg = json.loads(resp)
 304             #        except ValueError:
 305             #            msg = resp
 306             #    raise ClientException(msg)
 307         except ClientException as exc:
 308             message = "failed to create ns: {} nsd: {}\nerror:\n{}".format(
 309                 nsr_name, nsd_name, str(exc)
 310             )
 311             raise ClientException(message)
 312
 313     def list_op(self, name, filter=None):
 314         """Returns the list of operations of a NS"""
 315         self._logger.debug("")
 316         ns = self.get(name)
 317         try:
 318             self._apiResource = "/ns_lcm_op_occs"
 319             self._apiBase = "{}{}{}".format(
 320                 self._apiName, self._apiVersion, self._apiResource
 321             )
 322             filter_string = ""
 323             if filter:
 324                 filter_string = "&{}".format(filter)
 325             http_code, resp = self._http.get2_cmd(
 326                 "{}?nsInstanceId={}{}".format(self._apiBase, ns["_id"], filter_string)
 327             )
 328             # print('HTTP CODE: {}'.format(http_code))
 329             # print('RESP: {}'.format(resp))
 330             if http_code == 200:
 331                 if resp:
 332                     resp = json.loads(resp)
 333                     return resp
 334                 else:
 335                     raise ClientException("unexpected response from server")
 336             else:
 337                 msg = resp or ""
 338                 #    if resp:
 339                 #        try:
 340                 #            resp = json.loads(resp)
 341                 #            msg = resp['detail']
 342                 #        except ValueError:
 343                 #            msg = resp
 344                 raise ClientException(msg)
 345         except ClientException as exc:
 346             message = "failed to get operation list of NS {}:\nerror:\n{}".format(
 347                 name, str(exc)
 348             )
 349             raise ClientException(message)
 350
 351     def get_op(self, operationId):
 352         """Returns the status of an operation"""
 353         self._logger.debug("")
 354         self._client.get_token()
 355         try:
 356             self._apiResource = "/ns_lcm_op_occs"
 357             self._apiBase = "{}{}{}".format(
 358                 self._apiName, self._apiVersion, self._apiResource
 359             )
 360             http_code, resp = self._http.get2_cmd(
 361                 "{}/{}".format(self._apiBase, operationId)
 362             )
 363             # print('HTTP CODE: {}'.format(http_code))
 364             # print('RESP: {}'.format(resp))
 365             if http_code == 200:
 366                 if resp:
 367                     resp = json.loads(resp)
 368                     return resp
 369                 else:
 370                     raise ClientException("unexpected response from server")
 371             else:
 372                 msg = resp or ""
 373                 #    if resp:
 374                 #        try:
 375                 #            resp = json.loads(resp)
 376                 #            msg = resp['detail']
 377                 #        except ValueError:
 378                 #            msg = resp
 379                 raise ClientException(msg)
 380         except ClientException as exc:
 381             message = "failed to get status of operation {}:\nerror:\n{}".format(
 382                 operationId, str(exc)
 383             )
 384             raise ClientException(message)
 385
 386     def exec_op(
 387         self,
 388         name,
 389         op_name,
 390         op_data=None,
 391         wait=False,
 392     ):
 393         """Executes an operation on a NS"""
 394         self._logger.debug("")
 395         ns = self.get(name)
 396         try:
 397             ns = self.get(name)
 398             self._apiResource = "/ns_instances"
 399             self._apiBase = "{}{}{}".format(
 400                 self._apiName, self._apiVersion, self._apiResource
 401             )
 402             endpoint = "{}/{}/{}".format(self._apiBase, ns["_id"], op_name)
 403             # print('OP_NAME: {}'.format(op_name))
 404             # print('OP_DATA: {}'.format(json.dumps(op_data)))
 405             http_code, resp = self._http.post_cmd(
 406                 endpoint=endpoint, postfields_dict=op_data
 407             )
 408             # print('HTTP CODE: {}'.format(http_code))
 409             # print('RESP: {}'.format(resp))
 410             # if http_code in (200, 201, 202, 204):
 411             if resp:
 412                 resp = json.loads(resp)
 413             if not resp or "id" not in resp:
 414                 raise ClientException(
 415                     "unexpected response from server - {}".format(resp)
 416                 )
 417             if wait:
 418                 # Wait for status for NS instance action
 419                 # For the 'action' operation, 'id' is used
 420                 self._wait(resp.get("id"), wait)
 421             return resp["id"]
 422             # else:
 423             #    msg = ""
 424             #    if resp:
 425             #        try:
 426             #            msg = json.loads(resp)
 427             #        except ValueError:
 428             #            msg = resp
 429             #    raise ClientException(msg)
 430         except ClientException as exc:
 431             message = "failed to exec operation {}:\nerror:\n{}".format(name, str(exc))
 432             raise ClientException(message)
 433
 434     def scale_vnf(
 435         self,
 436         ns_name,
 437         vnf_name,
 438         scaling_group,
 439         scale_in,
 440         scale_out,
 441         wait=False,
 442         timeout=None,
 443     ):
 444         """Scales a VNF by adding/removing VDUs"""
 445         self._logger.debug("")
 446         self._client.get_token()
 447         try:
 448             op_data = {}
 449             op_data["scaleType"] = "SCALE_VNF"
 450             op_data["scaleVnfData"] = {}
 451             if scale_in and not scale_out:
 452                 op_data["scaleVnfData"]["scaleVnfType"] = "SCALE_IN"
 453             elif not scale_in and scale_out:
 454                 op_data["scaleVnfData"]["scaleVnfType"] = "SCALE_OUT"
 455             else:
 456                 raise ClientException("you must set either 'scale_in' or 'scale_out'")
 457             op_data["scaleVnfData"]["scaleByStepData"] = {
 458                 "member-vnf-index": vnf_name,
 459                 "scaling-group-descriptor": scaling_group,
 460             }
 461             if timeout:
 462                 op_data["timeout_ns_scale"] = timeout
 463             op_id = self.exec_op(ns_name, op_name="scale", op_data=op_data, wait=wait)
 464             print(str(op_id))
 465         except ClientException as exc:
 466             message = "failed to scale vnf {} of ns {}:\nerror:\n{}".format(
 467                 vnf_name, ns_name, str(exc)
 468             )
 469             raise ClientException(message)
 470
 471     def update(self, ns_name, data, wait=False):
 472         """Update NS instance.
 473
 474         This function calls the NBI in order to perform an update operation
 475         on a Network Service instance.
 476
 477         Args:
 478             ns_name: (str)
 479             data: (dict)
 480             wait: (boolean)
 481
 482         Returns:
 483             None
 484
 485         """
 486         self._logger.debug("")
 487         self._client.get_token()
 488         try:
 489             op_data = {"updateType": data.pop("updateType")}
 490
 491             # Check update parameters availability according to update type
 492             if op_data["updateType"] == "CHANGE_VNFPKG":
 493                 if not (
 494                     data["config"]["changeVnfPackageData"][0].get("vnfInstanceId")
 495                     and data["config"]["changeVnfPackageData"][0].get("vnfdId")
 496                 ):
 497                     raise ClientException("you must set both vnfInstanceId and vnfdId")
 498
 499             # Fill up op_data
 500             op_data["changeVnfPackageData"] = {}
 501             op_data["changeVnfPackageData"]["vnfInstanceId"] = data["config"][
 502                 "changeVnfPackageData"
 503             ][0].get("vnfInstanceId")
 504
 505             op_data["changeVnfPackageData"]["vnfdId"] = data["config"][
 506                 "changeVnfPackageData"
 507             ][0].get("vnfdId")
 508
 509             if data.get("timeout"):
 510                 op_data["timeout_ns_update"] = data["timeout"]
 511
 512             op_id = self.exec_op(ns_name, op_name="update", op_data=op_data, wait=wait)
 513             print(str(op_id))
 514
 515         except ClientException as exc:
 516             message = "failed to update ns {}:\nerror:\n{}".format(ns_name, str(exc))
 517             raise ClientException(message)
 518
 519     def create_alarm(self, alarm):
 520         self._logger.debug("")
 521         self._client.get_token()
 522         data = {}
 523         data["create_alarm_request"] = {}
 524         data["create_alarm_request"]["alarm_create_request"] = alarm
 525         try:
 526             http_code, resp = self._http.post_cmd(
 527                 endpoint="/test/message/alarm_request", postfields_dict=data
 528             )
 529             # print('HTTP CODE: {}'.format(http_code))
 530             # print('RESP: {}'.format(resp))
 531             # if http_code in (200, 201, 202, 204):
 532             #     resp = json.loads(resp)
 533             print("Alarm created")
 534             # else:
 535             #    msg = ""
 536             #    if resp:
 537             #        try:
 538             #            msg = json.loads(resp)
 539             #        except ValueError:
 540             #            msg = resp
 541             #    raise ClientException('error: code: {}, resp: {}'.format(
 542             #                          http_code, msg))
 543         except ClientException as exc:
 544             message = "failed to create alarm: alarm {}\n{}".format(alarm, str(exc))
 545             raise ClientException(message)
 546
 547     def delete_alarm(self, name):
 548         self._logger.debug("")
 549         self._client.get_token()
 550         data = {}
 551         data["delete_alarm_request"] = {}
 552         data["delete_alarm_request"]["alarm_delete_request"] = {}
 553         data["delete_alarm_request"]["alarm_delete_request"]["alarm_uuid"] = name
 554         try:
 555             http_code, resp = self._http.post_cmd(
 556                 endpoint="/test/message/alarm_request", postfields_dict=data
 557             )
 558             # print('HTTP CODE: {}'.format(http_code))
 559             # print('RESP: {}'.format(resp))
 560             # if http_code in (200, 201, 202, 204):
 561             #    resp = json.loads(resp)
 562             print("Alarm deleted")
 563             # else:
 564             #    msg = ""
 565             #    if resp:
 566             #        try:
 567             #            msg = json.loads(resp)
 568             #        except ValueError:
 569             #            msg = resp
 570             #    raise ClientException('error: code: {}, resp: {}'.format(
 571             #                          http_code, msg))
 572         except ClientException as exc:
 573             message = "failed to delete alarm: alarm {}\n{}".format(name, str(exc))
 574             raise ClientException(message)
 575
 576     def get_alarm(self, project_name=None, ns_id=None, uuid=None):
 577         self._client.get_token()
 578         try:
 579             self._apiName = "/nsfm"
 580             self._apiResource = "/alarms"
 581             self._apiBase = "{}{}{}".format(
 582                 self._apiName, self._apiVersion, self._apiResource
 583             )
 584             if uuid:
 585                 # if request is for any uuid
 586                 http_code, resp = self._http.get2_cmd(
 587                     "{}/{}".format(self._apiBase, uuid)
 588                 )
 589             if not uuid:
 590                 http_code, resp = self._http.get2_cmd(
 591                     "{}/{}/{}/{}".format(self._apiBase, uuid, project_name, ns_id)
 592                 )
 593             if http_code == 200:
 594                 if resp:
 595                     resp = json.loads(resp)
 596                     return resp
 597                 else:
 598                     raise ClientException("unexpected response from server")
 599             else:
 600                 msg = resp or ""
 601                 raise ClientException(msg)
 602         except ClientException as exc:
 603             message = "failed to get alarm :\nerror:\n{}".format(str(exc))
 604             raise ClientException(message)
 605
 606     def update_alarm(self, uuid, threshold=None, is_enable=None, wait=None):
 607         self._client.get_token()
 608         try:
 609             op_data = {}
 610             op_data["uuid"] = uuid
 611             op_data["threshold"] = threshold
 612             op_data["is_enable"] = is_enable
 613             self._apiName = "/nsfm"
 614             self._apiResource = "/alarms"
 615             self._apiBase = "{}{}{}".format(
 616                 self._apiName, self._apiVersion, self._apiResource
 617             )
 618             http_code, resp = self._http.patch_cmd(
 619                 endpoint="{}".format(self._apiBase), postfields_dict=op_data
 620             )
 621             if resp:
 622                 resp = json.loads(resp)
 623             print(resp)
 624             return resp
 625         except ClientException as exc:
 626             message = "failed to update alarm :\nerror:\n{}".format(str(exc))
 627             raise ClientException(message)
 628
 629     def export_metric(self, metric):
 630         self._logger.debug("")
 631         self._client.get_token()
 632         data = {}
 633         data["read_metric_data_request"] = metric
 634         try:
 635             http_code, resp = self._http.post_cmd(
 636                 endpoint="/test/message/metric_request", postfields_dict=data
 637             )
 638             # print('HTTP CODE: {}'.format(http_code))
 639             # print('RESP: {}'.format(resp))
 640             # if http_code in (200, 201, 202, 204):
 641             #    resp = json.loads(resp)
 642             return "Metric exported"
 643             # else:
 644             #    msg = ""
 645             #    if resp:
 646             #        try:
 647             #            msg = json.loads(resp)
 648             #        except ValueError:
 649             #            msg = resp
 650             #    raise ClientException('error: code: {}, resp: {}'.format(
 651             #                          http_code, msg))
 652         except ClientException as exc:
 653             message = "failed to export metric: metric {}\n{}".format(metric, str(exc))
 654             raise ClientException(message)
 655
 656     def get_field(self, ns_name, field):
 657         self._logger.debug("")
 658         nsr = self.get(ns_name)
 659         print(yaml.safe_dump(nsr))
 660         if nsr is None:
 661             raise NotFound("failed to retrieve ns {}".format(ns_name))
 662
 663         if field in nsr:
 664             return nsr[field]
 665
 666         raise NotFound("failed to find {} in ns {}".format(field, ns_name))
 667
 668     def heal(
 669         self,
 670         ns_name,
 671         heal_dict,
 672         wait=False,
 673         timeout=None,
 674     ):
 675         """Heals a NS"""
 676         self._logger.debug("")
 677         self._client.get_token()
 678         try:
 679             op_data = heal_dict
 680             if timeout:
 681                 op_data["timeout_ns_heal"] = timeout
 682             op_id = self.exec_op(ns_name, op_name="heal", op_data=op_data, wait=wait)
 683             print(str(op_id))
 684         except ClientException as exc:
 685             message = "failed to heal ns {}:\nerror:\n{}".format(ns_name, str(exc))
 686             raise ClientException(message)