vmwarerecli.py

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