osmclient/scripts/osm.py

   1 # Copyright 2017-2018 Sandvine
   2 # Copyright 2018 Telefonica
   3 #
   4 # All Rights Reserved.
   5 #
   6 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   7 #    not use this file except in compliance with the License. You may obtain
   8 #    a copy of the License at
   9 #
  10 #         http://www.apache.org/licenses/LICENSE-2.0
  11 #
  12 #    Unless required by applicable law or agreed to in writing, software
  13 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  14 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  15 #    License for the specific language governing permissions and limitations
  16 #    under the License.
  17 """
  18 OSM shell/cli
  19 """
  20
  21 import click
  22 from osmclient import client
  23 from osmclient.common.exceptions import ClientException, NotFound
  24 from osmclient.common.utils import validate_uuid4
  25 from prettytable import PrettyTable
  26 import yaml
  27 import json
  28 import time
  29 import pycurl
  30 import os
  31 import textwrap
  32 import pkg_resources
  33 import logging
  34 from datetime import datetime
  35 from typing import Any, Dict
  36
  37
  38 def wrap_text(text, width):
  39     wrapper = textwrap.TextWrapper(width=width)
  40     lines = text.splitlines()
  41     return "\n".join(map(wrapper.fill, lines))
  42
  43
  44 def trunc_text(text, length):
  45     if len(text) > length:
  46         return text[: (length - 3)] + "..."
  47     else:
  48         return text
  49
  50
  51 def check_client_version(obj, what, version="sol005"):
  52     """
  53     Checks the version of the client object and raises error if it not the expected.
  54
  55     :param obj: the client object
  56     :what: the function or command under evaluation (used when an error is raised)
  57     :return: -
  58     :raises ClientError: if the specified version does not match the client version
  59     """
  60     logger.debug("")
  61     fullclassname = obj.__module__ + "." + obj.__class__.__name__
  62     message = 'The following commands or options are only supported with the option "--sol005": {}'.format(
  63         what
  64     )
  65     if version == "v1":
  66         message = 'The following commands or options are not supported when using option "--sol005": {}'.format(
  67             what
  68         )
  69     if fullclassname != "osmclient.{}.client.Client".format(version):
  70         raise ClientException(message)
  71     return
  72
  73
  74 def get_project(project_list, item):
  75     # project_list = ctx.obj.project.list()
  76     item_project_list = item.get("_admin", {}).get("projects_read")
  77     project_id = "None"
  78     project_name = "None"
  79     if item_project_list:
  80         for p1 in item_project_list:
  81             project_id = p1
  82             for p2 in project_list:
  83                 if p2["_id"] == project_id:
  84                     project_name = p2["name"]
  85                     return project_id, project_name
  86     return project_id, project_name
  87
  88
  89 def get_vim_name(vim_list, vim_id):
  90     vim_name = "-"
  91     for v in vim_list:
  92         if v["uuid"] == vim_id:
  93             vim_name = v["name"]
  94             break
  95     return vim_name
  96
  97
  98 def create_config(config_file, json_string):
  99     """
 100     Combines a YAML or JSON file with a JSON string into a Python3 structure
 101     It loads the YAML or JSON file 'cfile' into a first dictionary.
 102     It loads the JSON string into a second dictionary.
 103     Then it updates the first dictionary with the info in the second dictionary.
 104     If the field is present in both cfile and cdict, the field in cdict prevails.
 105     If both cfile and cdict are None, it returns an empty dict (i.e. {})
 106     """
 107     config = {}
 108     if config_file:
 109         with open(config_file, "r") as cf:
 110             config = yaml.safe_load(cf.read())
 111     if json_string:
 112         cdict = yaml.safe_load(json_string)
 113         for k, v in cdict.items():
 114             config[k] = v
 115     return config
 116
 117
 118 @click.group(
 119     context_settings=dict(help_option_names=["-h", "--help"], max_content_width=160)
 120 )
 121 @click.option(
 122     "--hostname",
 123     default="127.0.0.1",
 124     envvar="OSM_HOSTNAME",
 125     help="hostname of server.  " + "Also can set OSM_HOSTNAME in environment",
 126 )
 127 @click.option(
 128     "--user",
 129     default=None,
 130     envvar="OSM_USER",
 131     help="user (defaults to admin). " + "Also can set OSM_USER in environment",
 132 )
 133 @click.option(
 134     "--password",
 135     default=None,
 136     envvar="OSM_PASSWORD",
 137     help="password (defaults to admin). " + "Also can set OSM_PASSWORD in environment",
 138 )
 139 @click.option(
 140     "--project",
 141     default=None,
 142     envvar="OSM_PROJECT",
 143     help="project (defaults to admin). " + "Also can set OSM_PROJECT in environment",
 144 )
 145 @click.option(
 146     "-v",
 147     "--verbose",
 148     count=True,
 149     help="increase verbosity (-v INFO, -vv VERBOSE, -vvv DEBUG)",
 150 )
 151 @click.option("--all-projects", default=None, is_flag=True, help="include all projects")
 152 @click.option(
 153     "--public/--no-public",
 154     default=None,
 155     help="flag for public items (packages, instances, VIM accounts, etc.)",
 156 )
 157 @click.option(
 158     "--project-domain-name",
 159     "project_domain_name",
 160     default=None,
 161     envvar="OSM_PROJECT_DOMAIN_NAME",
 162     help="project domain name for keystone authentication (default to None). "
 163     + "Also can set OSM_PROJECT_DOMAIN_NAME in environment",
 164 )
 165 @click.option(
 166     "--user-domain-name",
 167     "user_domain_name",
 168     default=None,
 169     envvar="OSM_USER_DOMAIN_NAME",
 170     help="user domain name for keystone authentication (default to None). "
 171     + "Also can set OSM_USER_DOMAIN_NAME in environment",
 172 )
 173 @click.pass_context
 174 def cli_osm(ctx, **kwargs):
 175     global logger
 176     hostname = kwargs.pop("hostname", None)
 177     if hostname is None:
 178         print(
 179             (
 180                 "either hostname option or OSM_HOSTNAME "
 181                 + "environment variable needs to be specified"
 182             )
 183         )
 184         exit(1)
 185     # Remove None values
 186     kwargs = {k: v for k, v in kwargs.items() if v is not None}
 187     sol005 = os.getenv("OSM_SOL005", True)
 188     ctx.obj = client.Client(host=hostname, sol005=sol005, **kwargs)
 189     logger = logging.getLogger("osmclient")
 190
 191
 192 ####################
 193 # LIST operations
 194 ####################
 195
 196
 197 @cli_osm.command(name="ns-list", short_help="list all NS instances")
 198 @click.option(
 199     "--filter",
 200     default=None,
 201     multiple=True,
 202     help="restricts the list to the NS instances matching the filter.",
 203 )
 204 @click.option(
 205     "--long",
 206     is_flag=True,
 207     help="get more details of the NS (project, vim, deployment status, configuration status.",
 208 )
 209 @click.pass_context
 210 def ns_list(ctx, filter, long):
 211     """list all NS instances
 212
 213     \b
 214     Options:
 215       --filter filterExpr    Restricts the list to the NS instances matching the filter
 216
 217     \b
 218     filterExpr consists of one or more strings formatted according to "simpleFilterExpr",
 219     concatenated using the "&" character:
 220
 221       \b
 222       filterExpr := <simpleFilterExpr>["&"<simpleFilterExpr>]*
 223       simpleFilterExpr := <attrName>["."<attrName>]*["."<op>]"="<value>[","<value>]*
 224       op := "eq" | "neq" | "gt" | "lt" | "gte" | "lte" | "cont" | "ncont"
 225       attrName := string
 226       value := scalar value
 227
 228     \b
 229     where:
 230       * zero or more occurrences
 231       ? zero or one occurrence
 232       [] grouping of expressions to be used with ? and *
 233       "" quotation marks for marking string constants
 234       <> name separator
 235
 236     \b
 237     "AttrName" is the name of one attribute in the data type that defines the representation
 238     of the resource. The dot (".") character in "simpleFilterExpr" allows concatenation of
 239     <attrName> entries to filter by attributes deeper in the hierarchy of a structured document.
 240     "Op" stands for the comparison operator. If the expression has concatenated <attrName>
 241     entries, it means that the operator "op" is applied to the attribute addressed by the last
 242     <attrName> entry included in the concatenation. All simple filter expressions are combined
 243     by the "AND" logical operator. In a concatenation of <attrName> entries in a <simpleFilterExpr>,
 244     the rightmost "attrName" entry in a "simpleFilterExpr" is called "leaf attribute". The
 245     concatenation of all "attrName" entries except the leaf attribute is called the "attribute
 246     prefix". If an attribute referenced in an expression is an array, an object that contains a
 247     corresponding array shall be considered to match the expression if any of the elements in the
 248     array matches all expressions that have the same attribute prefix.
 249
 250     \b
 251     Filter examples:
 252        --filter  admin-status=ENABLED
 253        --filter  nsd-ref=<NSD_NAME>
 254        --filter  nsd.vendor=<VENDOR>
 255        --filter  nsd.vendor=<VENDOR>&nsd-ref=<NSD_NAME>
 256        --filter  nsd.constituent-vnfd.vnfd-id-ref=<VNFD_NAME>
 257     """
 258
 259     def summarize_deployment_status(status_dict):
 260         # Nets
 261         summary = ""
 262         if not status_dict:
 263             return summary
 264         n_nets = 0
 265         status_nets = {}
 266         net_list = status_dict.get("nets", [])
 267         for net in net_list:
 268             n_nets += 1
 269             if net["status"] not in status_nets:
 270                 status_nets[net["status"]] = 1
 271             else:
 272                 status_nets[net["status"]] += 1
 273         message = "Nets: "
 274         for k, v in status_nets.items():
 275             message += "{}:{},".format(k, v)
 276         message += "TOTAL:{}".format(n_nets)
 277         summary += "{}".format(message)
 278         # VMs and VNFs
 279         n_vms = 0
 280         status_vms = {}
 281         status_vnfs = {}
 282         vnf_list = status_dict["vnfs"]
 283         for vnf in vnf_list:
 284             member_vnf_index = vnf["member_vnf_index"]
 285             if member_vnf_index not in status_vnfs:
 286                 status_vnfs[member_vnf_index] = {}
 287             for vm in vnf["vms"]:
 288                 n_vms += 1
 289                 if vm["status"] not in status_vms:
 290                     status_vms[vm["status"]] = 1
 291                 else:
 292                     status_vms[vm["status"]] += 1
 293                 if vm["status"] not in status_vnfs[member_vnf_index]:
 294                     status_vnfs[member_vnf_index][vm["status"]] = 1
 295                 else:
 296                     status_vnfs[member_vnf_index][vm["status"]] += 1
 297         message = "VMs: "
 298         for k, v in status_vms.items():
 299             message += "{}:{},".format(k, v)
 300         message += "TOTAL:{}".format(n_vms)
 301         summary += "\n{}".format(message)
 302         summary += "\nNFs:"
 303         for k, v in status_vnfs.items():
 304             total = 0
 305             message = "\n  {} VMs: ".format(k)
 306             for k2, v2 in v.items():
 307                 message += "{}:{},".format(k2, v2)
 308                 total += v2
 309             message += "TOTAL:{}".format(total)
 310         summary += message
 311         return summary
 312
 313     def summarize_config_status(ee_list):
 314         summary = ""
 315         if not ee_list:
 316             return summary
 317         n_ee = 0
 318         status_ee = {}
 319         for ee in ee_list:
 320             n_ee += 1
 321             if ee["elementType"] not in status_ee:
 322                 status_ee[ee["elementType"]] = {}
 323                 status_ee[ee["elementType"]][ee["status"]] = 1
 324                 continue
 325             if ee["status"] in status_ee[ee["elementType"]]:
 326                 status_ee[ee["elementType"]][ee["status"]] += 1
 327             else:
 328                 status_ee[ee["elementType"]][ee["status"]] = 1
 329         for elementType in ["KDU", "VDU", "PDU", "VNF", "NS"]:
 330             if elementType in status_ee:
 331                 message = ""
 332                 total = 0
 333                 for k, v in status_ee[elementType].items():
 334                     message += "{}:{},".format(k, v)
 335                     total += v
 336                 message += "TOTAL:{}\n".format(total)
 337                 summary += "{}: {}".format(elementType, message)
 338         summary += "TOTAL Exec. Env.: {}".format(n_ee)
 339         return summary
 340
 341     logger.debug("")
 342     if filter:
 343         check_client_version(ctx.obj, "--filter")
 344         filter = "&".join(filter)
 345         resp = ctx.obj.ns.list(filter)
 346     else:
 347         resp = ctx.obj.ns.list()
 348     if long:
 349         table = PrettyTable(
 350             [
 351                 "ns instance name",
 352                 "id",
 353                 "date",
 354                 "ns state",
 355                 "current operation",
 356                 "error details",
 357                 "project",
 358                 "vim (inst param)",
 359                 "deployment status",
 360                 "configuration status",
 361             ]
 362         )
 363         project_list = ctx.obj.project.list()
 364         try:
 365             vim_list = ctx.obj.vim.list()
 366         except Exception:
 367             vim_list = []
 368     else:
 369         table = PrettyTable(
 370             [
 371                 "ns instance name",
 372                 "id",
 373                 "date",
 374                 "ns state",
 375                 "current operation",
 376                 "error details",
 377             ]
 378         )
 379     for ns in resp:
 380         fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
 381         if fullclassname == "osmclient.sol005.client.Client":
 382             nsr = ns
 383             logger.debug("NS info: {}".format(nsr))
 384             nsr_name = nsr["name"]
 385             nsr_id = nsr["_id"]
 386             date = datetime.fromtimestamp(nsr["create-time"]).strftime(
 387                 "%Y-%m-%dT%H:%M:%S"
 388             )
 389             ns_state = nsr.get("nsState", nsr["_admin"]["nsState"])
 390             if long:
 391                 deployment_status = summarize_deployment_status(
 392                     nsr.get("deploymentStatus")
 393                 )
 394                 config_status = summarize_config_status(nsr.get("configurationStatus"))
 395                 project_id, project_name = get_project(project_list, nsr)
 396                 # project = '{} ({})'.format(project_name, project_id)
 397                 project = project_name
 398                 vim_id = nsr.get("datacenter")
 399                 vim_name = get_vim_name(vim_list, vim_id)
 400
 401                 # vim = '{} ({})'.format(vim_name, vim_id)
 402                 vim = vim_name
 403             if "currentOperation" in nsr:
 404                 current_operation = "{} ({})".format(
 405                     nsr["currentOperation"], nsr["currentOperationID"]
 406                 )
 407             else:
 408                 current_operation = "{} ({})".format(
 409                     nsr["_admin"].get("current-operation", "-"),
 410                     nsr["_admin"]["nslcmop"],
 411                 )
 412             error_details = "N/A"
 413             if (
 414                 ns_state == "BROKEN"
 415                 or ns_state == "DEGRADED"
 416                 or ("currentOperation" not in nsr and nsr.get("errorDescription"))
 417             ):
 418                 error_details = "{}\nDetail: {}".format(
 419                     nsr["errorDescription"], nsr["errorDetail"]
 420                 )
 421         else:
 422             nsopdata = ctx.obj.ns.get_opdata(ns["id"])
 423             nsr = nsopdata["nsr:nsr"]
 424             nsr_name = nsr["name-ref"]
 425             nsr_id = nsr["ns-instance-config-ref"]
 426             date = "-"
 427             project = "-"
 428             deployment_status = (
 429                 nsr["operational-status"]
 430                 if "operational-status" in nsr
 431                 else "Not found"
 432             )
 433             ns_state = deployment_status
 434             config_status = nsr.get("config-status", "Not found")
 435             current_operation = "Unknown"
 436             error_details = nsr.get("detailed-status", "Not found")
 437             if config_status == "config_not_needed":
 438                 config_status = "configured (no charms)"
 439
 440         if long:
 441             table.add_row(
 442                 [
 443                     nsr_name,
 444                     nsr_id,
 445                     date,
 446                     ns_state,
 447                     current_operation,
 448                     wrap_text(text=error_details, width=40),
 449                     project,
 450                     vim,
 451                     deployment_status,
 452                     config_status,
 453                 ]
 454             )
 455         else:
 456             table.add_row(
 457                 [
 458                     nsr_name,
 459                     nsr_id,
 460                     date,
 461                     ns_state,
 462                     current_operation,
 463                     wrap_text(text=error_details, width=40),
 464                 ]
 465             )
 466     table.align = "l"
 467     print(table)
 468     print('To get the history of all operations over a NS, run "osm ns-op-list NS_ID"')
 469     print(
 470         'For more details on the current operation, run "osm ns-op-show OPERATION_ID"'
 471     )
 472
 473
 474 def nsd_list(ctx, filter, long):
 475     logger.debug("")
 476     if filter:
 477         check_client_version(ctx.obj, "--filter")
 478         filter = "&".join(filter)
 479         resp = ctx.obj.nsd.list(filter)
 480     else:
 481         resp = ctx.obj.nsd.list()
 482     # print(yaml.safe_dump(resp))
 483     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
 484     if fullclassname == "osmclient.sol005.client.Client":
 485         if long:
 486             table = PrettyTable(
 487                 [
 488                     "nsd name",
 489                     "id",
 490                     "onboarding state",
 491                     "operational state",
 492                     "usage state",
 493                     "date",
 494                     "last update",
 495                 ]
 496             )
 497         else:
 498             table = PrettyTable(["nsd name", "id"])
 499         for nsd in resp:
 500             name = nsd.get("id", "-")
 501             if long:
 502                 onb_state = nsd["_admin"].get("onboardingState", "-")
 503                 op_state = nsd["_admin"].get("operationalState", "-")
 504                 usage_state = nsd["_admin"].get("usageState", "-")
 505                 date = datetime.fromtimestamp(nsd["_admin"]["created"]).strftime(
 506                     "%Y-%m-%dT%H:%M:%S"
 507                 )
 508                 last_update = datetime.fromtimestamp(
 509                     nsd["_admin"]["modified"]
 510                 ).strftime("%Y-%m-%dT%H:%M:%S")
 511                 table.add_row(
 512                     [
 513                         name,
 514                         nsd["_id"],
 515                         onb_state,
 516                         op_state,
 517                         usage_state,
 518                         date,
 519                         last_update,
 520                     ]
 521                 )
 522             else:
 523                 table.add_row([name, nsd["_id"]])
 524     else:
 525         table = PrettyTable(["nsd name", "id"])
 526         for nsd in resp:
 527             table.add_row([nsd["name"], nsd["id"]])
 528     table.align = "l"
 529     print(table)
 530
 531
 532 @cli_osm.command(name="nsd-list", short_help="list all NS packages")
 533 @click.option(
 534     "--filter",
 535     default=None,
 536     multiple=True,
 537     help="restricts the list to the NSD/NSpkg matching the filter",
 538 )
 539 @click.option("--long", is_flag=True, help="get more details")
 540 @click.pass_context
 541 def nsd_list1(ctx, filter, long):
 542     """list all NSD/NS pkg in the system"""
 543     logger.debug("")
 544     nsd_list(ctx, filter, long)
 545
 546
 547 @cli_osm.command(name="nspkg-list", short_help="list all NS packages")
 548 @click.option(
 549     "--filter",
 550     default=None,
 551     multiple=True,
 552     help="restricts the list to the NSD/NSpkg matching the filter",
 553 )
 554 @click.option("--long", is_flag=True, help="get more details")
 555 @click.pass_context
 556 def nsd_list2(ctx, filter, long):
 557     """list all NS packages"""
 558     logger.debug("")
 559     nsd_list(ctx, filter, long)
 560
 561
 562 def pkg_repo_list(ctx, pkgtype, filter, repo, long):
 563     resp = ctx.obj.osmrepo.pkg_list(pkgtype, filter, repo)
 564     if long:
 565         table = PrettyTable(
 566             ["nfpkg name", "vendor", "version", "latest", "description", "repository"]
 567         )
 568     else:
 569         table = PrettyTable(["nfpkg name", "repository"])
 570     for vnfd in resp:
 571         name = vnfd.get("id", vnfd.get("name", "-"))
 572         repository = vnfd.get("repository")
 573         if long:
 574             vendor = vnfd.get("provider", vnfd.get("vendor"))
 575             version = vnfd.get("version")
 576             description = vnfd.get("description")
 577             latest = vnfd.get("latest")
 578             table.add_row([name, vendor, version, latest, description, repository])
 579         else:
 580             table.add_row([name, repository])
 581         table.align = "l"
 582     print(table)
 583
 584
 585 def vnfd_list(ctx, nf_type, filter, long):
 586     logger.debug("")
 587     if nf_type:
 588         check_client_version(ctx.obj, "--nf_type")
 589     elif filter:
 590         check_client_version(ctx.obj, "--filter")
 591     if filter:
 592         filter = "&".join(filter)
 593     if nf_type:
 594         if nf_type == "vnf":
 595             nf_filter = "_admin.type=vnfd"
 596         elif nf_type == "pnf":
 597             nf_filter = "_admin.type=pnfd"
 598         elif nf_type == "hnf":
 599             nf_filter = "_admin.type=hnfd"
 600         else:
 601             raise ClientException(
 602                 'wrong value for "--nf_type" option, allowed values: vnf, pnf, hnf'
 603             )
 604         if filter:
 605             filter = "{}&{}".format(nf_filter, filter)
 606         else:
 607             filter = nf_filter
 608     if filter:
 609         resp = ctx.obj.vnfd.list(filter)
 610     else:
 611         resp = ctx.obj.vnfd.list()
 612     # print(yaml.safe_dump(resp))
 613     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
 614     if fullclassname == "osmclient.sol005.client.Client":
 615         if long:
 616             table = PrettyTable(
 617                 [
 618                     "nfpkg name",
 619                     "id",
 620                     "desc type",
 621                     "vendor",
 622                     "version",
 623                     "onboarding state",
 624                     "operational state",
 625                     "usage state",
 626                     "date",
 627                     "last update",
 628                 ]
 629             )
 630         else:
 631             table = PrettyTable(["nfpkg name", "id", "desc type"])
 632         for vnfd in resp:
 633             name = vnfd.get("id", vnfd.get("name", "-"))
 634             descriptor_type = "sol006" if "product-name" in vnfd else "rel8"
 635             if long:
 636                 onb_state = vnfd["_admin"].get("onboardingState", "-")
 637                 op_state = vnfd["_admin"].get("operationalState", "-")
 638                 vendor = vnfd.get("provider", vnfd.get("vendor"))
 639                 version = vnfd.get("version")
 640                 usage_state = vnfd["_admin"].get("usageState", "-")
 641                 date = datetime.fromtimestamp(vnfd["_admin"]["created"]).strftime(
 642                     "%Y-%m-%dT%H:%M:%S"
 643                 )
 644                 last_update = datetime.fromtimestamp(
 645                     vnfd["_admin"]["modified"]
 646                 ).strftime("%Y-%m-%dT%H:%M:%S")
 647                 table.add_row(
 648                     [
 649                         name,
 650                         vnfd["_id"],
 651                         descriptor_type,
 652                         vendor,
 653                         version,
 654                         onb_state,
 655                         op_state,
 656                         usage_state,
 657                         date,
 658                         last_update,
 659                     ]
 660                 )
 661             else:
 662                 table.add_row([name, vnfd["_id"], descriptor_type])
 663     else:
 664         table = PrettyTable(["nfpkg name", "id"])
 665         for vnfd in resp:
 666             table.add_row([vnfd["name"], vnfd["id"]])
 667     table.align = "l"
 668     print(table)
 669
 670
 671 @cli_osm.command(name="vnfd-list", short_help="list all xNF packages (VNF, HNF, PNF)")
 672 @click.option("--nf_type", help="type of NF (vnf, pnf, hnf)")
 673 @click.option(
 674     "--filter",
 675     default=None,
 676     multiple=True,
 677     help="restricts the list to the NF pkg matching the filter",
 678 )
 679 @click.option("--long", is_flag=True, help="get more details")
 680 @click.pass_context
 681 def vnfd_list1(ctx, nf_type, filter, long):
 682     """list all xNF packages (VNF, HNF, PNF)"""
 683     logger.debug("")
 684     vnfd_list(ctx, nf_type, filter, long)
 685
 686
 687 @cli_osm.command(name="vnfpkg-list", short_help="list all xNF packages (VNF, HNF, PNF)")
 688 @click.option("--nf_type", help="type of NF (vnf, pnf, hnf)")
 689 @click.option(
 690     "--filter",
 691     default=None,
 692     multiple=True,
 693     help="restricts the list to the NFpkg matching the filter",
 694 )
 695 @click.option("--long", is_flag=True, help="get more details")
 696 @click.pass_context
 697 def vnfd_list2(ctx, nf_type, filter, long):
 698     """list all xNF packages (VNF, HNF, PNF)"""
 699     logger.debug("")
 700     vnfd_list(ctx, nf_type, filter, long)
 701
 702
 703 @cli_osm.command(name="nfpkg-list", short_help="list all xNF packages (VNF, HNF, PNF)")
 704 @click.option("--nf_type", help="type of NF (vnf, pnf, hnf)")
 705 @click.option(
 706     "--filter",
 707     default=None,
 708     multiple=True,
 709     help="restricts the list to the NFpkg matching the filter",
 710 )
 711 @click.option("--long", is_flag=True, help="get more details")
 712 @click.pass_context
 713 def nfpkg_list(ctx, nf_type, filter, long):
 714     """list all xNF packages (VNF, HNF, PNF)"""
 715     logger.debug("")
 716     # try:
 717     check_client_version(ctx.obj, ctx.command.name)
 718     vnfd_list(ctx, nf_type, filter, long)
 719     # except ClientException as e:
 720     #     print(str(e))
 721     #     exit(1)
 722
 723
 724 @cli_osm.command(
 725     name="vnfpkg-repo-list", short_help="list all xNF from OSM repositories"
 726 )
 727 @click.option(
 728     "--filter",
 729     default=None,
 730     multiple=True,
 731     help="restricts the list to the NFpkg matching the filter",
 732 )
 733 @click.option(
 734     "--repo", default=None, help="restricts the list to a particular OSM repository"
 735 )
 736 @click.option("--long", is_flag=True, help="get more details")
 737 @click.pass_context
 738 def nfpkg_repo_list1(ctx, filter, repo, long):
 739     """list xNF packages from OSM repositories"""
 740     pkgtype = "vnf"
 741     pkg_repo_list(ctx, pkgtype, filter, repo, long)
 742
 743
 744 @cli_osm.command(
 745     name="nfpkg-repo-list", short_help="list all xNF from OSM repositories"
 746 )
 747 @click.option(
 748     "--filter",
 749     default=None,
 750     multiple=True,
 751     help="restricts the list to the NFpkg matching the filter",
 752 )
 753 @click.option(
 754     "--repo", default=None, help="restricts the list to a particular OSM repository"
 755 )
 756 @click.option("--long", is_flag=True, help="get more details")
 757 @click.pass_context
 758 def nfpkg_repo_list2(ctx, filter, repo, long):
 759     """list xNF packages from OSM repositories"""
 760     pkgtype = "vnf"
 761     pkg_repo_list(ctx, pkgtype, filter, repo, long)
 762
 763
 764 def vnf_list(ctx, ns, filter, long):
 765     # try:
 766     if ns or filter:
 767         if ns:
 768             check_client_version(ctx.obj, "--ns")
 769         if filter:
 770             filter = "&".join(filter)
 771             check_client_version(ctx.obj, "--filter")
 772         resp = ctx.obj.vnf.list(ns, filter)
 773     else:
 774         resp = ctx.obj.vnf.list()
 775     # except ClientException as e:
 776     #     print(str(e))
 777     #     exit(1)
 778     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
 779     if fullclassname == "osmclient.sol005.client.Client":
 780         field_names = [
 781             "vnf id",
 782             "name",
 783             "ns id",
 784             "vnf member index",
 785             "vnfd name",
 786             "vim account id",
 787             "ip address",
 788         ]
 789         if long:
 790             field_names = [
 791                 "vnf id",
 792                 "name",
 793                 "ns id",
 794                 "vnf member index",
 795                 "vnfd name",
 796                 "vim account id",
 797                 "ip address",
 798                 "date",
 799                 "last update",
 800             ]
 801         table = PrettyTable(field_names)
 802         for vnfr in resp:
 803             name = vnfr["name"] if "name" in vnfr else "-"
 804             new_row = [
 805                 vnfr["_id"],
 806                 name,
 807                 vnfr["nsr-id-ref"],
 808                 vnfr["member-vnf-index-ref"],
 809                 vnfr["vnfd-ref"],
 810                 vnfr["vim-account-id"],
 811                 vnfr["ip-address"],
 812             ]
 813             if long:
 814                 date = datetime.fromtimestamp(vnfr["_admin"]["created"]).strftime(
 815                     "%Y-%m-%dT%H:%M:%S"
 816                 )
 817                 last_update = datetime.fromtimestamp(
 818                     vnfr["_admin"]["modified"]
 819                 ).strftime("%Y-%m-%dT%H:%M:%S")
 820                 new_row.extend([date, last_update])
 821             table.add_row(new_row)
 822     else:
 823         table = PrettyTable(["vnf name", "id", "operational status", "config status"])
 824         for vnfr in resp:
 825             if "mgmt-interface" not in vnfr:
 826                 vnfr["mgmt-interface"] = {}
 827                 vnfr["mgmt-interface"]["ip-address"] = None
 828             table.add_row(
 829                 [
 830                     vnfr["name"],
 831                     vnfr["id"],
 832                     vnfr["operational-status"],
 833                     vnfr["config-status"],
 834                 ]
 835             )
 836     table.align = "l"
 837     print(table)
 838
 839
 840 @cli_osm.command(name="vnf-list", short_help="list all NF instances")
 841 @click.option(
 842     "--ns", default=None, help="NS instance id or name to restrict the NF list"
 843 )
 844 @click.option(
 845     "--filter",
 846     default=None,
 847     multiple=True,
 848     help="restricts the list to the NF instances matching the filter.",
 849 )
 850 @click.option("--long", is_flag=True, help="get more details")
 851 @click.pass_context
 852 def vnf_list1(ctx, ns, filter, long):
 853     """list all NF instances"""
 854     logger.debug("")
 855     vnf_list(ctx, ns, filter, long)
 856
 857
 858 @cli_osm.command(name="nsd-repo-list", short_help="list all NS from OSM repositories")
 859 @click.option(
 860     "--filter",
 861     default=None,
 862     multiple=True,
 863     help="restricts the list to the NS matching the filter",
 864 )
 865 @click.option(
 866     "--repo", default=None, help="restricts the list to a particular OSM repository"
 867 )
 868 @click.option("--long", is_flag=True, help="get more details")
 869 @click.pass_context
 870 def nspkg_repo_list(ctx, filter, repo, long):
 871     """list xNF packages from OSM repositories"""
 872     pkgtype = "ns"
 873     pkg_repo_list(ctx, pkgtype, filter, repo, long)
 874
 875
 876 @cli_osm.command(name="nspkg-repo-list", short_help="list all NS from OSM repositories")
 877 @click.option(
 878     "--filter",
 879     default=None,
 880     multiple=True,
 881     help="restricts the list to the NS matching the filter",
 882 )
 883 @click.option(
 884     "--repo", default=None, help="restricts the list to a particular OSM repository"
 885 )
 886 @click.option("--long", is_flag=True, help="get more details")
 887 @click.pass_context
 888 def nspkg_repo_list2(ctx, filter, repo, long):
 889     """list xNF packages from OSM repositories"""
 890     pkgtype = "ns"
 891     pkg_repo_list(ctx, pkgtype, filter, repo, long)
 892
 893
 894 @cli_osm.command(name="nf-list", short_help="list all NF instances")
 895 @click.option(
 896     "--ns", default=None, help="NS instance id or name to restrict the NF list"
 897 )
 898 @click.option(
 899     "--filter",
 900     default=None,
 901     multiple=True,
 902     help="restricts the list to the NF instances matching the filter.",
 903 )
 904 @click.option("--long", is_flag=True, help="get more details")
 905 @click.pass_context
 906 def nf_list(ctx, ns, filter, long):
 907     """list all NF instances
 908
 909     \b
 910     Options:
 911       --ns     TEXT           NS instance id or name to restrict the VNF list
 912       --filter filterExpr     Restricts the list to the VNF instances matching the filter
 913
 914     \b
 915     filterExpr consists of one or more strings formatted according to "simpleFilterExpr",
 916     concatenated using the "&" character:
 917
 918       \b
 919       filterExpr := <simpleFilterExpr>["&"<simpleFilterExpr>]*
 920       simpleFilterExpr := <attrName>["."<attrName>]*["."<op>]"="<value>[","<value>]*
 921       op := "eq" | "neq" | "gt" | "lt" | "gte" | "lte" | "cont" | "ncont"
 922       attrName := string
 923       value := scalar value
 924
 925     \b
 926     where:
 927       * zero or more occurrences
 928       ? zero or one occurrence
 929       [] grouping of expressions to be used with ? and *
 930       "" quotation marks for marking string constants
 931       <> name separator
 932
 933     \b
 934     "AttrName" is the name of one attribute in the data type that defines the representation
 935     of the resource. The dot (".") character in "simpleFilterExpr" allows concatenation of
 936     <attrName> entries to filter by attributes deeper in the hierarchy of a structured document.
 937     "Op" stands for the comparison operator. If the expression has concatenated <attrName>
 938     entries, it means that the operator "op" is applied to the attribute addressed by the last
 939     <attrName> entry included in the concatenation. All simple filter expressions are combined
 940     by the "AND" logical operator. In a concatenation of <attrName> entries in a <simpleFilterExpr>,
 941     the rightmost "attrName" entry in a "simpleFilterExpr" is called "leaf attribute". The
 942     concatenation of all "attrName" entries except the leaf attribute is called the "attribute
 943     prefix". If an attribute referenced in an expression is an array, an object that contains a
 944     corresponding array shall be considered to match the expression if any of the elements in the
 945     array matches all expressions that have the same attribute prefix.
 946
 947     \b
 948     Filter examples:
 949        --filter  vim-account-id=<VIM_ACCOUNT_ID>
 950        --filter  vnfd-ref=<VNFD_NAME>
 951        --filter  vdur.ip-address=<IP_ADDRESS>
 952        --filter  vnfd-ref=<VNFD_NAME>,vdur.ip-address=<IP_ADDRESS>
 953     """
 954     logger.debug("")
 955     vnf_list(ctx, ns, filter, long)
 956
 957
 958 @cli_osm.command(
 959     name="ns-op-list", short_help="shows the history of operations over a NS instance"
 960 )
 961 @click.argument("name")
 962 @click.option(
 963     "--long", is_flag=True, help="get more details of the NS operation (date, )."
 964 )
 965 @click.pass_context
 966 def ns_op_list(ctx, name, long):
 967     """shows the history of operations over a NS instance
 968
 969     NAME: name or ID of the NS instance
 970     """
 971
 972     def formatParams(params):
 973         if params["lcmOperationType"] == "instantiate":
 974             params.pop("nsDescription")
 975             params.pop("nsName")
 976             params.pop("nsdId")
 977             params.pop("nsr_id")
 978         elif params["lcmOperationType"] == "action":
 979             params.pop("primitive")
 980         params.pop("lcmOperationType")
 981         params.pop("nsInstanceId")
 982         return params
 983
 984     logger.debug("")
 985     # try:
 986     check_client_version(ctx.obj, ctx.command.name)
 987     resp = ctx.obj.ns.list_op(name)
 988     # except ClientException as e:
 989     #     print(str(e))
 990     #     exit(1)
 991
 992     if long:
 993         table = PrettyTable(
 994             [
 995                 "id",
 996                 "operation",
 997                 "action_name",
 998                 "operation_params",
 999                 "status",
1000                 "date",
1001                 "last update",
1002                 "detail",
1003             ]
1004         )
1005     else:
1006         table = PrettyTable(
1007             ["id", "operation", "action_name", "status", "date", "detail"]
1008         )
1009
1010     # print(yaml.safe_dump(resp))
1011     for op in resp:
1012         action_name = "N/A"
1013         if op["lcmOperationType"] == "action":
1014             action_name = op["operationParams"]["primitive"]
1015         detail = "-"
1016         if op["operationState"] == "PROCESSING":
1017             if op["queuePosition"] is not None and op["queuePosition"] > 0:
1018                 detail = "In queue. Current position: {}".format(op["queuePosition"])
1019             elif op["lcmOperationType"] in ("instantiate", "terminate"):
1020                 if op["stage"]:
1021                     detail = op["stage"]
1022         elif op["operationState"] in ("FAILED", "FAILED_TEMP"):
1023             detail = op.get("errorMessage", "-")
1024         date = datetime.fromtimestamp(op["startTime"]).strftime("%Y-%m-%dT%H:%M:%S")
1025         last_update = datetime.fromtimestamp(op["statusEnteredTime"]).strftime(
1026             "%Y-%m-%dT%H:%M:%S"
1027         )
1028         if long:
1029             table.add_row(
1030                 [
1031                     op["id"],
1032                     op["lcmOperationType"],
1033                     action_name,
1034                     wrap_text(
1035                         text=json.dumps(formatParams(op["operationParams"]), indent=2),
1036                         width=50,
1037                     ),
1038                     op["operationState"],
1039                     date,
1040                     last_update,
1041                     wrap_text(text=detail, width=50),
1042                 ]
1043             )
1044         else:
1045             table.add_row(
1046                 [
1047                     op["id"],
1048                     op["lcmOperationType"],
1049                     action_name,
1050                     op["operationState"],
1051                     date,
1052                     wrap_text(text=detail or "", width=50),
1053                 ]
1054             )
1055     table.align = "l"
1056     print(table)
1057
1058
1059 def nsi_list(ctx, filter):
1060     """list all Network Slice Instances"""
1061     logger.debug("")
1062     # try:
1063     check_client_version(ctx.obj, ctx.command.name)
1064     if filter:
1065         filter = "&".join(filter)
1066     resp = ctx.obj.nsi.list(filter)
1067     # except ClientException as e:
1068     #     print(str(e))
1069     #     exit(1)
1070     table = PrettyTable(
1071         [
1072             "netslice instance name",
1073             "id",
1074             "operational status",
1075             "config status",
1076             "detailed status",
1077         ]
1078     )
1079     for nsi in resp:
1080         nsi_name = nsi["name"]
1081         nsi_id = nsi["_id"]
1082         opstatus = (
1083             nsi["operational-status"] if "operational-status" in nsi else "Not found"
1084         )
1085         configstatus = nsi["config-status"] if "config-status" in nsi else "Not found"
1086         detailed_status = (
1087             nsi["detailed-status"] if "detailed-status" in nsi else "Not found"
1088         )
1089         if configstatus == "config_not_needed":
1090             configstatus = "configured (no charms)"
1091         table.add_row([nsi_name, nsi_id, opstatus, configstatus, detailed_status])
1092     table.align = "l"
1093     print(table)
1094
1095
1096 @cli_osm.command(name="nsi-list", short_help="list all Network Slice Instances (NSI)")
1097 @click.option(
1098     "--filter",
1099     default=None,
1100     multiple=True,
1101     help="restricts the list to the Network Slice Instances matching the filter",
1102 )
1103 @click.pass_context
1104 def nsi_list1(ctx, filter):
1105     """list all Network Slice Instances (NSI)"""
1106     logger.debug("")
1107     nsi_list(ctx, filter)
1108
1109
1110 @cli_osm.command(
1111     name="netslice-instance-list", short_help="list all Network Slice Instances (NSI)"
1112 )
1113 @click.option(
1114     "--filter",
1115     default=None,
1116     multiple=True,
1117     help="restricts the list to the Network Slice Instances matching the filter",
1118 )
1119 @click.pass_context
1120 def nsi_list2(ctx, filter):
1121     """list all Network Slice Instances (NSI)"""
1122     logger.debug("")
1123     nsi_list(ctx, filter)
1124
1125
1126 def nst_list(ctx, filter):
1127     logger.debug("")
1128     # try:
1129     check_client_version(ctx.obj, ctx.command.name)
1130     if filter:
1131         filter = "&".join(filter)
1132     resp = ctx.obj.nst.list(filter)
1133     # except ClientException as e:
1134     #     print(str(e))
1135     #     exit(1)
1136     # print(yaml.safe_dump(resp))
1137     table = PrettyTable(["nst name", "id"])
1138     for nst in resp:
1139         name = nst["name"] if "name" in nst else "-"
1140         table.add_row([name, nst["_id"]])
1141     table.align = "l"
1142     print(table)
1143
1144
1145 @cli_osm.command(name="nst-list", short_help="list all Network Slice Templates (NST)")
1146 @click.option(
1147     "--filter",
1148     default=None,
1149     multiple=True,
1150     help="restricts the list to the NST matching the filter",
1151 )
1152 @click.pass_context
1153 def nst_list1(ctx, filter):
1154     """list all Network Slice Templates (NST) in the system"""
1155     logger.debug("")
1156     nst_list(ctx, filter)
1157
1158
1159 @cli_osm.command(
1160     name="netslice-template-list", short_help="list all Network Slice Templates (NST)"
1161 )
1162 @click.option(
1163     "--filter",
1164     default=None,
1165     multiple=True,
1166     help="restricts the list to the NST matching the filter",
1167 )
1168 @click.pass_context
1169 def nst_list2(ctx, filter):
1170     """list all Network Slice Templates (NST) in the system"""
1171     logger.debug("")
1172     nst_list(ctx, filter)
1173
1174
1175 def nsi_op_list(ctx, name):
1176     logger.debug("")
1177     # try:
1178     check_client_version(ctx.obj, ctx.command.name)
1179     resp = ctx.obj.nsi.list_op(name)
1180     # except ClientException as e:
1181     #     print(str(e))
1182     #     exit(1)
1183     table = PrettyTable(["id", "operation", "status"])
1184     for op in resp:
1185         table.add_row([op["id"], op["lcmOperationType"], op["operationState"]])
1186     table.align = "l"
1187     print(table)
1188
1189
1190 @cli_osm.command(
1191     name="nsi-op-list",
1192     short_help="shows the history of operations over a Network Slice Instance (NSI)",
1193 )
1194 @click.argument("name")
1195 @click.pass_context
1196 def nsi_op_list1(ctx, name):
1197     """shows the history of operations over a Network Slice Instance (NSI)
1198
1199     NAME: name or ID of the Network Slice Instance
1200     """
1201     logger.debug("")
1202     nsi_op_list(ctx, name)
1203
1204
1205 @cli_osm.command(
1206     name="netslice-instance-op-list",
1207     short_help="shows the history of operations over a Network Slice Instance (NSI)",
1208 )
1209 @click.argument("name")
1210 @click.pass_context
1211 def nsi_op_list2(ctx, name):
1212     """shows the history of operations over a Network Slice Instance (NSI)
1213
1214     NAME: name or ID of the Network Slice Instance
1215     """
1216     logger.debug("")
1217     nsi_op_list(ctx, name)
1218
1219
1220 @cli_osm.command(name="pdu-list", short_help="list all Physical Deployment Units (PDU)")
1221 @click.option(
1222     "--filter",
1223     default=None,
1224     multiple=True,
1225     help="restricts the list to the Physical Deployment Units matching the filter",
1226 )
1227 @click.pass_context
1228 def pdu_list(ctx, filter):
1229     """list all Physical Deployment Units (PDU)"""
1230     logger.debug("")
1231     # try:
1232     check_client_version(ctx.obj, ctx.command.name)
1233     if filter:
1234         filter = "&".join(filter)
1235     resp = ctx.obj.pdu.list(filter)
1236     # except ClientException as e:
1237     #     print(str(e))
1238     #     exit(1)
1239     table = PrettyTable(["pdu name", "id", "type", "mgmt ip address"])
1240     for pdu in resp:
1241         pdu_name = pdu["name"]
1242         pdu_id = pdu["_id"]
1243         pdu_type = pdu["type"]
1244         pdu_ipaddress = "None"
1245         for iface in pdu["interfaces"]:
1246             if iface["mgmt"]:
1247                 pdu_ipaddress = iface["ip-address"]
1248                 break
1249         table.add_row([pdu_name, pdu_id, pdu_type, pdu_ipaddress])
1250     table.align = "l"
1251     print(table)
1252
1253
1254 ####################
1255 # SHOW operations
1256 ####################
1257
1258
1259 def nsd_show(ctx, name, literal):
1260     logger.debug("")
1261     # try:
1262     resp = ctx.obj.nsd.get(name)
1263     # resp = ctx.obj.nsd.get_individual(name)
1264     # except ClientException as e:
1265     #     print(str(e))
1266     #     exit(1)
1267
1268     if literal:
1269         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
1270         return
1271
1272     table = PrettyTable(["field", "value"])
1273     for k, v in list(resp.items()):
1274         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
1275     table.align = "l"
1276     print(table)
1277
1278
1279 @cli_osm.command(name="nsd-show", short_help="shows the details of a NS package")
1280 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1281 @click.argument("name")
1282 @click.pass_context
1283 def nsd_show1(ctx, name, literal):
1284     """shows the content of a NSD
1285
1286     NAME: name or ID of the NSD/NSpkg
1287     """
1288     logger.debug("")
1289     nsd_show(ctx, name, literal)
1290
1291
1292 @cli_osm.command(name="nspkg-show", short_help="shows the details of a NS package")
1293 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1294 @click.argument("name")
1295 @click.pass_context
1296 def nsd_show2(ctx, name, literal):
1297     """shows the content of a NSD
1298
1299     NAME: name or ID of the NSD/NSpkg
1300     """
1301     logger.debug("")
1302     nsd_show(ctx, name, literal)
1303
1304
1305 def vnfd_show(ctx, name, literal):
1306     logger.debug("")
1307     # try:
1308     resp = ctx.obj.vnfd.get(name)
1309     # resp = ctx.obj.vnfd.get_individual(name)
1310     # except ClientException as e:
1311     #     print(str(e))
1312     #     exit(1)
1313
1314     if literal:
1315         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
1316         return
1317
1318     table = PrettyTable(["field", "value"])
1319     for k, v in list(resp.items()):
1320         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
1321     table.align = "l"
1322     print(table)
1323
1324
1325 def pkg_repo_show(ctx, pkgtype, name, repo, version, filter, literal):
1326     logger.debug("")
1327     if filter:
1328         filter = "&".join(filter)
1329     # try:
1330     resp = ctx.obj.osmrepo.pkg_get(pkgtype, name, repo, version, filter)
1331
1332     if literal:
1333         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
1334         return
1335     pkgtype += "d"
1336     catalog = pkgtype + "-catalog"
1337     full_catalog = pkgtype + ":" + catalog
1338     if resp.get(catalog):
1339         resp = resp.pop(catalog)[pkgtype][0]
1340     elif resp.get(full_catalog):
1341         resp = resp.pop(full_catalog)[pkgtype][0]
1342
1343     table = PrettyTable(["field", "value"])
1344     for k, v in list(resp.items()):
1345         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
1346     table.align = "l"
1347     print(table)
1348
1349
1350 @cli_osm.command(name="vnfd-show", short_help="shows the details of a NF package")
1351 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1352 @click.argument("name")
1353 @click.pass_context
1354 def vnfd_show1(ctx, name, literal):
1355     """shows the content of a VNFD
1356
1357     NAME: name or ID of the VNFD/VNFpkg
1358     """
1359     logger.debug("")
1360     vnfd_show(ctx, name, literal)
1361
1362
1363 @cli_osm.command(name="vnfpkg-show", short_help="shows the details of a NF package")
1364 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1365 @click.argument("name")
1366 @click.pass_context
1367 def vnfd_show2(ctx, name, literal):
1368     """shows the content of a VNFD
1369
1370     NAME: name or ID of the VNFD/VNFpkg
1371     """
1372     logger.debug("")
1373     vnfd_show(ctx, name, literal)
1374
1375
1376 @cli_osm.command(
1377     name="vnfpkg-repo-show",
1378     short_help="shows the details of a NF package in an OSM repository",
1379 )
1380 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1381 @click.option("--repo", required=True, help="Repository name")
1382 @click.argument("name")
1383 @click.option("--filter", default=None, multiple=True, help="filter by fields")
1384 @click.option("--version", default="latest", help="package version")
1385 @click.pass_context
1386 def vnfd_show3(ctx, name, repo, version, literal=None, filter=None):
1387     """shows the content of a VNFD in a repository
1388
1389     NAME: name or ID of the VNFD/VNFpkg
1390     """
1391     pkgtype = "vnf"
1392     pkg_repo_show(ctx, pkgtype, name, repo, version, filter, literal)
1393
1394
1395 @cli_osm.command(
1396     name="nsd-repo-show",
1397     short_help="shows the details of a NS package in an OSM repository",
1398 )
1399 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1400 @click.option("--repo", required=True, help="Repository name")
1401 @click.argument("name")
1402 @click.option("--filter", default=None, multiple=True, help="filter by fields")
1403 @click.option("--version", default="latest", help="package version")
1404 @click.pass_context
1405 def nsd_repo_show(ctx, name, repo, version, literal=None, filter=None):
1406     """shows the content of a VNFD in a repository
1407
1408     NAME: name or ID of the VNFD/VNFpkg
1409     """
1410     pkgtype = "ns"
1411     pkg_repo_show(ctx, pkgtype, name, repo, version, filter, literal)
1412
1413
1414 @cli_osm.command(
1415     name="nspkg-repo-show",
1416     short_help="shows the details of a NS package in an OSM repository",
1417 )
1418 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1419 @click.option("--repo", required=True, help="Repository name")
1420 @click.argument("name")
1421 @click.option("--filter", default=None, multiple=True, help="filter by fields")
1422 @click.option("--version", default="latest", help="package version")
1423 @click.pass_context
1424 def nsd_repo_show2(ctx, name, repo, version, literal=None, filter=None):
1425     """shows the content of a VNFD in a repository
1426
1427     NAME: name or ID of the VNFD/VNFpkg
1428     """
1429     pkgtype = "ns"
1430     pkg_repo_show(ctx, pkgtype, name, repo, version, filter, literal)
1431
1432
1433 @cli_osm.command(name="nfpkg-show", short_help="shows the details of a NF package")
1434 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1435 @click.argument("name")
1436 @click.pass_context
1437 def nfpkg_show(ctx, name, literal):
1438     """shows the content of a NF Descriptor
1439
1440     NAME: name or ID of the NFpkg
1441     """
1442     logger.debug("")
1443     vnfd_show(ctx, name, literal)
1444
1445
1446 @cli_osm.command(
1447     name="nfpkg-repo-show",
1448     short_help="shows the details of a NF package in an OSM repository",
1449 )
1450 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1451 @click.option("--repo", required=True, help="Repository name")
1452 @click.argument("name")
1453 @click.option("--filter", default=None, multiple=True, help="filter by fields")
1454 @click.option("--version", default="latest", help="package version")
1455 @click.pass_context
1456 def vnfd_show4(ctx, name, repo, version, literal=None, filter=None):
1457     """shows the content of a VNFD in a repository
1458
1459     NAME: name or ID of the VNFD/VNFpkg
1460     """
1461     pkgtype = "vnf"
1462     pkg_repo_show(ctx, pkgtype, name, repo, version, filter, literal)
1463
1464
1465 @cli_osm.command(name="ns-show", short_help="shows the info of a NS instance")
1466 @click.argument("name")
1467 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1468 @click.option(
1469     "--filter",
1470     multiple=True,
1471     help="restricts the information to the fields in the filter",
1472 )
1473 @click.pass_context
1474 def ns_show(ctx, name, literal, filter):
1475     """shows the info of a NS instance
1476
1477     NAME: name or ID of the NS instance
1478     """
1479     logger.debug("")
1480     # try:
1481     ns = ctx.obj.ns.get(name)
1482     # except ClientException as e:
1483     #     print(str(e))
1484     #     exit(1)
1485
1486     if literal:
1487         print(yaml.safe_dump(ns, indent=4, default_flow_style=False))
1488         return
1489
1490     table = PrettyTable(["field", "value"])
1491
1492     for k, v in list(ns.items()):
1493         if not filter or k in filter:
1494             table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
1495
1496     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
1497     if fullclassname != "osmclient.sol005.client.Client":
1498         nsopdata = ctx.obj.ns.get_opdata(ns["id"])
1499         nsr_optdata = nsopdata["nsr:nsr"]
1500         for k, v in list(nsr_optdata.items()):
1501             if not filter or k in filter:
1502                 table.add_row([k, wrap_text(json.dumps(v, indent=2), width=100)])
1503     table.align = "l"
1504     print(table)
1505
1506
1507 @cli_osm.command(name="vnf-show", short_help="shows the info of a VNF instance")
1508 @click.argument("name")
1509 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1510 @click.option(
1511     "--filter",
1512     multiple=True,
1513     help="restricts the information to the fields in the filter",
1514 )
1515 @click.option("--kdu", default=None, help="KDU name (whose status will be shown)")
1516 @click.pass_context
1517 def vnf_show(ctx, name, literal, filter, kdu):
1518     """shows the info of a VNF instance
1519
1520     NAME: name or ID of the VNF instance
1521     """
1522
1523     def print_kdu_status(op_info_status):
1524         """print KDU status properly formatted"""
1525         try:
1526             op_status = yaml.safe_load(op_info_status)
1527             if (
1528                 "namespace" in op_status
1529                 and "info" in op_status
1530                 and "last_deployed" in op_status["info"]
1531                 and "status" in op_status["info"]
1532                 and "code" in op_status["info"]["status"]
1533                 and "resources" in op_status["info"]["status"]
1534                 and "seconds" in op_status["info"]["last_deployed"]
1535             ):
1536                 last_deployed_time = datetime.fromtimestamp(
1537                     op_status["info"]["last_deployed"]["seconds"]
1538                 ).strftime("%a %b %d %I:%M:%S %Y")
1539                 print("LAST DEPLOYED: {}".format(last_deployed_time))
1540                 print("NAMESPACE: {}".format(op_status["namespace"]))
1541                 status_code = "UNKNOWN"
1542                 if op_status["info"]["status"]["code"] == 1:
1543                     status_code = "DEPLOYED"
1544                 print("STATUS: {}".format(status_code))
1545                 print()
1546                 print("RESOURCES:")
1547                 print(op_status["info"]["status"]["resources"])
1548                 if "notes" in op_status["info"]["status"]:
1549                     print("NOTES:")
1550                     print(op_status["info"]["status"]["notes"])
1551             else:
1552                 print(op_info_status)
1553         except Exception:
1554             print(op_info_status)
1555
1556     logger.debug("")
1557     if kdu:
1558         if literal:
1559             raise ClientException(
1560                 '"--literal" option is incompatible with "--kdu" option'
1561             )
1562         if filter:
1563             raise ClientException(
1564                 '"--filter" option is incompatible with "--kdu" option'
1565             )
1566
1567     # try:
1568     check_client_version(ctx.obj, ctx.command.name)
1569     resp = ctx.obj.vnf.get(name)
1570
1571     if kdu:
1572         ns_id = resp["nsr-id-ref"]
1573         op_data = {}
1574         op_data["member_vnf_index"] = resp["member-vnf-index-ref"]
1575         op_data["kdu_name"] = kdu
1576         op_data["primitive"] = "status"
1577         op_data["primitive_params"] = {}
1578         op_id = ctx.obj.ns.exec_op(ns_id, op_name="action", op_data=op_data, wait=False)
1579         t = 0
1580         while t < 30:
1581             op_info = ctx.obj.ns.get_op(op_id)
1582             if op_info["operationState"] == "COMPLETED":
1583                 print_kdu_status(op_info["detailed-status"])
1584                 return
1585             time.sleep(5)
1586             t += 5
1587         print("Could not determine KDU status")
1588         return
1589
1590     if literal:
1591         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
1592         return
1593
1594     table = PrettyTable(["field", "value"])
1595     for k, v in list(resp.items()):
1596         if not filter or k in filter:
1597             table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
1598     table.align = "l"
1599     print(table)
1600     # except ClientException as e:
1601     #     print(str(e))
1602     #     exit(1)
1603
1604
1605 # @cli_osm.command(name='vnf-monitoring-show')
1606 # @click.argument('vnf_name')
1607 # @click.pass_context
1608 # def vnf_monitoring_show(ctx, vnf_name):
1609 #    try:
1610 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
1611 #        resp = ctx.obj.vnf.get_monitoring(vnf_name)
1612 #    except ClientException as e:
1613 #        print(str(e))
1614 #        exit(1)
1615 #
1616 #    table = PrettyTable(['vnf name', 'monitoring name', 'value', 'units'])
1617 #    if resp is not None:
1618 #        for monitor in resp:
1619 #            table.add_row(
1620 #                [vnf_name,
1621 #                 monitor['name'],
1622 #                    monitor['value-integer'],
1623 #                    monitor['units']])
1624 #    table.align = 'l'
1625 #    print(table)
1626
1627
1628 # @cli_osm.command(name='ns-monitoring-show')
1629 # @click.argument('ns_name')
1630 # @click.pass_context
1631 # def ns_monitoring_show(ctx, ns_name):
1632 #    try:
1633 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
1634 #        resp = ctx.obj.ns.get_monitoring(ns_name)
1635 #    except ClientException as e:
1636 #        print(str(e))
1637 #        exit(1)
1638 #
1639 #    table = PrettyTable(['vnf name', 'monitoring name', 'value', 'units'])
1640 #    for key, val in list(resp.items()):
1641 #        for monitor in val:
1642 #            table.add_row(
1643 #                [key,
1644 #                 monitor['name'],
1645 #                    monitor['value-integer'],
1646 #                    monitor['units']])
1647 #    table.align = 'l'
1648 #    print(table)
1649
1650
1651 @cli_osm.command(name="ns-op-show", short_help="shows the info of a NS operation")
1652 @click.argument("id")
1653 @click.option(
1654     "--filter",
1655     multiple=True,
1656     help="restricts the information to the fields in the filter",
1657 )
1658 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1659 @click.pass_context
1660 def ns_op_show(ctx, id, filter, literal):
1661     """shows the detailed info of a NS operation
1662
1663     ID: operation identifier
1664     """
1665     logger.debug("")
1666     # try:
1667     check_client_version(ctx.obj, ctx.command.name)
1668     op_info = ctx.obj.ns.get_op(id)
1669     # except ClientException as e:
1670     #     print(str(e))
1671     #     exit(1)
1672
1673     if literal:
1674         print(yaml.safe_dump(op_info, indent=4, default_flow_style=False))
1675         return
1676
1677     table = PrettyTable(["field", "value"])
1678     for k, v in list(op_info.items()):
1679         if not filter or k in filter:
1680             table.add_row([k, wrap_text(json.dumps(v, indent=2), 100)])
1681     table.align = "l"
1682     print(table)
1683
1684
1685 def nst_show(ctx, name, literal):
1686     logger.debug("")
1687     # try:
1688     check_client_version(ctx.obj, ctx.command.name)
1689     resp = ctx.obj.nst.get(name)
1690     # resp = ctx.obj.nst.get_individual(name)
1691     # except ClientException as e:
1692     #     print(str(e))
1693     #     exit(1)
1694
1695     if literal:
1696         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
1697         return
1698
1699     table = PrettyTable(["field", "value"])
1700     for k, v in list(resp.items()):
1701         table.add_row([k, wrap_text(json.dumps(v, indent=2), 100)])
1702     table.align = "l"
1703     print(table)
1704
1705
1706 @cli_osm.command(
1707     name="nst-show", short_help="shows the content of a Network Slice Template (NST)"
1708 )
1709 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1710 @click.argument("name")
1711 @click.pass_context
1712 def nst_show1(ctx, name, literal):
1713     """shows the content of a Network Slice Template (NST)
1714
1715     NAME: name or ID of the NST
1716     """
1717     logger.debug("")
1718     nst_show(ctx, name, literal)
1719
1720
1721 @cli_osm.command(
1722     name="netslice-template-show",
1723     short_help="shows the content of a Network Slice Template (NST)",
1724 )
1725 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1726 @click.argument("name")
1727 @click.pass_context
1728 def nst_show2(ctx, name, literal):
1729     """shows the content of a Network Slice Template (NST)
1730
1731     NAME: name or ID of the NST
1732     """
1733     logger.debug("")
1734     nst_show(ctx, name, literal)
1735
1736
1737 def nsi_show(ctx, name, literal, filter):
1738     logger.debug("")
1739     # try:
1740     check_client_version(ctx.obj, ctx.command.name)
1741     nsi = ctx.obj.nsi.get(name)
1742     # except ClientException as e:
1743     #     print(str(e))
1744     #     exit(1)
1745
1746     if literal:
1747         print(yaml.safe_dump(nsi, indent=4, default_flow_style=False))
1748         return
1749
1750     table = PrettyTable(["field", "value"])
1751
1752     for k, v in list(nsi.items()):
1753         if not filter or k in filter:
1754             table.add_row([k, json.dumps(v, indent=2)])
1755
1756     table.align = "l"
1757     print(table)
1758
1759
1760 @cli_osm.command(
1761     name="nsi-show", short_help="shows the content of a Network Slice Instance (NSI)"
1762 )
1763 @click.argument("name")
1764 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1765 @click.option(
1766     "--filter",
1767     multiple=True,
1768     help="restricts the information to the fields in the filter",
1769 )
1770 @click.pass_context
1771 def nsi_show1(ctx, name, literal, filter):
1772     """shows the content of a Network Slice Instance (NSI)
1773
1774     NAME: name or ID of the Network Slice Instance
1775     """
1776     logger.debug("")
1777     nsi_show(ctx, name, literal, filter)
1778
1779
1780 @cli_osm.command(
1781     name="netslice-instance-show",
1782     short_help="shows the content of a Network Slice Instance (NSI)",
1783 )
1784 @click.argument("name")
1785 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1786 @click.option(
1787     "--filter",
1788     multiple=True,
1789     help="restricts the information to the fields in the filter",
1790 )
1791 @click.pass_context
1792 def nsi_show2(ctx, name, literal, filter):
1793     """shows the content of a Network Slice Instance (NSI)
1794
1795     NAME: name or ID of the Network Slice Instance
1796     """
1797     logger.debug("")
1798     nsi_show(ctx, name, literal, filter)
1799
1800
1801 def nsi_op_show(ctx, id, filter):
1802     logger.debug("")
1803     # try:
1804     check_client_version(ctx.obj, ctx.command.name)
1805     op_info = ctx.obj.nsi.get_op(id)
1806     # except ClientException as e:
1807     #     print(str(e))
1808     #     exit(1)
1809
1810     table = PrettyTable(["field", "value"])
1811     for k, v in list(op_info.items()):
1812         if not filter or k in filter:
1813             table.add_row([k, json.dumps(v, indent=2)])
1814     table.align = "l"
1815     print(table)
1816
1817
1818 @cli_osm.command(
1819     name="nsi-op-show",
1820     short_help="shows the info of an operation over a Network Slice Instance(NSI)",
1821 )
1822 @click.argument("id")
1823 @click.option(
1824     "--filter",
1825     multiple=True,
1826     help="restricts the information to the fields in the filter",
1827 )
1828 @click.pass_context
1829 def nsi_op_show1(ctx, id, filter):
1830     """shows the info of an operation over a Network Slice Instance(NSI)
1831
1832     ID: operation identifier
1833     """
1834     logger.debug("")
1835     nsi_op_show(ctx, id, filter)
1836
1837
1838 @cli_osm.command(
1839     name="netslice-instance-op-show",
1840     short_help="shows the info of an operation over a Network Slice Instance(NSI)",
1841 )
1842 @click.argument("id")
1843 @click.option(
1844     "--filter",
1845     multiple=True,
1846     help="restricts the information to the fields in the filter",
1847 )
1848 @click.pass_context
1849 def nsi_op_show2(ctx, id, filter):
1850     """shows the info of an operation over a Network Slice Instance(NSI)
1851
1852     ID: operation identifier
1853     """
1854     logger.debug("")
1855     nsi_op_show(ctx, id, filter)
1856
1857
1858 @cli_osm.command(
1859     name="pdu-show", short_help="shows the content of a Physical Deployment Unit (PDU)"
1860 )
1861 @click.argument("name")
1862 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
1863 @click.option(
1864     "--filter",
1865     multiple=True,
1866     help="restricts the information to the fields in the filter",
1867 )
1868 @click.pass_context
1869 def pdu_show(ctx, name, literal, filter):
1870     """shows the content of a Physical Deployment Unit (PDU)
1871
1872     NAME: name or ID of the PDU
1873     """
1874     logger.debug("")
1875     # try:
1876     check_client_version(ctx.obj, ctx.command.name)
1877     pdu = ctx.obj.pdu.get(name)
1878     # except ClientException as e:
1879     #     print(str(e))
1880     #     exit(1)
1881
1882     if literal:
1883         print(yaml.safe_dump(pdu, indent=4, default_flow_style=False))
1884         return
1885
1886     table = PrettyTable(["field", "value"])
1887
1888     for k, v in list(pdu.items()):
1889         if not filter or k in filter:
1890             table.add_row([k, json.dumps(v, indent=2)])
1891
1892     table.align = "l"
1893     print(table)
1894
1895
1896 ####################
1897 # CREATE operations
1898 ####################
1899
1900
1901 def nsd_create(ctx, filename, overwrite, skip_charm_build, repo, vendor, version):
1902     logger.debug("")
1903     # try:
1904     check_client_version(ctx.obj, ctx.command.name)
1905     if repo:
1906         filename = ctx.obj.osmrepo.get_pkg("ns", filename, repo, vendor, version)
1907     ctx.obj.nsd.create(filename, overwrite=overwrite, skip_charm_build=skip_charm_build)
1908     # except ClientException as e:
1909     #     print(str(e))
1910     #     exit(1)
1911
1912
1913 @cli_osm.command(name="nsd-create", short_help="creates a new NSD/NSpkg")
1914 @click.argument("filename")
1915 @click.option(
1916     "--overwrite",
1917     "overwrite",
1918     default=None,  # hidden=True,
1919     help="Deprecated. Use override",
1920 )
1921 @click.option(
1922     "--override",
1923     "overwrite",
1924     default=None,
1925     help="overrides fields in descriptor, format: "
1926     '"key1.key2...=value[;key3...=value;...]"',
1927 )
1928 @click.option(
1929     "--skip-charm-build",
1930     default=False,
1931     is_flag=True,
1932     help="The charm will not be compiled, it is assumed to already exist",
1933 )
1934 @click.option("--repo", default=None, help="[repository]: Repository name")
1935 @click.option("--vendor", default=None, help="[repository]: filter by vendor]")
1936 @click.option(
1937     "--version",
1938     default="latest",
1939     help="[repository]: filter by version. Default: latest",
1940 )
1941 @click.pass_context
1942 def nsd_create1(ctx, filename, overwrite, skip_charm_build, repo, vendor, version):
1943     """onboards a new NSpkg (alias of nspkg-create) (TO BE DEPRECATED)
1944
1945     \b
1946     FILENAME: NF Package tar.gz file, NF Descriptor YAML file or NF Package folder
1947               If FILENAME is a file (NF Package tar.gz or NF Descriptor YAML), it is onboarded.
1948               If FILENAME is an NF Package folder, it is built and then onboarded.
1949     """
1950     logger.debug("")
1951     nsd_create(
1952         ctx,
1953         filename,
1954         overwrite=overwrite,
1955         skip_charm_build=skip_charm_build,
1956         repo=repo,
1957         vendor=vendor,
1958         version=version,
1959     )
1960
1961
1962 @cli_osm.command(name="nspkg-create", short_help="creates a new NSD/NSpkg")
1963 @click.argument("filename")
1964 @click.option(
1965     "--overwrite",
1966     "overwrite",
1967     default=None,  # hidden=True,
1968     help="Deprecated. Use override",
1969 )
1970 @click.option(
1971     "--override",
1972     "overwrite",
1973     default=None,
1974     help="overrides fields in descriptor, format: "
1975     '"key1.key2...=value[;key3...=value;...]"',
1976 )
1977 @click.option(
1978     "--skip-charm-build",
1979     default=False,
1980     is_flag=True,
1981     help="The charm will not be compiled, it is assumed to already exist",
1982 )
1983 @click.option("--repo", default=None, help="[repository]: Repository name")
1984 @click.option("--vendor", default=None, help="[repository]: filter by vendor]")
1985 @click.option(
1986     "--version",
1987     default="latest",
1988     help="[repository]: filter by version. Default: latest",
1989 )
1990 @click.pass_context
1991 def nsd_pkg_create(ctx, filename, overwrite, skip_charm_build, repo, vendor, version):
1992     """onboards a new NSpkg
1993     \b
1994     FILENAME: NF Package tar.gz file, NF Descriptor YAML file or NF Package folder
1995               If FILENAME is a file (NF Package tar.gz or NF Descriptor YAML), it is onboarded.
1996               If FILENAME is an NF Package folder, it is built and then onboarded.
1997     """
1998     logger.debug("")
1999     nsd_create(
2000         ctx,
2001         filename,
2002         overwrite=overwrite,
2003         skip_charm_build=skip_charm_build,
2004         repo=repo,
2005         vendor=vendor,
2006         version=version,
2007     )
2008
2009
2010 def vnfd_create(
2011     ctx,
2012     filename,
2013     overwrite,
2014     skip_charm_build,
2015     override_epa,
2016     override_nonepa,
2017     override_paravirt,
2018     repo,
2019     vendor,
2020     version,
2021 ):
2022     logger.debug("")
2023     # try:
2024     check_client_version(ctx.obj, ctx.command.name)
2025     if repo:
2026         filename = ctx.obj.osmrepo.get_pkg("vnf", filename, repo, vendor, version)
2027     ctx.obj.vnfd.create(
2028         filename,
2029         overwrite=overwrite,
2030         skip_charm_build=skip_charm_build,
2031         override_epa=override_epa,
2032         override_nonepa=override_nonepa,
2033         override_paravirt=override_paravirt,
2034     )
2035     # except ClientException as e:
2036     #     print(str(e))
2037     #     exit(1)
2038
2039
2040 @cli_osm.command(name="vnfd-create", short_help="creates a new VNFD/VNFpkg")
2041 @click.argument("filename")
2042 @click.option(
2043     "--overwrite", "overwrite", default=None, help="overwrite deprecated, use override"
2044 )
2045 @click.option(
2046     "--override",
2047     "overwrite",
2048     default=None,
2049     help="overrides fields in descriptor, format: "
2050     '"key1.key2...=value[;key3...=value;...]"',
2051 )
2052 @click.option(
2053     "--skip-charm-build",
2054     default=False,
2055     is_flag=True,
2056     help="The charm will not be compiled, it is assumed to already exist",
2057 )
2058 @click.option(
2059     "--override-epa",
2060     required=False,
2061     default=False,
2062     is_flag=True,
2063     help="adds guest-epa parameters to all VDU",
2064 )
2065 @click.option(
2066     "--override-nonepa",
2067     required=False,
2068     default=False,
2069     is_flag=True,
2070     help="removes all guest-epa parameters from all VDU",
2071 )
2072 @click.option(
2073     "--override-paravirt",
2074     required=False,
2075     default=False,
2076     is_flag=True,
2077     help="overrides all VDU interfaces to PARAVIRT",
2078 )
2079 @click.option("--repo", default=None, help="[repository]: Repository name")
2080 @click.option("--vendor", default=None, help="[repository]: filter by vendor]")
2081 @click.option(
2082     "--version",
2083     default="latest",
2084     help="[repository]: filter by version. Default: latest",
2085 )
2086 @click.pass_context
2087 def vnfd_create1(
2088     ctx,
2089     filename,
2090     overwrite,
2091     skip_charm_build,
2092     override_epa,
2093     override_nonepa,
2094     override_paravirt,
2095     repo,
2096     vendor,
2097     version,
2098 ):
2099     """creates a new VNFD/VNFpkg
2100     \b
2101     FILENAME: NF Package tar.gz file, NF Descriptor YAML file or NF Package folder
2102               If FILENAME is a file (NF Package tar.gz or NF Descriptor YAML), it is onboarded.
2103               If FILENAME is an NF Package folder, it is built and then onboarded.
2104     """
2105     logger.debug("")
2106     vnfd_create(
2107         ctx,
2108         filename,
2109         overwrite=overwrite,
2110         skip_charm_build=skip_charm_build,
2111         override_epa=override_epa,
2112         override_nonepa=override_nonepa,
2113         override_paravirt=override_paravirt,
2114         repo=repo,
2115         vendor=vendor,
2116         version=version,
2117     )
2118
2119
2120 @cli_osm.command(name="vnfpkg-create", short_help="creates a new VNFD/VNFpkg")
2121 @click.argument("filename")
2122 @click.option(
2123     "--overwrite",
2124     "overwrite",
2125     default=None,  # hidden=True,
2126     help="Deprecated. Use override",
2127 )
2128 @click.option(
2129     "--override",
2130     "overwrite",
2131     default=None,
2132     help="overrides fields in descriptor, format: "
2133     '"key1.key2...=value[;key3...=value;...]"',
2134 )
2135 @click.option(
2136     "--skip-charm-build",
2137     default=False,
2138     is_flag=True,
2139     help="The charm will not be compiled, it is assumed to already exist",
2140 )
2141 @click.option(
2142     "--override-epa",
2143     required=False,
2144     default=False,
2145     is_flag=True,
2146     help="adds guest-epa parameters to all VDU",
2147 )
2148 @click.option(
2149     "--override-nonepa",
2150     required=False,
2151     default=False,
2152     is_flag=True,
2153     help="removes all guest-epa parameters from all VDU",
2154 )
2155 @click.option(
2156     "--override-paravirt",
2157     required=False,
2158     default=False,
2159     is_flag=True,
2160     help="overrides all VDU interfaces to PARAVIRT",
2161 )
2162 @click.option("--repo", default=None, help="[repository]: Repository name")
2163 @click.option("--vendor", default=None, help="[repository]: filter by vendor]")
2164 @click.option(
2165     "--version",
2166     default="latest",
2167     help="[repository]: filter by version. Default: latest",
2168 )
2169 @click.pass_context
2170 def vnfd_create2(
2171     ctx,
2172     filename,
2173     overwrite,
2174     skip_charm_build,
2175     override_epa,
2176     override_nonepa,
2177     override_paravirt,
2178     repo,
2179     vendor,
2180     version,
2181 ):
2182     """creates a new VNFD/VNFpkg
2183     \b
2184     FILENAME: NF Package tar.gz file, NF Descriptor YAML file or NF Package folder
2185               If FILENAME is a file (NF Package tar.gz or NF Descriptor YAML), it is onboarded.
2186               If FILENAME is an NF Package folder, it is built and then onboarded.
2187     """
2188     logger.debug("")
2189     vnfd_create(
2190         ctx,
2191         filename,
2192         overwrite=overwrite,
2193         skip_charm_build=skip_charm_build,
2194         override_epa=override_epa,
2195         override_nonepa=override_nonepa,
2196         override_paravirt=override_paravirt,
2197         repo=repo,
2198         vendor=vendor,
2199         version=version,
2200     )
2201
2202
2203 @cli_osm.command(name="nfpkg-create", short_help="creates a new NFpkg")
2204 @click.argument("filename")
2205 @click.option(
2206     "--overwrite",
2207     "overwrite",
2208     default=None,  # hidden=True,
2209     help="Deprecated. Use override",
2210 )
2211 @click.option(
2212     "--override",
2213     "overwrite",
2214     default=None,
2215     help="overrides fields in descriptor, format: "
2216     '"key1.key2...=value[;key3...=value;...]"',
2217 )
2218 @click.option(
2219     "--skip-charm-build",
2220     default=False,
2221     is_flag=True,
2222     help="The charm will not be compiled, it is assumed to already exist",
2223 )
2224 @click.option(
2225     "--override-epa",
2226     required=False,
2227     default=False,
2228     is_flag=True,
2229     help="adds guest-epa parameters to all VDU",
2230 )
2231 @click.option(
2232     "--override-nonepa",
2233     required=False,
2234     default=False,
2235     is_flag=True,
2236     help="removes all guest-epa parameters from all VDU",
2237 )
2238 @click.option(
2239     "--override-paravirt",
2240     required=False,
2241     default=False,
2242     is_flag=True,
2243     help="overrides all VDU interfaces to PARAVIRT",
2244 )
2245 @click.option("--repo", default=None, help="[repository]: Repository name")
2246 @click.option("--vendor", default=None, help="[repository]: filter by vendor]")
2247 @click.option(
2248     "--version",
2249     default="latest",
2250     help="[repository]: filter by version. Default: latest",
2251 )
2252 @click.pass_context
2253 def nfpkg_create(
2254     ctx,
2255     filename,
2256     overwrite,
2257     skip_charm_build,
2258     override_epa,
2259     override_nonepa,
2260     override_paravirt,
2261     repo,
2262     vendor,
2263     version,
2264 ):
2265     """creates a new NFpkg
2266
2267     \b
2268     FILENAME: NF Package tar.gz file, NF Descriptor YAML file or NF Package folder
2269               If FILENAME is a file (NF Package tar.gz or NF Descriptor YAML), it is onboarded.
2270               If FILENAME is an NF Package folder, it is built and then onboarded.
2271     """
2272     logger.debug("")
2273     vnfd_create(
2274         ctx,
2275         filename,
2276         overwrite=overwrite,
2277         skip_charm_build=skip_charm_build,
2278         override_epa=override_epa,
2279         override_nonepa=override_nonepa,
2280         override_paravirt=override_paravirt,
2281         repo=repo,
2282         vendor=vendor,
2283         version=version,
2284     )
2285
2286
2287 @cli_osm.command(name="ns-create", short_help="creates a new Network Service instance")
2288 @click.option("--ns_name", prompt=True, help="name of the NS instance")
2289 @click.option("--nsd_name", prompt=True, help="name of the NS descriptor")
2290 @click.option(
2291     "--vim_account",
2292     prompt=True,
2293     help="default VIM account id or name for the deployment",
2294 )
2295 @click.option("--admin_status", default="ENABLED", help="administration status")
2296 @click.option(
2297     "--ssh_keys",
2298     default=None,
2299     help="comma separated list of public key files to inject to vnfs",
2300 )
2301 @click.option("--config", default=None, help="ns specific yaml configuration")
2302 @click.option("--config_file", default=None, help="ns specific yaml configuration file")
2303 @click.option(
2304     "--wait",
2305     required=False,
2306     default=False,
2307     is_flag=True,
2308     help="do not return the control immediately, but keep it "
2309     "until the operation is completed, or timeout",
2310 )
2311 @click.option("--timeout", default=None, help="ns deployment timeout")
2312 @click.pass_context
2313 def ns_create(
2314     ctx,
2315     nsd_name,
2316     ns_name,
2317     vim_account,
2318     admin_status,
2319     ssh_keys,
2320     config,
2321     config_file,
2322     wait,
2323     timeout,
2324 ):
2325     """creates a new NS instance"""
2326     logger.debug("")
2327     # try:
2328     if config_file:
2329         check_client_version(ctx.obj, "--config_file")
2330         if config:
2331             raise ClientException(
2332                 '"--config" option is incompatible with "--config_file" option'
2333             )
2334         with open(config_file, "r") as cf:
2335             config = cf.read()
2336     ctx.obj.ns.create(
2337         nsd_name,
2338         ns_name,
2339         config=config,
2340         ssh_keys=ssh_keys,
2341         account=vim_account,
2342         wait=wait,
2343         timeout=timeout,
2344     )
2345     # except ClientException as e:
2346     #     print(str(e))
2347     #     exit(1)
2348
2349
2350 def nst_create(ctx, filename, overwrite):
2351     logger.debug("")
2352     # try:
2353     check_client_version(ctx.obj, ctx.command.name)
2354     ctx.obj.nst.create(filename, overwrite)
2355     # except ClientException as e:
2356     #     print(str(e))
2357     #     exit(1)
2358
2359
2360 @cli_osm.command(
2361     name="nst-create", short_help="creates a new Network Slice Template (NST)"
2362 )
2363 @click.argument("filename")
2364 @click.option(
2365     "--overwrite",
2366     "overwrite",
2367     default=None,  # hidden=True,
2368     help="Deprecated. Use override",
2369 )
2370 @click.option(
2371     "--override",
2372     "overwrite",
2373     default=None,
2374     help="overrides fields in descriptor, format: "
2375     '"key1.key2...=value[;key3...=value;...]"',
2376 )
2377 @click.pass_context
2378 def nst_create1(ctx, filename, overwrite):
2379     """creates a new Network Slice Template (NST)
2380
2381     FILENAME: NST package folder, NST yaml file or NSTpkg tar.gz file
2382     """
2383     logger.debug("")
2384     nst_create(ctx, filename, overwrite)
2385
2386
2387 @cli_osm.command(
2388     name="netslice-template-create",
2389     short_help="creates a new Network Slice Template (NST)",
2390 )
2391 @click.argument("filename")
2392 @click.option(
2393     "--overwrite",
2394     "overwrite",
2395     default=None,  # hidden=True,
2396     help="Deprecated. Use override",
2397 )
2398 @click.option(
2399     "--override",
2400     "overwrite",
2401     default=None,
2402     help="overrides fields in descriptor, format: "
2403     '"key1.key2...=value[;key3...=value;...]"',
2404 )
2405 @click.pass_context
2406 def nst_create2(ctx, filename, overwrite):
2407     """creates a new Network Slice Template (NST)
2408
2409     FILENAME: NST yaml file or NSTpkg tar.gz file
2410     """
2411     logger.debug("")
2412     nst_create(ctx, filename, overwrite)
2413
2414
2415 def nsi_create(
2416     ctx, nst_name, nsi_name, vim_account, ssh_keys, config, config_file, wait
2417 ):
2418     """creates a new Network Slice Instance (NSI)"""
2419     logger.debug("")
2420     # try:
2421     check_client_version(ctx.obj, ctx.command.name)
2422     if config_file:
2423         if config:
2424             raise ClientException(
2425                 '"--config" option is incompatible with "--config_file" option'
2426             )
2427         with open(config_file, "r") as cf:
2428             config = cf.read()
2429     ctx.obj.nsi.create(
2430         nst_name,
2431         nsi_name,
2432         config=config,
2433         ssh_keys=ssh_keys,
2434         account=vim_account,
2435         wait=wait,
2436     )
2437     # except ClientException as e:
2438     #     print(str(e))
2439     #     exit(1)
2440
2441
2442 @cli_osm.command(name="nsi-create", short_help="creates a new Network Slice Instance")
2443 @click.option("--nsi_name", prompt=True, help="name of the Network Slice Instance")
2444 @click.option("--nst_name", prompt=True, help="name of the Network Slice Template")
2445 @click.option(
2446     "--vim_account",
2447     prompt=True,
2448     help="default VIM account id or name for the deployment",
2449 )
2450 @click.option(
2451     "--ssh_keys", default=None, help="comma separated list of keys to inject to vnfs"
2452 )
2453 @click.option(
2454     "--config",
2455     default=None,
2456     help="Netslice specific yaml configuration:\n"
2457     "netslice_subnet: [\n"
2458     "id: TEXT, vim_account: TEXT,\n"
2459     "vnf: [member-vnf-index: TEXT, vim_account: TEXT]\n"
2460     "vld: [name: TEXT, vim-network-name: TEXT or DICT with vim_account, vim_net entries]\n"
2461     "additionalParamsForNsi: {param: value, ...}\n"
2462     "additionalParamsForsubnet: [{id: SUBNET_ID, additionalParamsForNs: {}, additionalParamsForVnf: {}}]\n"
2463     "],\n"
2464     "netslice-vld: [name: TEXT, vim-network-name: TEXT or DICT with vim_account, vim_net entries]",
2465 )
2466 @click.option(
2467     "--config_file", default=None, help="nsi specific yaml configuration file"
2468 )
2469 @click.option(
2470     "--wait",
2471     required=False,
2472     default=False,
2473     is_flag=True,
2474     help="do not return the control immediately, but keep it "
2475     "until the operation is completed, or timeout",
2476 )
2477 @click.pass_context
2478 def nsi_create1(
2479     ctx, nst_name, nsi_name, vim_account, ssh_keys, config, config_file, wait
2480 ):
2481     """creates a new Network Slice Instance (NSI)"""
2482     logger.debug("")
2483     nsi_create(
2484         ctx, nst_name, nsi_name, vim_account, ssh_keys, config, config_file, wait=wait
2485     )
2486
2487
2488 @cli_osm.command(
2489     name="netslice-instance-create", short_help="creates a new Network Slice Instance"
2490 )
2491 @click.option("--nsi_name", prompt=True, help="name of the Network Slice Instance")
2492 @click.option("--nst_name", prompt=True, help="name of the Network Slice Template")
2493 @click.option(
2494     "--vim_account",
2495     prompt=True,
2496     help="default VIM account id or name for the deployment",
2497 )
2498 @click.option(
2499     "--ssh_keys", default=None, help="comma separated list of keys to inject to vnfs"
2500 )
2501 @click.option(
2502     "--config",
2503     default=None,
2504     help="Netslice specific yaml configuration:\n"
2505     "netslice_subnet: [\n"
2506     "id: TEXT, vim_account: TEXT,\n"
2507     "vnf: [member-vnf-index: TEXT, vim_account: TEXT]\n"
2508     "vld: [name: TEXT, vim-network-name: TEXT or DICT with vim_account, vim_net entries]"
2509     "],\n"
2510     "netslice-vld: [name: TEXT, vim-network-name: TEXT or DICT with vim_account, vim_net entries]",
2511 )
2512 @click.option(
2513     "--config_file", default=None, help="nsi specific yaml configuration file"
2514 )
2515 @click.option(
2516     "--wait",
2517     required=False,
2518     default=False,
2519     is_flag=True,
2520     help="do not return the control immediately, but keep it "
2521     "until the operation is completed, or timeout",
2522 )
2523 @click.pass_context
2524 def nsi_create2(
2525     ctx, nst_name, nsi_name, vim_account, ssh_keys, config, config_file, wait
2526 ):
2527     """creates a new Network Slice Instance (NSI)"""
2528     logger.debug("")
2529     nsi_create(
2530         ctx, nst_name, nsi_name, vim_account, ssh_keys, config, config_file, wait=wait
2531     )
2532
2533
2534 @cli_osm.command(
2535     name="pdu-create", short_help="adds a new Physical Deployment Unit to the catalog"
2536 )
2537 @click.option("--name", help="name of the Physical Deployment Unit")
2538 @click.option("--pdu_type", help="type of PDU (e.g. router, firewall, FW001)")
2539 @click.option(
2540     "--interface",
2541     help="interface(s) of the PDU: name=<NAME>,mgmt=<true|false>,ip-address=<IP_ADDRESS>"
2542     + "[,type=<overlay|underlay>][,mac-address=<MAC_ADDRESS>][,vim-network-name=<VIM_NET_NAME>]",
2543     multiple=True,
2544 )
2545 @click.option("--description", help="human readable description")
2546 @click.option(
2547     "--vim_account",
2548     help="list of VIM accounts (in the same VIM) that can reach this PDU\n"
2549     + "The format for multiple VIMs is --vim_account <vim_account_id_1> "
2550     + "--vim_account <vim_account_id_2> ... --vim_account <vim_account_id_N>",
2551     multiple=True,
2552 )
2553 @click.option(
2554     "--descriptor_file",
2555     default=None,
2556     help="PDU descriptor file (as an alternative to using the other arguments)",
2557 )
2558 @click.pass_context
2559 def pdu_create(
2560     ctx, name, pdu_type, interface, description, vim_account, descriptor_file
2561 ):
2562     """creates a new Physical Deployment Unit (PDU)"""
2563     logger.debug("")
2564
2565     check_client_version(ctx.obj, ctx.command.name)
2566
2567     pdu = create_pdu_dictionary(
2568         name, pdu_type, interface, description, vim_account, descriptor_file
2569     )
2570     ctx.obj.pdu.create(pdu)
2571
2572
2573 ########################
2574 # UPDATE PDU operation #
2575 ########################
2576
2577
2578 @cli_osm.command(
2579     name="pdu-update", short_help="updates a Physical Deployment Unit to the catalog"
2580 )
2581 @click.argument("name")
2582 @click.option("--newname", help="New name for the Physical Deployment Unit")
2583 @click.option("--pdu_type", help="type of PDU (e.g. router, firewall, FW001)")
2584 @click.option(
2585     "--interface",
2586     help="interface(s) of the PDU: name=<NAME>,mgmt=<true|false>,ip-address=<IP_ADDRESS>"
2587     + "[,type=<overlay|underlay>][,mac-address=<MAC_ADDRESS>][,vim-network-name=<VIM_NET_NAME>]",
2588     multiple=True,
2589 )
2590 @click.option("--description", help="human readable description")
2591 @click.option(
2592     "--vim_account",
2593     help="list of VIM accounts (in the same VIM) that can reach this PDU\n"
2594     + "The format for multiple VIMs is --vim_account <vim_account_id_1> "
2595     + "--vim_account <vim_account_id_2> ... --vim_account <vim_account_id_N>",
2596     multiple=True,
2597 )
2598 @click.option(
2599     "--descriptor_file",
2600     default=None,
2601     help="PDU descriptor file (as an alternative to using the other arguments)",
2602 )
2603 @click.pass_context
2604 def pdu_update(
2605     ctx, name, newname, pdu_type, interface, description, vim_account, descriptor_file
2606 ):
2607     """Updates a new Physical Deployment Unit (PDU)"""
2608     logger.debug("")
2609
2610     check_client_version(ctx.obj, ctx.command.name)
2611
2612     update = True
2613
2614     if not newname:
2615         newname = name
2616
2617     pdu = create_pdu_dictionary(
2618         newname, pdu_type, interface, description, vim_account, descriptor_file, update
2619     )
2620     ctx.obj.pdu.update(name, pdu)
2621
2622
2623 def create_pdu_dictionary(
2624     name, pdu_type, interface, description, vim_account, descriptor_file, update=False
2625 ):
2626
2627     logger.debug("")
2628     pdu = {}
2629
2630     if not descriptor_file:
2631         if not update:
2632             if not name:
2633                 raise ClientException(
2634                     'in absence of descriptor file, option "--name" is mandatory'
2635                 )
2636             if not pdu_type:
2637                 raise ClientException(
2638                     'in absence of descriptor file, option "--pdu_type" is mandatory'
2639                 )
2640             if not interface:
2641                 raise ClientException(
2642                     'in absence of descriptor file, option "--interface" is mandatory (at least once)'
2643                 )
2644             if not vim_account:
2645                 raise ClientException(
2646                     'in absence of descriptor file, option "--vim_account" is mandatory (at least once)'
2647                 )
2648     else:
2649         with open(descriptor_file, "r") as df:
2650             pdu = yaml.safe_load(df.read())
2651     if name:
2652         pdu["name"] = name
2653     if pdu_type:
2654         pdu["type"] = pdu_type
2655     if description:
2656         pdu["description"] = description
2657     if vim_account:
2658         pdu["vim_accounts"] = vim_account
2659     if interface:
2660         ifaces_list = []
2661         for iface in interface:
2662             new_iface = {k: v for k, v in [i.split("=") for i in iface.split(",")]}
2663             new_iface["mgmt"] = new_iface.get("mgmt", "false").lower() == "true"
2664             ifaces_list.append(new_iface)
2665         pdu["interfaces"] = ifaces_list
2666     return pdu
2667
2668
2669 ####################
2670 # UPDATE operations
2671 ####################
2672
2673
2674 def nsd_update(ctx, name, content):
2675     logger.debug("")
2676     # try:
2677     check_client_version(ctx.obj, ctx.command.name)
2678     ctx.obj.nsd.update(name, content)
2679     # except ClientException as e:
2680     #     print(str(e))
2681     #     exit(1)
2682
2683
2684 @cli_osm.command(name="nsd-update", short_help="updates a NSD/NSpkg")
2685 @click.argument("name")
2686 @click.option(
2687     "--content",
2688     default=None,
2689     help="filename with the NSD/NSpkg replacing the current one",
2690 )
2691 @click.pass_context
2692 def nsd_update1(ctx, name, content):
2693     """updates a NSD/NSpkg
2694
2695     NAME: name or ID of the NSD/NSpkg
2696     """
2697     logger.debug("")
2698     nsd_update(ctx, name, content)
2699
2700
2701 @cli_osm.command(name="nspkg-update", short_help="updates a NSD/NSpkg")
2702 @click.argument("name")
2703 @click.option(
2704     "--content",
2705     default=None,
2706     help="filename with the NSD/NSpkg replacing the current one",
2707 )
2708 @click.pass_context
2709 def nsd_update2(ctx, name, content):
2710     """updates a NSD/NSpkg
2711
2712     NAME: name or ID of the NSD/NSpkg
2713     """
2714     logger.debug("")
2715     nsd_update(ctx, name, content)
2716
2717
2718 def vnfd_update(ctx, name, content):
2719     logger.debug("")
2720     # try:
2721     check_client_version(ctx.obj, ctx.command.name)
2722     ctx.obj.vnfd.update(name, content)
2723     # except ClientException as e:
2724     #     print(str(e))
2725     #     exit(1)
2726
2727
2728 @cli_osm.command(name="vnfd-update", short_help="updates a new VNFD/VNFpkg")
2729 @click.argument("name")
2730 @click.option(
2731     "--content",
2732     default=None,
2733     help="filename with the VNFD/VNFpkg replacing the current one",
2734 )
2735 @click.pass_context
2736 def vnfd_update1(ctx, name, content):
2737     """updates a VNFD/VNFpkg
2738
2739     NAME: name or ID of the VNFD/VNFpkg
2740     """
2741     logger.debug("")
2742     vnfd_update(ctx, name, content)
2743
2744
2745 @cli_osm.command(name="vnfpkg-update", short_help="updates a VNFD/VNFpkg")
2746 @click.argument("name")
2747 @click.option(
2748     "--content",
2749     default=None,
2750     help="filename with the VNFD/VNFpkg replacing the current one",
2751 )
2752 @click.pass_context
2753 def vnfd_update2(ctx, name, content):
2754     """updates a VNFD/VNFpkg
2755
2756     NAME: VNFD yaml file or VNFpkg tar.gz file
2757     """
2758     logger.debug("")
2759     vnfd_update(ctx, name, content)
2760
2761
2762 @cli_osm.command(name="nfpkg-update", short_help="updates a NFpkg")
2763 @click.argument("name")
2764 @click.option(
2765     "--content", default=None, help="filename with the NFpkg replacing the current one"
2766 )
2767 @click.pass_context
2768 def nfpkg_update(ctx, name, content):
2769     """updates a NFpkg
2770
2771     NAME: NF Descriptor yaml file or NFpkg tar.gz file
2772     """
2773     logger.debug("")
2774     vnfd_update(ctx, name, content)
2775
2776
2777 def nst_update(ctx, name, content):
2778     logger.debug("")
2779     # try:
2780     check_client_version(ctx.obj, ctx.command.name)
2781     ctx.obj.nst.update(name, content)
2782     # except ClientException as e:
2783     #     print(str(e))
2784     #     exit(1)
2785
2786
2787 @cli_osm.command(name="nst-update", short_help="updates a Network Slice Template (NST)")
2788 @click.argument("name")
2789 @click.option(
2790     "--content",
2791     default=None,
2792     help="filename with the NST/NSTpkg replacing the current one",
2793 )
2794 @click.pass_context
2795 def nst_update1(ctx, name, content):
2796     """updates a Network Slice Template (NST)
2797
2798     NAME: name or ID of the NSD/NSpkg
2799     """
2800     logger.debug("")
2801     nst_update(ctx, name, content)
2802
2803
2804 @cli_osm.command(
2805     name="netslice-template-update", short_help="updates a Network Slice Template (NST)"
2806 )
2807 @click.argument("name")
2808 @click.option(
2809     "--content",
2810     default=None,
2811     help="filename with the NST/NSTpkg replacing the current one",
2812 )
2813 @click.pass_context
2814 def nst_update2(ctx, name, content):
2815     """updates a Network Slice Template (NST)
2816
2817     NAME: name or ID of the NSD/NSpkg
2818     """
2819     logger.debug("")
2820     nst_update(ctx, name, content)
2821
2822
2823 ####################
2824 # DELETE operations
2825 ####################
2826
2827
2828 def nsd_delete(ctx, name, force):
2829     logger.debug("")
2830     # try:
2831     if not force:
2832         ctx.obj.nsd.delete(name)
2833     else:
2834         check_client_version(ctx.obj, "--force")
2835         ctx.obj.nsd.delete(name, force)
2836     # except ClientException as e:
2837     #     print(str(e))
2838     #     exit(1)
2839
2840
2841 @cli_osm.command(name="nsd-delete", short_help="deletes a NSD/NSpkg")
2842 @click.argument("name")
2843 @click.option(
2844     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2845 )
2846 @click.pass_context
2847 def nsd_delete1(ctx, name, force):
2848     """deletes a NSD/NSpkg
2849
2850     NAME: name or ID of the NSD/NSpkg to be deleted
2851     """
2852     logger.debug("")
2853     nsd_delete(ctx, name, force)
2854
2855
2856 @cli_osm.command(name="nspkg-delete", short_help="deletes a NSD/NSpkg")
2857 @click.argument("name")
2858 @click.option(
2859     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2860 )
2861 @click.pass_context
2862 def nsd_delete2(ctx, name, force):
2863     """deletes a NSD/NSpkg
2864
2865     NAME: name or ID of the NSD/NSpkg to be deleted
2866     """
2867     logger.debug("")
2868     nsd_delete(ctx, name, force)
2869
2870
2871 def vnfd_delete(ctx, name, force):
2872     logger.debug("")
2873     # try:
2874     if not force:
2875         ctx.obj.vnfd.delete(name)
2876     else:
2877         check_client_version(ctx.obj, "--force")
2878         ctx.obj.vnfd.delete(name, force)
2879     # except ClientException as e:
2880     #     print(str(e))
2881     #     exit(1)
2882
2883
2884 @cli_osm.command(name="vnfd-delete", short_help="deletes a VNFD/VNFpkg")
2885 @click.argument("name")
2886 @click.option(
2887     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2888 )
2889 @click.pass_context
2890 def vnfd_delete1(ctx, name, force):
2891     """deletes a VNFD/VNFpkg
2892
2893     NAME: name or ID of the VNFD/VNFpkg to be deleted
2894     """
2895     logger.debug("")
2896     vnfd_delete(ctx, name, force)
2897
2898
2899 @cli_osm.command(name="vnfpkg-delete", short_help="deletes a VNFD/VNFpkg")
2900 @click.argument("name")
2901 @click.option(
2902     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2903 )
2904 @click.pass_context
2905 def vnfd_delete2(ctx, name, force):
2906     """deletes a VNFD/VNFpkg
2907
2908     NAME: name or ID of the VNFD/VNFpkg to be deleted
2909     """
2910     logger.debug("")
2911     vnfd_delete(ctx, name, force)
2912
2913
2914 @cli_osm.command(name="nfpkg-delete", short_help="deletes a NFpkg")
2915 @click.argument("name")
2916 @click.option(
2917     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2918 )
2919 @click.pass_context
2920 def nfpkg_delete(ctx, name, force):
2921     """deletes a NFpkg
2922
2923     NAME: name or ID of the NFpkg to be deleted
2924     """
2925     logger.debug("")
2926     vnfd_delete(ctx, name, force)
2927
2928
2929 @cli_osm.command(name="ns-delete", short_help="deletes a NS instance")
2930 @click.argument("name")
2931 @click.option(
2932     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2933 )
2934 @click.option(
2935     "--config",
2936     default=None,
2937     help="specific yaml configuration for the termination, e.g. '{autoremove: False, timeout_ns_terminate: "
2938     "600, skip_terminate_primitives: True}'",
2939 )
2940 @click.option(
2941     "--wait",
2942     required=False,
2943     default=False,
2944     is_flag=True,
2945     help="do not return the control immediately, but keep it "
2946     "until the operation is completed, or timeout",
2947 )
2948 @click.pass_context
2949 def ns_delete(ctx, name, force, config, wait):
2950     """deletes a NS instance
2951
2952     NAME: name or ID of the NS instance to be deleted
2953     """
2954     logger.debug("")
2955     # try:
2956     if not force:
2957         ctx.obj.ns.delete(name, config=config, wait=wait)
2958     else:
2959         check_client_version(ctx.obj, "--force")
2960         ctx.obj.ns.delete(name, force, config=config, wait=wait)
2961     # except ClientException as e:
2962     #     print(str(e))
2963     #     exit(1)
2964
2965
2966 def nst_delete(ctx, name, force):
2967     logger.debug("")
2968     # try:
2969     check_client_version(ctx.obj, ctx.command.name)
2970     ctx.obj.nst.delete(name, force)
2971     # except ClientException as e:
2972     #     print(str(e))
2973     #     exit(1)
2974
2975
2976 @cli_osm.command(name="nst-delete", short_help="deletes a Network Slice Template (NST)")
2977 @click.argument("name")
2978 @click.option(
2979     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2980 )
2981 @click.pass_context
2982 def nst_delete1(ctx, name, force):
2983     """deletes a Network Slice Template (NST)
2984
2985     NAME: name or ID of the NST/NSTpkg to be deleted
2986     """
2987     logger.debug("")
2988     nst_delete(ctx, name, force)
2989
2990
2991 @cli_osm.command(
2992     name="netslice-template-delete", short_help="deletes a Network Slice Template (NST)"
2993 )
2994 @click.argument("name")
2995 @click.option(
2996     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
2997 )
2998 @click.pass_context
2999 def nst_delete2(ctx, name, force):
3000     """deletes a Network Slice Template (NST)
3001
3002     NAME: name or ID of the NST/NSTpkg to be deleted
3003     """
3004     logger.debug("")
3005     nst_delete(ctx, name, force)
3006
3007
3008 def nsi_delete(ctx, name, force, wait):
3009     logger.debug("")
3010     # try:
3011     check_client_version(ctx.obj, ctx.command.name)
3012     ctx.obj.nsi.delete(name, force, wait=wait)
3013     # except ClientException as e:
3014     #     print(str(e))
3015     #     exit(1)
3016
3017
3018 @cli_osm.command(name="nsi-delete", short_help="deletes a Network Slice Instance (NSI)")
3019 @click.argument("name")
3020 @click.option(
3021     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3022 )
3023 @click.option(
3024     "--wait",
3025     required=False,
3026     default=False,
3027     is_flag=True,
3028     help="do not return the control immediately, but keep it "
3029     "until the operation is completed, or timeout",
3030 )
3031 @click.pass_context
3032 def nsi_delete1(ctx, name, force, wait):
3033     """deletes a Network Slice Instance (NSI)
3034
3035     NAME: name or ID of the Network Slice instance to be deleted
3036     """
3037     logger.debug("")
3038     nsi_delete(ctx, name, force, wait=wait)
3039
3040
3041 @cli_osm.command(
3042     name="netslice-instance-delete", short_help="deletes a Network Slice Instance (NSI)"
3043 )
3044 @click.argument("name")
3045 @click.option(
3046     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3047 )
3048 @click.pass_context
3049 def nsi_delete2(ctx, name, force, wait):
3050     """deletes a Network Slice Instance (NSI)
3051
3052     NAME: name or ID of the Network Slice instance to be deleted
3053     """
3054     logger.debug("")
3055     nsi_delete(ctx, name, force, wait=wait)
3056
3057
3058 @cli_osm.command(
3059     name="pdu-delete", short_help="deletes a Physical Deployment Unit (PDU)"
3060 )
3061 @click.argument("name")
3062 @click.option(
3063     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3064 )
3065 @click.pass_context
3066 def pdu_delete(ctx, name, force):
3067     """deletes a Physical Deployment Unit (PDU)
3068
3069     NAME: name or ID of the PDU to be deleted
3070     """
3071     logger.debug("")
3072     # try:
3073     check_client_version(ctx.obj, ctx.command.name)
3074     ctx.obj.pdu.delete(name, force)
3075     # except ClientException as e:
3076     #     print(str(e))
3077     #     exit(1)
3078
3079
3080 #################
3081 # VIM operations
3082 #################
3083
3084
3085 @cli_osm.command(name="vim-create", short_help="creates a new VIM account")
3086 @click.option("--name", required=True, help="Name to create datacenter")
3087 @click.option("--user", default=None, help="VIM username")
3088 @click.option("--password", default=None, help="VIM password")
3089 @click.option("--auth_url", default=None, help="VIM url")
3090 @click.option(
3091     "--tenant", "--project", "tenant", default=None, help="VIM tenant/project name"
3092 )
3093 @click.option("--config", default=None, help="VIM specific config parameters")
3094 @click.option(
3095     "--config_file",
3096     default=None,
3097     help="VIM specific config parameters in YAML or JSON file",
3098 )
3099 @click.option("--account_type", default="openstack", help="VIM type")
3100 @click.option("--description", default=None, help="human readable description")
3101 @click.option(
3102     "--sdn_controller",
3103     default=None,
3104     help="Name or id of the SDN controller associated to this VIM account",
3105 )
3106 @click.option(
3107     "--sdn_port_mapping",
3108     default=None,
3109     help="File describing the port mapping between compute nodes' ports and switch ports",
3110 )
3111 @click.option(
3112     "--wait",
3113     required=False,
3114     default=False,
3115     is_flag=True,
3116     help="do not return the control immediately, but keep it "
3117     "until the operation is completed, or timeout",
3118 )
3119 @click.option("--vca", default=None, help="VCA to be used in this VIM account")
3120 @click.option(
3121     "--creds", default=None, help="credentials file (only applycable for GCP VIM type)"
3122 )
3123 @click.option(
3124     "--prometheus_config_file",
3125     default=None,
3126     help="Prometheus configuration to get VIM data",
3127 )
3128 @click.pass_context
3129 def vim_create(
3130     ctx,
3131     name,
3132     user,
3133     password,
3134     auth_url,
3135     tenant,
3136     config,
3137     config_file,
3138     account_type,
3139     description,
3140     sdn_controller,
3141     sdn_port_mapping,
3142     wait,
3143     vca,
3144     creds,
3145     prometheus_config_file,
3146 ):
3147     """creates a new VIM account"""
3148     logger.debug("")
3149     # try:
3150     if sdn_controller:
3151         check_client_version(ctx.obj, "--sdn_controller")
3152     if sdn_port_mapping:
3153         check_client_version(ctx.obj, "--sdn_port_mapping")
3154     vim = {}
3155     if prometheus_config_file:
3156         with open(prometheus_config_file) as prometheus_file:
3157             prometheus_config_dict = json.load(prometheus_file)
3158         vim["prometheus-config"] = prometheus_config_dict
3159
3160     vim["vim-username"] = user
3161     vim["vim-password"] = password
3162     vim["vim-url"] = auth_url
3163     vim["vim-tenant-name"] = tenant
3164     vim["vim-type"] = account_type
3165     vim["description"] = description
3166     if vca:
3167         vim["vca"] = vca
3168     vim_config = create_config(config_file, config)
3169     if creds:
3170         with open(creds, "r") as cf:
3171             vim_config["credentials"] = yaml.safe_load(cf.read())
3172     ctx.obj.vim.create(
3173         name, vim, vim_config, sdn_controller, sdn_port_mapping, wait=wait
3174     )
3175     # except ClientException as e:
3176     #     print(str(e))
3177     #     exit(1)
3178
3179
3180 @cli_osm.command(name="vim-update", short_help="updates a VIM account")
3181 @click.argument("name")
3182 @click.option("--newname", help="New name for the VIM account")
3183 @click.option("--user", help="VIM username")
3184 @click.option("--password", help="VIM password")
3185 @click.option("--auth_url", help="VIM url")
3186 @click.option("--tenant", help="VIM tenant name")
3187 @click.option("--config", help="VIM specific config parameters")
3188 @click.option(
3189     "--config_file",
3190     default=None,
3191     help="VIM specific config parameters in YAML or JSON file",
3192 )
3193 @click.option("--account_type", help="VIM type")
3194 @click.option("--description", help="human readable description")
3195 @click.option(
3196     "--sdn_controller",
3197     default=None,
3198     help="Name or id of the SDN controller to be associated with this VIM"
3199     "account. Use empty string to disassociate",
3200 )
3201 @click.option(
3202     "--sdn_port_mapping",
3203     default=None,
3204     help="File describing the port mapping between compute nodes' ports and switch ports",
3205 )
3206 @click.option(
3207     "--wait",
3208     required=False,
3209     default=False,
3210     is_flag=True,
3211     help="do not return the control immediately, but keep it "
3212     "until the operation is completed, or timeout",
3213 )
3214 @click.option(
3215     "--creds", default=None, help="credentials file (only applycable for GCP VIM type)"
3216 )
3217 @click.option(
3218     "--prometheus_config_file",
3219     default=None,
3220     help="Prometheus configuration to get VIM data",
3221 )
3222 @click.pass_context
3223 def vim_update(
3224     ctx,
3225     name,
3226     newname,
3227     user,
3228     password,
3229     auth_url,
3230     tenant,
3231     config,
3232     config_file,
3233     account_type,
3234     description,
3235     sdn_controller,
3236     sdn_port_mapping,
3237     wait,
3238     creds,
3239     prometheus_config_file,
3240 ):
3241     """updates a VIM account
3242
3243     NAME: name or ID of the VIM account
3244     """
3245     logger.debug("")
3246     # try:
3247     check_client_version(ctx.obj, ctx.command.name)
3248     vim = {}
3249     if newname:
3250         vim["name"] = newname
3251     if user:
3252         vim["vim_user"] = user
3253     if password:
3254         vim["vim_password"] = password
3255     if auth_url:
3256         vim["vim_url"] = auth_url
3257     if tenant:
3258         vim["vim-tenant-name"] = tenant
3259     if account_type:
3260         vim["vim_type"] = account_type
3261     if description:
3262         vim["description"] = description
3263     vim_config = None
3264     if config or config_file:
3265         vim_config = create_config(config_file, config)
3266     if creds:
3267         with open(creds, "r") as cf:
3268             vim_config["credentials"] = yaml.safe_load(cf.read())
3269     if prometheus_config_file:
3270         with open(prometheus_config_file) as prometheus_file:
3271             prometheus_config_dict = json.load(prometheus_file)
3272         vim["prometheus-config"] = prometheus_config_dict
3273     logger.info(f"VIM: {vim}, VIM config: {vim_config}")
3274     ctx.obj.vim.update(
3275         name, vim, vim_config, sdn_controller, sdn_port_mapping, wait=wait
3276     )
3277     # except ClientException as e:
3278     #     print(str(e))
3279     #     exit(1)
3280
3281
3282 @cli_osm.command(name="vim-delete", short_help="deletes a VIM account")
3283 @click.argument("name")
3284 @click.option(
3285     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3286 )
3287 @click.option(
3288     "--wait",
3289     required=False,
3290     default=False,
3291     is_flag=True,
3292     help="do not return the control immediately, but keep it "
3293     "until the operation is completed, or timeout",
3294 )
3295 @click.pass_context
3296 def vim_delete(ctx, name, force, wait):
3297     """deletes a VIM account
3298
3299     NAME: name or ID of the VIM account to be deleted
3300     """
3301     logger.debug("")
3302     # try:
3303     if not force:
3304         ctx.obj.vim.delete(name, wait=wait)
3305     else:
3306         check_client_version(ctx.obj, "--force")
3307         ctx.obj.vim.delete(name, force, wait=wait)
3308     # except ClientException as e:
3309     #     print(str(e))
3310     #     exit(1)
3311
3312
3313 @cli_osm.command(name="vim-list", short_help="list all VIM accounts")
3314 # @click.option('--ro_update/--no_ro_update',
3315 #              default=False,
3316 #              help='update list from RO')
3317 @click.option(
3318     "--filter",
3319     default=None,
3320     multiple=True,
3321     help="restricts the list to the VIM accounts matching the filter",
3322 )
3323 @click.option(
3324     "--long",
3325     is_flag=True,
3326     help="get more details of the NS (project, vim, deployment status, configuration status.",
3327 )
3328 @click.pass_context
3329 def vim_list(ctx, filter, long):
3330     """list all VIM accounts"""
3331     logger.debug("")
3332     if filter:
3333         filter = "&".join(filter)
3334         check_client_version(ctx.obj, "--filter")
3335     #    if ro_update:
3336     #        check_client_version(ctx.obj, '--ro_update', 'v1')
3337     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
3338     if fullclassname == "osmclient.sol005.client.Client":
3339         resp = ctx.obj.vim.list(filter)
3340     #    else:
3341     #        resp = ctx.obj.vim.list(ro_update)
3342     if long:
3343         table = PrettyTable(
3344             ["vim name", "uuid", "project", "operational state", "error details"]
3345         )
3346         project_list = ctx.obj.project.list()
3347     else:
3348         table = PrettyTable(["vim name", "uuid", "operational state"])
3349     for vim in resp:
3350         if long:
3351             if "vim_password" in vim:
3352                 vim["vim_password"] = "********"
3353             if "config" in vim and "credentials" in vim["config"]:
3354                 vim["config"]["credentials"] = "********"
3355             logger.debug("VIM details: {}".format(yaml.safe_dump(vim)))
3356             vim_state = vim["_admin"].get("operationalState", "-")
3357             error_details = "N/A"
3358             if vim_state == "ERROR":
3359                 error_details = vim["_admin"].get("detailed-status", "Not found")
3360             project_id, project_name = get_project(project_list, vim)
3361             # project_info = '{} ({})'.format(project_name, project_id)
3362             project_info = project_name
3363             table.add_row(
3364                 [
3365                     vim["name"],
3366                     vim["uuid"],
3367                     project_info,
3368                     vim_state,
3369                     wrap_text(text=error_details, width=80),
3370                 ]
3371             )
3372         else:
3373             table.add_row(
3374                 [vim["name"], vim["uuid"], vim["_admin"].get("operationalState", "-")]
3375             )
3376     table.align = "l"
3377     print(table)
3378
3379
3380 @cli_osm.command(name="vim-show", short_help="shows the details of a VIM account")
3381 @click.argument("name")
3382 @click.option(
3383     "--filter",
3384     multiple=True,
3385     help="restricts the information to the fields in the filter",
3386 )
3387 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
3388 @click.pass_context
3389 def vim_show(ctx, name, filter, literal):
3390     """shows the details of a VIM account
3391
3392     NAME: name or ID of the VIM account
3393     """
3394     logger.debug("")
3395     # try:
3396     resp = ctx.obj.vim.get(name)
3397     if "vim_password" in resp:
3398         resp["vim_password"] = "********"
3399     if "config" in resp and "credentials" in resp["config"]:
3400         resp["config"]["credentials"] = "********"
3401     # except ClientException as e:
3402     #     print(str(e))
3403     #     exit(1)
3404
3405     if literal:
3406         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
3407         return
3408     table = PrettyTable(["key", "attribute"])
3409     for k, v in list(resp.items()):
3410         if not filter or k in filter:
3411             table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
3412     table.align = "l"
3413     print(table)
3414
3415
3416 ####################
3417 # WIM operations
3418 ####################
3419
3420
3421 @cli_osm.command(name="wim-create", short_help="creates a new WIM account")
3422 @click.option("--name", prompt=True, help="Name for the WIM account")
3423 @click.option("--user", help="WIM username")
3424 @click.option("--password", help="WIM password")
3425 @click.option("--url", prompt=True, help="WIM url")
3426 # @click.option('--tenant',
3427 #               help='wIM tenant name')
3428 @click.option("--config", default=None, help="WIM specific config parameters")
3429 @click.option("--wim_type", help="WIM type")
3430 @click.option("--description", default=None, help="human readable description")
3431 @click.option(
3432     "--wim_port_mapping",
3433     default=None,
3434     help="File describing the port mapping between DC edge (datacenters, switches, ports) and WAN edge "
3435     "(WAN service endpoint id and info)",
3436 )
3437 @click.option(
3438     "--wait",
3439     required=False,
3440     default=False,
3441     is_flag=True,
3442     help="do not return the control immediately, but keep it "
3443     "until the operation is completed, or timeout",
3444 )
3445 @click.pass_context
3446 def wim_create(
3447     ctx,
3448     name,
3449     user,
3450     password,
3451     url,
3452     # tenant,
3453     config,
3454     wim_type,
3455     description,
3456     wim_port_mapping,
3457     wait,
3458 ):
3459     """creates a new WIM account"""
3460     logger.debug("")
3461     # try:
3462     check_client_version(ctx.obj, ctx.command.name)
3463     # if sdn_controller:
3464     #     check_client_version(ctx.obj, '--sdn_controller')
3465     # if sdn_port_mapping:
3466     #     check_client_version(ctx.obj, '--sdn_port_mapping')
3467     wim = {}
3468     if user:
3469         wim["user"] = user
3470     if password:
3471         wim["password"] = password
3472     if url:
3473         wim["wim_url"] = url
3474     # if tenant: wim['tenant'] = tenant
3475     wim["wim_type"] = wim_type
3476     if description:
3477         wim["description"] = description
3478     if config:
3479         wim["config"] = config
3480     ctx.obj.wim.create(name, wim, wim_port_mapping, wait=wait)
3481     # except ClientException as e:
3482     #     print(str(e))
3483     #     exit(1)
3484
3485
3486 @cli_osm.command(name="wim-update", short_help="updates a WIM account")
3487 @click.argument("name")
3488 @click.option("--newname", help="New name for the WIM account")
3489 @click.option("--user", help="WIM username")
3490 @click.option("--password", help="WIM password")
3491 @click.option("--url", help="WIM url")
3492 @click.option("--config", help="WIM specific config parameters")
3493 @click.option("--wim_type", help="WIM type")
3494 @click.option("--description", help="human readable description")
3495 @click.option(
3496     "--wim_port_mapping",
3497     default=None,
3498     help="File describing the port mapping between DC edge (datacenters, switches, ports) and WAN edge "
3499     "(WAN service endpoint id and info)",
3500 )
3501 @click.option(
3502     "--wait",
3503     required=False,
3504     default=False,
3505     is_flag=True,
3506     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3507 )
3508 @click.pass_context
3509 def wim_update(
3510     ctx,
3511     name,
3512     newname,
3513     user,
3514     password,
3515     url,
3516     config,
3517     wim_type,
3518     description,
3519     wim_port_mapping,
3520     wait,
3521 ):
3522     """updates a WIM account
3523
3524     NAME: name or ID of the WIM account
3525     """
3526     logger.debug("")
3527     # try:
3528     check_client_version(ctx.obj, ctx.command.name)
3529     wim = {}
3530     if newname:
3531         wim["name"] = newname
3532     if user:
3533         wim["user"] = user
3534     if password:
3535         wim["password"] = password
3536     if url:
3537         wim["url"] = url
3538     # if tenant: wim['tenant'] = tenant
3539     if wim_type:
3540         wim["wim_type"] = wim_type
3541     if description:
3542         wim["description"] = description
3543     if config:
3544         wim["config"] = config
3545     ctx.obj.wim.update(name, wim, wim_port_mapping, wait=wait)
3546     # except ClientException as e:
3547     #     print(str(e))
3548     #     exit(1)
3549
3550
3551 @cli_osm.command(name="wim-delete", short_help="deletes a WIM account")
3552 @click.argument("name")
3553 @click.option(
3554     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3555 )
3556 @click.option(
3557     "--wait",
3558     required=False,
3559     default=False,
3560     is_flag=True,
3561     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3562 )
3563 @click.pass_context
3564 def wim_delete(ctx, name, force, wait):
3565     """deletes a WIM account
3566
3567     NAME: name or ID of the WIM account to be deleted
3568     """
3569     logger.debug("")
3570     # try:
3571     check_client_version(ctx.obj, ctx.command.name)
3572     ctx.obj.wim.delete(name, force, wait=wait)
3573     # except ClientException as e:
3574     #     print(str(e))
3575     #     exit(1)
3576
3577
3578 @cli_osm.command(name="wim-list", short_help="list all WIM accounts")
3579 @click.option(
3580     "--filter",
3581     default=None,
3582     multiple=True,
3583     help="restricts the list to the WIM accounts matching the filter",
3584 )
3585 @click.pass_context
3586 def wim_list(ctx, filter):
3587     """list all WIM accounts"""
3588     logger.debug("")
3589     # try:
3590     check_client_version(ctx.obj, ctx.command.name)
3591     if filter:
3592         filter = "&".join(filter)
3593     resp = ctx.obj.wim.list(filter)
3594     table = PrettyTable(["wim name", "uuid"])
3595     for wim in resp:
3596         table.add_row([wim["name"], wim["uuid"]])
3597     table.align = "l"
3598     print(table)
3599     # except ClientException as e:
3600     #     print(str(e))
3601     #     exit(1)
3602
3603
3604 @cli_osm.command(name="wim-show", short_help="shows the details of a WIM account")
3605 @click.argument("name")
3606 @click.pass_context
3607 def wim_show(ctx, name):
3608     """shows the details of a WIM account
3609
3610     NAME: name or ID of the WIM account
3611     """
3612     logger.debug("")
3613     # try:
3614     check_client_version(ctx.obj, ctx.command.name)
3615     resp = ctx.obj.wim.get(name)
3616     if "password" in resp:
3617         resp["wim_password"] = "********"
3618     # except ClientException as e:
3619     #     print(str(e))
3620     #     exit(1)
3621
3622     table = PrettyTable(["key", "attribute"])
3623     for k, v in list(resp.items()):
3624         table.add_row([k, json.dumps(v, indent=2)])
3625     table.align = "l"
3626     print(table)
3627
3628
3629 ####################
3630 # SDN controller operations
3631 ####################
3632
3633
3634 @cli_osm.command(name="sdnc-create", short_help="creates a new SDN controller")
3635 @click.option("--name", prompt=True, help="Name to create sdn controller")
3636 @click.option("--type", prompt=True, help="SDN controller type")
3637 @click.option(
3638     "--sdn_controller_version",  # hidden=True,
3639     help="Deprecated. Use --config {version: sdn_controller_version}",
3640 )
3641 @click.option("--url", help="URL in format http[s]://HOST:IP/")
3642 @click.option("--ip_address", help="Deprecated. Use --url")  # hidden=True,
3643 @click.option("--port", help="Deprecated. Use --url")  # hidden=True,
3644 @click.option(
3645     "--switch_dpid", help="Deprecated. Use --config {switch_id: DPID}"  # hidden=True,
3646 )
3647 @click.option(
3648     "--config",
3649     help="Extra information for SDN in yaml format, as {switch_id: identity used for the plugin (e.g. DPID: "
3650     "Openflow Datapath ID), version: version}",
3651 )
3652 @click.option("--user", help="SDN controller username")
3653 @click.option(
3654     "--password",
3655     hide_input=True,
3656     confirmation_prompt=True,
3657     help="SDN controller password",
3658 )
3659 @click.option("--description", default=None, help="human readable description")
3660 @click.option(
3661     "--wait",
3662     required=False,
3663     default=False,
3664     is_flag=True,
3665     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3666 )
3667 @click.pass_context
3668 def sdnc_create(ctx, **kwargs):
3669     """creates a new SDN controller"""
3670     logger.debug("")
3671     sdncontroller = {
3672         x: kwargs[x]
3673         for x in kwargs
3674         if kwargs[x] and x not in ("wait", "ip_address", "port", "switch_dpid")
3675     }
3676     if kwargs.get("port"):
3677         print("option '--port' is deprecated, use '--url' instead")
3678         sdncontroller["port"] = int(kwargs["port"])
3679     if kwargs.get("ip_address"):
3680         print("option '--ip_address' is deprecated, use '--url' instead")
3681         sdncontroller["ip"] = kwargs["ip_address"]
3682     if kwargs.get("switch_dpid"):
3683         print(
3684             "option '--switch_dpid' is deprecated, use '--config={switch_id: id|DPID}' instead"
3685         )
3686         sdncontroller["dpid"] = kwargs["switch_dpid"]
3687     if kwargs.get("sdn_controller_version"):
3688         print(
3689             "option '--sdn_controller_version' is deprecated, use '--config={version: SDN_CONTROLLER_VERSION}'"
3690             " instead"
3691         )
3692     # try:
3693     check_client_version(ctx.obj, ctx.command.name)
3694     ctx.obj.sdnc.create(kwargs["name"], sdncontroller, wait=kwargs["wait"])
3695     # except ClientException as e:
3696     #     print(str(e))
3697     #     exit(1)
3698
3699
3700 @cli_osm.command(name="sdnc-update", short_help="updates an SDN controller")
3701 @click.argument("name")
3702 @click.option("--newname", help="New name for the SDN controller")
3703 @click.option("--description", default=None, help="human readable description")
3704 @click.option("--type", help="SDN controller type")
3705 @click.option("--url", help="URL in format http[s]://HOST:IP/")
3706 @click.option(
3707     "--config",
3708     help="Extra information for SDN in yaml format, as "
3709     "{switch_id: identity used for the plugin (e.g. DPID: "
3710     "Openflow Datapath ID), version: version}",
3711 )
3712 @click.option("--user", help="SDN controller username")
3713 @click.option("--password", help="SDN controller password")
3714 @click.option("--ip_address", help="Deprecated. Use --url")  # hidden=True
3715 @click.option("--port", help="Deprecated. Use --url")  # hidden=True
3716 @click.option(
3717     "--switch_dpid", help="Deprecated. Use --config {switch_dpid: DPID}"
3718 )  # hidden=True
3719 @click.option(
3720     "--sdn_controller_version", help="Deprecated. Use --config {version: VERSION}"
3721 )  # hidden=True
3722 @click.option(
3723     "--wait",
3724     required=False,
3725     default=False,
3726     is_flag=True,
3727     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3728 )
3729 @click.pass_context
3730 def sdnc_update(ctx, **kwargs):
3731     """updates an SDN controller
3732
3733     NAME: name or ID of the SDN controller
3734     """
3735     logger.debug("")
3736     sdncontroller = {
3737         x: kwargs[x]
3738         for x in kwargs
3739         if kwargs[x]
3740         and x not in ("wait", "ip_address", "port", "switch_dpid", "new_name")
3741     }
3742     if kwargs.get("newname"):
3743         sdncontroller["name"] = kwargs["newname"]
3744     if kwargs.get("port"):
3745         print("option '--port' is deprecated, use '--url' instead")
3746         sdncontroller["port"] = int(kwargs["port"])
3747     if kwargs.get("ip_address"):
3748         print("option '--ip_address' is deprecated, use '--url' instead")
3749         sdncontroller["ip"] = kwargs["ip_address"]
3750     if kwargs.get("switch_dpid"):
3751         print(
3752             "option '--switch_dpid' is deprecated, use '--config={switch_id: id|DPID}' instead"
3753         )
3754         sdncontroller["dpid"] = kwargs["switch_dpid"]
3755     if kwargs.get("sdn_controller_version"):
3756         print(
3757             "option '--sdn_controller_version' is deprecated, use '---config={version: SDN_CONTROLLER_VERSION}'"
3758             " instead"
3759         )
3760
3761     # try:
3762     check_client_version(ctx.obj, ctx.command.name)
3763     ctx.obj.sdnc.update(kwargs["name"], sdncontroller, wait=kwargs["wait"])
3764     # except ClientException as e:
3765     #     print(str(e))
3766     #     exit(1)
3767
3768
3769 @cli_osm.command(name="sdnc-delete", short_help="deletes an SDN controller")
3770 @click.argument("name")
3771 @click.option(
3772     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3773 )
3774 @click.option(
3775     "--wait",
3776     required=False,
3777     default=False,
3778     is_flag=True,
3779     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3780 )
3781 @click.pass_context
3782 def sdnc_delete(ctx, name, force, wait):
3783     """deletes an SDN controller
3784
3785     NAME: name or ID of the SDN controller to be deleted
3786     """
3787     logger.debug("")
3788     # try:
3789     check_client_version(ctx.obj, ctx.command.name)
3790     ctx.obj.sdnc.delete(name, force, wait=wait)
3791     # except ClientException as e:
3792     #     print(str(e))
3793     #     exit(1)
3794
3795
3796 @cli_osm.command(name="sdnc-list", short_help="list all SDN controllers")
3797 @click.option(
3798     "--filter",
3799     default=None,
3800     multiple=True,
3801     help="restricts the list to the SDN controllers matching the filter with format: 'k[.k..]=v[&k[.k]=v2]'",
3802 )
3803 @click.pass_context
3804 def sdnc_list(ctx, filter):
3805     """list all SDN controllers"""
3806     logger.debug("")
3807     # try:
3808     check_client_version(ctx.obj, ctx.command.name)
3809     if filter:
3810         filter = "&".join(filter)
3811     resp = ctx.obj.sdnc.list(filter)
3812     # except ClientException as e:
3813     #     print(str(e))
3814     #     exit(1)
3815     table = PrettyTable(["sdnc name", "id"])
3816     for sdnc in resp:
3817         table.add_row([sdnc["name"], sdnc["_id"]])
3818     table.align = "l"
3819     print(table)
3820
3821
3822 @cli_osm.command(name="sdnc-show", short_help="shows the details of an SDN controller")
3823 @click.argument("name")
3824 @click.pass_context
3825 def sdnc_show(ctx, name):
3826     """shows the details of an SDN controller
3827
3828     NAME: name or ID of the SDN controller
3829     """
3830     logger.debug("")
3831     # try:
3832     check_client_version(ctx.obj, ctx.command.name)
3833     resp = ctx.obj.sdnc.get(name)
3834     # except ClientException as e:
3835     #     print(str(e))
3836     #     exit(1)
3837
3838     table = PrettyTable(["key", "attribute"])
3839     for k, v in list(resp.items()):
3840         table.add_row([k, json.dumps(v, indent=2)])
3841     table.align = "l"
3842     print(table)
3843
3844
3845 ###########################
3846 # K8s cluster operations
3847 ###########################
3848
3849
3850 @cli_osm.command(name="k8scluster-add", short_help="adds a K8s cluster to OSM")
3851 @click.argument("name")
3852 @click.option(
3853     "--creds", prompt=True, help="credentials file, i.e. a valid `.kube/config` file"
3854 )
3855 @click.option("--version", prompt=True, help="Kubernetes version")
3856 @click.option(
3857     "--vim", prompt=True, help="VIM target, the VIM where the cluster resides"
3858 )
3859 @click.option(
3860     "--k8s-nets",
3861     prompt=True,
3862     help='''list of VIM networks, in JSON inline format, where the cluster is
3863     accessible via L3 routing, e.g. "{(k8s_net1:vim_network1) [,(k8s_net2:vim_network2) ...]}"''',
3864 )
3865 @click.option(
3866     "--init-helm2/--skip-helm2",
3867     required=False,
3868     default=True,
3869     help="Initialize helm v2",
3870 )
3871 @click.option(
3872     "--init-helm3/--skip-helm3",
3873     required=False,
3874     default=True,
3875     help="Initialize helm v3",
3876 )
3877 @click.option(
3878     "--init-jujubundle/--skip-jujubundle",
3879     required=False,
3880     default=True,
3881     help="Initialize juju-bundle",
3882 )
3883 @click.option("--description", default=None, help="human readable description")
3884 @click.option(
3885     "--namespace",
3886     default="kube-system",
3887     help="namespace to be used for its operation, defaults to `kube-system`",
3888 )
3889 @click.option(
3890     "--wait",
3891     required=False,
3892     default=False,
3893     is_flag=True,
3894     help="do not return the control immediately, but keep it "
3895     "until the operation is completed, or timeout",
3896 )
3897 @click.option(
3898     "--cni",
3899     default=None,
3900     help="list of CNI plugins, in JSON inline format, used in the cluster",
3901 )
3902 # @click.option('--skip-init',
3903 #              is_flag=True,
3904 #              help='If set, K8s cluster is assumed to be ready for its use with OSM')
3905 # @click.option('--wait',
3906 #              is_flag=True,
3907 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
3908 @click.pass_context
3909 def k8scluster_add(
3910     ctx,
3911     name,
3912     creds,
3913     version,
3914     vim,
3915     k8s_nets,
3916     init_helm2,
3917     init_helm3,
3918     init_jujubundle,
3919     description,
3920     namespace,
3921     wait,
3922     cni,
3923 ):
3924     """adds a K8s cluster to OSM
3925
3926     NAME: name of the K8s cluster
3927     """
3928     # try:
3929     check_client_version(ctx.obj, ctx.command.name)
3930     cluster = {}
3931     cluster["name"] = name
3932     with open(creds, "r") as cf:
3933         cluster["credentials"] = yaml.safe_load(cf.read())
3934     cluster["k8s_version"] = version
3935     cluster["vim_account"] = vim
3936     cluster["nets"] = yaml.safe_load(k8s_nets)
3937     if not (init_helm2 and init_jujubundle and init_helm3):
3938         cluster["deployment_methods"] = {
3939             "helm-chart": init_helm2,
3940             "juju-bundle": init_jujubundle,
3941             "helm-chart-v3": init_helm3,
3942         }
3943     if description:
3944         cluster["description"] = description
3945     if namespace:
3946         cluster["namespace"] = namespace
3947     if cni:
3948         cluster["cni"] = yaml.safe_load(cni)
3949     ctx.obj.k8scluster.create(name, cluster, wait)
3950     # except ClientException as e:
3951     #     print(str(e))
3952     #     exit(1)
3953
3954
3955 @cli_osm.command(name="k8scluster-update", short_help="updates a K8s cluster")
3956 @click.argument("name")
3957 @click.option("--newname", help="New name for the K8s cluster")
3958 @click.option("--creds", help="credentials file, i.e. a valid `.kube/config` file")
3959 @click.option("--version", help="Kubernetes version")
3960 @click.option("--vim", help="VIM target, the VIM where the cluster resides")
3961 @click.option(
3962     "--k8s-nets",
3963     help='''list of VIM networks, in JSON inline format, where the cluster is accessible
3964     via L3 routing, e.g. "{(k8s_net1:vim_network1) [,(k8s_net2:vim_network2) ...]}"''',
3965 )
3966 @click.option("--description", help="human readable description")
3967 @click.option(
3968     "--namespace",
3969     help="namespace to be used for its operation, defaults to `kube-system`",
3970 )
3971 @click.option(
3972     "--wait",
3973     required=False,
3974     default=False,
3975     is_flag=True,
3976     help="do not return the control immediately, but keep it "
3977     "until the operation is completed, or timeout",
3978 )
3979 @click.option(
3980     "--cni", help="list of CNI plugins, in JSON inline format, used in the cluster"
3981 )
3982 @click.pass_context
3983 def k8scluster_update(
3984     ctx, name, newname, creds, version, vim, k8s_nets, description, namespace, wait, cni
3985 ):
3986     """updates a K8s cluster
3987
3988     NAME: name or ID of the K8s cluster
3989     """
3990     # try:
3991     check_client_version(ctx.obj, ctx.command.name)
3992     cluster = {}
3993     if newname:
3994         cluster["name"] = newname
3995     if creds:
3996         with open(creds, "r") as cf:
3997             cluster["credentials"] = yaml.safe_load(cf.read())
3998     if version:
3999         cluster["k8s_version"] = version
4000     if vim:
4001         cluster["vim_account"] = vim
4002     if k8s_nets:
4003         cluster["nets"] = yaml.safe_load(k8s_nets)
4004     if description:
4005         cluster["description"] = description
4006     if namespace:
4007         cluster["namespace"] = namespace
4008     if cni:
4009         cluster["cni"] = yaml.safe_load(cni)
4010     ctx.obj.k8scluster.update(name, cluster, wait)
4011     # except ClientException as e:
4012     #     print(str(e))
4013     #     exit(1)
4014
4015
4016 @cli_osm.command(name="k8scluster-delete", short_help="deletes a K8s cluster")
4017 @click.argument("name")
4018 @click.option(
4019     "--force", is_flag=True, help="forces the deletion from the DB (not recommended)"
4020 )
4021 @click.option(
4022     "--wait",
4023     required=False,
4024     default=False,
4025     is_flag=True,
4026     help="do not return the control immediately, but keep it "
4027     "until the operation is completed, or timeout",
4028 )
4029 @click.pass_context
4030 def k8scluster_delete(ctx, name, force, wait):
4031     """deletes a K8s cluster
4032
4033     NAME: name or ID of the K8s cluster to be deleted
4034     """
4035     # try:
4036     check_client_version(ctx.obj, ctx.command.name)
4037     ctx.obj.k8scluster.delete(name, force, wait)
4038     # except ClientException as e:
4039     #     print(str(e))
4040     #     exit(1)
4041
4042
4043 @cli_osm.command(name="k8scluster-list")
4044 @click.option(
4045     "--filter",
4046     default=None,
4047     multiple=True,
4048     help="restricts the list to the K8s clusters matching the filter",
4049 )
4050 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4051 @click.option("--long", is_flag=True, help="get more details")
4052 @click.pass_context
4053 def k8scluster_list(ctx, filter, literal, long):
4054     """list all K8s clusters"""
4055     # try:
4056     check_client_version(ctx.obj, ctx.command.name)
4057     if filter:
4058         filter = "&".join(filter)
4059     resp = ctx.obj.k8scluster.list(filter)
4060     if literal:
4061         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4062         return
4063     if long:
4064         table = PrettyTable(
4065             [
4066                 "Name",
4067                 "Id",
4068                 "Project",
4069                 "Version",
4070                 "VIM",
4071                 "K8s-nets",
4072                 "Deployment methods",
4073                 "Operational State",
4074                 "Op. state (details)",
4075                 "Description",
4076                 "Detailed status",
4077             ]
4078         )
4079         project_list = ctx.obj.project.list()
4080     else:
4081         table = PrettyTable(
4082             ["Name", "Id", "VIM", "Operational State", "Op. state details"]
4083         )
4084     try:
4085         vim_list = ctx.obj.vim.list()
4086     except Exception:
4087         vim_list = []
4088     for cluster in resp:
4089         logger.debug("Cluster details: {}".format(yaml.safe_dump(cluster)))
4090         vim_name = get_vim_name(vim_list, cluster["vim_account"])
4091         # vim_info = '{} ({})'.format(vim_name,cluster['vim_account'])
4092         vim_info = vim_name
4093         op_state_details = "Helm: {}\nJuju: {}".format(
4094             cluster["_admin"].get("helm-chart", {}).get("operationalState", "-"),
4095             cluster["_admin"].get("juju-bundle", {}).get("operationalState", "-"),
4096         )
4097         if long:
4098             project_id, project_name = get_project(project_list, cluster)
4099             # project_info = '{} ({})'.format(project_name, project_id)
4100             project_info = project_name
4101             detailed_status = cluster["_admin"].get("detailed-status", "-")
4102             table.add_row(
4103                 [
4104                     cluster["name"],
4105                     cluster["_id"],
4106                     project_info,
4107                     cluster["k8s_version"],
4108                     vim_info,
4109                     json.dumps(cluster["nets"]),
4110                     json.dumps(cluster["deployment_methods"]),
4111                     cluster["_admin"]["operationalState"],
4112                     op_state_details,
4113                     trunc_text(cluster.get("description") or "", 40),
4114                     wrap_text(text=detailed_status, width=40),
4115                 ]
4116             )
4117         else:
4118             table.add_row(
4119                 [
4120                     cluster["name"],
4121                     cluster["_id"],
4122                     vim_info,
4123                     cluster["_admin"]["operationalState"],
4124                     op_state_details,
4125                 ]
4126             )
4127     table.align = "l"
4128     print(table)
4129     # except ClientException as e:
4130     #     print(str(e))
4131     #     exit(1)
4132
4133
4134 @cli_osm.command(
4135     name="k8scluster-show", short_help="shows the details of a K8s cluster"
4136 )
4137 @click.argument("name")
4138 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4139 @click.pass_context
4140 def k8scluster_show(ctx, name, literal):
4141     """shows the details of a K8s cluster
4142
4143     NAME: name or ID of the K8s cluster
4144     """
4145     # try:
4146     resp = ctx.obj.k8scluster.get(name)
4147     if literal:
4148         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4149         return
4150     table = PrettyTable(["key", "attribute"])
4151     for k, v in list(resp.items()):
4152         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
4153     table.align = "l"
4154     print(table)
4155     # except ClientException as e:
4156     #     print(str(e))
4157     #     exit(1)
4158
4159
4160 ###########################
4161 # VCA operations
4162 ###########################
4163
4164
4165 @cli_osm.command(name="vca-add", short_help="adds a VCA (Juju controller) to OSM")
4166 @click.argument("name")
4167 @click.option(
4168     "--endpoints",
4169     prompt=True,
4170     help="Comma-separated list of IP or hostnames of the Juju controller",
4171 )
4172 @click.option("--user", prompt=True, help="Username with admin priviledges")
4173 @click.option("--secret", prompt=True, help="Password of the specified username")
4174 @click.option("--cacert", prompt=True, help="CA certificate")
4175 @click.option(
4176     "--lxd-cloud",
4177     prompt=True,
4178     help="Name of the cloud that will be used for LXD containers (LXD proxy charms)",
4179 )
4180 @click.option(
4181     "--lxd-credentials",
4182     prompt=True,
4183     help="Name of the cloud credentialsto be used for the LXD cloud",
4184 )
4185 @click.option(
4186     "--k8s-cloud",
4187     prompt=True,
4188     help="Name of the cloud that will be used for K8s containers (K8s proxy charms)",
4189 )
4190 @click.option(
4191     "--k8s-credentials",
4192     prompt=True,
4193     help="Name of the cloud credentialsto be used for the K8s cloud",
4194 )
4195 @click.option(
4196     "--model-config",
4197     default={},
4198     help="Configuration options for the models",
4199 )
4200 @click.option("--description", default=None, help="human readable description")
4201 @click.pass_context
4202 def vca_add(
4203     ctx,
4204     name,
4205     endpoints,
4206     user,
4207     secret,
4208     cacert,
4209     lxd_cloud,
4210     lxd_credentials,
4211     k8s_cloud,
4212     k8s_credentials,
4213     model_config,
4214     description,
4215 ):
4216     """adds a VCA to OSM
4217
4218     NAME: name of the VCA
4219     """
4220     check_client_version(ctx.obj, ctx.command.name)
4221     vca = {}
4222     vca["name"] = name
4223     vca["endpoints"] = endpoints.split(",")
4224     vca["user"] = user
4225     vca["secret"] = secret
4226     vca["cacert"] = cacert
4227     vca["lxd-cloud"] = lxd_cloud
4228     vca["lxd-credentials"] = lxd_credentials
4229     vca["k8s-cloud"] = k8s_cloud
4230     vca["k8s-credentials"] = k8s_credentials
4231     if description:
4232         vca["description"] = description
4233     if model_config:
4234         model_config = load(model_config)
4235         vca["model-config"] = model_config
4236     ctx.obj.vca.create(name, vca)
4237
4238
4239 def load(data: Any):
4240     if os.path.isfile(data):
4241         return load_file(data)
4242     else:
4243         try:
4244             return json.loads(data)
4245         except ValueError as e:
4246             raise ClientException(e)
4247
4248
4249 def load_file(file_path: str) -> Dict:
4250     content = None
4251     with open(file_path, "r") as f:
4252         content = f.read()
4253     try:
4254         return yaml.safe_load(content)
4255     except yaml.scanner.ScannerError:
4256         pass
4257     try:
4258         return json.loads(content)
4259     except ValueError:
4260         pass
4261     raise ClientException(f"{file_path} must be a valid yaml or json file")
4262
4263
4264 @cli_osm.command(name="vca-update", short_help="updates a K8s cluster")
4265 @click.argument("name")
4266 @click.option(
4267     "--endpoints", help="Comma-separated list of IP or hostnames of the Juju controller"
4268 )
4269 @click.option("--user", help="Username with admin priviledges")
4270 @click.option("--secret", help="Password of the specified username")
4271 @click.option("--cacert", help="CA certificate")
4272 @click.option(
4273     "--lxd-cloud",
4274     help="Name of the cloud that will be used for LXD containers (LXD proxy charms)",
4275 )
4276 @click.option(
4277     "--lxd-credentials",
4278     help="Name of the cloud credentialsto be used for the LXD cloud",
4279 )
4280 @click.option(
4281     "--k8s-cloud",
4282     help="Name of the cloud that will be used for K8s containers (K8s proxy charms)",
4283 )
4284 @click.option(
4285     "--k8s-credentials",
4286     help="Name of the cloud credentialsto be used for the K8s cloud",
4287 )
4288 @click.option(
4289     "--model-config",
4290     help="Configuration options for the models",
4291 )
4292 @click.option("--description", default=None, help="human readable description")
4293 @click.pass_context
4294 def vca_update(
4295     ctx,
4296     name,
4297     endpoints,
4298     user,
4299     secret,
4300     cacert,
4301     lxd_cloud,
4302     lxd_credentials,
4303     k8s_cloud,
4304     k8s_credentials,
4305     model_config,
4306     description,
4307 ):
4308     """updates a K8s cluster
4309
4310     NAME: name or ID of the K8s cluster
4311     """
4312     check_client_version(ctx.obj, ctx.command.name)
4313     vca = {}
4314     vca["name"] = name
4315     if endpoints:
4316         vca["endpoints"] = endpoints.split(",")
4317     if user:
4318         vca["user"] = user
4319     if secret:
4320         vca["secret"] = secret
4321     if cacert:
4322         vca["cacert"] = cacert
4323     if lxd_cloud:
4324         vca["lxd-cloud"] = lxd_cloud
4325     if lxd_credentials:
4326         vca["lxd-credentials"] = lxd_credentials
4327     if k8s_cloud:
4328         vca["k8s-cloud"] = k8s_cloud
4329     if k8s_credentials:
4330         vca["k8s-credentials"] = k8s_credentials
4331     if description:
4332         vca["description"] = description
4333     if model_config:
4334         model_config = load(model_config)
4335         vca["model-config"] = model_config
4336     ctx.obj.vca.update(name, vca)
4337
4338
4339 @cli_osm.command(name="vca-delete", short_help="deletes a K8s cluster")
4340 @click.argument("name")
4341 @click.option(
4342     "--force", is_flag=True, help="forces the deletion from the DB (not recommended)"
4343 )
4344 @click.pass_context
4345 def vca_delete(ctx, name, force):
4346     """deletes a K8s cluster
4347
4348     NAME: name or ID of the K8s cluster to be deleted
4349     """
4350     check_client_version(ctx.obj, ctx.command.name)
4351     ctx.obj.vca.delete(name, force=force)
4352
4353
4354 @cli_osm.command(name="vca-list")
4355 @click.option(
4356     "--filter",
4357     default=None,
4358     multiple=True,
4359     help="restricts the list to the VCAs matching the filter",
4360 )
4361 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4362 @click.option("--long", is_flag=True, help="get more details")
4363 @click.pass_context
4364 def vca_list(ctx, filter, literal, long):
4365     """list VCAs"""
4366     check_client_version(ctx.obj, ctx.command.name)
4367     if filter:
4368         filter = "&".join(filter)
4369     resp = ctx.obj.vca.list(filter)
4370     if literal:
4371         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4372         return
4373     if long:
4374         table = PrettyTable(
4375             ["Name", "Id", "Project", "Operational State", "Detailed Status"]
4376         )
4377         project_list = ctx.obj.project.list()
4378     else:
4379         table = PrettyTable(["Name", "Id", "Operational State"])
4380     for vca in resp:
4381         logger.debug("VCA details: {}".format(yaml.safe_dump(vca)))
4382         if long:
4383             project_id, project_name = get_project(project_list, vca)
4384             detailed_status = vca.get("_admin", {}).get("detailed-status", "-")
4385             table.add_row(
4386                 [
4387                     vca["name"],
4388                     vca["_id"],
4389                     project_name,
4390                     vca.get("_admin", {}).get("operationalState", "-"),
4391                     wrap_text(text=detailed_status, width=40),
4392                 ]
4393             )
4394         else:
4395             table.add_row(
4396                 [
4397                     vca["name"],
4398                     vca["_id"],
4399                     vca.get("_admin", {}).get("operationalState", "-"),
4400                 ]
4401             )
4402     table.align = "l"
4403     print(table)
4404
4405
4406 @cli_osm.command(name="vca-show", short_help="shows the details of a K8s cluster")
4407 @click.argument("name")
4408 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4409 @click.pass_context
4410 def vca_show(ctx, name, literal):
4411     """shows the details of a K8s cluster
4412
4413     NAME: name or ID of the K8s cluster
4414     """
4415     # try:
4416     resp = ctx.obj.vca.get(name)
4417     if literal:
4418         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4419         return
4420     table = PrettyTable(["key", "attribute"])
4421     for k, v in list(resp.items()):
4422         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
4423     table.align = "l"
4424     print(table)
4425
4426
4427 ###########################
4428 # Repo operations
4429 ###########################
4430
4431
4432 @cli_osm.command(name="repo-add", short_help="adds a repo to OSM")
4433 @click.argument("name")
4434 @click.argument("uri")
4435 @click.option(
4436     "--type",
4437     type=click.Choice(["helm-chart", "juju-bundle", "osm"]),
4438     default="osm",
4439     help="type of repo (helm-chart for Helm Charts, juju-bundle for Juju Bundles, osm for OSM Repositories)",
4440 )
4441 @click.option("--description", default=None, help="human readable description")
4442 @click.option(
4443     "--user", default=None, help="OSM repository: The username of the OSM repository"
4444 )
4445 @click.option(
4446     "--password",
4447     default=None,
4448     help="OSM repository: The password of the OSM repository",
4449 )
4450 # @click.option('--wait',
4451 #              is_flag=True,
4452 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
4453 @click.pass_context
4454 def repo_add(ctx, **kwargs):
4455     """adds a repo to OSM
4456
4457     NAME: name of the repo
4458     URI: URI of the repo
4459     """
4460     # try:
4461     kwargs = {k: v for k, v in kwargs.items() if v is not None}
4462     repo = kwargs
4463     repo["url"] = repo.pop("uri")
4464     if repo["type"] in ["helm-chart", "juju-bundle"]:
4465         ctx.obj.repo.create(repo["name"], repo)
4466     else:
4467         ctx.obj.osmrepo.create(repo["name"], repo)
4468     # except ClientException as e:
4469     #     print(str(e))
4470     #     exit(1)
4471
4472
4473 @cli_osm.command(name="repo-update", short_help="updates a repo in OSM")
4474 @click.argument("name")
4475 @click.option("--newname", help="New name for the repo")
4476 @click.option("--uri", help="URI of the repo")
4477 @click.option("--description", help="human readable description")
4478 # @click.option('--wait',
4479 #              is_flag=True,
4480 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
4481 @click.pass_context
4482 def repo_update(ctx, name, newname, uri, description):
4483     """updates a repo in OSM
4484
4485     NAME: name of the repo
4486     """
4487     # try:
4488     check_client_version(ctx.obj, ctx.command.name)
4489     repo = {}
4490     if newname:
4491         repo["name"] = newname
4492     if uri:
4493         repo["uri"] = uri
4494     if description:
4495         repo["description"] = description
4496     try:
4497         ctx.obj.repo.update(name, repo)
4498     except NotFound:
4499         ctx.obj.osmrepo.update(name, repo)
4500
4501     # except ClientException as e:
4502     #     print(str(e))
4503     #     exit(1)
4504
4505
4506 @cli_osm.command(
4507     name="repo-index", short_help="Index a repository from a folder with artifacts"
4508 )
4509 @click.option(
4510     "--origin", default=".", help="origin path where the artifacts are located"
4511 )
4512 @click.option(
4513     "--destination", default=".", help="destination path where the index is deployed"
4514 )
4515 @click.pass_context
4516 def repo_index(ctx, origin, destination):
4517     """Index a repository
4518
4519     NAME: name or ID of the repo to be deleted
4520     """
4521     check_client_version(ctx.obj, ctx.command.name)
4522     ctx.obj.osmrepo.repo_index(origin, destination)
4523
4524
4525 @cli_osm.command(name="repo-delete", short_help="deletes a repo")
4526 @click.argument("name")
4527 @click.option(
4528     "--force", is_flag=True, help="forces the deletion from the DB (not recommended)"
4529 )
4530 # @click.option('--wait',
4531 #              is_flag=True,
4532 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
4533 @click.pass_context
4534 def repo_delete(ctx, name, force):
4535     """deletes a repo
4536
4537     NAME: name or ID of the repo to be deleted
4538     """
4539     logger.debug("")
4540     try:
4541         ctx.obj.repo.delete(name, force=force)
4542     except NotFound:
4543         ctx.obj.osmrepo.delete(name, force=force)
4544     # except ClientException as e:
4545     #     print(str(e))
4546     #     exit(1)
4547
4548
4549 @cli_osm.command(name="repo-list")
4550 @click.option(
4551     "--filter",
4552     default=None,
4553     multiple=True,
4554     help="restricts the list to the repos matching the filter",
4555 )
4556 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4557 @click.pass_context
4558 def repo_list(ctx, filter, literal):
4559     """list all repos"""
4560     # try:
4561     # K8s Repositories
4562     check_client_version(ctx.obj, ctx.command.name)
4563     if filter:
4564         filter = "&".join(filter)
4565     resp = ctx.obj.repo.list(filter)
4566     resp += ctx.obj.osmrepo.list(filter)
4567     if literal:
4568         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4569         return
4570     table = PrettyTable(["Name", "Id", "Type", "URI", "Description"])
4571     for repo in resp:
4572         # cluster['k8s-nets'] = json.dumps(yaml.safe_load(cluster['k8s-nets']))
4573         table.add_row(
4574             [
4575                 repo["name"],
4576                 repo["_id"],
4577                 repo["type"],
4578                 repo["url"],
4579                 trunc_text(repo.get("description") or "", 40),
4580             ]
4581         )
4582     table.align = "l"
4583     print(table)
4584
4585     # except ClientException as e:
4586     #     print(str(e))
4587     #     exit(1)
4588
4589
4590 @cli_osm.command(name="repo-show", short_help="shows the details of a repo")
4591 @click.argument("name")
4592 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4593 @click.pass_context
4594 def repo_show(ctx, name, literal):
4595     """shows the details of a repo
4596
4597     NAME: name or ID of the repo
4598     """
4599     try:
4600         resp = ctx.obj.repo.get(name)
4601     except NotFound:
4602         resp = ctx.obj.osmrepo.get(name)
4603
4604     if literal:
4605         if resp:
4606             print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4607         return
4608     table = PrettyTable(["key", "attribute"])
4609     if resp:
4610         for k, v in list(resp.items()):
4611             table.add_row([k, json.dumps(v, indent=2)])
4612
4613     table.align = "l"
4614     print(table)
4615     # except ClientException as e:
4616     #     print(str(e))
4617     #     exit(1)
4618
4619
4620 ####################
4621 # Project mgmt operations
4622 ####################
4623
4624
4625 @cli_osm.command(name="project-create", short_help="creates a new project")
4626 @click.argument("name")
4627 # @click.option('--description',
4628 #              default='no description',
4629 #              help='human readable description')
4630 @click.option("--domain-name", "domain_name", default=None, help="assign to a domain")
4631 @click.option(
4632     "--quotas",
4633     "quotas",
4634     multiple=True,
4635     default=None,
4636     help="provide quotas. Can be used several times: 'quota1=number[,quota2=number,...]'. Quotas can be one "
4637     "of vnfds, nsds, nsts, pdus, nsrs, nsis, vim_accounts, wim_accounts, sdns, k8sclusters, k8srepos",
4638 )
4639 @click.pass_context
4640 def project_create(ctx, name, domain_name, quotas):
4641     """Creates a new project
4642
4643     NAME: name of the project
4644     DOMAIN_NAME: optional domain name for the project when keystone authentication is used
4645     QUOTAS: set quotas for the project
4646     """
4647     logger.debug("")
4648     project = {"name": name}
4649     if domain_name:
4650         project["domain_name"] = domain_name
4651     quotas_dict = _process_project_quotas(quotas)
4652     if quotas_dict:
4653         project["quotas"] = quotas_dict
4654
4655     # try:
4656     check_client_version(ctx.obj, ctx.command.name)
4657     ctx.obj.project.create(name, project)
4658     # except ClientException as e:
4659     #     print(str(e))
4660     #     exit(1)
4661
4662
4663 def _process_project_quotas(quota_list):
4664     quotas_dict = {}
4665     if not quota_list:
4666         return quotas_dict
4667     try:
4668         for quota in quota_list:
4669             for single_quota in quota.split(","):
4670                 k, v = single_quota.split("=")
4671                 quotas_dict[k] = None if v in ("None", "null", "") else int(v)
4672     except (ValueError, TypeError):
4673         raise ClientException(
4674             "invalid format for 'quotas'. Use 'k1=v1,v1=v2'. v must be a integer or null"
4675         )
4676     return quotas_dict
4677
4678
4679 @cli_osm.command(name="project-delete", short_help="deletes a project")
4680 @click.argument("name")
4681 # @click.option('--force', is_flag=True, help='forces the deletion bypassing pre-conditions')
4682 @click.pass_context
4683 def project_delete(ctx, name):
4684     """deletes a project
4685
4686     NAME: name or ID of the project to be deleted
4687     """
4688     logger.debug("")
4689     # try:
4690     check_client_version(ctx.obj, ctx.command.name)
4691     ctx.obj.project.delete(name)
4692     # except ClientException as e:
4693     #     print(str(e))
4694     #     exit(1)
4695
4696
4697 @cli_osm.command(name="project-list", short_help="list all projects")
4698 @click.option(
4699     "--filter",
4700     default=None,
4701     multiple=True,
4702     help="restricts the list to the projects matching the filter",
4703 )
4704 @click.pass_context
4705 def project_list(ctx, filter):
4706     """list all projects"""
4707     logger.debug("")
4708     # try:
4709     check_client_version(ctx.obj, ctx.command.name)
4710     if filter:
4711         filter = "&".join(filter)
4712     resp = ctx.obj.project.list(filter)
4713     # except ClientException as e:
4714     #     print(str(e))
4715     #     exit(1)
4716     table = PrettyTable(["name", "id"])
4717     for proj in resp:
4718         table.add_row([proj["name"], proj["_id"]])
4719     table.align = "l"
4720     print(table)
4721
4722
4723 @cli_osm.command(name="project-show", short_help="shows the details of a project")
4724 @click.argument("name")
4725 @click.pass_context
4726 def project_show(ctx, name):
4727     """shows the details of a project
4728
4729     NAME: name or ID of the project
4730     """
4731     logger.debug("")
4732     # try:
4733     check_client_version(ctx.obj, ctx.command.name)
4734     resp = ctx.obj.project.get(name)
4735     # except ClientException as e:
4736     #     print(str(e))
4737     #     exit(1)
4738
4739     table = PrettyTable(["key", "attribute"])
4740     for k, v in resp.items():
4741         table.add_row([k, json.dumps(v, indent=2)])
4742     table.align = "l"
4743     print(table)
4744
4745
4746 @cli_osm.command(
4747     name="project-update", short_help="updates a project (only the name can be updated)"
4748 )
4749 @click.argument("project")
4750 @click.option("--name", default=None, help="new name for the project")
4751 @click.option(
4752     "--quotas",
4753     "quotas",
4754     multiple=True,
4755     default=None,
4756     help="change quotas. Can be used several times: 'quota1=number|empty[,quota2=...]' "
4757     "(use empty to reset quota to default",
4758 )
4759 @click.pass_context
4760 def project_update(ctx, project, name, quotas):
4761     """
4762     Update a project name
4763
4764     :param ctx:
4765     :param project: id or name of the project to modify
4766     :param name:  new name for the project
4767     :param quotas:  change quotas of the project
4768     :return:
4769     """
4770     logger.debug("")
4771     project_changes = {}
4772     if name:
4773         project_changes["name"] = name
4774     quotas_dict = _process_project_quotas(quotas)
4775     if quotas_dict:
4776         project_changes["quotas"] = quotas_dict
4777
4778     # try:
4779     check_client_version(ctx.obj, ctx.command.name)
4780     ctx.obj.project.update(project, project_changes)
4781     # except ClientException as e:
4782     #     print(str(e))
4783
4784
4785 ####################
4786 # User mgmt operations
4787 ####################
4788
4789
4790 @cli_osm.command(name="user-create", short_help="creates a new user")
4791 @click.argument("username")
4792 @click.option(
4793     "--password",
4794     prompt=True,
4795     hide_input=True,
4796     confirmation_prompt=True,
4797     help="user password",
4798 )
4799 @click.option(
4800     "--projects",
4801     # prompt="Comma separate list of projects",
4802     multiple=True,
4803     callback=lambda ctx, param, value: "".join(value).split(",")
4804     if all(len(x) == 1 for x in value)
4805     else value,
4806     help="list of project ids that the user belongs to",
4807 )
4808 @click.option(
4809     "--project-role-mappings",
4810     "project_role_mappings",
4811     default=None,
4812     multiple=True,
4813     help="assign role(s) in a project. Can be used several times: 'project,role1[,role2,...]'",
4814 )
4815 @click.option("--domain-name", "domain_name", default=None, help="assign to a domain")
4816 @click.pass_context
4817 def user_create(ctx, username, password, projects, project_role_mappings, domain_name):
4818     """Creates a new user
4819
4820     \b
4821     USERNAME: name of the user
4822     PASSWORD: password of the user
4823     PROJECTS: projects assigned to user (internal only)
4824     PROJECT_ROLE_MAPPING: roles in projects assigned to user (keystone)
4825     DOMAIN_NAME: optional domain name for the user when keystone authentication is used
4826     """
4827     logger.debug("")
4828     user = {}
4829     user["username"] = username
4830     user["password"] = password
4831     user["projects"] = projects
4832     user["project_role_mappings"] = project_role_mappings
4833     if domain_name:
4834         user["domain_name"] = domain_name
4835
4836     # try:
4837     check_client_version(ctx.obj, ctx.command.name)
4838     ctx.obj.user.create(username, user)
4839     # except ClientException as e:
4840     #     print(str(e))
4841     #     exit(1)
4842
4843
4844 @cli_osm.command(name="user-update", short_help="updates user information")
4845 @click.argument("username")
4846 @click.option(
4847     "--password",
4848     # prompt=True,
4849     # hide_input=True,
4850     # confirmation_prompt=True,
4851     help="user password",
4852 )
4853 @click.option("--set-username", "set_username", default=None, help="change username")
4854 @click.option(
4855     "--set-project",
4856     "set_project",
4857     default=None,
4858     multiple=True,
4859     help="create/replace the roles for this project: 'project,role1[,role2,...]'",
4860 )
4861 @click.option(
4862     "--remove-project",
4863     "remove_project",
4864     default=None,
4865     multiple=True,
4866     help="removes project from user: 'project'",
4867 )
4868 @click.option(
4869     "--add-project-role",
4870     "add_project_role",
4871     default=None,
4872     multiple=True,
4873     help="assign role(s) in a project. Can be used several times: 'project,role1[,role2,...]'",
4874 )
4875 @click.option(
4876     "--remove-project-role",
4877     "remove_project_role",
4878     default=None,
4879     multiple=True,
4880     help="remove role(s) in a project. Can be used several times: 'project,role1[,role2,...]'",
4881 )
4882 @click.option("--change_password", "change_password", help="user's current password")
4883 @click.option(
4884     "--new_password",
4885     "new_password",
4886     help="user's new password to update in expiry condition",
4887 )
4888 @click.pass_context
4889 def user_update(
4890     ctx,
4891     username,
4892     password,
4893     set_username,
4894     set_project,
4895     remove_project,
4896     add_project_role,
4897     remove_project_role,
4898     change_password,
4899     new_password,
4900 ):
4901     """Update a user information
4902
4903     \b
4904     USERNAME: name of the user
4905     PASSWORD: new password
4906     SET_USERNAME: new username
4907     SET_PROJECT: creating mappings for project/role(s)
4908     REMOVE_PROJECT: deleting mappings for project/role(s)
4909     ADD_PROJECT_ROLE: adding mappings for project/role(s)
4910     REMOVE_PROJECT_ROLE: removing mappings for project/role(s)
4911     CHANGE_PASSWORD: user's current password to change
4912     NEW_PASSWORD: user's new password to update in expiry condition
4913     """
4914     logger.debug("")
4915     user = {}
4916     user["password"] = password
4917     user["username"] = set_username
4918     user["set-project"] = set_project
4919     user["remove-project"] = remove_project
4920     user["add-project-role"] = add_project_role
4921     user["remove-project-role"] = remove_project_role
4922     user["change_password"] = change_password
4923     user["new_password"] = new_password
4924
4925     # try:
4926     check_client_version(ctx.obj, ctx.command.name)
4927     if not user.get("change_password"):
4928         ctx.obj.user.update(username, user)
4929     else:
4930         ctx.obj.user.update(username, user, pwd_change=True)
4931     # except ClientException as e:
4932     #     print(str(e))
4933     #     exit(1)
4934
4935
4936 @cli_osm.command(name="user-delete", short_help="deletes a user")
4937 @click.argument("name")
4938 # @click.option('--force', is_flag=True, help='forces the deletion bypassing pre-conditions')
4939 @click.pass_context
4940 def user_delete(ctx, name):
4941     """deletes a user
4942
4943     \b
4944     NAME: name or ID of the user to be deleted
4945     """
4946     logger.debug("")
4947     # try:
4948     check_client_version(ctx.obj, ctx.command.name)
4949     ctx.obj.user.delete(name)
4950     # except ClientException as e:
4951     #     print(str(e))
4952     #     exit(1)
4953
4954
4955 @cli_osm.command(name="user-list", short_help="list all users")
4956 @click.option(
4957     "--filter",
4958     default=None,
4959     multiple=True,
4960     help="restricts the list to the users matching the filter",
4961 )
4962 @click.pass_context
4963 def user_list(ctx, filter):
4964     """list all users"""
4965     # try:
4966     check_client_version(ctx.obj, ctx.command.name)
4967     if filter:
4968         filter = "&".join(filter)
4969     resp = ctx.obj.user.list(filter)
4970     # except ClientException as e:
4971     #     print(str(e))
4972     #     exit(1)
4973     table = PrettyTable(["name", "id"])
4974     for user in resp:
4975         table.add_row([user["username"], user["_id"]])
4976     table.align = "l"
4977     print(table)
4978
4979
4980 @cli_osm.command(name="user-show", short_help="shows the details of a user")
4981 @click.argument("name")
4982 @click.pass_context
4983 def user_show(ctx, name):
4984     """shows the details of a user
4985
4986     NAME: name or ID of the user
4987     """
4988     logger.debug("")
4989     # try:
4990     check_client_version(ctx.obj, ctx.command.name)
4991     resp = ctx.obj.user.get(name)
4992     if "password" in resp:
4993         resp["password"] = "********"
4994     # except ClientException as e:
4995     #     print(str(e))
4996     #     exit(1)
4997
4998     table = PrettyTable(["key", "attribute"])
4999     for k, v in resp.items():
5000         table.add_row([k, json.dumps(v, indent=2)])
5001     table.align = "l"
5002     print(table)
5003
5004
5005 ####################
5006 # Fault Management operations
5007 ####################
5008
5009
5010 @cli_osm.command(name="ns-alarm-create")
5011 @click.argument("name")
5012 @click.option("--ns", prompt=True, help="NS instance id or name")
5013 @click.option(
5014     "--vnf", prompt=True, help="VNF name (VNF member index as declared in the NSD)"
5015 )
5016 @click.option("--vdu", prompt=True, help="VDU name (VDU name as declared in the VNFD)")
5017 @click.option("--metric", prompt=True, help="Name of the metric (e.g. cpu_utilization)")
5018 @click.option(
5019     "--severity",
5020     default="WARNING",
5021     help="severity of the alarm (WARNING, MINOR, MAJOR, CRITICAL, INDETERMINATE)",
5022 )
5023 @click.option(
5024     "--threshold_value",
5025     prompt=True,
5026     help="threshold value that, when crossed, an alarm is triggered",
5027 )
5028 @click.option(
5029     "--threshold_operator",
5030     prompt=True,
5031     help="threshold operator describing the comparison (GE, LE, GT, LT, EQ)",
5032 )
5033 @click.option(
5034     "--statistic",
5035     default="AVERAGE",
5036     help="statistic (AVERAGE, MINIMUM, MAXIMUM, COUNT, SUM)",
5037 )
5038 @click.pass_context
5039 def ns_alarm_create(
5040     ctx,
5041     name,
5042     ns,
5043     vnf,
5044     vdu,
5045     metric,
5046     severity,
5047     threshold_value,
5048     threshold_operator,
5049     statistic,
5050 ):
5051     """creates a new alarm for a NS instance"""
5052     # TODO: Check how to validate threshold_value.
5053     # Should it be an integer (1-100), percentage, or decimal (0.01-1.00)?
5054     logger.debug("")
5055     # try:
5056     ns_instance = ctx.obj.ns.get(ns)
5057     alarm = {}
5058     alarm["alarm_name"] = name
5059     alarm["ns_id"] = ns_instance["_id"]
5060     alarm["correlation_id"] = ns_instance["_id"]
5061     alarm["vnf_member_index"] = vnf
5062     alarm["vdu_name"] = vdu
5063     alarm["metric_name"] = metric
5064     alarm["severity"] = severity
5065     alarm["threshold_value"] = int(threshold_value)
5066     alarm["operation"] = threshold_operator
5067     alarm["statistic"] = statistic
5068     check_client_version(ctx.obj, ctx.command.name)
5069     ctx.obj.ns.create_alarm(alarm)
5070     # except ClientException as e:
5071     #     print(str(e))
5072     #     exit(1)
5073
5074
5075 # @cli_osm.command(name='ns-alarm-delete')
5076 # @click.argument('name')
5077 # @click.pass_context
5078 # def ns_alarm_delete(ctx, name):
5079 #    """deletes an alarm
5080 #
5081 #    NAME: name of the alarm to be deleted
5082 #    """
5083 #    try:
5084 #        check_client_version(ctx.obj, ctx.command.name)
5085 #        ctx.obj.ns.delete_alarm(name)
5086 #    except ClientException as e:
5087 #        print(str(e))
5088 #        exit(1)
5089
5090
5091 ####################
5092 # Performance Management operations
5093 ####################
5094
5095
5096 @cli_osm.command(
5097     name="ns-metric-export",
5098     short_help="exports a metric to the internal OSM bus, which can be read by other apps",
5099 )
5100 @click.option("--ns", prompt=True, help="NS instance id or name")
5101 @click.option(
5102     "--vnf", prompt=True, help="VNF name (VNF member index as declared in the NSD)"
5103 )
5104 @click.option("--vdu", prompt=True, help="VDU name (VDU name as declared in the VNFD)")
5105 @click.option("--metric", prompt=True, help="name of the metric (e.g. cpu_utilization)")
5106 # @click.option('--period', default='1w',
5107 #              help='metric collection period (e.g. 20s, 30m, 2h, 3d, 1w)')
5108 @click.option(
5109     "--interval", help="periodic interval (seconds) to export metrics continuously"
5110 )
5111 @click.pass_context
5112 def ns_metric_export(ctx, ns, vnf, vdu, metric, interval):
5113     """exports a metric to the internal OSM bus, which can be read by other apps"""
5114     # TODO: Check how to validate interval.
5115     # Should it be an integer (seconds), or should a suffix (s,m,h,d,w) also be permitted?
5116     logger.debug("")
5117     # try:
5118     ns_instance = ctx.obj.ns.get(ns)
5119     metric_data = {}
5120     metric_data["ns_id"] = ns_instance["_id"]
5121     metric_data["correlation_id"] = ns_instance["_id"]
5122     metric_data["vnf_member_index"] = vnf
5123     metric_data["vdu_name"] = vdu
5124     metric_data["metric_name"] = metric
5125     metric_data["collection_unit"] = "WEEK"
5126     metric_data["collection_period"] = 1
5127     check_client_version(ctx.obj, ctx.command.name)
5128     if not interval:
5129         print("{}".format(ctx.obj.ns.export_metric(metric_data)))
5130     else:
5131         i = 1
5132         while True:
5133             print("{} {}".format(ctx.obj.ns.export_metric(metric_data), i))
5134             time.sleep(int(interval))
5135             i += 1
5136     # except ClientException as e:
5137     #     print(str(e))
5138     #     exit(1)
5139
5140
5141 #################
5142 # Subscription operations
5143 #################
5144
5145
5146 @cli_osm.command(
5147     name="subscription-create",
5148     short_help="creates a new subscription to a specific event",
5149 )
5150 @click.option(
5151     "--event_type",
5152     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5153     type=click.Choice(["ns"], case_sensitive=False),
5154     help="event type to be subscribed (for the moment, only ns is supported)",
5155 )
5156 @click.option("--event", default=None, help="specific yaml configuration for the event")
5157 @click.option(
5158     "--event_file", default=None, help="specific yaml configuration file for the event"
5159 )
5160 @click.pass_context
5161 def subscription_create(ctx, event_type, event, event_file):
5162     """creates a new subscription to a specific event"""
5163     logger.debug("")
5164     check_client_version(ctx.obj, ctx.command.name)
5165     if event_file:
5166         if event:
5167             raise ClientException(
5168                 '"--event" option is incompatible with "--event_file" option'
5169             )
5170         with open(event_file, "r") as cf:
5171             event = cf.read()
5172     ctx.obj.subscription.create(event_type, event)
5173
5174
5175 @cli_osm.command(name="subscription-delete", short_help="deletes a subscription")
5176 @click.option(
5177     "--event_type",
5178     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5179     type=click.Choice(["ns"], case_sensitive=False),
5180     help="event type to be subscribed (for the moment, only ns is supported)",
5181 )
5182 @click.argument("subscription_id")
5183 @click.option(
5184     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
5185 )
5186 @click.pass_context
5187 def subscription_delete(ctx, event_type, subscription_id, force):
5188     """deletes a subscription
5189
5190     SUBSCRIPTION_ID: ID of the subscription to be deleted
5191     """
5192     logger.debug("")
5193     check_client_version(ctx.obj, ctx.command.name)
5194     ctx.obj.subscription.delete(event_type, subscription_id, force)
5195
5196
5197 @cli_osm.command(name="subscription-list", short_help="list all subscriptions")
5198 @click.option(
5199     "--event_type",
5200     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5201     type=click.Choice(["ns"], case_sensitive=False),
5202     help="event type to be subscribed (for the moment, only ns is supported)",
5203 )
5204 @click.option(
5205     "--filter",
5206     default=None,
5207     multiple=True,
5208     help="restricts the list to the subscriptions matching the filter",
5209 )
5210 @click.pass_context
5211 def subscription_list(ctx, event_type, filter):
5212     """list all subscriptions"""
5213     logger.debug("")
5214     check_client_version(ctx.obj, ctx.command.name)
5215     if filter:
5216         filter = "&".join(filter)
5217     resp = ctx.obj.subscription.list(event_type, filter)
5218     table = PrettyTable(["id", "filter", "CallbackUri"])
5219     for sub in resp:
5220         table.add_row(
5221             [
5222                 sub["_id"],
5223                 wrap_text(text=json.dumps(sub["filter"], indent=2), width=70),
5224                 sub["CallbackUri"],
5225             ]
5226         )
5227     table.align = "l"
5228     print(table)
5229
5230
5231 @cli_osm.command(
5232     name="subscription-show", short_help="shows the details of a subscription"
5233 )
5234 @click.argument("subscription_id")
5235 @click.option(
5236     "--event_type",
5237     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5238     type=click.Choice(["ns"], case_sensitive=False),
5239     help="event type to be subscribed (for the moment, only ns is supported)",
5240 )
5241 @click.option(
5242     "--filter",
5243     multiple=True,
5244     help="restricts the information to the fields in the filter",
5245 )
5246 @click.pass_context
5247 def subscription_show(ctx, event_type, subscription_id, filter):
5248     """shows the details of a subscription
5249
5250     SUBSCRIPTION_ID: ID of the subscription
5251     """
5252     logger.debug("")
5253     # try:
5254     resp = ctx.obj.subscription.get(subscription_id)
5255     table = PrettyTable(["key", "attribute"])
5256     for k, v in list(resp.items()):
5257         if not filter or k in filter:
5258             table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
5259     table.align = "l"
5260     print(table)
5261
5262
5263 ####################
5264 # Other operations
5265 ####################
5266
5267
5268 @cli_osm.command(name="version", short_help="shows client and server versions")
5269 @click.pass_context
5270 def get_version(ctx):
5271     """shows client and server versions"""
5272     # try:
5273     check_client_version(ctx.obj, "version")
5274     print("Server version: {}".format(ctx.obj.get_version()))
5275     print(
5276         "Client version: {}".format(pkg_resources.get_distribution("osmclient").version)
5277     )
5278     # except ClientException as e:
5279     #     print(str(e))
5280     #     exit(1)
5281
5282
5283 @cli_osm.command(
5284     name="upload-package", short_help="uploads a VNF package or NS package"
5285 )
5286 @click.argument("filename")
5287 @click.option(
5288     "--skip-charm-build",
5289     default=False,
5290     is_flag=True,
5291     help="the charm will not be compiled, it is assumed to already exist",
5292 )
5293 @click.pass_context
5294 def upload_package(ctx, filename, skip_charm_build):
5295     """uploads a vnf package or ns package
5296
5297     filename: vnf or ns package folder, or vnf or ns package file (tar.gz)
5298     """
5299     logger.debug("")
5300     # try:
5301     ctx.obj.package.upload(filename, skip_charm_build=skip_charm_build)
5302     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
5303     if fullclassname != "osmclient.sol005.client.Client":
5304         ctx.obj.package.wait_for_upload(filename)
5305     # except ClientException as e:
5306     #     print(str(e))
5307     #     exit(1)
5308
5309
5310 # @cli_osm.command(name='ns-scaling-show')
5311 # @click.argument('ns_name')
5312 # @click.pass_context
5313 # def show_ns_scaling(ctx, ns_name):
5314 #    """shows the status of a NS scaling operation
5315 #
5316 #    NS_NAME: name of the NS instance being scaled
5317 #    """
5318 #    try:
5319 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5320 #        resp = ctx.obj.ns.list()
5321 #    except ClientException as e:
5322 #        print(str(e))
5323 #        exit(1)
5324 #
5325 #    table = PrettyTable(
5326 #        ['group-name',
5327 #         'instance-id',
5328 #         'operational status',
5329 #         'create-time',
5330 #         'vnfr ids'])
5331 #
5332 #    for ns in resp:
5333 #        if ns_name == ns['name']:
5334 #            nsopdata = ctx.obj.ns.get_opdata(ns['id'])
5335 #            scaling_records = nsopdata['nsr:nsr']['scaling-group-record']
5336 #            for record in scaling_records:
5337 #                if 'instance' in record:
5338 #                    instances = record['instance']
5339 #                    for inst in instances:
5340 #                        table.add_row(
5341 #                            [record['scaling-group-name-ref'],
5342 #                             inst['instance-id'],
5343 #                                inst['op-status'],
5344 #                                time.strftime('%Y-%m-%d %H:%M:%S',
5345 #                                              time.localtime(
5346 #                                                  inst['create-time'])),
5347 #                                inst['vnfrs']])
5348 #    table.align = 'l'
5349 #    print(table)
5350
5351
5352 # @cli_osm.command(name='ns-scale')
5353 # @click.argument('ns_name')
5354 # @click.option('--ns_scale_group', prompt=True)
5355 # @click.option('--index', prompt=True)
5356 # @click.option('--wait',
5357 #              required=False,
5358 #              default=False,
5359 #              is_flag=True,
5360 #              help='do not return the control immediately, but keep it \
5361 #              until the operation is completed, or timeout')
5362 # @click.pass_context
5363 # def ns_scale(ctx, ns_name, ns_scale_group, index, wait):
5364 #    """scales NS
5365 #
5366 #    NS_NAME: name of the NS instance to be scaled
5367 #    """
5368 #    try:
5369 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5370 #        ctx.obj.ns.scale(ns_name, ns_scale_group, index, wait=wait)
5371 #    except ClientException as e:
5372 #        print(str(e))
5373 #        exit(1)
5374
5375
5376 # @cli_osm.command(name='config-agent-list')
5377 # @click.pass_context
5378 # def config_agent_list(ctx):
5379 #    """list config agents"""
5380 #    try:
5381 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5382 #    except ClientException as e:
5383 #        print(str(e))
5384 #        exit(1)
5385 #    table = PrettyTable(['name', 'account-type', 'details'])
5386 #    for account in ctx.obj.vca.list():
5387 #        table.add_row(
5388 #            [account['name'],
5389 #             account['account-type'],
5390 #             account['juju']])
5391 #    table.align = 'l'
5392 #    print(table)
5393
5394
5395 # @cli_osm.command(name='config-agent-delete')
5396 # @click.argument('name')
5397 # @click.pass_context
5398 # def config_agent_delete(ctx, name):
5399 #    """deletes a config agent
5400 #
5401 #    NAME: name of the config agent to be deleted
5402 #    """
5403 #    try:
5404 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5405 #        ctx.obj.vca.delete(name)
5406 #    except ClientException as e:
5407 #        print(str(e))
5408 #        exit(1)
5409
5410
5411 # @cli_osm.command(name='config-agent-add')
5412 # @click.option('--name',
5413 #              prompt=True)
5414 # @click.option('--account_type',
5415 #              prompt=True)
5416 # @click.option('--server',
5417 #              prompt=True)
5418 # @click.option('--user',
5419 #              prompt=True)
5420 # @click.option('--secret',
5421 #              prompt=True,
5422 #              hide_input=True,
5423 #              confirmation_prompt=True)
5424 # @click.pass_context
5425 # def config_agent_add(ctx, name, account_type, server, user, secret):
5426 #    """adds a config agent"""
5427 #    try:
5428 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5429 #        ctx.obj.vca.create(name, account_type, server, user, secret)
5430 #    except ClientException as e:
5431 #        print(str(e))
5432 #        exit(1)
5433
5434
5435 # @cli_osm.command(name='ro-dump')
5436 # @click.pass_context
5437 # def ro_dump(ctx):
5438 #    """shows RO agent information"""
5439 #    check_client_version(ctx.obj, ctx.command.name, 'v1')
5440 #    resp = ctx.obj.vim.get_resource_orchestrator()
5441 #    table = PrettyTable(['key', 'attribute'])
5442 #    for k, v in list(resp.items()):
5443 #        table.add_row([k, json.dumps(v, indent=2)])
5444 #    table.align = 'l'
5445 #    print(table)
5446
5447
5448 # @cli_osm.command(name='vcs-list')
5449 # @click.pass_context
5450 # def vcs_list(ctx):
5451 #    check_client_version(ctx.obj, ctx.command.name, 'v1')
5452 #    resp = ctx.obj.utils.get_vcs_info()
5453 #    table = PrettyTable(['component name', 'state'])
5454 #    for component in resp:
5455 #        table.add_row([component['component_name'], component['state']])
5456 #    table.align = 'l'
5457 #    print(table)
5458
5459
5460 @cli_osm.command(
5461     name="ns-action", short_help="executes an action/primitive over a NS instance"
5462 )
5463 @click.argument("ns_name")
5464 @click.option(
5465     "--vnf_name",
5466     default=None,
5467     help="member-vnf-index if the target is a vnf instead of a ns)",
5468 )
5469 @click.option("--kdu_name", default=None, help="kdu-name if the target is a kdu)")
5470 @click.option("--vdu_id", default=None, help="vdu-id if the target is a vdu")
5471 @click.option(
5472     "--vdu_count", default=None, type=int, help="number of vdu instance of this vdu_id"
5473 )
5474 @click.option("--action_name", prompt=True, help="action name")
5475 @click.option("--params", default=None, help="action params in YAML/JSON inline string")
5476 @click.option("--params_file", default=None, help="YAML/JSON file with action params")
5477 @click.option(
5478     "--timeout", required=False, default=None, type=int, help="timeout in seconds"
5479 )
5480 @click.option(
5481     "--wait",
5482     required=False,
5483     default=False,
5484     is_flag=True,
5485     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5486 )
5487 @click.pass_context
5488 def ns_action(
5489     ctx,
5490     ns_name,
5491     vnf_name,
5492     kdu_name,
5493     vdu_id,
5494     vdu_count,
5495     action_name,
5496     params,
5497     params_file,
5498     timeout,
5499     wait,
5500 ):
5501     """executes an action/primitive over a NS instance
5502
5503     NS_NAME: name or ID of the NS instance
5504     """
5505     logger.debug("")
5506     # try:
5507     check_client_version(ctx.obj, ctx.command.name)
5508     op_data = {}
5509     if vnf_name:
5510         op_data["member_vnf_index"] = vnf_name
5511     if kdu_name:
5512         op_data["kdu_name"] = kdu_name
5513     if vdu_id:
5514         op_data["vdu_id"] = vdu_id
5515     if vdu_count is not None:
5516         op_data["vdu_count_index"] = vdu_count
5517     if timeout:
5518         op_data["timeout_ns_action"] = timeout
5519     op_data["primitive"] = action_name
5520     if params_file:
5521         with open(params_file, "r") as pf:
5522             params = pf.read()
5523     if params:
5524         op_data["primitive_params"] = yaml.safe_load(params)
5525     else:
5526         op_data["primitive_params"] = {}
5527     print(ctx.obj.ns.exec_op(ns_name, op_name="action", op_data=op_data, wait=wait))
5528
5529     # except ClientException as e:
5530     #     print(str(e))
5531     #     exit(1)
5532
5533
5534 @cli_osm.command(
5535     name="vnf-scale", short_help="executes a VNF scale (adding/removing VDUs)"
5536 )
5537 @click.argument("ns_name")
5538 @click.argument("vnf_name")
5539 @click.option(
5540     "--scaling-group", prompt=True, help="scaling-group-descriptor name to use"
5541 )
5542 @click.option(
5543     "--scale-in", default=False, is_flag=True, help="performs a scale in operation"
5544 )
5545 @click.option(
5546     "--scale-out",
5547     default=False,
5548     is_flag=True,
5549     help="performs a scale out operation (by default)",
5550 )
5551 @click.option(
5552     "--timeout", required=False, default=None, type=int, help="timeout in seconds"
5553 )
5554 @click.option(
5555     "--wait",
5556     required=False,
5557     default=False,
5558     is_flag=True,
5559     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5560 )
5561 @click.pass_context
5562 def vnf_scale(
5563     ctx, ns_name, vnf_name, scaling_group, scale_in, scale_out, timeout, wait
5564 ):
5565     """
5566     Executes a VNF scale (adding/removing VDUs)
5567
5568     \b
5569     NS_NAME: name or ID of the NS instance.
5570     VNF_NAME: member-vnf-index in the NS to be scaled.
5571     """
5572     logger.debug("")
5573     # try:
5574     check_client_version(ctx.obj, ctx.command.name)
5575     if not scale_in and not scale_out:
5576         scale_out = True
5577     ctx.obj.ns.scale_vnf(
5578         ns_name, vnf_name, scaling_group, scale_in, scale_out, wait, timeout
5579     )
5580     # except ClientException as e:
5581     #     print(str(e))
5582     #     exit(1)
5583
5584
5585 @cli_osm.command(
5586     name="ns-update", short_help="executes an update of a Network Service."
5587 )
5588 @click.argument("ns_name")
5589 @click.option(
5590     "--updatetype", required=True, type=str, help="available types: CHANGE_VNFPKG"
5591 )
5592 @click.option(
5593     "--config",
5594     required=True,
5595     type=str,
5596     help="extra information for update operation as YAML/JSON inline string as --config"
5597     " '{changeVnfPackageData:[{vnfInstanceId: xxx, vnfdId: yyy}]}'",
5598 )
5599 @click.option(
5600     "--timeout", required=False, default=None, type=int, help="timeout in seconds"
5601 )
5602 @click.option(
5603     "--wait",
5604     required=False,
5605     default=False,
5606     is_flag=True,
5607     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5608 )
5609 @click.pass_context
5610 def update(ctx, ns_name, updatetype, config, timeout, wait):
5611     """Executes an update of a Network Service.
5612
5613     The update will check new revisions of the Network Functions that are part of the
5614     Network Service, and it will update them if needed.
5615     Sample update command: osm ns-update  ns_instance_id --updatetype CHANGE_VNFPKG
5616     --config '{changeVnfPackageData: [{vnfInstanceId: id_x,vnfdId: id_y}]}' --timeout 300 --wait
5617
5618     NS_NAME: Network service instance name or ID.
5619
5620     """
5621     op_data = {
5622         "timeout": timeout,
5623         "updateType": updatetype,
5624     }
5625     if config:
5626         op_data["config"] = yaml.safe_load(config)
5627
5628     check_client_version(ctx.obj, ctx.command.name)
5629     ctx.obj.ns.update(ns_name, op_data, wait=wait)
5630
5631
5632 def iterator_split(iterator, separators):
5633     """
5634     Splits a tuple or list into several lists whenever a separator is found
5635     For instance, the following tuple will be separated with the separator "--vnf" as follows.
5636     From:
5637         ("--vnf", "A", "--cause", "cause_A", "--vdu", "vdu_A1", "--vnf", "B", "--cause", "cause_B", ...
5638         "--vdu", "vdu_B1", "--count_index", "1", "--run-day1", "--vdu", "vdu_B1", "--count_index", "2")
5639     To:
5640         [
5641             ("--vnf", "A", "--cause", "cause_A", "--vdu", "vdu_A1"),
5642             ("--vnf", "B", "--cause", "cause_B", "--vdu", "vdu_B1", "--count_index", "1", "--run-day1", ...
5643              "--vdu", "vdu_B1", "--count_index", "2")
5644         ]
5645
5646     Returns as many lists as separators are found
5647     """
5648     logger.debug("")
5649     if iterator[0] not in separators:
5650         raise ClientException(f"Expected one of {separators}. Received: {iterator[0]}.")
5651     list_of_lists = []
5652     first = 0
5653     for i in range(len(iterator)):
5654         if iterator[i] in separators:
5655             if i == first:
5656                 continue
5657             if i - first < 2:
5658                 raise ClientException(
5659                     f"Expected at least one argument after separator (possible separators: {separators})."
5660                 )
5661             list_of_lists.append(list(iterator[first:i]))
5662             first = i
5663     if (len(iterator) - first) < 2:
5664         raise ClientException(
5665             f"Expected at least one argument after separator (possible separators: {separators})."
5666         )
5667     else:
5668         list_of_lists.append(list(iterator[first : len(iterator)]))
5669     # logger.debug(f"List of lists: {list_of_lists}")
5670     return list_of_lists
5671
5672
5673 def process_common_heal_params(heal_vnf_dict, args):
5674     logger.debug("")
5675     current_item = "vnf"
5676     i = 0
5677     while i < len(args):
5678         if args[i] == "--cause":
5679             if (i + 1 >= len(args)) or args[i + 1].startswith("--"):
5680                 raise ClientException("No cause was provided after --cause")
5681             heal_vnf_dict["cause"] = args[i + 1]
5682             i = i + 2
5683             continue
5684         if args[i] == "--run-day1":
5685             if current_item == "vnf":
5686                 if "additionalParams" not in heal_vnf_dict:
5687                     heal_vnf_dict["additionalParams"] = {}
5688                 heal_vnf_dict["additionalParams"]["run-day1"] = True
5689             else:
5690                 # if current_item == "vdu"
5691                 heal_vnf_dict["additionalParams"]["vdu"][-1]["run-day1"] = True
5692             i = i + 1
5693             continue
5694         if args[i] == "--vdu":
5695             if "additionalParams" not in heal_vnf_dict:
5696                 heal_vnf_dict["additionalParams"] = {}
5697                 heal_vnf_dict["additionalParams"]["vdu"] = []
5698             if (i + 1 >= len(args)) or args[i + 1].startswith("--"):
5699                 raise ClientException("No VDU ID was provided after --vdu")
5700             heal_vnf_dict["additionalParams"]["vdu"].append({"vdu-id": args[i + 1]})
5701             current_item = "vdu"
5702             i = i + 2
5703             continue
5704         if args[i] == "--count-index":
5705             if current_item == "vnf":
5706                 raise ClientException(
5707                     "Option --count-index only applies to VDU, not to VNF"
5708                 )
5709             if (i + 1 >= len(args)) or args[i + 1].startswith("--"):
5710                 raise ClientException("No count index was provided after --count-index")
5711             heal_vnf_dict["additionalParams"]["vdu"][-1]["count-index"] = int(
5712                 args[i + 1]
5713             )
5714             i = i + 2
5715             continue
5716         i = i + 1
5717     return
5718
5719
5720 def process_ns_heal_params(ctx, param, value):
5721     """
5722     Processes the params in the command ns-heal
5723     Click does not allow advanced patterns for positional options like this:
5724     --vnf volumes_vnf --cause "Heal several_volumes-VM of several_volumes_vnf"
5725                       --vdu several_volumes-VM
5726     --vnf charm_vnf --cause "Heal two VMs of native_manual_scale_charm_vnf"
5727                     --vdu mgmtVM --count-index 1 --run-day1
5728                     --vdu mgmtVM --count-index 2
5729
5730     It returns the dictionary with all the params stored in ctx.params["heal_params"]
5731     """
5732     logger.debug("")
5733     # logger.debug(f"Args: {value}")
5734     if param.name != "args":
5735         raise ClientException(f"Unexpected param: {param.name}")
5736     # Split the tuple "value" by "--vnf"
5737     vnfs = iterator_split(value, ["--vnf"])
5738     logger.debug(f"VNFs: {vnfs}")
5739     heal_dict = {}
5740     heal_dict["healVnfData"] = []
5741     for vnf in vnfs:
5742         # logger.debug(f"VNF: {vnf}")
5743         heal_vnf = {}
5744         if vnf[1].startswith("--"):
5745             raise ClientException("Expected a VNF_ID after --vnf")
5746         heal_vnf["vnfInstanceId"] = vnf[1]
5747         process_common_heal_params(heal_vnf, vnf[2:])
5748         heal_dict["healVnfData"].append(heal_vnf)
5749     ctx.params["heal_params"] = heal_dict
5750     return
5751
5752
5753 @cli_osm.command(
5754     name="ns-heal",
5755     short_help="heals (recreates) VNFs or VDUs of a NS instance",
5756     context_settings=dict(
5757         ignore_unknown_options=True,
5758     ),
5759 )
5760 @click.argument("ns_name")
5761 @click.argument(
5762     "args",
5763     nargs=-1,
5764     type=click.UNPROCESSED,
5765     callback=process_ns_heal_params,
5766 )
5767 @click.option("--timeout", type=int, default=None, help="timeout in seconds")
5768 @click.option(
5769     "--wait",
5770     default=False,
5771     is_flag=True,
5772     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5773 )
5774 @click.pass_context
5775 def ns_heal(ctx, ns_name, args, heal_params, timeout, wait):
5776     """heals (recreates) VNFs or VDUs of a NS instance
5777
5778     NS_NAME: name or ID of the NS instance
5779
5780     \b
5781     Options:
5782       --vnf TEXT             VNF instance ID or VNF id in the NS [required]
5783       --cause TEXT           human readable cause of the healing
5784       --run-day1             indicates whether or not to run day1 primitives for the VNF/VDU
5785       --vdu TEXT             vdu-id
5786       --count-index INTEGER  count-index
5787
5788     \b
5789     Example:
5790     osm ns-heal NS_NAME|NS_ID --vnf volumes_vnf --cause "Heal several_volumes-VM of several_volumes_vnf"
5791                                                 --vdu several_volumes-VM
5792                               --vnf charm_vnf --cause "Heal two VMs of native_manual_scale_charm_vnf"
5793                                               --vdu mgmtVM --count-index 1 --run-day1
5794                                               --vdu mgmtVM --count-index 2
5795     """
5796     logger.debug("")
5797     heal_dict = ctx.params["heal_params"]
5798     logger.debug(f"Heal dict:\n{yaml.safe_dump(heal_dict)}")
5799     # replace VNF id in the NS by the VNF instance ID
5800     for vnf in heal_dict["healVnfData"]:
5801         vnf_id = vnf["vnfInstanceId"]
5802         if not validate_uuid4(vnf_id):
5803             vnf_filter = f"member-vnf-index-ref={vnf_id}"
5804             vnf_list = ctx.obj.vnf.list(ns=ns_name, filter=vnf_filter)
5805             if len(vnf_list) == 0:
5806                 raise ClientException(
5807                     f"No VNF found in NS {ns_name} with filter {vnf_filter}"
5808                 )
5809             elif len(vnf_list) == 1:
5810                 vnf["vnfInstanceId"] = vnf_list[0]["_id"]
5811             else:
5812                 raise ClientException(
5813                     f"More than 1 VNF found in NS {ns_name} with filter {vnf_filter}"
5814                 )
5815     logger.debug(f"Heal dict:\n{yaml.safe_dump(heal_dict)}")
5816     check_client_version(ctx.obj, ctx.command.name)
5817     ctx.obj.ns.heal(ns_name, heal_dict, wait, timeout)
5818     exit(0)
5819
5820
5821 def process_vnf_heal_params(ctx, param, value):
5822     """
5823     Processes the params in the command vnf-heal
5824     Click does not allow advanced patterns for positional options like this:
5825     --vdu mgmtVM --count-index 1 --run-day1 --vdu mgmtVM --count-index 2
5826
5827     It returns the dictionary with all the params stored in ctx.params["heal_params"]
5828     """
5829     logger.debug("")
5830     # logger.debug(f"Args: {value}")
5831     if param.name != "args":
5832         raise ClientException(f"Unexpected param: {param.name}")
5833     # Split the tuple "value" by "--vnf"
5834     vnf = value
5835     heal_dict = {}
5836     heal_dict["healVnfData"] = []
5837     logger.debug(f"VNF: {vnf}")
5838     heal_vnf = {"vnfInstanceId": "id_to_be_substituted"}
5839     process_common_heal_params(heal_vnf, vnf)
5840     heal_dict["healVnfData"].append(heal_vnf)
5841     ctx.params["heal_params"] = heal_dict
5842     return
5843
5844
5845 @cli_osm.command(
5846     name="vnf-heal",
5847     short_help="heals (recreates) a VNF instance or the VDUs of a VNF instance",
5848     context_settings=dict(
5849         ignore_unknown_options=True,
5850     ),
5851 )
5852 @click.argument("vnf_name")
5853 @click.argument(
5854     "args",
5855     nargs=-1,
5856     type=click.UNPROCESSED,
5857     callback=process_vnf_heal_params,
5858 )
5859 @click.option("--timeout", type=int, default=None, help="timeout in seconds")
5860 @click.option(
5861     "--wait",
5862     default=False,
5863     is_flag=True,
5864     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5865 )
5866 @click.pass_context
5867 def vnf_heal2(
5868     ctx,
5869     vnf_name,
5870     args,
5871     heal_params,
5872     timeout,
5873     wait,
5874 ):
5875     """heals (recreates) a VNF instance or the VDUs of a VNF instance
5876
5877     VNF_NAME: name or ID of the VNF instance
5878
5879     \b
5880     Options:
5881       --cause TEXT           human readable cause of the healing of the VNF
5882       --run-day1             indicates whether or not to run day1 primitives for the VNF/VDU
5883       --vdu TEXT             vdu-id
5884       --count-index INTEGER  count-index
5885
5886     \b
5887     Example:
5888     osm vnf-heal VNF_INSTANCE_ID --vdu mgmtVM --count-index 1 --run-day1
5889                                  --vdu mgmtVM --count-index 2
5890     """
5891     logger.debug("")
5892     heal_dict = ctx.params["heal_params"]
5893     heal_dict["healVnfData"][-1]["vnfInstanceId"] = vnf_name
5894     logger.debug(f"Heal dict:\n{yaml.safe_dump(heal_dict)}")
5895     check_client_version(ctx.obj, ctx.command.name)
5896     vnfr = ctx.obj.vnf.get(vnf_name)
5897     ns_id = vnfr["nsr-id-ref"]
5898     ctx.obj.ns.heal(ns_id, heal_dict, wait, timeout)
5899     exit(0)
5900
5901
5902 @cli_osm.command(name="alarm-show", short_help="show alarm details")
5903 @click.argument("uuid")
5904 @click.pass_context
5905 def alarm_show(ctx, uuid):
5906     """Show alarm's detail information"""
5907
5908     check_client_version(ctx.obj, ctx.command.name)
5909     resp = ctx.obj.ns.get_alarm(uuid=uuid)
5910     alarm_filter = [
5911         "uuid",
5912         "name",
5913         "metric",
5914         "statistic",
5915         "threshold",
5916         "operation",
5917         "ns-id",
5918         "vnf-id",
5919         "vdu_name",
5920         "action",
5921         "status",
5922     ]
5923     table = PrettyTable(["key", "attribute"])
5924     try:
5925         # Arrange and return the response data
5926         alarm = resp.replace("ObjectId", "")
5927         for key in alarm_filter:
5928             if key == "uuid":
5929                 value = alarm.get(key)
5930                 key = "alarm-id"
5931             elif key == "name":
5932                 value = alarm.get(key)
5933                 key = "alarm-name"
5934             elif key == "ns-id":
5935                 value = alarm["tags"].get("ns_id")
5936             elif key == "vdu_name":
5937                 value = alarm["tags"].get("vdu_name")
5938             elif key == "status":
5939                 value = alarm["alarm_status"]
5940             else:
5941                 value = alarm[key]
5942             table.add_row([key, wrap_text(text=json.dumps(value, indent=2), width=100)])
5943         table.align = "l"
5944         print(table)
5945     except Exception:
5946         print(resp)
5947
5948
5949 # List alarm
5950 @cli_osm.command(name="alarm-list", short_help="list all alarms")
5951 @click.option(
5952     "--ns_id", default=None, required=False, help="List out alarm for given ns id"
5953 )
5954 @click.pass_context
5955 def alarm_list(ctx, ns_id):
5956     """list all alarm"""
5957
5958     check_client_version(ctx.obj, ctx.command.name)
5959     project_name = os.getenv("OSM_PROJECT", "admin")
5960     resp = ctx.obj.ns.get_alarm(project_name=project_name, ns_id=ns_id)
5961
5962     table = PrettyTable(
5963         ["alarm-id", "metric", "threshold", "operation", "action", "status"]
5964     )
5965     if resp:
5966         # return the response data in a table
5967         resp = resp.replace("ObjectId", "")
5968         for alarm in resp:
5969             table.add_row(
5970                 [
5971                     wrap_text(text=str(alarm["uuid"]), width=38),
5972                     alarm["metric"],
5973                     alarm["threshold"],
5974                     alarm["operation"],
5975                     wrap_text(text=alarm["action"], width=25),
5976                     alarm["alarm_status"],
5977                 ]
5978             )
5979     table.align = "l"
5980     print(table)
5981
5982
5983 # Update alarm
5984 @cli_osm.command(name="alarm-update", short_help="Update a alarm")
5985 @click.argument("uuid")
5986 @click.option("--threshold", default=None, help="Alarm threshold")
5987 @click.option("--is_enable", default=None, type=bool, help="enable or disable alarm")
5988 @click.pass_context
5989 def alarm_update(ctx, uuid, threshold, is_enable):
5990     """
5991     Update alarm
5992
5993     """
5994     if not threshold and is_enable is None:
5995         raise ClientException(
5996             "Please provide option to update i.e threshold or is_enable"
5997         )
5998     ctx.obj.ns.update_alarm(uuid, threshold, is_enable)
5999
6000
6001 ##############################
6002 # Role Management Operations #
6003 ##############################
6004
6005
6006 @cli_osm.command(name="role-create", short_help="creates a new role")
6007 @click.argument("name")
6008 @click.option("--permissions", default=None, help="role permissions using a dictionary")
6009 @click.pass_context
6010 def role_create(ctx, name, permissions):
6011     """
6012     Creates a new role.
6013
6014     \b
6015     NAME: Name or ID of the role.
6016     DEFINITION: Definition of grant/denial of access to resources.
6017     """
6018     logger.debug("")
6019     # try:
6020     check_client_version(ctx.obj, ctx.command.name)
6021     ctx.obj.role.create(name, permissions)
6022     # except ClientException as e:
6023     #     print(str(e))
6024     #     exit(1)
6025
6026
6027 @cli_osm.command(name="role-update", short_help="updates a role")
6028 @click.argument("name")
6029 @click.option("--set-name", default=None, help="change name of rle")
6030 # @click.option('--permissions',
6031 #               default=None,
6032 #               help='provide a yaml format dictionary with incremental changes. Values can be bool or None to delete')
6033 @click.option(
6034     "--add",
6035     default=None,
6036     help="yaml format dictionary with permission: True/False to access grant/denial",
6037 )
6038 @click.option("--remove", default=None, help="yaml format list to remove a permission")
6039 @click.pass_context
6040 def role_update(ctx, name, set_name, add, remove):
6041     """
6042     Updates a role.
6043
6044     \b
6045     NAME: Name or ID of the role.
6046     DEFINITION: Definition overwrites the old definition.
6047     ADD: Grant/denial of access to resource to add.
6048     REMOVE: Grant/denial of access to resource to remove.
6049     """
6050     logger.debug("")
6051     # try:
6052     check_client_version(ctx.obj, ctx.command.name)
6053     ctx.obj.role.update(name, set_name, None, add, remove)
6054     # except ClientException as e:
6055     #     print(str(e))
6056     #     exit(1)
6057
6058
6059 @cli_osm.command(name="role-delete", short_help="deletes a role")
6060 @click.argument("name")
6061 # @click.option('--force', is_flag=True, help='forces the deletion bypassing pre-conditions')
6062 @click.pass_context
6063 def role_delete(ctx, name):
6064     """
6065     Deletes a role.
6066
6067     \b
6068     NAME: Name or ID of the role.
6069     """
6070     logger.debug("")
6071     # try:
6072     check_client_version(ctx.obj, ctx.command.name)
6073     ctx.obj.role.delete(name)
6074     # except ClientException as e:
6075     #     print(str(e))
6076     #     exit(1)
6077
6078
6079 @cli_osm.command(name="role-list", short_help="list all roles")
6080 @click.option(
6081     "--filter",
6082     default=None,
6083     multiple=True,
6084     help="restricts the list to the projects matching the filter",
6085 )
6086 @click.pass_context
6087 def role_list(ctx, filter):
6088     """
6089     List all roles.
6090     """
6091     logger.debug("")
6092     # try:
6093     check_client_version(ctx.obj, ctx.command.name)
6094     if filter:
6095         filter = "&".join(filter)
6096     resp = ctx.obj.role.list(filter)
6097     # except ClientException as e:
6098     #     print(str(e))
6099     #     exit(1)
6100     table = PrettyTable(["name", "id"])
6101     for role in resp:
6102         table.add_row([role["name"], role["_id"]])
6103     table.align = "l"
6104     print(table)
6105
6106
6107 @cli_osm.command(name="role-show", short_help="show specific role")
6108 @click.argument("name")
6109 @click.pass_context
6110 def role_show(ctx, name):
6111     """
6112     Shows the details of a role.
6113
6114     \b
6115     NAME: Name or ID of the role.
6116     """
6117     logger.debug("")
6118     # try:
6119     check_client_version(ctx.obj, ctx.command.name)
6120     resp = ctx.obj.role.get(name)
6121     # except ClientException as e:
6122     #     print(str(e))
6123     #     exit(1)
6124
6125     table = PrettyTable(["key", "attribute"])
6126     for k, v in resp.items():
6127         table.add_row([k, json.dumps(v, indent=2)])
6128     table.align = "l"
6129     print(table)
6130
6131
6132 @cli_osm.command(name="package-create", short_help="Create empty NS package structure")
6133 @click.argument("package-type")
6134 @click.argument("package-name")
6135 @click.option(
6136     "--base-directory",
6137     default=".",
6138     help=('(NS/VNF/NST) Set the location for package creation. Default: "."'),
6139 )
6140 @click.option(
6141     "--image",
6142     default="image-name",
6143     help='(VNF) Set the name of the vdu image. Default "image-name"',
6144 )
6145 @click.option(
6146     "--vdus", default=1, help="(VNF) Set the number of vdus in a VNF. Default 1"
6147 )
6148 @click.option(
6149     "--vcpu", default=1, help="(VNF) Set the number of virtual CPUs in a vdu. Default 1"
6150 )
6151 @click.option(
6152     "--memory",
6153     default=1024,
6154     help="(VNF) Set the memory size (MB) of the vdu. Default 1024",
6155 )
6156 @click.option(
6157     "--storage", default=10, help="(VNF) Set the disk size (GB) of the vdu. Default 10"
6158 )
6159 @click.option(
6160     "--interfaces",
6161     default=0,
6162     help="(VNF) Set the number of additional interfaces apart from the management interface. Default 0",
6163 )
6164 @click.option(
6165     "--vendor", default="OSM", help='(NS/VNF) Set the descriptor vendor. Default "OSM"'
6166 )
6167 @click.option(
6168     "--override",
6169     default=False,
6170     is_flag=True,
6171     help="(NS/VNF/NST) Flag for overriding the package if exists.",
6172 )
6173 @click.option(
6174     "--detailed",
6175     is_flag=True,
6176     default=False,
6177     help="(NS/VNF/NST) Flag for generating descriptor .yaml with all possible commented options",
6178 )
6179 @click.option(
6180     "--netslice-subnets", default=1, help="(NST) Number of netslice subnets. Default 1"
6181 )
6182 @click.option(
6183     "--netslice-vlds", default=1, help="(NST) Number of netslice vlds. Default 1"
6184 )
6185 @click.option(
6186     "--old",
6187     default=False,
6188     is_flag=True,
6189     help="Flag to create a descriptor using the previous OSM format (pre SOL006, OSM<9)",
6190 )
6191 @click.pass_context
6192 def package_create(
6193     ctx,
6194     package_type,
6195     base_directory,
6196     package_name,
6197     override,
6198     image,
6199     vdus,
6200     vcpu,
6201     memory,
6202     storage,
6203     interfaces,
6204     vendor,
6205     detailed,
6206     netslice_subnets,
6207     netslice_vlds,
6208     old,
6209 ):
6210     """
6211     Creates an OSM NS, VNF, NST package
6212
6213     \b
6214     PACKAGE_TYPE: Package to be created: NS, VNF or NST.
6215     PACKAGE_NAME: Name of the package to create the folder with the content.
6216     """
6217
6218     # try:
6219     logger.debug("")
6220     check_client_version(ctx.obj, ctx.command.name)
6221     print(
6222         "Creating the {} structure: {}/{}".format(
6223             package_type.upper(), base_directory, package_name
6224         )
6225     )
6226     resp = ctx.obj.package_tool.create(
6227         package_type,
6228         base_directory,
6229         package_name,
6230         override=override,
6231         image=image,
6232         vdus=vdus,
6233         vcpu=vcpu,
6234         memory=memory,
6235         storage=storage,
6236         interfaces=interfaces,
6237         vendor=vendor,
6238         detailed=detailed,
6239         netslice_subnets=netslice_subnets,
6240         netslice_vlds=netslice_vlds,
6241         old=old,
6242     )
6243     print(resp)
6244     # except ClientException as inst:
6245     #     print("ERROR: {}".format(inst))
6246     #     exit(1)
6247
6248
6249 @cli_osm.command(
6250     name="package-validate", short_help="Validate descriptors given a base directory"
6251 )
6252 @click.argument("base-directory", default=".", required=False)
6253 @click.option(
6254     "--recursive/--no-recursive",
6255     default=True,
6256     help="The activated recursive option will validate the yaml files"
6257     " within the indicated directory and in its subdirectories",
6258 )
6259 @click.option(
6260     "--old",
6261     is_flag=True,
6262     default=False,
6263     help="Validates also the descriptors using the previous OSM format (pre SOL006)",
6264 )
6265 @click.pass_context
6266 def package_validate(ctx, base_directory, recursive, old):
6267     """
6268     Validate descriptors given a base directory.
6269
6270     \b
6271     BASE_DIRECTORY: Base folder for NS, VNF or NST package.
6272     """
6273     # try:
6274     logger.debug("")
6275     check_client_version(ctx.obj, ctx.command.name)
6276     results = ctx.obj.package_tool.validate(base_directory, recursive, old)
6277     table = PrettyTable()
6278     table.field_names = ["TYPE", "PATH", "VALID", "ERROR"]
6279     # Print the dictionary generated by the validation function
6280     for result in results:
6281         table.add_row(
6282             [result["type"], result["path"], result["valid"], result["error"]]
6283         )
6284     table.sortby = "VALID"
6285     table.align["PATH"] = "l"
6286     table.align["TYPE"] = "l"
6287     table.align["ERROR"] = "l"
6288     print(table)
6289     # except ClientException as inst:
6290     #     print("ERROR: {}".format(inst))
6291     #     exit(1)
6292
6293
6294 @cli_osm.command(
6295     name="package-translate", short_help="Translate descriptors given a base directory"
6296 )
6297 @click.argument("base-directory", default=".", required=False)
6298 @click.option(
6299     "--recursive/--no-recursive",
6300     default=True,
6301     help="The activated recursive option will translate the yaml files"
6302     " within the indicated directory and in its subdirectories",
6303 )
6304 @click.option(
6305     "--dryrun",
6306     is_flag=True,
6307     default=False,
6308     help="Do not translate yet, only make a dry-run to test translation",
6309 )
6310 @click.pass_context
6311 def package_translate(ctx, base_directory, recursive, dryrun):
6312     """
6313     Translate descriptors given a base directory.
6314
6315     \b
6316     BASE_DIRECTORY: Stub folder for NS, VNF or NST package.
6317     """
6318     logger.debug("")
6319     check_client_version(ctx.obj, ctx.command.name)
6320     results = ctx.obj.package_tool.translate(base_directory, recursive, dryrun)
6321     table = PrettyTable()
6322     table.field_names = [
6323         "CURRENT TYPE",
6324         "NEW TYPE",
6325         "PATH",
6326         "VALID",
6327         "TRANSLATED",
6328         "ERROR",
6329     ]
6330     # Print the dictionary generated by the validation function
6331     for result in results:
6332         table.add_row(
6333             [
6334                 result["current type"],
6335                 result["new type"],
6336                 result["path"],
6337                 result["valid"],
6338                 result["translated"],
6339                 result["error"],
6340             ]
6341         )
6342     table.sortby = "TRANSLATED"
6343     table.align["PATH"] = "l"
6344     table.align["TYPE"] = "l"
6345     table.align["ERROR"] = "l"
6346     print(table)
6347     # except ClientException as inst:
6348     #     print("ERROR: {}".format(inst))
6349     #     exit(1)
6350
6351
6352 @cli_osm.command(name="package-build", short_help="Build the tar.gz of the package")
6353 @click.argument("package-folder")
6354 @click.option(
6355     "--skip-validation", default=False, is_flag=True, help="skip package validation"
6356 )
6357 @click.option(
6358     "--skip-charm-build",
6359     default=False,
6360     is_flag=True,
6361     help="the charm will not be compiled, it is assumed to already exist",
6362 )
6363 @click.pass_context
6364 def package_build(ctx, package_folder, skip_validation, skip_charm_build):
6365     """
6366     Build the package NS, VNF given the package_folder.
6367
6368     \b
6369     PACKAGE_FOLDER: Folder of the NS, VNF or NST to be packaged
6370     """
6371     # try:
6372     logger.debug("")
6373     check_client_version(ctx.obj, ctx.command.name)
6374     results = ctx.obj.package_tool.build(
6375         package_folder,
6376         skip_validation=skip_validation,
6377         skip_charm_build=skip_charm_build,
6378     )
6379     print(results)
6380     # except ClientException as inst:
6381     #     print("ERROR: {}".format(inst))
6382     #     exit(1)
6383
6384
6385 @cli_osm.command(
6386     name="descriptor-translate",
6387     short_help="Translate input descriptor file from Rel EIGHT OSM descriptors to SOL006 and prints in standard output",
6388 )
6389 @click.argument("descriptor-file", required=True)
6390 @click.pass_context
6391 def descriptor_translate(ctx, descriptor_file):
6392     """
6393     Translate input descriptor.
6394
6395     \b
6396     DESCRIPTOR_FILE: Descriptor file for NS, VNF or Network Slice.
6397     """
6398     logger.debug("")
6399     check_client_version(ctx.obj, ctx.command.name)
6400     result = ctx.obj.package_tool.descriptor_translate(descriptor_file)
6401     print(result)
6402
6403
6404 def cli():
6405     try:
6406         cli_osm()  # pylint: disable=no-value-for-parameter
6407         exit(0)
6408     except pycurl.error as exc:
6409         print(exc)
6410         print(
6411             'Maybe "--hostname" option or OSM_HOSTNAME environment variable needs to be specified'
6412         )
6413     except ClientException as exc:
6414         print("ERROR: {}".format(exc))
6415     except (FileNotFoundError, PermissionError) as exc:
6416         print("Cannot open file: {}".format(exc))
6417     except yaml.YAMLError as exc:
6418         print("Invalid YAML format: {}".format(exc))
6419     exit(1)
6420     # TODO capture other controlled exceptions here
6421     # TODO remove the ClientException captures from all places, unless they do something different
6422
6423
6424 if __name__ == "__main__":
6425     cli()