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.get("queuePosition") is not None and op.get("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 def _check_ca_cert(vim_config: dict) -> None:
3086     """
3087     Checks if the VIM has a CA certificate.
3088     In that case, reads the content and add it to the config
3089     : param vim_config: configuration provided with the VIM creation
3090     : return: None
3091     """
3092
3093     if vim_config.get("ca_cert"):
3094         with open(vim_config["ca_cert"], "r") as cert_f:
3095             vim_config["ca_cert_content"] = str(cert_f.read())
3096             del vim_config["ca_cert"]
3097
3098
3099 @cli_osm.command(name="vim-create", short_help="creates a new VIM account")
3100 @click.option("--name", required=True, help="Name to create datacenter")
3101 @click.option("--user", default=None, help="VIM username")
3102 @click.option("--password", default=None, help="VIM password")
3103 @click.option("--auth_url", default=None, help="VIM url")
3104 @click.option(
3105     "--tenant", "--project", "tenant", default=None, help="VIM tenant/project name"
3106 )
3107 @click.option("--config", default=None, help="VIM specific config parameters")
3108 @click.option(
3109     "--config_file",
3110     default=None,
3111     help="VIM specific config parameters in YAML or JSON file",
3112 )
3113 @click.option("--account_type", default="openstack", help="VIM type")
3114 @click.option("--description", default=None, help="human readable description")
3115 @click.option(
3116     "--sdn_controller",
3117     default=None,
3118     help="Name or id of the SDN controller associated to this VIM account",
3119 )
3120 @click.option(
3121     "--sdn_port_mapping",
3122     default=None,
3123     help="File describing the port mapping between compute nodes' ports and switch ports",
3124 )
3125 @click.option(
3126     "--wait",
3127     required=False,
3128     default=False,
3129     is_flag=True,
3130     help="do not return the control immediately, but keep it "
3131     "until the operation is completed, or timeout",
3132 )
3133 @click.option("--vca", default=None, help="VCA to be used in this VIM account")
3134 @click.option(
3135     "--creds", default=None, help="credentials file (only applycable for GCP VIM type)"
3136 )
3137 @click.option(
3138     "--prometheus_config_file",
3139     default=None,
3140     help="Prometheus configuration to get VIM data",
3141 )
3142 @click.pass_context
3143 def vim_create(
3144     ctx,
3145     name,
3146     user,
3147     password,
3148     auth_url,
3149     tenant,
3150     config,
3151     config_file,
3152     account_type,
3153     description,
3154     sdn_controller,
3155     sdn_port_mapping,
3156     wait,
3157     vca,
3158     creds,
3159     prometheus_config_file,
3160 ):
3161     """creates a new VIM account"""
3162     logger.debug("")
3163     # try:
3164     if sdn_controller:
3165         check_client_version(ctx.obj, "--sdn_controller")
3166     if sdn_port_mapping:
3167         check_client_version(ctx.obj, "--sdn_port_mapping")
3168     vim = {}
3169     if prometheus_config_file:
3170         with open(prometheus_config_file) as prometheus_file:
3171             prometheus_config_dict = json.load(prometheus_file)
3172         vim["prometheus-config"] = prometheus_config_dict
3173
3174     vim["vim-username"] = user
3175     vim["vim-password"] = password
3176     vim["vim-url"] = auth_url
3177     vim["vim-tenant-name"] = tenant
3178     vim["vim-type"] = account_type
3179     vim["description"] = description
3180     if vca:
3181         vim["vca"] = vca
3182     vim_config = create_config(config_file, config)
3183     _check_ca_cert(vim_config)
3184     if creds:
3185         with open(creds, "r") as cf:
3186             vim_config["credentials"] = yaml.safe_load(cf.read())
3187     ctx.obj.vim.create(
3188         name, vim, vim_config, sdn_controller, sdn_port_mapping, wait=wait
3189     )
3190     # except ClientException as e:
3191     #     print(str(e))
3192     #     exit(1)
3193
3194
3195 @cli_osm.command(name="vim-update", short_help="updates a VIM account")
3196 @click.argument("name")
3197 @click.option("--newname", help="New name for the VIM account")
3198 @click.option("--user", help="VIM username")
3199 @click.option("--password", help="VIM password")
3200 @click.option("--auth_url", help="VIM url")
3201 @click.option("--tenant", help="VIM tenant name")
3202 @click.option("--config", help="VIM specific config parameters")
3203 @click.option(
3204     "--config_file",
3205     default=None,
3206     help="VIM specific config parameters in YAML or JSON file",
3207 )
3208 @click.option("--account_type", help="VIM type")
3209 @click.option("--description", help="human readable description")
3210 @click.option(
3211     "--sdn_controller",
3212     default=None,
3213     help="Name or id of the SDN controller to be associated with this VIM"
3214     "account. Use empty string to disassociate",
3215 )
3216 @click.option(
3217     "--sdn_port_mapping",
3218     default=None,
3219     help="File describing the port mapping between compute nodes' ports and switch ports",
3220 )
3221 @click.option(
3222     "--wait",
3223     required=False,
3224     default=False,
3225     is_flag=True,
3226     help="do not return the control immediately, but keep it "
3227     "until the operation is completed, or timeout",
3228 )
3229 @click.option(
3230     "--creds", default=None, help="credentials file (only applycable for GCP VIM type)"
3231 )
3232 @click.option(
3233     "--prometheus_config_file",
3234     default=None,
3235     help="Prometheus configuration to get VIM data",
3236 )
3237 @click.pass_context
3238 def vim_update(
3239     ctx,
3240     name,
3241     newname,
3242     user,
3243     password,
3244     auth_url,
3245     tenant,
3246     config,
3247     config_file,
3248     account_type,
3249     description,
3250     sdn_controller,
3251     sdn_port_mapping,
3252     wait,
3253     creds,
3254     prometheus_config_file,
3255 ):
3256     """updates a VIM account
3257
3258     NAME: name or ID of the VIM account
3259     """
3260     logger.debug("")
3261     # try:
3262     check_client_version(ctx.obj, ctx.command.name)
3263     vim = {}
3264     if newname:
3265         vim["name"] = newname
3266     if user:
3267         vim["vim_user"] = user
3268     if password:
3269         vim["vim_password"] = password
3270     if auth_url:
3271         vim["vim_url"] = auth_url
3272     if tenant:
3273         vim["vim-tenant-name"] = tenant
3274     if account_type:
3275         vim["vim_type"] = account_type
3276     if description:
3277         vim["description"] = description
3278     vim_config = None
3279     if config or config_file:
3280         vim_config = create_config(config_file, config)
3281         _check_ca_cert(vim_config)
3282     if creds:
3283         with open(creds, "r") as cf:
3284             vim_config["credentials"] = yaml.safe_load(cf.read())
3285     if prometheus_config_file:
3286         with open(prometheus_config_file) as prometheus_file:
3287             prometheus_config_dict = json.load(prometheus_file)
3288         vim["prometheus-config"] = prometheus_config_dict
3289     logger.info(f"VIM: {vim}, VIM config: {vim_config}")
3290     ctx.obj.vim.update(
3291         name, vim, vim_config, sdn_controller, sdn_port_mapping, wait=wait
3292     )
3293     # except ClientException as e:
3294     #     print(str(e))
3295     #     exit(1)
3296
3297
3298 @cli_osm.command(name="vim-delete", short_help="deletes a VIM account")
3299 @click.argument("name")
3300 @click.option(
3301     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3302 )
3303 @click.option(
3304     "--wait",
3305     required=False,
3306     default=False,
3307     is_flag=True,
3308     help="do not return the control immediately, but keep it "
3309     "until the operation is completed, or timeout",
3310 )
3311 @click.pass_context
3312 def vim_delete(ctx, name, force, wait):
3313     """deletes a VIM account
3314
3315     NAME: name or ID of the VIM account to be deleted
3316     """
3317     logger.debug("")
3318     # try:
3319     if not force:
3320         ctx.obj.vim.delete(name, wait=wait)
3321     else:
3322         check_client_version(ctx.obj, "--force")
3323         ctx.obj.vim.delete(name, force, wait=wait)
3324     # except ClientException as e:
3325     #     print(str(e))
3326     #     exit(1)
3327
3328
3329 @cli_osm.command(name="vim-list", short_help="list all VIM accounts")
3330 # @click.option('--ro_update/--no_ro_update',
3331 #              default=False,
3332 #              help='update list from RO')
3333 @click.option(
3334     "--filter",
3335     default=None,
3336     multiple=True,
3337     help="restricts the list to the VIM accounts matching the filter",
3338 )
3339 @click.option(
3340     "--long",
3341     is_flag=True,
3342     help="get more details of the NS (project, vim, deployment status, configuration status.",
3343 )
3344 @click.pass_context
3345 def vim_list(ctx, filter, long):
3346     """list all VIM accounts"""
3347     logger.debug("")
3348     if filter:
3349         filter = "&".join(filter)
3350         check_client_version(ctx.obj, "--filter")
3351     #    if ro_update:
3352     #        check_client_version(ctx.obj, '--ro_update', 'v1')
3353     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
3354     if fullclassname == "osmclient.sol005.client.Client":
3355         resp = ctx.obj.vim.list(filter)
3356     #    else:
3357     #        resp = ctx.obj.vim.list(ro_update)
3358     if long:
3359         table = PrettyTable(
3360             ["vim name", "uuid", "project", "operational state", "error details"]
3361         )
3362         project_list = ctx.obj.project.list()
3363     else:
3364         table = PrettyTable(["vim name", "uuid", "operational state"])
3365     for vim in resp:
3366         if long:
3367             if "vim_password" in vim:
3368                 vim["vim_password"] = "********"
3369             if "config" in vim and "credentials" in vim["config"]:
3370                 vim["config"]["credentials"] = "********"
3371             logger.debug("VIM details: {}".format(yaml.safe_dump(vim)))
3372             vim_state = vim["_admin"].get("operationalState", "-")
3373             error_details = "N/A"
3374             if vim_state == "ERROR":
3375                 error_details = vim["_admin"].get("detailed-status", "Not found")
3376             project_id, project_name = get_project(project_list, vim)
3377             # project_info = '{} ({})'.format(project_name, project_id)
3378             project_info = project_name
3379             table.add_row(
3380                 [
3381                     vim["name"],
3382                     vim["uuid"],
3383                     project_info,
3384                     vim_state,
3385                     wrap_text(text=error_details, width=80),
3386                 ]
3387             )
3388         else:
3389             table.add_row(
3390                 [vim["name"], vim["uuid"], vim["_admin"].get("operationalState", "-")]
3391             )
3392     table.align = "l"
3393     print(table)
3394
3395
3396 @cli_osm.command(name="vim-show", short_help="shows the details of a VIM account")
3397 @click.argument("name")
3398 @click.option(
3399     "--filter",
3400     multiple=True,
3401     help="restricts the information to the fields in the filter",
3402 )
3403 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
3404 @click.pass_context
3405 def vim_show(ctx, name, filter, literal):
3406     """shows the details of a VIM account
3407
3408     NAME: name or ID of the VIM account
3409     """
3410     logger.debug("")
3411     # try:
3412     resp = ctx.obj.vim.get(name)
3413     if "vim_password" in resp:
3414         resp["vim_password"] = "********"
3415     if "config" in resp and "credentials" in resp["config"]:
3416         resp["config"]["credentials"] = "********"
3417     # except ClientException as e:
3418     #     print(str(e))
3419     #     exit(1)
3420
3421     if literal:
3422         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
3423         return
3424     table = PrettyTable(["key", "attribute"])
3425     for k, v in list(resp.items()):
3426         if not filter or k in filter:
3427             table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
3428     table.align = "l"
3429     print(table)
3430
3431
3432 ####################
3433 # WIM operations
3434 ####################
3435
3436
3437 @cli_osm.command(name="wim-create", short_help="creates a new WIM account")
3438 @click.option("--name", prompt=True, help="Name for the WIM account")
3439 @click.option("--user", help="WIM username")
3440 @click.option("--password", help="WIM password")
3441 @click.option("--url", prompt=True, help="WIM url")
3442 # @click.option('--tenant',
3443 #               help='wIM tenant name')
3444 @click.option("--config", default=None, help="WIM specific config parameters")
3445 @click.option("--wim_type", help="WIM type")
3446 @click.option("--description", default=None, help="human readable description")
3447 @click.option(
3448     "--wim_port_mapping",
3449     default=None,
3450     help="File describing the port mapping between DC edge (datacenters, switches, ports) and WAN edge "
3451     "(WAN service endpoint id and info)",
3452 )
3453 @click.option(
3454     "--wait",
3455     required=False,
3456     default=False,
3457     is_flag=True,
3458     help="do not return the control immediately, but keep it "
3459     "until the operation is completed, or timeout",
3460 )
3461 @click.pass_context
3462 def wim_create(
3463     ctx,
3464     name,
3465     user,
3466     password,
3467     url,
3468     # tenant,
3469     config,
3470     wim_type,
3471     description,
3472     wim_port_mapping,
3473     wait,
3474 ):
3475     """creates a new WIM account"""
3476     logger.debug("")
3477     # try:
3478     check_client_version(ctx.obj, ctx.command.name)
3479     # if sdn_controller:
3480     #     check_client_version(ctx.obj, '--sdn_controller')
3481     # if sdn_port_mapping:
3482     #     check_client_version(ctx.obj, '--sdn_port_mapping')
3483     wim = {}
3484     if user:
3485         wim["user"] = user
3486     if password:
3487         wim["password"] = password
3488     if url:
3489         wim["wim_url"] = url
3490     # if tenant: wim['tenant'] = tenant
3491     wim["wim_type"] = wim_type
3492     if description:
3493         wim["description"] = description
3494     if config:
3495         wim["config"] = config
3496     ctx.obj.wim.create(name, wim, wim_port_mapping, wait=wait)
3497     # except ClientException as e:
3498     #     print(str(e))
3499     #     exit(1)
3500
3501
3502 @cli_osm.command(name="wim-update", short_help="updates a WIM account")
3503 @click.argument("name")
3504 @click.option("--newname", help="New name for the WIM account")
3505 @click.option("--user", help="WIM username")
3506 @click.option("--password", help="WIM password")
3507 @click.option("--url", help="WIM url")
3508 @click.option("--config", help="WIM specific config parameters")
3509 @click.option("--wim_type", help="WIM type")
3510 @click.option("--description", help="human readable description")
3511 @click.option(
3512     "--wim_port_mapping",
3513     default=None,
3514     help="File describing the port mapping between DC edge (datacenters, switches, ports) and WAN edge "
3515     "(WAN service endpoint id and info)",
3516 )
3517 @click.option(
3518     "--wait",
3519     required=False,
3520     default=False,
3521     is_flag=True,
3522     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3523 )
3524 @click.pass_context
3525 def wim_update(
3526     ctx,
3527     name,
3528     newname,
3529     user,
3530     password,
3531     url,
3532     config,
3533     wim_type,
3534     description,
3535     wim_port_mapping,
3536     wait,
3537 ):
3538     """updates a WIM account
3539
3540     NAME: name or ID of the WIM account
3541     """
3542     logger.debug("")
3543     # try:
3544     check_client_version(ctx.obj, ctx.command.name)
3545     wim = {}
3546     if newname:
3547         wim["name"] = newname
3548     if user:
3549         wim["user"] = user
3550     if password:
3551         wim["password"] = password
3552     if url:
3553         wim["url"] = url
3554     # if tenant: wim['tenant'] = tenant
3555     if wim_type:
3556         wim["wim_type"] = wim_type
3557     if description:
3558         wim["description"] = description
3559     if config:
3560         wim["config"] = config
3561     ctx.obj.wim.update(name, wim, wim_port_mapping, wait=wait)
3562     # except ClientException as e:
3563     #     print(str(e))
3564     #     exit(1)
3565
3566
3567 @cli_osm.command(name="wim-delete", short_help="deletes a WIM account")
3568 @click.argument("name")
3569 @click.option(
3570     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3571 )
3572 @click.option(
3573     "--wait",
3574     required=False,
3575     default=False,
3576     is_flag=True,
3577     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3578 )
3579 @click.pass_context
3580 def wim_delete(ctx, name, force, wait):
3581     """deletes a WIM account
3582
3583     NAME: name or ID of the WIM account to be deleted
3584     """
3585     logger.debug("")
3586     # try:
3587     check_client_version(ctx.obj, ctx.command.name)
3588     ctx.obj.wim.delete(name, force, wait=wait)
3589     # except ClientException as e:
3590     #     print(str(e))
3591     #     exit(1)
3592
3593
3594 @cli_osm.command(name="wim-list", short_help="list all WIM accounts")
3595 @click.option(
3596     "--filter",
3597     default=None,
3598     multiple=True,
3599     help="restricts the list to the WIM accounts matching the filter",
3600 )
3601 @click.pass_context
3602 def wim_list(ctx, filter):
3603     """list all WIM accounts"""
3604     logger.debug("")
3605     # try:
3606     check_client_version(ctx.obj, ctx.command.name)
3607     if filter:
3608         filter = "&".join(filter)
3609     resp = ctx.obj.wim.list(filter)
3610     table = PrettyTable(["wim name", "uuid"])
3611     for wim in resp:
3612         table.add_row([wim["name"], wim["uuid"]])
3613     table.align = "l"
3614     print(table)
3615     # except ClientException as e:
3616     #     print(str(e))
3617     #     exit(1)
3618
3619
3620 @cli_osm.command(name="wim-show", short_help="shows the details of a WIM account")
3621 @click.argument("name")
3622 @click.pass_context
3623 def wim_show(ctx, name):
3624     """shows the details of a WIM account
3625
3626     NAME: name or ID of the WIM account
3627     """
3628     logger.debug("")
3629     # try:
3630     check_client_version(ctx.obj, ctx.command.name)
3631     resp = ctx.obj.wim.get(name)
3632     if "password" in resp:
3633         resp["password"] = "********"
3634     # except ClientException as e:
3635     #     print(str(e))
3636     #     exit(1)
3637
3638     table = PrettyTable(["key", "attribute"])
3639     for k, v in list(resp.items()):
3640         table.add_row([k, json.dumps(v, indent=2)])
3641     table.align = "l"
3642     print(table)
3643
3644
3645 ####################
3646 # SDN controller operations
3647 ####################
3648
3649
3650 @cli_osm.command(name="sdnc-create", short_help="creates a new SDN controller")
3651 @click.option("--name", prompt=True, help="Name to create sdn controller")
3652 @click.option("--type", prompt=True, help="SDN controller type")
3653 @click.option(
3654     "--sdn_controller_version",  # hidden=True,
3655     help="Deprecated. Use --config {version: sdn_controller_version}",
3656 )
3657 @click.option("--url", help="URL in format http[s]://HOST:IP/")
3658 @click.option("--ip_address", help="Deprecated. Use --url")  # hidden=True,
3659 @click.option("--port", help="Deprecated. Use --url")  # hidden=True,
3660 @click.option(
3661     "--switch_dpid", help="Deprecated. Use --config {switch_id: DPID}"  # hidden=True,
3662 )
3663 @click.option(
3664     "--config",
3665     help="Extra information for SDN in yaml format, as {switch_id: identity used for the plugin (e.g. DPID: "
3666     "Openflow Datapath ID), version: version}",
3667 )
3668 @click.option("--user", help="SDN controller username")
3669 @click.option(
3670     "--password",
3671     hide_input=True,
3672     confirmation_prompt=True,
3673     help="SDN controller password",
3674 )
3675 @click.option("--description", default=None, help="human readable description")
3676 @click.option(
3677     "--wait",
3678     required=False,
3679     default=False,
3680     is_flag=True,
3681     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3682 )
3683 @click.pass_context
3684 def sdnc_create(ctx, **kwargs):
3685     """creates a new SDN controller"""
3686     logger.debug("")
3687     sdncontroller = {
3688         x: kwargs[x]
3689         for x in kwargs
3690         if kwargs[x] and x not in ("wait", "ip_address", "port", "switch_dpid")
3691     }
3692     if kwargs.get("port"):
3693         print("option '--port' is deprecated, use '--url' instead")
3694         sdncontroller["port"] = int(kwargs["port"])
3695     if kwargs.get("ip_address"):
3696         print("option '--ip_address' is deprecated, use '--url' instead")
3697         sdncontroller["ip"] = kwargs["ip_address"]
3698     if kwargs.get("switch_dpid"):
3699         print(
3700             "option '--switch_dpid' is deprecated, use '--config={switch_id: id|DPID}' instead"
3701         )
3702         sdncontroller["dpid"] = kwargs["switch_dpid"]
3703     if kwargs.get("sdn_controller_version"):
3704         print(
3705             "option '--sdn_controller_version' is deprecated, use '--config={version: SDN_CONTROLLER_VERSION}'"
3706             " instead"
3707         )
3708     # try:
3709     check_client_version(ctx.obj, ctx.command.name)
3710     ctx.obj.sdnc.create(kwargs["name"], sdncontroller, wait=kwargs["wait"])
3711     # except ClientException as e:
3712     #     print(str(e))
3713     #     exit(1)
3714
3715
3716 @cli_osm.command(name="sdnc-update", short_help="updates an SDN controller")
3717 @click.argument("name")
3718 @click.option("--newname", help="New name for the SDN controller")
3719 @click.option("--description", default=None, help="human readable description")
3720 @click.option("--type", help="SDN controller type")
3721 @click.option("--url", help="URL in format http[s]://HOST:IP/")
3722 @click.option(
3723     "--config",
3724     help="Extra information for SDN in yaml format, as "
3725     "{switch_id: identity used for the plugin (e.g. DPID: "
3726     "Openflow Datapath ID), version: version}",
3727 )
3728 @click.option("--user", help="SDN controller username")
3729 @click.option("--password", help="SDN controller password")
3730 @click.option("--ip_address", help="Deprecated. Use --url")  # hidden=True
3731 @click.option("--port", help="Deprecated. Use --url")  # hidden=True
3732 @click.option(
3733     "--switch_dpid", help="Deprecated. Use --config {switch_dpid: DPID}"
3734 )  # hidden=True
3735 @click.option(
3736     "--sdn_controller_version", help="Deprecated. Use --config {version: VERSION}"
3737 )  # hidden=True
3738 @click.option(
3739     "--wait",
3740     required=False,
3741     default=False,
3742     is_flag=True,
3743     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3744 )
3745 @click.pass_context
3746 def sdnc_update(ctx, **kwargs):
3747     """updates an SDN controller
3748
3749     NAME: name or ID of the SDN controller
3750     """
3751     logger.debug("")
3752     sdncontroller = {
3753         x: kwargs[x]
3754         for x in kwargs
3755         if kwargs[x]
3756         and x not in ("wait", "ip_address", "port", "switch_dpid", "new_name")
3757     }
3758     if kwargs.get("newname"):
3759         sdncontroller["name"] = kwargs["newname"]
3760     if kwargs.get("port"):
3761         print("option '--port' is deprecated, use '--url' instead")
3762         sdncontroller["port"] = int(kwargs["port"])
3763     if kwargs.get("ip_address"):
3764         print("option '--ip_address' is deprecated, use '--url' instead")
3765         sdncontroller["ip"] = kwargs["ip_address"]
3766     if kwargs.get("switch_dpid"):
3767         print(
3768             "option '--switch_dpid' is deprecated, use '--config={switch_id: id|DPID}' instead"
3769         )
3770         sdncontroller["dpid"] = kwargs["switch_dpid"]
3771     if kwargs.get("sdn_controller_version"):
3772         print(
3773             "option '--sdn_controller_version' is deprecated, use '---config={version: SDN_CONTROLLER_VERSION}'"
3774             " instead"
3775         )
3776
3777     # try:
3778     check_client_version(ctx.obj, ctx.command.name)
3779     ctx.obj.sdnc.update(kwargs["name"], sdncontroller, wait=kwargs["wait"])
3780     # except ClientException as e:
3781     #     print(str(e))
3782     #     exit(1)
3783
3784
3785 @cli_osm.command(name="sdnc-delete", short_help="deletes an SDN controller")
3786 @click.argument("name")
3787 @click.option(
3788     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
3789 )
3790 @click.option(
3791     "--wait",
3792     required=False,
3793     default=False,
3794     is_flag=True,
3795     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
3796 )
3797 @click.pass_context
3798 def sdnc_delete(ctx, name, force, wait):
3799     """deletes an SDN controller
3800
3801     NAME: name or ID of the SDN controller to be deleted
3802     """
3803     logger.debug("")
3804     # try:
3805     check_client_version(ctx.obj, ctx.command.name)
3806     ctx.obj.sdnc.delete(name, force, wait=wait)
3807     # except ClientException as e:
3808     #     print(str(e))
3809     #     exit(1)
3810
3811
3812 @cli_osm.command(name="sdnc-list", short_help="list all SDN controllers")
3813 @click.option(
3814     "--filter",
3815     default=None,
3816     multiple=True,
3817     help="restricts the list to the SDN controllers matching the filter with format: 'k[.k..]=v[&k[.k]=v2]'",
3818 )
3819 @click.pass_context
3820 def sdnc_list(ctx, filter):
3821     """list all SDN controllers"""
3822     logger.debug("")
3823     # try:
3824     check_client_version(ctx.obj, ctx.command.name)
3825     if filter:
3826         filter = "&".join(filter)
3827     resp = ctx.obj.sdnc.list(filter)
3828     # except ClientException as e:
3829     #     print(str(e))
3830     #     exit(1)
3831     table = PrettyTable(["sdnc name", "id"])
3832     for sdnc in resp:
3833         table.add_row([sdnc["name"], sdnc["_id"]])
3834     table.align = "l"
3835     print(table)
3836
3837
3838 @cli_osm.command(name="sdnc-show", short_help="shows the details of an SDN controller")
3839 @click.argument("name")
3840 @click.pass_context
3841 def sdnc_show(ctx, name):
3842     """shows the details of an SDN controller
3843
3844     NAME: name or ID of the SDN controller
3845     """
3846     logger.debug("")
3847     # try:
3848     check_client_version(ctx.obj, ctx.command.name)
3849     resp = ctx.obj.sdnc.get(name)
3850     # except ClientException as e:
3851     #     print(str(e))
3852     #     exit(1)
3853
3854     table = PrettyTable(["key", "attribute"])
3855     for k, v in list(resp.items()):
3856         table.add_row([k, json.dumps(v, indent=2)])
3857     table.align = "l"
3858     print(table)
3859
3860
3861 ###########################
3862 # K8s cluster operations
3863 ###########################
3864
3865
3866 @cli_osm.command(name="k8scluster-add", short_help="adds a K8s cluster to OSM")
3867 @click.argument("name")
3868 @click.option(
3869     "--creds", prompt=True, help="credentials file, i.e. a valid `.kube/config` file"
3870 )
3871 @click.option("--version", prompt=True, help="Kubernetes version")
3872 @click.option(
3873     "--vim", prompt=True, help="VIM target, the VIM where the cluster resides"
3874 )
3875 @click.option(
3876     "--k8s-nets",
3877     prompt=True,
3878     help='''list of VIM networks, in JSON inline format, where the cluster is
3879     accessible via L3 routing, e.g. "{(k8s_net1:vim_network1) [,(k8s_net2:vim_network2) ...]}"''',
3880 )
3881 @click.option(
3882     "--init-helm2/--skip-helm2",
3883     required=False,
3884     default=True,
3885     help="Initialize helm v2",
3886 )
3887 @click.option(
3888     "--init-helm3/--skip-helm3",
3889     required=False,
3890     default=True,
3891     help="Initialize helm v3",
3892 )
3893 @click.option(
3894     "--init-jujubundle/--skip-jujubundle",
3895     required=False,
3896     default=True,
3897     help="Initialize juju-bundle",
3898 )
3899 @click.option("--description", default=None, help="human readable description")
3900 @click.option(
3901     "--namespace",
3902     default="kube-system",
3903     help="namespace to be used for its operation, defaults to `kube-system`",
3904 )
3905 @click.option(
3906     "--wait",
3907     required=False,
3908     default=False,
3909     is_flag=True,
3910     help="do not return the control immediately, but keep it "
3911     "until the operation is completed, or timeout",
3912 )
3913 @click.option(
3914     "--cni",
3915     default=None,
3916     help="list of CNI plugins, in JSON inline format, used in the cluster",
3917 )
3918 # @click.option('--skip-init',
3919 #              is_flag=True,
3920 #              help='If set, K8s cluster is assumed to be ready for its use with OSM')
3921 # @click.option('--wait',
3922 #              is_flag=True,
3923 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
3924 @click.pass_context
3925 def k8scluster_add(
3926     ctx,
3927     name,
3928     creds,
3929     version,
3930     vim,
3931     k8s_nets,
3932     init_helm2,
3933     init_helm3,
3934     init_jujubundle,
3935     description,
3936     namespace,
3937     wait,
3938     cni,
3939 ):
3940     """adds a K8s cluster to OSM
3941
3942     NAME: name of the K8s cluster
3943     """
3944     # try:
3945     check_client_version(ctx.obj, ctx.command.name)
3946     cluster = {}
3947     cluster["name"] = name
3948     with open(creds, "r") as cf:
3949         cluster["credentials"] = yaml.safe_load(cf.read())
3950     cluster["k8s_version"] = version
3951     cluster["vim_account"] = vim
3952     cluster["nets"] = yaml.safe_load(k8s_nets)
3953     if not (init_helm2 and init_jujubundle and init_helm3):
3954         cluster["deployment_methods"] = {
3955             "helm-chart": init_helm2,
3956             "juju-bundle": init_jujubundle,
3957             "helm-chart-v3": init_helm3,
3958         }
3959     if description:
3960         cluster["description"] = description
3961     if namespace:
3962         cluster["namespace"] = namespace
3963     if cni:
3964         cluster["cni"] = yaml.safe_load(cni)
3965     ctx.obj.k8scluster.create(name, cluster, wait)
3966     # except ClientException as e:
3967     #     print(str(e))
3968     #     exit(1)
3969
3970
3971 @cli_osm.command(name="k8scluster-update", short_help="updates a K8s cluster")
3972 @click.argument("name")
3973 @click.option("--newname", help="New name for the K8s cluster")
3974 @click.option("--creds", help="credentials file, i.e. a valid `.kube/config` file")
3975 @click.option("--version", help="Kubernetes version")
3976 @click.option("--vim", help="VIM target, the VIM where the cluster resides")
3977 @click.option(
3978     "--k8s-nets",
3979     help='''list of VIM networks, in JSON inline format, where the cluster is accessible
3980     via L3 routing, e.g. "{(k8s_net1:vim_network1) [,(k8s_net2:vim_network2) ...]}"''',
3981 )
3982 @click.option("--description", help="human readable description")
3983 @click.option(
3984     "--namespace",
3985     help="namespace to be used for its operation, defaults to `kube-system`",
3986 )
3987 @click.option(
3988     "--wait",
3989     required=False,
3990     default=False,
3991     is_flag=True,
3992     help="do not return the control immediately, but keep it "
3993     "until the operation is completed, or timeout",
3994 )
3995 @click.option(
3996     "--cni", help="list of CNI plugins, in JSON inline format, used in the cluster"
3997 )
3998 @click.pass_context
3999 def k8scluster_update(
4000     ctx, name, newname, creds, version, vim, k8s_nets, description, namespace, wait, cni
4001 ):
4002     """updates a K8s cluster
4003
4004     NAME: name or ID of the K8s cluster
4005     """
4006     # try:
4007     check_client_version(ctx.obj, ctx.command.name)
4008     cluster = {}
4009     if newname:
4010         cluster["name"] = newname
4011     if creds:
4012         with open(creds, "r") as cf:
4013             cluster["credentials"] = yaml.safe_load(cf.read())
4014     if version:
4015         cluster["k8s_version"] = version
4016     if vim:
4017         cluster["vim_account"] = vim
4018     if k8s_nets:
4019         cluster["nets"] = yaml.safe_load(k8s_nets)
4020     if description:
4021         cluster["description"] = description
4022     if namespace:
4023         cluster["namespace"] = namespace
4024     if cni:
4025         cluster["cni"] = yaml.safe_load(cni)
4026     ctx.obj.k8scluster.update(name, cluster, wait)
4027     # except ClientException as e:
4028     #     print(str(e))
4029     #     exit(1)
4030
4031
4032 @cli_osm.command(name="k8scluster-delete", short_help="deletes a K8s cluster")
4033 @click.argument("name")
4034 @click.option(
4035     "--force", is_flag=True, help="forces the deletion from the DB (not recommended)"
4036 )
4037 @click.option(
4038     "--wait",
4039     required=False,
4040     default=False,
4041     is_flag=True,
4042     help="do not return the control immediately, but keep it "
4043     "until the operation is completed, or timeout",
4044 )
4045 @click.pass_context
4046 def k8scluster_delete(ctx, name, force, wait):
4047     """deletes a K8s cluster
4048
4049     NAME: name or ID of the K8s cluster to be deleted
4050     """
4051     # try:
4052     check_client_version(ctx.obj, ctx.command.name)
4053     ctx.obj.k8scluster.delete(name, force, wait)
4054     # except ClientException as e:
4055     #     print(str(e))
4056     #     exit(1)
4057
4058
4059 @cli_osm.command(name="k8scluster-list")
4060 @click.option(
4061     "--filter",
4062     default=None,
4063     multiple=True,
4064     help="restricts the list to the K8s clusters matching the filter",
4065 )
4066 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4067 @click.option("--long", is_flag=True, help="get more details")
4068 @click.pass_context
4069 def k8scluster_list(ctx, filter, literal, long):
4070     """list all K8s clusters"""
4071     # try:
4072     check_client_version(ctx.obj, ctx.command.name)
4073     if filter:
4074         filter = "&".join(filter)
4075     resp = ctx.obj.k8scluster.list(filter)
4076     if literal:
4077         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4078         return
4079     if long:
4080         table = PrettyTable(
4081             [
4082                 "Name",
4083                 "Id",
4084                 "Project",
4085                 "Version",
4086                 "VIM",
4087                 "K8s-nets",
4088                 "Deployment methods",
4089                 "Operational State",
4090                 "Op. state (details)",
4091                 "Description",
4092                 "Detailed status",
4093             ]
4094         )
4095         project_list = ctx.obj.project.list()
4096     else:
4097         table = PrettyTable(
4098             ["Name", "Id", "VIM", "Operational State", "Op. state details"]
4099         )
4100     try:
4101         vim_list = ctx.obj.vim.list()
4102     except Exception:
4103         vim_list = []
4104     for cluster in resp:
4105         logger.debug("Cluster details: {}".format(yaml.safe_dump(cluster)))
4106         vim_name = get_vim_name(vim_list, cluster["vim_account"])
4107         # vim_info = '{} ({})'.format(vim_name,cluster['vim_account'])
4108         vim_info = vim_name
4109         op_state_details = "Helm: {}\nJuju: {}".format(
4110             cluster["_admin"].get("helm-chart", {}).get("operationalState", "-"),
4111             cluster["_admin"].get("juju-bundle", {}).get("operationalState", "-"),
4112         )
4113         if long:
4114             project_id, project_name = get_project(project_list, cluster)
4115             # project_info = '{} ({})'.format(project_name, project_id)
4116             project_info = project_name
4117             detailed_status = cluster["_admin"].get("detailed-status", "-")
4118             table.add_row(
4119                 [
4120                     cluster["name"],
4121                     cluster["_id"],
4122                     project_info,
4123                     cluster["k8s_version"],
4124                     vim_info,
4125                     json.dumps(cluster["nets"]),
4126                     json.dumps(cluster["deployment_methods"]),
4127                     cluster["_admin"]["operationalState"],
4128                     op_state_details,
4129                     trunc_text(cluster.get("description") or "", 40),
4130                     wrap_text(text=detailed_status, width=40),
4131                 ]
4132             )
4133         else:
4134             table.add_row(
4135                 [
4136                     cluster["name"],
4137                     cluster["_id"],
4138                     vim_info,
4139                     cluster["_admin"]["operationalState"],
4140                     op_state_details,
4141                 ]
4142             )
4143     table.align = "l"
4144     print(table)
4145     # except ClientException as e:
4146     #     print(str(e))
4147     #     exit(1)
4148
4149
4150 @cli_osm.command(
4151     name="k8scluster-show", short_help="shows the details of a K8s cluster"
4152 )
4153 @click.argument("name")
4154 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4155 @click.pass_context
4156 def k8scluster_show(ctx, name, literal):
4157     """shows the details of a K8s cluster
4158
4159     NAME: name or ID of the K8s cluster
4160     """
4161     # try:
4162     resp = ctx.obj.k8scluster.get(name)
4163     if literal:
4164         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4165         return
4166     table = PrettyTable(["key", "attribute"])
4167     for k, v in list(resp.items()):
4168         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
4169     table.align = "l"
4170     print(table)
4171     # except ClientException as e:
4172     #     print(str(e))
4173     #     exit(1)
4174
4175
4176 ###########################
4177 # VCA operations
4178 ###########################
4179
4180
4181 @cli_osm.command(name="vca-add", short_help="adds a VCA (Juju controller) to OSM")
4182 @click.argument("name")
4183 @click.option(
4184     "--endpoints",
4185     prompt=True,
4186     help="Comma-separated list of IP or hostnames of the Juju controller",
4187 )
4188 @click.option("--user", prompt=True, help="Username with admin priviledges")
4189 @click.option("--secret", prompt=True, help="Password of the specified username")
4190 @click.option("--cacert", prompt=True, help="CA certificate")
4191 @click.option(
4192     "--lxd-cloud",
4193     prompt=True,
4194     help="Name of the cloud that will be used for LXD containers (LXD proxy charms)",
4195 )
4196 @click.option(
4197     "--lxd-credentials",
4198     prompt=True,
4199     help="Name of the cloud credentialsto be used for the LXD cloud",
4200 )
4201 @click.option(
4202     "--k8s-cloud",
4203     prompt=True,
4204     help="Name of the cloud that will be used for K8s containers (K8s proxy charms)",
4205 )
4206 @click.option(
4207     "--k8s-credentials",
4208     prompt=True,
4209     help="Name of the cloud credentialsto be used for the K8s cloud",
4210 )
4211 @click.option(
4212     "--model-config",
4213     default={},
4214     help="Configuration options for the models",
4215 )
4216 @click.option("--description", default=None, help="human readable description")
4217 @click.pass_context
4218 def vca_add(
4219     ctx,
4220     name,
4221     endpoints,
4222     user,
4223     secret,
4224     cacert,
4225     lxd_cloud,
4226     lxd_credentials,
4227     k8s_cloud,
4228     k8s_credentials,
4229     model_config,
4230     description,
4231 ):
4232     """adds a VCA to OSM
4233
4234     NAME: name of the VCA
4235     """
4236     check_client_version(ctx.obj, ctx.command.name)
4237     vca = {}
4238     vca["name"] = name
4239     vca["endpoints"] = endpoints.split(",")
4240     vca["user"] = user
4241     vca["secret"] = secret
4242     vca["cacert"] = cacert
4243     vca["lxd-cloud"] = lxd_cloud
4244     vca["lxd-credentials"] = lxd_credentials
4245     vca["k8s-cloud"] = k8s_cloud
4246     vca["k8s-credentials"] = k8s_credentials
4247     if description:
4248         vca["description"] = description
4249     if model_config:
4250         model_config = load(model_config)
4251         vca["model-config"] = model_config
4252     ctx.obj.vca.create(name, vca)
4253
4254
4255 def load(data: Any):
4256     if os.path.isfile(data):
4257         return load_file(data)
4258     else:
4259         try:
4260             return json.loads(data)
4261         except ValueError as e:
4262             raise ClientException(e)
4263
4264
4265 def load_file(file_path: str) -> Dict:
4266     content = None
4267     with open(file_path, "r") as f:
4268         content = f.read()
4269     try:
4270         return yaml.safe_load(content)
4271     except yaml.scanner.ScannerError:
4272         pass
4273     try:
4274         return json.loads(content)
4275     except ValueError:
4276         pass
4277     raise ClientException(f"{file_path} must be a valid yaml or json file")
4278
4279
4280 @cli_osm.command(name="vca-update", short_help="updates a K8s cluster")
4281 @click.argument("name")
4282 @click.option(
4283     "--endpoints", help="Comma-separated list of IP or hostnames of the Juju controller"
4284 )
4285 @click.option("--user", help="Username with admin priviledges")
4286 @click.option("--secret", help="Password of the specified username")
4287 @click.option("--cacert", help="CA certificate")
4288 @click.option(
4289     "--lxd-cloud",
4290     help="Name of the cloud that will be used for LXD containers (LXD proxy charms)",
4291 )
4292 @click.option(
4293     "--lxd-credentials",
4294     help="Name of the cloud credentialsto be used for the LXD cloud",
4295 )
4296 @click.option(
4297     "--k8s-cloud",
4298     help="Name of the cloud that will be used for K8s containers (K8s proxy charms)",
4299 )
4300 @click.option(
4301     "--k8s-credentials",
4302     help="Name of the cloud credentialsto be used for the K8s cloud",
4303 )
4304 @click.option(
4305     "--model-config",
4306     help="Configuration options for the models",
4307 )
4308 @click.option("--description", default=None, help="human readable description")
4309 @click.pass_context
4310 def vca_update(
4311     ctx,
4312     name,
4313     endpoints,
4314     user,
4315     secret,
4316     cacert,
4317     lxd_cloud,
4318     lxd_credentials,
4319     k8s_cloud,
4320     k8s_credentials,
4321     model_config,
4322     description,
4323 ):
4324     """updates a K8s cluster
4325
4326     NAME: name or ID of the K8s cluster
4327     """
4328     check_client_version(ctx.obj, ctx.command.name)
4329     vca = {}
4330     vca["name"] = name
4331     if endpoints:
4332         vca["endpoints"] = endpoints.split(",")
4333     if user:
4334         vca["user"] = user
4335     if secret:
4336         vca["secret"] = secret
4337     if cacert:
4338         vca["cacert"] = cacert
4339     if lxd_cloud:
4340         vca["lxd-cloud"] = lxd_cloud
4341     if lxd_credentials:
4342         vca["lxd-credentials"] = lxd_credentials
4343     if k8s_cloud:
4344         vca["k8s-cloud"] = k8s_cloud
4345     if k8s_credentials:
4346         vca["k8s-credentials"] = k8s_credentials
4347     if description:
4348         vca["description"] = description
4349     if model_config:
4350         model_config = load(model_config)
4351         vca["model-config"] = model_config
4352     ctx.obj.vca.update(name, vca)
4353
4354
4355 @cli_osm.command(name="vca-delete", short_help="deletes a K8s cluster")
4356 @click.argument("name")
4357 @click.option(
4358     "--force", is_flag=True, help="forces the deletion from the DB (not recommended)"
4359 )
4360 @click.pass_context
4361 def vca_delete(ctx, name, force):
4362     """deletes a K8s cluster
4363
4364     NAME: name or ID of the K8s cluster to be deleted
4365     """
4366     check_client_version(ctx.obj, ctx.command.name)
4367     ctx.obj.vca.delete(name, force=force)
4368
4369
4370 @cli_osm.command(name="vca-list")
4371 @click.option(
4372     "--filter",
4373     default=None,
4374     multiple=True,
4375     help="restricts the list to the VCAs matching the filter",
4376 )
4377 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4378 @click.option("--long", is_flag=True, help="get more details")
4379 @click.pass_context
4380 def vca_list(ctx, filter, literal, long):
4381     """list VCAs"""
4382     check_client_version(ctx.obj, ctx.command.name)
4383     if filter:
4384         filter = "&".join(filter)
4385     resp = ctx.obj.vca.list(filter)
4386     if literal:
4387         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4388         return
4389     if long:
4390         table = PrettyTable(
4391             ["Name", "Id", "Project", "Operational State", "Detailed Status"]
4392         )
4393         project_list = ctx.obj.project.list()
4394     else:
4395         table = PrettyTable(["Name", "Id", "Operational State"])
4396     for vca in resp:
4397         logger.debug("VCA details: {}".format(yaml.safe_dump(vca)))
4398         if long:
4399             project_id, project_name = get_project(project_list, vca)
4400             detailed_status = vca.get("_admin", {}).get("detailed-status", "-")
4401             table.add_row(
4402                 [
4403                     vca["name"],
4404                     vca["_id"],
4405                     project_name,
4406                     vca.get("_admin", {}).get("operationalState", "-"),
4407                     wrap_text(text=detailed_status, width=40),
4408                 ]
4409             )
4410         else:
4411             table.add_row(
4412                 [
4413                     vca["name"],
4414                     vca["_id"],
4415                     vca.get("_admin", {}).get("operationalState", "-"),
4416                 ]
4417             )
4418     table.align = "l"
4419     print(table)
4420
4421
4422 @cli_osm.command(name="vca-show", short_help="shows the details of a K8s cluster")
4423 @click.argument("name")
4424 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4425 @click.pass_context
4426 def vca_show(ctx, name, literal):
4427     """shows the details of a K8s cluster
4428
4429     NAME: name or ID of the K8s cluster
4430     """
4431     # try:
4432     resp = ctx.obj.vca.get(name)
4433     if literal:
4434         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4435         return
4436     table = PrettyTable(["key", "attribute"])
4437     for k, v in list(resp.items()):
4438         table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
4439     table.align = "l"
4440     print(table)
4441
4442
4443 ###########################
4444 # Repo operations
4445 ###########################
4446
4447
4448 @cli_osm.command(name="repo-add", short_help="adds a repo to OSM")
4449 @click.argument("name")
4450 @click.argument("uri")
4451 @click.option(
4452     "--type",
4453     type=click.Choice(["helm-chart", "juju-bundle", "osm"]),
4454     default="osm",
4455     help="type of repo (helm-chart for Helm Charts, juju-bundle for Juju Bundles, osm for OSM Repositories)",
4456 )
4457 @click.option("--description", default=None, help="human readable description")
4458 @click.option(
4459     "--user", default=None, help="OSM repository: The username of the OSM repository"
4460 )
4461 @click.option(
4462     "--password",
4463     default=None,
4464     help="OSM repository: The password of the OSM repository",
4465 )
4466 # @click.option('--wait',
4467 #              is_flag=True,
4468 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
4469 @click.pass_context
4470 def repo_add(ctx, **kwargs):
4471     """adds a repo to OSM
4472
4473     NAME: name of the repo
4474     URI: URI of the repo
4475     """
4476     # try:
4477     kwargs = {k: v for k, v in kwargs.items() if v is not None}
4478     repo = kwargs
4479     repo["url"] = repo.pop("uri")
4480     if repo["type"] in ["helm-chart", "juju-bundle"]:
4481         ctx.obj.repo.create(repo["name"], repo)
4482     else:
4483         ctx.obj.osmrepo.create(repo["name"], repo)
4484     # except ClientException as e:
4485     #     print(str(e))
4486     #     exit(1)
4487
4488
4489 @cli_osm.command(name="repo-update", short_help="updates a repo in OSM")
4490 @click.argument("name")
4491 @click.option("--newname", help="New name for the repo")
4492 @click.option("--uri", help="URI of the repo")
4493 @click.option("--description", help="human readable description")
4494 # @click.option('--wait',
4495 #              is_flag=True,
4496 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
4497 @click.pass_context
4498 def repo_update(ctx, name, newname, uri, description):
4499     """updates a repo in OSM
4500
4501     NAME: name of the repo
4502     """
4503     # try:
4504     check_client_version(ctx.obj, ctx.command.name)
4505     repo = {}
4506     if newname:
4507         repo["name"] = newname
4508     if uri:
4509         repo["uri"] = uri
4510     if description:
4511         repo["description"] = description
4512     try:
4513         ctx.obj.repo.update(name, repo)
4514     except NotFound:
4515         ctx.obj.osmrepo.update(name, repo)
4516
4517     # except ClientException as e:
4518     #     print(str(e))
4519     #     exit(1)
4520
4521
4522 @cli_osm.command(
4523     name="repo-index", short_help="Index a repository from a folder with artifacts"
4524 )
4525 @click.option(
4526     "--origin", default=".", help="origin path where the artifacts are located"
4527 )
4528 @click.option(
4529     "--destination", default=".", help="destination path where the index is deployed"
4530 )
4531 @click.pass_context
4532 def repo_index(ctx, origin, destination):
4533     """Index a repository
4534
4535     NAME: name or ID of the repo to be deleted
4536     """
4537     check_client_version(ctx.obj, ctx.command.name)
4538     ctx.obj.osmrepo.repo_index(origin, destination)
4539
4540
4541 @cli_osm.command(name="repo-delete", short_help="deletes a repo")
4542 @click.argument("name")
4543 @click.option(
4544     "--force", is_flag=True, help="forces the deletion from the DB (not recommended)"
4545 )
4546 # @click.option('--wait',
4547 #              is_flag=True,
4548 #              help='do not return the control immediately, but keep it until the operation is completed, or timeout')
4549 @click.pass_context
4550 def repo_delete(ctx, name, force):
4551     """deletes a repo
4552
4553     NAME: name or ID of the repo to be deleted
4554     """
4555     logger.debug("")
4556     try:
4557         ctx.obj.repo.delete(name, force=force)
4558     except NotFound:
4559         ctx.obj.osmrepo.delete(name, force=force)
4560     # except ClientException as e:
4561     #     print(str(e))
4562     #     exit(1)
4563
4564
4565 @cli_osm.command(name="repo-list")
4566 @click.option(
4567     "--filter",
4568     default=None,
4569     multiple=True,
4570     help="restricts the list to the repos matching the filter",
4571 )
4572 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4573 @click.pass_context
4574 def repo_list(ctx, filter, literal):
4575     """list all repos"""
4576     # try:
4577     # K8s Repositories
4578     check_client_version(ctx.obj, ctx.command.name)
4579     if filter:
4580         filter = "&".join(filter)
4581     resp = ctx.obj.repo.list(filter)
4582     resp += ctx.obj.osmrepo.list(filter)
4583     if literal:
4584         print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4585         return
4586     table = PrettyTable(["Name", "Id", "Type", "URI", "Description"])
4587     for repo in resp:
4588         # cluster['k8s-nets'] = json.dumps(yaml.safe_load(cluster['k8s-nets']))
4589         table.add_row(
4590             [
4591                 repo["name"],
4592                 repo["_id"],
4593                 repo["type"],
4594                 repo["url"],
4595                 trunc_text(repo.get("description") or "", 40),
4596             ]
4597         )
4598     table.align = "l"
4599     print(table)
4600
4601     # except ClientException as e:
4602     #     print(str(e))
4603     #     exit(1)
4604
4605
4606 @cli_osm.command(name="repo-show", short_help="shows the details of a repo")
4607 @click.argument("name")
4608 @click.option("--literal", is_flag=True, help="print literally, no pretty table")
4609 @click.pass_context
4610 def repo_show(ctx, name, literal):
4611     """shows the details of a repo
4612
4613     NAME: name or ID of the repo
4614     """
4615     try:
4616         resp = ctx.obj.repo.get(name)
4617     except NotFound:
4618         resp = ctx.obj.osmrepo.get(name)
4619
4620     if literal:
4621         if resp:
4622             print(yaml.safe_dump(resp, indent=4, default_flow_style=False))
4623         return
4624     table = PrettyTable(["key", "attribute"])
4625     if resp:
4626         for k, v in list(resp.items()):
4627             table.add_row([k, json.dumps(v, indent=2)])
4628
4629     table.align = "l"
4630     print(table)
4631     # except ClientException as e:
4632     #     print(str(e))
4633     #     exit(1)
4634
4635
4636 ####################
4637 # Project mgmt operations
4638 ####################
4639
4640
4641 @cli_osm.command(name="project-create", short_help="creates a new project")
4642 @click.argument("name")
4643 # @click.option('--description',
4644 #              default='no description',
4645 #              help='human readable description')
4646 @click.option("--domain-name", "domain_name", default=None, help="assign to a domain")
4647 @click.option(
4648     "--quotas",
4649     "quotas",
4650     multiple=True,
4651     default=None,
4652     help="provide quotas. Can be used several times: 'quota1=number[,quota2=number,...]'. Quotas can be one "
4653     "of vnfds, nsds, nsts, pdus, nsrs, nsis, vim_accounts, wim_accounts, sdns, k8sclusters, k8srepos",
4654 )
4655 @click.pass_context
4656 def project_create(ctx, name, domain_name, quotas):
4657     """Creates a new project
4658
4659     NAME: name of the project
4660     DOMAIN_NAME: optional domain name for the project when keystone authentication is used
4661     QUOTAS: set quotas for the project
4662     """
4663     logger.debug("")
4664     project = {"name": name}
4665     if domain_name:
4666         project["domain_name"] = domain_name
4667     quotas_dict = _process_project_quotas(quotas)
4668     if quotas_dict:
4669         project["quotas"] = quotas_dict
4670
4671     # try:
4672     check_client_version(ctx.obj, ctx.command.name)
4673     ctx.obj.project.create(name, project)
4674     # except ClientException as e:
4675     #     print(str(e))
4676     #     exit(1)
4677
4678
4679 def _process_project_quotas(quota_list):
4680     quotas_dict = {}
4681     if not quota_list:
4682         return quotas_dict
4683     try:
4684         for quota in quota_list:
4685             for single_quota in quota.split(","):
4686                 k, v = single_quota.split("=")
4687                 quotas_dict[k] = None if v in ("None", "null", "") else int(v)
4688     except (ValueError, TypeError):
4689         raise ClientException(
4690             "invalid format for 'quotas'. Use 'k1=v1,v1=v2'. v must be a integer or null"
4691         )
4692     return quotas_dict
4693
4694
4695 @cli_osm.command(name="project-delete", short_help="deletes a project")
4696 @click.argument("name")
4697 # @click.option('--force', is_flag=True, help='forces the deletion bypassing pre-conditions')
4698 @click.pass_context
4699 def project_delete(ctx, name):
4700     """deletes a project
4701
4702     NAME: name or ID of the project to be deleted
4703     """
4704     logger.debug("")
4705     # try:
4706     check_client_version(ctx.obj, ctx.command.name)
4707     ctx.obj.project.delete(name)
4708     # except ClientException as e:
4709     #     print(str(e))
4710     #     exit(1)
4711
4712
4713 @cli_osm.command(name="project-list", short_help="list all projects")
4714 @click.option(
4715     "--filter",
4716     default=None,
4717     multiple=True,
4718     help="restricts the list to the projects matching the filter",
4719 )
4720 @click.pass_context
4721 def project_list(ctx, filter):
4722     """list all projects"""
4723     logger.debug("")
4724     # try:
4725     check_client_version(ctx.obj, ctx.command.name)
4726     if filter:
4727         filter = "&".join(filter)
4728     resp = ctx.obj.project.list(filter)
4729     # except ClientException as e:
4730     #     print(str(e))
4731     #     exit(1)
4732     table = PrettyTable(["name", "id"])
4733     for proj in resp:
4734         table.add_row([proj["name"], proj["_id"]])
4735     table.align = "l"
4736     print(table)
4737
4738
4739 @cli_osm.command(name="project-show", short_help="shows the details of a project")
4740 @click.argument("name")
4741 @click.pass_context
4742 def project_show(ctx, name):
4743     """shows the details of a project
4744
4745     NAME: name or ID of the project
4746     """
4747     logger.debug("")
4748     # try:
4749     check_client_version(ctx.obj, ctx.command.name)
4750     resp = ctx.obj.project.get(name)
4751     # except ClientException as e:
4752     #     print(str(e))
4753     #     exit(1)
4754
4755     table = PrettyTable(["key", "attribute"])
4756     for k, v in resp.items():
4757         table.add_row([k, json.dumps(v, indent=2)])
4758     table.align = "l"
4759     print(table)
4760
4761
4762 @cli_osm.command(
4763     name="project-update", short_help="updates a project (only the name can be updated)"
4764 )
4765 @click.argument("project")
4766 @click.option("--name", default=None, help="new name for the project")
4767 @click.option(
4768     "--quotas",
4769     "quotas",
4770     multiple=True,
4771     default=None,
4772     help="change quotas. Can be used several times: 'quota1=number|empty[,quota2=...]' "
4773     "(use empty to reset quota to default",
4774 )
4775 @click.pass_context
4776 def project_update(ctx, project, name, quotas):
4777     """
4778     Update a project name
4779
4780     :param ctx:
4781     :param project: id or name of the project to modify
4782     :param name:  new name for the project
4783     :param quotas:  change quotas of the project
4784     :return:
4785     """
4786     logger.debug("")
4787     project_changes = {}
4788     if name:
4789         project_changes["name"] = name
4790     quotas_dict = _process_project_quotas(quotas)
4791     if quotas_dict:
4792         project_changes["quotas"] = quotas_dict
4793
4794     # try:
4795     check_client_version(ctx.obj, ctx.command.name)
4796     ctx.obj.project.update(project, project_changes)
4797     # except ClientException as e:
4798     #     print(str(e))
4799
4800
4801 ####################
4802 # User mgmt operations
4803 ####################
4804
4805
4806 @cli_osm.command(name="user-create", short_help="creates a new user")
4807 @click.argument("username")
4808 @click.option(
4809     "--password",
4810     prompt=True,
4811     hide_input=True,
4812     confirmation_prompt=True,
4813     help="user password",
4814 )
4815 @click.option(
4816     "--projects",
4817     # prompt="Comma separate list of projects",
4818     multiple=True,
4819     callback=lambda ctx, param, value: "".join(value).split(",")
4820     if all(len(x) == 1 for x in value)
4821     else value,
4822     help="list of project ids that the user belongs to",
4823 )
4824 @click.option(
4825     "--project-role-mappings",
4826     "project_role_mappings",
4827     default=None,
4828     multiple=True,
4829     help="assign role(s) in a project. Can be used several times: 'project,role1[,role2,...]'",
4830 )
4831 @click.option("--domain-name", "domain_name", default=None, help="assign to a domain")
4832 @click.pass_context
4833 def user_create(ctx, username, password, projects, project_role_mappings, domain_name):
4834     """Creates a new user
4835
4836     \b
4837     USERNAME: name of the user
4838     PASSWORD: password of the user
4839     PROJECTS: projects assigned to user (internal only)
4840     PROJECT_ROLE_MAPPING: roles in projects assigned to user (keystone)
4841     DOMAIN_NAME: optional domain name for the user when keystone authentication is used
4842     """
4843     logger.debug("")
4844     user = {}
4845     user["username"] = username
4846     user["password"] = password
4847     user["projects"] = projects
4848     user["project_role_mappings"] = project_role_mappings
4849     if domain_name:
4850         user["domain_name"] = domain_name
4851
4852     # try:
4853     check_client_version(ctx.obj, ctx.command.name)
4854     ctx.obj.user.create(username, user)
4855     # except ClientException as e:
4856     #     print(str(e))
4857     #     exit(1)
4858
4859
4860 @cli_osm.command(name="user-update", short_help="updates user information")
4861 @click.argument("username")
4862 @click.option(
4863     "--password",
4864     # prompt=True,
4865     # hide_input=True,
4866     # confirmation_prompt=True,
4867     help="user password",
4868 )
4869 @click.option("--set-username", "set_username", default=None, help="change username")
4870 @click.option(
4871     "--set-project",
4872     "set_project",
4873     default=None,
4874     multiple=True,
4875     help="create/replace the roles for this project: 'project,role1[,role2,...]'",
4876 )
4877 @click.option(
4878     "--remove-project",
4879     "remove_project",
4880     default=None,
4881     multiple=True,
4882     help="removes project from user: 'project'",
4883 )
4884 @click.option(
4885     "--add-project-role",
4886     "add_project_role",
4887     default=None,
4888     multiple=True,
4889     help="assign role(s) in a project. Can be used several times: 'project,role1[,role2,...]'",
4890 )
4891 @click.option(
4892     "--remove-project-role",
4893     "remove_project_role",
4894     default=None,
4895     multiple=True,
4896     help="remove role(s) in a project. Can be used several times: 'project,role1[,role2,...]'",
4897 )
4898 @click.option("--change_password", "change_password", help="user's current password")
4899 @click.option(
4900     "--new_password",
4901     "new_password",
4902     help="user's new password to update in expiry condition",
4903 )
4904 @click.pass_context
4905 def user_update(
4906     ctx,
4907     username,
4908     password,
4909     set_username,
4910     set_project,
4911     remove_project,
4912     add_project_role,
4913     remove_project_role,
4914     change_password,
4915     new_password,
4916 ):
4917     """Update a user information
4918
4919     \b
4920     USERNAME: name of the user
4921     PASSWORD: new password
4922     SET_USERNAME: new username
4923     SET_PROJECT: creating mappings for project/role(s)
4924     REMOVE_PROJECT: deleting mappings for project/role(s)
4925     ADD_PROJECT_ROLE: adding mappings for project/role(s)
4926     REMOVE_PROJECT_ROLE: removing mappings for project/role(s)
4927     CHANGE_PASSWORD: user's current password to change
4928     NEW_PASSWORD: user's new password to update in expiry condition
4929     """
4930     logger.debug("")
4931     user = {}
4932     user["password"] = password
4933     user["username"] = set_username
4934     user["set-project"] = set_project
4935     user["remove-project"] = remove_project
4936     user["add-project-role"] = add_project_role
4937     user["remove-project-role"] = remove_project_role
4938     user["change_password"] = change_password
4939     user["new_password"] = new_password
4940
4941     # try:
4942     check_client_version(ctx.obj, ctx.command.name)
4943     if not user.get("change_password"):
4944         ctx.obj.user.update(username, user)
4945     else:
4946         ctx.obj.user.update(username, user, pwd_change=True)
4947     # except ClientException as e:
4948     #     print(str(e))
4949     #     exit(1)
4950
4951
4952 @cli_osm.command(name="user-delete", short_help="deletes a user")
4953 @click.argument("name")
4954 # @click.option('--force', is_flag=True, help='forces the deletion bypassing pre-conditions')
4955 @click.pass_context
4956 def user_delete(ctx, name):
4957     """deletes a user
4958
4959     \b
4960     NAME: name or ID of the user to be deleted
4961     """
4962     logger.debug("")
4963     # try:
4964     check_client_version(ctx.obj, ctx.command.name)
4965     ctx.obj.user.delete(name)
4966     # except ClientException as e:
4967     #     print(str(e))
4968     #     exit(1)
4969
4970
4971 @cli_osm.command(name="user-list", short_help="list all users")
4972 @click.option(
4973     "--filter",
4974     default=None,
4975     multiple=True,
4976     help="restricts the list to the users matching the filter",
4977 )
4978 @click.pass_context
4979 def user_list(ctx, filter):
4980     """list all users"""
4981     # try:
4982     check_client_version(ctx.obj, ctx.command.name)
4983     if filter:
4984         filter = "&".join(filter)
4985     resp = ctx.obj.user.list(filter)
4986     # except ClientException as e:
4987     #     print(str(e))
4988     #     exit(1)
4989     table = PrettyTable(["name", "id"])
4990     for user in resp:
4991         table.add_row([user["username"], user["_id"]])
4992     table.align = "l"
4993     print(table)
4994
4995
4996 @cli_osm.command(name="user-show", short_help="shows the details of a user")
4997 @click.argument("name")
4998 @click.pass_context
4999 def user_show(ctx, name):
5000     """shows the details of a user
5001
5002     NAME: name or ID of the user
5003     """
5004     logger.debug("")
5005     # try:
5006     check_client_version(ctx.obj, ctx.command.name)
5007     resp = ctx.obj.user.get(name)
5008     if "password" in resp:
5009         resp["password"] = "********"
5010     # except ClientException as e:
5011     #     print(str(e))
5012     #     exit(1)
5013
5014     table = PrettyTable(["key", "attribute"])
5015     for k, v in resp.items():
5016         table.add_row([k, json.dumps(v, indent=2)])
5017     table.align = "l"
5018     print(table)
5019
5020
5021 ####################
5022 # Fault Management operations
5023 ####################
5024
5025
5026 @cli_osm.command(name="ns-alarm-create")
5027 @click.argument("name")
5028 @click.option("--ns", prompt=True, help="NS instance id or name")
5029 @click.option(
5030     "--vnf", prompt=True, help="VNF name (VNF member index as declared in the NSD)"
5031 )
5032 @click.option("--vdu", prompt=True, help="VDU name (VDU name as declared in the VNFD)")
5033 @click.option("--metric", prompt=True, help="Name of the metric (e.g. cpu_utilization)")
5034 @click.option(
5035     "--severity",
5036     default="WARNING",
5037     help="severity of the alarm (WARNING, MINOR, MAJOR, CRITICAL, INDETERMINATE)",
5038 )
5039 @click.option(
5040     "--threshold_value",
5041     prompt=True,
5042     help="threshold value that, when crossed, an alarm is triggered",
5043 )
5044 @click.option(
5045     "--threshold_operator",
5046     prompt=True,
5047     help="threshold operator describing the comparison (GE, LE, GT, LT, EQ)",
5048 )
5049 @click.option(
5050     "--statistic",
5051     default="AVERAGE",
5052     help="statistic (AVERAGE, MINIMUM, MAXIMUM, COUNT, SUM)",
5053 )
5054 @click.pass_context
5055 def ns_alarm_create(
5056     ctx,
5057     name,
5058     ns,
5059     vnf,
5060     vdu,
5061     metric,
5062     severity,
5063     threshold_value,
5064     threshold_operator,
5065     statistic,
5066 ):
5067     """creates a new alarm for a NS instance"""
5068     # TODO: Check how to validate threshold_value.
5069     # Should it be an integer (1-100), percentage, or decimal (0.01-1.00)?
5070     logger.debug("")
5071     # try:
5072     ns_instance = ctx.obj.ns.get(ns)
5073     alarm = {}
5074     alarm["alarm_name"] = name
5075     alarm["ns_id"] = ns_instance["_id"]
5076     alarm["correlation_id"] = ns_instance["_id"]
5077     alarm["vnf_member_index"] = vnf
5078     alarm["vdu_name"] = vdu
5079     alarm["metric_name"] = metric
5080     alarm["severity"] = severity
5081     alarm["threshold_value"] = int(threshold_value)
5082     alarm["operation"] = threshold_operator
5083     alarm["statistic"] = statistic
5084     check_client_version(ctx.obj, ctx.command.name)
5085     ctx.obj.ns.create_alarm(alarm)
5086     # except ClientException as e:
5087     #     print(str(e))
5088     #     exit(1)
5089
5090
5091 # @cli_osm.command(name='ns-alarm-delete')
5092 # @click.argument('name')
5093 # @click.pass_context
5094 # def ns_alarm_delete(ctx, name):
5095 #    """deletes an alarm
5096 #
5097 #    NAME: name of the alarm to be deleted
5098 #    """
5099 #    try:
5100 #        check_client_version(ctx.obj, ctx.command.name)
5101 #        ctx.obj.ns.delete_alarm(name)
5102 #    except ClientException as e:
5103 #        print(str(e))
5104 #        exit(1)
5105
5106
5107 ####################
5108 # Performance Management operations
5109 ####################
5110
5111
5112 @cli_osm.command(
5113     name="ns-metric-export",
5114     short_help="exports a metric to the internal OSM bus, which can be read by other apps",
5115 )
5116 @click.option("--ns", prompt=True, help="NS instance id or name")
5117 @click.option(
5118     "--vnf", prompt=True, help="VNF name (VNF member index as declared in the NSD)"
5119 )
5120 @click.option("--vdu", prompt=True, help="VDU name (VDU name as declared in the VNFD)")
5121 @click.option("--metric", prompt=True, help="name of the metric (e.g. cpu_utilization)")
5122 # @click.option('--period', default='1w',
5123 #              help='metric collection period (e.g. 20s, 30m, 2h, 3d, 1w)')
5124 @click.option(
5125     "--interval", help="periodic interval (seconds) to export metrics continuously"
5126 )
5127 @click.pass_context
5128 def ns_metric_export(ctx, ns, vnf, vdu, metric, interval):
5129     """exports a metric to the internal OSM bus, which can be read by other apps"""
5130     # TODO: Check how to validate interval.
5131     # Should it be an integer (seconds), or should a suffix (s,m,h,d,w) also be permitted?
5132     logger.debug("")
5133     # try:
5134     ns_instance = ctx.obj.ns.get(ns)
5135     metric_data = {}
5136     metric_data["ns_id"] = ns_instance["_id"]
5137     metric_data["correlation_id"] = ns_instance["_id"]
5138     metric_data["vnf_member_index"] = vnf
5139     metric_data["vdu_name"] = vdu
5140     metric_data["metric_name"] = metric
5141     metric_data["collection_unit"] = "WEEK"
5142     metric_data["collection_period"] = 1
5143     check_client_version(ctx.obj, ctx.command.name)
5144     if not interval:
5145         print("{}".format(ctx.obj.ns.export_metric(metric_data)))
5146     else:
5147         i = 1
5148         while True:
5149             print("{} {}".format(ctx.obj.ns.export_metric(metric_data), i))
5150             time.sleep(int(interval))
5151             i += 1
5152     # except ClientException as e:
5153     #     print(str(e))
5154     #     exit(1)
5155
5156
5157 #################
5158 # Subscription operations
5159 #################
5160
5161
5162 @cli_osm.command(
5163     name="subscription-create",
5164     short_help="creates a new subscription to a specific event",
5165 )
5166 @click.option(
5167     "--event_type",
5168     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5169     type=click.Choice(["ns"], case_sensitive=False),
5170     help="event type to be subscribed (for the moment, only ns is supported)",
5171 )
5172 @click.option("--event", default=None, help="specific yaml configuration for the event")
5173 @click.option(
5174     "--event_file", default=None, help="specific yaml configuration file for the event"
5175 )
5176 @click.pass_context
5177 def subscription_create(ctx, event_type, event, event_file):
5178     """creates a new subscription to a specific event"""
5179     logger.debug("")
5180     check_client_version(ctx.obj, ctx.command.name)
5181     if event_file:
5182         if event:
5183             raise ClientException(
5184                 '"--event" option is incompatible with "--event_file" option'
5185             )
5186         with open(event_file, "r") as cf:
5187             event = cf.read()
5188     ctx.obj.subscription.create(event_type, event)
5189
5190
5191 @cli_osm.command(name="subscription-delete", short_help="deletes a subscription")
5192 @click.option(
5193     "--event_type",
5194     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5195     type=click.Choice(["ns"], case_sensitive=False),
5196     help="event type to be subscribed (for the moment, only ns is supported)",
5197 )
5198 @click.argument("subscription_id")
5199 @click.option(
5200     "--force", is_flag=True, help="forces the deletion bypassing pre-conditions"
5201 )
5202 @click.pass_context
5203 def subscription_delete(ctx, event_type, subscription_id, force):
5204     """deletes a subscription
5205
5206     SUBSCRIPTION_ID: ID of the subscription to be deleted
5207     """
5208     logger.debug("")
5209     check_client_version(ctx.obj, ctx.command.name)
5210     ctx.obj.subscription.delete(event_type, subscription_id, force)
5211
5212
5213 @cli_osm.command(name="subscription-list", short_help="list all subscriptions")
5214 @click.option(
5215     "--event_type",
5216     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5217     type=click.Choice(["ns"], case_sensitive=False),
5218     help="event type to be subscribed (for the moment, only ns is supported)",
5219 )
5220 @click.option(
5221     "--filter",
5222     default=None,
5223     multiple=True,
5224     help="restricts the list to the subscriptions matching the filter",
5225 )
5226 @click.pass_context
5227 def subscription_list(ctx, event_type, filter):
5228     """list all subscriptions"""
5229     logger.debug("")
5230     check_client_version(ctx.obj, ctx.command.name)
5231     if filter:
5232         filter = "&".join(filter)
5233     resp = ctx.obj.subscription.list(event_type, filter)
5234     table = PrettyTable(["id", "filter", "CallbackUri"])
5235     for sub in resp:
5236         table.add_row(
5237             [
5238                 sub["_id"],
5239                 wrap_text(text=json.dumps(sub["filter"], indent=2), width=70),
5240                 sub["CallbackUri"],
5241             ]
5242         )
5243     table.align = "l"
5244     print(table)
5245
5246
5247 @cli_osm.command(
5248     name="subscription-show", short_help="shows the details of a subscription"
5249 )
5250 @click.argument("subscription_id")
5251 @click.option(
5252     "--event_type",
5253     # type=click.Choice(['ns', 'nspkg', 'vnfpkg'], case_sensitive=False))
5254     type=click.Choice(["ns"], case_sensitive=False),
5255     help="event type to be subscribed (for the moment, only ns is supported)",
5256 )
5257 @click.option(
5258     "--filter",
5259     multiple=True,
5260     help="restricts the information to the fields in the filter",
5261 )
5262 @click.pass_context
5263 def subscription_show(ctx, event_type, subscription_id, filter):
5264     """shows the details of a subscription
5265
5266     SUBSCRIPTION_ID: ID of the subscription
5267     """
5268     logger.debug("")
5269     # try:
5270     resp = ctx.obj.subscription.get(subscription_id)
5271     table = PrettyTable(["key", "attribute"])
5272     for k, v in list(resp.items()):
5273         if not filter or k in filter:
5274             table.add_row([k, wrap_text(text=json.dumps(v, indent=2), width=100)])
5275     table.align = "l"
5276     print(table)
5277
5278
5279 ####################
5280 # Other operations
5281 ####################
5282
5283
5284 @cli_osm.command(name="version", short_help="shows client and server versions")
5285 @click.pass_context
5286 def get_version(ctx):
5287     """shows client and server versions"""
5288     # try:
5289     check_client_version(ctx.obj, "version")
5290     print("Server version: {}".format(ctx.obj.get_version()))
5291     print(
5292         "Client version: {}".format(pkg_resources.get_distribution("osmclient").version)
5293     )
5294     # except ClientException as e:
5295     #     print(str(e))
5296     #     exit(1)
5297
5298
5299 @cli_osm.command(
5300     name="upload-package", short_help="uploads a VNF package or NS package"
5301 )
5302 @click.argument("filename")
5303 @click.option(
5304     "--skip-charm-build",
5305     default=False,
5306     is_flag=True,
5307     help="the charm will not be compiled, it is assumed to already exist",
5308 )
5309 @click.pass_context
5310 def upload_package(ctx, filename, skip_charm_build):
5311     """uploads a vnf package or ns package
5312
5313     filename: vnf or ns package folder, or vnf or ns package file (tar.gz)
5314     """
5315     logger.debug("")
5316     # try:
5317     ctx.obj.package.upload(filename, skip_charm_build=skip_charm_build)
5318     fullclassname = ctx.obj.__module__ + "." + ctx.obj.__class__.__name__
5319     if fullclassname != "osmclient.sol005.client.Client":
5320         ctx.obj.package.wait_for_upload(filename)
5321     # except ClientException as e:
5322     #     print(str(e))
5323     #     exit(1)
5324
5325
5326 # @cli_osm.command(name='ns-scaling-show')
5327 # @click.argument('ns_name')
5328 # @click.pass_context
5329 # def show_ns_scaling(ctx, ns_name):
5330 #    """shows the status of a NS scaling operation
5331 #
5332 #    NS_NAME: name of the NS instance being scaled
5333 #    """
5334 #    try:
5335 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5336 #        resp = ctx.obj.ns.list()
5337 #    except ClientException as e:
5338 #        print(str(e))
5339 #        exit(1)
5340 #
5341 #    table = PrettyTable(
5342 #        ['group-name',
5343 #         'instance-id',
5344 #         'operational status',
5345 #         'create-time',
5346 #         'vnfr ids'])
5347 #
5348 #    for ns in resp:
5349 #        if ns_name == ns['name']:
5350 #            nsopdata = ctx.obj.ns.get_opdata(ns['id'])
5351 #            scaling_records = nsopdata['nsr:nsr']['scaling-group-record']
5352 #            for record in scaling_records:
5353 #                if 'instance' in record:
5354 #                    instances = record['instance']
5355 #                    for inst in instances:
5356 #                        table.add_row(
5357 #                            [record['scaling-group-name-ref'],
5358 #                             inst['instance-id'],
5359 #                                inst['op-status'],
5360 #                                time.strftime('%Y-%m-%d %H:%M:%S',
5361 #                                              time.localtime(
5362 #                                                  inst['create-time'])),
5363 #                                inst['vnfrs']])
5364 #    table.align = 'l'
5365 #    print(table)
5366
5367
5368 # @cli_osm.command(name='ns-scale')
5369 # @click.argument('ns_name')
5370 # @click.option('--ns_scale_group', prompt=True)
5371 # @click.option('--index', prompt=True)
5372 # @click.option('--wait',
5373 #              required=False,
5374 #              default=False,
5375 #              is_flag=True,
5376 #              help='do not return the control immediately, but keep it \
5377 #              until the operation is completed, or timeout')
5378 # @click.pass_context
5379 # def ns_scale(ctx, ns_name, ns_scale_group, index, wait):
5380 #    """scales NS
5381 #
5382 #    NS_NAME: name of the NS instance to be scaled
5383 #    """
5384 #    try:
5385 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5386 #        ctx.obj.ns.scale(ns_name, ns_scale_group, index, wait=wait)
5387 #    except ClientException as e:
5388 #        print(str(e))
5389 #        exit(1)
5390
5391
5392 # @cli_osm.command(name='config-agent-list')
5393 # @click.pass_context
5394 # def config_agent_list(ctx):
5395 #    """list config agents"""
5396 #    try:
5397 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5398 #    except ClientException as e:
5399 #        print(str(e))
5400 #        exit(1)
5401 #    table = PrettyTable(['name', 'account-type', 'details'])
5402 #    for account in ctx.obj.vca.list():
5403 #        table.add_row(
5404 #            [account['name'],
5405 #             account['account-type'],
5406 #             account['juju']])
5407 #    table.align = 'l'
5408 #    print(table)
5409
5410
5411 # @cli_osm.command(name='config-agent-delete')
5412 # @click.argument('name')
5413 # @click.pass_context
5414 # def config_agent_delete(ctx, name):
5415 #    """deletes a config agent
5416 #
5417 #    NAME: name of the config agent to be deleted
5418 #    """
5419 #    try:
5420 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5421 #        ctx.obj.vca.delete(name)
5422 #    except ClientException as e:
5423 #        print(str(e))
5424 #        exit(1)
5425
5426
5427 # @cli_osm.command(name='config-agent-add')
5428 # @click.option('--name',
5429 #              prompt=True)
5430 # @click.option('--account_type',
5431 #              prompt=True)
5432 # @click.option('--server',
5433 #              prompt=True)
5434 # @click.option('--user',
5435 #              prompt=True)
5436 # @click.option('--secret',
5437 #              prompt=True,
5438 #              hide_input=True,
5439 #              confirmation_prompt=True)
5440 # @click.pass_context
5441 # def config_agent_add(ctx, name, account_type, server, user, secret):
5442 #    """adds a config agent"""
5443 #    try:
5444 #        check_client_version(ctx.obj, ctx.command.name, 'v1')
5445 #        ctx.obj.vca.create(name, account_type, server, user, secret)
5446 #    except ClientException as e:
5447 #        print(str(e))
5448 #        exit(1)
5449
5450
5451 # @cli_osm.command(name='ro-dump')
5452 # @click.pass_context
5453 # def ro_dump(ctx):
5454 #    """shows RO agent information"""
5455 #    check_client_version(ctx.obj, ctx.command.name, 'v1')
5456 #    resp = ctx.obj.vim.get_resource_orchestrator()
5457 #    table = PrettyTable(['key', 'attribute'])
5458 #    for k, v in list(resp.items()):
5459 #        table.add_row([k, json.dumps(v, indent=2)])
5460 #    table.align = 'l'
5461 #    print(table)
5462
5463
5464 # @cli_osm.command(name='vcs-list')
5465 # @click.pass_context
5466 # def vcs_list(ctx):
5467 #    check_client_version(ctx.obj, ctx.command.name, 'v1')
5468 #    resp = ctx.obj.utils.get_vcs_info()
5469 #    table = PrettyTable(['component name', 'state'])
5470 #    for component in resp:
5471 #        table.add_row([component['component_name'], component['state']])
5472 #    table.align = 'l'
5473 #    print(table)
5474
5475
5476 @cli_osm.command(
5477     name="ns-action", short_help="executes an action/primitive over a NS instance"
5478 )
5479 @click.argument("ns_name")
5480 @click.option(
5481     "--vnf_name",
5482     default=None,
5483     help="member-vnf-index if the target is a vnf instead of a ns)",
5484 )
5485 @click.option("--kdu_name", default=None, help="kdu-name if the target is a kdu)")
5486 @click.option("--vdu_id", default=None, help="vdu-id if the target is a vdu")
5487 @click.option(
5488     "--vdu_count", default=None, type=int, help="number of vdu instance of this vdu_id"
5489 )
5490 @click.option("--action_name", prompt=True, help="action name")
5491 @click.option("--params", default=None, help="action params in YAML/JSON inline string")
5492 @click.option("--params_file", default=None, help="YAML/JSON file with action params")
5493 @click.option(
5494     "--timeout", required=False, default=None, type=int, help="timeout in seconds"
5495 )
5496 @click.option(
5497     "--wait",
5498     required=False,
5499     default=False,
5500     is_flag=True,
5501     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5502 )
5503 @click.pass_context
5504 def ns_action(
5505     ctx,
5506     ns_name,
5507     vnf_name,
5508     kdu_name,
5509     vdu_id,
5510     vdu_count,
5511     action_name,
5512     params,
5513     params_file,
5514     timeout,
5515     wait,
5516 ):
5517     """executes an action/primitive over a NS instance
5518
5519     NS_NAME: name or ID of the NS instance
5520     """
5521     logger.debug("")
5522     # try:
5523     check_client_version(ctx.obj, ctx.command.name)
5524     op_data = {}
5525     if vnf_name:
5526         op_data["member_vnf_index"] = vnf_name
5527     if kdu_name:
5528         op_data["kdu_name"] = kdu_name
5529     if vdu_id:
5530         op_data["vdu_id"] = vdu_id
5531     if vdu_count is not None:
5532         op_data["vdu_count_index"] = vdu_count
5533     if timeout:
5534         op_data["timeout_ns_action"] = timeout
5535     op_data["primitive"] = action_name
5536     if params_file:
5537         with open(params_file, "r") as pf:
5538             params = pf.read()
5539     if params:
5540         op_data["primitive_params"] = yaml.safe_load(params)
5541     else:
5542         op_data["primitive_params"] = {}
5543     print(ctx.obj.ns.exec_op(ns_name, op_name="action", op_data=op_data, wait=wait))
5544
5545     # except ClientException as e:
5546     #     print(str(e))
5547     #     exit(1)
5548
5549
5550 @cli_osm.command(
5551     name="vnf-scale", short_help="executes a VNF scale (adding/removing VDUs)"
5552 )
5553 @click.argument("ns_name")
5554 @click.argument("vnf_name")
5555 @click.option(
5556     "--scaling-group", prompt=True, help="scaling-group-descriptor name to use"
5557 )
5558 @click.option(
5559     "--scale-in", default=False, is_flag=True, help="performs a scale in operation"
5560 )
5561 @click.option(
5562     "--scale-out",
5563     default=False,
5564     is_flag=True,
5565     help="performs a scale out operation (by default)",
5566 )
5567 @click.option(
5568     "--timeout", required=False, default=None, type=int, help="timeout in seconds"
5569 )
5570 @click.option(
5571     "--wait",
5572     required=False,
5573     default=False,
5574     is_flag=True,
5575     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5576 )
5577 @click.pass_context
5578 def vnf_scale(
5579     ctx, ns_name, vnf_name, scaling_group, scale_in, scale_out, timeout, wait
5580 ):
5581     """
5582     Executes a VNF scale (adding/removing VDUs)
5583
5584     \b
5585     NS_NAME: name or ID of the NS instance.
5586     VNF_NAME: member-vnf-index in the NS to be scaled.
5587     """
5588     logger.debug("")
5589     # try:
5590     check_client_version(ctx.obj, ctx.command.name)
5591     if not scale_in and not scale_out:
5592         scale_out = True
5593     ctx.obj.ns.scale_vnf(
5594         ns_name, vnf_name, scaling_group, scale_in, scale_out, wait, timeout
5595     )
5596     # except ClientException as e:
5597     #     print(str(e))
5598     #     exit(1)
5599
5600
5601 @cli_osm.command(
5602     name="ns-update", short_help="executes an update of a Network Service."
5603 )
5604 @click.argument("ns_name")
5605 @click.option(
5606     "--updatetype", required=True, type=str, help="available types: CHANGE_VNFPKG"
5607 )
5608 @click.option(
5609     "--config",
5610     required=True,
5611     type=str,
5612     help="extra information for update operation as YAML/JSON inline string as --config"
5613     " '{changeVnfPackageData:[{vnfInstanceId: xxx, vnfdId: yyy}]}'",
5614 )
5615 @click.option(
5616     "--timeout", required=False, default=None, type=int, help="timeout in seconds"
5617 )
5618 @click.option(
5619     "--wait",
5620     required=False,
5621     default=False,
5622     is_flag=True,
5623     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5624 )
5625 @click.pass_context
5626 def update(ctx, ns_name, updatetype, config, timeout, wait):
5627     """Executes an update of a Network Service.
5628
5629     The update will check new revisions of the Network Functions that are part of the
5630     Network Service, and it will update them if needed.
5631     Sample update command: osm ns-update  ns_instance_id --updatetype CHANGE_VNFPKG
5632     --config '{changeVnfPackageData: [{vnfInstanceId: id_x,vnfdId: id_y}]}' --timeout 300 --wait
5633
5634     NS_NAME: Network service instance name or ID.
5635
5636     """
5637     op_data = {
5638         "timeout": timeout,
5639         "updateType": updatetype,
5640     }
5641     if config:
5642         op_data["config"] = yaml.safe_load(config)
5643
5644     check_client_version(ctx.obj, ctx.command.name)
5645     ctx.obj.ns.update(ns_name, op_data, wait=wait)
5646
5647
5648 def iterator_split(iterator, separators):
5649     """
5650     Splits a tuple or list into several lists whenever a separator is found
5651     For instance, the following tuple will be separated with the separator "--vnf" as follows.
5652     From:
5653         ("--vnf", "A", "--cause", "cause_A", "--vdu", "vdu_A1", "--vnf", "B", "--cause", "cause_B", ...
5654         "--vdu", "vdu_B1", "--count_index", "1", "--run-day1", "--vdu", "vdu_B1", "--count_index", "2")
5655     To:
5656         [
5657             ("--vnf", "A", "--cause", "cause_A", "--vdu", "vdu_A1"),
5658             ("--vnf", "B", "--cause", "cause_B", "--vdu", "vdu_B1", "--count_index", "1", "--run-day1", ...
5659              "--vdu", "vdu_B1", "--count_index", "2")
5660         ]
5661
5662     Returns as many lists as separators are found
5663     """
5664     logger.debug("")
5665     if iterator[0] not in separators:
5666         raise ClientException(f"Expected one of {separators}. Received: {iterator[0]}.")
5667     list_of_lists = []
5668     first = 0
5669     for i in range(len(iterator)):
5670         if iterator[i] in separators:
5671             if i == first:
5672                 continue
5673             if i - first < 2:
5674                 raise ClientException(
5675                     f"Expected at least one argument after separator (possible separators: {separators})."
5676                 )
5677             list_of_lists.append(list(iterator[first:i]))
5678             first = i
5679     if (len(iterator) - first) < 2:
5680         raise ClientException(
5681             f"Expected at least one argument after separator (possible separators: {separators})."
5682         )
5683     else:
5684         list_of_lists.append(list(iterator[first : len(iterator)]))
5685     # logger.debug(f"List of lists: {list_of_lists}")
5686     return list_of_lists
5687
5688
5689 def process_common_heal_params(heal_vnf_dict, args):
5690     logger.debug("")
5691     current_item = "vnf"
5692     i = 0
5693     while i < len(args):
5694         if args[i] == "--cause":
5695             if (i + 1 >= len(args)) or args[i + 1].startswith("--"):
5696                 raise ClientException("No cause was provided after --cause")
5697             heal_vnf_dict["cause"] = args[i + 1]
5698             i = i + 2
5699             continue
5700         if args[i] == "--run-day1":
5701             if current_item == "vnf":
5702                 if "additionalParams" not in heal_vnf_dict:
5703                     heal_vnf_dict["additionalParams"] = {}
5704                 heal_vnf_dict["additionalParams"]["run-day1"] = True
5705             else:
5706                 # if current_item == "vdu"
5707                 heal_vnf_dict["additionalParams"]["vdu"][-1]["run-day1"] = True
5708             i = i + 1
5709             continue
5710         if args[i] == "--vdu":
5711             if "additionalParams" not in heal_vnf_dict:
5712                 heal_vnf_dict["additionalParams"] = {}
5713                 heal_vnf_dict["additionalParams"]["vdu"] = []
5714             if (i + 1 >= len(args)) or args[i + 1].startswith("--"):
5715                 raise ClientException("No VDU ID was provided after --vdu")
5716             heal_vnf_dict["additionalParams"]["vdu"].append({"vdu-id": args[i + 1]})
5717             current_item = "vdu"
5718             i = i + 2
5719             continue
5720         if args[i] == "--count-index":
5721             if current_item == "vnf":
5722                 raise ClientException(
5723                     "Option --count-index only applies to VDU, not to VNF"
5724                 )
5725             if (i + 1 >= len(args)) or args[i + 1].startswith("--"):
5726                 raise ClientException("No count index was provided after --count-index")
5727             heal_vnf_dict["additionalParams"]["vdu"][-1]["count-index"] = int(
5728                 args[i + 1]
5729             )
5730             i = i + 2
5731             continue
5732         i = i + 1
5733     return
5734
5735
5736 def process_ns_heal_params(ctx, param, value):
5737     """
5738     Processes the params in the command ns-heal
5739     Click does not allow advanced patterns for positional options like this:
5740     --vnf volumes_vnf --cause "Heal several_volumes-VM of several_volumes_vnf"
5741                       --vdu several_volumes-VM
5742     --vnf charm_vnf --cause "Heal two VMs of native_manual_scale_charm_vnf"
5743                     --vdu mgmtVM --count-index 1 --run-day1
5744                     --vdu mgmtVM --count-index 2
5745
5746     It returns the dictionary with all the params stored in ctx.params["heal_params"]
5747     """
5748     logger.debug("")
5749     # logger.debug(f"Args: {value}")
5750     if param.name != "args":
5751         raise ClientException(f"Unexpected param: {param.name}")
5752     # Split the tuple "value" by "--vnf"
5753     vnfs = iterator_split(value, ["--vnf"])
5754     logger.debug(f"VNFs: {vnfs}")
5755     heal_dict = {}
5756     heal_dict["healVnfData"] = []
5757     for vnf in vnfs:
5758         # logger.debug(f"VNF: {vnf}")
5759         heal_vnf = {}
5760         if vnf[1].startswith("--"):
5761             raise ClientException("Expected a VNF_ID after --vnf")
5762         heal_vnf["vnfInstanceId"] = vnf[1]
5763         process_common_heal_params(heal_vnf, vnf[2:])
5764         heal_dict["healVnfData"].append(heal_vnf)
5765     ctx.params["heal_params"] = heal_dict
5766     return
5767
5768
5769 @cli_osm.command(
5770     name="ns-heal",
5771     short_help="heals (recreates) VNFs or VDUs of a NS instance",
5772     context_settings=dict(
5773         ignore_unknown_options=True,
5774     ),
5775 )
5776 @click.argument("ns_name")
5777 @click.argument(
5778     "args",
5779     nargs=-1,
5780     type=click.UNPROCESSED,
5781     callback=process_ns_heal_params,
5782 )
5783 @click.option("--timeout", type=int, default=None, help="timeout in seconds")
5784 @click.option(
5785     "--wait",
5786     default=False,
5787     is_flag=True,
5788     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5789 )
5790 @click.pass_context
5791 def ns_heal(ctx, ns_name, args, heal_params, timeout, wait):
5792     """heals (recreates) VNFs or VDUs of a NS instance
5793
5794     NS_NAME: name or ID of the NS instance
5795
5796     \b
5797     Options:
5798       --vnf TEXT             VNF instance ID or VNF id in the NS [required]
5799       --cause TEXT           human readable cause of the healing
5800       --run-day1             indicates whether or not to run day1 primitives for the VNF/VDU
5801       --vdu TEXT             vdu-id
5802       --count-index INTEGER  count-index
5803
5804     \b
5805     Example:
5806     osm ns-heal NS_NAME|NS_ID --vnf volumes_vnf --cause "Heal several_volumes-VM of several_volumes_vnf"
5807                                                 --vdu several_volumes-VM
5808                               --vnf charm_vnf --cause "Heal two VMs of native_manual_scale_charm_vnf"
5809                                               --vdu mgmtVM --count-index 1 --run-day1
5810                                               --vdu mgmtVM --count-index 2
5811     """
5812     logger.debug("")
5813     heal_dict = ctx.params["heal_params"]
5814     logger.debug(f"Heal dict:\n{yaml.safe_dump(heal_dict)}")
5815     # replace VNF id in the NS by the VNF instance ID
5816     for vnf in heal_dict["healVnfData"]:
5817         vnf_id = vnf["vnfInstanceId"]
5818         if not validate_uuid4(vnf_id):
5819             vnf_filter = f"member-vnf-index-ref={vnf_id}"
5820             vnf_list = ctx.obj.vnf.list(ns=ns_name, filter=vnf_filter)
5821             if len(vnf_list) == 0:
5822                 raise ClientException(
5823                     f"No VNF found in NS {ns_name} with filter {vnf_filter}"
5824                 )
5825             elif len(vnf_list) == 1:
5826                 vnf["vnfInstanceId"] = vnf_list[0]["_id"]
5827             else:
5828                 raise ClientException(
5829                     f"More than 1 VNF found in NS {ns_name} with filter {vnf_filter}"
5830                 )
5831     logger.debug(f"Heal dict:\n{yaml.safe_dump(heal_dict)}")
5832     check_client_version(ctx.obj, ctx.command.name)
5833     ctx.obj.ns.heal(ns_name, heal_dict, wait, timeout)
5834     exit(0)
5835
5836
5837 def process_vnf_heal_params(ctx, param, value):
5838     """
5839     Processes the params in the command vnf-heal
5840     Click does not allow advanced patterns for positional options like this:
5841     --vdu mgmtVM --count-index 1 --run-day1 --vdu mgmtVM --count-index 2
5842
5843     It returns the dictionary with all the params stored in ctx.params["heal_params"]
5844     """
5845     logger.debug("")
5846     # logger.debug(f"Args: {value}")
5847     if param.name != "args":
5848         raise ClientException(f"Unexpected param: {param.name}")
5849     # Split the tuple "value" by "--vnf"
5850     vnf = value
5851     heal_dict = {}
5852     heal_dict["healVnfData"] = []
5853     logger.debug(f"VNF: {vnf}")
5854     heal_vnf = {"vnfInstanceId": "id_to_be_substituted"}
5855     process_common_heal_params(heal_vnf, vnf)
5856     heal_dict["healVnfData"].append(heal_vnf)
5857     ctx.params["heal_params"] = heal_dict
5858     return
5859
5860
5861 @cli_osm.command(
5862     name="vnf-heal",
5863     short_help="heals (recreates) a VNF instance or the VDUs of a VNF instance",
5864     context_settings=dict(
5865         ignore_unknown_options=True,
5866     ),
5867 )
5868 @click.argument("vnf_name")
5869 @click.argument(
5870     "args",
5871     nargs=-1,
5872     type=click.UNPROCESSED,
5873     callback=process_vnf_heal_params,
5874 )
5875 @click.option("--timeout", type=int, default=None, help="timeout in seconds")
5876 @click.option(
5877     "--wait",
5878     default=False,
5879     is_flag=True,
5880     help="do not return the control immediately, but keep it until the operation is completed, or timeout",
5881 )
5882 @click.pass_context
5883 def vnf_heal2(
5884     ctx,
5885     vnf_name,
5886     args,
5887     heal_params,
5888     timeout,
5889     wait,
5890 ):
5891     """heals (recreates) a VNF instance or the VDUs of a VNF instance
5892
5893     VNF_NAME: name or ID of the VNF instance
5894
5895     \b
5896     Options:
5897       --cause TEXT           human readable cause of the healing of the VNF
5898       --run-day1             indicates whether or not to run day1 primitives for the VNF/VDU
5899       --vdu TEXT             vdu-id
5900       --count-index INTEGER  count-index
5901
5902     \b
5903     Example:
5904     osm vnf-heal VNF_INSTANCE_ID --vdu mgmtVM --count-index 1 --run-day1
5905                                  --vdu mgmtVM --count-index 2
5906     """
5907     logger.debug("")
5908     heal_dict = ctx.params["heal_params"]
5909     heal_dict["healVnfData"][-1]["vnfInstanceId"] = vnf_name
5910     logger.debug(f"Heal dict:\n{yaml.safe_dump(heal_dict)}")
5911     check_client_version(ctx.obj, ctx.command.name)
5912     vnfr = ctx.obj.vnf.get(vnf_name)
5913     ns_id = vnfr["nsr-id-ref"]
5914     ctx.obj.ns.heal(ns_id, heal_dict, wait, timeout)
5915     exit(0)
5916
5917
5918 @cli_osm.command(name="alarm-show", short_help="show alarm details")
5919 @click.argument("uuid")
5920 @click.pass_context
5921 def alarm_show(ctx, uuid):
5922     """Show alarm's detail information"""
5923
5924     check_client_version(ctx.obj, ctx.command.name)
5925     resp = ctx.obj.ns.get_alarm(uuid=uuid)
5926     alarm_filter = [
5927         "uuid",
5928         "name",
5929         "metric",
5930         "statistic",
5931         "threshold",
5932         "operation",
5933         "ns-id",
5934         "vnf-id",
5935         "vdu_name",
5936         "action",
5937         "status",
5938     ]
5939     table = PrettyTable(["key", "attribute"])
5940     try:
5941         # Arrange and return the response data
5942         alarm = resp.replace("ObjectId", "")
5943         for key in alarm_filter:
5944             if key == "uuid":
5945                 value = alarm.get(key)
5946                 key = "alarm-id"
5947             elif key == "name":
5948                 value = alarm.get(key)
5949                 key = "alarm-name"
5950             elif key == "ns-id":
5951                 value = alarm["tags"].get("ns_id")
5952             elif key == "vdu_name":
5953                 value = alarm["tags"].get("vdu_name")
5954             elif key == "status":
5955                 value = alarm["alarm_status"]
5956             else:
5957                 value = alarm[key]
5958             table.add_row([key, wrap_text(text=json.dumps(value, indent=2), width=100)])
5959         table.align = "l"
5960         print(table)
5961     except Exception:
5962         print(resp)
5963
5964
5965 # List alarm
5966 @cli_osm.command(name="alarm-list", short_help="list all alarms")
5967 @click.option(
5968     "--ns_id", default=None, required=False, help="List out alarm for given ns id"
5969 )
5970 @click.pass_context
5971 def alarm_list(ctx, ns_id):
5972     """list all alarm"""
5973
5974     check_client_version(ctx.obj, ctx.command.name)
5975     project_name = os.getenv("OSM_PROJECT", "admin")
5976     resp = ctx.obj.ns.get_alarm(project_name=project_name, ns_id=ns_id)
5977
5978     table = PrettyTable(
5979         ["alarm-id", "metric", "threshold", "operation", "action", "status"]
5980     )
5981     if resp:
5982         # return the response data in a table
5983         resp = resp.replace("ObjectId", "")
5984         for alarm in resp:
5985             table.add_row(
5986                 [
5987                     wrap_text(text=str(alarm["uuid"]), width=38),
5988                     alarm["metric"],
5989                     alarm["threshold"],
5990                     alarm["operation"],
5991                     wrap_text(text=alarm["action"], width=25),
5992                     alarm["alarm_status"],
5993                 ]
5994             )
5995     table.align = "l"
5996     print(table)
5997
5998
5999 # Update alarm
6000 @cli_osm.command(name="alarm-update", short_help="Update a alarm")
6001 @click.argument("uuid")
6002 @click.option("--threshold", default=None, help="Alarm threshold")
6003 @click.option("--is_enable", default=None, type=bool, help="enable or disable alarm")
6004 @click.pass_context
6005 def alarm_update(ctx, uuid, threshold, is_enable):
6006     """
6007     Update alarm
6008
6009     """
6010     if not threshold and is_enable is None:
6011         raise ClientException(
6012             "Please provide option to update i.e threshold or is_enable"
6013         )
6014     ctx.obj.ns.update_alarm(uuid, threshold, is_enable)
6015
6016
6017 ##############################
6018 # Role Management Operations #
6019 ##############################
6020
6021
6022 @cli_osm.command(name="role-create", short_help="creates a new role")
6023 @click.argument("name")
6024 @click.option("--permissions", default=None, help="role permissions using a dictionary")
6025 @click.pass_context
6026 def role_create(ctx, name, permissions):
6027     """
6028     Creates a new role.
6029
6030     \b
6031     NAME: Name or ID of the role.
6032     DEFINITION: Definition of grant/denial of access to resources.
6033     """
6034     logger.debug("")
6035     # try:
6036     check_client_version(ctx.obj, ctx.command.name)
6037     ctx.obj.role.create(name, permissions)
6038     # except ClientException as e:
6039     #     print(str(e))
6040     #     exit(1)
6041
6042
6043 @cli_osm.command(name="role-update", short_help="updates a role")
6044 @click.argument("name")
6045 @click.option("--set-name", default=None, help="change name of rle")
6046 # @click.option('--permissions',
6047 #               default=None,
6048 #               help='provide a yaml format dictionary with incremental changes. Values can be bool or None to delete')
6049 @click.option(
6050     "--add",
6051     default=None,
6052     help="yaml format dictionary with permission: True/False to access grant/denial",
6053 )
6054 @click.option("--remove", default=None, help="yaml format list to remove a permission")
6055 @click.pass_context
6056 def role_update(ctx, name, set_name, add, remove):
6057     """
6058     Updates a role.
6059
6060     \b
6061     NAME: Name or ID of the role.
6062     DEFINITION: Definition overwrites the old definition.
6063     ADD: Grant/denial of access to resource to add.
6064     REMOVE: Grant/denial of access to resource to remove.
6065     """
6066     logger.debug("")
6067     # try:
6068     check_client_version(ctx.obj, ctx.command.name)
6069     ctx.obj.role.update(name, set_name, None, add, remove)
6070     # except ClientException as e:
6071     #     print(str(e))
6072     #     exit(1)
6073
6074
6075 @cli_osm.command(name="role-delete", short_help="deletes a role")
6076 @click.argument("name")
6077 # @click.option('--force', is_flag=True, help='forces the deletion bypassing pre-conditions')
6078 @click.pass_context
6079 def role_delete(ctx, name):
6080     """
6081     Deletes a role.
6082
6083     \b
6084     NAME: Name or ID of the role.
6085     """
6086     logger.debug("")
6087     # try:
6088     check_client_version(ctx.obj, ctx.command.name)
6089     ctx.obj.role.delete(name)
6090     # except ClientException as e:
6091     #     print(str(e))
6092     #     exit(1)
6093
6094
6095 @cli_osm.command(name="role-list", short_help="list all roles")
6096 @click.option(
6097     "--filter",
6098     default=None,
6099     multiple=True,
6100     help="restricts the list to the projects matching the filter",
6101 )
6102 @click.pass_context
6103 def role_list(ctx, filter):
6104     """
6105     List all roles.
6106     """
6107     logger.debug("")
6108     # try:
6109     check_client_version(ctx.obj, ctx.command.name)
6110     if filter:
6111         filter = "&".join(filter)
6112     resp = ctx.obj.role.list(filter)
6113     # except ClientException as e:
6114     #     print(str(e))
6115     #     exit(1)
6116     table = PrettyTable(["name", "id"])
6117     for role in resp:
6118         table.add_row([role["name"], role["_id"]])
6119     table.align = "l"
6120     print(table)
6121
6122
6123 @cli_osm.command(name="role-show", short_help="show specific role")
6124 @click.argument("name")
6125 @click.pass_context
6126 def role_show(ctx, name):
6127     """
6128     Shows the details of a role.
6129
6130     \b
6131     NAME: Name or ID of the role.
6132     """
6133     logger.debug("")
6134     # try:
6135     check_client_version(ctx.obj, ctx.command.name)
6136     resp = ctx.obj.role.get(name)
6137     # except ClientException as e:
6138     #     print(str(e))
6139     #     exit(1)
6140
6141     table = PrettyTable(["key", "attribute"])
6142     for k, v in resp.items():
6143         table.add_row([k, json.dumps(v, indent=2)])
6144     table.align = "l"
6145     print(table)
6146
6147
6148 @cli_osm.command(name="package-create", short_help="Create empty NS package structure")
6149 @click.argument("package-type")
6150 @click.argument("package-name")
6151 @click.option(
6152     "--base-directory",
6153     default=".",
6154     help=('(NS/VNF/NST) Set the location for package creation. Default: "."'),
6155 )
6156 @click.option(
6157     "--image",
6158     default="image-name",
6159     help='(VNF) Set the name of the vdu image. Default "image-name"',
6160 )
6161 @click.option(
6162     "--vdus", default=1, help="(VNF) Set the number of vdus in a VNF. Default 1"
6163 )
6164 @click.option(
6165     "--vcpu", default=1, help="(VNF) Set the number of virtual CPUs in a vdu. Default 1"
6166 )
6167 @click.option(
6168     "--memory",
6169     default=1024,
6170     help="(VNF) Set the memory size (MB) of the vdu. Default 1024",
6171 )
6172 @click.option(
6173     "--storage", default=10, help="(VNF) Set the disk size (GB) of the vdu. Default 10"
6174 )
6175 @click.option(
6176     "--interfaces",
6177     default=0,
6178     help="(VNF) Set the number of additional interfaces apart from the management interface. Default 0",
6179 )
6180 @click.option(
6181     "--vendor", default="OSM", help='(NS/VNF) Set the descriptor vendor. Default "OSM"'
6182 )
6183 @click.option(
6184     "--override",
6185     default=False,
6186     is_flag=True,
6187     help="(NS/VNF/NST) Flag for overriding the package if exists.",
6188 )
6189 @click.option(
6190     "--detailed",
6191     is_flag=True,
6192     default=False,
6193     help="(NS/VNF/NST) Flag for generating descriptor .yaml with all possible commented options",
6194 )
6195 @click.option(
6196     "--netslice-subnets", default=1, help="(NST) Number of netslice subnets. Default 1"
6197 )
6198 @click.option(
6199     "--netslice-vlds", default=1, help="(NST) Number of netslice vlds. Default 1"
6200 )
6201 @click.option(
6202     "--old",
6203     default=False,
6204     is_flag=True,
6205     help="Flag to create a descriptor using the previous OSM format (pre SOL006, OSM<9)",
6206 )
6207 @click.pass_context
6208 def package_create(
6209     ctx,
6210     package_type,
6211     base_directory,
6212     package_name,
6213     override,
6214     image,
6215     vdus,
6216     vcpu,
6217     memory,
6218     storage,
6219     interfaces,
6220     vendor,
6221     detailed,
6222     netslice_subnets,
6223     netslice_vlds,
6224     old,
6225 ):
6226     """
6227     Creates an OSM NS, VNF, NST package
6228
6229     \b
6230     PACKAGE_TYPE: Package to be created: NS, VNF or NST.
6231     PACKAGE_NAME: Name of the package to create the folder with the content.
6232     """
6233
6234     # try:
6235     logger.debug("")
6236     check_client_version(ctx.obj, ctx.command.name)
6237     print(
6238         "Creating the {} structure: {}/{}".format(
6239             package_type.upper(), base_directory, package_name
6240         )
6241     )
6242     resp = ctx.obj.package_tool.create(
6243         package_type,
6244         base_directory,
6245         package_name,
6246         override=override,
6247         image=image,
6248         vdus=vdus,
6249         vcpu=vcpu,
6250         memory=memory,
6251         storage=storage,
6252         interfaces=interfaces,
6253         vendor=vendor,
6254         detailed=detailed,
6255         netslice_subnets=netslice_subnets,
6256         netslice_vlds=netslice_vlds,
6257         old=old,
6258     )
6259     print(resp)
6260     # except ClientException as inst:
6261     #     print("ERROR: {}".format(inst))
6262     #     exit(1)
6263
6264
6265 @cli_osm.command(
6266     name="package-validate", short_help="Validate descriptors given a base directory"
6267 )
6268 @click.argument("base-directory", default=".", required=False)
6269 @click.option(
6270     "--recursive/--no-recursive",
6271     default=True,
6272     help="The activated recursive option will validate the yaml files"
6273     " within the indicated directory and in its subdirectories",
6274 )
6275 @click.option(
6276     "--old",
6277     is_flag=True,
6278     default=False,
6279     help="Validates also the descriptors using the previous OSM format (pre SOL006)",
6280 )
6281 @click.pass_context
6282 def package_validate(ctx, base_directory, recursive, old):
6283     """
6284     Validate descriptors given a base directory.
6285
6286     \b
6287     BASE_DIRECTORY: Base folder for NS, VNF or NST package.
6288     """
6289     # try:
6290     logger.debug("")
6291     check_client_version(ctx.obj, ctx.command.name)
6292     results = ctx.obj.package_tool.validate(base_directory, recursive, old)
6293     table = PrettyTable()
6294     table.field_names = ["TYPE", "PATH", "VALID", "ERROR"]
6295     # Print the dictionary generated by the validation function
6296     for result in results:
6297         table.add_row(
6298             [result["type"], result["path"], result["valid"], result["error"]]
6299         )
6300     table.sortby = "VALID"
6301     table.align["PATH"] = "l"
6302     table.align["TYPE"] = "l"
6303     table.align["ERROR"] = "l"
6304     print(table)
6305     # except ClientException as inst:
6306     #     print("ERROR: {}".format(inst))
6307     #     exit(1)
6308
6309
6310 @cli_osm.command(
6311     name="package-translate", short_help="Translate descriptors given a base directory"
6312 )
6313 @click.argument("base-directory", default=".", required=False)
6314 @click.option(
6315     "--recursive/--no-recursive",
6316     default=True,
6317     help="The activated recursive option will translate the yaml files"
6318     " within the indicated directory and in its subdirectories",
6319 )
6320 @click.option(
6321     "--dryrun",
6322     is_flag=True,
6323     default=False,
6324     help="Do not translate yet, only make a dry-run to test translation",
6325 )
6326 @click.pass_context
6327 def package_translate(ctx, base_directory, recursive, dryrun):
6328     """
6329     Translate descriptors given a base directory.
6330
6331     \b
6332     BASE_DIRECTORY: Stub folder for NS, VNF or NST package.
6333     """
6334     logger.debug("")
6335     check_client_version(ctx.obj, ctx.command.name)
6336     results = ctx.obj.package_tool.translate(base_directory, recursive, dryrun)
6337     table = PrettyTable()
6338     table.field_names = [
6339         "CURRENT TYPE",
6340         "NEW TYPE",
6341         "PATH",
6342         "VALID",
6343         "TRANSLATED",
6344         "ERROR",
6345     ]
6346     # Print the dictionary generated by the validation function
6347     for result in results:
6348         table.add_row(
6349             [
6350                 result["current type"],
6351                 result["new type"],
6352                 result["path"],
6353                 result["valid"],
6354                 result["translated"],
6355                 result["error"],
6356             ]
6357         )
6358     table.sortby = "TRANSLATED"
6359     table.align["PATH"] = "l"
6360     table.align["TYPE"] = "l"
6361     table.align["ERROR"] = "l"
6362     print(table)
6363     # except ClientException as inst:
6364     #     print("ERROR: {}".format(inst))
6365     #     exit(1)
6366
6367
6368 @cli_osm.command(name="package-build", short_help="Build the tar.gz of the package")
6369 @click.argument("package-folder")
6370 @click.option(
6371     "--skip-validation", default=False, is_flag=True, help="skip package validation"
6372 )
6373 @click.option(
6374     "--skip-charm-build",
6375     default=False,
6376     is_flag=True,
6377     help="the charm will not be compiled, it is assumed to already exist",
6378 )
6379 @click.pass_context
6380 def package_build(ctx, package_folder, skip_validation, skip_charm_build):
6381     """
6382     Build the package NS, VNF given the package_folder.
6383
6384     \b
6385     PACKAGE_FOLDER: Folder of the NS, VNF or NST to be packaged
6386     """
6387     # try:
6388     logger.debug("")
6389     check_client_version(ctx.obj, ctx.command.name)
6390     results = ctx.obj.package_tool.build(
6391         package_folder,
6392         skip_validation=skip_validation,
6393         skip_charm_build=skip_charm_build,
6394     )
6395     print(results)
6396     # except ClientException as inst:
6397     #     print("ERROR: {}".format(inst))
6398     #     exit(1)
6399
6400
6401 @cli_osm.command(
6402     name="descriptor-translate",
6403     short_help="Translate input descriptor file from Rel EIGHT OSM descriptors to SOL006 and prints in standard output",
6404 )
6405 @click.argument("descriptor-file", required=True)
6406 @click.pass_context
6407 def descriptor_translate(ctx, descriptor_file):
6408     """
6409     Translate input descriptor.
6410
6411     \b
6412     DESCRIPTOR_FILE: Descriptor file for NS, VNF or Network Slice.
6413     """
6414     logger.debug("")
6415     check_client_version(ctx.obj, ctx.command.name)
6416     result = ctx.obj.package_tool.descriptor_translate(descriptor_file)
6417     print(result)
6418
6419
6420 def cli():
6421     try:
6422         cli_osm()  # pylint: disable=no-value-for-parameter
6423         exit(0)
6424     except pycurl.error as exc:
6425         print(exc)
6426         print(
6427             'Maybe "--hostname" option or OSM_HOSTNAME environment variable needs to be specified'
6428         )
6429     except ClientException as exc:
6430         print("ERROR: {}".format(exc))
6431     except (FileNotFoundError, PermissionError) as exc:
6432         print("Cannot open file: {}".format(exc))
6433     except yaml.YAMLError as exc:
6434         print("Invalid YAML format: {}".format(exc))
6435     exit(1)
6436     # TODO capture other controlled exceptions here
6437     # TODO remove the ClientException captures from all places, unless they do something different
6438
6439
6440 if __name__ == "__main__":
6441     cli()