def add_disk(ctx, name, vm_name, size, storage_profile):
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)
task = vapp.add_disk_to_vm(vm_name, size)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
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 test_012_add_disk(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 self.config['vcd']['vapp'] == vapp_resource.get('name')
vm_name = self.config['vcd']['vm']
vapp = VApp(self.client, resource=vapp_resource)
disk_size = 1024 # 1GB
result = vapp.add_disk_to_vm(vm_name, disk_size)
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_012_add_disk(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 self.config['vcd']['vapp'] == vapp_resource.get('name')
vm_name = self.config['vcd']['vm']
vapp = VApp(self.client, resource=vapp_resource)
disk_size = 1024 # 1GB
result = vapp.add_disk_to_vm(vm_name, disk_size)
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
class VappVMDisk(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VappVMDisk, self).__init__(**kwargs)
self.org = self.get_org()
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()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "read":
return self.read_disks()
def get_org(self):
org_name = self.params.get('org_name')
org_resource = self.client.get_org()
if org_name:
org_resource = self.client.get_org_by_name(org_name)
return Org(self.client, resource=org_resource)
def get_resource(self):
vapp = self.params.get('vapp')
vdc = self.params.get('vdc')
vdc_resource = VDC(self.client, resource=self.org.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 get_formatted_disk_size(self, disk_size):
'''
Convert disk byte size into GB or MB
MB = 1024 * 1024 ( 2 ** 20 )
GB = 1024 * 1024 * 1024 ( 2 ** 30 )
Note - only MB and GB are supported from vCD
'''
log_value = int(math.floor(math.log(disk_size, 1024)))
pow_value = math.pow(1024, log_value)
size_metric = ' MB' if log_value == 2 else ' GB'
return str(round(disk_size / pow_value, 1)) + size_metric
def add_disk(self):
disks = self.params.get('disks')
vm_name = self.params.get('vm_name')
response = dict()
response['msg'] = list()
response['changed'] = False
available_disks = self.read_disks().get("disks").keys()
warnings = list()
for disk in disks:
disk_size = int(disk.get("size"))
disk_controller = disk.get("controller")
disk_name = disk.get("name")
'''
here the condition covers both the situtation
1. if someone has given the disk name then first it will
check for disk availability first before adding it.
2. if someone has ignored giving the disk name then it will
add a new disk any way.
'''
if disk_name not in available_disks:
add_disk_task = self.vapp.add_disk_to_vm(
vm_name, disk_size, disk_controller)
self.execute_task(add_disk_task)
msg = "A disk with size {0} and controller {1} has been added to VM {2}"
msg = msg.format(disk_size, disk_controller, vm_name)
response['changed'] = True
response['msg'].append(msg)
else:
warnings.append(disk_name)
if warnings:
warnings = ','.join(warnings)
msg = "Hard disk(s) with name '{0}' are already present"
response["warnings"] = msg.format(warnings)
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.get_formatted_disk_size(disk_size),
'HostResource': str(round(disk_capacity / 1024, 1)) + ' GB'
}
return response
def update_disk(self):
disks = self.params.get('disks')
response = dict()
response['changed'] = False
response['msg'] = list()
vm = self.get_vm()
vm_disks = self.client.get_resource(
vm.resource.get('href') + '/virtualHardwareSection/disks')
disk_names = [disk.get("name") for disk in disks]
disk_sizes = [disk.get("size", None) for disk in disks]
disk_sizes = list(filter(lambda size: size is not None, disk_sizes))
assert len(disk_sizes) == len(disk_names)
for index, disk_name in enumerate(disk_names):
for vm_disk_index, disk in enumerate(vm_disks.Item):
disk_size = int(disk_sizes[index])
if disk['{' + NSMAP['rasd'] + '}ElementName'] == disk_name:
disk['{' + NSMAP['rasd'] + '}VirtualQuantity'] = disk_size
disk['{' + NSMAP['rasd'] + '}HostResource'].set(
'{' + NSMAP['vcloud'] + '}capacity', str(disk_size))
vm_disks.Item[vm_disk_index] = disk
update_disk_task = self.client.put_resource(
vm.resource.get('href') + '/virtualHardwareSection/disks',
vm_disks, EntityType.RASD_ITEMS_LIST.value)
self.execute_task(update_disk_task)
msg = 'Vapp VM disk with name {0} has been updated.'
response['msg'].append(msg.format(disk_name))
response['changed'] = True
return response
def delete_disk(self):
vm = self.get_vm()
disks = self.params.get('disks')
disks_to_remove = [disk.get("name") for disk in 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:
error = 'VM disk(s) with name {0} was not found.'
error = error.format(','.join(disks_to_remove))
raise EntityNotFoundException(error)
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
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()
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 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
