def test_0030_get_non_existent_vm(self):
"""Test the method VApp.get_vm().
This test passes if the non-existent vm can't be successfully retrieved
by name.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
try:
vapp.get_vm(TestVM._non_existent_vm_name)
self.fail('Should not be able to fetch vm ' +
TestVM._non_existent_vm_name)
except EntityNotFoundException:
return
def test_0030_get_non_existent_vm(self):
"""Test the method VApp.get_vm().
This test passes if the non-existent vm can't be successfully retrieved
by name.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
try:
vapp.get_vm(TestVM._non_existent_vm_name)
self.fail('Should not be able to fetch vm ' +
TestVM._non_existent_vm_name)
except EntityNotFoundException:
return
def delete_nodes_thread(self):
LOGGER.debug(f"About to delete nodes from cluster with name: "
f"{self.cluster_name}")
try:
vapp = VApp(self.tenant_client, href=self.cluster['vapp_href'])
template = self._get_template()
self._update_task(
TaskStatus.RUNNING,
message=f"Deleting "
f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}"
f" node(s) from "
f"{self.cluster_name}({self.cluster_id})")
try:
server_config = get_server_runtime_config()
delete_nodes_from_cluster(
server_config,
vapp,
template,
self.req_spec.get(RequestKey.NODE_NAMES_LIST),
self.req_spec.get(RequestKey.FORCE_DELETE))
except Exception:
LOGGER.error(f"Couldn't delete node "
f"{self.req_spec.get(RequestKey.NODE_NAMES_LIST)}"
f" from cluster:{self.cluster_name}")
self._update_task(
TaskStatus.RUNNING,
message=f"Undeploying "
f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}"
f" node(s) for {self.cluster_name}({self.cluster_id})")
for vm_name in self.req_spec.get(RequestKey.NODE_NAMES_LIST):
vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name))
try:
task = vm.undeploy()
self.tenant_client.get_task_monitor().wait_for_status(task)
except Exception:
LOGGER.warning(f"Couldn't undeploy VM {vm_name}")
self._update_task(
TaskStatus.RUNNING,
message=f"Deleting "
f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}"
f" VM(s) for {self.cluster_name}({self.cluster_id})")
task = vapp.delete_vms(self.req_spec.get(RequestKey.NODE_NAMES_LIST)) # noqa: E501
self.tenant_client.get_task_monitor().wait_for_status(task)
self._update_task(
TaskStatus.SUCCESS,
message=f"Deleted "
f"{len(self.req_spec.get(RequestKey.NODE_NAMES_LIST))}"
f" node(s) to cluster "
f"{self.cluster_name}({self.cluster_id})")
except Exception as e:
LOGGER.error(traceback.format_exc())
error_obj = error_to_json(e)
stack_trace = \
''.join(error_obj[ERROR_MESSAGE_KEY][ERROR_STACKTRACE_KEY])
self._update_task(
TaskStatus.ERROR,
error_message=error_obj[ERROR_MESSAGE_KEY][ERROR_DESCRIPTION_KEY], # noqa: E501
stack_trace=stack_trace)
finally:
self._disconnect_sys_admin()
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 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 node_rollback(self, node_list):
"""Implements rollback for node creation failure
:param list node_list: faulty nodes to be deleted
"""
LOGGER.info('About to rollback nodes from cluster with name: %s' %
self.cluster_name)
LOGGER.info('Node list to be deleted:%s' % node_list)
vapp = VApp(self.client_tenant, href=self.cluster['vapp_href'])
template = self.get_template()
try:
delete_nodes_from_cluster(self.config,
vapp,
template,
node_list,
force=True)
except Exception:
LOGGER.warning("Couldn't delete node %s from cluster:%s" %
(node_list, self.cluster_name))
for vm_name in node_list:
vm = VM(self.client_tenant, resource=vapp.get_vm(vm_name))
try:
vm.undeploy()
except Exception:
LOGGER.warning("Couldn't undeploy VM %s" % vm_name)
vapp.delete_vms(node_list)
LOGGER.info('Successfully deleted nodes: %s' % node_list)
def node_rollback(self, node_list):
"""Rollback for node creation failure.
:param list node_list: faulty nodes to be deleted
"""
LOGGER.info(f"About to rollback nodes from cluster with name: "
"{self.cluster_name}")
LOGGER.info(f"Node list to be deleted:{node_list}")
vapp = VApp(self.tenant_client, href=self.cluster['vapp_href'])
template = self._get_template()
try:
server_config = get_server_runtime_config()
delete_nodes_from_cluster(server_config, vapp, template,
node_list, force=True)
except Exception:
LOGGER.warning("Couldn't delete node {node_list} from cluster:"
"{self.cluster_name}")
for vm_name in node_list:
vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name))
try:
vm.undeploy()
except Exception:
LOGGER.warning(f"Couldn't undeploy VM {vm_name}")
vapp.delete_vms(node_list)
LOGGER.info(f"Successfully deleted nodes: {node_list}")
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 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 test_0010_vm_setup(self):
"""Setup the vms required for the other tests in this module.
Create a vApp with just one vm as per the configuration stated above.
This test passes if the vApp and vm hrefs are not None.
"""
logger = Environment.get_default_logger()
TestPVDC._org_client = Environment.get_client_in_default_org(
TestPVDC._test_runner_role)
vdc = Environment.get_test_vdc(TestPVDC._org_client)
logger.debug('Creating vApp ' + TestPVDC._test_vapp_name + '.')
TestPVDC._test_vapp_href = create_customized_vapp_from_template(
client=TestPVDC._org_client,
vdc=vdc,
name=TestPVDC._test_vapp_name,
catalog_name=Environment.get_default_catalog_name(),
template_name=Environment.get_default_template_name(),
memory_size=TestPVDC._test_vapp_first_vm_memory_size,
num_cpu=TestPVDC._test_vapp_first_vm_num_cpu,
disk_size=TestPVDC._test_vapp_first_vm_first_disk_size,
vm_name=TestPVDC._test_vapp_first_vm_name,
nw_adapter_type=TestPVDC._test_vapp_first_vm_network_adapter_type)
self.assertIsNotNone(TestPVDC._test_vapp_href)
vapp = VApp(TestPVDC._org_client, href=TestPVDC._test_vapp_href)
vm_resource = vapp.get_vm(TestPVDC._test_vapp_first_vm_name)
TestPVDC._test_vapp_first_vm_href = vm_resource.get('href')
self.assertIsNotNone(TestPVDC._test_vapp_first_vm_href)
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_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_0010_vm_setup(self):
"""Setup the vms required for the other tests in this module.
Create a vApp with just one vm as per the configuration stated above.
This test passes if the vApp and vm hrefs are not None.
"""
logger = Environment.get_default_logger()
TestPVDC._org_client = Environment.get_client_in_default_org(
TestPVDC._test_runner_role)
vdc = Environment.get_test_vdc(TestPVDC._org_client)
logger.debug('Creating vApp ' + TestPVDC._test_vapp_name + '.')
TestPVDC._test_vapp_href = create_customized_vapp_from_template(
client=TestPVDC._org_client,
vdc=vdc,
name=TestPVDC._test_vapp_name,
catalog_name=Environment.get_default_catalog_name(),
template_name=Environment.get_default_template_name(),
memory_size=TestPVDC._test_vapp_first_vm_memory_size,
num_cpu=TestPVDC._test_vapp_first_vm_num_cpu,
disk_size=TestPVDC._test_vapp_first_vm_first_disk_size,
vm_name=TestPVDC._test_vapp_first_vm_name,
nw_adapter_type=TestPVDC._test_vapp_first_vm_network_adapter_type)
self.assertIsNotNone(TestPVDC._test_vapp_href)
vapp = VApp(TestPVDC._org_client, href=TestPVDC._test_vapp_href)
vm_resource = vapp.get_vm(TestPVDC._test_vapp_first_vm_name)
TestPVDC._test_vapp_first_vm_href = vm_resource.get('href')
self.assertIsNotNone(TestPVDC._test_vapp_first_vm_href)
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 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_0020_get_vm(self):
"""Test the method VApp.get_vm().
This test passes if the retrieved vm's name and href matches with the
expected values.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
vm_resource = vapp.get_vm(TestVM._test_vapp_first_vm_name)
self.assertEqual(TestVM._test_vapp_first_vm_name,
vm_resource.get('name'))
self.assertEqual(TestVM._test_vapp_first_vm_href,
vm_resource.get('href'))
def test_0074_delete_vm(self):
"""Test the method related to delete VM.
This test passes if delete VM operation is successful.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
vm_resource = vapp.get_vm(TestVM._target_vm_name)
TestVM._target_vm_href = vm_resource.get('href')
vm = VM(TestVM._client, href=TestVM._target_vm_href)
task = vm.delete()
result = TestVM._client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
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 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 test_0006_undeploy(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.undeploy()
task = self.client.get_task_monitor().wait_for_status(task)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_0006_undeploy(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.undeploy()
task = self.client.get_task_monitor().wait_for_status(task)
assert task.get('status') == TaskStatus.SUCCESS.value
def test_0020_get_vm(self):
"""Test the method VApp.get_vm().
This test passes if the retrieved vm's name and href matches with the
expected values.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
vm_resource = vapp.get_vm(TestVM._test_vapp_first_vm_name)
self.assertEqual(TestVM._test_vapp_first_vm_name,
vm_resource.get('name'))
self.assertEqual(TestVM._test_vapp_first_vm_href,
vm_resource.get('href'))
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 test_0000_setup(self):
"""Setup the vms required for the other tests in this module.
Create a vApp with just one vm as per the configuration stated above.
This test passes if the vApp and vm hrefs are not None.
"""
logger = Environment.get_default_logger()
TestVM._client = Environment.get_client_in_default_org(
TestVM._test_runner_role)
TestVM._sys_admin_client = Environment.get_sys_admin_client()
vdc = Environment.get_test_vdc(TestVM._client)
TestVM._media_resource = Environment.get_test_media_resource()
logger.debug('Creating vApp ' + TestVM._test_vapp_name + '.')
TestVM._test_vapp_href = create_customized_vapp_from_template(
client=TestVM._client,
vdc=vdc,
name=TestVM._test_vapp_name,
catalog_name=Environment.get_default_catalog_name(),
template_name=Environment.get_default_template_name(),
memory_size=TestVM._test_vapp_first_vm_memory_size,
num_cpu=TestVM._test_vapp_first_vm_num_cpu,
disk_size=TestVM._test_vapp_first_vm_first_disk_size,
vm_name=TestVM._test_vapp_first_vm_name,
nw_adapter_type=TestVM._test_vapp_first_vm_network_adapter_type)
self.assertIsNotNone(TestVM._test_vapp_href)
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
TestVM._test_vapp = vapp
vm_resource = vapp.get_vm(TestVM._test_vapp_first_vm_name)
TestVM._test_vapp_first_vm_href = vm_resource.get('href')
self.assertIsNotNone(TestVM._test_vapp_first_vm_href)
logger.debug('Creating empty vApp.')
TestVM._empty_vapp_href = \
create_empty_vapp(client=TestVM._client,
vdc=vdc,
name=TestVM._empty_vapp_name,
description=TestVM._empty_vapp_description)
TestVM._empty_vapp_owner_name = Environment. \
get_username_for_role_in_test_org(TestVM._test_runner_role)
#Create independent disk
TestVM._idisk = vdc.create_disk(name=self._idisk_name,
size=self._idisk_size,
description=self._idisk_description)
def delete_nodes_thread(self):
LOGGER.debug(f"About to delete nodes from cluster with name: "
f"{self.cluster_name}")
try:
vapp = VApp(self.tenant_client, href=self.cluster['vapp_href'])
template = self.get_template()
self.update_task(
TaskStatus.RUNNING,
message=f"Deleting {len(self.req_spec['nodes'])} node(s) from "
f"{self.cluster_name}({self.cluster_id})")
try:
server_config = get_server_runtime_config()
delete_nodes_from_cluster(server_config, vapp, template,
self.req_spec['nodes'],
self.req_spec['force'])
except Exception:
LOGGER.error(f"Couldn't delete node {self.req_spec['nodes']} "
f"from cluster:{self.cluster_name}")
self.update_task(
TaskStatus.RUNNING,
message=f"Undeploying {len(self.req_spec['nodes'])} node(s) "
f"for {self.cluster_name}({self.cluster_id})")
for vm_name in self.req_spec['nodes']:
vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name))
try:
task = vm.undeploy()
self.tenant_client.get_task_monitor().wait_for_status(task)
except Exception:
LOGGER.warning(f"Couldn't undeploy VM {vm_name}")
self.update_task(
TaskStatus.RUNNING,
message=f"Deleting {len(self.req_spec['nodes'])} VM(s) for "
f"{self.cluster_name}({self.cluster_id})")
task = vapp.delete_vms(self.req_spec['nodes'])
self.tenant_client.get_task_monitor().wait_for_status(task)
self.update_task(
TaskStatus.SUCCESS,
message=f"Deleted {len(self.req_spec['nodes'])} node(s) to "
f"cluster {self.cluster_name}({self.cluster_id})")
except Exception as e:
LOGGER.error(traceback.format_exc())
error_obj = error_to_json(e)
stack_trace = ''.join(error_obj[ERROR_MESSAGE][ERROR_STACKTRACE])
self.update_task(
TaskStatus.ERROR,
error_message=error_obj[ERROR_MESSAGE][ERROR_DESCRIPTION],
stack_trace=stack_trace)
finally:
self._disconnect_sys_admin()
def test_0010_list_vms(self):
"""Test the method VApp.get_all_vms().
This test passes if the retrieved vms contain the vm created during
setup.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
vm_resources = vapp.get_vm(TestVM._test_vapp_first_vm_name)
for vm_resource in vm_resources:
if vm_resource.get(
'name') == TestVM._test_vapp_first_vm_name and \
vm_resource.get(
'href') == TestVM._test_vapp_first_vm_href:
return
self.fail('Retrieved vm list doesn\'t contain vm ' +
TestVM._test_vapp_first_vm_name)
def test_0073_move_to(self):
"""Test the method related to move VM from one vapp to another.
This test passes if move VM operation is successful.
"""
target_vapp_name = TestVM._test_vapp_name
source_vapp_name = TestVM._empty_vapp_name
target_vm_name = TestVM._target_vm_name
vapp = VApp(TestVM._client, href=TestVM._empty_vapp_href)
vm_resource = vapp.get_vm(TestVM._target_vm_name)
TestVM._target_vm_href = vm_resource.get('href')
vm = VM(TestVM._client, href=TestVM._target_vm_href)
task = vm.move_to(source_vapp_name=source_vapp_name,
target_vapp_name=target_vapp_name,
target_vm_name=target_vm_name)
result = TestVM._client.get_task_monitor().wait_for_success(task)
self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value)
def test_0010_list_vms(self):
"""Test the method VApp.get_all_vms().
This test passes if the retrieved vms contain the vm created during
setup.
"""
vapp = VApp(TestVM._client, href=TestVM._test_vapp_href)
vm_resources = vapp.get_vm(TestVM._test_vapp_first_vm_name)
for vm_resource in vm_resources:
if vm_resource.get('name') == TestVM._test_vapp_first_vm_name and\
vm_resource.get('href') == TestVM._test_vapp_first_vm_href:
return
self.fail('Retrieved vm list doesn\'t contain vm ' +
TestVM._test_vapp_first_vm_name)
def reset(ctx, name, vm_names):
try:
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 len(vm_names) == 0:
task = vapp.power_reset()
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, resource=vapp.get_vm(vm_name))
task = vm.power_reset()
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def power_off(self, request):
logging.info("__INIT__power_off[VappVm]")
res = vapp_vm_pb2.PowerOffVappVmResult()
res.powered_off = 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)
power_off_response = vm.undeploy()
task = self.client.get_task_monitor().wait_for_status(
task=power_off_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.VappVmCreateError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
powered_off = True
except Exception as e:
errmsg = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
logging.info("__DONE__power_off[VappVm]")
return powered_off
def power_off(self, request):
logging.info("__INIT__power_off[VappVm]")
res = vapp_vm_pb2.PowerOffVappVmResult()
res.powered_off = 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)
power_off_response = vm.undeploy()
task = self.client.get_task_monitor().wait_for_status(
task=power_off_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.VappVmCreateError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
powered_off = True
except Exception as e:
errmsg = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'
logging.warn(errmsg.format(request.target_vm_name, str(e)))
logging.info("__DONE__power_off[VappVm]")
return powered_off
def reset(ctx, name, vm_names):
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 len(vm_names) == 0:
task = vapp.power_reset()
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, resource=vapp.get_vm(vm_name))
task = vm.power_reset()
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def undeploy(ctx, name, vm_names, action):
try:
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 len(vm_names) == 0:
task = vapp.undeploy(action)
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, href=vapp.get_vm(vm_name).get('href'))
vm.reload()
task = vm.undeploy(action)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def test_0003_get_vm_info(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, 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)
vm_name = self.config['vcd']['hostname']
vm_resource = vapp.get_vm(vm_name)
self.logger.debug('vm name: %s' % vm_resource.get('name'))
vm = VM(self.client, resource=vm_resource)
vcenter = vm.get_vc()
self.logger.debug('vCenter: %s' % vcenter)
assert vcenter == self.config['vcd']['vcenter']
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 shutdown(ctx, name, vm_names):
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 len(vm_names) == 0:
task = vapp.shutdown()
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, href=vapp.get_vm(vm_name).get('href'))
vm.reload()
task = vm.shutdown()
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def _delete_nodes(self, *args,
cluster_name, cluster_vapp_href, node_names_list):
LOGGER.debug(f"About to delete nodes {node_names_list} "
f"from cluster {cluster_name}")
vapp = VApp(self.tenant_client, href=cluster_vapp_href)
try:
delete_nodes_from_cluster(vapp, node_names_list)
except Exception:
LOGGER.error(f"Couldn't delete node {node_names_list} "
f"from cluster:{cluster_name}")
for vm_name in node_names_list:
vm = VM(self.tenant_client, resource=vapp.get_vm(vm_name))
try:
task = vm.undeploy()
self.tenant_client.get_task_monitor().wait_for_status(task)
except Exception:
LOGGER.warning(f"Couldn't undeploy VM {vm_name}")
task = vapp.delete_vms(node_names_list)
self.tenant_client.get_task_monitor().wait_for_status(task)
def update(ctx, vapp_name, vm_name, cpu, cores, memory):
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(vapp_name)
vapp = VApp(client, resource=vapp_resource)
vm_resource = vapp.get_vm(vm_name)
vm = VM(client, resource=vm_resource)
if cpu is not None:
task_cpu_update = vm.modify_cpu(cpu, cores)
stdout("Updating cpu (and core(s) if specified) for the VM")
stdout(task_cpu_update, ctx)
if memory is not None:
task_memory_update = vm.modify_memory(memory)
stdout("Updating memory for the VM")
stdout(task_memory_update, ctx)
except Exception as e:
stderr(e, ctx)
def delete_nodes_thread(self):
LOGGER.debug('about to delete nodes from cluster with name: %s',
self.cluster_name)
try:
vapp = VApp(self.client_tenant, href=self.cluster['vapp_href'])
template = self.get_template()
self.update_task(
TaskStatus.RUNNING,
message='Deleting %s node(s) from %s(%s)' %
(len(self.body['nodes']), self.cluster_name, self.cluster_id))
try:
delete_nodes_from_cluster(self.config, vapp, template,
self.body['nodes'],
self.body['force'])
except Exception:
LOGGER.error("Couldn't delete node %s from cluster:%s" %
(self.body['nodes'], self.cluster_name))
self.update_task(
TaskStatus.RUNNING,
message='Undeploying %s node(s) for %s(%s)' %
(len(self.body['nodes']), self.cluster_name, self.cluster_id))
for vm_name in self.body['nodes']:
vm = VM(self.client_tenant, resource=vapp.get_vm(vm_name))
try:
task = vm.undeploy()
self.client_tenant.get_task_monitor().wait_for_status(task)
except Exception as e:
LOGGER.warning('couldn\'t undeploy VM %s' % vm_name)
self.update_task(
TaskStatus.RUNNING,
message='Deleting %s VM(s) for %s(%s)' %
(len(self.body['nodes']), self.cluster_name, self.cluster_id))
task = vapp.delete_vms(self.body['nodes'])
self.client_tenant.get_task_monitor().wait_for_status(task)
self.update_task(
TaskStatus.SUCCESS,
message='Deleted %s node(s) to cluster %s(%s)' %
(len(self.body['nodes']), self.cluster_name, self.cluster_id))
except Exception as e:
LOGGER.error(traceback.format_exc())
self.update_task(TaskStatus.ERROR, error_message=str(e))
def test_0005_power_off(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.power_off()
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
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 power_off(client, target_vdc, target_vapp, target_vm_name):
logging.info("__INIT__delete[VappVm]")
powered_off = False
org_resource = client.get_org()
org = Org(client, resource=org_resource)
try:
vdc_resource = org.get_vdc(target_vdc)
vdc = VDC(slef.client, name=target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(target_vapp)
vapp = VApp(client, name=target_vapp, resource=vapp_resource)
vapp_vm_resource = vapp.get_vm(target_vm_name)
vm = VM(client, resource=vapp_vm_resource)
vm.power_off()
powered_off = True
except Exception as e:
error_message = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'.format(
target_vm_name, str(e))
logging.warn(error_message)
return powered_off
def power_off(client, target_vdc, target_vapp, target_vm_name):
logging.info("__INIT__delete[VappVm]")
powered_off = False
org_resource = client.get_org()
org = Org(client, resource=org_resource)
try:
vdc_resource = org.get_vdc(target_vdc)
vdc = VDC(slef.client, name=target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(target_vapp)
vapp = VApp(client, name=target_vapp, resource=vapp_resource)
vapp_vm_resource = vapp.get_vm(target_vm_name)
vm = VM(client, resource=vapp_vm_resource)
vm.power_off()
powered_off = True
except Exception as e:
error_message = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'.format(
target_vm_name, str(e))
logging.warn(error_message)
return powered_off
def deploy(ctx, name, vm_names, power_on, force_customization):
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 power_on is not None:
power_on = False
if force_customization is not None:
force_customization = True
if len(vm_names) == 0:
task = vapp.deploy(power_on=power_on)
stdout(task, ctx)
else:
for vm_name in vm_names:
vm = VM(client, href=vapp.get_vm(vm_name).get('href'))
vm.reload()
task = vm.deploy(
power_on=power_on, force_customization=force_customization)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
task_monitor = client.get_task_monitor()
print("Fetching Org...")
org_resource = client.get_org()
org = Org(client, resource=org_resource)
print("Fetching VDC...")
vdc_resource = org.get_vdc(vdc)
vdc = VDC(client, resource=vdc_resource)
print("Fetching vApp...")
vapp_resource = vdc.get_vapp(vapp)
vapp = VApp(client, resource=vapp_resource)
print("Fetching VM...")
vm_resource = vapp.get_vm(vm)
vm = VM(client, resource=vm_resource)
print("Creating Snapshot...")
snaphot_resource = vm.snapshot_create(memory=False, quiesce=False)
print("Waiting for Snapshot finish...")
task_monitor.wait_for_success(snaphot_resource)
print("Revert Back To Current Snapshot...")
vm.reload()
snaphot_resource = vm.snapshot_revert_to_current()
print("Waiting for Revert finish...")
task_monitor.wait_for_success(snaphot_resource)
print("Remove All Snapshot...")
snaphot_resource = vm.snapshot_remove_all()
class VappVM(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappVM, self).__init__(**kwargs)
vapp_resource = self.get_target_resource()
self.vapp = VApp(self.client, resource=vapp_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.add_vm()
if state == "absent":
return self.delete_vm()
if state == "update":
return self.update_vm()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "poweron":
return self.power_on_vm()
if operation == "poweroff":
return self.power_off_vm()
if operation == "reloadvm":
return self.reload_vm()
if operation == "deploy":
return self.deploy_vm()
if operation == "undeploy":
return self.undeploy_vm()
if operation == "list_disks":
return self.list_disks()
if operation == "list_nics":
return self.list_nics()
def get_source_resource(self):
source_catalog_name = self.params.get('source_catalog_name')
source_template_name = self.params.get('source_template_name')
source_vdc = self.params.get('source_vdc')
source_vapp = self.params.get('source_vapp')
org_resource = Org(self.client, resource=self.client.get_org())
source_vapp_resource = None
if source_vapp:
source_vdc_resource = VDC(
self.client, resource=org_resource.get_vdc(source_vdc))
source_vapp_resource_href = source_vdc_resource.get_resource_href(
name=source_vapp, entity_type=EntityType.VAPP)
source_vapp_resource = self.client.get_resource(
source_vapp_resource_href)
if source_catalog_name:
catalog_item = org_resource.get_catalog_item(
source_catalog_name, source_template_name)
source_vapp_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
return source_vapp_resource
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 get_storage_profile(self, profile_name):
target_vdc = self.params.get('target_vdc')
org_resource = Org(self.client, resource=self.client.get_org())
vdc_resource = VDC(self.client, resource=org_resource.get_vdc(target_vdc))
return vdc_resource.get_storage_profile(profile_name)
def get_vm(self):
vapp_vm_resource = self.vapp.get_vm(self.params.get('target_vm_name'))
return VM(self.client, resource=vapp_vm_resource)
def add_vm(self):
params = self.params
source_vapp_resource = self.get_source_resource()
target_vm_name = params.get('target_vm_name')
source_vm_name = params.get('source_vm_name')
hostname = params.get('hostname')
vmpassword = params.get('vmpassword')
vmpassword_auto = params.get('vmpassword_auto')
vmpassword_reset = params.get('vmpassword_reset')
network = params.get('network')
all_eulas_accepted = params.get('all_eulas_accepted')
power_on = params.get('power_on')
ip_allocation_mode = params.get('ip_allocation_mode')
cust_script = params.get('cust_script')
storage_profile = params.get('storage_profile')
properties = params.get('properties')
response = dict()
response['changed'] = False
try:
self.get_vm()
except EntityNotFoundException:
spec = {
'source_vm_name': source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': target_vm_name,
'hostname': hostname,
'password': vmpassword,
'password_auto': vmpassword_auto,
'password_reset': vmpassword_reset,
'ip_allocation_mode': ip_allocation_mode,
'network': network,
'cust_script': cust_script
}
if storage_profile!='':
spec['storage_profile'] = self.get_storage_profile(storage_profile)
spec = {k: v for k, v in spec.items() if v}
source_vm = self.vapp.to_sourced_item(spec)
# Check the source vm if we need to inject OVF properties.
source_vapp = VApp(self.client, resource=source_vapp_resource)
vm = source_vapp.get_vm(source_vm_name)
productsection = vm.find('ovf:ProductSection', NSMAP)
if productsection is not None:
for prop in productsection.iterfind('ovf:Property', NSMAP):
if properties and prop.get('{'+NSMAP['ovf']+'}key') in properties:
val = prop.find('ovf:Value', NSMAP)
if val:
prop.remove(val)
val = E_OVF.Value()
val.set('{'+NSMAP['ovf']+'}value', properties[prop.get('{'+NSMAP['ovf']+'}key')])
prop.append(val)
source_vm.InstantiationParams.append(productsection)
source_vm.VmGeneralParams.NeedsCustomization = E.NeedsCustomization('true')
params = E.RecomposeVAppParams(deploy='true', powerOn='true' if power_on else 'false')
params.append(source_vm)
if all_eulas_accepted is not None:
params.append(E.AllEULAsAccepted(all_eulas_accepted))
add_vms_task = self.client.post_linked_resource(
self.get_target_resource(), RelationType.RECOMPOSE,
EntityType.RECOMPOSE_VAPP_PARAMS.value, params)
self.execute_task(add_vms_task)
response['msg'] = 'Vapp VM {} has been created.'.format(
target_vm_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp VM {} is already present.'.format(
target_vm_name)
return response
def delete_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
self.get_vm()
except EntityNotFoundException:
response['warnings'] = 'Vapp VM {} is not present.'.format(vm_name)
else:
self.undeploy_vm()
delete_vms_task = self.vapp.delete_vms([vm_name])
self.execute_task(delete_vms_task)
response['msg'] = 'Vapp VM {} has been deleted.'.format(vm_name)
response['changed'] = True
return response
def update_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
if self.params.get("virtual_cpus"):
self.update_vm_cpu()
response['changed'] = True
if self.params.get("memory"):
self.update_vm_memory()
response['changed'] = True
response['msg'] = 'Vapp VM {} has been updated.'.format(vm_name)
return response
def update_vm_cpu(self):
virtual_cpus = self.params.get('virtual_cpus')
cores_per_socket = self.params.get('cores_per_socket')
vm = self.get_vm()
update_cpu_task = vm.modify_cpu(virtual_cpus, cores_per_socket)
return self.execute_task(update_cpu_task)
def update_vm_memory(self):
memory = self.params.get('memory')
vm = self.get_vm()
update_memory_task = vm.modify_memory(memory)
return self.execute_task(update_memory_task)
def power_on_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
power_on_task = vm.power_on()
self.execute_task(power_on_task)
response['msg'] = 'Vapp VM {} has been powered on.'.format(vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp VM {} is already powered on.'.format(
vm_name)
return response
def power_off_vm(self,):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
power_off_task = vm.power_off()
self.execute_task(power_off_task)
response['msg'] = 'Vapp VM {} has been powered off.'.format(
vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp VM {} is already powered off.'.format(
vm_name)
return response
def reload_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
vm = self.get_vm()
vm.reload()
response['msg'] = 'Vapp VM {} has been reloaded.'.format(vm_name)
response['changed'] = True
return response
def deploy_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
deploy_vm_task = vm.deploy()
self.execute_task(deploy_vm_task)
response['msg'] = 'Vapp VM {} has been deployed.'.format(vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp VM {} is already deployed.'.format(
vm_name)
return response
def undeploy_vm(self):
vm_name = self.params.get('target_vm_name')
response = dict()
response['changed'] = False
try:
vm = self.get_vm()
undeploy_vm_task = vm.undeploy()
self.execute_task(undeploy_vm_task)
response['msg'] = 'Vapp VM {} has been undeployed.'.format(vm_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp VM {} is already undeployed.'.format(
vm_name)
return response
def list_disks(self):
response = dict()
response['changed'] = False
response['msg'] = []
vm = self.get_vm()
disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks')
for disk in disks.Item:
if disk['{'+NSMAP['rasd']+'}ResourceType'] == 17:
response['msg'].append({
'id': disk['{'+NSMAP['rasd']+'}InstanceID'].text,
'name': disk['{'+NSMAP['rasd']+'}ElementName'].text,
'description': disk['{'+NSMAP['rasd']+'}Description'].text,
'size': disk['{'+NSMAP['rasd']+'}HostResource'].get('{'+NSMAP['vcloud']+'}capacity')
})
return response
def list_nics(self):
response = dict()
response['changed'] = False
response['msg'] = []
vm = self.get_vm()
nics = self.client.get_resource(vm.resource.get('href') + '/networkConnectionSection')
for nic in nics.NetworkConnection:
response['msg'].append({
'index': nic.NetworkConnectionIndex.text,
'network': nic.get('network')
})
return response
def add_vm(self):
params = self.params
source_vapp_resource = self.get_source_resource()
target_vm_name = params.get('target_vm_name')
source_vm_name = params.get('source_vm_name')
hostname = params.get('hostname')
vmpassword = params.get('vmpassword')
vmpassword_auto = params.get('vmpassword_auto')
vmpassword_reset = params.get('vmpassword_reset')
network = params.get('network')
all_eulas_accepted = params.get('all_eulas_accepted')
power_on = params.get('power_on')
ip_allocation_mode = params.get('ip_allocation_mode')
cust_script = params.get('cust_script')
storage_profile = params.get('storage_profile')
properties = params.get('properties')
response = dict()
response['changed'] = False
try:
self.get_vm()
except EntityNotFoundException:
spec = {
'source_vm_name': source_vm_name,
'vapp': source_vapp_resource,
'target_vm_name': target_vm_name,
'hostname': hostname,
'password': vmpassword,
'password_auto': vmpassword_auto,
'password_reset': vmpassword_reset,
'ip_allocation_mode': ip_allocation_mode,
'network': network,
'cust_script': cust_script
}
if storage_profile!='':
spec['storage_profile'] = self.get_storage_profile(storage_profile)
spec = {k: v for k, v in spec.items() if v}
source_vm = self.vapp.to_sourced_item(spec)
# Check the source vm if we need to inject OVF properties.
source_vapp = VApp(self.client, resource=source_vapp_resource)
vm = source_vapp.get_vm(source_vm_name)
productsection = vm.find('ovf:ProductSection', NSMAP)
if productsection is not None:
for prop in productsection.iterfind('ovf:Property', NSMAP):
if properties and prop.get('{'+NSMAP['ovf']+'}key') in properties:
val = prop.find('ovf:Value', NSMAP)
if val:
prop.remove(val)
val = E_OVF.Value()
val.set('{'+NSMAP['ovf']+'}value', properties[prop.get('{'+NSMAP['ovf']+'}key')])
prop.append(val)
source_vm.InstantiationParams.append(productsection)
source_vm.VmGeneralParams.NeedsCustomization = E.NeedsCustomization('true')
params = E.RecomposeVAppParams(deploy='true', powerOn='true' if power_on else 'false')
params.append(source_vm)
if all_eulas_accepted is not None:
params.append(E.AllEULAsAccepted(all_eulas_accepted))
add_vms_task = self.client.post_linked_resource(
self.get_target_resource(), RelationType.RECOMPOSE,
EntityType.RECOMPOSE_VAPP_PARAMS.value, params)
self.execute_task(add_vms_task)
response['msg'] = 'Vapp VM {} has been created.'.format(
target_vm_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp VM {} is already present.'.format(
target_vm_name)
return response
class VappVMDisk(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappVMDisk, self).__init__(**kwargs)
vapp_resource = self.get_resource()
self.vapp = VApp(self.client, resource=vapp_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.add_disk()
if state == "absent":
return self.delete_disk()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "update":
return self.update_disk()
def get_resource(self):
vapp = self.params.get('vapp')
vdc = self.params.get('vdc')
org_resource = Org(self.client, resource=self.client.get_org())
vdc_resource = VDC(self.client, resource=org_resource.get_vdc(vdc))
vapp_resource_href = vdc_resource.get_resource_href(name=vapp, entity_type=EntityType.VAPP)
vapp_resource = self.client.get_resource(vapp_resource_href)
return vapp_resource
def get_vm(self):
vapp_vm_resource = self.vapp.get_vm(self.params.get('vm_name'))
return VM(self.client, resource=vapp_vm_resource)
def add_disk(self):
vm = self.get_vm()
disk_id = self.params.get('disk_id')
size = self.params.get('size')
response = dict()
response['changed'] = False
# Some day, we well learn how to add a disk properly.
# For now, do what pyvcloud does: Copy another disk.
disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks')
base_disk = None
for disk in disks.Item:
if disk['{'+NSMAP['rasd']+'}ResourceType'] == 17:
base_disk = deepcopy(disk)
if disk_id is not None and disk['{'+NSMAP['rasd']+'}InstanceID'] == disk_id:
response['warnings'] = 'Disk is already present.'
return response
assert base_disk is not None
address = base_disk['{'+NSMAP['rasd']+'}AddressOnParent'] + 1
instance_id = base_disk['{'+NSMAP['rasd']+'}InstanceID'] + 1
base_disk['{'+NSMAP['rasd']+'}AddressOnParent'] = address
base_disk['{'+NSMAP['rasd']+'}InstanceID'] = instance_id if disk_id is None else disk_id
base_disk['{'+NSMAP['rasd']+'}Description'] = 'Hard disk'
base_disk['{'+NSMAP['rasd']+'}ElementName'] = 'Hard disk %s' % address
base_disk['{'+NSMAP['rasd']+'}VirtualQuantity'] = size*1024*1024
base_disk['{'+NSMAP['rasd']+'}HostResource'].set('{'+NSMAP['vcloud']+'}capacity', str(size))
disks.append(base_disk)
add_disk_task = self.client.put_resource(
vm.resource.get('href') + '/virtualHardwareSection/disks', disks,
EntityType.RASD_ITEMS_LIST.value)
self.execute_task(add_disk_task)
response['msg'] = 'Vapp VM disk has been added.'
response['changed'] = True
return response
def delete_disk(self):
vm = self.get_vm()
disk_id = self.params.get('disk_id')
response = dict()
response['changed'] = False
disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks')
for disk in disks.Item:
if disk['{'+NSMAP['rasd']+'}InstanceID'] == disk_id:
disks.remove(disk)
remove_disk_task = self.client.put_resource(
vm.resource.get('href') + '/virtualHardwareSection/disks', disks,
EntityType.RASD_ITEMS_LIST.value)
self.execute_task(remove_disk_task)
response['msg'] = 'VM disk has been deleted.'
response['changed'] = True
return response
response['warnings'] = 'VM disk was not found'
return response
def update_disk(self):
vm = self.get_vm()
disk_id = self.params.get('disk_id')
disk_name = self.params.get('disk_name')
size = self.params.get('size')
response = dict()
response['changed'] = False
disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks')
index = -1
for i, disk in enumerate(disks.Item):
if disk['{'+NSMAP['rasd']+'}InstanceID'] == disk_id:
index = i
if index < 0:
EntityNotFoundException('Can\'t find the specified VM disk')
if size:
disks.Item[index]['{'+NSMAP['rasd']+'}VirtualQuantity'] = size*1024*1024
disks.Item[index]['{'+NSMAP['rasd']+'}HostResource'].set(
'{' + NSMAP['vcloud'] + '}capacity', str(size))
response['changed'] = True
if disk_name:
disks.Item[index]['{'+NSMAP['rasd']+'}ElementName'] = disk_name
response['changed'] = True
if response['changed']:
update_disk_task = self.client.put_resource(
vm.resource.get('href') + '/virtualHardwareSection/disks', disks,
EntityType.RASD_ITEMS_LIST.value)
self.execute_task(update_disk_task)
response['msg'] = 'Vapp VM disk has been updated.'
return response
class VappVMNIC(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappVMNIC, self).__init__(**kwargs)
vapp_resource = self.get_resource()
self.vapp = VApp(self.client, resource=vapp_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.add_nic()
if state == "absent":
return self.delete_nic()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "update":
return self.update_nic()
def get_resource(self):
vapp = self.params.get('vapp')
vdc = self.params.get('vdc')
org_resource = Org(self.client, resource=self.client.get_org())
vdc_resource = VDC(self.client, resource=org_resource.get_vdc(vdc))
vapp_resource_href = vdc_resource.get_resource_href(name=vapp, entity_type=EntityType.VAPP)
vapp_resource = self.client.get_resource(vapp_resource_href)
return vapp_resource
def get_vm(self):
vapp_vm_resource = self.vapp.get_vm(self.params.get('vm_name'))
return VM(self.client, resource=vapp_vm_resource)
def add_nic(self):
vm = self.get_vm()
nic_id = self.params.get('nic_id')
network = self.params.get('network')
response = dict()
response['changed'] = False
max_id = -1;
nics = self.client.get_resource(vm.resource.get('href') + '/networkConnectionSection')
for nic in nics.NetworkConnection:
if nic.NetworkConnectionIndex == nic_id:
response['warnings'] = 'NIC is already present.'
return response
if nic.NetworkConnectionIndex > max_id:
max_id = int(nic.NetworkConnectionIndex.text)
nic = E.NetworkConnection(
E.NetworkConnectionIndex(max_id+1 if nic_id is None else nic_id),
E.IsConnected(True),
E.IpAddressAllocationMode('DHCP'),
network=network)
nics.NetworkConnection.addnext(nic)
add_nic_task = self.client.put_resource(
vm.resource.get('href') + '/networkConnectionSection', nics,
EntityType.NETWORK_CONNECTION_SECTION.value)
self.execute_task(add_nic_task)
response['msg'] = 'Vapp VM NIC has been added.'
response['changed'] = True
return response
def delete_nic(self):
vm = self.get_vm()
nic_id = self.params.get('nic_id')
response = dict()
response['changed'] = False
nics = self.client.get_resource(vm.resource.get('href') + '/networkConnectionSection')
for nic in nics.NetworkConnection:
if nic.NetworkConnectionIndex == nic_id:
nics.remove(nic)
remove_nic_task = self.client.put_resource(
vm.resource.get('href') + '/networkConnectionSection', nics,
EntityType.NETWORK_CONNECTION_SECTION.value)
self.execute_task(remove_nic_task)
response['msg'] = 'VM nic has been deleted.'
response['changed'] = True
return response
response['warnings'] = 'VM nic was not found'
return response
def update_nic(self):
vm = self.get_vm()
nic_id = self.params.get('nic_id')
network = self.params.get('network')
response = dict()
response['changed'] = False
nics = self.client.get_resource(vm.resource.get('href') + '/networkConnectionSection')
index = -1
for i, nic in enumerate(nics.NetworkConnection):
if nic.NetworkConnectionIndex == nic_id:
index = i
if index < 0:
EntityNotFoundException('Can\'t find the specified VM nic')
if network:
nics.NetworkConnection[index].set('network', network)
response['changed'] = True
if response['changed']:
update_nic_task = self.client.put_resource(
vm.resource.get('href') + '/networkConnectionSection', nics,
EntityType.NETWORK_CONNECTION_SECTION.value)
self.execute_task(update_nic_task)
response['msg'] = 'Vapp VM nic has been updated.'
return response
