def test_0000_setup(self):
"""
Create one external network as per the configuration stated aboveself.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Test the method Platform.create_external_network().
This test passes if external network is created successfully.
"""
logger = Environment.get_default_logger()
TestExtNet._sys_admin_client = Environment.get_sys_admin_client()
TestExtNet._config = Environment.get_config()
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc']['vcenter_host_name']
name_filter = ('vcName', vc_name)
query = TestExtNet._sys_admin_client.get_typed_query(
ResourceType.PORT_GROUP.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
for record in list(query.execute()):
if record.get('networkName') == '--':
if not record.get('name').startswith('vxw-'):
TestExtNet._port_group = record.get('name')
break
self.assertIsNotNone(self._port_group,
'None of the port groups are free.')
ext_net = platform.create_external_network(
name=TestExtNet._name,
vim_server_name=vc_name,
port_group_names=[TestExtNet._port_group],
gateway_ip=TestExtNet._gateway,
netmask=TestExtNet._netmask,
ip_ranges=[TestExtNet._ip_range],
description=TestExtNet._description,
primary_dns_ip=TestExtNet._dns1,
secondary_dns_ip=TestExtNet._dns2,
dns_suffix=TestExtNet._dns_suffix)
task = ext_net.find('vcloud:Tasks', NSMAP).Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Created external network ' + TestExtNet._name + '.')
def _create_external_network(cls):
vc_name = cls._config['vc']['vcenter_host_name']
name_filter = ('vcName', vc_name)
query = cls._sys_admin_client.get_typed_query(
ResourceType.PORT_GROUP.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
port_group = None
for record in list(query.execute()):
if record.get('networkName') == '--':
if not record.get('name').startswith('vxw-'):
port_group = record.get('name')
break
if port_group is None:
raise Exception(
'None of the port groups are free for new network.')
ext_config = cls._config['external_network']
ip_scopes = cls._config['external_network']['ip_scopes']
if len(ip_scopes) == 0:
raise Exception('No network spec provided.')
# [{subnet:'10.10.10.1/24', ip_range:'10.10.10.101-10.10.10.150'}]
primary_subnet = ip_scopes[0]['subnet']
gateway_ip, prefix_len = primary_subnet.split('/')
netmask = cidr_to_netmask(primary_subnet)[1]
ip_ranges = ip_scopes[0]['ip_ranges']
primary_dns_ip = '8.8.8.8'
secondary_dns_ip = '8.8.8.9'
dns_suffix = 'example.com'
platform = Platform(cls._sys_admin_client)
ext_net = platform.create_external_network(
name=ext_config['name'],
vim_server_name=vc_name,
port_group_names=[port_group],
gateway_ip=gateway_ip,
netmask=netmask,
ip_ranges=ip_ranges,
description=ext_config['name'],
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
cls._sys_admin_client.get_task_monitor().wait_for_success(task=task)
return ext_net
def test_0000_setup(self):
"""
Create one external network as per the configuration stated aboveself.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Test the method Platform.create_external_network().
This test passes if external network is created successfully.
"""
logger = Environment.get_default_logger()
TestExtNet._sys_admin_client = Environment.get_sys_admin_client()
TestExtNet._config = Environment.get_config()
TestExtNet._common_ext_net_name = TestExtNet._config[
'external_network']['name']
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc']['vcenter_host_name']
TestExtNet._vc2_host_ip = TestExtNet._config['vc2']['vcenter_host_ip']
portgrouphelper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = portgrouphelper.get_available_portgroup_name(
vc_name, TestExtNet._portgroupType)
ext_net = platform.create_external_network(
name=TestExtNet._name,
vim_server_name=vc_name,
port_group_names=[pg_name],
gateway_ip=TestExtNet._gateway,
netmask=TestExtNet._netmask,
ip_ranges=[TestExtNet._ip_range],
description=TestExtNet._description,
primary_dns_ip=TestExtNet._dns1,
secondary_dns_ip=TestExtNet._dns2,
dns_suffix=TestExtNet._dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Created external network ' + TestExtNet._name + '.')
def test_0000_setup(self):
"""
Create one external network as per the configuration stated aboveself.
Choose first unused port group which is not a VxLAN. Unused port groups
have network names set to '--'. VxLAN port groups have name starting
with 'vxw-'.
Test the method Platform.create_external_network().
This test passes if external network is created successfully.
"""
logger = Environment.get_default_logger()
TestExtNet._sys_admin_client = Environment.get_sys_admin_client()
TestExtNet._config = Environment.get_config()
TestExtNet._common_ext_net_name = TestExtNet._config[
'external_network']['name']
platform = Platform(TestExtNet._sys_admin_client)
vc_name = TestExtNet._config['vc']['vcenter_host_name']
TestExtNet._vc2_host_ip = TestExtNet._config['vc2']['vcenter_host_ip']
portgrouphelper = PortgroupHelper(TestExtNet._sys_admin_client)
pg_name = portgrouphelper.get_available_portgroup_name(
vc_name, TestExtNet._portgroupType)
ext_net = platform.create_external_network(
name=TestExtNet._name,
vim_server_name=vc_name,
port_group_names=[pg_name],
gateway_ip=TestExtNet._gateway,
netmask=TestExtNet._netmask,
ip_ranges=[TestExtNet._ip_range],
description=TestExtNet._description,
primary_dns_ip=TestExtNet._dns1,
secondary_dns_ip=TestExtNet._dns2,
dns_suffix=TestExtNet._dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestExtNet._sys_admin_client.get_task_monitor().wait_for_success(
task=task)
logger.debug('Created external network ' + TestExtNet._name + '.')
def _create_external_network(cls):
vc_name = cls._config['vc']['vcenter_host_name']
portgrouphelper = PortgroupHelper(cls._sys_admin_client)
port_group = portgrouphelper.get_available_portgroup_name(
vc_name, Environment._portgroupType)
if port_group is None:
raise Exception(
'None of the port groups are free for new network.')
ext_config = cls._config['external_network']
ip_scopes = cls._config['external_network']['ip_scopes']
if len(ip_scopes) == 0:
raise Exception('No network spec provided.')
# [{subnet:'10.10.10.1/24', ip_range:'10.10.10.101-10.10.10.150'}]
primary_subnet = ip_scopes[0]['subnet']
gateway_ip, prefix_len = primary_subnet.split('/')
netmask = cidr_to_netmask(primary_subnet)[1]
ip_ranges = ip_scopes[0]['ip_ranges']
primary_dns_ip = '8.8.8.8'
secondary_dns_ip = '8.8.8.9'
dns_suffix = 'example.com'
platform = Platform(cls._sys_admin_client)
ext_net = platform.create_external_network(
name=ext_config['name'],
vim_server_name=vc_name,
port_group_names=[port_group],
gateway_ip=gateway_ip,
netmask=netmask,
ip_ranges=ip_ranges,
description=ext_config['name'],
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix)
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
cls._sys_admin_client.get_task_monitor().wait_for_success(task=task)
return ext_net
def _create_external_network(self):
"""Creates an external network from the available portgroup."""
vc_name = TestGateway._config['vc']['vcenter_host_name']
name_filter = ('vcName', vc_name)
query = TestGateway._client.get_typed_query(
ResourceType.PORT_GROUP.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
port_group = None
for record in list(query.execute()):
if record.get('networkName') == '--':
if not record.get('name').startswith('vxw-'):
port_group = record.get('name')
break
if port_group is None:
raise Exception(
'None of the port groups are free for new network.')
name = 'external_network_' + str(uuid1())
platform = Platform(TestGateway._client)
ext_net = platform.create_external_network(
name=name,
vim_server_name=vc_name,
port_group_names=[port_group],
gateway_ip='10.10.30.1',
netmask='255.255.255.0',
ip_ranges=['10.10.30.101-10.10.30.150'],
description=name,
primary_dns_ip='8.8.8.8',
secondary_dns_ip='8.8.8.9',
dns_suffix='example.com')
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestGateway._client.get_task_monitor().wait_for_success(task=task)
TestGateway._external_network2 = ext_net
return ext_net
def _create_external_network(self):
"""Creates an external network from the available portgroup."""
vc_name = TestGateway._config['vc']['vcenter_host_name']
name_filter = ('vcName', vc_name)
query = TestGateway._client.get_typed_query(
ResourceType.PORT_GROUP.value,
query_result_format=QueryResultFormat.RECORDS,
equality_filter=name_filter)
port_group = None
for record in list(query.execute()):
if record.get('networkName') == '--':
if not record.get('name').startswith('vxw-'):
port_group = record.get('name')
break
if port_group is None:
raise Exception(
'None of the port groups are free for new network.')
name = 'external_network_' + str(uuid1())
platform = Platform(TestGateway._client)
ext_net = platform.create_external_network(
name=name,
vim_server_name=vc_name,
port_group_names=[port_group],
gateway_ip='10.10.30.1',
netmask='255.255.255.0',
ip_ranges=['10.10.30.101-10.10.30.150'],
description=name,
primary_dns_ip='8.8.8.8',
secondary_dns_ip='8.8.8.9',
dns_suffix='example.com')
task = ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0]
TestGateway._client.get_task_monitor().wait_for_success(task=task)
TestGateway._external_network2 = ext_net
return ext_net
def create_external_network(ctx, name, vc_name, port_group, gateway_ip,
netmask, ip_range, description, primary_dns_ip,
secondary_dns_ip, dns_suffix):
try:
restore_session(ctx)
client = ctx.obj['client']
platform = Platform(client)
ext_net = platform.create_external_network(
name=name,
vim_server_name=vc_name,
port_group_names=port_group,
gateway_ip=gateway_ip,
netmask=netmask,
ip_ranges=ip_range,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix)
stdout(ext_net['{' + NSMAP['vcloud'] + '}Tasks'].Task[0], ctx)
stdout('External network created successfully.', ctx)
except Exception as e:
stderr(e, ctx)
class VcdExternalNetwork(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VcdExternalNetwork, self).__init__(**kwargs)
self.platform = Platform(self.client)
def manage_states(self):
state = self.params.get('state')
if state == "present":
return self.create()
if state == "update":
return self.update()
if state == "absent":
return self.delete()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "list_networks":
return self.list_external_networks()
if operation == "add_subnet":
return self.add_subnet()
if operation == "add_ip_ranges":
return self.add_ip_ranges()
if operation == "modify_ip_ranges":
return self.modify_ip_ranges()
if operation == "delete_ip_ranges":
return self.delete_ip_ranges()
if operation == "enable_subnet":
return self.enable_subnet()
if operation == "attach_port_group":
return self.attach_port_group()
if operation == "detach_port_group":
return self.detach_port_group()
def create(self):
vc_name = self.params.get('vc_name')
port_group_names = self.params.get('port_group_names')
network_name = self.params.get('network_name')
gateway_ip = self.params.get('gateway_ip')
netmask = self.params.get('netmask')
ip_ranges = self.params.get('ip_ranges')
primary_dns_ip = self.params.get('primary_dns_ip')
secondary_dns_ip = self.params.get('secondary_dns_ip')
dns_suffix = self.params.get('dns_suffix')
description = self.params.get('description')
response = dict()
response['changed'] = False
try:
self.platform.get_external_network(network_name)
except EntityNotFoundException:
self.platform.create_external_network(network_name, vc_name,
port_group_names, gateway_ip,
netmask, ip_ranges,
description,
primary_dns_ip,
secondary_dns_ip,
dns_suffix)
msg = "External Network {0} is created"
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = "External Network {0} is already present"
response['warnings'] = msg.format(network_name)
return response
def update(self):
network_name = self.params.get('network_name')
new_network_name = self.params.get('new_network_name')
description = self.params.get('description')
response = dict()
response['changed'] = False
try:
self.platform.get_external_network(network_name)
self.platform.update_external_network(
network_name, new_network_name, description)
except EntityNotFoundException:
msg = "External Network {0} does not exists"
response['msg'] = msg.format(network_name)
else:
msg = "External Network {0} has been updated with {1}"
response['msg'] = msg.format(network_name, new_network_name)
response['changed'] = True
return response
def delete(self):
network_name = self.params.get('network_name')
force_delete = self.params.get('force_delete')
response = dict()
response['changed'] = False
try:
task = self.platform.delete_external_network(
network_name, force_delete)
self.execute_task(task)
except EntityNotFoundException:
msg = "External Network {0} does not exists"
response['msg'] = msg.format(network_name)
else:
msg = "External Network {0} has been deleted"
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def list_external_networks(self):
response = dict()
response['msg'] = list()
response['changed'] = False
networks = self.platform.list_external_networks()
response['msg'] = [v for k, v in networks.items() if k == "name"]
return response
def add_subnet(self):
network_name = self.params.get('network_name')
gateway_ip = self.params.get('gateway_ip')
netmask = self.params.get('netmask')
ip_ranges = self.params.get('ip_ranges')
primary_dns_ip = self.params.get('primary_dns_ip')
secondary_dns_ip = self.params.get('secondary_dns_ip')
dns_suffix = self.params.get('dns_suffix')
response = dict()
response['changed'] = False
network = self.get_network(network_name)
network.add_subnet(network_name, gateway_ip, netmask, ip_ranges,
primary_dns_ip, secondary_dns_ip, dns_suffix)
msg = "A new subnet has been added to network {0}"
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def add_ip_ranges(self):
network_name = self.params.get('network_name')
gateway_ip = self.params.get('gateway_ip')
ip_ranges = self.params.get('ip_ranges')
response = dict()
response['changed'] = False
network = self.get_network(network_name)
network.add_ip_range(gateway_ip, ip_ranges)
msg = "A new ip ranges has been added to network {0}"
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def modify_ip_ranges(self):
network_name = self.params.get('network_name')
gateway_ip = self.params.get('gateway_ip')
ip_ranges = self.params.get('ip_ranges')
new_ip_ranges = self.params.get('new_ip_ranges')
response = dict()
response['changed'] = False
if len(ip_ranges) != len(new_ip_ranges):
raise ValueError(
"ip_ranges and new_ip_ranges should have same length")
network = self.get_network(network_name)
for i in range(len(ip_ranges)):
network.modify_ip_range(gateway_ip, ip_ranges[i], new_ip_ranges[i])
msg = "Ip ranges have been updated to network {0}"
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def delete_ip_ranges(self):
network_name = self.params.get('network_name')
gateway_ip = self.params.get('gateway_ip')
ip_ranges = self.params.get('ip_ranges')
response = dict()
response['changed'] = False
network = self.get_network(network_name)
network.delete_ip_range(gateway_ip, ip_ranges)
msg = "Ip ranges have been deleted from network {0}"
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def enable_subnet(self):
network_name = self.params.get('network_name')
gateway_ip = self.params.get('gateway_ip')
enable_subnet = self.params.get('enable_subnet')
response = dict()
response['changed'] = False
network = self.get_network(network_name)
network.enable_subnet(gateway_ip, enable_subnet)
s = "has been enabled" if enable_subnet else "has been disabled"
msg = "subnet with gatway {0} {1} now in network {2}"
response['msg'] = msg.format(gateway_ip, s, network_name)
response['changed'] = True
return response
def attach_port_group(self):
network_name = self.params.get('network_name')
vc_name = self.params.get('vc_name')
port_group_names = self.params.get('port_group_names')
response = dict()
response['changed'] = False
network = self.get_network(network_name)
for port_group_name in port_group_names:
network.attach_port_group(vc_name, port_group_name)
msg = "port groups {0} have been attached now from network {1}"
response['msg'] = msg.format(','.join(port_group_names), network_name)
response['changed'] = True
return response
def detach_port_group(self):
network_name = self.params.get('network_name')
vc_name = self.params.get('vc_name')
port_group_names = self.params.get('port_group_names')
response = dict()
response['changed'] = False
network = self.get_network(network_name)
for port_group_name in port_group_names:
network.detach_port_group(vc_name, port_group_name)
msg = "port groups {0} have been detached now from network {1}"
response['msg'] = msg.format(','.join(port_group_names), network_name)
response['changed'] = True
return response
def get_network(self, network_name):
network_resource = self.platform.get_external_network(network_name)
return ExternalNetwork(self.client, resource=network_resource)
print("External Network already exists: {0}".format(
cfg.system.ext_network.name))
except Exception:
print("External Network {0} does not exist, creating".format(
cfg.system.ext_network.name))
# Ensure Port Group exists.
print("Fetching Port Groups...")
# Fetch dvportgroups - not startswith('vxw-')
records = platform.list_available_port_group_names(
vim_server_name=cfg.system.vcenter)
if cfg.system.ext_network.portgroup in records:
print("Port Group {0} found".format(cfg.system.ext_network.portgroup))
print("Creating External Network {0} ".format(
cfg.system.ext_network.name))
network_resource = platform.create_external_network(
cfg.system.ext_network.name, cfg.system.vcenter,
[cfg.system.ext_network.portgroup], cfg.system.ext_network.gateway,
cfg.system.ext_network.mask, [cfg.system.ext_network.range])
else:
print("Port Group {0} does not exist, exiting".format(
cfg.system.ext_network.portgroup))
# Status report -----------------------------------------------------------------------------------
new_external_network = platform.get_external_network(
cfg.system.ext_network.name)
print(
'\nNew External network is created -------------------------------------------------'
)
print('name: {}'.format(new_external_network.attrib['name']))
print('href: {}'.format(new_external_network.attrib['href']))
