1 # -*- coding: utf-8 -*-
3 # This file is standalone vmware vcloud director util
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
10 # http://www.apache.org/licenses/LICENSE-2.0
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
18 # For those usages not covered by the Apache License, Version 2.0 please
19 # contact with: mbayramov@vmware.com
24 Standalone application that leverage openmano vmware connector work with vCloud director rest api.
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
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
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
41 python vmwarerecli.py image upload /Users/spyroot/Developer/Openmano/Ro/vnfs/cirros/cirros.ovf
44 python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF image boot cirros cirros
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
50 python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vms
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
63 from xml
.etree
import ElementTree
as ET
65 from pyvcloud
import Http
74 from vimconn_vmware
import vimconnector
75 from requests
.packages
.urllib3
.exceptions
import InsecureRequestWarning
76 from prettytable
import PrettyTable
78 requests
.packages
.urllib3
.disable_warnings(InsecureRequestWarning
)
80 __author__
= "Mustafa Bayramov"
81 __date__
= "$16-Sep-2016 11:09:29$"
84 # TODO move to main vim
85 def delete_network_action(vca
=None, network_uuid
=None):
87 Method leverages vCloud director and query network based on network uuid
90 vca - is active VCA connection.
91 network_uuid - is a network uuid
94 The return XML respond
97 if vca
is None or network_uuid
is None:
100 url_list
= [vca
.host
, '/api/admin/network/', network_uuid
]
101 vm_list_rest_call
= ''.join(url_list
)
103 if not (not vca
.vcloud_session
or not vca
.vcloud_session
.organization
):
104 response
= Http
.get(url
=vm_list_rest_call
,
105 headers
=vca
.vcloud_session
.get_vcloud_headers(),
108 if response
.status_code
== requests
.codes
.ok
:
109 print response
.content
110 return response
.content
115 def print_vapp(vapp_dict
=None):
116 """ Method takes vapp_dict and print in tabular format
119 vapp_dict: container vapp object.
125 # following key available to print
126 # {'status': 'POWERED_OFF', 'storageProfileName': '*', 'hardwareVersion': '7', 'vmToolsVersion': '0',
128 # 'href': 'https://172.16.254.206/api/vAppTemplate/vm-129e22e8-08dc-4cb6-8358-25f635e65d3b',
129 # 'isBusy': 'false', 'isDeployed': 'false', 'isInMaintenanceMode': 'false', 'isVAppTemplate': 'true',
130 # 'networkName': 'nat', 'isDeleted': 'false', 'catalogName': 'Cirros',
131 # 'containerName': 'Cirros Template', # 'container':
132 # 'https://172.16.254.206/api/vAppTemplate/vappTemplate-b966453d-c361-4505-9e38-ccef45815e5d',
133 # 'name': 'Cirros', 'pvdcHighestSupportedHardwareVersion': '11', 'isPublished': 'false',
134 # 'numberOfCpus': '1', 'vdc': 'https://172.16.254.206/api/vdc/a5056f85-418c-4bfd-8041-adb0f48be9d9',
135 # 'guestOs': 'Other (32-bit)', 'isVdcEnabled': 'true'}
137 if vapp_dict
is None:
140 vm_table
= PrettyTable(['vm uuid',
145 'vcpu', 'memory', 'hw ver','deployed','status'])
149 entry
.append(vapp_dict
[k
]['containerName'])
150 # vm-b1f5cd4c-2239-4c89-8fdc-a41ff18e0d61
151 entry
.append(vapp_dict
[k
]['container'].split('/')[-1:][0][5:])
152 entry
.append(vapp_dict
[k
]['networkName'])
153 entry
.append(vapp_dict
[k
]['storageProfileName'])
154 entry
.append(vapp_dict
[k
]['numberOfCpus'])
155 entry
.append(vapp_dict
[k
]['memoryMB'])
156 entry
.append(vapp_dict
[k
]['pvdcHighestSupportedHardwareVersion'])
157 entry
.append(vapp_dict
[k
]['isDeployed'])
158 entry
.append(vapp_dict
[k
]['status'])
160 vm_table
.add_row(entry
)
165 def print_org(org_dict
=None):
166 """ Method takes vapp_dict and print in tabular format
169 org_dict: dictionary of organization where key is org uuid.
178 org_table
= PrettyTable(['org uuid', 'name'])
180 entry
= [k
, org_dict
[k
]]
181 org_table
.add_row(entry
)
186 def print_vm_list(vm_dict
=None):
187 """ Method takes vapp_dict and print in tabular format
190 vm_dict: dictionary of organization where key is org uuid.
198 vm_table
= PrettyTable(
199 ['vm uuid', 'vm name', 'vapp uuid', 'vdc uuid', 'network name', 'is deployed', 'vcpu', 'memory', 'status'])
205 entry
.append(vm_dict
[k
]['name'])
206 entry
.append(vm_dict
[k
]['container'].split('/')[-1:][0][5:])
207 entry
.append(vm_dict
[k
]['vdc'].split('/')[-1:][0])
208 entry
.append(vm_dict
[k
]['networkName'])
209 entry
.append(vm_dict
[k
]['isDeployed'])
210 entry
.append(vm_dict
[k
]['numberOfCpus'])
211 entry
.append(vm_dict
[k
]['memoryMB'])
212 entry
.append(vm_dict
[k
]['status'])
213 vm_table
.add_row(entry
)
216 logger
.error("wrong key {}".format(KeyError.message
))
220 def print_vdc_list(org_dict
=None):
221 """ Method takes vapp_dict and print in tabular format
224 org_dict: dictionary of organization where key is org uuid.
233 if org_dict
.has_key('vdcs'):
234 vdcs_dict
= org_dict
['vdcs']
235 vdc_table
= PrettyTable(['vdc uuid', 'vdc name'])
237 entry
= [k
, vdcs_dict
[k
]]
238 vdc_table
.add_row(entry
)
242 logger
.error("wrong key {}".format(KeyError.message
))
243 logger
.logger
.debug(traceback
.format_exc())
246 def print_network_list(org_dict
=None):
247 """ Method print network list.
250 org_dict: dictionary of organization that contain key networks with a list of all
251 network for for specific VDC
260 if org_dict
.has_key('networks'):
261 network_dict
= org_dict
['networks']
262 network_table
= PrettyTable(['network uuid', 'network name'])
263 for k
in network_dict
:
264 entry
= [k
, network_dict
[k
]]
265 network_table
.add_row(entry
)
270 logger
.error("wrong key {}".format(KeyError.message
))
271 logger
.logger
.debug(traceback
.format_exc())
274 def print_org_details(org_dict
=None):
275 """ Method takes vapp_dict and print in tabular format
278 org_dict: dictionary of organization where key is org uuid.
288 print_vdc_list(org_dict
=org_dict
)
289 print_network_list(org_dict
=org_dict
)
291 if org_dict
.has_key('catalogs'):
292 catalogs_dict
= org_dict
['catalogs']
294 catalog_table
= PrettyTable(['catalog uuid', 'catalog name'])
295 for k
in catalogs_dict
:
296 entry
= [k
, catalogs_dict
[k
]]
297 catalog_table
.add_row(entry
)
302 logger
.error("wrong key {}".format(KeyError.message
))
303 logger
.logger
.debug(traceback
.format_exc())
306 def delete_actions(vim
=None, action
=None, namespace
=None):
307 if action
== 'network' or namespace
.action
== 'network':
308 logger
.debug("Requesting delete for network {}".format(namespace
.network_name
))
309 network_uuid
= namespace
.network_name
310 # if request name based we need find UUID
311 # TODO optimize it or move to external function
312 if not namespace
.uuid
:
313 org_dict
= vim
.get_org_list()
315 org_net
= vim
.get_org(org
)['networks']
316 for network
in org_net
:
317 if org_net
[network
] == namespace
.network_name
:
318 network_uuid
= network
320 vim
.delete_network_action(network_uuid
=network_uuid
)
323 def list_actions(vim
=None, action
=None, namespace
=None):
324 """ Method provide list object from VDC action
327 vim - is vcloud director vim connector.
328 action - is action for list ( vdc / org etc)
329 namespace - must contain VDC / Org information.
336 myorgs
= vim
.get_org_list()
338 if myorgs
[org
] == namespace
.vcdorg
:
342 print(" Invalid organization.")
345 if action
== 'vms' or namespace
.action
== 'vms':
346 vm_dict
= vim
.get_vm_list(vdc_name
=namespace
.vcdvdc
)
347 print_vm_list(vm_dict
=vm_dict
)
348 elif action
== 'vapps' or namespace
.action
== 'vapps':
349 vapp_dict
= vim
.get_vapp_list(vdc_name
=namespace
.vcdvdc
)
350 print_vapp(vapp_dict
=vapp_dict
)
351 elif action
== 'networks' or namespace
.action
== 'networks':
353 osm_print(vim
.get_network_list(filter_dict
={}))
355 print_network_list(vim
.get_org(org_uuid
=org_id
))
356 elif action
== 'vdc' or namespace
.action
== 'vdc':
358 osm_print(vim
.get_tenant_list(filter_dict
=None))
360 print_vdc_list(vim
.get_org(org_uuid
=org_id
))
361 elif action
== 'org' or namespace
.action
== 'org':
362 print_org(org_dict
=vim
.get_org_list())
367 def print_network_details(network_dict
=None):
369 network_table
= PrettyTable(network_dict
.keys())
370 entry
= [network_dict
.values()]
371 network_table
.add_row(entry
[0])
374 logger
.error("wrong key {}".format(KeyError.message
))
375 logger
.logger
.debug(traceback
.format_exc())
378 def osm_print(generic_dict
=None):
381 for element
in generic_dict
:
382 table
= PrettyTable(element
.keys())
383 entry
= [element
.values()]
384 table
.add_row(entry
[0])
387 logger
.error("wrong key {}".format(KeyError.message
))
388 logger
.logger
.debug(traceback
.format_exc())
391 def view_actions(vim
=None, action
=None, namespace
=None):
393 orgs
= vim
.get_org_list()
395 if orgs
[org
] == namespace
.vcdorg
:
399 print(" Invalid organization.")
402 myorg
= vim
.get_org(org_uuid
=org_id
)
405 if action
== 'org' or namespace
.action
== 'org':
407 orgs
= vim
.get_org_list()
409 if namespace
.org_name
in orgs
:
410 org_id
= namespace
.org_name
412 # we need find UUID based on name provided
414 if orgs
[org
] == namespace
.org_name
:
418 logger
.debug("Requesting view for orgs {}".format(org_id
))
419 print_org_details(vim
.get_org(org_uuid
=org_id
))
422 if action
== 'vapp' or namespace
.action
== 'vapp':
423 print namespace
.vapp_name
424 if namespace
.vapp_name
is not None and namespace
.uuid
:
425 logger
.debug("Requesting vapp {} for vdc {}".format(namespace
.vapp_name
, namespace
.vcdvdc
))
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
))
435 vapp_dict
= vim
.get_vapp(vdc_name
=namespace
.vcdvdc
, vapp_name
=vapp_uuid
, isuuid
=True)
436 if vapp_dict
is not None:
437 print_vapp(vapp_dict
=vapp_dict
)
440 if action
== 'network' or namespace
.action
== 'network':
441 logger
.debug("Requesting view for network {}".format(namespace
.network_name
))
442 network_uuid
= namespace
.network_name
443 # if request name based we need find UUID
444 # TODO optimize it or move to external function
445 if not namespace
.uuid
:
446 if not myorg
.has_key('networks'):
447 print("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace
.network_name
,
452 my_org_net
= myorg
['networks']
453 for network
in my_org_net
:
454 if my_org_net
[network
] == namespace
.network_name
:
455 network_uuid
= network
458 print print_network_details(network_dict
=vim
.get_vcd_network(network_uuid
=network_uuid
))
461 def create_actions(vim
=None, action
=None, namespace
=None):
462 """Method gets provider vdc view from vcloud director
465 vim - is Cloud director vim connector
466 action - action for create ( network / vdc etc)
469 The return xml content of respond or None
471 if action
== 'network' or namespace
.action
== 'network':
472 logger
.debug("Creating a network in vcloud director".format(namespace
.network_name
))
473 network_uuid
= vim
.create_network(namespace
.network_name
)
474 if network_uuid
is not None:
475 print ("Crated new network {} and uuid: {}".format(namespace
.network_name
, network_uuid
))
477 print ("Failed create a new network {}".format(namespace
.network_name
))
478 elif action
== 'vdc' or namespace
.action
== 'vdc':
479 logger
.debug("Creating a new vdc in vcloud director.".format(namespace
.vdc_name
))
480 vdc_uuid
= vim
.create_vdc(namespace
.vdc_name
)
481 if vdc_uuid
is not None:
482 print ("Crated new vdc {} and uuid: {}".format(namespace
.vdc_name
, vdc_uuid
))
484 print ("Failed create a new vdc {}".format(namespace
.vdc_name
))
489 def validate_uuid4(uuid_string
):
490 """Function validate that string contain valid uuid4
493 uuid_string - valid UUID string
496 The return true if string contain valid UUID format
499 val
= uuid
.UUID(uuid_string
, version
=4)
505 def upload_image(vim
=None, image_file
=None):
506 """Function upload image to vcloud director
509 image_file - valid UUID string
512 The return true if image uploaded correctly
515 catalog_uuid
= vim
.get_image_id_from_path(path
=image_file
)
516 if catalog_uuid
is not None and validate_uuid4(catalog_uuid
):
517 print("Image uploaded and uuid {}".format(catalog_uuid
))
520 print("Failed uploaded {} image".format(image_file
))
525 def boot_image(vim
=None, image_name
=None, vm_name
=None):
526 """ Function boot image that resided in vcloud director.
527 The image name can be UUID of name.
530 image_name - image identified by UUID or text string.
534 The return true if image uploaded correctly
539 catalogs
= vim
.vca
.get_catalogs()
540 if not validate_uuid4(image_name
):
541 vim_catalog
= vim
.get_catalogid(catalog_name
=image_name
, catalogs
=catalogs
)
542 if vim_catalog
is None:
545 vim_catalog
= vim
.get_catalogid(catalog_name
=image_name
, catalogs
=catalogs
)
546 if vim_catalog
is None:
549 vm_uuid
= vim
.new_vminstance(name
=vm_name
, image_id
=vim_catalog
)
550 if vm_uuid
is not None and validate_uuid4(vm_uuid
):
551 print("Image booted and vm uuid {}".format(vm_uuid
))
552 vapp_dict
= vim
.get_vapp(vdc_name
=namespace
.vcdvdc
, vapp_name
=vm_uuid
, isuuid
=True)
553 if vapp_dict
is not None:
554 print_vapp(vapp_dict
=vapp_dict
)
557 print("Failed uploaded {} image".format(image_name
))
560 def image_action(vim
=None, action
=None, namespace
=None):
561 """ Function present set of action to manipulate with image.
564 - delete image ( not yet done )
567 vim - vcloud director connector
568 action - string (upload/boot etc)
569 namespace - contain other attributes image name etc
575 if action
== 'upload' or namespace
.action
== 'upload':
576 upload_image(vim
=vim
, image_file
=namespace
.image
)
577 elif action
== 'boot' or namespace
.action
== 'boot':
578 boot_image(vim
=vim
, image_name
=namespace
.image
, vm_name
=namespace
.vmname
)
583 def vmwarecli(command
=None, action
=None, namespace
=None):
584 logger
.debug("Namespace {}".format(namespace
))
585 urllib3
.disable_warnings()
592 if hasattr(__builtins__
, 'raw_input'):
595 if namespace
.vcdvdc
is None:
597 vcduser
= input("Enter vcd username: ")
598 if vcduser
is not None and len(vcduser
) > 0:
601 vcduser
= namespace
.vcduser
603 if namespace
.vcdpassword
is None:
605 vcdpasword
= input("Please enter vcd password: ")
606 if vcdpasword
is not None and len(vcdpasword
) > 0:
609 vcdpasword
= namespace
.vcdpassword
611 if namespace
.vcdhost
is None:
613 vcdhost
= input("Please enter vcd host name or ip: ")
614 if vcdhost
is not None and len(vcdhost
) > 0:
617 vcdhost
= namespace
.vcdhost
619 if namespace
.vcdorg
is None:
621 vcdorg
= input("Please enter vcd organization name: ")
622 if vcdorg
is not None and len(vcdorg
) > 0:
625 vcdorg
= namespace
.vcdorg
628 vim
= vimconnector(uuid
=None,
631 tenant_name
=namespace
.vcdvdc
,
637 config
={'admin_username': namespace
.vcdamdin
, 'admin_password': namespace
.vcdadminpassword
})
638 vim
.vca
= vim
.connect()
639 except vimconn
.vimconnConnectionException
:
640 print("Failed connect to vcloud director. Please check credential and hostname.")
644 if command
== 'list' or namespace
.command
== 'list':
645 logger
.debug("Client requested list action")
646 # route request to list actions
647 list_actions(vim
=vim
, action
=action
, namespace
=namespace
)
650 if command
== 'view' or namespace
.command
== 'view':
651 logger
.debug("Client requested view action")
652 view_actions(vim
=vim
, action
=action
, namespace
=namespace
)
655 if command
== 'delete' or namespace
.command
== 'delete':
656 logger
.debug("Client requested delete action")
657 delete_actions(vim
=vim
, action
=action
, namespace
=namespace
)
660 if command
== 'create' or namespace
.command
== 'create':
661 logger
.debug("Client requested create action")
662 create_actions(vim
=vim
, action
=action
, namespace
=namespace
)
665 if command
== 'image' or namespace
.command
== 'image':
666 logger
.debug("Client requested create action")
667 image_action(vim
=vim
, action
=action
, namespace
=namespace
)
670 if __name__
== '__main__':
671 defaults
= {'vcdvdc': 'default',
673 'vcdpassword': 'admin',
674 'vcdhost': 'https://localhost',
678 parser
= argparse
.ArgumentParser()
679 parser
.add_argument('-u', '--vcduser', help='vcloud director username', type=str)
680 parser
.add_argument('-p', '--vcdpassword', help='vcloud director password', type=str)
681 parser
.add_argument('-U', '--vcdamdin', help='vcloud director password', type=str)
682 parser
.add_argument('-P', '--vcdadminpassword', help='vcloud director password', type=str)
683 parser
.add_argument('-c', '--vcdhost', help='vcloud director host', type=str)
684 parser
.add_argument('-o', '--vcdorg', help='vcloud director org', type=str)
685 parser
.add_argument('-v', '--vcdvdc', help='vcloud director vdc', type=str)
686 parser
.add_argument('-d', '--debug', help='debug level', type=int)
688 parser_subparsers
= parser
.add_subparsers(help='commands', dest
='command')
689 sub
= parser_subparsers
.add_parser('list', help='List objects (VMs, vApps, networks)')
690 sub_subparsers
= sub
.add_subparsers(dest
='action')
692 list_vms
= sub_subparsers
.add_parser('vms', help='list - all vm deployed in vCloud director')
693 list_vapps
= sub_subparsers
.add_parser('vapps', help='list - all vapps deployed in vCloud director')
694 list_network
= sub_subparsers
.add_parser('networks', help='list - all networks deployed')
695 list_network
.add_argument('-o', '--osm', default
=False, action
='store_true', help='provide view in OSM format')
698 list_vdc
= sub_subparsers
.add_parser('vdc', help='list - list all vdc for organization accessible to you')
699 list_vdc
.add_argument('-o', '--osm', default
=False, action
='store_true', help='provide view in OSM format')
701 list_org
= sub_subparsers
.add_parser('org', help='list - list of organizations accessible to you.')
703 create_sub
= parser_subparsers
.add_parser('create')
704 create_sub_subparsers
= create_sub
.add_subparsers(dest
='action')
705 create_vms
= create_sub_subparsers
.add_parser('vms')
706 create_vapp
= create_sub_subparsers
.add_parser('vapp')
707 create_vapp
.add_argument('uuid')
710 create_network
= create_sub_subparsers
.add_parser('network')
711 create_network
.add_argument('network_name', action
='store', help='create a network for a vdc')
714 create_vdc
= create_sub_subparsers
.add_parser('vdc')
715 create_vdc
.add_argument('vdc_name', action
='store', help='create a new VDC for org')
717 delete_sub
= parser_subparsers
.add_parser('delete')
718 del_sub_subparsers
= delete_sub
.add_subparsers(dest
='action')
719 del_vms
= del_sub_subparsers
.add_parser('vms')
720 del_vapp
= del_sub_subparsers
.add_parser('vapp')
721 del_vapp
.add_argument('uuid', help='view vapp based on UUID')
724 del_network
= del_sub_subparsers
.add_parser('network')
725 del_network
.add_argument('network_name', action
='store',
726 help='- delete network for vcloud director by provided name')
727 del_network
.add_argument('-u', '--uuid', default
=False, action
='store_true',
728 help='delete network for vcloud director by provided uuid')
731 del_vdc
= del_sub_subparsers
.add_parser('vdc')
733 view_sub
= parser_subparsers
.add_parser('view')
734 view_sub_subparsers
= view_sub
.add_subparsers(dest
='action')
736 view_vms_parser
= view_sub_subparsers
.add_parser('vms')
737 view_vms_parser
.add_argument('uuid', default
=False, action
='store_true',
738 help='- View VM for specific uuid in vcloud director')
739 view_vms_parser
.add_argument('name', default
=False, action
='store_true',
740 help='- View VM for specific vapp name in vcloud director')
743 view_vapp_parser
= view_sub_subparsers
.add_parser('vapp')
744 view_vapp_parser
.add_argument('vapp_name', action
='store',
745 help='- view vapp for specific vapp name in vcloud director')
746 view_vapp_parser
.add_argument('-u', '--uuid', default
=False, action
='store_true', help='view vapp based on uuid')
749 view_network
= view_sub_subparsers
.add_parser('network')
750 view_network
.add_argument('network_name', action
='store',
751 help='- view network for specific network name in vcloud director')
752 view_network
.add_argument('-u', '--uuid', default
=False, action
='store_true', help='view network based on uuid')
754 # view VDC command and actions
755 view_vdc
= view_sub_subparsers
.add_parser('vdc')
756 view_vdc
.add_argument('vdc_name', action
='store',
757 help='- View VDC based and action based on provided vdc uuid')
758 view_vdc
.add_argument('-u', '--uuid', default
=False, action
='store_true', help='view vdc based on uuid')
760 # view organization command and actions
761 view_org
= view_sub_subparsers
.add_parser('org')
762 view_org
.add_argument('org_name', action
='store',
763 help='- View VDC based and action based on provided vdc uuid')
764 view_org
.add_argument('-u', '--uuid', default
=False, action
='store_true', help='view org based on uuid')
766 # upload image action
767 image_sub
= parser_subparsers
.add_parser('image')
768 image_subparsers
= image_sub
.add_subparsers(dest
='action')
769 upload_parser
= image_subparsers
.add_parser('upload')
770 upload_parser
.add_argument('image', default
=False, action
='store', help='- valid path to OVF image ')
771 upload_parser
.add_argument('catalog', default
=False, action
='store_true', help='- catalog name')
774 boot_parser
= image_subparsers
.add_parser('boot')
775 boot_parser
.add_argument('image', default
=False, action
='store', help='- Image name')
776 boot_parser
.add_argument('vmname', default
=False, action
='store', help='- VM name')
777 boot_parser
.add_argument('-u', '--uuid', default
=False, action
='store_true', help='view org based on uuid')
779 namespace
= parser
.parse_args()
780 # put command_line args to mapping
781 command_line_args
= {k
: v
for k
, v
in vars(namespace
).items() if v
}
785 d
.update(command_line_args
)
787 logger
= logging
.getLogger('mano.vim.vmware')
788 formatter
= logging
.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
789 ch
= logging
.StreamHandler()
790 ch
.setLevel(str.upper(d
['debug']))
791 ch
.setFormatter(formatter
)
792 logger
.addHandler(ch
)
793 logger
.setLevel(getattr(logging
, str.upper(d
['debug'])))
795 "Connecting {} username: {} org: {} vdc: {} ".format(d
['vcdhost'], d
['vcduser'], d
['vcdorg'], d
['vcdvdc']))
797 logger
.debug("command: \"{}\" actio: \"{}\"".format(d
['command'], d
['action']))
800 vmwarecli(namespace
=namespace
)