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 _gateways(self, org_name, vdc_name):
org_resource = self.client.get_org_by_name(org_name)
org = Org(self.client, resource=org_resource)
vdc_resource = org.get_vdc(vdc_name)
vdc = VDC(self.client, name=vdc_name, resource=vdc_resource)
gateways = vdc.list_edge_gateways()
result = list()
for gateway in gateways:
nats = list()
nat_resources = self.client.get_resource(str(gateway.get('href')))
for nat in nat_resources['Configuration'][
'EdgeGatewayServiceConfiguration']['NatService'][
'NatRule']:
if nat['IsEnabled'] == True:
nats.append({
'id':
str(nat['Id']),
'type':
str(nat['RuleType']),
'network':
str(nat['GatewayNatRule']['Interface'].get('name')),
'original':
str(nat['GatewayNatRule']['OriginalIp']),
'translated':
str(nat['GatewayNatRule']['TranslatedIp'])
})
result.append({
'href': gateway.get('href'),
'name': gateway.get('name'),
'nats': nats
})
return result
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 list_gateways(ctx):
try:
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
result = vdc.list_edge_gateways()
for e in result:
del e['href']
stdout(result, ctx, show_id=False)
except Exception as e:
stderr(e, ctx)
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 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 org_info(self):
response = dict()
response['changed'] = False
response['json'] = list()
##
org_details = dict()
org_name = self.params.get('org')
resource = self.client.get_org_by_name(org_name)
org = Org(self.client, resource=resource)
org_admin_resource = org.client.get_resource(org.href_admin)
#org_details['token'] = str(self.client.get_xvcloud_authorization_token())
org_details['href'] = str(org.href_admin)
org_details['name'] = str(org_admin_resource['FullName'])
org_details['description'] = str(org_admin_resource['Description'])
org_details['enabled'] = str(org_admin_resource['IsEnabled'])
org_details['users'] = list()
org_details['vdcs'] = list()
## Users/UserReference
for user in org_admin_resource['Users']['UserReference']:
org_details['users'].append({
'name': user.get('name'),
'href': user.get('href')
})
## Vdcs/Vdc
for vdc in org_admin_resource['Vdcs']['Vdc']:
vdc_resources = self.client.get_resource(vdc.get('href'))
## ResourceEntities/ResourceEntity
vapps = list()
try:
vdc_resources['ResourceEntities']['ResourceEntity']
except AttributeError:
vapps = list()
else:
for vapp in vdc_resources['ResourceEntities'][
'ResourceEntity']:
if "vApp+" in vapp.get('type'):
vapp_resourses = self.client.get_resource(
vapp.get('href'))
vms = list()
try:
vapp_resourses['Children']
except AttributeError:
vms = list()
else:
for vm in vapp_resourses['Children']['Vm']:
vm_info = self.vm_info(name=vm.get('name'),
vapp=vapp.get('name'))
vms = vm_info['json']
if len(vms) > 0:
vapps.append({
'href': str(vapp.get('href')),
'name': str(vapp.get('name')),
'vms': vms
})
## AvailableNetworks/Network
nets = list()
for net in vdc_resources['AvailableNetworks']['Network']:
nets.append({
'href': str(net.get('href')),
'name': str(net.get('name'))
})
## VdcStorageProfiles/VdcStorageProfile
storages = list()
for storage in vdc_resources['VdcStorageProfiles'][
'VdcStorageProfile']:
storage_resources = self.client.get_resource(
str(storage.get('href')))
storages.append({
'href':
str(storage.get('href')),
'name':
str(storage.get('name')),
'units':
str(storage_resources['Units']),
'total':
str(storage_resources['Limit']),
'used':
str(storage_resources['StorageUsedMB']),
'free':
str(storage_resources['Limit'] -
storage_resources['StorageUsedMB'])
})
vdc_name = vdc.get('name')
vdc_resource = org.get_vdc(vdc_name)
vdcenter = VDC(self.client, name=vdc_name, resource=vdc_resource)
gateways = vdcenter.list_edge_gateways()
org_details['vdcs'].append({
'name': vdc.get('name'),
'href': vdc.get('href'),
'cpu': {
'units':
str(vdc_resources['ComputeCapacity']['Cpu']['Units']),
'total':
str(vdc_resources['ComputeCapacity']['Cpu']['Limit']),
'used':
str(vdc_resources['ComputeCapacity']['Cpu']['Used']),
'free':
str(vdc_resources['ComputeCapacity']['Cpu']['Limit'] -
vdc_resources['ComputeCapacity']['Cpu']['Used'])
},
'ram': {
'units':
str(vdc_resources['ComputeCapacity']['Memory']['Units']),
'total':
str(vdc_resources['ComputeCapacity']['Memory']['Limit']),
'used':
str(vdc_resources['ComputeCapacity']['Memory']['Used']),
'free':
str(vdc_resources['ComputeCapacity']['Memory']['Limit'] -
vdc_resources['ComputeCapacity']['Memory']['Used'])
},
'vapps': vapps,
'networks': nets,
'storages': storages,
'gateways': gateways
})
## Networks/Network
## Catalogs/CatalogReference
response['json'] = org_details
##
response['changed'] = True
return response
vdclist = org.list_vdcs()
vdctable = PrettyTable(["Organization", "VDC name", "VDC href"])
for i in range(len(vdclist)):
vdctable.add_row(
[o.get('name'), vdclist[i]['name'], vdclist[i]['href']])
print(vdctable)
# Iterate over VDCs to retrieve data about Edges, Org Networks, vAPPs and VMs
for vdc in vdclist:
# print("\nFetching VDC {}".format(vdc['name']))
vdc_resource = org.get_vdc(vdc['name'])
vdc_instance = VDC(client, resource=vdc_resource)
cprint("\nList of all Tenant Edges in the VDC {}".format(vdc['name']),
'yellow')
edgelist = vdc_instance.list_edge_gateways()
edgetable = PrettyTable(
["Organization", "VDC name", "Edge name", "Edge href"])
for j in range(len(edgelist)):
edgetable.add_row([
o.get('name'), vdc['name'], edgelist[j]['name'],
edgelist[j]['href']
])
print(edgetable)
# Retrieve VDC Org Networks ---------------------------------------------------------------
cprint("\nList of VDC Org Networks from VDC {}".format(vdc['name']),
'yellow')
orgnets = vdc_instance.list_orgvdc_network_resources()
orgnettable = PrettyTable(
["Organization", "VDC name", "Org Nw name", "Org Nw href"])
