From: tierno Date: Fri, 24 Aug 2018 09:34:54 +0000 (+0200) Subject: Introduce deprecating methods X-Git-Tag: v5.0.0~44 X-Git-Url: https://osm.etsi.org/gitweb/?p=osm%2FRO.git;a=commitdiff_plain;h=b8569aa8595fef5fadd0acc94d7949cf10b77a14 Introduce deprecating methods Change-Id: Ic35d8596631cc6c30ea9e54a1144c6d6c08e6e79 Signed-off-by: tierno --- diff --git a/deprecated/vmwarerecli.py b/deprecated/vmwarerecli.py new file mode 100755 index 00000000..b2f1752f --- /dev/null +++ b/deprecated/vmwarerecli.py @@ -0,0 +1,818 @@ +# -*- coding: utf-8 -*- +## +# This file is standalone vmware vcloud director util +# All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may +# not use this file except in compliance with the License. You may obtain +# a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +# License for the specific language governing permissions and limitations +# under the License. +# +# For those usages not covered by the Apache License, Version 2.0 please +# contact with: mbayramov@vmware.com +## + +""" + +Standalone application that leverage openmano vmware connector work with vCloud director rest api. + + - Provides capability to create and delete VDC for specific organization. + - Create, delete and manage network for specific VDC + - List deployed VM's , VAPPs, VDSs, Organization + - View detail information about VM / Vapp , Organization etc + - Operate with images upload / boot / power on etc + + Usage example. + + List organization created in vCloud director + vmwarecli.py -u admin -p qwerty123 -c 172.16.254.206 -U Administrator -P qwerty123 -o test -v TEF list org + + List VDC for particular organization + vmwarecli.py -u admin -p qwerty123 -c 172.16.254.206 -U Administrator -P qwerty123 -o test -v TEF list vdc + + Upload image + python vmwarerecli.py image upload /Users/spyroot/Developer/Openmano/Ro/vnfs/cirros/cirros.ovf + + Boot Image + python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF image boot cirros cirros + + View vApp + python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF view vapp 90bd2b4e-f782-46cf-b5e2-c3817dcf6633 -u + + List VMS + python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vms + + List VDC in OSM format + python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vdc -o + +Mustaafa Bayramov +mbayramov@vmware.com +""" +import os +import argparse +import traceback +import uuid + +from xml.etree import ElementTree as ET + +import sys +from pyvcloud import Http + +import logging +import vimconn +import time +import uuid +import urllib3 +import requests + +from vimconn_vmware import vimconnector +from requests.packages.urllib3.exceptions import InsecureRequestWarning +from prettytable import PrettyTable + +requests.packages.urllib3.disable_warnings(InsecureRequestWarning) + +__author__ = "Mustafa Bayramov" +__date__ = "$16-Sep-2016 11:09:29$" + + +# TODO move to main vim +def delete_network_action(vca=None, network_uuid=None): + """ + Method leverages vCloud director and query network based on network uuid + + Args: + vca - is active VCA connection. + network_uuid - is a network uuid + + Returns: + The return XML respond + """ + + if vca is None or network_uuid is None: + return None + + url_list = [vca.host, '/api/admin/network/', network_uuid] + vm_list_rest_call = ''.join(url_list) + + if not (not vca.vcloud_session or not vca.vcloud_session.organization): + response = Http.get(url=vm_list_rest_call, + headers=vca.vcloud_session.get_vcloud_headers(), + verify=vca.verify, + logger=vca.logger) + if response.status_code == requests.codes.ok: + print response.content + return response.content + + return None + + +def print_vapp(vapp_dict=None): + """ Method takes vapp_dict and print in tabular format + + Args: + vapp_dict: container vapp object. + + Returns: + The return nothing + """ + + # following key available to print + # {'status': 'POWERED_OFF', 'storageProfileName': '*', 'hardwareVersion': '7', 'vmToolsVersion': '0', + # 'memoryMB': '384', + # 'href': 'https://172.16.254.206/api/vAppTemplate/vm-129e22e8-08dc-4cb6-8358-25f635e65d3b', + # 'isBusy': 'false', 'isDeployed': 'false', 'isInMaintenanceMode': 'false', 'isVAppTemplate': 'true', + # 'networkName': 'nat', 'isDeleted': 'false', 'catalogName': 'Cirros', + # 'containerName': 'Cirros Template', # 'container': + # 'https://172.16.254.206/api/vAppTemplate/vappTemplate-b966453d-c361-4505-9e38-ccef45815e5d', + # 'name': 'Cirros', 'pvdcHighestSupportedHardwareVersion': '11', 'isPublished': 'false', + # 'numberOfCpus': '1', 'vdc': 'https://172.16.254.206/api/vdc/a5056f85-418c-4bfd-8041-adb0f48be9d9', + # 'guestOs': 'Other (32-bit)', 'isVdcEnabled': 'true'} + + if vapp_dict is None: + return + + vm_table = PrettyTable(['vm uuid', + 'vapp name', + 'vapp uuid', + 'network name', + 'storage name', + 'vcpu', 'memory', 'hw ver','deployed','status']) + for k in vapp_dict: + entry = [] + entry.append(k) + entry.append(vapp_dict[k]['containerName']) + # vm-b1f5cd4c-2239-4c89-8fdc-a41ff18e0d61 + entry.append(vapp_dict[k]['container'].split('/')[-1:][0][5:]) + entry.append(vapp_dict[k]['networkName']) + entry.append(vapp_dict[k]['storageProfileName']) + entry.append(vapp_dict[k]['numberOfCpus']) + entry.append(vapp_dict[k]['memoryMB']) + entry.append(vapp_dict[k]['pvdcHighestSupportedHardwareVersion']) + entry.append(vapp_dict[k]['isDeployed']) + entry.append(vapp_dict[k]['status']) + + vm_table.add_row(entry) + + print vm_table + + +def print_org(org_dict=None): + """ Method takes vapp_dict and print in tabular format + + Args: + org_dict: dictionary of organization where key is org uuid. + + Returns: + The return nothing + """ + + if org_dict is None: + return + + org_table = PrettyTable(['org uuid', 'name']) + for k in org_dict: + entry = [k, org_dict[k]] + org_table.add_row(entry) + + print org_table + + +def print_vm_list(vm_dict=None): + """ Method takes vapp_dict and print in tabular format + + Args: + vm_dict: dictionary of organization where key is org uuid. + + Returns: + The return nothing + """ + if vm_dict is None: + return + + vm_table = PrettyTable( + ['vm uuid', 'vm name', 'vapp uuid', 'vdc uuid', 'network name', 'is deployed', 'vcpu', 'memory', 'status']) + + try: + for k in vm_dict: + entry = [] + entry.append(k) + entry.append(vm_dict[k]['name']) + entry.append(vm_dict[k]['container'].split('/')[-1:][0][5:]) + entry.append(vm_dict[k]['vdc'].split('/')[-1:][0]) + entry.append(vm_dict[k]['networkName']) + entry.append(vm_dict[k]['isDeployed']) + entry.append(vm_dict[k]['numberOfCpus']) + entry.append(vm_dict[k]['memoryMB']) + entry.append(vm_dict[k]['status']) + vm_table.add_row(entry) + print vm_table + except KeyError: + logger.error("wrong key {}".format(KeyError.message)) + pass + + +def print_vdc_list(org_dict=None): + """ Method takes vapp_dict and print in tabular format + + Args: + org_dict: dictionary of organization where key is org uuid. + + Returns: + The return nothing + """ + if org_dict is None: + return + try: + vdcs_dict = {} + if org_dict.has_key('vdcs'): + vdcs_dict = org_dict['vdcs'] + vdc_table = PrettyTable(['vdc uuid', 'vdc name']) + for k in vdcs_dict: + entry = [k, vdcs_dict[k]] + vdc_table.add_row(entry) + + print vdc_table + except KeyError: + logger.error("wrong key {}".format(KeyError.message)) + logger.logger.debug(traceback.format_exc()) + + +def print_network_list(org_dict=None): + """ Method print network list. + + Args: + org_dict: dictionary of organization that contain key networks with a list of all + network for for specific VDC + + Returns: + The return nothing + """ + if org_dict is None: + return + try: + network_dict = {} + if org_dict.has_key('networks'): + network_dict = org_dict['networks'] + network_table = PrettyTable(['network uuid', 'network name']) + for k in network_dict: + entry = [k, network_dict[k]] + network_table.add_row(entry) + + print network_table + + except KeyError: + logger.error("wrong key {}".format(KeyError.message)) + logger.logger.debug(traceback.format_exc()) + + +def print_org_details(org_dict=None): + """ Method takes vapp_dict and print in tabular format + + Args: + org_dict: dictionary of organization where key is org uuid. + + Returns: + The return nothing + """ + if org_dict is None: + return + try: + catalogs_dict = {} + + print_vdc_list(org_dict=org_dict) + print_network_list(org_dict=org_dict) + + if org_dict.has_key('catalogs'): + catalogs_dict = org_dict['catalogs'] + + catalog_table = PrettyTable(['catalog uuid', 'catalog name']) + for k in catalogs_dict: + entry = [k, catalogs_dict[k]] + catalog_table.add_row(entry) + + print catalog_table + + except KeyError: + logger.error("wrong key {}".format(KeyError.message)) + logger.logger.debug(traceback.format_exc()) + + +def delete_actions(vim=None, action=None, namespace=None): + if action == 'network' or namespace.action == 'network': + logger.debug("Requesting delete for network {}".format(namespace.network_name)) + network_uuid = namespace.network_name + # if request name based we need find UUID + # TODO optimize it or move to external function + if not namespace.uuid: + org_dict = vim.get_org_list() + for org in org_dict: + org_net = vim.get_org(org)['networks'] + for network in org_net: + if org_net[network] == namespace.network_name: + network_uuid = network + + vim.delete_network_action(network_uuid=network_uuid) + + +def list_actions(vim=None, action=None, namespace=None): + """ Method provide list object from VDC action + + Args: + vim - is vcloud director vim connector. + action - is action for list ( vdc / org etc) + namespace - must contain VDC / Org information. + + Returns: + The return nothing + """ + + org_id = None + myorgs = vim.get_org_list() + for org in myorgs: + if myorgs[org] == namespace.vcdorg: + org_id = org + break + else: + print(" Invalid organization.") + return + + if action == 'vms' or namespace.action == 'vms': + vm_dict = vim.get_vm_list(vdc_name=namespace.vcdvdc) + print_vm_list(vm_dict=vm_dict) + elif action == 'vapps' or namespace.action == 'vapps': + vapp_dict = vim.get_vapp_list(vdc_name=namespace.vcdvdc) + print_vapp(vapp_dict=vapp_dict) + elif action == 'networks' or namespace.action == 'networks': + if namespace.osm: + osm_print(vim.get_network_list(filter_dict={})) + else: + print_network_list(vim.get_org(org_uuid=org_id)) + elif action == 'vdc' or namespace.action == 'vdc': + if namespace.osm: + osm_print(vim.get_tenant_list(filter_dict=None)) + else: + print_vdc_list(vim.get_org(org_uuid=org_id)) + elif action == 'org' or namespace.action == 'org': + print_org(org_dict=vim.get_org_list()) + else: + return None + + +def print_network_details(network_dict=None): + try: + network_table = PrettyTable(network_dict.keys()) + entry = [network_dict.values()] + network_table.add_row(entry[0]) + print network_table + except KeyError: + logger.error("wrong key {}".format(KeyError.message)) + logger.logger.debug(traceback.format_exc()) + + +def osm_print(generic_dict=None): + + try: + for element in generic_dict: + table = PrettyTable(element.keys()) + entry = [element.values()] + table.add_row(entry[0]) + print table + except KeyError: + logger.error("wrong key {}".format(KeyError.message)) + logger.logger.debug(traceback.format_exc()) + + +def view_actions(vim=None, action=None, namespace=None): + org_id = None + orgs = vim.get_org_list() + for org in orgs: + if orgs[org] == namespace.vcdorg: + org_id = org + break + else: + print(" Invalid organization.") + return + + myorg = vim.get_org(org_uuid=org_id) + + # view org + if action == 'org' or namespace.action == 'org': + org_id = None + orgs = vim.get_org_list() + if namespace.uuid: + if namespace.org_name in orgs: + org_id = namespace.org_name + else: + # we need find UUID based on name provided + for org in orgs: + if orgs[org] == namespace.org_name: + org_id = org + break + + logger.debug("Requesting view for orgs {}".format(org_id)) + print_org_details(vim.get_org(org_uuid=org_id)) + + # view vapp action + if action == 'vapp' or namespace.action == 'vapp': + if namespace.vapp_name is not None and namespace.uuid: + logger.debug("Requesting vapp {} for vdc {}".format(namespace.vapp_name, namespace.vcdvdc)) + vapp_dict = {} + vapp_uuid = namespace.vapp_name + # if request based on just name we need get UUID + if not namespace.uuid: + vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name) + if vapp_uuid is None: + print("Can't find vapp by given name {}".format(namespace.vapp_name)) + return + + print " namespace {}".format(namespace) + if vapp_dict is not None and namespace.osm: + vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid) + print vm_info_dict + if vapp_dict is not None and namespace.osm != True: + vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True) + print_vapp(vapp_dict=vapp_dict) + + # view network + if action == 'network' or namespace.action == 'network': + logger.debug("Requesting view for network {}".format(namespace.network_name)) + network_uuid = namespace.network_name + # if request name based we need find UUID + # TODO optimize it or move to external function + if not namespace.uuid: + if not myorg.has_key('networks'): + print("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name, + vim.name, + vim.tenant_name)) + return + + my_org_net = myorg['networks'] + for network in my_org_net: + if my_org_net[network] == namespace.network_name: + network_uuid = network + break + + print print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid)) + + +def create_actions(vim=None, action=None, namespace=None): + """Method gets provider vdc view from vcloud director + + Args: + vim - is Cloud director vim connector + action - action for create ( network / vdc etc) + + Returns: + The return xml content of respond or None + """ + if action == 'network' or namespace.action == 'network': + logger.debug("Creating a network in vcloud director".format(namespace.network_name)) + network_uuid = vim.create_network(namespace.network_name) + if network_uuid is not None: + print ("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid)) + else: + print ("Failed create a new network {}".format(namespace.network_name)) + elif action == 'vdc' or namespace.action == 'vdc': + logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name)) + vdc_uuid = vim.create_vdc(namespace.vdc_name) + if vdc_uuid is not None: + print ("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid)) + else: + print ("Failed create a new vdc {}".format(namespace.vdc_name)) + else: + return None + + +def validate_uuid4(uuid_string): + """Function validate that string contain valid uuid4 + + Args: + uuid_string - valid UUID string + + Returns: + The return true if string contain valid UUID format + """ + try: + val = uuid.UUID(uuid_string, version=4) + except ValueError: + return False + return True + + +def upload_image(vim=None, image_file=None): + """Function upload image to vcloud director + + Args: + image_file - valid UUID string + + Returns: + The return true if image uploaded correctly + """ + try: + catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True) + if catalog_uuid is not None and validate_uuid4(catalog_uuid): + print("Image uploaded and uuid {}".format(catalog_uuid)) + return True + except vimconn.vimconnException as upload_exception: + print("Failed uploaded {} image".format(image_file)) + print("Error Reason: {}".format(upload_exception.message)) + return False + + +def boot_image(vim=None, image_name=None, vm_name=None): + """ Function boot image that resided in vcloud director. + The image name can be UUID of name. + + Args: + vim - vim connector + image_name - image identified by UUID or text string. + vm_name - vmname + + + Returns: + The return true if image uploaded correctly + """ + + vim_catalog = None + try: + catalogs = vim.vca.get_catalogs() + if not validate_uuid4(image_name): + vim_catalog = vim.get_catalogid(catalog_name=image_name, catalogs=catalogs) + if vim_catalog is None: + return None + else: + vim_catalog = vim.get_catalogid(catalog_name=image_name, catalogs=catalogs) + if vim_catalog is None: + return None + + print (" Booting {} image id {} ".format(vm_name, vim_catalog)) + vm_uuid, _ = vim.new_vminstance(name=vm_name, image_id=vim_catalog) + if vm_uuid is not None and validate_uuid4(vm_uuid): + print("Image booted and vm uuid {}".format(vm_uuid)) + vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True) + if vapp_dict is not None: + print_vapp(vapp_dict=vapp_dict) + return True + except vimconn.vimconnNotFoundException as notFound: + print("Failed boot {} image".format(image_name)) + print(notFound.message) + except vimconn.vimconnException as vimconError: + print("Failed boot {} image".format(image_name)) + print(vimconError.message) + except: + print("Failed boot {} image".format(image_name)) + + + return False + + +def image_action(vim=None, action=None, namespace=None): + """ Function present set of action to manipulate with image. + - upload image + - boot image. + - delete image ( not yet done ) + + Args: + vim - vcloud director connector + action - string (upload/boot etc) + namespace - contain other attributes image name etc + + Returns: + The return nothing + """ + + if action == 'upload' or namespace.action == 'upload': + upload_image(vim=vim, image_file=namespace.image) + elif action == 'boot' or namespace.action == 'boot': + boot_image(vim=vim, image_name=namespace.image, vm_name=namespace.vmname) + else: + return None + + +def vmwarecli(command=None, action=None, namespace=None): + logger.debug("Namespace {}".format(namespace)) + urllib3.disable_warnings() + + vcduser = None + vcdpasword = None + vcdhost = None + vcdorg = None + + if hasattr(__builtins__, 'raw_input'): + input = raw_input + + if namespace.vcdvdc is None: + while True: + vcduser = input("Enter vcd username: ") + if vcduser is not None and len(vcduser) > 0: + break + else: + vcduser = namespace.vcduser + + if namespace.vcdpassword is None: + while True: + vcdpasword = input("Please enter vcd password: ") + if vcdpasword is not None and len(vcdpasword) > 0: + break + else: + vcdpasword = namespace.vcdpassword + + if namespace.vcdhost is None: + while True: + vcdhost = input("Please enter vcd host name or ip: ") + if vcdhost is not None and len(vcdhost) > 0: + break + else: + vcdhost = namespace.vcdhost + + if namespace.vcdorg is None: + while True: + vcdorg = input("Please enter vcd organization name: ") + if vcdorg is not None and len(vcdorg) > 0: + break + else: + vcdorg = namespace.vcdorg + + try: + vim = vimconnector(uuid=None, + name=vcdorg, + tenant_id=None, + tenant_name=namespace.vcdvdc, + url=vcdhost, + url_admin=vcdhost, + user=vcduser, + passwd=vcdpasword, + log_level="DEBUG", + config={'admin_username': namespace.vcdamdin, 'admin_password': namespace.vcdadminpassword}) + vim.vca = vim.connect() + + except vimconn.vimconnConnectionException: + print("Failed connect to vcloud director. Please check credential and hostname.") + return + + # list + if command == 'list' or namespace.command == 'list': + logger.debug("Client requested list action") + # route request to list actions + list_actions(vim=vim, action=action, namespace=namespace) + + # view action + if command == 'view' or namespace.command == 'view': + logger.debug("Client requested view action") + view_actions(vim=vim, action=action, namespace=namespace) + + # delete action + if command == 'delete' or namespace.command == 'delete': + logger.debug("Client requested delete action") + delete_actions(vim=vim, action=action, namespace=namespace) + + # create action + if command == 'create' or namespace.command == 'create': + logger.debug("Client requested create action") + create_actions(vim=vim, action=action, namespace=namespace) + + # image action + if command == 'image' or namespace.command == 'image': + logger.debug("Client requested create action") + image_action(vim=vim, action=action, namespace=namespace) + + +if __name__ == '__main__': + defaults = {'vcdvdc': 'default', + 'vcduser': 'admin', + 'vcdpassword': 'admin', + 'vcdhost': 'https://localhost', + 'vcdorg': 'default', + 'debug': 'INFO'} + + parser = argparse.ArgumentParser() + parser.add_argument('-u', '--vcduser', help='vcloud director username', type=str) + parser.add_argument('-p', '--vcdpassword', help='vcloud director password', type=str) + parser.add_argument('-U', '--vcdamdin', help='vcloud director password', type=str) + parser.add_argument('-P', '--vcdadminpassword', help='vcloud director password', type=str) + parser.add_argument('-c', '--vcdhost', help='vcloud director host', type=str) + parser.add_argument('-o', '--vcdorg', help='vcloud director org', type=str) + parser.add_argument('-v', '--vcdvdc', help='vcloud director vdc', type=str) + parser.add_argument('-d', '--debug', help='debug level', type=int) + + parser_subparsers = parser.add_subparsers(help='commands', dest='command') + sub = parser_subparsers.add_parser('list', help='List objects (VMs, vApps, networks)') + sub_subparsers = sub.add_subparsers(dest='action') + + list_vms = sub_subparsers.add_parser('vms', help='list - all vm deployed in vCloud director') + list_vapps = sub_subparsers.add_parser('vapps', help='list - all vapps deployed in vCloud director') + list_network = sub_subparsers.add_parser('networks', help='list - all networks deployed') + list_network.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format') + + #list vdc + list_vdc = sub_subparsers.add_parser('vdc', help='list - list all vdc for organization accessible to you') + list_vdc.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format') + + list_org = sub_subparsers.add_parser('org', help='list - list of organizations accessible to you.') + + create_sub = parser_subparsers.add_parser('create') + create_sub_subparsers = create_sub.add_subparsers(dest='action') + create_vms = create_sub_subparsers.add_parser('vms') + create_vapp = create_sub_subparsers.add_parser('vapp') + create_vapp.add_argument('uuid') + + # add network + create_network = create_sub_subparsers.add_parser('network') + create_network.add_argument('network_name', action='store', help='create a network for a vdc') + + # add VDC + create_vdc = create_sub_subparsers.add_parser('vdc') + create_vdc.add_argument('vdc_name', action='store', help='create a new VDC for org') + + delete_sub = parser_subparsers.add_parser('delete') + del_sub_subparsers = delete_sub.add_subparsers(dest='action') + del_vms = del_sub_subparsers.add_parser('vms') + del_vapp = del_sub_subparsers.add_parser('vapp') + del_vapp.add_argument('uuid', help='view vapp based on UUID') + + # delete network + del_network = del_sub_subparsers.add_parser('network') + del_network.add_argument('network_name', action='store', + help='- delete network for vcloud director by provided name') + del_network.add_argument('-u', '--uuid', default=False, action='store_true', + help='delete network for vcloud director by provided uuid') + + # delete vdc + del_vdc = del_sub_subparsers.add_parser('vdc') + + view_sub = parser_subparsers.add_parser('view') + view_sub_subparsers = view_sub.add_subparsers(dest='action') + + view_vms_parser = view_sub_subparsers.add_parser('vms') + view_vms_parser.add_argument('uuid', default=False, action='store_true', + help='- View VM for specific uuid in vcloud director') + view_vms_parser.add_argument('name', default=False, action='store_true', + help='- View VM for specific vapp name in vcloud director') + + # view vapp + view_vapp_parser = view_sub_subparsers.add_parser('vapp') + view_vapp_parser.add_argument('vapp_name', action='store', + help='- view vapp for specific vapp name in vcloud director') + view_vapp_parser.add_argument('-u', '--uuid', default=False, action='store_true', help='view vapp based on uuid') + view_vapp_parser.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format') + + # view network + view_network = view_sub_subparsers.add_parser('network') + view_network.add_argument('network_name', action='store', + help='- view network for specific network name in vcloud director') + view_network.add_argument('-u', '--uuid', default=False, action='store_true', help='view network based on uuid') + + # view VDC command and actions + view_vdc = view_sub_subparsers.add_parser('vdc') + view_vdc.add_argument('vdc_name', action='store', + help='- View VDC based and action based on provided vdc uuid') + view_vdc.add_argument('-u', '--uuid', default=False, action='store_true', help='view vdc based on uuid') + + # view organization command and actions + view_org = view_sub_subparsers.add_parser('org') + view_org.add_argument('org_name', action='store', + help='- View VDC based and action based on provided vdc uuid') + view_org.add_argument('-u', '--uuid', default=False, action='store_true', help='view org based on uuid') + + # upload image action + image_sub = parser_subparsers.add_parser('image') + image_subparsers = image_sub.add_subparsers(dest='action') + upload_parser = image_subparsers.add_parser('upload') + upload_parser.add_argument('image', default=False, action='store', help='- valid path to OVF image ') + upload_parser.add_argument('catalog', default=False, action='store_true', help='- catalog name') + + # boot vm action + boot_parser = image_subparsers.add_parser('boot') + boot_parser.add_argument('image', default=False, action='store', help='- Image name') + boot_parser.add_argument('vmname', default=False, action='store', help='- VM name') + boot_parser.add_argument('-u', '--uuid', default=False, action='store_true', help='view org based on uuid') + + namespace = parser.parse_args() + # put command_line args to mapping + command_line_args = {k: v for k, v in vars(namespace).items() if v} + + d = defaults.copy() + d.update(os.environ) + d.update(command_line_args) + + logger = logging.getLogger('mano.vim.vmware') + formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') + ch = logging.StreamHandler() + ch.setLevel(str.upper(d['debug'])) + ch.setFormatter(formatter) + logger.addHandler(ch) + logger.setLevel(getattr(logging, str.upper(d['debug']))) + logger.info( + "Connecting {} username: {} org: {} vdc: {} ".format(d['vcdhost'], d['vcduser'], d['vcdorg'], d['vcdvdc'])) + + logger.debug("command: \"{}\" actio: \"{}\"".format(d['command'], d['action'])) + + # main entry point. + vmwarecli(namespace=namespace) diff --git a/docker/Dockerfile-local b/docker/Dockerfile-local index b1ad1021..3847032f 100644 --- a/docker/Dockerfile-local +++ b/docker/Dockerfile-local @@ -67,7 +67,8 @@ ENV RO_DB_HOST="" \ RO_DB_PORT=3306 \ RO_DB_OVIM_PORT=3306 \ RO_DB_NAME=mano_db \ - RO_DB_OVIM_NAME=mano_vim_db + RO_DB_OVIM_NAME=mano_vim_db \ + OPENMANO_TENANT=osm CMD /bin/RO/start.sh diff --git a/osm_ro/nfvo.py b/osm_ro/nfvo.py index 02413234..98463ea2 100644 --- a/osm_ro/nfvo.py +++ b/osm_ro/nfvo.py @@ -31,6 +31,7 @@ __date__ ="$16-sep-2014 22:05:01$" # import json import yaml import utils +from utils import deprecated import vim_thread from db_base import HTTP_Unauthorized, HTTP_Bad_Request, HTTP_Internal_Server_Error, HTTP_Not_Found,\ HTTP_Conflict, HTTP_Method_Not_Allowed @@ -1305,6 +1306,7 @@ def new_vnfd_v3(mydb, tenant_id, vnf_descriptor): raise # NfvoException("Exception {}".format(e), HTTP_Bad_Request) +@deprecated("Use new_vnfd_v3") def new_vnf(mydb, tenant_id, vnf_descriptor): global global_config @@ -1442,6 +1444,7 @@ def new_vnf(mydb, tenant_id, vnf_descriptor): raise NfvoException(error_text, e.http_code) +@deprecated("Use new_vnfd_v3") def new_vnf_v02(mydb, tenant_id, vnf_descriptor): global global_config @@ -1742,6 +1745,7 @@ def delete_vnf(mydb,tenant_id,vnf_id,datacenter=None,vim_tenant=None): # return "delete_vnf. Undeleted: %s" %(undeletedItems) +@deprecated("Not used") def get_hosts_info(mydb, nfvo_tenant_id, datacenter_name=None): result, vims = get_vim(mydb, nfvo_tenant_id, None, datacenter_name) if result < 0: @@ -1792,6 +1796,7 @@ def get_hosts(mydb, nfvo_tenant_id): raise NfvoException("Not possible to get_host_list from VIM: {}".format(str(e)), e.http_code) +@deprecated("Use new_nsd_v3") def new_scenario(mydb, tenant_id, topo): # result, vims = get_vim(mydb, tenant_id) @@ -2073,6 +2078,7 @@ def new_scenario(mydb, tenant_id, topo): return c +@deprecated("Use new_nsd_v3") def new_scenario_v02(mydb, tenant_id, scenario_dict, version): """ This creates a new scenario for version 0.2 and 0.3""" scenario = scenario_dict["scenario"] @@ -2518,6 +2524,7 @@ def edit_scenario(mydb, tenant_id, scenario_id, data): return c +@deprecated("Use create_instance") def start_scenario(mydb, tenant_id, scenario_id, instance_scenario_name, instance_scenario_description, datacenter=None,vim_tenant=None, startvms=True): #print "Checking that nfvo_tenant_id exists and getting the VIM URI and the VIM tenant_id" datacenter_id, myvim = get_datacenter_by_name_uuid(mydb, tenant_id, datacenter, vim_tenant=vim_tenant) @@ -4118,6 +4125,7 @@ def get_instance_id(mydb, tenant_id, instance_id): } return instance_dict +@deprecated("Instance is automatically refreshed by vim_threads") def refresh_instance(mydb, nfvo_tenant, instanceDict, datacenter=None, vim_tenant=None): '''Refreshes a scenario instance. It modifies instanceDict''' '''Returns: diff --git a/osm_ro/utils.py b/osm_ro/utils.py index c7d966e7..2ae062fd 100644 --- a/osm_ro/utils.py +++ b/osm_ro/utils.py @@ -30,6 +30,7 @@ __author__="Alfonso Tierno, Gerardo Garcia" __date__ ="$08-sep-2014 12:21:22$" import datetime +import warnings from jsonschema import validate as js_v, exceptions as js_e #from bs4 import BeautifulSoup @@ -196,3 +197,14 @@ def expand_brackets(text): for char in text[start+1:end]: text_list += expand_brackets(text[:start] + char + text[end+1:]) return text_list + +def deprecated(message): + def deprecated_decorator(func): + def deprecated_func(*args, **kwargs): + warnings.warn("{} is a deprecated function. {}".format(func.__name__, message), + category=DeprecationWarning, + stacklevel=2) + warnings.simplefilter('default', DeprecationWarning) + return func(*args, **kwargs) + return deprecated_func + return deprecated_decorator \ No newline at end of file diff --git a/osm_ro/vmwarerecli.py b/osm_ro/vmwarerecli.py deleted file mode 100755 index b2f1752f..00000000 --- a/osm_ro/vmwarerecli.py +++ /dev/null @@ -1,818 +0,0 @@ -# -*- coding: utf-8 -*- -## -# This file is standalone vmware vcloud director util -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. -# -# For those usages not covered by the Apache License, Version 2.0 please -# contact with: mbayramov@vmware.com -## - -""" - -Standalone application that leverage openmano vmware connector work with vCloud director rest api. - - - Provides capability to create and delete VDC for specific organization. - - Create, delete and manage network for specific VDC - - List deployed VM's , VAPPs, VDSs, Organization - - View detail information about VM / Vapp , Organization etc - - Operate with images upload / boot / power on etc - - Usage example. - - List organization created in vCloud director - vmwarecli.py -u admin -p qwerty123 -c 172.16.254.206 -U Administrator -P qwerty123 -o test -v TEF list org - - List VDC for particular organization - vmwarecli.py -u admin -p qwerty123 -c 172.16.254.206 -U Administrator -P qwerty123 -o test -v TEF list vdc - - Upload image - python vmwarerecli.py image upload /Users/spyroot/Developer/Openmano/Ro/vnfs/cirros/cirros.ovf - - Boot Image - python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF image boot cirros cirros - - View vApp - python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF view vapp 90bd2b4e-f782-46cf-b5e2-c3817dcf6633 -u - - List VMS - python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vms - - List VDC in OSM format - python vmwarerecli.py -u admin -p qwerty123 -c 172.16.254.206 -o test -v TEF list vdc -o - -Mustaafa Bayramov -mbayramov@vmware.com -""" -import os -import argparse -import traceback -import uuid - -from xml.etree import ElementTree as ET - -import sys -from pyvcloud import Http - -import logging -import vimconn -import time -import uuid -import urllib3 -import requests - -from vimconn_vmware import vimconnector -from requests.packages.urllib3.exceptions import InsecureRequestWarning -from prettytable import PrettyTable - -requests.packages.urllib3.disable_warnings(InsecureRequestWarning) - -__author__ = "Mustafa Bayramov" -__date__ = "$16-Sep-2016 11:09:29$" - - -# TODO move to main vim -def delete_network_action(vca=None, network_uuid=None): - """ - Method leverages vCloud director and query network based on network uuid - - Args: - vca - is active VCA connection. - network_uuid - is a network uuid - - Returns: - The return XML respond - """ - - if vca is None or network_uuid is None: - return None - - url_list = [vca.host, '/api/admin/network/', network_uuid] - vm_list_rest_call = ''.join(url_list) - - if not (not vca.vcloud_session or not vca.vcloud_session.organization): - response = Http.get(url=vm_list_rest_call, - headers=vca.vcloud_session.get_vcloud_headers(), - verify=vca.verify, - logger=vca.logger) - if response.status_code == requests.codes.ok: - print response.content - return response.content - - return None - - -def print_vapp(vapp_dict=None): - """ Method takes vapp_dict and print in tabular format - - Args: - vapp_dict: container vapp object. - - Returns: - The return nothing - """ - - # following key available to print - # {'status': 'POWERED_OFF', 'storageProfileName': '*', 'hardwareVersion': '7', 'vmToolsVersion': '0', - # 'memoryMB': '384', - # 'href': 'https://172.16.254.206/api/vAppTemplate/vm-129e22e8-08dc-4cb6-8358-25f635e65d3b', - # 'isBusy': 'false', 'isDeployed': 'false', 'isInMaintenanceMode': 'false', 'isVAppTemplate': 'true', - # 'networkName': 'nat', 'isDeleted': 'false', 'catalogName': 'Cirros', - # 'containerName': 'Cirros Template', # 'container': - # 'https://172.16.254.206/api/vAppTemplate/vappTemplate-b966453d-c361-4505-9e38-ccef45815e5d', - # 'name': 'Cirros', 'pvdcHighestSupportedHardwareVersion': '11', 'isPublished': 'false', - # 'numberOfCpus': '1', 'vdc': 'https://172.16.254.206/api/vdc/a5056f85-418c-4bfd-8041-adb0f48be9d9', - # 'guestOs': 'Other (32-bit)', 'isVdcEnabled': 'true'} - - if vapp_dict is None: - return - - vm_table = PrettyTable(['vm uuid', - 'vapp name', - 'vapp uuid', - 'network name', - 'storage name', - 'vcpu', 'memory', 'hw ver','deployed','status']) - for k in vapp_dict: - entry = [] - entry.append(k) - entry.append(vapp_dict[k]['containerName']) - # vm-b1f5cd4c-2239-4c89-8fdc-a41ff18e0d61 - entry.append(vapp_dict[k]['container'].split('/')[-1:][0][5:]) - entry.append(vapp_dict[k]['networkName']) - entry.append(vapp_dict[k]['storageProfileName']) - entry.append(vapp_dict[k]['numberOfCpus']) - entry.append(vapp_dict[k]['memoryMB']) - entry.append(vapp_dict[k]['pvdcHighestSupportedHardwareVersion']) - entry.append(vapp_dict[k]['isDeployed']) - entry.append(vapp_dict[k]['status']) - - vm_table.add_row(entry) - - print vm_table - - -def print_org(org_dict=None): - """ Method takes vapp_dict and print in tabular format - - Args: - org_dict: dictionary of organization where key is org uuid. - - Returns: - The return nothing - """ - - if org_dict is None: - return - - org_table = PrettyTable(['org uuid', 'name']) - for k in org_dict: - entry = [k, org_dict[k]] - org_table.add_row(entry) - - print org_table - - -def print_vm_list(vm_dict=None): - """ Method takes vapp_dict and print in tabular format - - Args: - vm_dict: dictionary of organization where key is org uuid. - - Returns: - The return nothing - """ - if vm_dict is None: - return - - vm_table = PrettyTable( - ['vm uuid', 'vm name', 'vapp uuid', 'vdc uuid', 'network name', 'is deployed', 'vcpu', 'memory', 'status']) - - try: - for k in vm_dict: - entry = [] - entry.append(k) - entry.append(vm_dict[k]['name']) - entry.append(vm_dict[k]['container'].split('/')[-1:][0][5:]) - entry.append(vm_dict[k]['vdc'].split('/')[-1:][0]) - entry.append(vm_dict[k]['networkName']) - entry.append(vm_dict[k]['isDeployed']) - entry.append(vm_dict[k]['numberOfCpus']) - entry.append(vm_dict[k]['memoryMB']) - entry.append(vm_dict[k]['status']) - vm_table.add_row(entry) - print vm_table - except KeyError: - logger.error("wrong key {}".format(KeyError.message)) - pass - - -def print_vdc_list(org_dict=None): - """ Method takes vapp_dict and print in tabular format - - Args: - org_dict: dictionary of organization where key is org uuid. - - Returns: - The return nothing - """ - if org_dict is None: - return - try: - vdcs_dict = {} - if org_dict.has_key('vdcs'): - vdcs_dict = org_dict['vdcs'] - vdc_table = PrettyTable(['vdc uuid', 'vdc name']) - for k in vdcs_dict: - entry = [k, vdcs_dict[k]] - vdc_table.add_row(entry) - - print vdc_table - except KeyError: - logger.error("wrong key {}".format(KeyError.message)) - logger.logger.debug(traceback.format_exc()) - - -def print_network_list(org_dict=None): - """ Method print network list. - - Args: - org_dict: dictionary of organization that contain key networks with a list of all - network for for specific VDC - - Returns: - The return nothing - """ - if org_dict is None: - return - try: - network_dict = {} - if org_dict.has_key('networks'): - network_dict = org_dict['networks'] - network_table = PrettyTable(['network uuid', 'network name']) - for k in network_dict: - entry = [k, network_dict[k]] - network_table.add_row(entry) - - print network_table - - except KeyError: - logger.error("wrong key {}".format(KeyError.message)) - logger.logger.debug(traceback.format_exc()) - - -def print_org_details(org_dict=None): - """ Method takes vapp_dict and print in tabular format - - Args: - org_dict: dictionary of organization where key is org uuid. - - Returns: - The return nothing - """ - if org_dict is None: - return - try: - catalogs_dict = {} - - print_vdc_list(org_dict=org_dict) - print_network_list(org_dict=org_dict) - - if org_dict.has_key('catalogs'): - catalogs_dict = org_dict['catalogs'] - - catalog_table = PrettyTable(['catalog uuid', 'catalog name']) - for k in catalogs_dict: - entry = [k, catalogs_dict[k]] - catalog_table.add_row(entry) - - print catalog_table - - except KeyError: - logger.error("wrong key {}".format(KeyError.message)) - logger.logger.debug(traceback.format_exc()) - - -def delete_actions(vim=None, action=None, namespace=None): - if action == 'network' or namespace.action == 'network': - logger.debug("Requesting delete for network {}".format(namespace.network_name)) - network_uuid = namespace.network_name - # if request name based we need find UUID - # TODO optimize it or move to external function - if not namespace.uuid: - org_dict = vim.get_org_list() - for org in org_dict: - org_net = vim.get_org(org)['networks'] - for network in org_net: - if org_net[network] == namespace.network_name: - network_uuid = network - - vim.delete_network_action(network_uuid=network_uuid) - - -def list_actions(vim=None, action=None, namespace=None): - """ Method provide list object from VDC action - - Args: - vim - is vcloud director vim connector. - action - is action for list ( vdc / org etc) - namespace - must contain VDC / Org information. - - Returns: - The return nothing - """ - - org_id = None - myorgs = vim.get_org_list() - for org in myorgs: - if myorgs[org] == namespace.vcdorg: - org_id = org - break - else: - print(" Invalid organization.") - return - - if action == 'vms' or namespace.action == 'vms': - vm_dict = vim.get_vm_list(vdc_name=namespace.vcdvdc) - print_vm_list(vm_dict=vm_dict) - elif action == 'vapps' or namespace.action == 'vapps': - vapp_dict = vim.get_vapp_list(vdc_name=namespace.vcdvdc) - print_vapp(vapp_dict=vapp_dict) - elif action == 'networks' or namespace.action == 'networks': - if namespace.osm: - osm_print(vim.get_network_list(filter_dict={})) - else: - print_network_list(vim.get_org(org_uuid=org_id)) - elif action == 'vdc' or namespace.action == 'vdc': - if namespace.osm: - osm_print(vim.get_tenant_list(filter_dict=None)) - else: - print_vdc_list(vim.get_org(org_uuid=org_id)) - elif action == 'org' or namespace.action == 'org': - print_org(org_dict=vim.get_org_list()) - else: - return None - - -def print_network_details(network_dict=None): - try: - network_table = PrettyTable(network_dict.keys()) - entry = [network_dict.values()] - network_table.add_row(entry[0]) - print network_table - except KeyError: - logger.error("wrong key {}".format(KeyError.message)) - logger.logger.debug(traceback.format_exc()) - - -def osm_print(generic_dict=None): - - try: - for element in generic_dict: - table = PrettyTable(element.keys()) - entry = [element.values()] - table.add_row(entry[0]) - print table - except KeyError: - logger.error("wrong key {}".format(KeyError.message)) - logger.logger.debug(traceback.format_exc()) - - -def view_actions(vim=None, action=None, namespace=None): - org_id = None - orgs = vim.get_org_list() - for org in orgs: - if orgs[org] == namespace.vcdorg: - org_id = org - break - else: - print(" Invalid organization.") - return - - myorg = vim.get_org(org_uuid=org_id) - - # view org - if action == 'org' or namespace.action == 'org': - org_id = None - orgs = vim.get_org_list() - if namespace.uuid: - if namespace.org_name in orgs: - org_id = namespace.org_name - else: - # we need find UUID based on name provided - for org in orgs: - if orgs[org] == namespace.org_name: - org_id = org - break - - logger.debug("Requesting view for orgs {}".format(org_id)) - print_org_details(vim.get_org(org_uuid=org_id)) - - # view vapp action - if action == 'vapp' or namespace.action == 'vapp': - if namespace.vapp_name is not None and namespace.uuid: - logger.debug("Requesting vapp {} for vdc {}".format(namespace.vapp_name, namespace.vcdvdc)) - vapp_dict = {} - vapp_uuid = namespace.vapp_name - # if request based on just name we need get UUID - if not namespace.uuid: - vapp_uuid = vim.get_vappid(vdc=namespace.vcdvdc, vapp_name=namespace.vapp_name) - if vapp_uuid is None: - print("Can't find vapp by given name {}".format(namespace.vapp_name)) - return - - print " namespace {}".format(namespace) - if vapp_dict is not None and namespace.osm: - vm_info_dict = vim.get_vminstance(vim_vm_uuid=vapp_uuid) - print vm_info_dict - if vapp_dict is not None and namespace.osm != True: - vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vapp_uuid, isuuid=True) - print_vapp(vapp_dict=vapp_dict) - - # view network - if action == 'network' or namespace.action == 'network': - logger.debug("Requesting view for network {}".format(namespace.network_name)) - network_uuid = namespace.network_name - # if request name based we need find UUID - # TODO optimize it or move to external function - if not namespace.uuid: - if not myorg.has_key('networks'): - print("Network {} is undefined in vcloud director for org {} vdc {}".format(namespace.network_name, - vim.name, - vim.tenant_name)) - return - - my_org_net = myorg['networks'] - for network in my_org_net: - if my_org_net[network] == namespace.network_name: - network_uuid = network - break - - print print_network_details(network_dict=vim.get_vcd_network(network_uuid=network_uuid)) - - -def create_actions(vim=None, action=None, namespace=None): - """Method gets provider vdc view from vcloud director - - Args: - vim - is Cloud director vim connector - action - action for create ( network / vdc etc) - - Returns: - The return xml content of respond or None - """ - if action == 'network' or namespace.action == 'network': - logger.debug("Creating a network in vcloud director".format(namespace.network_name)) - network_uuid = vim.create_network(namespace.network_name) - if network_uuid is not None: - print ("Crated new network {} and uuid: {}".format(namespace.network_name, network_uuid)) - else: - print ("Failed create a new network {}".format(namespace.network_name)) - elif action == 'vdc' or namespace.action == 'vdc': - logger.debug("Creating a new vdc in vcloud director.".format(namespace.vdc_name)) - vdc_uuid = vim.create_vdc(namespace.vdc_name) - if vdc_uuid is not None: - print ("Crated new vdc {} and uuid: {}".format(namespace.vdc_name, vdc_uuid)) - else: - print ("Failed create a new vdc {}".format(namespace.vdc_name)) - else: - return None - - -def validate_uuid4(uuid_string): - """Function validate that string contain valid uuid4 - - Args: - uuid_string - valid UUID string - - Returns: - The return true if string contain valid UUID format - """ - try: - val = uuid.UUID(uuid_string, version=4) - except ValueError: - return False - return True - - -def upload_image(vim=None, image_file=None): - """Function upload image to vcloud director - - Args: - image_file - valid UUID string - - Returns: - The return true if image uploaded correctly - """ - try: - catalog_uuid = vim.get_image_id_from_path(path=image_file, progress=True) - if catalog_uuid is not None and validate_uuid4(catalog_uuid): - print("Image uploaded and uuid {}".format(catalog_uuid)) - return True - except vimconn.vimconnException as upload_exception: - print("Failed uploaded {} image".format(image_file)) - print("Error Reason: {}".format(upload_exception.message)) - return False - - -def boot_image(vim=None, image_name=None, vm_name=None): - """ Function boot image that resided in vcloud director. - The image name can be UUID of name. - - Args: - vim - vim connector - image_name - image identified by UUID or text string. - vm_name - vmname - - - Returns: - The return true if image uploaded correctly - """ - - vim_catalog = None - try: - catalogs = vim.vca.get_catalogs() - if not validate_uuid4(image_name): - vim_catalog = vim.get_catalogid(catalog_name=image_name, catalogs=catalogs) - if vim_catalog is None: - return None - else: - vim_catalog = vim.get_catalogid(catalog_name=image_name, catalogs=catalogs) - if vim_catalog is None: - return None - - print (" Booting {} image id {} ".format(vm_name, vim_catalog)) - vm_uuid, _ = vim.new_vminstance(name=vm_name, image_id=vim_catalog) - if vm_uuid is not None and validate_uuid4(vm_uuid): - print("Image booted and vm uuid {}".format(vm_uuid)) - vapp_dict = vim.get_vapp(vdc_name=namespace.vcdvdc, vapp_name=vm_uuid, isuuid=True) - if vapp_dict is not None: - print_vapp(vapp_dict=vapp_dict) - return True - except vimconn.vimconnNotFoundException as notFound: - print("Failed boot {} image".format(image_name)) - print(notFound.message) - except vimconn.vimconnException as vimconError: - print("Failed boot {} image".format(image_name)) - print(vimconError.message) - except: - print("Failed boot {} image".format(image_name)) - - - return False - - -def image_action(vim=None, action=None, namespace=None): - """ Function present set of action to manipulate with image. - - upload image - - boot image. - - delete image ( not yet done ) - - Args: - vim - vcloud director connector - action - string (upload/boot etc) - namespace - contain other attributes image name etc - - Returns: - The return nothing - """ - - if action == 'upload' or namespace.action == 'upload': - upload_image(vim=vim, image_file=namespace.image) - elif action == 'boot' or namespace.action == 'boot': - boot_image(vim=vim, image_name=namespace.image, vm_name=namespace.vmname) - else: - return None - - -def vmwarecli(command=None, action=None, namespace=None): - logger.debug("Namespace {}".format(namespace)) - urllib3.disable_warnings() - - vcduser = None - vcdpasword = None - vcdhost = None - vcdorg = None - - if hasattr(__builtins__, 'raw_input'): - input = raw_input - - if namespace.vcdvdc is None: - while True: - vcduser = input("Enter vcd username: ") - if vcduser is not None and len(vcduser) > 0: - break - else: - vcduser = namespace.vcduser - - if namespace.vcdpassword is None: - while True: - vcdpasword = input("Please enter vcd password: ") - if vcdpasword is not None and len(vcdpasword) > 0: - break - else: - vcdpasword = namespace.vcdpassword - - if namespace.vcdhost is None: - while True: - vcdhost = input("Please enter vcd host name or ip: ") - if vcdhost is not None and len(vcdhost) > 0: - break - else: - vcdhost = namespace.vcdhost - - if namespace.vcdorg is None: - while True: - vcdorg = input("Please enter vcd organization name: ") - if vcdorg is not None and len(vcdorg) > 0: - break - else: - vcdorg = namespace.vcdorg - - try: - vim = vimconnector(uuid=None, - name=vcdorg, - tenant_id=None, - tenant_name=namespace.vcdvdc, - url=vcdhost, - url_admin=vcdhost, - user=vcduser, - passwd=vcdpasword, - log_level="DEBUG", - config={'admin_username': namespace.vcdamdin, 'admin_password': namespace.vcdadminpassword}) - vim.vca = vim.connect() - - except vimconn.vimconnConnectionException: - print("Failed connect to vcloud director. Please check credential and hostname.") - return - - # list - if command == 'list' or namespace.command == 'list': - logger.debug("Client requested list action") - # route request to list actions - list_actions(vim=vim, action=action, namespace=namespace) - - # view action - if command == 'view' or namespace.command == 'view': - logger.debug("Client requested view action") - view_actions(vim=vim, action=action, namespace=namespace) - - # delete action - if command == 'delete' or namespace.command == 'delete': - logger.debug("Client requested delete action") - delete_actions(vim=vim, action=action, namespace=namespace) - - # create action - if command == 'create' or namespace.command == 'create': - logger.debug("Client requested create action") - create_actions(vim=vim, action=action, namespace=namespace) - - # image action - if command == 'image' or namespace.command == 'image': - logger.debug("Client requested create action") - image_action(vim=vim, action=action, namespace=namespace) - - -if __name__ == '__main__': - defaults = {'vcdvdc': 'default', - 'vcduser': 'admin', - 'vcdpassword': 'admin', - 'vcdhost': 'https://localhost', - 'vcdorg': 'default', - 'debug': 'INFO'} - - parser = argparse.ArgumentParser() - parser.add_argument('-u', '--vcduser', help='vcloud director username', type=str) - parser.add_argument('-p', '--vcdpassword', help='vcloud director password', type=str) - parser.add_argument('-U', '--vcdamdin', help='vcloud director password', type=str) - parser.add_argument('-P', '--vcdadminpassword', help='vcloud director password', type=str) - parser.add_argument('-c', '--vcdhost', help='vcloud director host', type=str) - parser.add_argument('-o', '--vcdorg', help='vcloud director org', type=str) - parser.add_argument('-v', '--vcdvdc', help='vcloud director vdc', type=str) - parser.add_argument('-d', '--debug', help='debug level', type=int) - - parser_subparsers = parser.add_subparsers(help='commands', dest='command') - sub = parser_subparsers.add_parser('list', help='List objects (VMs, vApps, networks)') - sub_subparsers = sub.add_subparsers(dest='action') - - list_vms = sub_subparsers.add_parser('vms', help='list - all vm deployed in vCloud director') - list_vapps = sub_subparsers.add_parser('vapps', help='list - all vapps deployed in vCloud director') - list_network = sub_subparsers.add_parser('networks', help='list - all networks deployed') - list_network.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format') - - #list vdc - list_vdc = sub_subparsers.add_parser('vdc', help='list - list all vdc for organization accessible to you') - list_vdc.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format') - - list_org = sub_subparsers.add_parser('org', help='list - list of organizations accessible to you.') - - create_sub = parser_subparsers.add_parser('create') - create_sub_subparsers = create_sub.add_subparsers(dest='action') - create_vms = create_sub_subparsers.add_parser('vms') - create_vapp = create_sub_subparsers.add_parser('vapp') - create_vapp.add_argument('uuid') - - # add network - create_network = create_sub_subparsers.add_parser('network') - create_network.add_argument('network_name', action='store', help='create a network for a vdc') - - # add VDC - create_vdc = create_sub_subparsers.add_parser('vdc') - create_vdc.add_argument('vdc_name', action='store', help='create a new VDC for org') - - delete_sub = parser_subparsers.add_parser('delete') - del_sub_subparsers = delete_sub.add_subparsers(dest='action') - del_vms = del_sub_subparsers.add_parser('vms') - del_vapp = del_sub_subparsers.add_parser('vapp') - del_vapp.add_argument('uuid', help='view vapp based on UUID') - - # delete network - del_network = del_sub_subparsers.add_parser('network') - del_network.add_argument('network_name', action='store', - help='- delete network for vcloud director by provided name') - del_network.add_argument('-u', '--uuid', default=False, action='store_true', - help='delete network for vcloud director by provided uuid') - - # delete vdc - del_vdc = del_sub_subparsers.add_parser('vdc') - - view_sub = parser_subparsers.add_parser('view') - view_sub_subparsers = view_sub.add_subparsers(dest='action') - - view_vms_parser = view_sub_subparsers.add_parser('vms') - view_vms_parser.add_argument('uuid', default=False, action='store_true', - help='- View VM for specific uuid in vcloud director') - view_vms_parser.add_argument('name', default=False, action='store_true', - help='- View VM for specific vapp name in vcloud director') - - # view vapp - view_vapp_parser = view_sub_subparsers.add_parser('vapp') - view_vapp_parser.add_argument('vapp_name', action='store', - help='- view vapp for specific vapp name in vcloud director') - view_vapp_parser.add_argument('-u', '--uuid', default=False, action='store_true', help='view vapp based on uuid') - view_vapp_parser.add_argument('-o', '--osm', default=False, action='store_true', help='provide view in OSM format') - - # view network - view_network = view_sub_subparsers.add_parser('network') - view_network.add_argument('network_name', action='store', - help='- view network for specific network name in vcloud director') - view_network.add_argument('-u', '--uuid', default=False, action='store_true', help='view network based on uuid') - - # view VDC command and actions - view_vdc = view_sub_subparsers.add_parser('vdc') - view_vdc.add_argument('vdc_name', action='store', - help='- View VDC based and action based on provided vdc uuid') - view_vdc.add_argument('-u', '--uuid', default=False, action='store_true', help='view vdc based on uuid') - - # view organization command and actions - view_org = view_sub_subparsers.add_parser('org') - view_org.add_argument('org_name', action='store', - help='- View VDC based and action based on provided vdc uuid') - view_org.add_argument('-u', '--uuid', default=False, action='store_true', help='view org based on uuid') - - # upload image action - image_sub = parser_subparsers.add_parser('image') - image_subparsers = image_sub.add_subparsers(dest='action') - upload_parser = image_subparsers.add_parser('upload') - upload_parser.add_argument('image', default=False, action='store', help='- valid path to OVF image ') - upload_parser.add_argument('catalog', default=False, action='store_true', help='- catalog name') - - # boot vm action - boot_parser = image_subparsers.add_parser('boot') - boot_parser.add_argument('image', default=False, action='store', help='- Image name') - boot_parser.add_argument('vmname', default=False, action='store', help='- VM name') - boot_parser.add_argument('-u', '--uuid', default=False, action='store_true', help='view org based on uuid') - - namespace = parser.parse_args() - # put command_line args to mapping - command_line_args = {k: v for k, v in vars(namespace).items() if v} - - d = defaults.copy() - d.update(os.environ) - d.update(command_line_args) - - logger = logging.getLogger('mano.vim.vmware') - formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') - ch = logging.StreamHandler() - ch.setLevel(str.upper(d['debug'])) - ch.setFormatter(formatter) - logger.addHandler(ch) - logger.setLevel(getattr(logging, str.upper(d['debug']))) - logger.info( - "Connecting {} username: {} org: {} vdc: {} ".format(d['vcdhost'], d['vcduser'], d['vcdorg'], d['vcdvdc'])) - - logger.debug("command: \"{}\" actio: \"{}\"".format(d['command'], d['action'])) - - # main entry point. - vmwarecli(namespace=namespace)