def check_config(config_file_name, template='*'):
click.secho('Validating CSE on vCD from file: %s' % config_file_name)
config = get_config(config_file_name)
validate_broker_config_elements(config['broker'])
amqp = config['amqp']
credentials = pika.PlainCredentials(amqp['username'], amqp['password'])
parameters = pika.ConnectionParameters(
amqp['host'], amqp['port'], '/', credentials, ssl=amqp['ssl'])
connection = pika.BlockingConnection(parameters)
click.echo('Connected to AMQP server (%s:%s): %s' %
(amqp['host'], amqp['port'], bool_to_msg(connection.is_open)))
connection.close()
v = VSphere(
config['vcs']['host'],
config['vcs']['username'],
config['vcs']['password'],
port=int(config['vcs']['port']))
v.connect()
click.echo('Connected to vCenter Server as %s '
'(%s:%s): %s' % (config['vcs']['username'],
config['vcs']['host'], config['vcs']['port'],
bool_to_msg(True)))
if not config['vcd']['verify']:
click.secho(
'InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
client = Client(
config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file='cse.log',
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
click.echo('Connected to vCloud Director as system '
'administrator (%s:%s): %s' % (config['vcd']['host'],
config['vcd']['port'],
bool_to_msg(True)))
click.secho('Validating \'%s\' service broker' % config['broker']['type'])
if config['broker']['type'] == 'default':
validate_broker_config_content(config, client, template)
return config
def get_vsphere(config, vapp, vm_name, logger=None):
"""Get the VSphere object for a specific VM inside a VApp.
:param dict config: CSE config as a dictionary
:param pyvcloud.vcd.vapp.VApp vapp: VApp used to get the VM ID.
:param str vm_name:
:param logging.Logger logger: optional logger to log with.
:return: VSphere object for a specific VM inside a VApp
:rtype: vsphere_guest_run.vsphere.VSphere
"""
global cache
# get vm id from vm resource
vm_id = vapp.get_vm(vm_name).get('id')
if vm_id not in cache:
client = Client(uri=config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_headers=True,
log_bodies=True)
credentials = BasicLoginCredentials(config['vcd']['username'],
SYSTEM_ORG_NAME,
config['vcd']['password'])
client.set_credentials(credentials)
# must recreate vapp, or cluster creation fails
vapp = VApp(client, href=vapp.href)
vm_resource = vapp.get_vm(vm_name)
vm_sys = VM(client, resource=vm_resource)
vcenter_name = vm_sys.get_vc()
platform = Platform(client)
vcenter = platform.get_vcenter(vcenter_name)
vcenter_url = urlparse(vcenter.Url.text)
cache_item = {
'hostname': vcenter_url.hostname,
'port': vcenter_url.port
}
for vc in config['vcs']:
if vc['name'] == vcenter_name:
cache_item['username'] = vc['username']
cache_item['password'] = vc['password']
break
cache[vm_id] = cache_item
if logger:
logger.debug(f"VM ID: {vm_id}, Hostname: {cache[vm_id]['hostname']}")
return VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
def get_vsphere(config, vapp, vm_name):
"""Get the VSphere object for a specific VM inside a VApp.
:param dict config: CSE config as a dictionary
:param pyvcloud.vcd.vapp.VApp vapp:
:param str vm_name:
:return: VSphere object for a specific VM inside a VApp
:rtype: vsphere_guest_run.vsphere.VSphere
"""
global cache
vm_resource = vapp.get_vm(vm_name)
vm_id = vm_resource.get('id')
if vm_id not in cache:
client = Client(uri=config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_headers=True,
log_bodies=True)
credentials = BasicLoginCredentials(config['vcd']['username'],
SYSTEM_ORG_NAME,
config['vcd']['password'])
client.set_credentials(credentials)
vm_sys = VM(client, resource=vm_resource)
vcenter_name = vm_sys.get_vc()
platform = Platform(client)
vcenter = platform.get_vcenter(vcenter_name)
vcenter_url = urlparse(vcenter.Url.text)
cache_item = {
'hostname': vcenter_url.hostname,
'port': vcenter_url.port
}
for vc in config['vcs']:
if vc['name'] == vcenter_name:
cache_item['username'] = vc['username']
cache_item['password'] = vc['password']
break
cache[vm_id] = cache_item
else:
LOGGER.debug(f"vCenter retrieved from cache\nVM ID: {vm_id}"
f"\nHostname: {cache[vm_id]['hostname']}")
return VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
def execute_script_in_nodes(config,
vapp,
password,
script,
nodes,
check_tools=True):
vs = VSphere(
config['vcs']['host'],
config['vcs']['username'],
config['vcs']['password'],
port=int(config['vcs']['port']))
vs.connect()
all_results = []
for node in nodes:
LOGGER.debug('running script on %s' % node.get('name'))
print('running script on %s' % node.get('name'))
moid = vapp.get_vm_moid(node.get('name'))
vm = vs.get_vm_by_moid(moid)
if check_tools:
vs.wait_until_tools_ready(
vm, sleep=5, callback=wait_for_tools_ready_callback)
wait_until_ready_to_exec(vs, vm, password)
result = vs.execute_script_in_guest(
vm,
'root',
password,
script,
target_file=None,
wait_for_completion=True,
wait_time=10,
get_output=True,
delete_script=True,
callback=wait_for_guest_execution_callback)
result_stdout = result[1].content.decode()
result_stderr = result[2].content.decode()
LOGGER.debug(result[0])
LOGGER.debug(result_stderr)
LOGGER.debug(result_stdout)
print(result[0])
print(result_stderr)
print(result_stdout)
all_results.append(result)
return all_results
def get_vsphere(sys_admin_client, vapp, vm_name, logger=NULL_LOGGER):
"""Get the VSphere object for a specific VM inside a VApp.
:param pyvcloud.vcd.client.Client sys_admin_client:
:param pyvcloud.vcd.vapp.VApp vapp: VApp used to get the VM ID.
:param str vm_name:
:param logging.Logger logger: logger to log with.
:return: VSphere object for a specific VM inside a VApp
:rtype: vsphere_guest_run.vsphere.VSphere
"""
global cache
global vsphere_list
# get vm id from vm resource
vm_id = vapp.get_vm(vm_name).get('id')
if vm_id not in cache:
# recreate vapp with sys admin client
vapp = VApp(sys_admin_client, href=vapp.href)
vm_resource = vapp.get_vm(vm_name)
vm_sys = VM(sys_admin_client, resource=vm_resource)
vcenter_name = vm_sys.get_vc()
platform = Platform(sys_admin_client)
vcenter = platform.get_vcenter(vcenter_name)
vcenter_url = urlparse(vcenter.Url.text)
cache_item = {
'hostname': vcenter_url.hostname,
'port': vcenter_url.port
}
if not vsphere_list:
raise Exception("Global list of vSphere info not set.")
for vc in vsphere_list:
if vc['name'] == vcenter_name:
cache_item['username'] = vc['username']
cache_item['password'] = vc['password']
break
cache[vm_id] = cache_item
logger.debug(f"VM ID: {vm_id}, Hostname: {cache[vm_id]['hostname']}")
return VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
def get_vsphere(config, vapp, vm_name):
global cache
vm_resource = vapp.get_vm(vm_name)
vm_id = vm_resource.get('id')
if vm_id not in cache:
client_sysadmin = Client(uri=config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_headers=True,
log_bodies=True)
client_sysadmin.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
vapp_sys = VApp(client_sysadmin, href=vapp.href)
vm_resource = vapp_sys.get_vm(vm_name)
vm_sys = VM(client_sysadmin, resource=vm_resource)
vcenter_name = vm_sys.get_vc()
platform = Platform(client_sysadmin)
vcenter = platform.get_vcenter(vcenter_name)
vcenter_url = urlparse(vcenter.Url.text)
cache_item = {
'hostname': vcenter_url.hostname,
'username': vcenter.Username.text,
'port': vcenter_url.port
}
for vc in config['vcs']:
if vc['name'] == vcenter_name:
cache_item['password'] = vc['password']
break
cache[vm_id] = cache_item
else:
LOGGER.debug('vCenter retrieved from cache: %s / %s' %
(vm_id, cache[vm_id]['hostname']))
v = VSphere(cache[vm_id]['hostname'], cache[vm_id]['username'],
cache[vm_id]['password'], cache[vm_id]['port'])
return v
def get_file_from_nodes(config,
vapp,
password,
file_name,
nodes,
check_tools=True):
vs = VSphere(
config['vcs']['host'],
config['vcs']['username'],
config['vcs']['password'],
port=int(config['vcs']['port']))
vs.connect()
all_results = []
for node in nodes:
LOGGER.debug('getting file from node %s' % node.get('name'))
moid = vapp.get_vm_moid(node.get('name'))
vm = vs.get_vm_by_moid(moid)
if check_tools:
vs.wait_until_tools_ready(
vm, sleep=5, callback=wait_for_tools_ready_callback)
wait_until_ready_to_exec(vs, vm, password)
result = vs.download_file_from_guest(vm, 'root', password, file_name)
all_results.append(result)
return all_results
url = os.environ['VGR_URL']
verify_ssl_certs = False
moid = os.environ['VGR_MOID']
guest_user = os.environ['VGR_GUEST_USER']
guest_password = os.environ['VGR_GUEST_PASSWORD']
if len(sys.argv) < 2:
print('usage: run-cmd.py \'program to run on guest with arguments\'')
sys.exit()
vgr_command = sys.argv[1]
tokens = url.split(':')
vc_user = tokens[0]
tokens = tokens[1].split('@')
vc_host = tokens[-1]
vc_password = ''
for token in tokens[:-1]:
if len(vc_password) > 0:
vc_password += '@'
vc_password += token
vs = VSphere(vc_host, vc_user, vc_password, verify=verify_ssl_certs)
vs.connect()
vm = vs.get_vm_by_moid(moid)
result = vs.execute_program_in_guest(vm,
guest_user,
guest_password,
vgr_command,
get_output=False,
wait_for_completion=False)
print(result)
def _validate_vcd_and_vcs_config(
vcd_dict,
vcs,
msg_update_callback=NullPrinter(),
log_file=None,
log_wire=False
):
"""Ensure that 'vcd' and vcs' section of config are correct.
Checks that
* 'vcd' and 'vcs' section of config have correct keys and value types.
* vCD and all registered VCs in vCD are accessible.
* api version specified for vcd is supported by CSE.
:param dict vcd_dict: 'vcd' section of config file as a dict.
:param list vcs: 'vcs' section of config file as a list of dicts.
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object.
:param str log_file: log_file for pyvcloud wire log.
:param bool log_wire: If pyvcloud requests should be logged.
:raises KeyError: if @vcd_dict or a vc in @vcs has missing or
extra properties.
:raises TypeError: if the value type for a @vcd_dict or vc property
is incorrect.
:raises ValueError: if vCD has a VC that is not listed in the config file.
"""
check_keys_and_value_types(vcd_dict, SAMPLE_VCD_CONFIG['vcd'],
location="config file 'vcd' section",
msg_update_callback=msg_update_callback)
if not vcd_dict['verify']:
msg_update_callback.general(
'InsecureRequestWarning: Unverified HTTPS request is '
'being made. Adding certificate verification is '
'strongly advised.'
)
requests.packages.urllib3.disable_warnings()
client = None
try:
_validate_vcd_url_scheme(vcd_dict['host'])
client = Client(
vcd_dict['host'],
verify_ssl_certs=vcd_dict['verify'],
log_file=log_file,
log_requests=log_wire,
log_headers=log_wire,
log_bodies=log_wire
)
client.set_credentials(
BasicLoginCredentials(
vcd_dict['username'],
SYSTEM_ORG_NAME,
vcd_dict['password']
)
)
msg_update_callback.general(
"Connected to vCloud Director "
f"({vcd_dict['host']}:{vcd_dict['port']})"
)
for index, vc in enumerate(vcs, 1):
check_keys_and_value_types(
vc,
SAMPLE_VCS_CONFIG['vcs'][0],
location=f"config file 'vcs' section, vc #{index}",
msg_update_callback=msg_update_callback
)
# Check that all registered VCs in vCD are listed in config file
platform = Platform(client)
config_vc_names = [vc['name'] for vc in vcs]
for platform_vc in platform.list_vcenters():
platform_vc_name = platform_vc.get('name')
if platform_vc_name not in config_vc_names:
raise ValueError(
f"vCenter '{platform_vc_name}' registered in "
"vCD but not found in config file"
)
# Check that all VCs listed in config file are registered in vCD
for vc in vcs:
vcenter = platform.get_vcenter(vc['name'])
if not (hasattr(vcenter, 'IsConnected') and vcenter.IsConnected):
msg = f"vCenter Server '{vc['name']}' not available"
msg_update_callback.info(msg)
continue
vsphere_url = urlparse(vcenter.Url.text)
vsphere_url_port = vsphere_url.port
if vsphere_url_port:
v = VSphere(
vsphere_url.hostname,
vc['username'],
vc['password'],
vsphere_url.port
)
else:
v = VSphere(
vsphere_url.hostname,
vc['username'],
vc['password']
)
v.connect()
msg = f"Connected to vCenter Server '{vc['name']}' as " \
f"'{vc['username']}' ({vsphere_url.hostname}"
if vsphere_url_port:
msg += f":{vsphere_url.port}"
msg += ")"
msg_update_callback.general(msg)
finally:
if client is not None:
client.logout()
def check_config(config_file_name, template=None):
click.secho('Validating CSE on vCD from file: %s' % config_file_name)
if sys.version_info.major >= 3 and sys.version_info.minor >= 6:
python_valid = True
else:
python_valid = False
click.echo('Python version >= 3.6 (installed: %s.%s.%s): %s' %
(sys.version_info.major, sys.version_info.minor,
sys.version_info.micro, bool_to_msg(python_valid)))
if not python_valid:
raise Exception('Python version not supported')
config = get_config(config_file_name)
validate_broker_config_elements(config['broker'])
amqp = config['amqp']
credentials = pika.PlainCredentials(amqp['username'], amqp['password'])
parameters = pika.ConnectionParameters(amqp['host'],
amqp['port'],
'/',
credentials,
ssl=amqp['ssl'])
connection = pika.BlockingConnection(parameters)
click.echo('Connected to AMQP server (%s:%s): %s' %
(amqp['host'], amqp['port'], bool_to_msg(connection.is_open)))
connection.close()
if not config['vcd']['verify']:
click.secho(
'InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
client = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file='cse-check.log',
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
click.echo(
'Connected to vCloud Director as system '
'administrator (%s:%s): %s' %
(config['vcd']['host'], config['vcd']['port'], bool_to_msg(True)))
platform = Platform(client)
for vc in platform.list_vcenters():
found = False
for config_vc in config['vcs']:
if vc.get('name') == config_vc.get('name'):
found = True
break
if not found:
raise Exception('vCenter \'%s\' defined in vCloud Director '
'but not in CSE config file' % vc.get('name'))
return None
for vc in config['vcs']:
vcenter = platform.get_vcenter(vc['name'])
vsphere_url = urlparse(vcenter.Url.text)
v = VSphere(vsphere_url.hostname, vcenter.Username.text,
vc['password'], vsphere_url.port)
v.connect()
click.echo('Connected to vCenter Server %s as %s '
'(%s:%s): %s' %
(vc['name'], vcenter.Username.text, vsphere_url.hostname,
vsphere_url.port, bool_to_msg(True)))
if template is None:
pass
else:
click.secho('Validating \'%s\' service broker' %
config['broker']['type'])
if config['broker']['type'] == 'default':
validate_broker_config_content(config, client, template)
return config
def validate_vcd_and_vcs_config(vcd_dict, vcs):
"""Ensures that 'vcd' and vcs' section of config are correct.
Checks that 'vcd' and 'vcs' section of config have correct keys and value
types. Also checks that vCD and all registered VCs in vCD are accessible.
:param dict vcd_dict: 'vcd' section of config file as a dict.
:param list vcs: 'vcs' section of config file as a list of dicts.
:raises KeyError: if @vcd_dict or a vc in @vcs has missing or
extra properties.
:raises: ValueError: if the value type for a @vcd_dict or vc property
is incorrect, or if vCD has a VC that is not listed in the config file.
"""
check_keys_and_value_types(vcd_dict,
SAMPLE_VCD_CONFIG['vcd'],
location="config file 'vcd' section")
if not vcd_dict['verify']:
click.secho(
'InsecureRequestWarning: Unverified HTTPS request is '
'being made. Adding certificate verification is '
'strongly advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
client = None
try:
client = Client(vcd_dict['host'],
api_version=vcd_dict['api_version'],
verify_ssl_certs=vcd_dict['verify'])
client.set_credentials(
BasicLoginCredentials(vcd_dict['username'], SYSTEM_ORG_NAME,
vcd_dict['password']))
click.secho(
f"Connected to vCloud Director "
f"({vcd_dict['host']}:{vcd_dict['port']})",
fg='green')
for index, vc in enumerate(vcs, 1):
check_keys_and_value_types(vc,
SAMPLE_VCS_CONFIG['vcs'][0],
location=f"config file 'vcs' section, "
f"vc #{index}")
# Check that all registered VCs in vCD are listed in config file
platform = Platform(client)
config_vc_names = [vc['name'] for vc in vcs]
for platform_vc in platform.list_vcenters():
platform_vc_name = platform_vc.get('name')
if platform_vc_name not in config_vc_names:
raise ValueError(f"vCenter '{platform_vc_name}' registered in "
f"vCD but not found in config file")
# Check that all VCs listed in config file are registered in vCD
for vc in vcs:
vcenter = platform.get_vcenter(vc['name'])
vsphere_url = urlparse(vcenter.Url.text)
v = VSphere(vsphere_url.hostname, vc['username'], vc['password'],
vsphere_url.port)
v.connect()
click.secho(
f"Connected to vCenter Server '{vc['name']}' as "
f"'{vc['username']}' ({vsphere_url.hostname}:"
f"{vsphere_url.port})",
fg='green')
finally:
if client is not None:
client.logout()
def vgr(ctx, debug, url, verify_ssl_certs, disable_warnings):
"""vSphere Guest Run
\b
Run commands and work with files on VM guest OS.
\b
Examples
vgr list
list of VMs.
\b
vgr run vm-111 /bin/date
run command on a VM guest OS.
\b
vgr -i -w run vm-111 '/bin/which uname'
run command on a VM guest OS.
\b
vgr -i -w run vm-111 '/bin/uname -a'
run command on a VM guest OS.
\b
Environment Variables
VGR_URL
If this environment variable is set, the command will use its value
as the URL to login on the vCenter or ESXi. The --url
option has precedence over the environment variable. The format for
the URL is: 'user:pass@host'
VGR_GUEST_USER
If this environment variable is set, the command will use its value
as the user to login on the guest. The --guest-user
option has precedence over the environment variable.
VGR_GUEST_PASSWORD
If this environment variable is set, the command will use its value
as the password to login on the guest. The --guest-password
option has precedence over the environment variable.
""" # NOQA
if ctx.invoked_subcommand is None:
click.secho(ctx.get_help())
return
if not verify_ssl_certs:
if disable_warnings:
pass
else:
click.secho(
'InsecureRequestWarning: '
'Unverified HTTPS request is being made. '
'Adding certificate verification is strongly '
'advised.',
fg='yellow',
err=True)
requests.packages.urllib3.disable_warnings()
tokens = url.split(':')
vc_user = tokens[0]
tokens = tokens[1].split('@')
vc_host = tokens[-1]
vc_password = ''
for token in tokens[:-1]:
if len(vc_password) > 0:
vc_password += '@'
vc_password += token
vs = VSphere(vc_host, vc_user, vc_password, verify=verify_ssl_certs)
ctx.obj = {}
ctx.obj['vs'] = vs
def create_template(ctx, config, client, org, vdc_resource, catalog,
no_capture, template):
ctx.obj = {}
ctx.obj['client'] = client
try:
source_ova_item = org.get_catalog_item(config['broker']['catalog'],
template['source_ova_name'])
except Exception:
source_ova_item = upload_source_ova(config, client, org, template)
click.secho('Find source ova \'%s\': %s' %
(template['source_ova_name'],
bool_to_msg(source_ova_item is not None)))
if source_ova_item is None:
return None
item_id = source_ova_item.get('id')
flag = False
while True:
q = client.get_typed_query(
'adminCatalogItem',
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='id==%s' % item_id)
records = list(q.execute())
if records[0].get('status') == 'RESOLVED':
if flag:
click.secho('done', fg='blue')
break
else:
if flag:
click.secho('.', nl=False, fg='green')
else:
click.secho(
'Waiting for upload to complete...', nl=False, fg='green')
flag = True
time.sleep(5)
vdc = VDC(client, resource=vdc_resource)
try:
vapp_resource = vdc.get_vapp(template['temp_vapp'])
except Exception:
vapp_resource = None
if vapp_resource is None:
click.secho(
'Creating vApp template \'%s\'' % template['temp_vapp'],
fg='green')
init_script = get_data_file('init-%s.sh' % template['name'])
vapp_resource = vdc.instantiate_vapp(
template['temp_vapp'],
catalog.get('name'),
template['source_ova_name'],
network=config['broker']['network'],
fence_mode='bridged',
ip_allocation_mode=config['broker']['ip_allocation_mode'],
deploy=True,
power_on=True,
memory=template['mem'],
cpu=template['cpu'],
password=None,
cust_script=init_script,
accept_all_eulas=True,
vm_name=template['temp_vapp'],
hostname=template['temp_vapp'],
storage_profile=config['broker']['storage_profile'])
stdout(vapp_resource.Tasks.Task[0], ctx)
vapp = VApp(client, resource=vapp_resource)
vapp.reload()
moid = vapp.get_vm_moid(template['temp_vapp'])
vs = VSphere(
config['vcs']['host'],
config['vcs']['username'],
config['vcs']['password'],
port=int(config['vcs']['port']))
vs.connect()
vm = vs.get_vm_by_moid(moid)
vs.wait_until_tools_ready(
vm, sleep=5, callback=wait_for_tools_ready_callback)
click.secho(
'Customizing vApp template \'%s\'' % template['temp_vapp'],
fg='green')
vapp.reload()
password_auto = vapp.get_admin_password(template['temp_vapp'])
cust_script = get_data_file('cust-%s.sh' % template['name'])
result = vs.execute_script_in_guest(
vm,
'root',
password_auto,
cust_script,
target_file=None,
wait_for_completion=True,
wait_time=10,
get_output=True,
delete_script=True,
callback=wait_for_guest_execution_callback)
click.secho('Result: %s' % result, fg='green')
result_stdout = result[1].content.decode()
result_stderr = result[2].content.decode()
click.secho('stderr:')
if len(result_stderr) > 0:
click.secho(result_stderr, err=True)
click.secho('stdout:')
if len(result_stdout) > 0:
click.secho(result_stdout, err=False)
if not no_capture:
capture_as_template(ctx, config, vapp_resource, org, catalog, template)
if template['cleanup']:
click.secho(
'Deleting vApp template \'%s\' ' % template['temp_vapp'],
fg='green')
vdc.reload()
task = vdc.delete_vapp(template['temp_vapp'], force=True)
stdout(task, ctx)
def _validate_vcd_and_vcs_config(vcd_dict, vcs, msg_update_callback=None):
"""Ensure that 'vcd' and vcs' section of config are correct.
Checks that 'vcd' and 'vcs' section of config have correct keys and value
types. Also checks that vCD and all registered VCs in vCD are accessible.
:param dict vcd_dict: 'vcd' section of config file as a dict.
:param list vcs: 'vcs' section of config file as a list of dicts.
:param utils.ConsoleMessagePrinter msg_update_callback: Callback object
that writes messages onto console.
:raises KeyError: if @vcd_dict or a vc in @vcs has missing or
extra properties.
:raises TypeError: if the value type for a @vcd_dict or vc property
is incorrect.
:raises ValueError: if vCD has a VC that is not listed in the config file.
"""
check_keys_and_value_types(vcd_dict,
SAMPLE_VCD_CONFIG['vcd'],
location="config file 'vcd' section",
msg_update_callback=msg_update_callback)
if not vcd_dict['verify']:
if msg_update_callback:
msg_update_callback.general(
'InsecureRequestWarning: Unverified HTTPS request is '
'being made. Adding certificate verification is '
'strongly advised.')
requests.packages.urllib3.disable_warnings()
client = None
try:
# TODO() we get an error during client initialization if the specified
# logfile points to the directory which doesn't exist. This issue
# should be fixed in pyvcloud, where the logging setup creates
# directories used in the log filepath if they do not exist yet.
setup_log_file_directory()
client = Client(vcd_dict['host'],
api_version=vcd_dict['api_version'],
verify_ssl_certs=vcd_dict['verify'],
log_file=SERVER_DEBUG_WIRELOG_FILEPATH,
log_requests=True,
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(vcd_dict['username'], SYSTEM_ORG_NAME,
vcd_dict['password']))
if msg_update_callback:
msg_update_callback.general(
"Connected to vCloud Director "
f"({vcd_dict['host']}:{vcd_dict['port']})")
for index, vc in enumerate(vcs, 1):
check_keys_and_value_types(
vc,
SAMPLE_VCS_CONFIG['vcs'][0],
location=f"config file 'vcs' section, vc #{index}",
msg_update_callback=msg_update_callback)
# Check that all registered VCs in vCD are listed in config file
platform = Platform(client)
config_vc_names = [vc['name'] for vc in vcs]
for platform_vc in platform.list_vcenters():
platform_vc_name = platform_vc.get('name')
if platform_vc_name not in config_vc_names:
raise ValueError(f"vCenter '{platform_vc_name}' registered in "
f"vCD but not found in config file")
# Check that all VCs listed in config file are registered in vCD
for vc in vcs:
vcenter = platform.get_vcenter(vc['name'])
vsphere_url = urlparse(vcenter.Url.text)
v = VSphere(vsphere_url.hostname, vc['username'], vc['password'],
vsphere_url.port)
v.connect()
if msg_update_callback:
msg_update_callback.general(
f"Connected to vCenter Server '{vc['name']}' as "
f"'{vc['username']}' ({vsphere_url.hostname}:"
f"{vsphere_url.port})")
finally:
if client is not None:
client.logout()
