def create(client, context, name, description):
logging.debug("_INIT_create_catalog__")
logging.debug("name = [%s] desc = [%s] ", name, description)
result = pyvcloudprovider_pb2.CreateCatalogResult()
result.created = False
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
try:
catalog = org.create_catalog(name=name, description=description)
result.created = True
except Exception as e:
error_message = "__ ERROR Creating catalog [{0}] __ERROR_MESSAGE__ [{1}]".format(
name, str(e))
logging.warn(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
except Exception as e:
error_message = "__ ERROR Creating catalog [{0}] __ERROR_MESSAGE__ [{1}]".format(
name, str(e))
logging.warn(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
logging.debug("_DONE_create_catalog__")
return result
def read(client, context, name):
#logging.basicConfig(level=logging.DEBUG)
logging.debug("__INIT__read[catalog]__ %s", name)
logging.debug("catalog_name %s", name)
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
result = pyvcloudprovider_pb2.ReadCatalogResult()
result.present = False
try:
catalog = org.get_catalog(name)
logging.info(vars(catalog))
logging.info("\n==desc=[%s]", catalog.Description)
result.name = str(catalog.get("name"))
result.description = str(catalog.Description)
result.shared = catalog.IsPublished
result.present = True
except Exception as e:
logging.warning(
"__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]".
format(name, str(e)))
return result
except Exception as e:
logging.error(
"__ERROR__ while reading catalog[{0}]. __ERROR_MESSAGE__[{1}]".
format(name, str(e)))
raise
def update(client, context, old_name, new_name, description):
logging.info("\n __INIT_update_catalog__")
logging.debug(
"\n old_name = [%s] new_name = [%s] desc = [%s]",
old_name, new_name, description)
result = pyvcloudprovider_pb2.UpdateCatalogResult()
result.updated = False
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
try:
catalog = org.update_catalog(
old_catalog_name=old_name,
new_catalog_name=new_name,
description=description)
result.updated = True
except Exception as e:
error_message = "Error occured while updating catalog {0} __ERROR_MESSAGE__ {1}".format(
old_name, str(e))
logging.error(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
except Exception as e:
error_message = "Error occured while updating catalog {0} __ERROR_MESSAGE__ {1}".format(
old_name, str(e))
logging.error(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
logging.debug("__DONE_update_catalog__")
return result
def delete(client, context, name):
logging.debug("=== delete catalog called === \n")
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
result = pyvcloudprovider_pb2.DeleteCatalogResult()
result.deleted = False
try:
catalog = org.delete_catalog(name)
result.deleted = True
except Exception as e:
error_message = "Error occured while deleting catalog {0} __ERROR_MESSAGE__ {1}".format(
name, str(e))
logging.error(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
return result
except Exception as e:
error_message = "Error occured while deleting catalog {0} __ERROR_MESSAGE__ {1}".format(
name, str(e))
logging.error(error_message)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
def list_catalogs_or_items(ctx, catalog_name):
try:
restore_session(ctx)
client = ctx.obj['client']
if catalog_name is None:
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
result = org.list_catalogs()
else:
result = []
if is_sysadmin(ctx):
resource_type = ResourceType.ADMIN_CATALOG_ITEM.value
else:
resource_type = ResourceType.CATALOG_ITEM.value
q = client.get_typed_query(
resource_type,
query_result_format=QueryResultFormat.ID_RECORDS,
equality_filter=('catalogName', catalog_name))
records = list(q.execute())
if len(records) == 0:
result = 'not found'
else:
for r in records:
result.append(to_dict(r, resource_type=resource_type))
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
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_09_catalog_unshare_access(self):
org_in_use = self.client.get_org_by_name(
self.config['vcd']['org_in_use'])
org = Org(self.client, resource=org_in_use)
control_access = org.unshare_catalog_with_org_members(
self.config['vcd']['catalog'])
assert control_access.IsSharedToEveryone.text == 'false'
def test_03_remove_all_catalog_access(self):
org_in_use = self.client.get_org_by_name(
self.config['vcd']['org_in_use'])
org = Org(self.client, resource=org_in_use)
control_access = org.remove_catalog_access_settings(
self.config['vcd']['catalog'], remove_all=True)
self.assertFalse(hasattr(control_access, 'AccessSettings'))
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_catalog(cls):
"""Creates a catalog by the name specified in the configuration file.
Skips creating one, if such a catalog already exists.
:raises: Exception: if the class variable _org_href is not populated.
"""
cls._basic_check()
if cls._org_href is None:
raise Exception('Org ' + cls._config['vcd']['default_org_name'] +
' doesn\'t exist.')
try:
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
org = Org(catalog_author_client, href=cls._org_href)
catalog_name = cls._config['vcd']['default_catalog_name']
catalog_records = org.list_catalogs()
for catalog_record in catalog_records:
if catalog_record.get('name') == catalog_name:
cls._logger.debug('Reusing existing catalog ' +
catalog_name)
return
cls._logger.debug('Creating new catalog ' + catalog_name)
catalog_resource = org.create_catalog(
name=catalog_name, description='')
catalog_author_client.get_task_monitor().wait_for_success(
task=catalog_resource.Tasks.Task[0])
finally:
catalog_author_client.logout()
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 share_catalog(cls):
"""Shares the test catalog with all members in the test organization.
:raises: Exception: if the class variable _org_href is not populated.
:raises: EntityNotFoundException: if the catalog in question is
missing.
"""
cls._basic_check()
if cls._org_href is None:
raise Exception('Org ' + cls._config['vcd']['default_org_name'] +
' doesn\'t exist.')
try:
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
org = Org(catalog_author_client, href=cls._org_href)
catalog_name = cls._config['vcd']['default_catalog_name']
catalog_records = org.list_catalogs()
for catalog_record in catalog_records:
if catalog_record.get('name') == catalog_name:
cls._logger.debug('Sharing catalog ' + catalog_name + ' to'
' all members of org ' + org.get_name())
org.share_catalog_with_org_members(
catalog_name=catalog_name)
return
raise EntityNotFoundException('Catalog ' + catalog_name +
'doesn\'t exist.')
finally:
catalog_author_client.logout()
def capture(ctx, name, catalog, template, customizable, description):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
catalog_resource = org.get_catalog(catalog)
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
vapp_resource = vdc.get_vapp(name)
overwrite = False
if template is None:
template = vapp_resource.get('name')
else:
overwrite = True
task = org.capture_vapp(
catalog_resource,
vapp_href=vapp_resource.get('href'),
catalog_item_name=template,
description=description,
customize_on_instantiate=customizable == 'customizable',
overwrite=overwrite)
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
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_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 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_update_catalog(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
catalog = org.update_catalog(self.config['vcd']['catalog'],
self.config['vcd']['new_name'], self.config['vcd']['new_desc'])
assert self.config['vcd']['new_name'] == catalog.get('name')
assert self.config['vcd']['new_desc'] == catalog['Description']
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 create(ctx, user_name, password, role_name, full_name, description, email,
telephone, im, enabled, alert_enabled, alert_email,
alert_email_prefix, external, default_cached, group_role,
stored_vm_quota, deployed_vm_quota):
try:
if len(password) < 6:
raise Exception('Password must be at least 6 characters long.')
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
role = org.get_role_record(role_name)
role_href = role.get('href')
result = org.create_user(
user_name=user_name,
password=password,
role_href=role_href,
full_name=full_name,
description=description,
email=email,
telephone=telephone,
im=im,
alert_email=alert_email,
alert_email_prefix=alert_email_prefix,
stored_vm_quota=stored_vm_quota,
deployed_vm_quota=deployed_vm_quota,
is_group_role=group_role,
is_default_cached=default_cached,
is_external=external,
is_alert_enabled=alert_enabled,
is_enabled=enabled)
stdout('User \'%s\' is successfully created.' % result.get('name'),
ctx)
except Exception as e:
stderr(e, ctx)
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 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_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_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 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 create_users(cls):
"""Creates users for each of the roles in CommonRoles.
Skips creating users which are already present in the organization.
:raises: Exception: if the class variable _org_href is not populated.
"""
cls._basic_check()
if cls._org_href is None:
raise Exception('Org ' + cls._config['vcd']['default_org_name'] +
' doesn\'t exist.')
org = Org(cls._sys_admin_client, href=cls._org_href)
for role_enum in cls._user_name_for_roles.keys():
user_name = cls._user_name_for_roles[role_enum]
user_records = list(
org.list_users(name_filter=('name', user_name)))
if len(user_records) > 0:
cls._logger.debug('Reusing existing user ' + user_name + '.')
cls._user_href_for_user_names[user_name] = \
user_records[0].get('href')
continue
role = org.get_role_record(role_enum.value)
cls._logger.debug('Creating user ' + user_name + '.')
user_resource = org.create_user(
user_name=user_name,
password=cls._config['vcd']['default_org_user_password'],
role_href=role.get('href'),
is_enabled=True)
cls._user_href_for_user_names[user_name] = \
user_resource.get('href')
def update(self):
logging.info("__INIT__update[User]")
res = user_pb2.UpdateUserResult()
res.updated = False
context = self.context
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
name = self.name
is_enabled = self.is_enabled
try:
result = org.update_user(name, is_enabled)
res.updated = True
except Exception as e:
error_message = '__ERROR_update[user] failed for user {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[User]")
return res
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_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 info(ctx, catalog_name, item_name):
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)
if item_name is None:
catalog = org.get_catalog(catalog_name)
result = to_dict(catalog)
# We don't have a way to know in advance if a user has access to a
# catalog's ACL or not. So we try to retrieve it always. If the
# call fails due to permission issues, we silently eat the
# exception and exclude ACL settings from the output of the current
# command. Users who have access to ACL of the catalog will remain
# unaffected. Also any other errors/exceptions will bubble up as
# usual.
try:
access_control_settings = access_settings_to_dict(
org.get_catalog_access_settings(catalog_name))
result.update(access_control_settings)
except AccessForbiddenException as e:
pass
else:
catalog_item = org.get_catalog_item(catalog_name, item_name)
result = to_dict(catalog_item)
vapp = VApp(client, href=catalog_item.Entity.get('href'))
vapp.reload()
template = vapp_to_dict(vapp.resource)
for k, v in template.items():
result['template-%s' % k] = v
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def Update(self, request, context):
"""
Update an organization.
Expected request params:
:param org_name: (string): name of organisation
:param is_enabled: (bool): enable/disable the organization
:return (bool): true/false based on the api execution success
"""
logging.info("__INIT_update_org_[org_plugin]")
org_name = request.name
is_enabled = request.is_enabled
res = org_pb2.UpdateOrgResult()
res.updated = False
try:
vref = VCDClientRef()
client = vref.get_ref()
org_resource = client.get_org_by_name(org_name)
org = Org(client, resource=org_resource)
org.update_org(is_enabled)
logging.info("__DONE_update_org_[org_plugin]")
res.updated = True
return res
except Exception as e:
error_message = '__ERROR_update_org_[org_plugin] failed for org {0} '.format(
org_name)
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
return res
def read(client, context, vapp_info):
logging.debug('__INIT__vapp_read [ {0} ]'.format(vapp_info))
try:
cresult = vapp_pb2.ReadVAppResult()
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vapp_info.vdc)
vdc = VDC(client, href=v.get('href'))
try:
vapp = vdc.get_vapp(vapp_info.name)
except Exception as e:
logging.error("error occured in vapp", e)
cresult.present = False
return cresult
logging.debug('vapp read [ %s ]', vapp)
if vapp:
nconfig_section = vapp.NetworkConfigSection
nconfig = nconfig_section.findall(
"{http://www.vmware.com/vcloud/v1.5}NetworkConfig")
for i in range(0, len(nconfig)):
print(nconfig[i].get('networkName'))
cresult.network.append(nconfig[i].get('networkName'))
cresult.name = vapp_info.name
cresult.present = True
else:
cresult.present = False
logging.debug('__LOG__ vapp not found [ {0} ] '.format(vapp_info))
logging.debug('__DONE__vapp_read [ {0} ][{1}] '.format(
cresult, vapp_info))
return cresult
except Exception as e:
error_message = 'ERROR........ {0}'.format(e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
def capture_vapp(client, context, capture_info):
logging.debug("__INIT__capture_vapp [%s]", capture_info)
vapp_name = capture_info.vapp_name
vdc_name = capture_info.vdc_name
catalog_name = capture_info.catalog_name
item_name = capture_info.item_name
desc = capture_info.description
customize_on_instantiate = capture_info.customize_on_instantiate
result = catalog_item_pb2.CaptureVAppResult()
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vdc_name)
if v is None:
raise errors.VDCNotFoundError(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
vapp = vdc.get_vapp(vapp_name)
logging.info(vapp.get('href'))
catalog = org.get_catalog(catalog_name)
org.capture_vapp(catalog_resource=catalog,
vapp_href=vapp.get('href'),
catalog_item_name=item_name,
description=desc,
customize_on_instantiate=customize_on_instantiate)
result.captured = True
logging.debug("__DONE__capture_vapp [%s] , [%s] , [%s] ", vapp_name,
vdc_name, catalog_name)
return result
except Exception as e:
error_message = 'ERROR.. capture vapp failed {0} {1} {2}'.format(
vapp_name, vdc_name, catalog_name)
logging.warn(error_message, e)
context.set_code(grpc.StatusCode.INVALID_ARGUMENT)
context.set_details(error_message)
def share_catalog(cls):
"""Shares the test catalog with all members in the test organization.
:raises: Exception: if the class variable _org_href is not populated.
:raises: EntityNotFoundException: if the catalog in question is
missing.
"""
cls._basic_check()
if cls._org_href is None:
raise Exception('Org ' + cls._config['vcd']['default_org_name'] +
' doesn\'t exist.')
try:
catalog_author_client = Environment.get_client_in_default_org(
CommonRoles.CATALOG_AUTHOR)
org = Org(catalog_author_client, href=cls._org_href)
catalog_name = cls._config['vcd']['default_catalog_name']
catalog_records = org.list_catalogs()
for catalog_record in catalog_records:
if catalog_record.get('name') == catalog_name:
cls._logger.debug('Sharing catalog ' + catalog_name + ' to'
' all members of org ' + org.get_name())
org.share_catalog_with_org_members(
catalog_name=catalog_name)
return
raise EntityNotFoundException('Catalog ' + catalog_name +
'doesn\'t exist.')
finally:
catalog_author_client.logout()
def test_1003_reset_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')
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)
result = vapp.power_reset()
# result = vapp.reboot()
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 power_off(client, target_vdc, target_vapp, target_vm_name):
logging.info("__INIT__delete[VappVm]")
powered_off = False
org_resource = client.get_org()
org = Org(client, resource=org_resource)
try:
vdc_resource = org.get_vdc(target_vdc)
vdc = VDC(slef.client, name=target_vdc, resource=vdc_resource)
vapp_resource = vdc.get_vapp(target_vapp)
vapp = VApp(client, name=target_vapp, resource=vapp_resource)
vapp_vm_resource = vapp.get_vm(target_vm_name)
vm = VM(client, resource=vapp_vm_resource)
vm.power_off()
powered_off = True
except Exception as e:
error_message = '__ERROR_power_off[VappVm] failed for VappVm {0}. __ErrorMessage__ {1}'.format(
target_vm_name, str(e))
logging.warn(error_message)
return powered_off
def create(client, name, description):
logging.debug("=== create catalog called === \n")
try:
logged_in_org = client.get_org()
logging.info("loged in org ================ \n\n\n\n\n")
org = Org(client, resource=logged_in_org)
logging.info(
"\n\n\n\n\n\n got ord ,,,, ================== \n\n\n")
result = pyvcloudprovider_pb2.CreateCatalogResult()
result.created = False
try:
catalog = org.create_catalog(name, description)
result.created = True
except Exception as e:
logging.info("\n Not Created catalog [" + name + "]")
return result
except Exception as e:
print(e)
print("\n")
logging.warn("error occured", e)
def remove(ctx, catalog_name, access_list, all):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
if all:
click.confirm(
'Do you want to remove all access settings from the catalog '
'\'%s\'' % catalog_name,
abort=True)
updated_acl = org.remove_catalog_access_settings(
catalog_name=catalog_name,
access_settings_list=acl_str_to_list_of_dict(access_list),
remove_all=all)
stdout(
access_settings_to_list(
updated_acl, ctx.obj['profiles'].get('org_in_use')),
ctx,
sort_headers=False)
except Exception as e:
stderr(e, ctx)
def download(ctx, catalog_name, item_name, file_name, progress, overwrite):
try:
restore_session(ctx)
save_as_name = item_name
if file_name is not None:
save_as_name = file_name
if not overwrite and os.path.isfile(save_as_name):
raise Exception('File exists.')
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
cb = download_callback if progress else None
bytes_written = org.download_catalog_item(
catalog_name,
item_name,
save_as_name,
callback=cb,
task_callback=task_callback)
result = {'file': save_as_name, 'size': bytes_written}
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def delete(client, vappInfo):
logging.debug("===INIT delete vapp called === \n")
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
v = org.get_vdc(vappInfo.vdc)
vdc = VDC(client, href=v.get('href'))
cresult = vapp_pb2.DeleteVAppResult()
cresult.deleted = False
try:
logging.info(" calling delete_vapp............")
result = vdc.delete_vapp(name=vappInfo.name, force=True)
logging.info(" delete proceeding............")
task = 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=task_callback)
if task.get('status') == TaskStatus.SUCCESS.value:
cresult.deleted = True
except Exception as e:
logging.exception("\n Not Deleted VApp [" + vappInfo.name + "]")
return cresult
except Exception as e:
logging.exception("error occured create vapp ", e)
def info(ctx, catalog_name, item_name):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
if item_name is None:
catalog = org.get_catalog(catalog_name)
result = to_dict(catalog)
access_control_settings = access_settings_to_dict(
org.get_catalog_access_settings(catalog_name))
result.update(access_control_settings)
else:
catalog_item = org.get_catalog_item(catalog_name, item_name)
result = to_dict(catalog_item)
vapp = VApp(client, href=catalog_item.Entity.get('href'))
vapp.reload()
template = vapp_to_dict(vapp.resource)
for k, v in template.items():
result['template-%s' % k] = v
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def info(ctx, name):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
in_use_vdc = ctx.obj['profiles'].get('vdc_in_use')
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, href=org_href)
vdc_resource = org.get_vdc(name)
vdc = VDC(client, resource=vdc_resource)
access_settings = None
try:
access_settings = vdc.get_access_settings()
except OperationNotSupportedException:
pass
result = vdc_to_dict(vdc_resource,
access_settings_to_dict(access_settings))
result['in_use'] = in_use_vdc == name
result['org'] = in_use_org_name
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def remove(ctx, vdc_name, access_list, all):
try:
restore_session(ctx)
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
if all:
click.confirm(
'Do you want to remove all access settings from the vdc '
'\'%s\'' % vdc_name,
abort=True)
org = Org(client, in_use_org_href)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, resource=vdc_resource)
vdc.remove_access_settings(
access_settings_list=acl_str_to_list_of_dict(access_list),
remove_all=all)
stdout('Access settings removed from vdc \'%s\'.' % vdc_name, ctx)
except Exception as e:
stderr(e, ctx)
def test_0003_power_on(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
vdc_resource = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, resource=vdc_resource)
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
vapp = VApp(self.client, resource=vapp_resource)
vm_resource = vapp.get_vm(self.config['vcd']['vm'])
vm = VM(self.client, resource=vm_resource)
task = vm.power_on()
task = self.client.get_task_monitor().wait_for_status(
task=task,
timeout=60,
poll_frequency=2,
fail_on_statuses=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def upload(ctx, catalog_name, file_name, item_name, progress):
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)
cb = upload_callback if progress else None
filename, file_extension = os.path.splitext(file_name)
if file_extension == '.ova':
bytes_written = org.upload_ovf(catalog_name,
file_name,
item_name,
callback=cb)
else:
bytes_written = org.upload_media(catalog_name,
file_name,
item_name,
callback=cb)
result = {'file': file_name, 'size': bytes_written}
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def test_200_delete_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()
for disk in disks:
result = vdc.delete_disk(disk_id=disk.get('id'))
task = self.client.get_task_monitor().wait_for_status(
task=result,
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_011_update_vapp_network(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 = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['vapp'] == vapp.get('name')
result = vdc.reconfigure_vapp_network(self.config['vcd']['vapp'],
'net2',
self.config['vcd']['fence_mode'])
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
def read_and_return(self):
response = dict()
response_data = dict()
vdc_resources = dict()
copy_result = dict()
vdc_resources = self.get_vdc_org_resource()
self.vdc_resources = vdc_resources
self.org = Org(self.client, resource=self.client.get_org())
platform = Platform(self.org.client)
self.platform = platform
vdc_name = self.vdc_org_name
vdc_response = VDC(self.client,
name=self.vdc,
resource=(self.org.get_vdc(self.vdc)))
result = vdc_response.list_edge_gateways()
for ko in result:
copy_result.update(ko)
self.copy_result = copy_result
#networks_result_xml = str()
networks_result_xml = vdc_response.get_gateway(self.edge_input_to_get)
response_data = vdc_response.list_edge_gateways()
for m in response_data:
edge_href = m['href']
self.edge_href = edge_href
for e in result:
del e['href']
#result_n_gateway = Gateway(self.edge_input_to_get,self.edge_href,resource=(self.org.get_vdc(self.vdc)))
#response['networks_result_xml'] = networks_result_xml
response['edge-gw-info'] = result_n_gateway
response['edge-gw-href'] = edge_href
response['edge-gw-copy'] = response_data
response['edge-gw-name'] = self.edge_input_to_get
response['edge-gw'] = result
self.vdc_response = vdc_response
# vdc_resource = self.org.get_vdc(self.org)
# self.vdc = VDC(self.client, name=self.vdc, resource=vdc_resource)
# vdc = self.vdc
response['changed'] = True
return response
def login(session_id=None):
log_requests = True if config['log'] == True else False
log_headers = True if config['log'] == True else False
log_bodies = True if config['log'] == True else False
client = Client(config['host'],
api_version=config['api_version'],
verify_ssl_certs=config['verify_ssl_certs'],
log_file=config['log_file'],
log_requests=log_requests,
log_headers=log_headers,
log_bodies=log_bodies)
if not config['verify_ssl_certs']:
requests.packages.urllib3.disable_warnings()
try:
if session_id is not None:
client.rehydrate_from_token(session_id)
else:
client.set_credentials(
BasicLoginCredentials(config['username'], config['org'],
config['password']))
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org_url = "https://%s/cloud/org/%s" % (config['host'], logged_in_org)
the_vdc = org.get_vdc(config['vdc'])
# Set contextual data:
ctx.client = client
ctx.vdc = VDC(client, href=the_vdc.get('href'))
ctx.token = client._session.headers['x-vcloud-authorization']
except Exception as e:
if config['debug'] == True:
print("Exception: {}\n".format(e))
return False
return True
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_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_012_add_disk(self):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
v = org.get_vdc(self.config['vcd']['vdc'])
vdc = VDC(self.client, href=v.get('href'))
assert self.config['vcd']['vdc'] == vdc.get_resource().get('name')
vapp_resource = vdc.get_vapp(self.config['vcd']['vapp'])
assert self.config['vcd']['vapp'] == vapp_resource.get('name')
vm_name = self.config['vcd']['vm']
vapp = VApp(self.client, resource=vapp_resource)
disk_size = 1024 # 1GB
result = vapp.add_disk_to_vm(vm_name, disk_size)
task = self.client.get_task_monitor().wait_for_status(
task=result,
timeout=60,
poll_frequency=2,
fail_on_status=None,
expected_target_statuses=[
TaskStatus.SUCCESS, TaskStatus.ABORTED, TaskStatus.ERROR,
TaskStatus.CANCELED
],
callback=None)
assert task.get('status') == TaskStatus.SUCCESS.value
class VcdResource(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VcdResource, self).__init__(**kwargs)
operation = self.params.get('operation')
vdc = self.params.get('vdc')
org_name = self.params.get('org_name')
org = self.params.get('org')
name = self.params.get('name')
host = self.params.get('host')
user = self.params.get('user')
password = self.params.get('password')
vdc_org_name = self.params.get('vdc_org_name')
self.operation = operation
self.vdc = vdc
self.org_name = org_name
self.org = org
self.name = name
self.host = host
self.user = user
self.password = password
self.vdc_org_name = vdc_org_name
def get_vdc_org_resource(self):
if self.params.get(self.vdc_org_name):
return self.client.get_org_by_name(self.params.get(self.vdc_org_name))
return self.client.get_org()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "read_and_return":
return self.read_and_return()
def read_and_return(self):
response = dict()
vdc_resources = dict()
vdc_resources = self.get_vdc_org_resource()
self.vdc_resources = vdc_resources
self.org = Org(self.client, resource=self.client.get_org())
platform = ""
#platform = Platform(self.org.client)
self.platform = platform
vddc_name = self.vdc_org_name
vdc_response = VDC(self.client, name=self.vdc, resource=(self.org.get_vdc(self.vdc)))
result = vdc_response.list_edge_gateways()
response['edge-gw'] = result
for e in result:
del e['href']
self.vdc_response = vdc_response
response['changed'] = True
return response
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 delete(self):
logging.info("__INIT__delete[User]")
res = user_pb2.DeleteUserResult()
res.deleted = False
context = self.context
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
try:
result = org.delete_user(self.name)
res.deleted = True
except Exception as e:
res.deleted = False
error_message = '__ERROR_delete[user] failed for user {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__delete[User]")
return res
def get_org_name_of_ovdc(vdc_id):
"""Get org_name from vdc_id using OVDC_TO_ORG_MAP.
Update OVDC_TO_ORG_MAP for new {org_name:vdc_id} pair
:param vdc_id: unique ovdc id
:return: org_name
"""
if vdc_id in OVDC_TO_ORG_MAP:
org_name = OVDC_TO_ORG_MAP.get(vdc_id)
else:
client = get_vcd_sys_admin_client()
vdc_href = f"{client._uri}/vdc/{vdc_id}"
vdc_resource = client.get_resource(get_admin_href(vdc_href))
vdc_obj = VDC(client, resource=vdc_resource)
link = find_link(vdc_obj.resource, RelationType.UP,
EntityType.ADMIN_ORG.value)
org = Org(client, href=link.href)
'''Add the entry to the map to be used next time the \
same ovdc is requested'''
OVDC_TO_ORG_MAP[vdc_id] = org.get_name()
org_name = org.get_name()
return org_name
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 delete_catalog_item(item_name):
org = Org(CLIENT, href=ORG_HREF)
try:
org.delete_catalog_item(CATALOG_NAME, item_name)
utils.wait_for_catalog_item_to_resolve(CLIENT, CATALOG_NAME, item_name,
org=org)
org.reload()
except EntityNotFoundException:
pass
def create_nodes_thread(self):
LOGGER.debug('about to add nodes to cluster with name: %s',
self.cluster_name)
try:
org_resource = self.client_tenant.get_org()
org = Org(self.client_tenant, resource=org_resource)
vdc = VDC(self.client_tenant, href=self.cluster['vdc_href'])
vapp = VApp(self.client_tenant, href=self.cluster['vapp_href'])
template = self.get_template()
self.update_task(
TaskStatus.RUNNING,
message='Creating %s node(s) for %s(%s)' %
(self.body['node_count'], self.cluster_name, self.cluster_id))
new_nodes = add_nodes(self.body['node_count'], template,
self.body['node_type'], self.config,
self.client_tenant, org, vdc, vapp,
self.body)
if self.body['node_type'] == TYPE_NFS:
self.update_task(TaskStatus.SUCCESS,
message='Created %s node(s) for %s(%s)' %
(self.body['node_count'], self.cluster_name,
self.cluster_id))
elif self.body['node_type'] == TYPE_NODE:
self.update_task(TaskStatus.RUNNING,
message='Adding %s node(s) to %s(%s)' %
(self.body['node_count'], self.cluster_name,
self.cluster_id))
target_nodes = []
for spec in new_nodes['specs']:
target_nodes.append(spec['target_vm_name'])
vapp.reload()
join_cluster(self.config, vapp, template, target_nodes)
self.update_task(TaskStatus.SUCCESS,
message='Added %s node(s) to cluster %s(%s)' %
(self.body['node_count'], self.cluster_name,
self.cluster_id))
except NodeCreationError as e:
error_obj = error_to_json(e)
LOGGER.error(traceback.format_exc())
self.update_task(
TaskStatus.ERROR,
error_message=error_obj[ERROR_MESSAGE][ERROR_DESCRIPTION])
raise
except Exception as e:
error_obj = error_to_json(e)
LOGGER.error(traceback.format_exc())
self.update_task(
TaskStatus.ERROR,
error_message=error_obj[ERROR_MESSAGE][ERROR_DESCRIPTION])
class EdgeInCatalogWhole(VcdAnsibleModule):
def __init__(self, **kwargs):
super(EdgeInCatalogWhole, self).__init__(**kwargs)
self.host = self.params.get('host')
self.host = self.params.get('host')
self.user = self.params.get('user')
self.password = self.params.get('password')
self.api_version = self.params.get('api_version')
self.vdc_name = self.params.get('vdc_name')
self.org_name = self.params.get('org_name')
self.edge_name = self.params.get('edge_name')
logged_in_org = self.client.get_org_by_name(self.org_name)
self.org = Org(self.client, resource=logged_in_org)
#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):
operation = self.params.get('operation')
if operation == "read":
return self.get_edge_information()
def get_edge_information(self):
operation = self.params.get('operation')
if operation:
return self.run_get_edge_information()
raise ValueError("Operation type is must be read, now is missing")
def run_get_edge_information(self):
response = dict()
response['changed'] = False
edge_name = self.params.get('edge_name')
description = self.params.get('description')
try:
self.vdc.get_direct_orgvdc_network(edge_name)
except EntityNotFoundException:
msg = 'EDGE INFO Cannot be found for {0} '
response['msg'] = error.__str__(msg)
response['changed'] = True
else:
msg = 'EDGE INFO Network {0} is already present'
response['warnings'] = msg.format(edge_name)
return response
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")))
