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 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 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 test_080_update_disk(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)
result = vdc.update_disk(
name=self.config['vcd']['idisk_name'],
new_name=self.config['vcd']['idisk_new_name'],
new_size=self.config['vcd']['idisk_new_size'],
new_description=self.config['vcd']['idisk_new_description'],
new_storage_profile_name=self.config['vcd']['idisk_new_sp_name'],
new_iops=self.config['vcd']['idisk_new_iops'])
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=30,
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_03_get_vdc_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)
control_access = vdc.get_access_settings()
assert len(control_access.AccessSettings.AccessSetting) == 2
def update(self):
logging.info("__INIT__update[Vdc]")
res = vdc_pb2.UpdateVdcResult()
res.updated = False
context = self.context
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
#Vdc details
name = self.name
is_enabled = self.is_enabled
try:
vdc_resource = org.get_vdc(name)
vdc = VDC(self.client, name=name, resource=vdc_resource)
result = vdc.enable_vdc(is_enabled)
res.updated = True
except Exception as e:
error_message = '__ERROR_update[Vdc] failed for Vdc {0}. __ErrorMessage__ {1}'.format(
self.name, str(e))
logging.warn(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
return res
logging.info("__DONE__update[Vdc]")
return res
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_001_instantiate_vapp(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='net2',
fence_mode='natRouted',
deploy=False,
power_on=False)
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
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_001_list_edge_gateways(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, resource=v)
edge_gateways = vdc.list_edge_gateways()
assert len(edge_gateways) > 0
def create_disk(client):
logging.info('INIT create_disk')
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc('OVD2')
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
#task=vdc.delete_disk('disk01')
result = vdc.add_disk('disk02', "100")
logging.info('DONE create_disk %s', result)
task = 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=task_callback)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
logging.info("__LOG__ created DISK")
#cresult.created = True
else:
raise errors.VCDDiskCreationError(
etree.tostring(task, pretty_print=True))
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 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_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_06_unshare_vdc_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)
control_access = vdc.unshare_from_org_members()
assert control_access.IsSharedToEveryone.text == 'false'
def test_get_vdc(self):
org_to_use = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
org = Org(self.client, href=org_to_use.get('href'))
resource = org.get_vdc(self.config['vcd']['new_vdc'])
assert resource is not None
vdc = VDC(self.client, resource=resource)
assert self.config['vcd']['new_vdc'] == vdc.get_resource().get('name')
def test_05_share_vdc_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)
control_access = vdc.share_with_org_members()
assert control_access.IsSharedToEveryone.text == 'true'
assert control_access.EveryoneAccessLevel.text == 'ReadOnly'
def test_01_remove_all_vdc_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)
vdc.share_with_org_members()
control_access = vdc.remove_access_settings(remove_all=True)
self.assertFalse(hasattr(control_access, 'AccessSettings'))
def get_vapp_resource(self, vdc_name, vapp_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_href = vdc_resource.get_resource_href(
name=vapp_name, entity_type=EntityType.VAPP)
return self.client.get_resource(vapp_resource_href)
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_disable_vdc(self):
org_to_use = self.client.get_org_by_name(
self.config['vcd']['org_to_use'])
org = Org(self.client, href=org_to_use.get('href'))
resource = org.get_vdc(self.config['vcd']['new_vdc'])
vdc = VDC(self.client, resource=resource)
vdc.enable_vdc(False)
vdc.reload()
assert vdc.resource.IsEnabled.text == 'false'
def test_010_get_storage_profiles(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)
profiles = vdc.get_storage_profiles()
assert len(profiles) > 0
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 test_050_list_isolated_orgvdc_networks(self):
org_record = self.client.get_org_by_name(
self.config['vcd']['org_name'])
org = Org(self.client, href=org_record.get('href'))
vdc_resource = org.get_vdc(self.config['vcd']['vdc_name'])
vdc = VDC(self.client, href=vdc_resource.get('href'))
result = vdc.list_orgvdc_isolated_networks()
assert len(result) > 0
def read(self):
logging.info("__INIT__read[Vdc]")
res = vdc_pb2.ReadVdcResult()
res.present = False
context = self.context
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
#Vdc details
name = self.name
try:
vdc_resource = org.get_vdc(name)
res.name = name
#res.provider_vdc = str(result.provider_vdc)
res.description = str(vdc_resource.Description)
res.allocation_model = str(vdc_resource.AllocationModel)
res.cpu_units = str(vdc_resource.ComputeCapacity.Cpu.Units)
res.cpu_allocated = int(vdc_resource.ComputeCapacity.Cpu.Allocated)
res.cpu_limit = int(vdc_resource.ComputeCapacity.Cpu.Limit)
res.mem_units = str(vdc_resource.ComputeCapacity.Memory.Units)
res.mem_allocated = int(
vdc_resource.ComputeCapacity.Memory.Allocated)
res.mem_limit = int(vdc_resource.ComputeCapacity.Memory.Limit)
res.nic_quota = int(vdc_resource.NicQuota)
res.network_quota = int(vdc_resource.NetworkQuota)
res.vm_quota = int(vdc_resource.VmQuota)
#res.storage_profiles = str(vdc_resource.VdcStorageProfiles.VdcStorageProfile.get('name'))
#res.resource_guaranteed_memory = str(result.resource_guaranteed_memory)
#res.resource_guaranteed_cpu = str(result.resource_guaranteed_cpu)
res.vcpu_in_mhz = int(vdc_resource.VCpuInMhz2)
#res.is_thin_provision = str(result.is_thin_provision)
#res.network_pool_name = str(result.network_pool_name)
#res.uses_fast_provisioning = str(result.uses_fast_provisioning)
#res.over_commit_allowed = str(result.over_commit_allowed)
#res.vm_discovery_enabled = str(result.vm_discovery_enabled)
res.is_enabled = vdc_resource.IsEnabled
res.present = True
except Exception as e:
error_message = '__ERROR_read[Vdc] failed for Vdc {0}. __ErrorMessage__ {1}'.format(
self.name, str(e))
logging.warn(error_message)
#context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
#context.set_details(error_message)
return res
logging.info("__DONE__read[Vdc]")
return res
def test_04_remove_vdc_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)
control_access = vdc.remove_access_settings(
access_settings_list=[
{'name': self.config['vcd']['access_user'], 'type': 'user'}
])
assert len(control_access.AccessSettings.AccessSetting) == 1
def test_020_get_all_disks(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)
disks = vdc.get_disks()
assert len(disks) > 0
assert disks[0].get('name') == self.config['vcd']['idisk_name']
def test_030_get_disk_by_name(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)
fetched_disk = vdc.get_disk(name=self.config['vcd']['idisk_name'])
assert fetched_disk is not None
assert fetched_disk.get('name') == self.config['vcd']['idisk_name']
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 test_040_get_disk_by_id(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)
disks = vdc.get_disks()
assert len(disks) > 0
fetched_disk = vdc.get_disk(disk_id=disks[0].get('id'))
assert fetched_disk is not None
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 test_0008_shutdown_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.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 main():
argument_spec = vcd_fetch_vapps_argument_spec()
response = dict(msg=dict(type='str'), vapps=[])
module = VcdAnsibleModule(argument_spec=argument_spec,
supports_check_mode=True)
try:
vdc = module.params['vdc']
client = module.client
org_resource = client.get_org()
org = Org(client, resource=org_resource)
vdc_resource = org.get_vdc(vdc)
vdc = VDC(client, resource=vdc_resource)
vapps = vdc.list_resources(EntityType.VAPP)
for vapp in vapps:
response['vapps'].append(vapp.get('name'))
except Exception as error:
response['msg'] = error.__str__()
module.fail_json(**response)
module.exit_json(**response)
def test_010_create_disk(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)
result = vdc.create_disk(
name=self.config['vcd']['idisk_name'],
size=self.config['vcd']['idisk_size'],
description=self.config['vcd']['idisk_description'])
task = self.client.get_task_monitor().wait_for_status(
task=result.Tasks.Task[0],
timeout=30,
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_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_001_instantiate_vapp(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='net2',
fence_mode='natRouted',
deploy=False,
power_on=False)
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
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 test_008_update_disk_storage_profile(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'))
taskObj = vdc.update_disk(self.config['vcd']['disk'], "3072",
"DiskUpdated", "3 GB Disk", "*", "200")
task = self.client.get_task_monitor().wait_for_status(
task=taskObj,
timeout=30,
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
print(("Updating VDC disk: " +
str(etree.tostring(task, pretty_print=True), "utf-8")))
def create_cluster_thread(self):
network_name = self.body['network']
try:
clusters = load_from_metadata(self.client_tenant,
name=self.cluster_name)
if len(clusters) != 0:
raise Exception('Cluster already exists.')
org_resource = self.client_tenant.get_org()
org = Org(self.client_tenant, resource=org_resource)
vdc_resource = org.get_vdc(self.body['vdc'])
vdc = VDC(self.client_tenant, resource=vdc_resource)
template = self.get_template()
self.update_task(TaskStatus.RUNNING,
self.op,
message='Creating cluster vApp %s(%s)' %
(self.cluster_name, self.cluster_id))
vapp_resource = vdc.create_vapp(self.cluster_name,
description='cluster %s' %
self.cluster_name,
network=network_name,
fence_mode='bridged')
t = self.client_tenant.get_task_monitor().wait_for_status(
task=vapp_resource.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 t.get('status').lower() == TaskStatus.SUCCESS.value
tags = {}
tags['cse.cluster.id'] = self.cluster_id
tags['cse.version'] = pkg_resources.require(
'container-service-extension')[0].version
tags['cse.template'] = template['name']
vapp = VApp(self.client_tenant, href=vapp_resource.get('href'))
for k, v in tags.items():
t = vapp.set_metadata('GENERAL', 'READWRITE', k, v)
self.client_tenant.get_task_monitor().\
wait_for_status(
task=t,
timeout=600,
poll_frequency=5,
fail_on_status=None,
expected_target_statuses=[TaskStatus.SUCCESS],
callback=None)
self.update_task(TaskStatus.RUNNING,
self.op,
message='Creating master node for %s(%s)' %
(self.cluster_name, self.cluster_id))
vapp.reload()
add_nodes(1,
template,
TYPE_MASTER,
self.config,
self.client_tenant,
org,
vdc,
vapp,
self.body,
wait=True)
self.update_task(TaskStatus.RUNNING,
self.op,
message='Initializing cluster %s(%s)' %
(self.cluster_name, self.cluster_id))
vapp.reload()
init_cluster(self.config, vapp, template)
master_ip = get_master_ip(self.config, vapp, template)
t = vapp.set_metadata('GENERAL', 'READWRITE', 'cse.master.ip',
master_ip)
self.client_tenant.get_task_monitor().\
wait_for_status(
task=t,
timeout=600,
poll_frequency=5,
fail_on_status=None,
expected_target_statuses=[TaskStatus.SUCCESS],
callback=None)
if self.body['node_count'] > 0:
self.update_task(TaskStatus.RUNNING,
self.op,
message='Creating %s node(s) for %s(%s)' %
(self.body['node_count'], self.cluster_name,
self.cluster_id))
add_nodes(self.body['node_count'],
template,
TYPE_NODE,
self.config,
self.client_tenant,
org,
vdc,
vapp,
self.body,
wait=True)
self.update_task(TaskStatus.RUNNING,
self.op,
message='Adding %s node(s) to %s(%s)' %
(self.body['node_count'], self.cluster_name,
self.cluster_id))
vapp.reload()
join_cluster(self.config, vapp, template)
self.update_task(TaskStatus.SUCCESS,
self.op,
message='Created cluster %s(%s)' %
(self.cluster_name, self.cluster_id))
except Exception as e:
LOGGER.error(traceback.format_exc())
self.update_task(TaskStatus.ERROR, self.op, error_message=str(e))
print("User now exists: {0}".format(user_resource.get('name')))
# Ensure the user is enabled. We could also do so when creating the user
# but this approach will also fix an existing user who is disabled.
user_dict = to_dict(user_resource)
if user_dict.get('IsEnabled') == 'true':
print("User is enabled: {0}".format(user_dict.get('name')))
else:
print("User is not enabled, enabling...")
org.update_user(user_name=user_dict.get('name'), is_enabled=True)
print("User is now enabled: {0}".format(user_dict.get('name')))
# Ensure VDC exists. If we create it reload the org as it affects
# org resource contents and future calls might fail otherwise.
try:
vdc_resource = org.get_vdc(cfg.vdc['vdc_name'])
vdc = VDC(client, resource=vdc_resource)
print("VDC already exists: {0}".format(vdc.name))
except Exception:
print("VDC does not exist, creating: {0}".format(cfg.vdc['vdc_name']))
vdc_kwargs = cfg.vdc
# Vet the netpool and pvcd arguments as either can be '*' in which
# case we need to find default values.
_fill_in_pvdc_default(client, vdc_kwargs)
_fill_in_netpool_default(client, vdc_kwargs)
# Now create the VDC.
admin_vdc_resource = org.create_org_vdc(**vdc_kwargs)
# The 'admin_vdc_resource' is not a task but an AdminVdc entity. Tasks
# are two levels down.
handle_task(client, admin_vdc_resource.Tasks.Task[0])
org.reload()
config.read(CONF_PATH)
host = config['Main']['Host']
org = config['Main']['Org']
user = config['Main']['User']
password = config['Main']['Password']
vdc = config['Main']['Vdc']
db = ialab_db(config)
ldap = ldapConnection(config)
client = login(user, org, password)
org_resource = client.get_org()
org = Org(client, resource=org_resource)
vdc_resource = org.get_vdc(vdc)
vdc = VDC(client, resource=vdc_resource)
users = org.list_users()
for user in users:
name = user.attrib['name']
fullName = user.attrib['fullName']
href = user.attrib['href']
if db.checkIalabUserExistsByID(href) == False:
print(name)
db.insertIalabUser(name, href, fullName)
ldapUsers = ldap.getUserByUsername(name)
for ldapUser in ldapUsers:
ldap_username = ldapUser[0]
for email in ldapUser[1]:
def org_info(self):
response = dict()
response['changed'] = False
response['json'] = list()
##
org_details = dict()
org_name = self.params.get('org')
resource = self.client.get_org_by_name(org_name)
org = Org(self.client, resource=resource)
org_admin_resource = org.client.get_resource(org.href_admin)
#org_details['token'] = str(self.client.get_xvcloud_authorization_token())
org_details['href'] = str(org.href_admin)
org_details['name'] = str(org_admin_resource['FullName'])
org_details['description'] = str(org_admin_resource['Description'])
org_details['enabled'] = str(org_admin_resource['IsEnabled'])
org_details['users'] = list()
org_details['vdcs'] = list()
## Users/UserReference
for user in org_admin_resource['Users']['UserReference']:
org_details['users'].append({
'name': user.get('name'),
'href': user.get('href')
})
## Vdcs/Vdc
for vdc in org_admin_resource['Vdcs']['Vdc']:
vdc_resources = self.client.get_resource(vdc.get('href'))
## ResourceEntities/ResourceEntity
vapps = list()
try:
vdc_resources['ResourceEntities']['ResourceEntity']
except AttributeError:
vapps = list()
else:
for vapp in vdc_resources['ResourceEntities'][
'ResourceEntity']:
if "vApp+" in vapp.get('type'):
vapp_resourses = self.client.get_resource(
vapp.get('href'))
vms = list()
try:
vapp_resourses['Children']
except AttributeError:
vms = list()
else:
for vm in vapp_resourses['Children']['Vm']:
vm_info = self.vm_info(name=vm.get('name'),
vapp=vapp.get('name'))
vms = vm_info['json']
if len(vms) > 0:
vapps.append({
'href': str(vapp.get('href')),
'name': str(vapp.get('name')),
'vms': vms
})
## AvailableNetworks/Network
nets = list()
for net in vdc_resources['AvailableNetworks']['Network']:
nets.append({
'href': str(net.get('href')),
'name': str(net.get('name'))
})
## VdcStorageProfiles/VdcStorageProfile
storages = list()
for storage in vdc_resources['VdcStorageProfiles'][
'VdcStorageProfile']:
storage_resources = self.client.get_resource(
str(storage.get('href')))
storages.append({
'href':
str(storage.get('href')),
'name':
str(storage.get('name')),
'units':
str(storage_resources['Units']),
'total':
str(storage_resources['Limit']),
'used':
str(storage_resources['StorageUsedMB']),
'free':
str(storage_resources['Limit'] -
storage_resources['StorageUsedMB'])
})
vdc_name = vdc.get('name')
vdc_resource = org.get_vdc(vdc_name)
vdcenter = VDC(self.client, name=vdc_name, resource=vdc_resource)
gateways = vdcenter.list_edge_gateways()
org_details['vdcs'].append({
'name': vdc.get('name'),
'href': vdc.get('href'),
'cpu': {
'units':
str(vdc_resources['ComputeCapacity']['Cpu']['Units']),
'total':
str(vdc_resources['ComputeCapacity']['Cpu']['Limit']),
'used':
str(vdc_resources['ComputeCapacity']['Cpu']['Used']),
'free':
str(vdc_resources['ComputeCapacity']['Cpu']['Limit'] -
vdc_resources['ComputeCapacity']['Cpu']['Used'])
},
'ram': {
'units':
str(vdc_resources['ComputeCapacity']['Memory']['Units']),
'total':
str(vdc_resources['ComputeCapacity']['Memory']['Limit']),
'used':
str(vdc_resources['ComputeCapacity']['Memory']['Used']),
'free':
str(vdc_resources['ComputeCapacity']['Memory']['Limit'] -
vdc_resources['ComputeCapacity']['Memory']['Used'])
},
'vapps': vapps,
'networks': nets,
'storages': storages,
'gateways': gateways
})
## Networks/Network
## Catalogs/CatalogReference
response['json'] = org_details
##
response['changed'] = True
return response
class Vdc(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vdc, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
def manage_states(self):
state = self.params.get('state')
if state == 'present':
return self.create()
if state == 'absent':
return self.delete()
if state == 'update':
return self.update()
def create(self):
vdc_name = self.params.get('vdc_name')
is_enabled = self.params.get('is_enabled')
provider_vdc_name = self.params.get('provider_vdc_name')
description = self.params.get('description')
allocation_model = self.params.get('allocation_model')
storage_profiles = json.loads(self.params.get('storage_profiles'))
cpu_units = self.params.get('cpu_units')
cpu_allocated = self.params.get('cpu_allocated')
cpu_limit = self.params.get('cpu_limit')
mem_units = self.params.get('mem_units')
mem_allocated = self.params.get('mem_allocated')
mem_limit = self.params.get('mem_limit')
nic_quota = self.params.get('nic_quota')
network_quota = self.params.get('network_quota')
vm_quota = self.params.get('vm_quota')
resource_guaranteed_memory = self.params.get(
'resource_guaranteed_memory')
resource_guaranteed_cpu = self.params.get('resource_guaranteed_cpu')
vcpu_in_mhz = self.params.get('vcpu_in_mhz')
is_thin_provision = self.params.get('is_thin_provision')
network_pool_name = self.params.get('network_pool_name')
uses_fast_provisioning = self.params.get('uses_fast_provisioning')
over_commit_allowed = self.params.get('over_commit_allowed')
vm_discovery_enabled = self.params.get('vm_discovery_enabled')
storage_profiles = storage_profiles if type(
storage_profiles) is list else [storage_profiles]
response = dict()
response['changed'] = False
try:
self.org.get_vdc(vdc_name)
except EntityNotFoundException:
create_vdc_task = self.org.create_org_vdc(
vdc_name=vdc_name,
provider_vdc_name=provider_vdc_name,
description=description,
allocation_model=allocation_model,
storage_profiles=storage_profiles,
cpu_units=cpu_units,
cpu_allocated=cpu_allocated,
cpu_limit=cpu_limit,
mem_units=mem_units,
mem_allocated=mem_allocated,
mem_limit=mem_limit,
nic_quota=nic_quota,
network_quota=network_quota,
vm_quota=vm_quota,
resource_guaranteed_memory=resource_guaranteed_memory,
resource_guaranteed_cpu=resource_guaranteed_cpu,
vcpu_in_mhz=vcpu_in_mhz,
is_thin_provision=is_thin_provision,
network_pool_name=network_pool_name,
uses_fast_provisioning=uses_fast_provisioning,
over_commit_allowed=over_commit_allowed,
vm_discovery_enabled=vm_discovery_enabled,
is_enabled=is_enabled)
self.execute_task(create_vdc_task.Tasks.Task[0])
response['msg'] = 'VDC {} has been created.'.format(vdc_name)
response['changed'] = True
else:
response['warnings'] = 'VDC {} is already present.'.format(
vdc_name)
return response
def update(self):
vdc_name = self.params.get('vdc_name')
is_enabled = self.params.get('is_enabled')
response = dict()
response['changed'] = False
vdc_resource = self.org.get_vdc(vdc_name)
vdc = VDC(self.client, name=vdc_name, resource=vdc_resource)
vdc.enable_vdc(enable=is_enabled)
response['msg'] = 'VDC {} has been updated.'.format(vdc_name)
response['changed'] = True
return response
def delete(self):
vdc_name = self.params.get('vdc_name')
response = dict()
response['changed'] = False
try:
vdc_resource = self.org.get_vdc(vdc_name)
except EntityNotFoundException:
response['warnings'] = 'VDC {} is not present.'.format(vdc_name)
else:
vdc = VDC(self.client, name=vdc_name, resource=vdc_resource)
vdc.enable_vdc(enable=False)
delete_vdc_task = vdc.delete_vdc()
self.execute_task(delete_vdc_task)
response['msg'] = 'VDC {} has been deleted.'.format(vdc_name)
response['changed'] = True
return response
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
state = self.params.get('operation')
if state == "poweron":
return self.power_on()
if state == "poweroff":
return self.power_off()
if state == "deploy":
return self.deploy()
if state == "undeploy":
return self.undeploy()
def create(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(
vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(name=vapp_name,
force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered on.'.format(
vapp_name)
return response
def power_off(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_off_vapp_task = vapp.power_off()
self.execute_task(power_off_vapp_task)
response['msg'] = 'Vapp {} has been powered off.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already powered off.'.format(
vapp_name)
return response
def deploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
response['msg'] = 'Vapp {} has been deployed.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already deployed.'.format(
vapp_name)
return response
def undeploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
try:
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
undeploy_vapp_task = vapp.undeploy()
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been undeployed.'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException:
response['warnings'] = 'Vapp {} is already undeployed.'.format(
vapp_name)
return response
def create(client, context, vappInfo):
logging.debug('__INIT__vapp_create [ {0} ]'.format(vappInfo))
cresult = vapp_pb2.CreateVAppResult()
cresult.created = False
#cresult.in_vapp_info=vapp_pb2.CreateVAppInfo()
cresult.in_vapp_info.CopyFrom(vappInfo)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vappInfo.vdc)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
logging.info("__LOG__vapp_create_calling instantiate_vapp............")
network = None
memory = None
storage_profile = None
accept_all_eulas = False
power_on = False
if vappInfo.network:
network = vappInfo.network
if vappInfo.memory:
memory = vappInfo.memory
if vappInfo.storage_profile:
storage_profile = vappInfo.storage_profile
if vappInfo.accept_all_eulas:
accept_all_eulas = vappInfo.accept_all_eulas
if vappInfo.power_on:
power_on = vappInfo.power_on
logging.info(
"__LOG__ CREATE VAPP Params - MEMORY = [%s] NETWORK = [%s] storage_profile =[%s] ",
memory, network, storage_profile)
result = vdc.instantiate_vapp(name=vappInfo.name,
catalog=vappInfo.catalog_name,
template=vappInfo.template_name,
network=network,
memory=memory,
cpu=vappInfo.cpu,
power_on=power_on,
storage_profile=storage_profile,
accept_all_eulas=accept_all_eulas)
task = 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=task_callback)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
cresult.created = True
else:
raise errors.VCDVappCreationError(
etree.tostring(task, pretty_print=True))
vapp = vdc.get_vapp(vappInfo.name)
if vappInfo.power_on is True:
logging.info("Powering on [Vapp %v]".format(vappInfo.name))
vapp.power_on()
else:
logging.info("Powering off [Vapp %v]".format(vappInfo.name))
vapp.undeploy()
except Exception as e:
error_message = 'ERROR.. Not Created VApp {0} {1}'.format(
vappInfo.name, str(e))
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
return cresult
# Create an Instance of Org by specifying org's href
org = Org(client, href=(o.attrib['href']))
cprint("\nList of all VDCs in the Organization {}".format(o.get('name')),
'yellow')
vdclist = org.list_vdcs()
vdctable = PrettyTable(["Organization", "VDC name", "VDC href"])
for i in range(len(vdclist)):
vdctable.add_row(
[o.get('name'), vdclist[i]['name'], vdclist[i]['href']])
print(vdctable)
# Iterate over VDCs to retrieve data about Edges, Org Networks, vAPPs and VMs
for vdc in vdclist:
# print("\nFetching VDC {}".format(vdc['name']))
vdc_resource = org.get_vdc(vdc['name'])
vdc_instance = VDC(client, resource=vdc_resource)
cprint("\nList of all Tenant Edges in the VDC {}".format(vdc['name']),
'yellow')
edgelist = vdc_instance.list_edge_gateways()
edgetable = PrettyTable(
["Organization", "VDC name", "Edge name", "Edge href"])
for j in range(len(edgelist)):
edgetable.add_row([
o.get('name'), vdc['name'], edgelist[j]['name'],
edgelist[j]['href']
])
print(edgetable)
# Retrieve VDC Org Networks ---------------------------------------------------------------
class OrgVdcNetwork(VcdAnsibleModule):
def __init__(self, **kwargs):
super(OrgVdcNetwork, self).__init__(**kwargs)
self.vdc_name = self.params.get('vdc_name')
self.org_name = self.params.get('org_name')
org_resource = self.client.get_org_by_name(self.org_name)
self.org = Org(self.client, resource=org_resource)
vdc_resource = self.org.get_vdc(self.vdc_name)
self.vdc = VDC(self.client, name=self.vdc_name, resource=vdc_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create_org_vdc_network()
if state == "absent":
return self.delete_org_vdc_network()
def create_org_vdc_network(self):
direct = self.params.get('direct')
isolated = self.params.get('isolated')
routed = self.params.get('routed')
if direct:
return self.create_org_vdc_direct_network()
elif isolated:
return self.create_org_vdc_isolated_network()
elif routed:
return self.create_org_vdc_routed_network()
raise ValueError("Bool 'direct', 'isolated' or 'routed' is missing")
def create_org_vdc_direct_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
parent_network_name = self.params.get('parent_network_name')
description = self.params.get('description')
shared = self.params.get('shared')
try:
self.vdc.get_direct_orgvdc_network(network_name)
except EntityNotFoundException:
create_task = self.vdc.create_directly_connected_vdc_network(
network_name,
parent_network_name,
description=description,
is_shared=shared)
self.execute_task(create_task.Tasks.Task[0])
msg = 'Org VDC Direct Network {0} has been created'
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = 'Org VDC Direct Network {0} is already present'
response['warnings'] = msg.format(network_name)
return response
def create_org_vdc_isolated_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
network_cidr = self.params.get('network_cidr')
description = self.params.get('description')
shared = self.params.get('shared')
primary_dns_ip = self.params.get('primary_dns_ip')
secondary_dns_ip = self.params.get('secondary_dns_ip')
dns_suffix = self.params.get('dns_suffix')
ip_range_start = self.params.get('ip_range_start')
ip_range_end = self.params.get('ip_range_end')
dhcp_enabled = self.params.get('dhcp_enabled')
default_lease_time = self.params.get('default_lease_time')
max_lease_time = self.params.get('max_lease_time')
dhcp_ip_range_start = self.params.get('dhcp_ip_range_start')
dhcp_ip_range_end = self.params.get('dhcp_ip_range_end')
try:
self.vdc.get_isolated_orgvdc_network(network_name)
except EntityNotFoundException:
create_task = self.vdc.create_isolated_vdc_network(
network_name,
network_cidr,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_dhcp_enabled=dhcp_enabled,
default_lease_time=default_lease_time,
max_lease_time=max_lease_time,
dhcp_ip_range_start=dhcp_ip_range_start,
dhcp_ip_range_end=dhcp_ip_range_end,
is_shared=shared)
self.execute_task(create_task.Tasks.Task[0])
msg = 'Org VDC Isolated Network {0} has been created'
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = 'Org VDC Isolated Network {0} is already present'
response['warnings'] = msg.format(network_name)
return response
def create_org_vdc_routed_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
gateway_name = self.params.get('gateway_name')
network_cidr = self.params.get('network_cidr')
description = self.params.get('description')
shared = self.params.get('shared')
primary_dns_ip = self.params.get('primary_dns_ip')
secondary_dns_ip = self.params.get('secondary_dns_ip')
dns_suffix = self.params.get('dns_suffix')
ip_range_start = self.params.get('ip_range_start')
ip_range_end = self.params.get('ip_range_end')
guest_vx_vlan_allowed = self.params.get('guest_vx_vlan_allowed')
sub_interface = self.params.get('sub_interface')
distributed_interface = self.params.get('distributed_interface')
retain_net_info_across_deployments = self.params.get(
'retain_net_info_across_deployments')
try:
self.vdc.get_routed_orgvdc_network(network_name)
except EntityNotFoundException:
create_task = self.vdc.create_routed_vdc_network(
network_name,
gateway_name,
network_cidr,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_shared=shared,
guest_vx_vlan_allowed=guest_vx_vlan_allowed,
sub_interface=sub_interface,
distributed_interface=distributed_interface,
retain_net_info_across_deployments=
retain_net_info_across_deployments)
self.execute_task(create_task.Tasks.Task[0])
msg = 'Org VDC Routed Network {0} has been created'
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = 'Org VDC Routed Network {0} is already present'
response['warnings'] = msg.format(network_name)
return response
def delete_org_vdc_network(self):
response = dict()
response['changed'] = False
direct = self.params.get('direct')
isolated = self.params.get('isolated')
routed = self.params.get('routed')
if direct:
return self.delete_org_vdc_direct_network()
if isolated:
return self.delete_org_vdc_isolated_network()
if routed:
return self.delete_org_vdc_routed_network()
raise ValueError("Bool 'direct', 'isolated' or 'routed' is missing")
def delete_org_vdc_direct_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
force = self.params.get('force')
try:
self.vdc.get_direct_orgvdc_network(network_name)
except EntityNotFoundException:
msg = "Org VDC Direct Network {0} is not present"
response['warnings'] = msg.format(network_name)
else:
delete_task = self.vdc.delete_direct_orgvdc_network(network_name,
force=force)
self.execute_task(delete_task)
msg = 'Org VDC Direct Network {} has been deleted'
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def delete_org_vdc_isolated_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
force = self.params.get('force')
try:
self.vdc.get_isolated_orgvdc_network(network_name)
except EntityNotFoundException:
msg = "Org VDC Direct Network {0} is not present"
response['warnings'] = msg.format(network_name)
else:
delete_task = self.vdc.delete_isolated_orgvdc_network(network_name,
force=force)
self.execute_task(delete_task)
msg = 'Org VDC Direct Network {} has been deleted'
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def delete_org_vdc_routed_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
force = self.params.get('force')
try:
self.vdc.get_routed_orgvdc_network(network_name)
except EntityNotFoundException:
msg = "Org VDC Direct Network {0} is not present"
response['warnings'] = msg.format(network_name)
else:
delete_task = self.vdc.delete_routed_orgvdc_network(network_name,
force=force)
self.execute_task(delete_task)
msg = 'Org VDC Direct Network {} has been deleted'
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def install_cse(ctx, config_file_name, template_name, no_capture, update,
amqp_install, ext_install):
check_config(config_file_name)
click.secho('Installing CSE on vCD from file: %s, template: %s' %
(config_file_name, template_name))
config = get_config(config_file_name)
client = Client(config['vcd']['host'],
api_version=config['vcd']['api_version'],
verify_ssl_certs=config['vcd']['verify'],
log_file='cse-install.log',
log_headers=True,
log_bodies=True)
client.set_credentials(
BasicLoginCredentials(config['vcd']['username'], 'System',
config['vcd']['password']))
click.echo(
'Connected to vCloud Director as system '
'administrator (%s:%s): %s' %
(config['vcd']['host'], config['vcd']['port'], bool_to_msg(True)))
click.secho('Installing \'%s\' service broker' % config['broker']['type'])
if config['broker']['type'] == 'default':
orgs = client.get_org_list()
org_href = None
for org in [o for o in orgs.Org if hasattr(orgs, 'Org')]:
if org.get('name') == config['broker']['org']:
org_href = org.get('href')
org = Org(client, href=org_href)
click.echo('Find org \'%s\': %s' % (org.get_name(), bool_to_msg(True)))
vdc_resource = org.get_vdc(config['broker']['vdc'])
click.echo('Find vdc \'%s\': %s' %
(vdc_resource.get('name'), bool_to_msg(True)))
try:
catalog = org.get_catalog(config['broker']['catalog'])
except Exception:
click.secho('Creating catalog %s ' % config['broker']['catalog'],
nl=False,
fg='green')
catalog = org.create_catalog(config['broker']['catalog'],
'CSE catalog')
org.share_catalog(config['broker']['catalog'])
click.secho('done', fg='blue')
catalog = org.get_catalog(config['broker']['catalog'])
click.echo(
'Find catalog \'%s\': %s' %
(config['broker']['catalog'], bool_to_msg(catalog is not None)))
for template in config['broker']['templates']:
if template_name == '*' or template['name'] == template_name:
click.secho('Processing template: %s' % template['name'])
k8s_template = None
try:
k8s_template = org.get_catalog_item(
config['broker']['catalog'], template['catalog_item'])
click.echo(
'Find template \'%s\', \'%s\': %s' %
(config['broker']['catalog'], template['catalog_item'],
bool_to_msg(k8s_template is not None)))
except Exception:
pass
try:
if k8s_template is None or update:
if update:
click.secho('Updating template')
else:
click.secho('Creating template')
create_template(ctx, config, client, org, vdc_resource,
catalog, no_capture, template)
k8s_template = org.get_catalog_item(
config['broker']['catalog'],
template['catalog_item'])
if update:
click.echo('Updated template \'%s\', \'%s\': %s' %
(config['broker']['catalog'],
template['catalog_item'],
bool_to_msg(k8s_template is not None)))
else:
click.echo('Find template \'%s\', \'%s\': %s' %
(config['broker']['catalog'],
template['catalog_item'],
bool_to_msg(k8s_template is not None)))
except Exception:
LOGGER.error(traceback.format_exc())
click.echo('Can\'t create or update template \'%s\' '
'\'%s\': %s' %
(template['name'], config['broker']['catalog'],
template['catalog_item']))
configure_amqp_settings(ctx, client, config, amqp_install)
register_extension(ctx, client, config, ext_install)
click.secho('Start CSE with: \'cse run %s\'' % config_file_name)
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)
class Vdc(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vdc, self).__init__(**kwargs)
self.org = Org(self.client, resource=self.get_vdc_org_resource())
def manage_states(self):
state = self.params.get('state')
if state == 'present':
return self.create()
if state == 'absent':
return self.delete()
if state == 'update':
return self.update()
def manage_operations(self):
operation = self.params.get('operation')
if operation == 'add_storage_profile':
return self.add_storage_profile()
if operation == 'update_storage_profile':
return self.update_storage_profile()
if operation == 'delete_storage_profile':
return self.delete_storage_profile()
if operation == 'list_storage_profiles':
return self.get_storage_profiles()
def get_vdc_org_resource(self):
if self.params.get('vdc_org_name'):
return self.client.get_org_by_name(self.params.get('vdc_org_name'))
return self.client.get_org()
def get_vdc(self):
try:
vdc_name = self.params['vdc_name']
vdc_resource = self.org.get_vdc(vdc_name)
assert vdc_resource is not None
except AssertionError:
msg = "{0} is not found"
raise EntityNotFoundException(msg.format(vdc_name))
return VDC(self.client, name=vdc_name, resource=vdc_resource)
def create(self):
vdc_name = self.params['vdc_name']
is_enabled = self.params['is_enabled']
provider_vdc_name = self.params['provider_vdc_name']
description = self.params['description'] or ''
allocation_model = self.params['allocation_model'] or 'AllocationVApp'
storage_profiles = self.params['storage_profiles']
cpu_units = self.params['cpu_units'] or "MHz"
cpu_allocated = self.params['cpu_allocated'] or 0
cpu_limit = self.params['cpu_limit'] or 0
mem_units = self.params['mem_units'] or 'MB'
mem_allocated = self.params['mem_allocated'] or 0
mem_limit = self.params['mem_limit'] or 0
nic_quota = self.params['nic_quota'] or 0
network_quota = self.params['network_quota'] or 0
vm_quota = self.params['vm_quota'] or 0
resource_guaranteed_memory = self.params[
'resource_guaranteed_memory'] or 1.0
resource_guaranteed_cpu = self.params['resource_guaranteed_cpu'] or 1.0
vcpu_in_mhz = self.params['vcpu_in_mhz']
is_thin_provision = self.params['is_thin_provision']
network_pool_name = self.params['network_pool_name']
uses_fast_provisioning = self.params['uses_fast_provisioning']
over_commit_allowed = self.params['over_commit_allowed']
vm_discovery_enabled = self.params['vm_discovery_enabled']
response = dict()
response['changed'] = False
response['msg'] = self.params["description"] or "None"
try:
self.get_vdc()
except EntityNotFoundException:
create_vdc_task = self.org.create_org_vdc(
vdc_name=vdc_name,
provider_vdc_name=provider_vdc_name,
description=description,
allocation_model=allocation_model,
storage_profiles=storage_profiles,
cpu_units=cpu_units,
cpu_allocated=cpu_allocated,
cpu_limit=cpu_limit,
mem_units=mem_units,
mem_allocated=mem_allocated,
mem_limit=mem_limit,
nic_quota=nic_quota,
network_quota=network_quota,
vm_quota=vm_quota,
resource_guaranteed_memory=resource_guaranteed_memory,
resource_guaranteed_cpu=resource_guaranteed_cpu,
vcpu_in_mhz=vcpu_in_mhz,
is_thin_provision=is_thin_provision,
network_pool_name=network_pool_name,
uses_fast_provisioning=uses_fast_provisioning,
over_commit_allowed=over_commit_allowed,
vm_discovery_enabled=vm_discovery_enabled,
is_enabled=is_enabled)
self.execute_task(create_vdc_task.Tasks.Task[0])
response['msg'] = 'VDC {} has been created'.format(vdc_name)
response['changed'] = True
else:
response['warnings'] = 'VDC {} is already present'.format(vdc_name)
return response
def update(self):
vdc_name = self.params['vdc_name']
description = self.params['description']
allocation_model = self.params['allocation_model']
cpu_units = self.params['cpu_units']
cpu_allocated = self.params['cpu_allocated']
cpu_limit = self.params['cpu_limit']
mem_units = self.params['mem_units']
mem_allocated = self.params['mem_allocated']
mem_limit = self.params['mem_limit']
nic_quota = self.params['nic_quota']
network_quota = self.params['network_quota']
vm_quota = self.params['vm_quota']
resource_guaranteed_memory = self.params['resource_guaranteed_memory']
resource_guaranteed_cpu = self.params['resource_guaranteed_cpu']
vcpu_in_mhz = self.params['vcpu_in_mhz']
is_thin_provision = self.params['is_thin_provision']
is_enabled = self.params['is_enabled']
response = dict()
response['changed'] = False
try:
self.get_vdc()
update_org_vdc_task = self.org.update_org_vdc(
vdc_name, description, allocation_model, cpu_units,
cpu_allocated, cpu_limit, mem_units, mem_allocated, mem_limit,
nic_quota, network_quota, vm_quota, resource_guaranteed_memory,
resource_guaranteed_cpu, vcpu_in_mhz, is_thin_provision,
is_enabled)
self.execute_task(update_org_vdc_task)
response['msg'] = 'VDC {} has been updated'.format(vdc_name)
response['changed'] = True
except OperationNotSupportedException:
msg = "VDC {} may already in desired state"
response['warnings'] = msg.format(vdc_name)
except EntityNotFoundException:
response['warnings'] = 'VDC {} is not present.'.format(vdc_name)
return response
def delete(self):
vdc_name = self.params['vdc_name']
response = dict()
response['changed'] = False
try:
vdc = self.get_vdc()
vdc.enable_vdc(enable=False)
delete_vdc_task = vdc.delete_vdc()
self.execute_task(delete_vdc_task)
response['msg'] = 'VDC {} has been deleted.'.format(vdc_name)
response['changed'] = True
except EntityNotFoundException:
response['warnings'] = 'VDC {} is not present.'.format(vdc_name)
except OperationNotSupportedException:
pass
return response
def get_storage_profiles(self):
vdc_name = self.params['vdc_name']
response = dict()
response['changed'] = False
try:
vdc = self.get_vdc()
response['msg'] = [
storage_profile.get("name")
for storage_profile in vdc.get_storage_profiles()
]
except EntityNotFoundException:
msg = 'VDC {} is not present'
response['warnings'] = msg.format(vdc_name)
return response
def _update_response(self, response, msg, warning):
vdc_name = self.params['vdc_name']
if response['msg']:
response['msg'] = msg.format(response['msg'], vdc_name)
if response['warnings']:
response['warnings'] = warning.format(response['warnings'])
return response
def add_storage_profile(self):
vdc_name = self.params['vdc_name']
profiles = self.params['storage_profiles']
response = dict()
response['changed'] = False
response['msg'] = list()
response['warnings'] = list()
storage_profiles = self.get_storage_profiles()['msg']
msg = 'VDC Storage profile(s) {0} are added'
warning = 'VDC Storage profile(s) {0} are already present'
try:
vdc = self.get_vdc()
for profile in profiles:
name = profile['name']
if name not in storage_profiles:
enabled = profile['enabled']
default = profile['default']
kwargs = {
'enabled': True if enabled == 'true' else False,
'default': True if default == 'true' else False,
'limit_in_mb': profile['limit']
}
task = vdc.add_storage_profile(name, **kwargs)
self.execute_task(task)
response['msg'].append(profile['name'])
continue
response['warnings'].append(name)
response = self._update_response(response, msg, warning)
except EntityNotFoundException:
msg = 'VDC {} is not present'
response['warnings'] = msg.format(vdc_name)
return response
def update_storage_profile(self):
vdc_name = self.params['vdc_name']
profiles = self.params['storage_profiles']
response = dict()
response['changed'] = False
response['msg'] = list()
response['warnings'] = list()
storage_profiles = self.get_storage_profiles()['msg']
msg = 'Storage profile(s) {0} are updated'
warning = 'VDC Storage profile(s) {0} are not found'
try:
vdc = self.get_vdc()
for profile in profiles:
name = profile['name']
if name in storage_profiles:
enabled = True if profile['enabled'] == 'true' else False
kwargs = {
'default': profile.get('default', None),
'limit_in_mb': profile.get('limit', None)
}
vdc.update_storage_profile(name, enabled, **kwargs)
response['msg'].append(name)
continue
response['warnings'].append(name)
response = self._update_response(response, msg, warning)
except EntityNotFoundException:
msg = 'VDC {} is not present'
response['warnings'] = msg.format(vdc_name)
return response
def delete_storage_profile(self):
vdc_name = self.params['vdc_name']
profiles = self.params['storage_profiles']
response = dict()
response['msg'] = list()
response['warnings'] = list()
response['changed'] = False
storage_profiles = self.get_storage_profiles()['msg']
msg = 'Storage profile(s) {0} are deleted'
warning = 'VDC Storage profile(s) {0} are not found'
try:
vdc = self.get_vdc()
for profile in profiles:
name = profile.get("name")
if name in storage_profiles:
remove_vdc_task = vdc.remove_storage_profile(name)
self.execute_task(remove_vdc_task)
response['msg'].append(name)
continue
response['warnings'].append(name)
response = self._update_response(response, msg, warning)
except EntityNotFoundException:
msg = 'VDC {} is not present'
response['warnings'] = msg.format(vdc_name)
return response
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
state = self.params.get('operation')
if state == "poweron":
return self.power_on()
if state == "poweroff":
return self.power_off()
if state == "deploy":
return self.deploy()
if state == "undeploy":
return self.undeploy()
if state == "list_vms":
return self.list_vms()
if state == "list_networks":
return self.list_networks()
def get_vapp(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
return VApp(self.client, name=vapp_name, resource=vapp_resource)
def instantiate(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(vapp_name)
return response
def create(self):
params = self.params
catalog_name = params.get('catalog_name')
# vapp initialization if catalog has been provided
if catalog_name:
return self.instantiate()
vapp_name = params.get('vapp_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
accept_all_eulas = params.get('accept_all_eulas')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.create_vapp(
name=vapp_name,
description=description,
network=network,
fence_mode=fence_mode,
accept_all_eulas=accept_all_eulas)
self.execute_task(create_vapp_task.Tasks.Task[0])
response['msg'] = 'Vapp {} has been created.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = "Vapp {} is already present.".format(vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(name=vapp_name, force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
try:
if not vapp.is_powered_on():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_on_vapp_task = vapp.power_on()
self.execute_task(power_on_vapp_task)
response['msg'] = 'Vapp {} has been powered on.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already powered on.'.format(vapp_name)
except OperationNotSupportedException:
response['warnings'] = 'Operation is not supported. You may have no VM(s) in {}'.format(vapp_name)
return response
def power_off(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
try:
if not vapp.is_powered_off():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
power_off_vapp_task = vapp.power_off()
self.execute_task(power_off_vapp_task)
response['msg'] = 'Vapp {} has been powered off.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already powered off.'.format(vapp_name)
except OperationNotSupportedException:
response['warnings'] = 'Operation is not supported. You may have no VM(s) in {}'.format(vapp_name)
return response
def deploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
if not vapp.is_deployed():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
response['msg'] = 'Vapp {} has been deployed.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already deployed.'.format(vapp_name)
return response
def undeploy(self):
vapp_name = self.params.get('vapp_name')
response = dict()
response['changed'] = False
vapp = self.get_vapp()
if vapp.is_deployed():
vapp_resource = self.vdc.get_vapp(vapp_name)
vapp = VApp(self.client, name=vapp_name, resource=vapp_resource)
undeploy_vapp_task = vapp.undeploy()
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been undeployed.'.format(vapp_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp {} is already undeployed.'.format(vapp_name)
return response
def list_vms(self):
vapp = self.get_vapp()
response = dict()
response['msg'] = list()
for vm in vapp.get_all_vms():
vm_details = dict()
vm_details['name'] = vm.get('name')
vm_details['status'] = VM_STATUSES[vm.get('status')]
vm_details['deployed'] = vm.get('deployed') == 'true'
try:
vm_details['ip_address'] = vapp.get_primary_ip(vm.get('name'))
except Exception:
vm_details['ip_address'] = None
response['msg'].append(vm_details)
return response
def list_networks(self):
vapp = self.get_vapp()
response = dict()
response['msg'] = list()
for network in vapp.get_all_networks():
response['msg'].append(network.get('{' + NSMAP['ovf'] + '}name'))
return response
class CatalogItem(VcdAnsibleModule):
def __init__(self, **kwargs):
super(CatalogItem, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.upload()
if state == "absent":
return self.delete()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "capturevapp":
return self.capture_vapp()
if operation == "list_vms":
return self.list_vms()
def is_present(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
try:
self.org.get_catalog_item(catalog_name, item_name)
except EntityNotFoundException:
return False
return True
def upload(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
file_name = params.get('file_name')
chunk_size = params.get('chunk_size')
response = dict()
response['changed'] = False
item_details = {
"catalog_name": catalog_name,
"item_name": item_name,
"file_name": file_name,
"chunk_size": chunk_size
}
if self.is_present():
response['warnings'] = "Catalog Item {} is already present.".format(item_name)
return response
if file_name.endswith(".ova") or file_name.endswith(".ovf"):
self.org.upload_ovf(**item_details)
self.ova_check_resolved()
if not file_name.endswith(".ova"):
self.org.upload_media(**item_details)
response['msg'] = "Catalog item {} is uploaded.".format(item_name)
response['changed'] = True
return response
def delete(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = dict()
response['changed'] = False
if not self.is_present():
response['warnings'] = "Catalog Item {} is not present.".format(item_name)
return response
self.org.delete_catalog_item(name=catalog_name, item_name=item_name)
response['msg'] = "Catalog Item {} has been deleted.".format(item_name)
response['changed'] = True
return response
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 ova_check_resolved(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = False
source_ova_item = self.org.get_catalog_item(catalog_name, item_name)
self.check_resolved(source_ova_item, catalog_name, item_name)
response = True
return response
def check_resolved(self, source_ova_item, catalog_name, item_name):
client = self.client
item_id = source_ova_item.get('id')
while True:
q = client.get_typed_query(
'catalogItem',
query_result_format=QueryResultFormat.ID_RECORDS,
qfilter='id==%s' % item_id
)
records = list(q.execute())
if records[0].get('status') == 'RESOLVED':
break
else:
time.sleep(5)
# TODO might have to check when status goes to other state than resolved
def list_vms(self):
params = self.params
catalog_name = params.get('catalog_name')
item_name = params.get('item_name')
response = dict()
result = list()
response['changed'] = False
catalog_item = self.org.get_catalog_item(catalog_name, item_name)
vapp_template_resource = self.client.get_resource(
catalog_item.Entity.get('href'))
vapp_template = VApp(self.client, name=item_name, resource=vapp_template_resource)
for vm in vapp_template.get_all_vms():
result.append(vm.get('name'))
response['msg'] = result
response['changed'] = False
return response
socket.setdefaulttimeout(10)
# load config
with open('config.json', 'r') as f:
config = json.load(f)
client = Client(config['url'])
client.set_highest_supported_version()
client.set_credentials(
BasicLoginCredentials(config['user'], config['org'], config['password']))
print("Fetching Org...")
org = Org(client, resource=client.get_org())
print("Fetching VDC...")
vdc = VDC(client, resource=org.get_vdc(config['vdc']))
print("Fetching vApp...")
vapp_resource = vdc.get_vapp(config['vapp'])
vapp = VApp(client, resource=vapp_resource)
print("Validating VMs...")
vms = vapp.get_all_vms()
names = map(lambda vm: vm.get('name'), vms)
names = list(names)
services = config['services']
for service in services:
name = service['vm']
index = names.index(name)
class VdcNet(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VdcNet, self).__init__(**kwargs)
self.vdc_name = self.params.get('vdc_name')
self.org_name = self.params.get('org_name')
self.gateway_name = self.params.get('gateway_name')
self.network_name = self.params.get('network_name')
self.description = self.params.get('description')
self.parent_network_name = self.params.get('parent_network_name')
self.shared = self.params.get('shared')
self.gateway_ip = self.params.get('gateway_ip')
self.netmask = self.params.get('netmask')
self.network_cidr = self.params.get('network_cidr')
self.primary_dns_ip = self.params.get('primary_dns_ip')
self.secondary_dns_ip = self.params.get('secondary_dns_ip')
self.dns_suffix = self.params.get('dns_suffix')
self.ip_range_start = self.params.get('ip_range_start')
self.ip_range_end = self.params.get('ip_range_end')
self.dhcp_enabled = self.params.get('dhcp_enabled')
self.default_lease_time = self.params.get('default_lease_time')
self.max_lease_time = self.params.get('max_lease_time')
self.dhcp_ip_range_start = self.params.get('dhcp_ip_range_start')
self.dhcp_ip_range_end = self.params.get('dhcp_ip_range_end')
self.force = self.params.get('force')
self.state = self.params.get('state')
self.direct = self.params.get('direct')
self.isolated = self.params.get('isolated')
self.routed = self.params.get('routed')
self.guest_vlan_allowed = self.params.get('guest_vlan_allowed')
self.sub_interface = self.params.get('sub_interface')
self.distributed_interface = self.params.get('distributed_interface')
self.retain_net_info_across_deployments = self.params.get(
'retain_net_info_across_deployments')
org_resource = self.client.get_org_by_name(self.org_name)
self.org = Org(self.client, resource=org_resource)
vdc_resource = self.org.get_vdc(self.vdc_name)
self.vdc = VDC(self.client, name=self.vdc_name, resource=vdc_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
if self.direct:
return self.create_direct_network()
elif self.isolated:
return self.create_isolated_network()
elif self.routed:
return self.create_routed_network()
else:
raise Exception("Bool 'direct', 'isolated' or 'routed' is missing")
if state == "absent":
return self.delete_network()
def create_direct_network(self):
response = dict()
try:
self.vdc.get_direct_orgvdc_network(self.network_name)
except EntityNotFoundException:
create = self.vdc.create_directly_connected_vdc_network(
self.network_name,
self.parent_network_name,
description=self.description,
is_shared=self.shared)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Network {0} created'.format(self.network_name)
response['changed'] = True
else:
response['warnings'] = 'Network {0} is already present.'.format(
self.network_name)
return response
def create_isolated_network(self):
response = dict()
try:
self.vdc.get_isolated_orgvdc_network(self.network_name)
except EntityNotFoundException:
create = self.vdc.create_isolated_vdc_network(
self.network_name,
self.network_cidr,
description=self.description,
primary_dns_ip=self.primary_dns_ip,
secondary_dns_ip=self.secondary_dns_ip,
dns_suffix=self.dns_suffix,
ip_range_start=self.ip_range_start,
ip_range_end=self.ip_range_end,
is_dhcp_enabled=self.dhcp_enabled,
default_lease_time=self.default_lease_time,
max_lease_time=self.max_lease_time,
dhcp_ip_range_start=self.dhcp_ip_range_start,
dhcp_ip_range_end=self.dhcp_ip_range_end,
is_shared=self.shared)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Network {0} created'.format(self.network_name)
response['changed'] = True
else:
response['warnings'] = 'Network {0} is already present.'.format(
self.network_name)
return response
def create_routed_network(self):
response = dict()
try:
self.vdc.get_routed_orgvdc_network(self.network_name)
except EntityNotFoundException:
create = self.vdc.create_routed_vdc_network(
self.network_name,
self.gateway_name,
self.network_cidr,
description=self.description,
primary_dns_ip=self.primary_dns_ip,
secondary_dns_ip=self.secondary_dns_ip,
dns_suffix=self.dns_suffix,
ip_range_start=self.ip_range_start,
ip_range_end=self.ip_range_end,
is_shared=self.shared,
guest_vlan_allowed=self.guest_vlan_allowed,
sub_interface=self.sub_interface,
distributed_interface=self.distributed_interface,
retain_net_info_across_deployments=self.retain_net_info_across_deployments)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Network {0} created'.format(self.network_name)
response['changed'] = True
else:
response['warnings'] = 'Network {0} is already present.'.format(
self.network_name)
return response
def delete_network(self):
response = dict()
try:
if self.direct:
self.vdc.get_direct_orgvdc_network(self.network_name)
elif self.isolated:
self.vdc.get_isolated_orgvdc_network(self.network_name)
elif self.routed:
self.vdc.get_routed_orgvdc_network(self.network_name)
except EntityNotFoundException:
response['warnings'] = 'Network {} is not present.'.format(
self.network_name)
else:
if self.direct:
delete = self.vdc.delete_direct_orgvdc_network(
self.network_name,
force=self.force)
elif self.isolated:
delete = self.vdc.delete_isolated_orgvdc_network(
self.network_name,
force=self.force)
elif self.routed:
delete = self.vdc.delete_routed_orgvdc_network(
self.network_name,
force=self.force)
self.execute_task(delete)
response['msg'] = 'Network {} has been deleted.'.format(
self.network_name)
response['changed'] = True
return response
def create_cluster_thread(self):
network_name = self.req_spec.get(RequestKey.NETWORK_NAME)
try:
clusters = load_from_metadata(self.tenant_client,
name=self.cluster_name)
if len(clusters) != 0:
raise ClusterAlreadyExistsError(f"Cluster {self.cluster_name} "
"already exists.")
org_resource = self.tenant_client.get_org_by_name(
self.req_spec.get(RequestKey.ORG_NAME))
org = Org(self.tenant_client, resource=org_resource)
vdc_resource = org.get_vdc(self.req_spec.get(RequestKey.OVDC_NAME))
vdc = VDC(self.tenant_client, resource=vdc_resource)
template = self._get_template()
self._update_task(
TaskStatus.RUNNING,
message=f"Creating cluster vApp {self.cluster_name}"
f"({self.cluster_id})")
try:
vapp_resource = vdc.create_vapp(
self.cluster_name,
description=f"cluster {self.cluster_name}",
network=network_name,
fence_mode='bridged')
except Exception as e:
raise ClusterOperationError(
"Error while creating vApp:", str(e))
self.tenant_client.get_task_monitor().wait_for_status(
vapp_resource.Tasks.Task[0])
tags = {}
tags['cse.cluster.id'] = self.cluster_id
tags['cse.version'] = pkg_resources.require(
'container-service-extension')[0].version
tags['cse.template'] = template['name']
vapp = VApp(self.tenant_client, href=vapp_resource.get('href'))
for k, v in tags.items():
task = vapp.set_metadata('GENERAL', 'READWRITE', k, v)
self.tenant_client.get_task_monitor().wait_for_status(task)
self._update_task(
TaskStatus.RUNNING,
message=f"Creating master node for {self.cluster_name}"
f"({self.cluster_id})")
vapp.reload()
server_config = get_server_runtime_config()
try:
add_nodes(1, template, NodeType.MASTER, server_config,
self.tenant_client, org, vdc, vapp, self.req_spec)
except Exception as e:
raise MasterNodeCreationError(
"Error while adding master node:", str(e))
self._update_task(
TaskStatus.RUNNING,
message=f"Initializing cluster {self.cluster_name}"
f"({self.cluster_id})")
vapp.reload()
init_cluster(server_config, vapp, template)
master_ip = get_master_ip(server_config, vapp, template)
task = vapp.set_metadata('GENERAL', 'READWRITE', 'cse.master.ip',
master_ip)
self.tenant_client.get_task_monitor().wait_for_status(task)
if self.req_spec.get(RequestKey.NUM_WORKERS) > 0:
self._update_task(
TaskStatus.RUNNING,
message=f"Creating "
f"{self.req_spec.get(RequestKey.NUM_WORKERS)} "
f"node(s) for "
f"{self.cluster_name}({self.cluster_id})")
try:
add_nodes(self.req_spec.get(RequestKey.NUM_WORKERS),
template, NodeType.WORKER, server_config,
self.tenant_client, org, vdc, vapp,
self.req_spec)
except Exception as e:
raise WorkerNodeCreationError(
"Error while creating worker node:", str(e))
self._update_task(
TaskStatus.RUNNING,
message=f"Adding "
f"{self.req_spec.get(RequestKey.NUM_WORKERS)} "
f"node(s) to "
f"{self.cluster_name}({self.cluster_id})")
vapp.reload()
join_cluster(server_config, vapp, template)
if self.req_spec.get(RequestKey.ENABLE_NFS):
self._update_task(
TaskStatus.RUNNING,
message=f"Creating NFS node for {self.cluster_name}"
f"({self.cluster_id})")
try:
add_nodes(1, template, NodeType.NFS,
server_config, self.tenant_client, org, vdc,
vapp, self.req_spec)
except Exception as e:
raise NFSNodeCreationError(
"Error while creating NFS node:", str(e))
self._update_task(
TaskStatus.SUCCESS,
message=f"Created cluster {self.cluster_name}"
f"({self.cluster_id})")
except (MasterNodeCreationError, WorkerNodeCreationError,
NFSNodeCreationError, ClusterJoiningError,
ClusterInitializationError, ClusterOperationError) 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],
stack_trace=stack_trace)
raise e
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()
class Vdc(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vdc, self).__init__(**kwargs)
self.org = Org(self.client, resource=self.get_vdc_org_resource())
def manage_states(self):
state = self.params.get('state')
if state == 'present':
return self.create()
if state == 'absent':
return self.delete()
if state == 'update':
return self.update()
def manage_operations(self):
operation = self.params.get('operation')
if operation == 'list_vdcs':
return self.list_vdcs()
def get_vdc_org_resource(self):
if self.params.get('vdc_org_name'):
return self.client.get_org_by_name(self.params.get('vdc_org_name'))
return self.client.get_org()
def create(self):
vdc_name = self.params.get('vdc_name')
is_enabled = self.params.get('is_enabled')
provider_vdc_name = self.params.get('provider_vdc_name')
description = self.params.get('description')
allocation_model = self.params.get('allocation_model')
storage_profiles = self.params.get('storage_profiles')
cpu_units = self.params.get('cpu_units')
cpu_allocated = self.params.get('cpu_allocated')
cpu_limit = self.params.get('cpu_limit')
mem_units = self.params.get('mem_units')
mem_allocated = self.params.get('mem_allocated')
mem_limit = self.params.get('mem_limit')
nic_quota = self.params.get('nic_quota')
network_quota = self.params.get('network_quota')
vm_quota = self.params.get('vm_quota')
resource_guaranteed_memory = self.params.get(
'resource_guaranteed_memory')
resource_guaranteed_cpu = self.params.get('resource_guaranteed_cpu')
vcpu_in_mhz = self.params.get('vcpu_in_mhz')
is_thin_provision = self.params.get('is_thin_provision')
network_pool_name = self.params.get('network_pool_name')
uses_fast_provisioning = self.params.get('uses_fast_provisioning')
over_commit_allowed = self.params.get('over_commit_allowed')
vm_discovery_enabled = self.params.get('vm_discovery_enabled')
response = dict()
response['changed'] = False
if not self.org.get_vdc(vdc_name):
create_vdc_task = self.org.create_org_vdc(
vdc_name=vdc_name,
provider_vdc_name=provider_vdc_name,
description=description,
allocation_model=allocation_model,
storage_profiles=storage_profiles,
cpu_units=cpu_units,
cpu_allocated=cpu_allocated,
cpu_limit=cpu_limit,
mem_units=mem_units,
mem_allocated=mem_allocated,
mem_limit=mem_limit,
nic_quota=nic_quota,
network_quota=network_quota,
vm_quota=vm_quota,
resource_guaranteed_memory=resource_guaranteed_memory,
resource_guaranteed_cpu=resource_guaranteed_cpu,
vcpu_in_mhz=vcpu_in_mhz,
is_thin_provision=is_thin_provision,
network_pool_name=network_pool_name,
uses_fast_provisioning=uses_fast_provisioning,
over_commit_allowed=over_commit_allowed,
vm_discovery_enabled=vm_discovery_enabled,
is_enabled=is_enabled)
self.execute_task(create_vdc_task.Tasks.Task[0])
response['msg'] = 'VDC {} has been created.'.format(vdc_name)
response['changed'] = True
else:
response['warnings'] = 'VDC {} is already present.'.format(
vdc_name)
return response
def update(self):
vdc_name = self.params.get('vdc_name')
is_enabled = self.params.get('is_enabled')
response = dict()
response['changed'] = False
try:
vdc_resource = self.org.get_vdc(vdc_name, is_admin_operation=True)
vdc = VDC(self.client, name=vdc_name, resource=vdc_resource)
vdc.enable_vdc(enable=is_enabled)
response['msg'] = 'VDC {} has been updated.'.format(vdc_name)
response['changed'] = True
except OperationNotSupportedException:
m = "VDC {} may already in {} state"
response['warnings'] = m.format(
vdc_name, "enabled") if is_enabled else m.format(
vdc_name, "disabled")
return response
def delete(self):
vdc_name = self.params.get('vdc_name')
response = dict()
response['changed'] = False
try:
vdc_resource = self.org.get_vdc(vdc_name, is_admin_operation=True)
vdc = VDC(self.client, name=vdc_name, resource=vdc_resource)
vdc.enable_vdc(enable=False)
except EntityNotFoundException:
response['warnings'] = 'VDC {} is not present.'.format(vdc_name)
return
except OperationNotSupportedException:
pass
delete_vdc_task = vdc.delete_vdc()
self.execute_task(delete_vdc_task)
response['msg'] = 'VDC {} has been deleted.'.format(vdc_name)
response['changed'] = True
return response
def list_vdcs(self):
response = dict()
response['changed'] = False
response['msg'] = list()
for vdc in self.org.list_vdcs():
response['msg'].append(vdc.get('name'))
return response
org_record = client.get_org_by_name(os.environ['VCLOUD_ORG'])
org = Org(client, href=org_record.get('href'))
print("Org already exists: {0}".format(org.get_name()))
except Exception:
print("Org does not exist, creating: {0}".format(os.environ['VCLOUD_ORG']))
sys_admin_resource = client.get_admin()
system = System(client, admin_resource=sys_admin_resource)
admin_org_resource = system.create_org(os.environ['VCLOUD_ORG'],
"Test Org", True)
org_record = client.get_org_by_name(os.environ['VCLOUD_ORG'])
org = Org(client, href=org_record.get('href'))
print("Org now exists: {0}".format(org.get_name()))
# Ensure VDC exists.
try:
vdc_resource = org.get_vdc(os.environ['VCLOUD_VDC_NAME'])
vdc = VDC(client, resource=vdc_resource)
print(" VDC '{0}' ... OK".format(os.environ['VCLOUD_VDC_NAME']))
except Exception:
print(" VDC '{0}' ... KO. Exiting.".format(os.environ['VCLOUD_VDC_NAME']))
exit(0)
# # Fetching catalogs
#try:
# catalogs_resource = org.list_catalogs()
# print("Catalogs: {0}".format(catalogs_resource))
#except Exception:
# print("Catalogs fetch error")
# List catalog items (Templates).
class Vapp(VcdAnsibleModule):
def __init__(self, **kwargs):
super(Vapp, self).__init__(**kwargs)
logged_in_org = self.client.get_org()
self.org = Org(self.client, resource=logged_in_org)
vdc_resource = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc_resource.get('href'))
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "absent":
return self.delete()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "poweron":
return self.power_on()
if operation == "poweroff":
return self.power_off()
if operation == "list_vms":
return self.list_vms()
if operation == "list_networks":
return self.list_networks()
if operation == "share":
return self.share()
if operation == "unshare":
return self.unshare()
if operation == "set_meta":
return self.set_meta()
if operation == "get_meta":
return self.get_meta()
if operation == "remove_meta":
return self.remove_meta()
if operation == "add_org_network":
return self.add_org_network()
if operation == "delete_org_network":
return self.delete_org_network()
def get_vapp(self):
vapp_name = self.params.get('vapp_name')
vapp_resource = self.vdc.get_vapp(vapp_name)
return VApp(self.client, name=vapp_name, resource=vapp_resource)
def instantiate(self):
params = self.params
vapp_name = params.get('vapp_name')
catalog_name = params.get('catalog_name')
template_name = params.get('template_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
ip_allocation_mode = params.get('ip_allocation_mode')
deploy = params.get('deploy')
power_on = params.get('power_on')
accept_all_eulas = params.get('accept_all_eulas')
memory = params.get('memory')
cpu = params.get('cpu')
disk_size = params.get('disk_size')
vmpassword = params.get('vmpassword')
cust_script = params.get('cust_script')
vm_name = params.get('vm_name')
hostname = params.get('hostname')
ip_address = params.get('ip_address')
storage_profile = params.get('storage_profile')
network_adapter_type = params.get('network_adapter_type')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.instantiate_vapp(
name=vapp_name,
catalog=catalog_name,
template=template_name,
description=description,
network=network,
fence_mode=fence_mode,
ip_allocation_mode=ip_allocation_mode,
deploy=deploy,
power_on=power_on,
accept_all_eulas=accept_all_eulas,
memory=memory,
cpu=cpu,
disk_size=disk_size,
password=vmpassword,
cust_script=cust_script,
vm_name=vm_name,
hostname=hostname,
ip_address=ip_address,
storage_profile=storage_profile,
network_adapter_type=network_adapter_type)
self.execute_task(create_vapp_task.Tasks.Task[0])
msg = 'Vapp {} has been created'
response['msg'] = msg.format(vapp_name)
response['changed'] = True
else:
msg = "Vapp {} is already present"
response['warnings'] = msg.format(vapp_name)
return response
def create(self):
params = self.params
catalog_name = params.get('catalog_name')
# vapp initialization if catalog has been provided
if catalog_name:
return self.instantiate()
vapp_name = params.get('vapp_name')
description = params.get('description')
network = params.get('network')
fence_mode = params.get('fence_mode')
accept_all_eulas = params.get('accept_all_eulas')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
create_vapp_task = self.vdc.create_vapp(
name=vapp_name,
description=description,
network=network,
fence_mode=fence_mode,
accept_all_eulas=accept_all_eulas)
self.execute_task(create_vapp_task.Tasks.Task[0])
msg = 'Vapp {} has been created'
response['msg'] = msg.format(vapp_name)
response['changed'] = True
else:
msg = "Vapp {} is already present"
response['warnings'] = msg.format(vapp_name)
return response
def delete(self):
vapp_name = self.params.get('vapp_name')
force = self.params.get('force')
response = dict()
response['changed'] = False
try:
self.vdc.get_vapp(vapp_name)
except EntityNotFoundException:
response['warnings'] = "Vapp {} is not present.".format(vapp_name)
else:
delete_vapp_task = self.vdc.delete_vapp(
name=vapp_name, force=force)
self.execute_task(delete_vapp_task)
response['msg'] = 'Vapp {} has been deleted.'.format(vapp_name)
response['changed'] = True
return response
def power_on(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
try:
vapp = self.get_vapp()
deploy_vapp_task = vapp.deploy()
self.execute_task(deploy_vapp_task)
msg = 'Vapp {} has been powered on'
response['msg'] = msg.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException as ex:
response['warnings'] = str(ex)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def power_off(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
try:
vapp = self.get_vapp()
undeploy_vapp_task = vapp.undeploy(action="powerOff")
self.execute_task(undeploy_vapp_task)
response['msg'] = 'Vapp {} has been powered off'.format(vapp_name)
response['changed'] = True
except OperationNotSupportedException as ex:
response['warnings'] = str(ex)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def list_vms(self):
response = dict()
response['msg'] = list()
response['changed'] = False
try:
vapp = self.get_vapp()
for vm in vapp.get_all_vms():
try:
ip = vapp.get_primary_ip(vm.get('name'))
except Exception:
ip = None
finally:
response['msg'].append({
"name": vm.get('name'),
"status": VM_STATUSES[vm.get('status')],
"deployed": vm.get('deployed') == 'true',
"ip_address": ip
})
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def list_networks(self):
response = dict()
response['changed'] = False
try:
vapp = self.get_vapp()
networks = vapp.get_all_networks()
response['msg'] = [
network.get('{' + NSMAP['ovf'] + '}name') for network in networks
]
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def share(self):
response = dict()
response['changed'] = False
access = self.params.get("shared_access")
try:
vapp = self.get_vapp()
vapp.share_with_org_members(everyone_access_level=access)
msg = "Vapp is shared across org with {0} access"
response['msg'] = msg.format(access)
response['changed'] = True
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def unshare(self):
response = dict()
response['changed'] = False
try:
vapp = self.get_vapp()
vapp.unshare_from_org_members()
response['msg'] = "Sharing has been stopped for Vapp"
response['changed'] = True
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def set_meta(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
metadata = self.params.get('metadata')
domain = self.params.get("metadata_domain")
visibility = self.params.get("metadata_visibility")
metadata_type = self.params.get("metadata_type")
metadata_type = "Metadata{0}Value".format(metadata_type)
try:
vapp = self.get_vapp()
domain = MetadataDomain(domain)
visibility = MetadataVisibility(visibility)
metadata_type = MetadataValueType(metadata_type)
set_meta_task = vapp.set_multiple_metadata(metadata,
domain=domain,
visibility=visibility,
metadata_value_type=metadata_type)
self.execute_task(set_meta_task)
msg = "Metadata {0} have been set to vApp {1}"
response["msg"] = msg.format(list(metadata.keys()), vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def get_meta(self):
response = dict()
response['changed'] = False
response['msg'] = dict()
try:
vapp = self.get_vapp()
metadata = vapp.get_metadata()
response['msg'] = {
metadata.MetadataEntry.Key.text: metadata.MetadataEntry.TypedValue.Value.text
}
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def remove_meta(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
domain = self.params.get("metadata_domain")
metadata = self.params.get('metadata')
domain = MetadataDomain(domain)
response['msg'] = list()
try:
vapp = self.get_vapp()
for key in metadata:
remove_meta_task = vapp.remove_metadata(key, domain=domain)
self.execute_task(remove_meta_task)
msg = "Metadata {0} have been removed from vApp {1}"
response["msg"] = msg.format(list(metadata.keys()), vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
return response
def add_org_network(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
network = self.params.get("network")
try:
vapp = self.get_vapp()
vapp.connect_org_vdc_network(network)
response['changed'] = True
msg = "Org Network {0} has been added to vApp {1}"
response['msg'] = msg.format(network, vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
except InvalidStateException as ex:
response['warnings'] = str(ex)
return response
def delete_org_network(self):
response = dict()
response['changed'] = False
vapp_name = self.params.get('vapp_name')
network = self.params.get("network")
try:
vapp = self.get_vapp()
vapp.disconnect_org_vdc_network(network)
response['changed'] = True
msg = "Org Network {0} has been added to vApp {1}"
response['msg'] = msg.format(network, vapp_name)
except EntityNotFoundException as ex:
response['warnings'] = str(ex)
except InvalidStateException as ex:
response['warnings'] = str(ex)
return response
class VdcGW(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VdcGW, self).__init__(**kwargs)
self.vdc_name = self.params.get('vdc_name')
self.org_name = self.params.get('org_name')
org_resource = self.client.get_org_by_name(self.org_name)
self.org = Org(self.client, resource=org_resource)
vdc_resource = self.org.get_vdc(self.vdc_name)
self.vdc = VDC(self.client, name=self.vdc_name, resource=vdc_resource)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create_gw()
if state == "update":
return self.update_gw()
if state == "absent":
return self.delete_gw()
def get_gateway(self, gateway_name):
gateway = self.vdc.get_gateway(gateway_name)
if gateway is None:
raise EntityNotFoundException(
"Edge gateway {0} is not present".format(gateway_name))
return gateway
def create_gw(self):
api_version = self.client.get_api_version()
if api_version == "30.0":
return self.create_gateway_api_version_30()
if api_version == "31.0":
return self.create_gateway_api_version_31()
if api_version == "32.0":
return self.create_gateway_api_version_32()
def create_gateway_api_version_30(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_30(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def create_gateway_api_version_31(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
flips_mode = self.params.get('flips_mode')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_31(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit,
is_flips_mode_enabled=flips_mode)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def create_gateway_api_version_32(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
edge_gateway_type = self.params.get('edge_gateway_type')
flips_mode = self.params.get('flips_mode')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_32(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit,
is_flips_mode_enabled=flips_mode,
edgeGatewayType=edge_gateway_type)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def update_gw(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
new_gateway_name = self.params.get('new_gateway_name')
description = self.params.get('description')
ha_enabled = self.params.get('ha_enabled')
edge_gateway_href = None
try:
gateway = self.get_gateway(gateway_name)
for key, value in gateway.items():
if key == "href":
edge_gateway_href = value
break
gateway = Gateway(
self.client, name=gateway_name, href=edge_gateway_href)
update_task = gateway.edit_gateway(newname=new_gateway_name,
desc=description, ha=ha_enabled)
self.execute_task(update_task)
msg = "Edge Gateway {0} has been updated with {1}"
response['msg'] = msg.format(gateway_name, new_gateway_name)
response['changed'] = True
except EntityNotFoundException:
msg = 'Edge Gateway {0} is not present'
response['warnings'] = msg.format(gateway_name)
return response
def delete_gw(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
msg = "Edge Gateway {0} is not present"
response['warnings'] = msg.format(gateway_name)
else:
delete_task = self.vdc.delete_gateway(gateway_name)
self.execute_task(delete_task)
msg = "Edge Gateway {0} has been deleted"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
return response
