def create(ctx, name, pvdc_name, network_pool_name, allocation_model, sp_name,
sp_limit, description, cpu_allocated, cpu_limit):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
storage_profiles = [{
'name': sp_name,
'enabled': True,
'units': 'MB',
'limit': sp_limit,
'default': True
}]
vdc_resource = org.create_org_vdc(name,
pvdc_name,
network_pool_name=network_pool_name,
description=description,
allocation_model=allocation_model,
cpu_allocated=cpu_allocated,
cpu_limit=cpu_limit,
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
stdout(vdc_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def create(ctx, name, pvdc_name, network_pool_name, allocation_model, sp_name,
sp_limit, description, cpu_allocated, cpu_limit):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
storage_profiles = [{
'name': sp_name,
'enabled': True,
'units': 'MB',
'limit': sp_limit,
'default': True
}]
vdc_resource = org.create_org_vdc(
name,
pvdc_name,
network_pool_name=network_pool_name,
description=description,
allocation_model=allocation_model,
cpu_allocated=cpu_allocated,
cpu_limit=cpu_limit,
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
stdout(vdc_resource.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def test_create_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'))
storage_profiles = [{
'name': self.config['vcd']['storage_profile'],
'enabled': True,
'units': 'MB',
'limit': 0,
'default': True
}]
vdc_resource = org.create_org_vdc(
self.config['vcd']['new_vdc'],
self.config['vcd']['provider_vdc'],
network_pool_name=self.config['vcd']['network_pool'],
description='description',
allocation_model='AllocationVApp',
cpu_allocated=0,
cpu_limit=0,
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
task = self.client.get_task_monitor().wait_for_status(
task=vdc_resource.Tasks.Task[0],
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_create_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'))
storage_profiles = [{
'name': self.config['vcd']['storage_profile'],
'enabled': True,
'units': 'MB',
'limit': 0,
'default': True
}]
vdc_resource = org.create_org_vdc(
self.config['vcd']['new_vdc'],
self.config['vcd']['provider_vdc'],
network_pool_name=self.config['vcd']['network_pool'],
description='description',
allocation_model='AllocationVApp',
cpu_allocated=0,
cpu_limit=0,
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
task = self.client.get_task_monitor().wait_for_status(
task=vdc_resource.Tasks.Task[0],
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 create_ovdc(cls):
"""Creates an org vdc with the name specified in the config file.
Skips creating one, if such an org vdc already exists. Also stores the
href of the org vdc as class variable for future use.
:raises: Exception: if the class variable _org_href or _pvdc_name
is not populated.
"""
cls._basic_check()
if cls._org_href is None:
raise Exception('Org ' + cls._config['vcd']['default_org_name'] +
' doesn\'t exist.')
if cls._pvdc_name is None:
raise Exception('pVDC ' + cls._config['vcd']['default_pvdc_name'] +
' doesn\'t exist.')
org = Org(cls._sys_admin_client, href=cls._org_href)
ovdc_name = cls._config['vcd']['default_ovdc_name']
for vdc in org.list_vdcs():
if vdc.get('name').lower() == ovdc_name.lower():
cls._logger.debug('Reusing existing ovdc ' + ovdc_name + '.')
cls._ovdc_href = vdc.get('href')
return
storage_profiles = [{
'name': cls._config['vcd']['default_storage_profile_name'],
'enabled': True,
'units': 'MB',
'limit': 0,
'default': True
}]
system = System(
cls._sys_admin_client,
admin_resource=cls._sys_admin_client.get_admin())
netpool_to_use = cls._get_netpool_name_to_use(system)
cls._logger.debug('Creating ovdc ' + ovdc_name + '.')
vdc_resource = org.create_org_vdc(
ovdc_name,
cls._pvdc_name,
network_pool_name=netpool_to_use,
network_quota=cls._config['vcd']['default_network_quota'],
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
cls._sys_admin_client.get_task_monitor().wait_for_success(
task=vdc_resource.Tasks.Task[0])
org.reload()
# The following contraption is required to get the non admin href of
# the ovdc. vdc_resource contains the admin version of the href since
# we created the ovdc as a sys admin.
for vdc in org.list_vdcs():
if vdc.get('name').lower() == ovdc_name.lower():
cls._ovdc_href = vdc.get('href')
# 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()
vdc_resource = org.get_vdc(cfg.vdc['vdc_name'])
vdc = VDC(client, resource=vdc_resource)
print("VDC now exists: {0}".format(vdc.name))
# Ensure the catalog exists. For now we don't do anything special with
# permissions. As with VDC's we reload the org if we create a catalog
# so that it's visible in future calls.
try:
catalog_resource = org.get_catalog_resource(cfg.catalog['name'])
print("Catalog already exists: {0}".format(cfg.catalog['name']))
except Exception:
def create_ovdc(cls):
"""Creates an org vdc with the name specified in the config file.
Skips creating one, if such an org vdc already exists. Also stores the
href of the org vdc as class variable for future use.
:raises: Exception: if the class variable _org_href or _pvdc_name
is not populated.
"""
cls._basic_check()
if cls._org_href is None:
raise Exception('Org ' + cls._config['vcd']['default_org_name'] +
' doesn\'t exist.')
if cls._pvdc_name is None:
raise Exception('pVDC ' + cls._config['vcd']['default_pvdc_name'] +
' doesn\'t exist.')
org = Org(cls._sys_admin_client, href=cls._org_href)
ovdc_name = cls._config['vcd']['default_ovdc_name']
for vdc in org.list_vdcs():
if vdc.get('name').lower() == ovdc_name.lower():
cls._logger.debug('Reusing existing ovdc ' + ovdc_name + '.')
cls._ovdc_href = vdc.get('href')
return
storage_profiles = [{
'name':
cls._config['vcd']['default_storage_profile_name'],
'enabled':
True,
'units':
'MB',
'limit':
0,
'default':
True
}]
system = System(
cls._sys_admin_client,
admin_resource=cls._sys_admin_client.get_admin())
netpool_to_use = cls._get_netpool_name_to_use(system)
cls._logger.debug('Creating ovdc ' + ovdc_name + '.')
vdc_resource = org.create_org_vdc(
ovdc_name,
cls._pvdc_name,
network_pool_name=netpool_to_use,
network_quota=cls._config['vcd']['default_network_quota'],
storage_profiles=storage_profiles,
uses_fast_provisioning=True,
is_thin_provision=True)
cls._sys_admin_client.get_task_monitor().wait_for_success(
task=vdc_resource.Tasks.Task[0])
org.reload()
# The following contraption is required to get the non admin href of
# the ovdc. vdc_resource contains the admin version of the href since
# we created the ovdc as a sys admin.
for vdc in org.list_vdcs():
if vdc.get('name').lower() == ovdc_name.lower():
cls._ovdc_href = vdc.get('href')
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
# 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()
vdc_resource = org.get_vdc(cfg.vdc['vdc_name'])
vdc = VDC(client, resource=vdc_resource)
print("VDC now exists: {0}".format(vdc.name))
# Ensure the catalog exists. For now we don't do anything special with
# permissions. As with VDC's we reload the org if we create a catalog
# so that it's visible in future calls.
try:
catalog_resource = org.get_catalog_resource(cfg.catalog['name'])
print("Catalog already exists: {0}".format(cfg.catalog['name']))
except Exception:
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 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
def create(self, provider_vdc_name, description, allocation_model,
storage_profiles, 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, network_pool_name,
uses_fast_provisioning, over_commit_allowed,
vm_discovery_enabled):
logging.info("__INIT__create[Vdc]")
res = vdc_pb2.CreateVdcResult()
res.created = 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:
storage_profiles = json.loads(storage_profiles)
if not network_pool_name.strip():
network_pool_name = None
create_vdc_resp = org.create_org_vdc(
vdc_name=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)
task = self.client.get_task_monitor().wait_for_status(
task=create_vdc_resp.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)
st = task.get('status')
if st == TaskStatus.SUCCESS.value:
message = 'delete vdc status : {0} '.format(st)
logging.info(message)
else:
raise errors.VCDVdcCreateError(
etree.tostring(task, pretty_print=True))
res.created = True
except Exception as e:
error_message = '__ERROR_create[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__create[Vdc]")
return res
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
