def create_ovdc_network(cls):
"""Creates an isolated org vdc network.
The name of the created org vdc network is specified in the
configuration file, skips creating one, if such a network already
exists.
:raises: Exception: if the class variable _ovdc_href is not populated.
"""
cls._basic_check()
if cls._ovdc_href is None:
raise Exception('OrgVDC ' +
cls._config['vcd']['default_ovdc_name'] +
' doesn\'t exist.')
vdc = VDC(cls._sys_admin_client, href=cls._ovdc_href)
expected_net_name = cls._config['vcd']['default_ovdc_network_name']
records_list = vdc.list_orgvdc_network_records()
for network_record in records_list:
if network_record['name'].lower() == expected_net_name.lower():
cls._logger.debug('Reusing existing org-vdc network ' +
expected_net_name)
return
cls._logger.debug('Creating org-vdc network ' + expected_net_name)
result = vdc.create_isolated_vdc_network(
network_name=expected_net_name,
network_cidr=cls._config['vcd']
['default_ovdc_network_network_cidr'])
cls._sys_admin_client.get_task_monitor()\
.wait_for_success(task=result.Tasks.Task[0])
def create_isolated_network(ctx, name, gateway_ip, netmask, description,
primary_dns_ip, secondary_dns_ip, dns_suffix,
ip_range_start, ip_range_end, is_dhcp_enabled,
default_lease_time, max_lease_time,
dhcp_ip_range_start, dhcp_ip_range_end, is_shared):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=in_use_vdc_href)
result = vdc.create_isolated_vdc_network(
network_name=name,
gateway_ip=gateway_ip,
netmask=netmask,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_dhcp_enabled=is_dhcp_enabled,
default_lease_time=default_lease_time,
max_lease_time=max_lease_time,
dhcp_ip_range_start=dhcp_ip_range_start,
dhcp_ip_range_end=dhcp_ip_range_end,
is_shared=is_shared)
stdout(result.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
def create_isolated_network(ctx, name, gateway_ip, netmask, description,
primary_dns_ip, secondary_dns_ip, dns_suffix,
ip_range_start, ip_range_end, is_dhcp_enabled,
default_lease_time, max_lease_time,
dhcp_ip_range_start, dhcp_ip_range_end, is_shared):
try:
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
in_use_vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=in_use_vdc_href)
prefix_len = netmask_to_cidr_prefix_len(gateway_ip, netmask)
network_cidr = gateway_ip + '/' + str(prefix_len)
result = vdc.create_isolated_vdc_network(
network_name=name,
network_cidr=network_cidr,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_dhcp_enabled=is_dhcp_enabled,
default_lease_time=default_lease_time,
max_lease_time=max_lease_time,
dhcp_ip_range_start=dhcp_ip_range_start,
dhcp_ip_range_end=dhcp_ip_range_end,
is_shared=is_shared)
stdout(result.Tasks.Task[0], ctx)
except Exception as e:
stderr(e, ctx)
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
# Check for desired networks and create them if they don't exist.
# (We might add other kinds of networks later.)
if cfg.networks.get("isolated"):
print("Checking isolated networks...")
for network in cfg.networks['isolated']:
isolated_network_list = vdc.list_orgvdc_network_resources(
name=network['network_name'], type=FenceMode.ISOLATED.value)
if len(isolated_network_list) > 0:
print("Isolated network exists: {0}".format(
network['network_name']))
else:
# Create the network in the vDC.
print("Network does not exist, creating: {0}".format(
network['network_name']))
network_resource = vdc.create_isolated_vdc_network(**network)
handle_task(client, network_resource.Tasks.Task[0])
print("Network created")
# Ensure the network is visible in the VDC.
network_exists = False
while not network_exists:
new_network_list = vdc.list_orgvdc_network_resources(
name=network['network_name'],
type=FenceMode.ISOLATED.value)
if len(new_network_list) > 0:
print("Isolated network is visible in VDC: {0}".format(
network['network_name']))
network_exists = True
else:
print("Isolated network is not visible yet: {0}".format(
class OrgVdcNetwork(VcdAnsibleModule):
def __init__(self, **kwargs):
super(OrgVdcNetwork, self).__init__(**kwargs)
self.vdc_name = self.params.get('vdc_name')
self.org_name = self.params.get('org_name')
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):
state = self.params.get('state')
if state == "present":
return self.create_org_vdc_network()
if state == "absent":
return self.delete_org_vdc_network()
def create_org_vdc_network(self):
direct = self.params.get('direct')
isolated = self.params.get('isolated')
routed = self.params.get('routed')
if direct:
return self.create_org_vdc_direct_network()
elif isolated:
return self.create_org_vdc_isolated_network()
elif routed:
return self.create_org_vdc_routed_network()
raise ValueError("Bool 'direct', 'isolated' or 'routed' is missing")
def create_org_vdc_direct_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
parent_network_name = self.params.get('parent_network_name')
description = self.params.get('description')
shared = self.params.get('shared')
try:
self.vdc.get_direct_orgvdc_network(network_name)
except EntityNotFoundException:
create_task = self.vdc.create_directly_connected_vdc_network(
network_name,
parent_network_name,
description=description,
is_shared=shared)
self.execute_task(create_task.Tasks.Task[0])
msg = 'Org VDC Direct Network {0} has been created'
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = 'Org VDC Direct Network {0} is already present'
response['warnings'] = msg.format(network_name)
return response
def create_org_vdc_isolated_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
network_cidr = self.params.get('network_cidr')
description = self.params.get('description')
shared = self.params.get('shared')
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')
ip_range_start = self.params.get('ip_range_start')
ip_range_end = self.params.get('ip_range_end')
dhcp_enabled = self.params.get('dhcp_enabled')
default_lease_time = self.params.get('default_lease_time')
max_lease_time = self.params.get('max_lease_time')
dhcp_ip_range_start = self.params.get('dhcp_ip_range_start')
dhcp_ip_range_end = self.params.get('dhcp_ip_range_end')
try:
self.vdc.get_isolated_orgvdc_network(network_name)
except EntityNotFoundException:
create_task = self.vdc.create_isolated_vdc_network(
network_name,
network_cidr,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_dhcp_enabled=dhcp_enabled,
default_lease_time=default_lease_time,
max_lease_time=max_lease_time,
dhcp_ip_range_start=dhcp_ip_range_start,
dhcp_ip_range_end=dhcp_ip_range_end,
is_shared=shared)
self.execute_task(create_task.Tasks.Task[0])
msg = 'Org VDC Isolated Network {0} has been created'
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = 'Org VDC Isolated Network {0} is already present'
response['warnings'] = msg.format(network_name)
return response
def create_org_vdc_routed_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
gateway_name = self.params.get('gateway_name')
network_cidr = self.params.get('network_cidr')
description = self.params.get('description')
shared = self.params.get('shared')
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')
ip_range_start = self.params.get('ip_range_start')
ip_range_end = self.params.get('ip_range_end')
guest_vx_vlan_allowed = self.params.get('guest_vx_vlan_allowed')
sub_interface = self.params.get('sub_interface')
distributed_interface = self.params.get('distributed_interface')
retain_net_info_across_deployments = self.params.get(
'retain_net_info_across_deployments')
try:
self.vdc.get_routed_orgvdc_network(network_name)
except EntityNotFoundException:
create_task = self.vdc.create_routed_vdc_network(
network_name,
gateway_name,
network_cidr,
description=description,
primary_dns_ip=primary_dns_ip,
secondary_dns_ip=secondary_dns_ip,
dns_suffix=dns_suffix,
ip_range_start=ip_range_start,
ip_range_end=ip_range_end,
is_shared=shared,
guest_vx_vlan_allowed=guest_vx_vlan_allowed,
sub_interface=sub_interface,
distributed_interface=distributed_interface,
retain_net_info_across_deployments=
retain_net_info_across_deployments)
self.execute_task(create_task.Tasks.Task[0])
msg = 'Org VDC Routed Network {0} has been created'
response['msg'] = msg.format(network_name)
response['changed'] = True
else:
msg = 'Org VDC Routed Network {0} is already present'
response['warnings'] = msg.format(network_name)
return response
def delete_org_vdc_network(self):
response = dict()
response['changed'] = False
direct = self.params.get('direct')
isolated = self.params.get('isolated')
routed = self.params.get('routed')
if direct:
return self.delete_org_vdc_direct_network()
if isolated:
return self.delete_org_vdc_isolated_network()
if routed:
return self.delete_org_vdc_routed_network()
raise ValueError("Bool 'direct', 'isolated' or 'routed' is missing")
def delete_org_vdc_direct_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
force = self.params.get('force')
try:
self.vdc.get_direct_orgvdc_network(network_name)
except EntityNotFoundException:
msg = "Org VDC Direct Network {0} is not present"
response['warnings'] = msg.format(network_name)
else:
delete_task = self.vdc.delete_direct_orgvdc_network(network_name,
force=force)
self.execute_task(delete_task)
msg = 'Org VDC Direct Network {} has been deleted'
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def delete_org_vdc_isolated_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
force = self.params.get('force')
try:
self.vdc.get_isolated_orgvdc_network(network_name)
except EntityNotFoundException:
msg = "Org VDC Direct Network {0} is not present"
response['warnings'] = msg.format(network_name)
else:
delete_task = self.vdc.delete_isolated_orgvdc_network(network_name,
force=force)
self.execute_task(delete_task)
msg = 'Org VDC Direct Network {} has been deleted'
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
def delete_org_vdc_routed_network(self):
response = dict()
response['changed'] = False
network_name = self.params.get('network_name')
force = self.params.get('force')
try:
self.vdc.get_routed_orgvdc_network(network_name)
except EntityNotFoundException:
msg = "Org VDC Direct Network {0} is not present"
response['warnings'] = msg.format(network_name)
else:
delete_task = self.vdc.delete_routed_orgvdc_network(network_name,
force=force)
self.execute_task(delete_task)
msg = 'Org VDC Direct Network {} has been deleted'
response['msg'] = msg.format(network_name)
response['changed'] = True
return response
class VdcNet(VcdAnsibleModule):
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 manage_states(self):
state = self.params.get('state')
if state == "present":
if self.direct:
return self.create_direct_network()
elif self.isolated:
return self.create_isolated_network()
elif self.routed:
return self.create_routed_network()
else:
raise Exception("Bool 'direct', 'isolated' or 'routed' is missing")
if state == "absent":
return self.delete_network()
def create_direct_network(self):
response = dict()
try:
self.vdc.get_direct_orgvdc_network(self.network_name)
except EntityNotFoundException:
create = self.vdc.create_directly_connected_vdc_network(
self.network_name,
self.parent_network_name,
description=self.description,
is_shared=self.shared)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Network {0} created'.format(self.network_name)
response['changed'] = True
else:
response['warnings'] = 'Network {0} is already present.'.format(
self.network_name)
return response
def create_isolated_network(self):
response = dict()
try:
self.vdc.get_isolated_orgvdc_network(self.network_name)
except EntityNotFoundException:
create = self.vdc.create_isolated_vdc_network(
self.network_name,
self.network_cidr,
description=self.description,
primary_dns_ip=self.primary_dns_ip,
secondary_dns_ip=self.secondary_dns_ip,
dns_suffix=self.dns_suffix,
ip_range_start=self.ip_range_start,
ip_range_end=self.ip_range_end,
is_dhcp_enabled=self.dhcp_enabled,
default_lease_time=self.default_lease_time,
max_lease_time=self.max_lease_time,
dhcp_ip_range_start=self.dhcp_ip_range_start,
dhcp_ip_range_end=self.dhcp_ip_range_end,
is_shared=self.shared)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Network {0} created'.format(self.network_name)
response['changed'] = True
else:
response['warnings'] = 'Network {0} is already present.'.format(
self.network_name)
return response
def create_routed_network(self):
response = dict()
try:
self.vdc.get_routed_orgvdc_network(self.network_name)
except EntityNotFoundException:
create = self.vdc.create_routed_vdc_network(
self.network_name,
self.gateway_name,
self.network_cidr,
description=self.description,
primary_dns_ip=self.primary_dns_ip,
secondary_dns_ip=self.secondary_dns_ip,
dns_suffix=self.dns_suffix,
ip_range_start=self.ip_range_start,
ip_range_end=self.ip_range_end,
is_shared=self.shared,
guest_vlan_allowed=self.guest_vlan_allowed,
sub_interface=self.sub_interface,
distributed_interface=self.distributed_interface,
retain_net_info_across_deployments=self.retain_net_info_across_deployments)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Network {0} created'.format(self.network_name)
response['changed'] = True
else:
response['warnings'] = 'Network {0} is already present.'.format(
self.network_name)
return response
def delete_network(self):
response = dict()
try:
if self.direct:
self.vdc.get_direct_orgvdc_network(self.network_name)
elif self.isolated:
self.vdc.get_isolated_orgvdc_network(self.network_name)
elif self.routed:
self.vdc.get_routed_orgvdc_network(self.network_name)
except EntityNotFoundException:
response['warnings'] = 'Network {} is not present.'.format(
self.network_name)
else:
if self.direct:
delete = self.vdc.delete_direct_orgvdc_network(
self.network_name,
force=self.force)
elif self.isolated:
delete = self.vdc.delete_isolated_orgvdc_network(
self.network_name,
force=self.force)
elif self.routed:
delete = self.vdc.delete_routed_orgvdc_network(
self.network_name,
force=self.force)
self.execute_task(delete)
response['msg'] = 'Network {} has been deleted.'.format(
self.network_name)
response['changed'] = True
return response
# Check for desired networks and create them if they don't exist.
# (We might add other kinds of networks later.)
if cfg.networks.get("isolated"):
print("Checking isolated networks...")
for network in cfg.networks['isolated']:
isolated_network_list = vdc.list_orgvdc_network_resources(
name=network['network_name'], type=FenceMode.ISOLATED.value)
if len(isolated_network_list) > 0:
print("Isolated network exists: {0}".format(
network['network_name']))
else:
# Create the network in the vDC.
print("Network does not exist, creating: {0}".format(
network['network_name']))
network_resource = vdc.create_isolated_vdc_network(**network)
handle_task(client, network_resource.Tasks.Task[0])
print("Network created")
# Ensure the network is visible in the VDC.
network_exists = False
while not network_exists:
new_network_list = vdc.list_orgvdc_network_resources(
name=network['network_name'],
type=FenceMode.ISOLATED.value)
if len(new_network_list) > 0:
print("Isolated network is visible in VDC: {0}".format(
network['network_name']))
network_exists = True
else:
print("Isolated network is not visible yet: {0}".format(
print("VDC already exists: {0}".format(cfg.org.vdc_name))
except Exception:
print("VDC {0} does not exist, exiting".format(cfg.org['vdc_name']))
sys.exit()
# Ensure Isolated Org Network doesn't exist.
print("Fetching Network...")
try:
network_resource = vdc.get_isolated_orgvdc_network(
cfg.org.org_isol_nw.name)
print("Network already exists: {0}".format(cfg.org.org_isol_nw.name))
except Exception:
print("Network {0} does not exist, creating".format(
cfg.org.org_isol_nw.name))
network_resource = vdc.create_isolated_vdc_network(
network_name=cfg.org.org_isol_nw.name,
network_cidr=cfg.org.org_isol_nw.cidr,
is_dhcp_enabled=False,
is_shared=cfg.org.org_isol_nw.is_shared)
handle_task(client, network_resource.Tasks.Task[0])
# Final report ------------------------------------------------------------------------------------
new_isolated_network = vdc.get_isolated_orgvdc_network(
cfg.org.org_isol_nw.name)
print(
'\nNew Isolated network is created -------------------------------------------------'
)
print('name: {}'.format(new_isolated_network.attrib['name']))
print('href: {}'.format(new_isolated_network.attrib['href']))
vdc = VDC(client, resource=vdc_resource)
print("VDC already exists: {0}".format(cfg.org.vdc_name))
except Exception:
print("VDC {0} does not exist, exiting".format(cfg.org['vdc_name']))
sys.exit()
# Ensure Isolated Org Network doesn't exist.
print("Fetching Network...")
try:
network_resource = vdc.get_isolated_orgvdc_network(cfg.org.org_isol_nw.name)
print("Network already exists: {0}".format(cfg.org.org_isol_nw.name))
except Exception:
print("Network {0} does not exist, creating".format(cfg.org.org_isol_nw.name))
network_resource = vdc.create_isolated_vdc_network(network_name=cfg.org.org_isol_nw.name,
gateway_ip=cfg.org.org_isol_nw.gateway,
netmask=cfg.org.org_isol_nw.netmask,
ip_range_start=cfg.org.org_isol_nw.ip_range_start,
ip_range_end=cfg.org.org_isol_nw.ip_range_end,
is_dhcp_enabled=cfg.org.org_isol_nw.is_dhcp_enabled,
is_shared=cfg.org.org_isol_nw.is_shared)
handle_task(client, network_resource.Tasks.Task[0])
# Final report ------------------------------------------------------------------------------------
new_isolated_network = vdc.get_isolated_orgvdc_network(cfg.org.org_isol_nw.name)
print('\nNew Isolated network is created -------------------------------------------------')
print('name: {}'.format(new_isolated_network.attrib['name']))
print('href: {}'.format(new_isolated_network.attrib['href']))
