RO/osm_ro/vmwarecli.py

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 ##
   4 # This file is standalone vmware vcloud director util
   5 # All Rights Reserved.
   6 #
   7 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   8 # not use this file except in compliance with the License. You may obtain
   9 # a copy of the License at
  10 #
  11 #         http://www.apache.org/licenses/LICENSE-2.0
  12 #
  13 # Unless required by applicable law or agreed to in writing, software
  14 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  16 # License for the specific language governing permissions and limitations
  17 # under the License.
  18 #
  19 # For those usages not covered by the Apache License, Version 2.0 please
  20 # contact with: mbayramov@vmware.com
  21 ##
  22
  23 """
  24
  25 Standalone application that leverage openmano vmware connector work with vCloud director rest api.
  26
  27  - Provides capability to create and delete VDC for specific organization.
  28  - Create, delete and manage network for specific VDC
  29  - List deployed VM's , VAPPs, VDSs, Organization
  30  - View detail information about VM / Vapp , Organization etc
  31  - Operate with images upload / boot / power on etc
  32
  33  Usage example.
  34
  35  List organization created in vCloud director
  36   vmwarecli.py -u admin -p qwerty123 -c 172.16.254.206 -U Administrator -P qwerty123 -o test -v TEF list org
  37
  38  List VDC for particular organization
  39   vmwarecli.py -u admin -p qwerty123 -c 172.16.254.206 -U Administrator -P qwerty123 -o test -v TEF list vdc
  40
  41  Upload image
  42   python vmwarerecli.py image upload /Users/spyroot/Developer/Openmano/Ro/vnfs/cirros/cirros.ovf
  43
  44  Boot Image
  45     python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF image boot cirros cirros
  46
  47  View vApp
  48     python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF view vapp 90bd2b4e-f782-46cf-b5e2-c3817dcf6633 -u
  49
  50  List VMS
  51     python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vms
  52
  53  List VDC in OSM format
  54   python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vdc -o
  55
  56 Mustaafa Bayramov
  57 mbayramov@vmware.com
  58 """
  59 import os
  60 import argparse
  61 import traceback
  62 import uuid
  63
  64 from xml.etree import ElementTree as ET
  65
  66 import sys
  67 from pyvcloud import Http
  68
  69 import logging
  70 from osm_ro_plugin import vimconn
  71 import time
  72 import uuid
  73 import urllib3
  74 import requests
  75
  76 from osm_ro.vimconn_vmware import vimconnector
  77 # TODO py3 uncoment  from requests.packages.urllib3.exceptions import InsecureRequestWarning
  78 from prettytable import PrettyTable
  79
  80 # TODO py3 uncoment requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
  81
  82 __author__ = "Mustafa Bayramov"
  83 __date__ = "$16-Sep-2016 11:09:29$"
  84
  85
  86 # TODO move to main vim
  87 def delete_network_action(vca=None, network_uuid=None):
  88     """
  89     Method leverages vCloud director and query network based on network uuid
  90
  91     Args:
  92         vca - is active VCA connection.
  93         network_uuid - is a network uuid
  94
  95         Returns:
  96             The return XML respond
  97     """
  98
  99     if vca is None or network_uuid is None:
 100         return None
 101
 102     url_list = [vca.host, '/api/admin/network/', network_uuid]
 103     vm_list_rest_call = ''.join(url_list)
 104
 105     if not (not vca.vcloud_session or not vca.vcloud_session.organization):
 106         response = Http.get(url=vm_list_rest_call,
 107                             headers=vca.vcloud_session.get_vcloud_headers(),
 108                             verify=vca.verify,
 109                             logger=vca.logger)
 110         if response.status_code == requests.codes.ok:
 111             print(response.content)
 112             return response.content
 113
 114     return None
 115
 116
 117 def print_vapp(vapp_dict=None):
 118     """ Method takes vapp_dict and print in tabular format
 119
 120     Args:
 121         vapp_dict: container vapp object.
 122
 123         Returns:
 124             The return nothing
 125     """
 126
 127     # following key available to print
 128     # {'status': 'POWERED_OFF', 'storageProfileName': '*', 'hardwareVersion': '7', 'vmToolsVersion': '0',
 129     #  'memoryMB': '384',
 130     #  'href': 'https://172.16.254.206/api/vAppTemplate/vm-129e22e8-08dc-4cb6-8358-25f635e65d3b',
 131     #  'isBusy': 'false', 'isDeployed': 'false', 'isInMaintenanceMode': 'false', 'isVAppTemplate': 'true',
 132     #  'networkName': 'nat', 'isDeleted': 'false', 'catalogName': 'Cirros',
 133     #  'containerName': 'Cirros Template', #  'container':
 134     #  'https://172.16.254.206/api/vAppTemplate/vappTemplate-b966453d-c361-4505-9e38-ccef45815e5d',
 135     #  'name': 'Cirros', 'pvdcHighestSupportedHardwareVersion': '11', 'isPublished': 'false',
 136     #  'numberOfCpus': '1', 'vdc': 'https://172.16.254.206/api/vdc/a5056f85-418c-4bfd-8041-adb0f48be9d9',
 137     #  'guestOs': 'Other (32-bit)', 'isVdcEnabled': 'true'}
 138
 139     if vapp_dict is None:
 140         return
 141
 142     vm_table = PrettyTable(['vm   uuid',
 143                             'vapp name',
 144                             'vapp uuid',
 145                             'network name',
 146                             'storage name',
 147                             'vcpu', 'memory', 'hw ver','deployed','status'])
 148     for k in vapp_dict:
 149         entry = []
 150         entry.append(k)
 151         entry.append(vapp_dict[k]['containerName'])
 152         # vm-b1f5cd4c-2239-4c89-8fdc-a41ff18e0d61
 153         entry.append(vapp_dict[k]['container'].split('/')[-1:][0][5:])
 154         entry.append(vapp_dict[k]['networkName'])
 155         entry.append(vapp_dict[k]['storageProfileName'])
 156         entry.append(vapp_dict[k]['numberOfCpus'])
 157         entry.append(vapp_dict[k]['memoryMB'])
 158         entry.append(vapp_dict[k]['pvdcHighestSupportedHardwareVersion'])
 159         entry.append(vapp_dict[k]['isDeployed'])
 160         entry.append(vapp_dict[k]['status'])
 161
 162         vm_table.add_row(entry)
 163
 164     print(vm_table)
 165
 166
 167 def print_org(org_dict=None):
 168     """ Method takes vapp_dict and print in tabular format
 169
 170     Args:
 171         org_dict:  dictionary of organization where key is org uuid.
 172
 173         Returns:
 174             The return nothing
 175     """
 176
 177     if org_dict is None:
 178         return
 179
 180     org_table = PrettyTable(['org uuid', 'name'])
 181     for k in org_dict:
 182         entry = [k, org_dict[k]]
 183         org_table.add_row(entry)
 184
 185     print(org_table)
 186
 187
 188 def print_vm_list(vm_dict=None):
 189     """ Method takes vapp_dict and print in tabular format
 190
 191     Args:
 192         vm_dict:  dictionary of organization where key is org uuid.
 193
 194         Returns:
 195             The return nothing
 196     """
 197     if vm_dict is None:
 198         return
 199
 200     vm_table = PrettyTable(
 201         ['vm uuid', 'vm name', 'vapp uuid', 'vdc uuid', 'network name', 'is deployed', 'vcpu', 'memory', 'status'])
 202
 203     try:
 204         for k in vm_dict:
 205             entry = []
 206             entry.append(k)
 207             entry.append(vm_dict[k]['name'])
 208             entry.append(vm_dict[k]['container'].split('/')[-1:][0][5:])
 209             entry.append(vm_dict[k]['vdc'].split('/')[-1:][0])
 210             entry.append(vm_dict[k]['networkName'])
 211             entry.append(vm_dict[k]['isDeployed'])
 212             entry.append(vm_dict[k]['numberOfCpus'])
 213             entry.append(vm_dict[k]['memoryMB'])
 214             entry.append(vm_dict[k]['status'])
 215             vm_table.add_row(entry)
 216         print(vm_table)
 217     except KeyError:
 218         logger.error("wrong key {}".format(KeyError.message))
 219         pass
 220
 221
 222 def print_vdc_list(org_dict=None):
 223     """ Method takes vapp_dict and print in tabular format
 224
 225     Args:
 226         org_dict:  dictionary of organization where key is org uuid.
 227
 228         Returns:
 229             The return nothing
 230     """
 231     if org_dict is None:
 232         return
 233     try:
 234         vdcs_dict = {}
 235         if 'vdcs' in org_dict:
 236             vdcs_dict = org_dict['vdcs']
 237         vdc_table = PrettyTable(['vdc uuid', 'vdc name'])
 238         for k in vdcs_dict:
 239             entry = [k, vdcs_dict[k]]
 240             vdc_table.add_row(entry)
 241
 242         print(vdc_table)
 243     except KeyError:
 244         logger.error("wrong key {}".format(KeyError.message))
 245         logger.logger.debug(traceback.format_exc())
 246
 247
 248 def print_network_list(org_dict=None):
 249     """ Method print network list.
 250
 251     Args:
 252         org_dict:   dictionary of organization that contain key networks with a list of all
 253                     network for for specific VDC
 254
 255         Returns:
 256             The return nothing
 257     """
 258     if org_dict is None:
 259         return
 260     try:
 261         network_dict = {}
 262         if 'networks' in org_dict:
 263             network_dict = org_dict['networks']
 264         network_table = PrettyTable(['network uuid', 'network name'])
 265         for k in network_dict:
 266             entry = [k, network_dict[k]]
 267             network_table.add_row(entry)
 268
 269         print(network_table)
 270
 271     except KeyError:
 272         logger.error("wrong key {}".format(KeyError.message))
 273         logger.logger.debug(traceback.format_exc())
 274
 275
 276 def print_org_details(org_dict=None):
 277     """ Method takes vapp_dict and print in tabular format
 278
 279     Args:
 280         org_dict:  dictionary of organization where key is org uuid.
 281
 282         Returns:
 283             The return nothing
 284     """
 285     if org_dict is None:
 286         return
 287     try:
 288         catalogs_dict = {}
 289
 290         print_vdc_list(org_dict=org_dict)
 291         print_network_list(org_dict=org_dict)
 292
 293         if 'catalogs' in org_dict:
 294             catalogs_dict = org_dict['catalogs']
 295
 296         catalog_table = PrettyTable(['catalog uuid', 'catalog name'])
 297         for k in catalogs_dict:
 298             entry = [k, catalogs_dict[k]]
 299             catalog_table.add_row(entry)
 300
 301         print(catalog_table)
 302
 303     except KeyError:
 304         logger.error("wrong key {}".format(KeyError.message))
 305         logger.logger.debug(traceback.format_exc())
 306
 307
 308 def delete_actions(vim=None, action=None, namespace=None):
 309     if action == 'network' or namespace.action == 'network':
 310         logger.debug("Requesting delete for network {}".format(namespace.network_name))
 311         network_uuid = namespace.network_name
 312         # if request name based we need find UUID
 313         # TODO optimize it or move to external function
 314         if not namespace.uuid:
 315             org_dict = vim.get_org_list()
 316             for org in org_dict:
 317                 org_net = vim.get_org(org)['networks']
 318                 for network in org_net:
 319                     if org_net[network] == namespace.network_name:
 320                         network_uuid = network
 321
 322         vim.delete_network_action(network_uuid=network_uuid)
 323
 324
 325 def list_actions(vim=None, action=None, namespace=None):
 326     """ Method provide list object from VDC action
 327
 328        Args:
 329            vim - is vcloud director vim connector.
 330            action - is action for list ( vdc / org etc)
 331            namespace -  must contain VDC / Org information.
 332
 333            Returns:
 334                The return nothing
 335        """
 336
 337     org_id = None
 338     myorgs = vim.get_org_list()
 339     for org in myorgs:
 340         if myorgs[org] == namespace.vcdorg:
 341             org_id = org
 342         break
 343     else:
 344         print(" Invalid organization.")
 345         return
 346
 347     if action == 'vms' or namespace.action == 'vms':
 348         vm_dict = vim.get_vm_list(vdc_name=namespace.vcdvdc)
 349         print_vm_list(vm_dict=vm_dict)
 350     elif action == 'vapps' or namespace.action == 'vapps':
 351         vapp_dict = vim.get_vapp_list(vdc_name=namespace.vcdvdc)
 352         print_vapp(vapp_dict=vapp_dict)
 353     elif action == 'networks' or namespace.action == 'networks':
 354         if namespace.osm:
 355             osm_print(vim.get_network_list(filter_dict={}))
 356         else:
 357             print_network_list(vim.get_org(org_uuid=org_id))
 358     elif action == 'vdc' or namespace.action == 'vdc':
 359         if namespace.osm:
 360             osm_print(vim.get_tenant_list(filter_dict=None))
 361         else:
 362             print_vdc_list(vim.get_org(org_uuid=org_id))
 363     elif action == 'org' or namespace.action == 'org':
 364         print_org(org_dict=vim.get_org_list())
 365     else:
 366         return None
 367
 368
 369 def print_network_details(network_dict=None):
 370     try:
 371         network_table = PrettyTable(network_dict.keys())
 372         entry = list(network_dict.values())
 373         network_table.add_row(entry[0])
 374         print(network_table)
 375     except KeyError:
 376         logger.error("wrong key {}".format(KeyError.message))
 377         logger.logger.debug(traceback.format_exc())
 378
 379
 380 def osm_print(generic_dict=None):
 381
 382     try:
 383         for element in generic_dict:
 384             table = PrettyTable(element.keys())
 385             entry = list(element.values())
 386             table.add_row(entry[0])
 387         print(table)
 388     except KeyError:
 389         logger.error("wrong key {}".format(KeyError.message))
 390         logger.logger.debug(traceback.format_exc())
 391
 392
 393 def view_actions(vim=None, action=None, namespace=None):
 394     org_id = None
 395     orgs = vim.get_org_list()
 396     for org in orgs:
 397         if orgs[org] == namespace.vcdorg:
 398             org_id = org
 399         break
 400     else:
 401         print(" Invalid organization.")
 402         return
 403
 404     myorg = vim.get_org(org_uuid=org_id)
 405
 406     # view org
 407     if action == 'org' or namespace.action == 'org':
 408         org_id = None
 409         orgs = vim.get_org_list()
 410         if namespace.uuid:
 411             if namespace.org_name in orgs:
 412                 org_id = namespace.org_name
 413         else:
 414             # we need find UUID based on name provided
 415             for org in orgs:
 416                 if orgs[org] == namespace.org_name:
 417                     org_id = org
 418                     break
 419
 420         logger.debug("Requesting view for orgs {}".format(org_id))
 421         print_org_details(vim.get_org(org_uuid=org_id))
 422
 423     # view vapp action
 424     if action == 'vapp' or namespace.action == 'vapp':
 425         if namespace.vapp_name is not None and namespace.uuid:
 426             logger.debug("Requesting vapp {} for vdc {}".format(namespace.vapp_name, namespace.vcdvdc))
 427             vapp_dict = {}
 428             vapp_uuid = namespace.vapp_name
 429             # if request based on just name we need get UUID
 430             if not namespace.uuid:
 431                 vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name)
 432                 if vapp_uuid is None:
 433                     print("Can't find vapp by given name {}".format(namespace.vapp_name))
 434                     return
 435
 436             print(" namespace {}".format(namespace))
 437             if vapp_dict is not None and namespace.osm:
 438                 vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid)
 439                 print(vm_info_dict)
 440             if vapp_dict is not None and namespace.osm != True:
 441                 vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True)
 442                 print_vapp(vapp_dict=vapp_dict)
 443
 444     # view network
 445     if action == 'network' or namespace.action == 'network':
 446         logger.debug("Requesting view for network {}".format(namespace.network_name))
 447         network_uuid = namespace.network_name
 448         # if request name based we need find UUID
 449         # TODO optimize it or move to external function
 450         if not namespace.uuid:
 451             if 'networks' not in myorg:
 452                 print("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name,
 453                                                                                             vim.name,
 454                                                                                             vim.tenant_name))
 455                 return
 456
 457             my_org_net = myorg['networks']
 458             for network in my_org_net:
 459                 if my_org_net[network] == namespace.network_name:
 460                     network_uuid = network
 461                     break
 462
 463         print(print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid)))
 464
 465
 466 def create_actions(vim=None, action=None, namespace=None):
 467     """Method gets provider vdc view from vcloud director
 468
 469         Args:
 470             vim - is Cloud director vim connector
 471             action - action for create ( network / vdc etc)
 472
 473         Returns:
 474             The return xml content of respond or None
 475     """
 476     if action == 'network' or namespace.action == 'network':
 477         logger.debug("Creating a network in vcloud director".format(namespace.network_name))
 478         network_uuid = vim.create_network(namespace.network_name)
 479         if network_uuid is not None:
 480             print("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid))
 481         else:
 482             print("Failed create a new network {}".format(namespace.network_name))
 483     elif action == 'vdc' or namespace.action == 'vdc':
 484         logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name))
 485         vdc_uuid = vim.create_vdc(namespace.vdc_name)
 486         if vdc_uuid is not None:
 487             print("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid))
 488         else:
 489             print("Failed create a new vdc {}".format(namespace.vdc_name))
 490     else:
 491         return None
 492
 493
 494 def validate_uuid4(uuid_string):
 495     """Function validate that string contain valid uuid4
 496
 497         Args:
 498             uuid_string - valid UUID string
 499
 500         Returns:
 501             The return true if string contain valid UUID format
 502     """
 503     try:
 504         val = uuid.UUID(uuid_string, version=4)
 505     except ValueError:
 506         return False
 507     return True
 508
 509
 510 def upload_image(vim=None, image_file=None):
 511     """Function upload image to vcloud director
 512
 513         Args:
 514             image_file - valid UUID string
 515
 516         Returns:
 517             The return true if image uploaded correctly
 518     """
 519     try:
 520         catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True)
 521         if catalog_uuid is not None and validate_uuid4(catalog_uuid):
 522             print("Image uploaded and uuid {}".format(catalog_uuid))
 523             return True
 524     except vimconn.VimConnException as upload_exception:
 525         print("Failed uploaded {} image".format(image_file))
 526         print("Error Reason: {}".format(upload_exception.message))
 527     return False
 528
 529
 530 def boot_image(vim=None, image_name=None, vm_name=None):
 531     """ Function boot image that resided in vcloud director.
 532         The image name can be UUID of name.
 533
 534         Args:
 535             vim - vim connector
 536             image_name - image identified by UUID or text string.
 537             vm_name - vmname
 538
 539
 540          Returns:
 541              The return true if image uploaded correctly
 542      """
 543
 544     vim_catalog = None
 545     try:
 546         catalogs = vim.vca.get_catalogs()
 547         if not validate_uuid4(image_name):
 548             vim_catalog = vim.get_catalogid(catalog_name=image_name, catalogs=catalogs)
 549             if vim_catalog is None:
 550                 return None
 551         else:
 552             vim_catalog = vim.get_catalogid(catalog_name=image_name, catalogs=catalogs)
 553             if vim_catalog is None:
 554                 return None
 555
 556         print(" Booting {} image id {} ".format(vm_name, vim_catalog))
 557         vm_uuid, _ = vim.new_vminstance(name=vm_name, image_id=vim_catalog)
 558         if vm_uuid is not None and validate_uuid4(vm_uuid):
 559             print("Image booted and vm uuid {}".format(vm_uuid))
 560             vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True)
 561             if vapp_dict is not None:
 562                 print_vapp(vapp_dict=vapp_dict)
 563         return True
 564     except vimconn.VimConnNotFoundException as notFound:
 565         print("Failed boot {} image".format(image_name))
 566         print(notFound.message)
 567     except vimconn.VimConnException as vimconError:
 568         print("Failed boot {} image".format(image_name))
 569         print(vimconError.message)
 570     except:
 571         print("Failed boot {} image".format(image_name))
 572
 573
 574         return False
 575
 576
 577 def image_action(vim=None, action=None, namespace=None):
 578     """ Function present set of action to manipulate with image.
 579           - upload image
 580           - boot image.
 581           - delete image ( not yet done )
 582
 583         Args:
 584              vim - vcloud director connector
 585              action - string (upload/boot etc)
 586              namespace - contain other attributes image name etc
 587
 588          Returns:
 589              The return nothing
 590      """
 591
 592     if action == 'upload' or namespace.action == 'upload':
 593         upload_image(vim=vim, image_file=namespace.image)
 594     elif action == 'boot' or namespace.action == 'boot':
 595         boot_image(vim=vim, image_name=namespace.image, vm_name=namespace.vmname)
 596     else:
 597         return None
 598
 599
 600 def vmwarecli(command=None, action=None, namespace=None):
 601     logger.debug("Namespace {}".format(namespace))
 602     urllib3.disable_warnings()
 603
 604     vcduser = None
 605     vcdpasword = None
 606     vcdhost = None
 607     vcdorg = None
 608
 609     if namespace.vcdvdc is None:
 610         while True:
 611             vcduser = input("Enter vcd username: ")
 612             if vcduser is not None and len(vcduser) > 0:
 613                 break
 614     else:
 615         vcduser = namespace.vcduser
 616
 617     if namespace.vcdpassword is None:
 618         while True:
 619             vcdpasword = input("Please enter vcd password: ")
 620             if vcdpasword is not None and len(vcdpasword) > 0:
 621                 break
 622     else:
 623         vcdpasword = namespace.vcdpassword
 624
 625     if namespace.vcdhost is None:
 626         while True:
 627             vcdhost = input("Please enter vcd host name or ip: ")
 628             if vcdhost is not None and len(vcdhost) > 0:
 629                 break
 630     else:
 631         vcdhost = namespace.vcdhost
 632
 633     if namespace.vcdorg is None:
 634         while True:
 635             vcdorg = input("Please enter vcd organization name: ")
 636             if vcdorg is not None and len(vcdorg) > 0:
 637                 break
 638     else:
 639         vcdorg = namespace.vcdorg
 640
 641     try:
 642         vim = vimconnector(uuid=None,
 643                            name=vcdorg,
 644                            tenant_id=None,
 645                            tenant_name=namespace.vcdvdc,
 646                            url=vcdhost,
 647                            url_admin=vcdhost,
 648                            user=vcduser,
 649                            passwd=vcdpasword,
 650                            log_level="DEBUG",
 651                            config={'admin_username': namespace.vcdamdin, 'admin_password': namespace.vcdadminpassword})
 652         vim.vca = vim.connect()
 653
 654     except vimconn.VimConnConnectionException:
 655         print("Failed connect to vcloud director. Please check credential and hostname.")
 656         return
 657
 658     # list
 659     if command == 'list' or namespace.command == 'list':
 660         logger.debug("Client requested list action")
 661         # route request to list actions
 662         list_actions(vim=vim, action=action, namespace=namespace)
 663
 664     # view action
 665     if command == 'view' or namespace.command == 'view':
 666         logger.debug("Client requested view action")
 667         view_actions(vim=vim, action=action, namespace=namespace)
 668
 669     # delete action
 670     if command == 'delete' or namespace.command == 'delete':
 671         logger.debug("Client requested delete action")
 672         delete_actions(vim=vim, action=action, namespace=namespace)
 673
 674     # create action
 675     if command == 'create' or namespace.command == 'create':
 676         logger.debug("Client requested create action")
 677         create_actions(vim=vim, action=action, namespace=namespace)
 678
 679     # image action
 680     if command == 'image' or namespace.command == 'image':
 681         logger.debug("Client requested create action")
 682         image_action(vim=vim, action=action, namespace=namespace)
 683
 684
 685 if __name__ == '__main__':
 686     defaults = {'vcdvdc': 'default',
 687                 'vcduser': 'admin',
 688                 'vcdpassword': 'admin',
 689                 'vcdhost': 'https://localhost',
 690                 'vcdorg': 'default',
 691                 'debug': 'INFO'}
 692
 693     parser = argparse.ArgumentParser()
 694     parser.add_argument('-u', '--vcduser', help='vcloud director username', type=str)
 695     parser.add_argument('-p', '--vcdpassword', help='vcloud director password', type=str)
 696     parser.add_argument('-U', '--vcdamdin', help='vcloud director password', type=str)
 697     parser.add_argument('-P', '--vcdadminpassword', help='vcloud director password', type=str)
 698     parser.add_argument('-c', '--vcdhost', help='vcloud director host', type=str)
 699     parser.add_argument('-o', '--vcdorg', help='vcloud director org', type=str)
 700     parser.add_argument('-v', '--vcdvdc', help='vcloud director vdc', type=str)
 701     parser.add_argument('-d', '--debug', help='debug level', type=int)
 702
 703     parser_subparsers = parser.add_subparsers(help='commands', dest='command')
 704     sub = parser_subparsers.add_parser('list', help='List objects (VMs, vApps, networks)')
 705     sub_subparsers = sub.add_subparsers(dest='action')
 706
 707     list_vms = sub_subparsers.add_parser('vms', help='list - all vm deployed in vCloud director')
 708     list_vapps = sub_subparsers.add_parser('vapps', help='list - all vapps deployed in vCloud director')
 709     list_network = sub_subparsers.add_parser('networks', help='list - all networks deployed')
 710     list_network.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format')
 711
 712     #list vdc
 713     list_vdc = sub_subparsers.add_parser('vdc', help='list - list all vdc for organization accessible to you')
 714     list_vdc.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format')
 715
 716     list_org = sub_subparsers.add_parser('org', help='list - list of organizations accessible to you.')
 717
 718     create_sub = parser_subparsers.add_parser('create')
 719     create_sub_subparsers = create_sub.add_subparsers(dest='action')
 720     create_vms = create_sub_subparsers.add_parser('vms')
 721     create_vapp = create_sub_subparsers.add_parser('vapp')
 722     create_vapp.add_argument('uuid')
 723
 724     # add network
 725     create_network = create_sub_subparsers.add_parser('network')
 726     create_network.add_argument('network_name', action='store', help='create a network for a vdc')
 727
 728     # add VDC
 729     create_vdc = create_sub_subparsers.add_parser('vdc')
 730     create_vdc.add_argument('vdc_name', action='store', help='create a new VDC for org')
 731
 732     delete_sub = parser_subparsers.add_parser('delete')
 733     del_sub_subparsers = delete_sub.add_subparsers(dest='action')
 734     del_vms = del_sub_subparsers.add_parser('vms')
 735     del_vapp = del_sub_subparsers.add_parser('vapp')
 736     del_vapp.add_argument('uuid', help='view vapp based on UUID')
 737
 738     # delete network
 739     del_network = del_sub_subparsers.add_parser('network')
 740     del_network.add_argument('network_name', action='store',
 741                              help='- delete network for vcloud director by provided name')
 742     del_network.add_argument('-u', '--uuid', default=False, action='store_true',
 743                              help='delete network for vcloud director by provided uuid')
 744
 745     # delete vdc
 746     del_vdc = del_sub_subparsers.add_parser('vdc')
 747
 748     view_sub = parser_subparsers.add_parser('view')
 749     view_sub_subparsers = view_sub.add_subparsers(dest='action')
 750
 751     view_vms_parser = view_sub_subparsers.add_parser('vms')
 752     view_vms_parser.add_argument('uuid', default=False, action='store_true',
 753                                  help='- View VM for specific uuid in vcloud director')
 754     view_vms_parser.add_argument('name', default=False, action='store_true',
 755                                  help='- View VM for specific vapp name in vcloud director')
 756
 757     # view vapp
 758     view_vapp_parser = view_sub_subparsers.add_parser('vapp')
 759     view_vapp_parser.add_argument('vapp_name', action='store',
 760                                   help='- view vapp for specific vapp name in vcloud director')
 761     view_vapp_parser.add_argument('-u', '--uuid', default=False, action='store_true', help='view vapp based on uuid')
 762     view_vapp_parser.add_argument('-o', '--osm', default=False, action='store_true',  help='provide view in OSM format')
 763
 764     # view network
 765     view_network = view_sub_subparsers.add_parser('network')
 766     view_network.add_argument('network_name', action='store',
 767                               help='- view network for specific network name in vcloud director')
 768     view_network.add_argument('-u', '--uuid', default=False, action='store_true', help='view network based on uuid')
 769
 770     # view VDC command and actions
 771     view_vdc = view_sub_subparsers.add_parser('vdc')
 772     view_vdc.add_argument('vdc_name', action='store',
 773                           help='- View VDC based and action based on provided vdc uuid')
 774     view_vdc.add_argument('-u', '--uuid', default=False, action='store_true', help='view vdc based on uuid')
 775
 776     # view organization command and actions
 777     view_org = view_sub_subparsers.add_parser('org')
 778     view_org.add_argument('org_name', action='store',
 779                           help='- View VDC based and action based on provided vdc uuid')
 780     view_org.add_argument('-u', '--uuid', default=False, action='store_true', help='view org based on uuid')
 781
 782     # upload image action
 783     image_sub = parser_subparsers.add_parser('image')
 784     image_subparsers = image_sub.add_subparsers(dest='action')
 785     upload_parser = image_subparsers.add_parser('upload')
 786     upload_parser.add_argument('image', default=False, action='store', help='- valid path to OVF image ')
 787     upload_parser.add_argument('catalog', default=False, action='store_true', help='- catalog name')
 788
 789     # boot vm action
 790     boot_parser = image_subparsers.add_parser('boot')
 791     boot_parser.add_argument('image', default=False, action='store', help='- Image name')
 792     boot_parser.add_argument('vmname', default=False, action='store', help='- VM name')
 793     boot_parser.add_argument('-u', '--uuid', default=False, action='store_true', help='view org based on uuid')
 794
 795     namespace = parser.parse_args()
 796     # put command_line args to mapping
 797     command_line_args = {k: v for k, v in vars(namespace).items() if v}
 798
 799     d = defaults.copy()
 800     d.update(os.environ)
 801     d.update(command_line_args)
 802
 803     logger = logging.getLogger('mano.vim.vmware')
 804     formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
 805     ch = logging.StreamHandler()
 806     ch.setLevel(str.upper(d['debug']))
 807     ch.setFormatter(formatter)
 808     logger.addHandler(ch)
 809     logger.setLevel(getattr(logging, str.upper(d['debug'])))
 810     logger.info(
 811         "Connecting {} username: {} org: {} vdc: {} ".format(d['vcdhost'], d['vcduser'], d['vcdorg'], d['vcdvdc']))
 812
 813     logger.debug("command: \"{}\" actio: \"{}\"".format(d['command'], d['action']))
 814
 815     # main entry point.
 816     vmwarecli(namespace=namespace)