products/onap-dublin/features/integration/src/main/resources/script/vnf-tosca-lcm.py

   1 #!/usr/bin/python
   2 # Copyright 2019 Huawei Technologies Co., Ltd.
   3 #
   4 # Licensed under the Apache License, Version 2.0 (the "License");
   5 # you may not use this file except in compliance with the License.
   6 # You may obtain a copy of the License at
   7 #
   8 #     http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 # Unless required by applicable law or agreed to in writing, software
  11 # distributed under the License is distributed on an "AS IS" BASIS,
  12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 # See the License for the specific language governing permissions and
  14 # limitations under the License.
  15
  16 # This script uses the ONAP CLI for providing the end-end service creation and termination.
  17 # Used in devops, testing, certification and production
  18 # NOTE: This feature is avaialble as ONAP CLI vnf-tosca-lcm
  19 #
  20 # Author: kanagaraj.manickam@huawei.com
  21 #
  22
  23 import json
  24 import os
  25 import argparse
  26 import sys
  27 import uuid
  28 import subprocess
  29 import platform
  30 import datetime
  31 import string
  32 import random
  33 import time
  34
  35 from argparse import RawTextHelpFormatter
  36
  37 if platform.system() == 'Windows':
  38     CMD_NAME = 'oclip.cmd'
  39 else:
  40     CMD_NAME = 'oclip.sh'
  41
  42 class OcompException(Exception):
  43     def __init__(self, code, message):
  44         super(OcompException, self).__init__()
  45         self.code = code;
  46         self.message = message;
  47
  48 class OCOMP:
  49     def __init__(self,
  50                  request_id = os.environ.get('OPEN_CLI_REQUEST_ID'),
  51                  debug = False,
  52                  format = 'json',
  53                  product = os.environ.get('OPEN_CLI_PRODUCT_IN_USE'),
  54                  profile = os.environ.get('OPEN_CLI_PROFILE')):
  55         if not request_id:
  56                 request_id = str(uuid.uuid4())
  57         self.request_id = request_id
  58         self.debug = debug
  59         self.format = format
  60         self.product = product
  61         self.profile = profile
  62
  63     def __str__(self):
  64         return  str(vars(self))
  65
  66     def __repr__(self):
  67         return  str(self)
  68
  69     @staticmethod
  70     def version():
  71         return os.popen('{} --version'.format(CMD_NAME)).read()
  72
  73     def run(self, command, params={}, product=None,  profile=None, request_id=None):
  74         CMD = [CMD_NAME]
  75
  76         if not request_id:
  77                 request_id = self.request_id
  78
  79         if request_id:
  80             CMD.append('--request-id')
  81             CMD.append(request_id)
  82
  83         if not product:
  84             product = self.product
  85
  86         if product:
  87             CMD.append('--product')
  88             CMD.append(product)
  89
  90         if not profile:
  91             profile = self.profile
  92
  93         if profile:
  94             CMD.append('--profile')
  95             CMD.append(profile)
  96
  97         CMD.append(command)
  98
  99         if self.debug:
 100             CMD.append('--debug')
 101
 102         CMD.append('--format')
 103         CMD.append(self.format)
 104
 105         for name, value in params.items():
 106             CMD.append('--{}'.format(name))
 107             CMD.append(value)
 108
 109         cmd_string = ' '.join(CMD)
 110         print (cmd_string)
 111
 112         try:
 113             res = subprocess.Popen(CMD, stdout=subprocess.PIPE)
 114             res.wait()
 115             result = res.stdout.read().strip()
 116             print (res.returncode, result)
 117
 118             if res.returncode != 0:# and res.returncode != 1:
 119                 raise OcompException(9999, result)
 120             if result:
 121                 return json.loads(result)
 122             else:
 123                 return {}
 124         except OSError as e:
 125             sys.stderr.write(str(e))
 126             msg = 'failed to executed the command {}'.format(cmd_string)
 127             print (msg)
 128             raise OcompException(9999, msg)
 129
 130 class ONAP:
 131     def __init__(self,
 132                  product,
 133                  profile,
 134                  conf,
 135                  request_id,
 136                  debug = False):
 137         self.conf = conf or {}
 138         self.ocomp = OCOMP(request_id, debug, product=product, profile=profile)
 139         self.preload()
 140         self.tag = 'Powered by Open Command Platform - OCOMP'
 141
 142     def preload(self):
 143         if self.conf['ONAP']:
 144             for attr in self.conf['ONAP']:
 145                 setattr(self, attr, self.conf['ONAP'][attr])
 146         else:
 147             self.conf['ONAP'] = {}
 148
 149     def create_vlm(self):
 150         submit = False
 151
 152         if not self.vlm_id and not self.vlm_version:
 153             output = self.ocomp.run(command='vlm-create',
 154                                         params={'vendor-name': self.conf['vnf']['vendor-name'],
 155                                                 'description': self.tag})
 156
 157             self.vlm_id = output['id']
 158             self.vlm_version = output['version']
 159             submit = True
 160
 161         if not self.entitlement_id:
 162             output = self.ocomp.run(command='vlm-entitlement-pool-create',
 163                                     params={'name': '{} Entitlement Pool'.format(self.conf['vnf']['vendor-name']),
 164                                             'vlm-id': self.vlm_id,
 165                                             'vlm-version': self.vlm_version,
 166                                             'manufacture-reference-number': 'OCOMP',
 167                                             'start-date': datetime.datetime.strftime(datetime.datetime.today(),'%m/%d/%Y'),
 168                                             'expiry-date': datetime.datetime.strftime(datetime.datetime.today() + datetime.timedelta(1),'%m/%d/%Y')})
 169             self.entitlement_id = output['id']
 170             submit = True
 171
 172         if not self.key_group_id:
 173             output = self.ocomp.run(command='vlm-key-group-create',
 174                                         params={'name': '{} Key goroup'.format(self.conf['vnf']['vendor-name']),
 175                                                 'vlm-id': self.vlm_id,
 176                                                 'vlm-version': self.vlm_version,
 177                                                 'type': 'Universal'})
 178
 179             self.key_group_id = output['id']
 180             submit = True
 181
 182         if not self.feature_group_id:
 183             output = self.ocomp.run(command='vlm-feature-group-create',
 184                                         params={'name': '{} Feature group'.format(self.conf['vnf']['vendor-name']),
 185                                                 'vlm-id': self.vlm_id,
 186                                                 'vlm-version': self.vlm_version,
 187                                                 'vlm-key-group-id': self.key_group_id,
 188                                                 'vlm-entitle-pool-id': self.entitlement_id,
 189                                                 'part-number': '100000'})
 190
 191             self.feature_group_id = output['id']
 192             submit = True
 193
 194         if not self.agreement_id:
 195             output = self.ocomp.run(command='vlm-aggreement-create',
 196                                         params={'name': '{} Agreement'.format(self.conf['vnf']['vendor-name']),
 197                                                 'vlm-id': self.vlm_id,
 198                                                 'vlm-version': self.vlm_version,
 199                                                 'vlm-feature-group-id': self.feature_group_id})
 200
 201             self.agreement_id = output['id']
 202             submit = True
 203
 204         if submit:
 205             self.ocomp.run(command='vlm-submit',
 206                                     params={'vlm-id': self.vlm_id,
 207                                             'vlm-version': self.vlm_version})
 208
 209     def create_vsp(self):
 210         if not self.vsp_id and not self.vsp_version and not self.vsp_version_id:
 211             output = self.ocomp.run(command='vsp-create',
 212                                     params={'vlm-id': self.vlm_id,
 213                                             'vlm-version': self.vlm_version,
 214                                             'vlm-vendor': self.conf['vnf']['vendor-name'],
 215                                             'vsp-name': self.conf['vnf']['name'],
 216                                             'vsp-description': self.tag,
 217                                             'vlm-agreement-id': self.agreement_id,
 218                                             'vlm-feature-group-id': self.feature_group_id})
 219             self.vsp_id = output['id']
 220             self.vsp_version_id = output['version-id']
 221             self.vsp_version = output['version']
 222
 223             self.ocomp.run(command='vsp-add-artifact',
 224                                     params={'vsp-id': self.vsp_id,
 225                                             'vsp-version': self.vsp_version_id,
 226                                             'vsp-file': self.conf['vnf']['vsp-csar']})
 227
 228             output = self.ocomp.run(command='vsp-validate',
 229                                     params={'vsp-id': self.vsp_id,
 230                                             'vsp-version': self.vsp_version_id})
 231             if not output['status'] == "Success":
 232                 raise Exception("Invalid VSP package, please check it compliance using VTP")
 233
 234             self.ocomp.run(command='vsp-commit',
 235                                     params={'vsp-id': self.vsp_id,
 236                                             'vsp-version': self.vsp_version_id,
 237                                             'remarks': self.tag})
 238
 239             self.ocomp.run(command='vsp-submit',
 240                                     params={'vsp-id': self.vsp_id,
 241                                             'vsp-version': self.vsp_version_id})
 242
 243             self.ocomp.run(command='vsp-package',
 244                                     params={'vsp-id': self.vsp_id,
 245                                             'vsp-version': self.vsp_version_id})
 246
 247     def create_vf_model(self):
 248         if not self.vf_id and not self.vf_version:
 249             output = self.ocomp.run(command='vf-model-create',
 250                                     params={'name': '{} Vnf'.format(self.conf['vnf']['name']),
 251                                             'vendor-name': self.conf['vnf']['vendor-name'],
 252                                             'vsp-id': self.vsp_id,
 253                                             'vsp-version': self.vsp_version, # TODO: SDC fails to add VSP, check it
 254                                             'description': self.tag})
 255
 256             vf_id = output['id']
 257             inputs = output['inputs'].replace('[', '').replace(']', '').split(',')
 258             # add artifact
 259             self.ocomp.run(command='vf-model-add-artifact',
 260                                     params={'vf-id': vf_id,
 261                                             'remarks': self.tag,
 262                                             'artifact': self.conf['vnf']['vnf-csar'],
 263                                             'artifact-name': 'vnf.csar'})
 264
 265             output = self.ocomp.run(command='vf-model-certify',
 266                                         params={'vf-id': vf_id,
 267                                                 'remarks': self.tag})
 268             self.vf_id = output['id']
 269             self.vf_version = output['version']
 270             self.vf_uuid = output['uuid']
 271             self.vf_inputs = inputs
 272
 273     def create_service_model(self):
 274         if not self.ns_id and not self.ns_version:
 275             output = self.ocomp.run(command='service-model-create',
 276                                     params={'service-name': '{} Service'.format(self.conf['vnf']['name']),
 277                                             'description': self.tag,
 278                                             'project-code':  'OCOMP',
 279                                             'category':  'network l1-3',
 280                                             'category-display-name':  'Network L1-3',
 281                                             'icon-id':  'network_l_1-3'})
 282             ns_id = output['id']
 283
 284             if not self.ns_vf_resource_id:
 285                 output = self.ocomp.run(command='service-model-add-vf',
 286                                         params={'service-id': ns_id,
 287                                                 'vf-id': self.vf_id,
 288                                                 'vf-version': self.vf_version,
 289                                                 'vf-name': self.conf['vnf']['name']})
 290                 self.ns_vf_resource_id = output['id']
 291
 292             # add artifact
 293             self.ocomp.run(command='service-model-add-artifact',
 294                                     params={'service-id': ns_id,
 295                                             'remarks': self.tag,
 296                                             'artifact': self.conf['vnf']['ns-csar'],
 297                                             'artifact-group-type': 'DEPLOYMENT',
 298                                             'artifact-name': 'ns.csar'})
 299             #set property vnfmdriver
 300             for input in self.vf_inputs:
 301                 if input.endswith('.nf_type'):
 302                     tkns = input.strip().split('.')
 303                     input_uuid = tkns[0]
 304                     self.ocomp.run(command='service-model-set-property',
 305                                              params={'service-id': ns_id,
 306                                                      'vf-id': self.vf_id,
 307                                                      'vf-resource-id': self.ns_vf_resource_id,
 308                                                      'property-name': 'nf_type',
 309                                                      'property-value': self.conf['vnf']['vnfm-driver'],
 310                                                      'input-uuid': input_uuid})
 311                     break
 312
 313             self.ocomp.run(command='service-model-test-request',
 314                                     params={'service-id': ns_id,
 315                                             'remarks': self.tag})
 316
 317             self.ocomp.run(command='service-model-test-start',
 318                                     params={'service-id': ns_id})
 319
 320         output = self.ocomp.run(command='service-model-test-accept',
 321                                 params={'service-id': ns_id,
 322                                         'remarks': self.tag})
 323         self.ns_id = output['id']
 324         self.ns_version = output['version']
 325         self.ns_uuid = output['uuid']
 326
 327         self.ocomp.run(command='service-model-approve',
 328                                 params={'service-id': self.ns_id,
 329                                         'remarks': self.tag})
 330
 331         self.ocomp.run(command='service-model-distribute',
 332                                 params={'service-id': self.ns_id})
 333
 334     def setup_cloud_and_subscription(self):
 335         associate = False
 336         if not self.location_id and not self.location_version:
 337             location_id = 'ocomp-region-{}'.format(self.conf['ONAP']['uid'])
 338             self.ocomp.run(command='complex-create',
 339                                     params={'physical-location-id': location_id,
 340                                             'data-center-code': 'ocomp',
 341                                             'complex-name': location_id,
 342                                             'identity-url': self.conf['cloud']['identity-url'],
 343                                             'physical-location-type': 'phy_type',
 344                                             'street1': 'ocomp-street1',
 345                                             'street2': 'ocomp-street2',
 346                                             'city': 'ocomp-city',
 347                                             'state': 'ocomp-state',
 348                                             'postal-code': '001481',
 349                                             'country': 'abc',
 350                                             'longitude': '1.0',
 351                                             'latitude': '1.0',
 352                                             'region': 'onap',
 353                                             'elevation': 'ocomp-elelation',
 354                                             'lata': 'ocomp-lata'})
 355             self.location_id = location_id
 356             associate = True
 357
 358             output = self.ocomp.run(command='complex-list')
 359
 360             for location in output:
 361                 if location['complex-name'] == self.location_id:
 362                     self.location_version = location['resource-version']
 363                     break
 364
 365         if not self.cloud_id and not self.cloud_version:
 366             cloud_id = 'OCOMP-{}'.format(self.conf['ONAP']['uid'])
 367             self.ocomp.run(command='cloud-create',
 368                                     params={'region-name': self.conf['cloud']['region'],
 369                                             'complex-name': self.location_id,
 370                                             'identity-url': self.conf['cloud']['identity-url'],
 371                                             'cloud-owner': cloud_id,
 372                                             'cloud-type': 'openstack',
 373                                             'owner-type': 'ocomp',
 374                                             'cloud-region-version': self.conf['cloud']['version'],
 375                                             'cloud-zone': 'az1',
 376                                             'esr-id': cloud_id,
 377                                             'service-url': self.conf['cloud']['identity-url'],
 378                                             'username': self.conf['cloud']['username'],
 379                                             'password': self.conf['cloud']['password'],
 380                                             'system-type': 'VIM',
 381                                             'ssl-insecure': 'true',
 382                                             'cloud-domain': 'Default',
 383                                             'default-tenant': self.conf['cloud']['tenant'],
 384                                             'system-status': "active"})
 385             self.cloud_id = cloud_id
 386             associate = True
 387
 388             output = self.ocomp.run(command='cloud-list')
 389
 390             for cloud in output:
 391                 if cloud['cloud'] == self.cloud_id:
 392                     self.cloud_version = cloud['resource-version']
 393                     break
 394
 395         if associate:
 396             self.ocomp.run(command='complex-associate',
 397                                     params={'complex-name': self.location_id,
 398                                             'cloud-region': self.conf['cloud']['region'],
 399                                             'cloud-owner': self.cloud_id})
 400
 401         self.ocomp.run(command='multicloud-register-cloud',
 402                        params={'cloud-region': self.conf['cloud']['region'], 'cloud-owner': self.cloud_id})
 403
 404         subscribe = False
 405         if not self.service_type_id and not self.service_type_version:
 406             service_type_id = '{}-{}'.format(self.conf['subscription']['service-type'], self.conf['ONAP']['uid'])
 407             self.ocomp.run(command='service-type-create',
 408                                 params={'service-type': service_type_id,
 409                                         'service-type-id': service_type_id})
 410             self.service_type_id = service_type_id
 411             subscribe = True
 412
 413             output = self.ocomp.run(command='service-type-list')
 414
 415             for st in output:
 416                 if st['service-type'] == self.service_type_id:
 417                     self.service_type_version = st['resource-version']
 418                     break
 419
 420         if not self.customer_id and not self.customer_version:
 421             customer_id = '{}-{}'.format(self.conf['subscription']['customer-name'], self.conf['ONAP']['uid'])
 422             self.ocomp.run(command='customer-create',
 423                                 params={'customer-name': customer_id,
 424                                         'subscriber-name': customer_id})
 425             self.customer_id = customer_id
 426             subscribe = True
 427
 428             output = self.ocomp.run(command='customer-list')
 429
 430             for customer in output:
 431                 if customer['name'] == self.customer_id:
 432                     self.customer_version = customer['resource-version']
 433                     break
 434
 435         if not self.tenant_id and not self.tenant_version:
 436             output = self.ocomp.run(command='tenant-list', params={
 437                 'cloud': self.cloud_id,
 438                 'region': self.conf['cloud']['region']
 439                 })
 440
 441             for tenant in output:
 442                 if tenant['tenant-name'] == self.conf['cloud']['tenant']:
 443                     self.tenant_id = tenant['tenant-id']
 444                     self.tenant_version = tenant['resource-version']
 445                     subscribe = True
 446                     break
 447
 448         if subscribe:
 449             self.ocomp.run(command='subscription-create',
 450                                     params={'customer-name': self.customer_id,
 451                                             'cloud-owner': self.cloud_id,
 452                                             'cloud-region': self.conf['cloud']['region'],
 453                                             'cloud-tenant-id': self.tenant_id,
 454                                             'service-type': self.service_type_id,
 455                                             'tenant-name': self.conf['cloud']['tenant']})
 456
 457         if not self.subscription_version:
 458             output = self.ocomp.run(command='subscription-list', params={
 459                     'customer-name': self.customer_id
 460                     })
 461
 462             for subscription in output:
 463                 if subscription['service-type'] == self.service_type_id:
 464                     self.subscription_version = subscription['resource-version']
 465                     break
 466
 467         if not self.esr_vnfm_id and not self.esr_vnfm_version:
 468             vnfmdriver = self.conf['vnf']['vnfm-driver']
 469
 470             esr_vnfm_id = str(uuid.uuid4())
 471             self.ocomp.run(command='vnfm-create',
 472                                     params={'vim-id': self.cloud_id + "_" + self.conf['cloud']['region'],
 473                                             'vnfm-id': esr_vnfm_id,
 474                                             'name': 'OCOMP {}'.format(vnfmdriver),
 475                                             'type': vnfmdriver,
 476                                             'vendor': self.conf['vnf']['vendor-name'],
 477                                             'vnfm-version': self.conf['vnfm'][vnfmdriver]['version'],
 478                                             'url': self.conf['vnfm'][vnfmdriver]['url'],
 479                                             'username': self.conf['vnfm'][vnfmdriver]['username'] ,
 480                                             'password': self.conf['vnfm'][vnfmdriver]['password']})
 481             self.esr_vnfm_id = esr_vnfm_id
 482
 483         output = self.ocomp.run(command='vnfm-list')
 484
 485         for vnfm in output:
 486             if vnfm['vnfm-id'] == self.esr_vnfm_id:
 487                 self.esr_vnfm_version = vnfm['resource-version']
 488                 break
 489
 490 #         self.ocomp.run(command='multicloud-register-cloud',
 491 #                                 params={'cloud-region': self.conf['cloud']['region'],
 492 #                                         'cloud-owner': self.cloud_id})
 493
 494     def create_vnf(self):
 495         self.ocomp.run(command='vfc-catalog-onboard-vnf',
 496                        params={'vnf-csar-uuid': self.vf_uuid})
 497
 498         vnf_flag = False
 499         for i in range(60):
 500             output = self.ocomp.run(command='vfc-catalog-get-vnf')
 501             for csar in output:
 502                 if csar.get("csar-id") == self.vf_uuid:
 503                     vnf_flag = True
 504                     break
 505             if vnf_flag:
 506                 break
 507             else:
 508                 time.sleep(1)
 509
 510         self.ocomp.run(command='vfc-catalog-onboard-ns',
 511                                 params={'ns-csar-uuid': self.ns_uuid})
 512
 513         output = self.ocomp.run(command='vfc-nslcm-create',
 514                                 params={'ns-csar-uuid': self.ns_uuid,
 515                                         'ns-csar-name': '{} Service'.format(self.conf['vnf']['name']),
 516                                         'customer-name': self.customer_id,
 517                                         'service-type': self.service_type_id})
 518
 519         self.ns_instance_id = output['ns-instance-id']
 520
 521         output = self.ocomp.run(command='vfc-nslcm-instantiate',
 522                                 params={'ns-instance-id': self.ns_instance_id,
 523                                         'location': self.cloud_id + "_" + self.conf['cloud']['region'],
 524                                         'sdn-controller-id': self.esr_vnfm_id})
 525
 526         jobid = output['job-id']
 527         self.waitProcessFinished(jobid)
 528
 529     def vnf_status_check(self):
 530         self.vnf_status = 'active'
 531         self.ns_instance_status = 'active'
 532
 533     def waitProcessFinished(self, job_id):
 534         for i in range(150):
 535             output = self.ocomp.run(command='vfc-nslcm-get-jobid',
 536                                     params={'ns-job-id': job_id})
 537             progress_rep = int(output["job-progress"])
 538             if 100 != progress_rep:
 539                 if 255 == progress_rep:
 540                     break
 541                 time.sleep(1)
 542             else:
 543                 break
 544
 545     def cleanup(self):
 546         if self.ns_instance_id:
 547             output = self.ocomp.run(command='vfc-nslcm-terminate',
 548                               params={'ns-instance-id': self.ns_instance_id})
 549             jobid = output['job-id']
 550             self.waitProcessFinished(jobid)
 551             self.ocomp.run(command='vfc-nslcm-delete',
 552                               params={'ns-instance-id': self.ns_instance_id})
 553             self.ns_instance_id = None
 554
 555         if self.ns_id:
 556             self.ocomp.run(command='service-model-archive',
 557                               params={'service-id': self.ns_id})
 558             self.ns_id = self.ns_uuid = self.ns_version = self.ns_vf_resource_id = None
 559
 560         if self.vf_id:
 561             self.ocomp.run(command='vf-model-archive',
 562                               params={'vf-id': self.vf_id})
 563             self.vf_id = self.vf_uuid = self.vf_inputs = self.vf_version = None
 564
 565         if self.vsp_id:
 566             self.ocomp.run(command='vsp-archive',
 567                               params={'vsp-id': self.vsp_id})
 568             self.vsp_id = self.vsp_version_id = self.vsp_version = None
 569
 570         if self.vlm_id:
 571             self.ocomp.run(command='vlm-archive',
 572                               params={'vlm-id': self.vlm_id})
 573             self.vlm_id = self.vlm_version = self.entitlement_id = self.key_group_id = self.feature_group_id = self.agreement_id = None
 574
 575         if self.subscription_version and self.customer_id and self.service_type_id:
 576             self.ocomp.run(command='subscription-delete',
 577                               params={'customer-name': self.customer_id,
 578                                       'service-type': self.service_type_id,
 579                                       'resource-version': self.subscription_version})
 580             self.subscription_version = None
 581
 582         if self.customer_id and self.customer_version:
 583             self.ocomp.run(command='customer-delete',
 584                               params={'customer-id': self.customer_id,
 585                                       'resource-version': self.customer_version})
 586             self.customer_id = self.customer_version = None
 587
 588         if self.service_type_id and self.service_type_version:
 589             output = self.ocomp.run(command='service-type-list')
 590
 591             for st in output:
 592                 if st['service-type-id'] == self.service_type_id:
 593                     self.service_type_version = st['resource-version']
 594                     break
 595
 596             self.ocomp.run(command='service-type-delete',
 597                               params={'service-type-id': self.service_type_id,
 598                                       'resource-version': self.service_type_version})
 599             self.service_type_id = self.service_type_version = None
 600
 601         output = self.ocomp.run(command='tenant-list', params={
 602             'cloud': self.cloud_id,
 603             'region': self.conf['cloud']['region']
 604         })
 605
 606         for tenant in output:
 607             if tenant['tenant-name'] == self.conf['cloud']['tenant']:
 608                 self.tenant_id = tenant['tenant-id']
 609                 self.tenant_version = tenant['resource-version']
 610                 break
 611
 612         if self.tenant_id and self.tenant_version:
 613             self.ocomp.run(command='tenant-delete',
 614                               params={'cloud': self.cloud_id,
 615                                       'region': self.conf['cloud']['region'],
 616                                       'tenant-id': self.tenant_id,
 617                                       'resource-version': self.tenant_version})
 618             self.tenant_id = self.tenant_version = None
 619
 620         if self.cloud_id:
 621             self.ocomp.run(command='multicloud-cloud-delete',
 622                            params={'cloud-owner': self.cloud_id,
 623                                    'cloud-region': self.conf['cloud']['region']})
 624
 625             for i in range(30):
 626                 cloud_flag = False
 627                 output = self.ocomp.run(command='cloud-list')
 628                 for cloud in output:
 629                     if cloud.get('cloud') == self.cloud_id:
 630                         cloud_flag = True
 631                         break
 632                 if not cloud_flag:
 633                     break
 634                 else:
 635                     time.sleep(1)
 636
 637             self.cloud_id = self.cloud_version = None
 638
 639         output = self.ocomp.run(command='complex-list')
 640
 641         for location in output:
 642             if location['complex-name'] == self.location_id:
 643                 self.location_version = location['resource-version']
 644                 break
 645
 646         if self.location_id and self.location_version:
 647             self.ocomp.run(command='complex-delete',
 648                               params={'complex-name': self.location_id,
 649                                       'resource-version': self.location_version})
 650             self.location_id = self.location_version = None
 651
 652         if self.esr_vnfm_id and self.esr_vnfm_version:
 653             self.ocomp.run(command='vnfm-delete',
 654                               params={'vnfm-id': self.esr_vnfm_id,
 655                                       'resource-version': self.esr_vnfm_version})
 656             self.esr_vnfm_id = self.esr_vnfm_version = None
 657
 658     def __str__(self):
 659         return  str(vars(self))
 660
 661 #Main
 662 if __name__ == '__main__':
 663     parser = argparse.ArgumentParser(description="ONAP TOSCA VNF validation using ONAP CLI and Open Command Platform (OCOMP)", formatter_class=RawTextHelpFormatter)
 664     parser.add_argument('--product', action='store', dest='product', help='OCOMP product to use, default to onap-dublin',
 665                         default=os.environ.get('OPEN_CLI_PRODUCT_IN_USE'))
 666     parser.add_argument('--profile', action='store', dest='profile', help='OCOMP profile to use, default to onap-dublin',
 667                         default=os.environ.get('OPEN_CLI_PROFILE'))
 668     parser.add_argument('--request-id', action='store', dest='request_id',
 669                         help='Request Id to track the progress of running this script',
 670                         default=os.environ.get('OPEN_CLI_REQUEST_ID'))
 671     parser.add_argument('--conf', action='store', dest='config_file_path', help='Configuration file path')
 672     parser.add_argument('--vsp', action='store', dest='vsp', help='ONAP VSP file path')
 673     parser.add_argument('--vnf-csar', action='store', dest='vnf_csar', help='TOSCA VNF CSAR file path')
 674     parser.add_argument('--ns-csar', action='store', dest='ns_csar', help='TOSCA VNF CSAR file path')
 675     parser.add_argument('--vnfm-driver', action='store', dest='vnfm_driver', help='VNFM dirver type one of gvnfmdriver or hwvnfmdriver',
 676                         choices=('gvnfmdriver', 'hwvnfmdriver'))
 677     parser.add_argument('--vnf-name', action='store', dest='vnf_name', help='VNF Name')
 678     parser.add_argument('--vendor-name', action='store', dest='vendor_name', help='VNF Vendor name')
 679     parser.add_argument('--result-json', action='store', dest='result', help='Result json file. ' \
 680                                     '\nInstead of creating new ONAP objects while running this script \nand to use the existing ONAP object Ids, '\
 681                                     'use this \nresult json parameter. Object Id names are provided in configuration \nfile under ONAP section')
 682     parser.add_argument('--mode', action='store', dest='mode', help='Supports 5 mode.'\
 683                         '\nsetup - Create the required VLM, service type, cloud, customer and \nsubscription as given in conf file' \
 684                         '\nstandup - Create the VSP, VF Model, Service Model and provision\n the service using VFC'\
 685                         '\ncleanup - Remove the ONAP objects which are either created during \nsetup and standup phase or provided by the user in result-json file ' \
 686                                    '\nCAUTION: If required, do not provide the existing ONAP object ids \nin result-json while doing the cleanup, to avoid them getting deleted.'\
 687                         '\ncheckup - Check the deployment weather OCOMP is working properly or not' \
 688                         '\nprovision - Run thru setup -> standup' \
 689                         '\nvalidate -  run thru setup -> standup -> cleanup modes for end to end vnf validation',
 690                                    choices=('setup', 'standup', 'cleanup', 'checkup', 'provision', 'validate'))
 691
 692     args = parser.parse_args()
 693     print (args)
 694
 695     if not args.product:
 696         product = 'onap-dublin'
 697     else:
 698         product = args.product
 699
 700     if not args.profile:
 701         profile = 'onap-dublin'
 702     else:
 703         profile = args.profile
 704
 705     request_id = args.request_id
 706     if not request_id:
 707         request_id = str(uuid.uuid4())
 708     vsp_csar = args.vsp
 709     vnf_csar = args.vnf_csar
 710     ns_csar = args.ns_csar
 711     if args.mode:
 712         mode = args.mode
 713     else:
 714         mode = 'checkup'
 715
 716     if args.vnfm_driver:
 717         vnfm_driver = args.vnfm_driver
 718     else:
 719         vnfm_driver = 'gvnfmdriver'
 720
 721     if args.vnf_name:
 722         vnf_name = args.vnf_name
 723     else:
 724         vnf_name = None
 725
 726     if args.vendor_name:
 727         vendor_name = args.vendor_name
 728     else:
 729         vendor_name = None
 730
 731     conf = {}
 732     config_file = args.config_file_path
 733     with open(config_file) as json_file:
 734         conf = json.load(json_file)
 735         if not 'uid' in conf['ONAP']:
 736             conf['ONAP']['uid'] = ''.join(random.sample(string.ascii_lowercase,5))
 737         if vsp_csar:
 738             conf['vnf']['vsp-csar'] = vsp_csar
 739         if vnf_csar:
 740             conf['vnf']['vnf-csar'] = vnf_csar
 741         if ns_csar:
 742             conf['vnf']['ns-csar'] = ns_csar
 743         if vnf_name:
 744             conf['vnf']['name'] = vnf_name
 745         conf['vnf']['name'] = '{}{}'.format(conf['vnf']['name'], conf['ONAP']['uid'])
 746         if vendor_name:
 747             conf['vnf']['vendor-name'] = vendor_name
 748         conf['vnf']['vendor-name'] = '{}-{}'.format(conf['vnf']['vendor-name'], conf['ONAP']['uid'])
 749         if vnfm_driver:
 750             conf['vnf']['vnfm-driver'] = vnfm_driver
 751
 752     if args.result:
 753         result_file = args.result
 754         with open(result_file) as r_file:
 755             result_json = json.load(r_file)
 756             for r in result_json:
 757                 if r in conf['ONAP']:
 758                     conf['ONAP'][r] = result_json[r]
 759     else:
 760         result_file = None
 761
 762     print (OCOMP.version())
 763
 764     onap = ONAP(product, profile, conf, request_id)
 765
 766     def _setup():
 767         onap.create_vlm()
 768         onap.setup_cloud_and_subscription()
 769
 770     def _standup():
 771         onap.create_vsp()
 772         onap.create_vf_model()
 773         onap.create_service_model()
 774         onap.create_vnf()
 775         onap.vnf_status_check()
 776
 777     def _cleanup():
 778         onap.cleanup()
 779
 780     try:
 781         if mode == 'setup':
 782             _setup()
 783         elif mode == 'standup':
 784             _standup()
 785         elif mode == 'cleanup':
 786             _cleanup()
 787         elif mode == 'checkup':
 788             onap.ocomp.product = 'open-cli'
 789             onap.ocomp.run(command='schema-list', params={'product': 'open-cli'})
 790         elif mode == 'provision':
 791            _setup()
 792            _standup()
 793         elif mode == 'validate':
 794            _setup()
 795            _standup()
 796            _cleanup()
 797
 798         print ('Done')
 799     finally:
 800         onap_result = json.dumps(onap, default=lambda x: x.__dict__)
 801         print(onap_result)
 802
 803         if result_file:
 804             #Remove conf and ocomp from the onap object
 805             for attr in ['ocomp', 'tag', 'conf']:
 806                 delattr(onap, attr)
 807
 808             with open(result_file, "w") as f:
 809                 f.write(json.dumps(onap, default=lambda x: x.__dict__))