def test_070_detach_disk_from_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.detach_disk_from_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 detach_disk_by_urn(ctx, vm_name, disk_urn, block=False):
try:
vm = find_vm_in_vapp(ctx, vm_name=vm_name)
if len(vm) > 0:
vm = vm[0]
vapp = ctx.vdc.get_vapp(vm['vapp_name'])
the_vapp = VApp(ctx.client, vm['vapp_name'], resource=vapp)
disks = get_disks(ctx)
for disk in disks:
if disk['id'] == disk_urn:
result = the_vapp.detach_disk_from_vm(disk['href'], vm['vm_name'])
if block == True:
task = ctx.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
return True
else:
return result
except Exception as e:
if ctx.config['debug'] == True:
raise
else:
pass
return False
def test_070_detach_disk_from_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.detach_disk_from_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_0060_detach_disk_from_vm_in_vapp(self):
"""Test the method vapp.detach_disk_to_vm().
Invoke the method for the second independent disk, detach it from the
first vm of the vApp created during setup. We need to power down the
vm before running this test, and power it back on once the test
is over.
This test passes if the disk detachment task succeeds.
"""
vdc = Environment.get_test_vdc(TestDisk._client)
vapp = VApp(TestDisk._client, href=TestDisk._test_vapp_href)
vm_name = TestDisk._test_vapp_first_vm_name
disk = vdc.get_disk(disk_id=TestDisk._idisk2_id)
# vm needs to be powered off for detach to succeed.
is_vapp_powered_on_before_test = vapp.is_powered_on()
if is_vapp_powered_on_before_test:
task = vapp.power_off()
TestDisk._client.get_task_monitor().wait_for_success(task=task)
vapp.reload()
task = vapp.detach_disk_from_vm(
disk_href=disk.get('href'), vm_name=vm_name)
TestDisk._client.get_task_monitor().wait_for_success(task=task)
vapp.reload()
# restore vApp to powered on state (if required)
if is_vapp_powered_on_before_test:
task = vapp.power_on()
TestDisk._client.get_task_monitor().wait_for_success(task=task)
def detach(ctx, vapp_name, vm_name, disk_name, disk_id):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
disk = vdc.get_disk(disk_name, disk_id)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.detach_disk_from_vm(disk_href=disk.get('href'),
disk_type=disk.get('type'),
disk_name=disk_name,
vm_name=vm_name)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def detach(ctx, vapp_name, vm_name, disk_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)
disk_name, disk_id = extract_name_and_id(disk_name)
disk = vdc.get_disk(name=disk_name, disk_id=disk_id)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.detach_disk_from_vm(disk_href=disk.get('href'),
vm_name=vm_name)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
def detach(ctx, vapp_name, vm_name, disk_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)
disk_name, disk_id = extract_name_and_id(disk_name)
disk = vdc.get_disk(name=disk_name, disk_id=disk_id)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
task = vapp.detach_disk_from_vm(
disk_href=disk.get('href'), vm_name=vm_name)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
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 == "update":
return self.update_disk()
if state == "absent":
return self.delete_disk()
if state == "attached":
return self.attach_disk()
if state == "detached":
return self.detach_disk()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "read":
return self.read_disks()
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):
size = self.params.get('size')
vm_name = self.params.get('vm_name')
response = dict()
response['changed'] = False
disks = self.read_disks().get('disks')
last_disk = list(disks.keys())[-1]
last_disk_instance_id = int(disks[last_disk]['InstanceID'])
new_disk_name = str(int(last_disk.split(' ')[2]) + 1)
new_disk_instance_id = last_disk_instance_id + 1
add_disk_task = self.vapp.add_disk_to_vm(vm_name, size)
self.execute_task(add_disk_task)
msg = 'Vapp VM disk of size {0} has been added.'
response['msg'] = msg.format(str(size))
response['metadata'] = {
'new_disk_name': 'Hard disk {0}'.format(new_disk_name),
'new_disk_size': size,
'new_disk_instance_id': new_disk_instance_id
}
response['changed'] = True
return response
def attach_disk(self):
vm = self.get_vm()
vm_name = vm.resource.get('name')
disk_name = self.params.get('disk_name')
response = dict()
response['changed'] = False
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))
disk = vdc_resource.get_disk(name=disk_name)
attach_disk_task = self.vapp.attach_disk_to_vm(disk_href=disk.get('href'), vm_name=vm_name)
self.execute_task(attach_disk_task)
msg = 'Independent disk {0} has been attached.'
response['msg'] = msg.format(disk_name)
response['changed'] = True
return response
def detach_disk(self):
vm = self.get_vm()
vm_name = vm.resource.get('name')
disk_name = self.params.get('disk_name')
response = dict()
response['changed'] = False
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))
disk = vdc_resource.get_disk(name=disk_name)
detach_disk_task = self.vapp.detach_disk_from_vm(disk_href=disk.get('href'), vm_name=vm_name)
self.execute_task(detach_disk_task)
msg = 'Independent disk {0} has been detached.'
response['msg'] = msg.format(disk_name)
response['changed'] = True
return response
def read_disks(self):
vm = self.get_vm()
response = dict()
response['changed'] = False
response['disks'] = dict()
disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks')
for disk in disks.Item:
if disk['{' + NSMAP['rasd'] + '}Description'] == "Hard disk":
disk_name = str(disk['{' + NSMAP['rasd'] + '}ElementName'])
disk_instance = int(disk['{' + NSMAP['rasd'] + '}InstanceID'])
disk_size = int(disk['{' + NSMAP['rasd'] + '}VirtualQuantity'])
disk_hostresource = disk['{' + NSMAP['rasd'] + '}HostResource']
disk_capacity = int(disk_hostresource.get('{' + NSMAP['vcloud'] + '}capacity'))
response['disks'][disk_name] = {
'InstanceID': disk_instance,
'VirtualQuantity': self.convert_bytes_to_gb(disk_size),
'HostResource': str(round(disk_capacity / 1024, 1)) + ' GB'
}
return response
def convert_bytes_to_gb(self, disk_size):
log_value = int(math.floor(math.log(disk_size, 1024)))
pow_value = math.pow(1024, log_value)
return str(round(disk_size / pow_value, 1)) + ' GB'
def update_disk(self):
vm = self.get_vm()
disk_name = self.params.get('disk_name')
size = self.params.get('size')
response = dict()
response['changed'] = False
index = -1
if not size:
err = '''Hard disk size argument is missing. Disk \'update\' operation only allows disk size to be updated
for the exisiting VM\'s.'''
raise Exception(err)
disks = self.client.get_resource(vm.resource.get('href') + '/virtualHardwareSection/disks')
for i, disk in enumerate(disks.Item):
if disk['{' + NSMAP['rasd'] + '}ElementName'] == disk_name:
index = i
if index < 0:
err = 'Can\'t find the specified VM disk with name {0}'
err = err.format(disk_name)
raise EntityNotFoundException(err)
disks.Item[index]['{' + NSMAP['rasd'] + '}VirtualQuantity'] = size * 1024 * 1024
disks.Item[index]['{' + NSMAP['rasd'] + '}HostResource'].set(
'{' + NSMAP['vcloud'] + '}capacity', str(size))
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)
msg = 'Vapp VM disk with name {0} has been updated.'
response['msg'] = msg.format(disk_name)
response['changed'] = True
return response
def delete_disk(self):
vm = self.get_vm()
disks_to_remove = self.params.get('disks')
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'] + '}ElementName'] in disks_to_remove:
disks.remove(disk)
disks_to_remove.remove(disk['{' + NSMAP['rasd'] + '}ElementName'])
if len(disks_to_remove) > 0:
err = 'VM disk(s) with name {0} was not found.'
err = err.format(','.join(disks_to_remove))
raise EntityNotFoundException(err)
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(s) has been deleted.'
response['changed'] = True
return response
