def __create_advanced_gateway(self):
"""Creates a gateway."""
ext_config = TestIpSecVpn._config['external_network']
vdc_reource = TestIpSecVpn._vdc_resource
api_version = TestIpSecVpn._config['vcd']['api_version']
vdc = VDC(TestIpSecVpn._client, resource=vdc_reource)
gateway = vdc.get_gateway(TestIpSecVpn._gateway_name)
if self.__does_exist_gateway(TestIpSecVpn._gateway_name):
return
if float(api_version) <= float(
ApiVersion.VERSION_30.value):
gateway = vdc.create_gateway_api_version_30(
TestIpSecVpn._gateway_name, [ext_config['name']])
elif float(api_version) == float(ApiVersion.VERSION_31.value):
gateway = vdc.create_gateway_api_version_31(
TestIpSecVpn._gateway_name,
[ext_config['name']],
should_create_as_advanced=True)
elif float(api_version) >= float(ApiVersion.VERSION_32.value):
gateway = vdc.create_gateway_api_version_32(
TestIpSecVpn._gateway_name, [ext_config['name']],
should_create_as_advanced=True)
TestIpSecVpn._client.get_task_monitor(). \
wait_for_success(task=gateway.Tasks.Task[0])
TestIpSecVpn._gateway_href = gateway.get('href')
TestIpSecVpn._gateway_obj = Gateway(TestIpSecVpn._client,
href=TestIpSecVpn._gateway_href)
TestIpSecVpn._gateway_resource = TestIpSecVpn. \
_gateway_obj.get_resource()
def __create_advanced_gateway(self):
"""Creates a gateway."""
ext_config = TestIpSecVpn._config['external_network']
vdc_reource = TestIpSecVpn._vdc_resource
api_version = TestIpSecVpn._config['vcd']['api_version']
vdc = VDC(TestIpSecVpn._client, resource=vdc_reource)
gateway = vdc.get_gateway(TestIpSecVpn._gateway_name)
if self.__does_exist_gateway(TestIpSecVpn._gateway_name):
return
if float(api_version) <= float(
ApiVersion.VERSION_30.value):
gateway = vdc.create_gateway_api_version_30(
TestIpSecVpn._gateway_name, [ext_config['name']])
elif float(api_version) == float(ApiVersion.VERSION_31.value):
gateway = vdc.create_gateway_api_version_31(
TestIpSecVpn._gateway_name,
[ext_config['name']],
should_create_as_advanced=True)
elif float(api_version) >= float(ApiVersion.VERSION_32.value):
gateway = vdc.create_gateway_api_version_32(
TestIpSecVpn._gateway_name, [ext_config['name']],
should_create_as_advanced=True)
TestIpSecVpn._client.get_task_monitor(). \
wait_for_success(task=gateway.Tasks.Task[0])
TestIpSecVpn._gateway_href = gateway.get('href')
TestIpSecVpn._gateway_obj = Gateway(TestIpSecVpn._client,
href=TestIpSecVpn._gateway_href)
TestIpSecVpn._gateway_resource = TestIpSecVpn. \
_gateway_obj.get_resource()
def __does_exist_gateway(self, gateway_name):
vdc = VDC(TestIpSecVpn._client, resource=TestIpSecVpn._vdc_resource)
gateway = vdc.get_gateway(TestIpSecVpn._gateway_name)
if gateway:
TestIpSecVpn._gateway_resource = gateway
TestIpSecVpn._gateway_href = gateway.get('href')
TestIpSecVpn._gateway_obj = Gateway(
TestIpSecVpn._client, href=TestIpSecVpn._gateway_href)
return True
else:
return False
def __does_exist_gateway(self, gateway_name):
vdc = VDC(TestIpSecVpn._client, resource=TestIpSecVpn._vdc_resource)
gateway = vdc.get_gateway(TestIpSecVpn._gateway_name)
if gateway:
TestIpSecVpn._gateway_resource = gateway
TestIpSecVpn._gateway_href = gateway.get('href')
TestIpSecVpn._gateway_obj = Gateway(
TestIpSecVpn._client, href=TestIpSecVpn._gateway_href)
return True
else:
return False
def get_gateway(ctx, name):
"""Get the sdk's gateway resource.
It will restore sessions if expired. It will read the client and vdc
from context and make get_gateway call to VDC for gateway object.
"""
restore_session(ctx, vdc_required=True)
client = ctx.obj['client']
vdc_href = ctx.obj['profiles'].get('vdc_href')
vdc = VDC(client, href=vdc_href)
gateway = vdc.get_gateway(name)
gateway_resource = Gateway(client, href=gateway.get('href'))
return gateway_resource
def enable_distributed_routing(ctx, name, is_enabled=False):
"""Enable Distributed routing for gateway.
\b
Examples
vcd gateway enable-distributed-routing <gateway-name>
--enable/--disable
Enable/Disable Distributed routing for gateway.
"""
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)
gateway = vdc.get_gateway(name)
gateway_resource = Gateway(client, href=gateway.get('href'))
task = gateway_resource.enable_distributed_routing(is_enabled)
stdout(task, ctx)
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 convert_to_advanced_gateway(ctx, name):
"""Convert to advanced gateway.
\b
Note
System Administrators and Organization Administrator can
convert legacy gateway to advanced.
\b
Examples
vcd gateway convert-to-advanced <gateway-name>
Convert gateway to advanced by providing gateway 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)
gateway = vdc.get_gateway(name)
gateway_resource = Gateway(client, href=gateway.get('href'))
task = gateway_resource.convert_to_advanced()
stdout(task, ctx)
except Exception as e:
stderr(e, ctx)
class EdgeServices(VcdAnsibleModule):
def __init__(self, **kwargs):
super(EdgeServices, self).__init__(**kwargs)
self.org = self.get_org()
vdc = self.org.get_vdc(self.params.get('vdc'))
self.vdc = VDC(self.client, href=vdc.get('href'))
def manage_states(self):
state = self.params.get("state")
if state == "present":
return self.add_service()
if state == "update":
return self.update_service()
if state == "absent":
return self.delete_service()
def manage_operations(self):
operation = self.params.get("operation")
return self.apply_operation_on_service(operation)
def get_org(self):
org_name = self.params.get('org_name')
org_resource = self.client.get_org()
if org_name:
org_resource = self.client.get_org_by_name(org_name)
return Org(self.client, resource=org_resource)
def get_gateway(self):
gateway_name = self.params.get("gateway")
gateway = self.vdc.get_gateway(gateway_name)
if gateway is None:
msg = "Gateway {0} not found".format(gateway_name)
raise EntityNotFoundException(msg)
extra_args = {"name": gateway_name, "href": gateway.get("href")}
return Gateway(self.client, **extra_args)
def add_service(self):
service = self.params.get("service")
service_params = self.params.get("service_params")
if service == "firewall":
service = FirewallService(self.get_gateway(), service_params)
if service == "nat_rule":
service = NatRuleService(self.get_gateway(), service_params)
if service == "static_route":
service = StaticRoutes(self.get_gateway(), service_params)
if service == "ssl_certificates":
service = SSLCertificates(self.get_gateway(), service_params)
return service.manage_states(state="present")
def delete_service(self):
service = self.params.get("service")
service_params = self.params.get("service_params")
if service == "firewall":
service = FirewallService(self.get_gateway(), service_params)
if service == "nat_rule":
service = NatRuleService(self.get_gateway(), service_params)
if service == "static_route":
service = StaticRoutes(self.get_gateway(), service_params)
if service == "ssl_certificates":
service = SSLCertificates(self.get_gateway(), service_params)
return service.manage_states(state="absent")
def update_service(self):
service = self.params.get("service")
service_params = self.params.get("service_params")
if service == "firewall":
service = FirewallService(self.get_gateway(), service_params)
if service == "nat_rule":
service = NatRuleService(self.get_gateway(), service_params)
if service == "static_route":
service = StaticRoutes(self.get_gateway(), service_params)
return service.manage_states(state="update")
def apply_operation_on_service(self, operation):
service = self.params.get("service")
if service == "firewall":
service = FirewallService(self.get_gateway())
if service == "nat_rule":
service = NatRuleService(self.get_gateway())
if service == "static_route":
service = StaticRoutes(self.get_gateway())
if service == "ssl_certificates":
service = SSLCertificates(self.get_gateway())
return service.manage_operations(operation=operation)
class VdcGW(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VdcGW, 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_gw()
if state == "update":
return self.update_gw()
if state == "absent":
return self.delete_gw()
def get_gateway(self, gateway_name):
gateway = self.vdc.get_gateway(gateway_name)
if gateway is None:
raise EntityNotFoundException(
"Edge gateway {0} is not present".format(gateway_name))
return gateway
def create_gw(self):
api_version = self.client.get_api_version()
if api_version == "30.0":
return self.create_gateway_api_version_30()
if api_version == "31.0":
return self.create_gateway_api_version_31()
if api_version == "32.0":
return self.create_gateway_api_version_32()
def create_gateway_api_version_30(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_30(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def create_gateway_api_version_31(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
flips_mode = self.params.get('flips_mode')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_31(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit,
is_flips_mode_enabled=flips_mode)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def create_gateway_api_version_32(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
edge_gateway_type = self.params.get('edge_gateway_type')
flips_mode = self.params.get('flips_mode')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_32(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit,
is_flips_mode_enabled=flips_mode,
edgeGatewayType=edge_gateway_type)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def update_gw(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
new_gateway_name = self.params.get('new_gateway_name')
description = self.params.get('description')
ha_enabled = self.params.get('ha_enabled')
edge_gateway_href = None
try:
gateway = self.get_gateway(gateway_name)
for key, value in gateway.items():
if key == "href":
edge_gateway_href = value
break
gateway = Gateway(
self.client, name=gateway_name, href=edge_gateway_href)
update_task = gateway.edit_gateway(newname=new_gateway_name,
desc=description, ha=ha_enabled)
self.execute_task(update_task)
msg = "Edge Gateway {0} has been updated with {1}"
response['msg'] = msg.format(gateway_name, new_gateway_name)
response['changed'] = True
except EntityNotFoundException:
msg = 'Edge Gateway {0} is not present'
response['warnings'] = msg.format(gateway_name)
return response
def delete_gw(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
msg = "Edge Gateway {0} is not present"
response['warnings'] = msg.format(gateway_name)
else:
delete_task = self.vdc.delete_gateway(gateway_name)
self.execute_task(delete_task)
msg = "Edge Gateway {0} has been deleted"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
return response
class VdcGW(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VdcGW, self).__init__(**kwargs)
self.vdc_name = self.params.get('vdc_name')
self.gateway_name = self.params.get('gateway_name')
self.description = self.params.get('description')
self.external_networks = self.params.get('external_networks')
self.gateway_backing_config = self.params.get('gateway_backing_config')
self.default_gateway = self.params.get('default_gateway')
self.extnw_for_default_gw = self.params.get('extnw_for_default_gw')
self.default_gateway_ip = self.params.get('default_gateway_ip')
self.default_gw_for_dns_relay = self.params.get(
'default_gw_for_dns_relay')
self.ha_enabled = self.params.get('ha_enabled')
self.create_as_advanced_gw = self.params.get('create_as_advanced_gw')
self.dr_enabled = self.params.get('dr_enabled')
self.configure_ip_settings = self.params.get('configure_ip_settings')
self.ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
self.sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
self.ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
self.ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
self.flips_mode = self.params.get('flips_mode')
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_gw()
if state == "absent":
return self.delete_gw()
def create_gw(self):
response = dict()
try:
self.vdc.get_gateway(self.gateway_name)
except EntityNotFoundException:
create = self.vdc.create_gateway(
name=self.gateway_name,
external_networks=self.external_networks,
gateway_backing_config=self.gateway_backing_config,
desc=self.description,
is_default_gateway=self.default_gateway,
selected_extnw_for_default_gw=self.extnw_for_default_gw,
default_gateway_ip=self.default_gateway_ip,
is_default_gw_for_dns_relay_selected=self.
default_gw_for_dns_relay,
is_ha_enabled=self.ha_enabled,
should_create_as_advanced=self.create_as_advanced_gw,
is_dr_enabled=self.dr_enabled,
is_ip_settings_configured=self.configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=self.
ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=self.sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=self.
ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=self.ext_net_to_rate_limit,
is_flips_mode_enabled=self.flips_mode)
self.execute_task(create.Tasks.Task[0])
response['msg'] = 'Edge Gateway {0} created'.format(
self.gateway_name)
response['changed'] = True
else:
response[
'warnings'] = 'Edge Gateway {0} is already present.'.format(
self.gateway_name)
return response
def delete_gw(self):
response = dict()
try:
self.vdc.get_gateway(self.gateway_name)
except EntityNotFoundException:
response['warnings'] = 'Edge Gateway {0} is not present.'.format(
self.gateway_name)
else:
delete = self.vdc.delete_gateway(self.gateway_name)
self.execute_task(delete)
response['changed'] = True
return response
class VdcGW(VcdAnsibleModule):
def __init__(self, **kwargs):
super(VdcGW, 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_gw()
if state == "update":
return self.update_gw()
if state == "absent":
return self.delete_gw()
def manage_operations(self):
operation = self.params.get('operation')
if operation == "update_ip_pool":
return self.update_sub_allocated_ip_pools()
if operation == "add_network":
return self.add_network()
if operation == "remove_network":
return self.remove_network()
def get_gateway(self, gateway_name):
gateway = self.vdc.get_gateway(gateway_name)
if gateway is not None:
for key, value in gateway.items():
if key == "href":
return Gateway(self.client, name=gateway_name, href=value)
msg = "Edge gateway {0} is not present"
raise EntityNotFoundException(msg.format(gateway_name))
def create_gw(self):
api_version = self.client.get_api_version()
if api_version == "30.0":
return self.create_gateway_api_version_30()
if api_version == "31.0":
return self.create_gateway_api_version_31()
if api_version == "32.0":
return self.create_gateway_api_version_32()
def create_gateway_api_version_30(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_30(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def create_gateway_api_version_31(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
flips_mode = self.params.get('flips_mode')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_31(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit,
is_flips_mode_enabled=flips_mode)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def create_gateway_api_version_32(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
description = self.params.get('description')
external_networks = self.params.get('external_networks')
gateway_backing_config = self.params.get('gateway_backing_config')
default_gateway = self.params.get('default_gateway')
extnw_for_default_gw = self.params.get('extnw_for_default_gw')
default_gateway_ip = self.params.get('default_gateway_ip')
default_gw_for_dns_relay = self.params.get('default_gw_for_dns_relay')
ha_enabled = self.params.get('ha_enabled')
create_as_advanced_gw = self.params.get('create_as_advanced_gw')
dr_enabled = self.params.get('dr_enabled')
configure_ip_settings = self.params.get('configure_ip_settings')
sub_allocate_ip_pools = self.params.get('sub_allocate_ip_pools')
ext_net_to_rate_limit = self.params.get('ext_net_to_rate_limit')
edge_gateway_type = self.params.get('edge_gateway_type')
flips_mode = self.params.get('flips_mode')
ext_net_to_subnet_with_ip_range = self.params.get(
'ext_net_to_subnet_with_ip_range')
ext_net_to_participated_subnet_with_ip_settings = self.params.get(
'ext_net_to_participated_subnet_with_ip_settings')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException:
create_task = self.vdc.create_gateway_api_version_32(
name=gateway_name,
external_networks=external_networks,
gateway_backing_config=gateway_backing_config,
desc=description,
is_default_gateway=default_gateway,
selected_extnw_for_default_gw=extnw_for_default_gw,
default_gateway_ip=default_gateway_ip,
is_default_gw_for_dns_relay_selected=default_gw_for_dns_relay,
is_ha_enabled=ha_enabled,
should_create_as_advanced=create_as_advanced_gw,
is_dr_enabled=dr_enabled,
is_ip_settings_configured=configure_ip_settings,
ext_net_to_participated_subnet_with_ip_settings=ext_net_to_participated_subnet_with_ip_settings,
is_sub_allocate_ip_pools_enabled=sub_allocate_ip_pools,
ext_net_to_subnet_with_ip_range=ext_net_to_subnet_with_ip_range,
ext_net_to_rate_limit=ext_net_to_rate_limit,
is_flips_mode_enabled=flips_mode,
edgeGatewayType=edge_gateway_type)
self.execute_task(create_task.Tasks.Task[0])
msg = "Edge Gateway {0} has been created"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
else:
msg = "Edge Gateway {0} is already present"
response['warnings'] = msg.format(gateway_name)
return response
def update_gw(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
new_gateway_name = self.params.get('new_gateway_name')
description = self.params.get('description')
ha_enabled = self.params.get('ha_enabled')
try:
gateway = self.get_gateway(gateway_name)
except EntityNotFoundException as ex:
response['warnings'] = ex
else:
update_task = gateway.edit_gateway(
newname=new_gateway_name, desc=description, ha=ha_enabled)
self.execute_task(update_task)
msg = "Edge Gateway {0} has been updated with {1}"
response['msg'] = msg.format(gateway_name, new_gateway_name)
response['changed'] = True
return response
def delete_gw(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
try:
self.get_gateway(gateway_name)
except EntityNotFoundException as ex:
response['warnings'] = ex
else:
delete_task = self.vdc.delete_gateway(gateway_name)
self.execute_task(delete_task)
msg = "Edge Gateway {0} has been deleted"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
return response
def _get_subnet_participation(self, gw_resource, network):
for gateway_inf in \
gw_resource.Configuration.GatewayInterfaces.GatewayInterface:
if gateway_inf.Name == network:
return gateway_inf.SubnetParticipation
return None
def update_sub_allocated_ip_pools(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
try:
gateway = self.get_gateway(gateway_name)
except EntityNotFoundException as ex:
response['warnings'] = ex
else:
ip_pool = self.params.get('ext_net_subnet_allocated_ip_pool')
for network, new_ip_range in ip_pool.items():
subnet_participation = self._get_subnet_participation(gateway.get_resource(), network)
if subnet_participation is None:
msg = "No subnet ip pools are attached with network {0}"
raise Exception(msg.format(network))
ip_ranges = gateway.get_sub_allocate_ip_ranges_element(subnet_participation)
old_ip_range = "{0}-{1}".format(ip_ranges.IpRange.StartAddress, ip_ranges.IpRange.EndAddress)
update_task = gateway.edit_sub_allocated_ip_pools(network, old_ip_range, new_ip_range)
self.execute_task(update_task)
msg = "Ip Pools have been updated on edge gatway {0}"
response['msg'] = msg.format(gateway_name)
response['changed'] = True
return response
def add_network(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
try:
gateway = self.get_gateway(gateway_name)
except EntityNotFoundException as ex:
response['warnings'] = ex
else:
network_settings = self.params.get('ext_net_to_participated_subnet_with_ip_settings')
networks_to_attach = network_settings.keys()
attached_networks = gateway.list_external_network_ip_allocations().keys()
networks = list()
for network in networks_to_attach:
if network not in attached_networks:
networks.append(network)
for ip_settings in network_settings.values():
for subnet, ip in ip_settings.items():
add_network_task = gateway.add_external_network(network, [(subnet, ip)])
self.execute_task(add_network_task)
if len(networks) == 0:
networks = list(networks_to_attach)
msg = "Networks {0} are already attached to edge gatway {1}"
else:
msg = "Networks {0} are added to edge gatway {1}"
response['msg'] = msg.format(networks, gateway_name)
response['changed'] = True
return response
def remove_network(self):
response = dict()
response['changed'] = False
gateway_name = self.params.get('gateway_name')
try:
gateway = self.get_gateway(gateway_name)
except EntityNotFoundException as ex:
response['warnings'] = ex
else:
external_networks = self.params.get('external_networks')
for network in external_networks:
remove_network_task = gateway.remove_external_network(network)
self.execute_task(remove_network_task)
msg = "Networks {0} have been removed from edge gatway {1}"
response['msg'] = msg.format(external_networks, gateway_name)
response['changed'] = True
return response
sys.exit()
# Ensure VDC exists.
print("Fetching VDC...")
try:
vdc_resource = org.get_vdc(cfg.org.vdc_name)
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 the edge doesn't exist.
print("Fetching Edges...")
try:
edge_resource = vdc.get_gateway(cfg.org.edge_gateway.name)
print("Edge gateway already exists: {0}".format(cfg.org.edge_gateway.name))
except Exception:
print("Edge gateway {0} does not exist, exiting".format(
cfg.org.edge_gateway.name))
sys.exit()
# Ensure Routed Org Network doesn't exist.
print("Fetching Network...")
try:
network_resource = vdc.get_routed_orgvdc_network(
cfg.org.org_routed_nw.name)
print("Network already exists: {0}".format(cfg.org.org_routed_nw.name))
except Exception:
print("Network {0} does not exist, creating".format(
cfg.org.org_routed_nw.name))
sys.exit()
# Ensure VDC exists. ------------------------------------------------------------------------------
print("\nFetching VDC...")
try:
vdc_resource = org.get_vdc(cfg.org.vdc_name)
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 the edge doesn't exist. ------------------------------------------------------------------
print("\nFetching Edges...")
try:
network_resource = vdc.get_gateway(cfg.org.edge_gateway.name)
print("Edge gateway already exists: {0}".format(cfg.org.edge_gateway.name))
except Exception:
print("Edge gateway {0} does not exist, creating".format(
cfg.org.edge_gateway.name))
network_resource = vdc.create_gateway(
cfg.org.edge_gateway.name,
external_networks=[cfg.system.ext_network.name, cfg.org.mng_nw],
gateway_backing_config=GatewayBackingConfigType.XLARGE.value,
is_default_gateway=True,
selected_extnw_for_default_gw=cfg.system.ext_network.name,
default_gateway_ip=cfg.system.ext_network.gateway,
is_ha_enabled=True,
should_create_as_advanced=True,
is_dr_enabled=True)
