def test_020_create_isolated_orgvdc_network(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.create_isolated_vdc_network(
network_name=self.config['vcd']['vdc_isolated_network_name'],
gateway_ip=self.config['vcd']['isolated_network_gateway_ip'],
netmask=self.config['vcd']['isolated_network_gateway_netmask'],
description='Dummy description')
task = self.client.get_task_monitor().wait_for_success(
task=result.Tasks.Task[0])
assert task.get('status') == TaskStatus.SUCCESS.value
def delete(client, catalog_name, item_name):
logging.debug("===== delete ova to %s catalog called === \n",
catalog_name)
result = catalog_item_pb2.DeleteCatalogItemResult()
result.deleted = False
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org.delete_catalog_item(name=catalog_name, item_name=item_name)
result.deleted = True
return result
except Exception as e:
logging.warn("error occured", e)
return result
def list_acl(ctx, catalog_name):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
acl = org.get_catalog_access_control_settings(
catalog_name=catalog_name)
stdout(
access_settings_to_list(
acl, ctx.obj['profiles'].get('org_in_use')),
ctx,
sort_headers=False)
except Exception as e:
stderr(e, ctx)
def change_owner(ctx, vapp_name, user_name):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
user_resource = org.get_user(user_name)
vapp_resource = vdc.get_vapp(vapp_name)
vapp = VApp(client, resource=vapp_resource)
vapp.change_owner(user_resource.get('href'))
stdout('vapp owner changed', ctx)
except Exception as e:
stderr(e, ctx)
def read(self):
org_name = self.params.get('org_name')
response = dict()
org_details = dict()
response['changed'] = False
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['org_name'] = org_name
org_details['full_name'] = str(org_admin_resource['FullName'])
org_details['is_enabled'] = str(org_admin_resource['IsEnabled'])
response['msg'] = org_details
return response
def list_roles(ctx, org_name):
try:
restore_session(ctx)
client = ctx.obj['client']
if org_name is not None:
org_href = client.get_org_by_name(org_name).get('href')
else:
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, href=org_href)
roles = org.list_roles()
for role in roles:
del role['href']
stdout(roles, ctx)
except Exception as e:
stderr(e, ctx)
def add_right(ctx, role_name, rights, org_name):
try:
restore_session(ctx)
client = ctx.obj['client']
if org_name is not None:
org_href = client.get_org_by_name(org_name).get('href')
else:
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, href=org_href)
role_record = org.get_role_record(role_name)
role = Role(client, href=role_record.get('href'))
role.add_rights(list(rights), org)
stdout('Rights added successfully to the role \'%s\'' % role_name, ctx)
except Exception as e:
stderr(e, ctx)
def list_disks(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'))
#disks = vdc.get_disk('disk02')
#print(etree.tostring(disks, pretty_print=True))
logging.info(disks.get('href'))
vdc.delete_disk('disk02')
def list_rights(ctx, role_name, org_name):
try:
restore_session(ctx)
client = ctx.obj['client']
if org_name is not None:
org_href = client.get_org_by_name(org_name).get('href')
else:
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, href=org_href)
role_record = org.get_role_record(role_name)
role = Role(client, href=role_record.get('href'))
rights = role.list_rights()
stdout(rights, ctx)
except Exception as e:
stderr(e, ctx)
def delete_catalog(catalog_name=None, logger=NULL_LOGGER):
if catalog_name is None:
catalog_name = CATALOG_NAME
logger.debug(f"Deleting catalog {catalog_name}")
org = Org(CLIENT, href=ORG_HREF)
try:
org.delete_catalog(catalog_name)
# TODO() no way currently to wait for catalog deletion.
# https://github.com/vmware/pyvcloud/issues/334
# below causes EntityNotFoundException, catalog not found.
# time.sleep(15)
# org.reload()
logger.debug(f"Successfully deleted the catalog {catalog_name}")
except EntityNotFoundException:
logger.warning(f"Failed to delete catalog {catalog_name}")
def share(ctx, catalog_name, access_level):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
updated_acl = org.share_catalog_access(
catalog_name=catalog_name, everyone_access_level=access_level)
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 remove_right(ctx, role_name, rights, org_name):
try:
client = ctx.obj['client']
if org_name is not None:
org_href = client.get_org_by_name(org_name).get('href')
else:
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, href=org_href)
role_record = org.get_role_record(role_name)
role = Role(client, href=role_record.get('href'))
role.remove_rights(list(rights))
stdout('Removed rights successfully from the role \'%s\'' % role_name,
ctx)
except Exception as e:
stderr(e, ctx)
def unshare(ctx, vdc_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)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, resource=vdc_resource)
vdc.unshare_from_org_members()
stdout(
'Vdc \'%s\' unshared from all members of the org \'%s\'.' %
(vdc_name, ctx.obj['profiles'].get('org_in_use')), ctx)
except Exception as e:
stderr(e, ctx)
def add_network(self):
network_name = self.params.get('network')
fence_mode = self.params.get('fence_mode')
parent_network = self.params.get('parent_network')
ip_scope = self.params.get('ip_scope')
response = dict()
response['changed'] = False
try:
self.get_network()
except EntityNotFoundException:
network_config_section = self.vapp.resource.NetworkConfigSection
config = E.Configuration()
if parent_network:
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))
orgvdc_networks = vdc_resource.list_orgvdc_network_resources(parent_network)
parent = next((network for network in orgvdc_networks if network.get('name') == parent_network), None)
if parent:
config.append(E.ParentNetwork(href=parent.get('href')))
else:
raise EntityNotFoundException('Parent network \'%s\' does not exist'.format(parent_network))
elif ip_scope:
scope = E.IpScope(
E.IsInherited('false'),
E.Gateway(str(ip_network(ip_scope, strict=False).network_address+1)),
E.Netmask(str(ip_network(ip_scope, strict=False).netmask)))
config.append(E.IpScopes(scope))
else:
raise VappNetworkCreateError('Either parent_network or ip_scope must be set')
config.append(E.FenceMode(fence_mode))
network_config = E.NetworkConfig(config, networkName=network_name)
network_config_section.append(network_config)
add_network_task = self.client.put_linked_resource(
self.vapp.resource.NetworkConfigSection, RelationType.EDIT,
EntityType.NETWORK_CONFIG_SECTION.value,
network_config_section)
self.execute_task(add_network_task)
response['msg'] = 'Vapp Network {} has been added'.format(network_name)
response['changed'] = True
else:
response['warnings'] = 'Vapp Network {} is already present.'.format(network_name)
return response
def delete(self):
logging.info("__INIT__delete[Vdc]")
res = vdc_pb2.DeleteVdcResult()
res.deleted = 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)
vdc = VDC(self.client, name=name, resource=vdc_resource)
delete_vdc_resp = vdc.delete_vdc()
task = self.client.get_task_monitor().wait_for_status(
task=delete_vdc_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))
res.deleted = True
except Exception as e:
res.deleted = False
error_message = '__ERROR_delete[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__delete[Vdc]")
return res
def power_on(self, request):
logging.info("__INIT__power_on[VappVm]")
res = vapp_vm_pb2.PowerOnVappVmResult()
res.powered_on = 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)
vapp_vm_resource = vapp.get_vm(request.target_vm_name)
vm = VM(self.client, resource=vapp_vm_resource)
power_on_response = vm.power_on()
task = self.client.get_task_monitor().wait_for_status(
task=power_on_response,
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.VappVmPowerOnError(
etree.tostring(task, pretty_print=True))
message = 'status : {0} '.format(st)
logging.info(message)
res.powered_on = True
except Exception as e:
errmsg = '__ERROR_power_off[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)
logging.info("__DONE__power_on[VappVm]")
return res
def save_metadata(client,
org_name,
catalog_name,
catalog_item_name,
template_data,
metadata_key_list=None):
metadata_key_list = metadata_key_list or []
org_resource = client.get_org_by_name(org_name=org_name)
org = Org(client, resource=org_resource)
org.set_multiple_metadata_on_catalog_item(
catalog_name=catalog_name,
item_name=catalog_item_name,
key_value_dict={k: template_data[k]
for k in metadata_key_list},
domain=MetadataDomain.SYSTEM,
visibility=MetadataVisibility.PRIVATE)
def info(ctx, name):
try:
restore_session(ctx)
client = ctx.obj['client']
logged_in_org_name = ctx.obj['profiles'].get('org')
in_use_org_name = ctx.obj['profiles'].get('org_in_use')
org_resource = client.get_org_by_name(name)
org = Org(client=client, resource=org_resource)
result = org_to_dict(org)
result['logged_in'] = logged_in_org_name.lower() == \
result.get('name').lower()
result['in_use'] = in_use_org_name.lower() == \
result.get('name').lower()
stdout(result, ctx)
except Exception as e:
stderr(e, ctx)
def link(ctx, role_name, org_name):
try:
client = ctx.obj['client']
if org_name is not None:
org_href = client.get_org_by_name(org_name).get('href')
else:
org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, org_href)
role_record = org.get_role(role_name)
role = Role(client, href=role_record.get('href'))
role.link()
stdout(
'Role \'%s\' has been successfully linked to it\'s template.' %
role_name, ctx)
except Exception as e:
stderr(e, ctx)
def upload_media(client, catalog_name, file_name, item_name):
logging.debug("===== upload_media to ++catalog called === \n")
result = pyvcloudprovider_pb2.CatalogUploadMediaResult()
result.created = False
try:
logged_in_org = client.get_org()
org = Org(client, resource=logged_in_org)
org.upload_media(catalog_name=catalog_name,
file_name=file_name,
item_name=item_name)
result.created = True
return result
except Exception as e:
logging.warn("error occured", e)
return result
def create_user(self, user_name, enabled=False):
logged_in_org = self.client.get_org()
org = Org(self.client, resource=logged_in_org)
role = org.get_role(self.config['vcd']['role_name'])
role_href = role.get('href')
return org.create_user(user_name,
"password",
role_href,
"Full Name",
"Description",
"*****@*****.**",
"408-487-9087",
"test_user_im",
"*****@*****.**",
"Alert Vcd:",
is_enabled=enabled)
def test_delete_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'))
t = org.delete_org_vdc(self.config['vcd']['new_vdc'])
task = self.client.get_task_monitor().wait_for_status(
task=t,
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_04_add_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.add_catalog_access_settings(
self.config['vcd']['catalog'],
access_settings_list=[
{'name': self.config['vcd']['access_user1'], 'type': 'user',
'access_level': 'ReadOnly'},
{'name': self.config['vcd']['access_user'], 'type': 'user',
'access_level':'Change'},
{'name': self.config['vcd']['access_org'], 'type': 'org',
'access_level': 'ReadOnly'}
])
assert len(control_access.AccessSettings.AccessSetting) == 3
def test_050_change_idisk_owner(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)
user_resource = org.get_user(
self.config['vcd']['idisk_new_owner_name'])
vdc.change_disk_owner(name=self.config['vcd']['idisk_name'],
user_href=user_resource.get('href'))
disk_resource = vdc.get_disk(self.config['vcd']['idisk_name'])
new_user = disk_resource.Owner.User.get('name')
assert self.config['vcd']['idisk_new_owner_name'] == new_user
def test_008_get_disks(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'))
disks = vdc.get_disks()
for disk in disks:
print (" Disk: " + str(etree.tostring(disk, pretty_print=True), "utf-8"))
assert len(disks) > 0
assert disks[0].get('name') == self.config['vcd']['disk']
def assign_native_rights(role_name, right_list=None, logger=NULL_LOGGER):
logger.debug(f"Assigning rights {right_list} to the role {role_name}")
if not right_list:
logger.debug(f"Skipping assigning native rights to role {role_name}")
return
try:
test_org = Org(CLIENT, href=TEST_ORG_HREF)
role_resource = test_org.get_role_resource(role_name)
role = Role(CLIENT, resource=role_resource)
initial_right_set = set([r['name'] for r in role.list_rights()])
right_set = set(right_list)
initial_right_set.update(right_set)
role.add_rights(list(initial_right_set), test_org)
except Exception as e:
logger.warning(f"Failed to assign native rights "
f"{right_list} to role {role_name}: {e} ")
def add(ctx, catalog_name, access_list):
try:
client = ctx.obj['client']
in_use_org_href = ctx.obj['profiles'].get('org_href')
org = Org(client, in_use_org_href)
updated_acl = org.add_catalog_access_settings(
catalog_name=catalog_name,
access_settings_list=acl_str_to_list_of_dict(access_list))
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 list_acl(ctx, vdc_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)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(client, resource=vdc_resource)
acl = vdc.get_access_settings()
stdout(
access_settings_to_list(acl,
ctx.obj['profiles'].get('org_in_use')),
ctx)
except Exception as e:
stderr(e, ctx)
def _list_ovdcs(self, list_pks_plans):
"""Get list of ovdcs.
If client is sysadmin,
Gets all ovdcs of all organizations.
Else
Gets all ovdcs of the organization in context.
"""
client, _ = connect_vcd_user_via_token(self.tenant_auth_token)
if client.is_sysadmin():
org_resource_list = client.get_org_list()
else:
org_resource_list = list(client.get_org())
ovdc_list = []
vc_to_pks_plans_map = {}
if is_pks_enabled() and list_pks_plans:
if client.is_sysadmin():
vc_to_pks_plans_map = self._construct_vc_to_pks_map()
else:
raise UnauthorizedActionError(
'Operation Denied. Plans available only for '
'System Administrator.')
for org_resource in org_resource_list:
org = Org(client, resource=org_resource)
vdc_list = org.list_vdcs()
for vdc_sparse in vdc_list:
ctr_prov_ctx = \
OvdcManager().get_ovdc_container_provider_metadata(
ovdc_name=vdc_sparse['name'], org_name=org.get_name(),
credentials_required=False)
vdc_dict = {
'name': vdc_sparse['name'],
'org': org.get_name(),
K8S_PROVIDER_KEY: ctr_prov_ctx[K8S_PROVIDER_KEY]
}
if is_pks_enabled() and list_pks_plans:
pks_plans, pks_server = self.\
_get_pks_plans_and_server_for_vdc(client,
vdc_sparse,
org_resource,
vc_to_pks_plans_map)
vdc_dict['pks_api_server'] = pks_server
vdc_dict['available pks plans'] = pks_plans
ovdc_list.append(vdc_dict)
return ovdc_list
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)
