def add_vm(ctx, name, source_vapp, source_vm, catalog, target_vm, hostname,
network, ip_allocation_mode, storage_profile, password_auto,
accept_all_eulas):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
source_vapp_resource = None
if catalog is None:
source_vapp_resource = vdc.get_vapp(source_vapp)
else:
catalog_item = org.get_catalog_item(catalog, source_vapp)
source_vapp_resource = client.get_resource(
catalog_item.Entity.get('href'))
assert source_vapp_resource is not None
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
spec = {'source_vm_name': source_vm, 'vapp': source_vapp_resource}
if target_vm is not None:
spec['target_vm_name'] = target_vm
if hostname is not None:
spec['hostname'] = hostname
if network is not None:
spec['network'] = network
spec['ip_allocation_mode'] = ip_allocation_mode
if storage_profile is not None:
spec['storage_profile'] = vdc.get_storage_profile(storage_profile)
if password_auto is not None:
spec['password_auto'] = password_auto
task = vapp.add_vms([spec], all_eulas_accepted=accept_all_eulas)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def vapp_exists(vapp_name):
vdc = VDC(CLIENT, href=VDC_HREF)
try:
vdc.get_vapp(vapp_name)
return True
except EntityNotFoundException:
return False
def test_0090_install_all_templates(config, unregister_cse_before_test):
"""Test install.
Installation options: '--ssh-key', '--retain-temp-vapp',
'--skip-config-decryption'.
Tests that installation:
- downloads/uploads ova file,
- creates photon temp vapp,
- creates k8s templates
- skips deleting the temp vapp
- checks that proper packages are installed in the vm in temp vApp
command: cse install --config cse_test_config.yaml --retain-temp-vapp
--skip-config-decryption --ssh-key ~/.ssh/id_rsa.pub
required files: ~/.ssh/id_rsa.pub, cse_test_config.yaml
expected: cse registered, catalog exists, source OVAs exist,
temp vapps exist, k8s templates exist.
"""
cmd = f"install --config {env.ACTIVE_CONFIG_FILEPATH} --ssh-key " \
f"{env.SSH_KEY_FILEPATH} --retain-temp-vapp --skip-config-decryption"
result = env.CLI_RUNNER.invoke(cli, cmd.split(), catch_exceptions=False)
PYTEST_LOGGER.debug(f"Executing command: {cmd}")
PYTEST_LOGGER.debug(f"Exit code: {result.exit_code}")
PYTEST_LOGGER.debug(f"Output: {result.output}")
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that cse was registered correctly
env.check_cse_registration_as_mqtt_extension()
remote_template_keys = server_utils.get_template_descriptor_keys(
env.TEMPLATE_COOKBOOK_VERSION)
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
for template_config in env.TEMPLATE_DEFINITIONS:
# check that source ova file exists in catalog
assert env.catalog_item_exists(
template_config[remote_template_keys.SOURCE_OVA_NAME],
logger=PYTEST_LOGGER), \
'Source ova file does not exist when it should.'
# check that k8s templates exist
catalog_item_name = ltm.get_revisioned_template_name(
template_config[remote_template_keys.NAME],
template_config[remote_template_keys.REVISION])
assert env.catalog_item_exists(
catalog_item_name, logger=PYTEST_LOGGER), \
'k8s template does not exist when it should.'
# check that temp vapp exists
temp_vapp_name = testutils.get_temp_vapp_name(
template_config[remote_template_keys.NAME])
try:
vdc.reload()
vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should.'
def test_0100_install_select_templates(config, unregister_cse_before_test):
"""Tests template installation.
Tests that selected template installation is done correctly
command: cse template install template_name template_revision
--config cse_test_config.yaml --ssh-key ~/.ssh/id_rsa.pub
--skip-config-decryption --retain-temp-vapp
required files: cse_test_config.yaml, ~/.ssh/id_rsa.pub,
ubuntu/photon init/cust scripts
expected: cse registered, source ovas exist, k8s templates exist and
temp vapps exist.
"""
cmd = f"install --config {env.ACTIVE_CONFIG_FILEPATH} --ssh-key " \
f"{env.SSH_KEY_FILEPATH} --skip-template-creation " \
f"--skip-config-decryption"
result = env.CLI_RUNNER.invoke(cli, cmd.split(), catch_exceptions=False)
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that cse was registered correctly
env.check_cse_registration(config['amqp']['routing_key'],
config['amqp']['exchange'])
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
for template_config in env.TEMPLATE_DEFINITIONS:
# install the template
cmd = f"template install {template_config['name']} " \
f"{template_config['revision']} " \
f"--config {env.ACTIVE_CONFIG_FILEPATH} " \
f"--ssh-key {env.SSH_KEY_FILEPATH} " \
f"--skip-config-decryption --force --retain-temp-vapp"
result = env.CLI_RUNNER.invoke(
cli, cmd.split(), catch_exceptions=False)
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that source ova file exists in catalog
assert env.catalog_item_exists(
template_config['source_ova_name']), \
'Source ova file does not exists when it should.'
# check that k8s templates exist
catalog_item_name = ltm.get_revisioned_template_name(
template_config['name'], template_config['revision'])
assert env.catalog_item_exists(catalog_item_name), \
'k8s template does not exist when it should.'
# check that temp vapp exists
temp_vapp_name = testutils.get_temp_vapp_name(
template_config['name'])
try:
vdc.reload()
vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should.'
def vapp_exists(vapp_name, vdc_href, logger=NULL_LOGGER):
vdc = VDC(CLIENT, href=vdc_href)
try:
vdc.get_vapp(vapp_name)
logger.debug(f"Vapp {vapp_name} found in vdc {vdc.name}")
return True
except EntityNotFoundException:
logger.warning(f"Vapp {vapp_name} not found in vdc {vdc.name}")
return False
def test_0100_install_select_templates(config):
"""Tests template installation.
Tests that selected template installation is done correctly
command: cse template install template_name template_revision
--config cse_test_config.yaml --ssh-key ~/.ssh/id_rsa.pub
--skip-config-decryption --retain-temp-vapp
required files: cse_test_config.yaml, ~/.ssh/id_rsa.pub,
ubuntu/photon init/cust scripts
expected: cse registered, source OVAs exist, k8s templates exist and
temp vapps exist.
"""
# check that cse was registered correctly
env.check_cse_registration_as_mqtt_extension()
remote_template_keys = server_utils.get_template_descriptor_keys(
env.TEMPLATE_COOKBOOK_VERSION)
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
for template_config in env.TEMPLATE_DEFINITIONS:
# install the template
cmd = f"template install {template_config[remote_template_keys.NAME]} " \
f"{template_config['revision']} " \
f"--config {env.ACTIVE_CONFIG_FILEPATH} " \
f"--ssh-key {env.SSH_KEY_FILEPATH} " \
f"--skip-config-decryption --force --retain-temp-vapp" # noqa: E501
result = env.CLI_RUNNER.invoke(
cli, cmd.split(), catch_exceptions=False)
PYTEST_LOGGER.debug(f"Executing command: {cmd}")
PYTEST_LOGGER.debug(f"Exit code: {result.exit_code}")
PYTEST_LOGGER.debug(f"Output: {result.output}")
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that source ova file exists in catalog
assert env.catalog_item_exists(
template_config[remote_template_keys.SOURCE_OVA_NAME],
logger=PYTEST_LOGGER), \
'Source ova file does not exists when it should.'
# check that k8s templates exist
catalog_item_name = ltm.get_revisioned_template_name(
template_config[remote_template_keys.NAME],
template_config[remote_template_keys.REVISION])
assert env.catalog_item_exists(
catalog_item_name, logger=PYTEST_LOGGER), \
'k8s template does not exist when it should.'
# check that temp vapp exists
temp_vapp_name = testutils.get_temp_vapp_name(
template_config[remote_template_keys.NAME])
try:
vdc.reload()
vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should.'
def test_0090_install_all_templates(config, unregister_cse_before_test):
"""Test install.
Installation options: '--ssh-key', '--retain-temp-vapp',
'--skip-config-decryption'.
Tests that installation:
- downloads/uploads ova file,
- creates photon temp vapp,
- creates k8s templates
- skips deleting the temp vapp
- checks that proper packages are installed in the vm in temp vApp
command: cse install --config cse_test_config.yaml --retain-temp-vapp
--skip-config-decryption --ssh-key ~/.ssh/id_rsa.pub
required files: ~/.ssh/id_rsa.pub, cse_test_config.yaml
expected: cse registered, catalog exists, source ovas exist,
temp vapps exist, k8s templates exist.
"""
cmd = f"install --config {env.ACTIVE_CONFIG_FILEPATH} --ssh-key " \
f"{env.SSH_KEY_FILEPATH} --retain-temp-vapp --skip-config-decryption"
result = env.CLI_RUNNER.invoke(cli, cmd.split(),
catch_exceptions=False)
assert result.exit_code == 0,\
testutils.format_command_info('cse', cmd, result.exit_code,
result.output)
# check that cse was registered correctly
env.check_cse_registration(config['amqp']['routing_key'],
config['amqp']['exchange'])
vdc = VDC(env.CLIENT, href=env.VDC_HREF)
for template_config in env.TEMPLATE_DEFINITIONS:
# check that source ova file exists in catalog
assert env.catalog_item_exists(
template_config['source_ova_name']), \
'Source ova file does not exist when it should.'
# check that k8s templates exist
catalog_item_name = ltm.get_revisioned_template_name(
template_config['name'], template_config['revision'])
assert env.catalog_item_exists(catalog_item_name), \
'k8s template does not exist when it should.'
# check that temp vapp exists
temp_vapp_name = testutils.get_temp_vapp_name(
template_config['name'])
try:
vdc.reload()
vdc.get_vapp(temp_vapp_name)
except EntityNotFoundException:
assert False, 'vApp does not exist when it should.'
def test_11_change_owner(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
user_resource = org.get_user(self.config['vcd']['new_vapp_user'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
vapp.change_owner(user_resource.get('href'))
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['new_vapp_user'] == \
vapp_resource.Owner.User.get('name')
def test_11_change_owner(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
user_resource = org.get_user(self.config['vcd']['new_vapp_user'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
vapp.change_owner(user_resource.get('href'))
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['new_vapp_user'] == \
vapp_resource.Owner.User.get('name')
def test_100_instantiate_vapp_identical(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
result = vdc.instantiate_vapp(
self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network=self.config['vcd']['network'],
fence_mode='bridged',
deploy=True,
power_on=False,
identical=True)
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
vdc.reload()
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vm = vapp_resource.xpath(
'//vcloud:VApp/vcloud:Children/vcloud:Vm', namespaces=NSMAP)
assert len(vm) > 0
assert vm[0].get('name') == self.config['vcd']['vm']
def test_0002_add_vm(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms)
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def delete_vm(client):
print("================= Vdc delete request ===================")
vdc_name = "pcp_vdc_02"
target_vm_name = "pcp_vm"
org_resource = client.get_org()
org = Org(client, resource=org_resource)
print("Org name: ", org.get_name())
print("Vdc name: ", vdc_name)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, name=vdc_name, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, name=vapp_name, resource=vapp_resource)
delete_vapp_vm_resp = vapp.delete_vms(target_vm_name)
task = client.get_task_monitor().wait_for_status(
task=delete_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
message = 'delete vdc status : {0} '.format(st)
logging.info(message)
else:
raise errors.VCDVdcDeleteError(etree.tostring(task, pretty_print=True))
def vcd_login(host, user, password, org):
logging.basicConfig(level=logging.DEBUG)
logging.info("login called")
client = Client(host,
api_version="27.0",
verify_ssl_certs=False,
log_file='vcd.log',
log_requests=True,
log_headers=True,
log_bodies=True)
try:
client.set_credentials(BasicLoginCredentials(user, org, password))
x = client._session.headers['x-vcloud-authorization']
logging.info(" ===== X VCloud ========\n \n" + x + "\n \n")
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc('OVD2')
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp('cento_vapp11_2')
nconfig_section = vapp.NetworkConfigSection
nconfig = nconfig_section.findall(
"{http://www.vmware.com/vcloud/v1.5}NetworkConfig")
for i in range(0, len(nconfig)):
print(nconfig[i].get('networkName'))
##print(etree.tostring(nconfig[0], pretty_print=True))
#pRes= catalog.isPresent(client,"c1")
# res=catalog.create(client,"c44","c44",True)
#logging.info(" is create ===== \n \n "+ str(res.created)+ "\n \n ")
#logging.info("\n\n=====callling upload ova===\n")
#catalog_item.upload_ova(client,"c44","/home/iso/tiny.ova",item_name="tiny3.ova")
#logging.info("\n\n=====upload done ===\n ")
#logging.info(" Delete ===== \n \n "+ str(catalog.delete(client,"c3").deleted)+ "\n \n ")
#logging.info(" Delete ===== \n \n "+ str(catalog.delete(client,"c4").deleted)+ "\n \n ")
#vappInfo=pyvcloudprovider_pb2.CreateVAppInfo()
#vappInfo.name="vappacc2"
#vappInfo.catalog_name="c1"
#vappInfo.template_name="cento_tmpl1"
#vapp.create(client,vappInfo)
#delVappInfo=pyvcloudprovider_pb2.DeleteVAppInfo()
#delVappInfo.name="vappacc2"
#vapp.delete(client,delVappInfo)
#ovaInfo=pyvcloudprovider_pb2.CatalogUploadOvaInfo()
#ovaInfo.item_name="item1"
#ovaInfo.catalog_name="testcata1"
#ovaInfo.file_path="/Users/srinarayana/vmws/tiny.ova"
# catalog_item.ova_check_resolved(client,ovaInfo)
#vappInfo.template_name="cento_tmpl1"
#vapp.create(client,vappInfo)
return client
except Exception as e:
print('error occured', e)
def capture_vapp(self):
params = self.params
vapp_name = params.get('vapp_name')
vdc_name = params.get('vdc_name')
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
desc = params.get('description')
customize_on_instantiate = params.get('customize_on_instantiate')
overwrite = params.get('overwrite')
client = self.client
response = dict()
response['changed'] = False
v = self.org.get_vdc(vdc_name)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
catalog = self.org.get_catalog(catalog_name)
self.org.capture_vapp(
catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate,
overwrite=overwrite)
self.ova_check_resolved()
response['msg'] = "Catalog Item {} has been captured".format(item_name)
response['changed'] = True
return response
def test_060_attach_disk_to_vm_in_vapp(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['vapp'] == vapp_resource.get('name')
vapp = VApp(self.client, resource=vapp_resource)
disk = vdc.get_disk(self.config['vcd']['idisk_name'])
result = vapp.attach_disk_to_vm(disk_href=disk.get('href'),
vm_name=self.config['vcd']['vm'])
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def capture(ctx, name, catalog, template, customizable, description):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
catalog_resource = org.get_catalog(catalog)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
overwrite = False
if template is None:
template = vapp_resource.get('name')
else:
overwrite = True
task = org.capture_vapp(
catalog_resource,
vapp_href=vapp_resource.get('href'),
catalog_item_name=template,
description=description,
customize_on_instantiate=customizable == 'customizable',
overwrite=overwrite)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def read(self, request):
logging.info("__INIT__read[VappVm]")
res = vapp_vm_pb2.ReadVappVmResult()
res.present = False
org_resource = self.client.get_org()
org = Org(self.client, resource=org_resource)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(
self.client, name=request.target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(
self.client, name=request.target_vapp, resource=vapp_resource)
read_vapp_vm_resp = vapp.get_vm(request.target_vm_name)
vm = VM(client=self.client, href=None, resource=read_vapp_vm_resp)
res.present = True
except Exception as e:
errmsg = '__ERROR_read[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
return res
logging.info("__DONE__read[VappVm]")
return res
def capture_vapp(self):
params = self.params
vapp_name = params.get('vapp_name')
vdc_name = params.get('vdc_name')
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
desc = params.get('description')
customize_on_instantiate = params.get('customize_on_instantiate')
overwrite = params.get('overwrite')
client = self.client
response = dict()
response['changed'] = False
v = self.org.get_vdc(vdc_name)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
catalog = self.org.get_catalog(catalog_name)
self.org.capture_vapp(
catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate,
overwrite=overwrite)
self.ova_check_resolved()
response['msg'] = "Catalog Item {} has been captured".format(item_name)
response['changed'] = True
return response
def test_0002_add_vm(self):
org_resource = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
self.logger.debug('org: %s' % org_resource.get('name'))
org = Org(self.client, href=org_resource.get('href'))
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
catalog_item = org.get_catalog_item(self.config['vcd']['catalog'],
self.config['vcd']['template'])
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
spec = {
'source_vm_name': self.config['vcd']['vm'],
'vapp': source_vapp_resource
}
spec['target_vm_name'] = self.config['vcd']['hostname']
spec['hostname'] = self.config['vcd']['hostname']
spec['network'] = self.config['vcd']['network']
spec['ip_allocation_mode'] = self.config['vcd']['ip_allocation_mode']
spec['storage_profile'] = vdc.get_storage_profile(
self.config['vcd']['storage_profile'])
vms = [spec]
result = vapp.add_vms(vms, all_eulas_accepted=True)
task = self.client.get_task_monitor().wait_for_status(task=result)
assert task.get('status') == TaskStatus.SUCCESS.value
def capture(ctx, name, catalog, template, customizable, description):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
catalog_resource = org.get_catalog(catalog)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
overwrite = False
if template is None:
template = vapp_resource.get('name')
else:
overwrite = True
task = org.capture_vapp(
catalog_resource,
vapp_href=vapp_resource.get('href'),
catalog_item_name=template,
description=description,
customize_on_instantiate=customizable == 'customizable',
overwrite=overwrite)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def capture_vapp(client, context, capture_info):
logging.debug("__INIT__capture_vapp [%s]", capture_info)
vapp_name = capture_info.vapp_name
vdc_name = capture_info.vdc_name
catalog_name = capture_info.catalog_name
item_name = capture_info.item_name
desc = capture_info.description
customize_on_instantiate = capture_info.customize_on_instantiate
result = catalog_item_pb2.CaptureVAppResult()
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vdc_name)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
logging.info(vapp.get('href'))
catalog = org.get_catalog(catalog_name)
org.capture_vapp(catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate)
result.captured = True
logging.debug("__DONE__capture_vapp [%s] , [%s] , [%s] ", vapp_name,
vdc_name, catalog_name)
return result
except Exception as e:
error_message = 'ERROR.. capture vapp failed {0} {1} {2}'.format(
vapp_name, vdc_name, catalog_name)
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
def test_0160_move_to(self):
org = Environment.get_test_org(TestVApp._client)
target_vdc = org.get_vdc(TestVApp._ovdc_name)
logger = Environment.get_default_logger()
vapp = Environment.get_vapp_in_test_vdc(
client=TestVApp._sys_admin_client,
vapp_name=TestVApp._customized_vapp_name)
logger.debug('Move vApp ' + TestVApp._customized_vapp_name)
task = vapp.move_to(target_vdc.get('href'))
result = TestVApp._sys_admin_client.get_task_monitor(
).wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
target_vdc = org.get_vdc(TestVApp._ovdc_name)
target_vdc_obj = VDC(TestVApp._sys_admin_client,
href=target_vdc.get('href'))
vapp_resource = target_vdc_obj.get_vapp(TestVApp._customized_vapp_name)
vapp = VApp(TestVApp._sys_admin_client, resource=vapp_resource)
target_vdc = Environment.get_test_vdc(TestVApp._client)
logger.debug('Move back vApp ' + TestVApp._customized_vapp_name)
task = vapp.move_to(target_vdc.href)
result = TestVApp._sys_admin_client.get_task_monitor(
).wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def count_vcloud(self, client):
"""
Obtain counts via vCloud API. Multiple dependent requests are needed therefore
we collect them all in one pass to avoid repeating previous requests e.g. to
fetch VMs, one must first fetch vApps and vdcs.
:param client:
:return:
"""
org_resource = client.get_org()
org = Org(client, resource=org_resource)
stats = {
'num_availability_zone': 0,
'num_orchestration_stack': 0,
'num_vm': 0
}
for vdc_info in org.list_vdcs():
stats['num_availability_zone'] += 1
vdc = VDC(client, resource=org.get_vdc(vdc_info['name']))
for vapp_info in vdc.list_resources():
try:
vapp_resource = vdc.get_vapp(vapp_info.get('name'))
except Exception:
continue # not a vapp (probably vapp template or something)
vapp = VApp(client, resource=vapp_resource)
stats['num_orchestration_stack'] += 1
stats['num_vm'] += len(vapp.get_all_vms())
return stats
def test_100_instantiate_vapp_identical(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
result = vdc.instantiate_vapp(self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network=self.config['vcd']['network'],
fence_mode='bridged',
deploy=True,
power_on=False,
identical=True)
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
# vdc.reload()
vdc.resource = vdc.client.get_resource(vdc.href)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vm = vapp_resource.xpath('//vcloud:VApp/vcloud:Children/vcloud:Vm',
namespaces=NSMAP)
assert len(vm) > 0
assert vm[0].get('name') == self.config['vcd']['vm']
def GetvAppObj(parameters, client, virtual_machine):
"""
Get vApp Object
"""
try:
# Get the org object that corresponds with the org provided at runtime
org_resource = client.get_org()
org = Org(client, resource=org_resource)
# Get the VDC object that correspondes with the VDC provided at runtime
vdc_resource = org.get_vdc(parameters['VCD_VDC'])
vdc = VDC(client, resource=vdc_resource)
# Loop through all vApps until matching virtual machine is found, return vapp
vapps = vdc.list_resources(EntityType.VAPP)
for vapp in vapps:
vapp_name = vapp.get('name')
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
for vm in vapp.get_all_vms():
if vm.get('name') == virtual_machine:
return vapp
except Exception as e:
print("ERROR: Failed To Get vApp Object For Virtual Machine: '" +
virtual_machine + "'")
print(e)
exit(1)
def test_0001_modify_cpu(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
vm_resource = vapp.get_vm(self.config['vcd']['vm'])
vm = VM(self.client, resource=vm_resource)
task = vm.modify_cpu(self.config['vcd']['cpu'],
self.config['vcd']['cores_per_socket'])
task = self.client.get_task_monitor().wait_for_status(
task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
vm.reload()
cpus = vm.get_cpus()
assert cpus['num_cpus'] == self.config['vcd']['cpu']
assert cpus['num_cores_per_socket'] == self.config['vcd'][
'cores_per_socket']
def test_1006_snapshot_create(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
vm_resource = vapp.get_vm(self.config['vcd']['vm'])
assert vm_resource.get('name') == self.config['vcd']['vm']
vm = VM(self.client, resource=vm_resource)
task = vm.snapshot_create(memory=False, quiesce=False)
task = self.client.get_task_monitor().wait_for_status(
task=task,
timeout=120,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_0002_modify_memory(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
vm_resource = vapp.get_vm(self.config['vcd']['vm'])
vm = VM(self.client, resource=vm_resource)
task = vm.modify_memory(self.config['vcd']['memory'])
task = self.client.get_task_monitor().wait_for_status(
task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
vm.reload()
assert vm.get_memory() == self.config['vcd']['memory']
def test_060_attach_disk_to_vm_in_vapp(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['vapp'] == vapp_resource.get('name')
vapp = VApp(self.client, resource=vapp_resource)
disk = vdc.get_disk(self.config['vcd']['idisk_name'])
result = vapp.attach_disk_to_vm(disk_href=disk.get('href'),
vm_name=self.config['vcd']['vm'])
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_1002_deploy_vm(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert vapp_resource.get('name') == self.config['vcd']['vapp']
vapp = VApp(self.client, resource=vapp_resource)
vm_resource = vapp.get_vm(self.config['vcd']['vm'])
vm = VM(self.client, resource=vm_resource)
result = vm.deploy()
# result = vm.shutdown()
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def delete_vm(client):
print("================= Vdc delete request ===================")
vdc_name = "pcp_vdc_02"
target_vm_name = "pcp_vm"
org_resource = client.get_org()
org = Org(client, resource=org_resource)
print("Org name: ", org.get_name())
print("Vdc name: ", vdc_name)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, name=vdc_name, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, name=vapp_name, resource=vapp_resource)
delete_vapp_vm_resp = vapp.delete_vms(target_vm_name)
task = client.get_task_monitor().wait_for_status(task=delete_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS,
TaskStatus.ABORTED,
TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
message = 'delete vdc status : {0} '.format(st)
logging.info(message)
else:
raise errors.VCDVdcDeleteError(etree.tostring(task, pretty_print=True))
def instantiate_vapp(cls):
"""Instantiates the test template in the test catalog.
This template will be used to create the test vApp. if the vApp already
exists then skips creating it.
:raises: Exception: if the class variable _ovdc_href is not populated.
"""
cls._basic_check()
if cls._ovdc_href is None:
raise Exception('OVDC ' + cls._config['vcd']['default_ovdc_name'] +
' doesn\'t exist.')
try:
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
vdc = VDC(catalog_author_client, href=cls._ovdc_href)
vapp_name = cls._config['vcd']['default_vapp_name']
vapp_resource = vdc.get_vapp(vapp_name)
cls._logger.debug('Reusing existing vApp ' + vapp_name + '.')
cls._vapp_href = vapp_resource.get('href')
except EntityNotFoundException as e:
cls._logger.debug('Instantiating vApp ' + vapp_name + '.')
cls._vapp_href = create_vapp_from_template(
client=catalog_author_client,
vdc=vdc,
name=vapp_name,
catalog_name=cls._config['vcd']['default_catalog_name'],
template_name=cls._config['vcd']['default_template_file_name'])
finally:
catalog_author_client.logout()
def read(self, request):
logging.info("__INIT__read[VappVm]")
res = vapp_vm_pb2.ReadVappVmResult()
res.present = False
org_resource = self.client.get_org()
org = Org(self.client, resource=org_resource)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(self.client, name=request.target_vdc,
resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(self.client, name=request.target_vapp,
resource=vapp_resource)
read_vapp_vm_resp = vapp.get_vm(request.target_vm_name)
vm = VM(client=self.client, href=None, resource=read_vapp_vm_resp)
res.present = True
except Exception as e:
errmsg = '__ERROR_read[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
return res
logging.info("__DONE__read[VappVm]")
return res
def get_vm(self, vm_name):
vapp_name = self.params.get('vapp_name')
vdc_name = self.params.get('vdc_name')
vdc_resource = VDC(self.client, resource=self.org.get_vdc(vdc_name))
vapp_resource = vdc_resource.get_vapp(vapp_name)
vapp = VApp(self.client, resource=vapp_resource)
return VM(self.client, resource=vapp.get_vm(vm_name))
def test_1006_unshare_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.unshare_from_org_members()
assert control_access.IsSharedToEveryone.text == 'false'
def test_1003_get_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.get_access_settings()
assert len(control_access.AccessSettings.AccessSetting) == 2
def test__1001_vapp_control_access_retrieval(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
access_control_settings = vapp.get_access_control_settings()
assert len(access_control_settings) > 0
def test_1003_get_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.get_access_settings()
assert len(control_access.AccessSettings.AccessSetting) == 2
def test_1006_unshare_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.unshare_from_org_members()
assert control_access.IsSharedToEveryone.text == 'false'
def test_1001_remove_all_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.remove_access_settings(remove_all=True)
self.assertFalse(hasattr(control_access, 'AccessSettings'))
def test_1001_remove_all_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.remove_access_settings(remove_all=True)
self.assertFalse(hasattr(control_access, 'AccessSettings'))
def get_target_resource(self):
target_vapp = self.params.get('vapp')
target_vdc = self.params.get('vdc')
org_resource = Org(self.client, resource=self.client.get_org())
target_vapp_resource = None
target_vdc_resource = VDC(self.client,
resource=org_resource.get_vdc(target_vdc))
target_vapp_resource = target_vdc_resource.get_vapp(target_vapp)
return target_vapp_resource
def delete(self, request):
logging.info("__INIT__delete[VappVm]")
res = vapp_vm_pb2.DeleteVappVmResult()
res.deleted = False
org_resource = self.client.get_org()
org = Org(self.client, resource=org_resource)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(
self.client, name=request.target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(
self.client, name=request.target_vapp, resource=vapp_resource)
# Before deleting power_off vm
# self.power_off(request.target_vdc, request.target_vapp)
# Before deleting undeploy vm
self.undeploy(request)
vms = [request.target_vm_name]
delete_vapp_vm_resp = vapp.delete_vms(vms)
task = self.client.get_task_monitor().wait_for_status(
task=delete_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmDeleteError(
etree.tostring(task, pretty_print=True))
message = 'delete vapp_vm status : {0} '.format(st)
logging.info(message)
res.deleted = True
except Exception as e:
res.deleted = False
errmsg = '__ERROR_delete[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
return res
logging.info("__DONE__delete[VappVm]")
return res
def delete(self, request):
logging.info("__INIT__delete[VappVm]")
res = vapp_vm_pb2.DeleteVappVmResult()
res.deleted = False
org_resource = self.client.get_org()
org = Org(self.client, resource=org_resource)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(self.client, name=request.target_vdc,
resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(self.client, name=request.target_vapp,
resource=vapp_resource)
# Before deleting power_off vm
# self.power_off(request.target_vdc, request.target_vapp)
# Before deleting undeploy vm
self.undeploy(request)
vms = [request.target_vm_name]
delete_vapp_vm_resp = vapp.delete_vms(vms)
task = self.client.get_task_monitor().wait_for_status(
task=delete_vapp_vm_resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmDeleteError(
etree.tostring(task, pretty_print=True))
message = 'delete vapp_vm status : {0} '.format(st)
logging.info(message)
res.deleted = True
except Exception as e:
res.deleted = False
errmsg = '__ERROR_delete[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
return res
logging.info("__DONE__delete[VappVm]")
return res
def get_vm(self):
vapp_name = self.params.get('vapp_name')
vdc_name = self.params.get('vdc_name')
vm_name = self.params.get('vm_name')
org_resource = Org(self.client, resource=self.client.get_org())
vdc_resource = VDC(self.client,
resource=org_resource.get_vdc(vdc_name))
vapp_resource = vdc_resource.get_vapp(vapp_name)
vapp = VApp(self.client, resource=vapp_resource)
return VM(self.client, resource=vapp.get_vm(vm_name))
def test_0007_delete(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
task = vapp.delete_vms([self.config['vcd']['vm']])
task = self.client.get_task_monitor().wait_for_status(task)
assert task.get('status') == TaskStatus.SUCCESS.value
def get_target_resource(self):
target_vapp = self.params.get('target_vapp')
target_vdc = self.params.get('target_vdc')
org_resource = Org(self.client, resource=self.client.get_org())
target_vapp_resource = None
target_vdc_resource = VDC(
self.client, resource=org_resource.get_vdc(target_vdc))
target_vapp_resource = target_vdc_resource.get_vapp(target_vapp)
return target_vapp_resource
def test_1005_share_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.share_with_org_members(
everyone_access_level='ReadOnly')
assert control_access.IsSharedToEveryone.text == 'true'
assert control_access.EveryoneAccessLevel.text == 'ReadOnly'
def add_disk(ctx, name, vm_name, size, storage_profile):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.add_disk_to_vm(vm_name, size)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def disconnect(ctx, name, network):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.disconnect_org_vdc_network(network)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_1004_remove_vapp_access(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
control_access = vapp.remove_access_settings(
access_settings_list=[
{'name': self.config['vcd']['access_user'], 'type': 'user'}
])
assert len(control_access.AccessSettings.AccessSetting) == 1
def test_110_instantiate_vapp_custom_disk_size(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
result = vdc.instantiate_vapp(
self.config['vcd']['vapp'],
self.config['vcd']['catalog'],
self.config['vcd']['template'],
network=self.config['vcd']['network'],
fence_mode='bridged',
deploy=True,
power_on=False,
disk_size=self.config['vcd']['disk_size_new'])
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
vdc.resource = vdc.client.get_resource(vdc.href)
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vms = vapp_resource.xpath(
'//vcloud:VApp/vcloud:Children/vcloud:Vm', namespaces=NSMAP)
assert len(vms) > 0
items = vms[0].xpath(
'//ovf:VirtualHardwareSection/ovf:Item',
namespaces={
'ovf': NSMAP['ovf']
})
assert len(items) > 0
found_disk = False
for item in items:
if item['{' + NSMAP['rasd'] + '}ResourceType'] == 17: # NOQA
found_disk = True
assert item['{' + NSMAP['rasd'] + '}VirtualQuantity'] == \
(self.config['vcd']['disk_size_new'] * 1024 * 1024)
break
# this check makes sure that the vm isn't disk-less
assert found_disk
# cleanup
self.test_100_delete_vapp()
def modify_cpu(self, request):
logging.info("__INIT__modify_cpu[VappVm]")
res = vapp_vm_pb2.ModifyVappVmCPUResult()
res.modified = False
org_resource = self.client.get_org()
org = Org(self.client, resource=org_resource)
try:
vdc_resource = org.get_vdc(request.target_vdc)
vdc = VDC(
self.client, name=request.target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(request.target_vapp)
vapp = VApp(
self.client, name=request.target_vapp, resource=vapp_resource)
vapp_vm_resource = vapp.get_vm(request.target_vm_name)
vm = VM(self.client, resource=vapp_vm_resource)
self.undeploy(request)
modify_cpu_response = vm.modify_cpu(request.virtual_cpus,
request.cores_per_socket)
task = self.client.get_task_monitor().wait_for_status(
task=modify_cpu_response,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st != TaskStatus.SUCCESS.value:
raise errors.VappVmModifyCPUError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
self.power_on(request)
res.modified = True
except Exception as e:
errmsg = '__ERROR_modify_cpu[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
self.context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
self.context.set_details(errmsg)
logging.info("__DONE__modify_cpu[VappVm]")
return res
def add(ctx, vapp_name, access_list):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp = VApp(client, resource=vdc.get_vapp(vapp_name))
vapp.add_access_settings(
access_settings_list=acl_str_to_list_of_dict(access_list))
stdout('Access settings added to vapp \'%s\'.' % vapp_name, ctx)
except Exception as e:
stderr(e, ctx)
def update(client, context, vappInfo):
logging.info("__INIT__update[Vapp]")
cresult = vapp_pb2.UpdateVAppResult()
cresult.updated = False
print("Vapp[ {0} ], Vdc[ {1} ]".format(vappInfo.name, vappInfo.vdc))
org_resource = client.get_org()
org = Org(client, resource=org_resource)
try:
vdc_resource = org.get_vdc(vappInfo.vdc)
vdc = VDC(client, name=vappInfo.vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(vappInfo.name)
vapp = VApp(client, name=vappInfo.name, resource=vapp_resource)
resp = None
if (vappInfo.power_on == True):
logging.info("Powering on [Vapp %v]".format(vappInfo.name))
resp = vapp.power_on()
else:
logging.info("Powering off [Vapp %v]".format(vappInfo.name))
resp = vapp.undeploy()
task = client.get_task_monitor().wait_for_status(
task=resp,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
message = 'status : {0} '.format(st)
logging.info(message)
cresult.updated = True
else:
raise errors.VappUpdateError(
etree.tostring(task, pretty_print=True))
except Exception as e:
error_message = '__ERROR_updating [Vapp] power_on={0} for Vapp {1} . __ErrorMessage__ {2}'.format(
vappInfo.power_on, vappInfo.name, str(e))
logging.warn(error_message)
cresult.updated = False
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
logging.info("__DONE__update[Vapp]")
return cresult
def list_acl(ctx, vapp_name):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp = VApp(client, resource=vdc.get_vapp(vapp_name))
acl = vapp.get_access_settings()
stdout(
access_settings_to_list(
acl, ctx.obj['profiles'].get('org_in_use')), ctx)
except Exception as e:
stderr(e, ctx)
def unshare(ctx, vapp_name):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp = VApp(client, resource=vdc.get_vapp(vapp_name))
vapp.unshare_from_org_members()
stdout(
'Vapp \'%s\' unshared from all members of the org \'%s\'.' %
(vapp_name, ctx.obj['profiles'].get('org_in_use')), ctx)
except Exception as e:
stderr(e, ctx)
def update_lease(ctx, name, runtime_seconds, storage_seconds):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
vapp = VApp(client, resource=vapp_resource)
if storage_seconds is None:
storage_seconds = runtime_seconds
task = vapp.set_lease(runtime_seconds, storage_seconds)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def share(ctx, vapp_name, access_level):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp = VApp(client, resource=vdc.get_vapp(vapp_name))
vapp.share_with_org_members(everyone_access_level=access_level)
stdout(
'Vapp \'%s\' shared to all members of the org \'%s\'.' %
(vapp_name, ctx.obj['profiles'].get('org_in_use')), ctx)
except Exception as e:
stderr(e, ctx)
def change_owner(ctx, vapp_name, user_name):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
user_resource = org.get_user(user_name)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
vapp.change_owner(user_resource.get('href'))
stdout('vapp owner changed', ctx)
except Exception as e:
stderr(e, ctx)
