def create_lb_backend_address_pool(resource_group_name, load_balancer_name,
item_name):
ncf = _network_client_factory()
lb = ncf.load_balancers.get(resource_group_name, load_balancer_name)
lb.backend_address_pools.append(BackendAddressPool(name=item_name))
return ncf.load_balancers.create_or_update(resource_group_name,
load_balancer_name, lb)
def add_nic_ip_config_address_pool(resource_group_name,
network_interface_name,
ip_config_name,
backend_address_pool,
load_balancer_name=None): # pylint: disable=unused-argument
client = _network_client_factory().network_interfaces
nic = client.get(resource_group_name, network_interface_name)
ip_config = next((x for x in nic.ip_configurations
if x.name.lower() == ip_config_name.lower()), None)
try:
ip_config.load_balancer_backend_address_pools.append(
BackendAddressPool(backend_address_pool))
except AttributeError:
ip_config.load_balancer_backend_address_pools = [
BackendAddressPool(backend_address_pool)
]
return client.create_or_update(resource_group_name, network_interface_name,
nic)
def get_load_balancer_backend_pool(self, load_balancer,
load_balancer_backend_pool):
self.log("Fetching load balancer names {0}-{1}".format(
load_balancer, load_balancer_backend_pool))
lb_pool_id = ''
try:
lb_pool_id = self.network_client.load_balancer_backend_address_pools.get(
self.resource_group, load_balancer,
load_balancer_backend_pool).id
lbpool = BackendAddressPool(id=lb_pool_id)
except Exception as exc:
self.fail(
"Error: creating load balancer backend {0} - {1}.".format(
lb_pool_id, str(exc)))
return lbpool
def exec_module(self, **kwargs):
"""Main module execution method"""
for key in self.module_args.keys():
setattr(self, key, kwargs[key])
results = dict()
changed = False
pip = None
load_balancer_props = dict()
try:
resource_group = self.get_resource_group(self.resource_group)
except CloudError:
self.fail('resource group {} not found'.format(
self.resource_group))
if not self.location:
self.location = resource_group.location
load_balancer_props['location'] = self.location
if self.state == 'present':
# handle present status
frontend_ip_config_name = random_name('feipconfig')
frontend_ip_config_id = frontend_ip_configuration_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=frontend_ip_config_name)
if self.public_ip_address_name:
pip = self.get_public_ip_address(self.public_ip_address_name)
load_balancer_props['frontend_ip_configurations'] = [
FrontendIPConfiguration(name=frontend_ip_config_name,
public_ip_address=pip)
]
elif self.state == 'absent':
try:
self.network_client.load_balancers.delete(
resource_group_name=self.resource_group,
load_balancer_name=self.name).wait()
changed = True
except CloudError:
changed = False
self.results['changed'] = changed
return self.results
try:
# before we do anything, we need to attempt to retrieve the load balancer
# knowing whether or not it exists will tell us what to do in the future
self.log('Fetching load balancer {}'.format(self.name))
load_balancer = self.network_client.load_balancers.get(
self.resource_group, self.name)
self.log('Load balancer {} exists'.format(self.name))
self.check_provisioning_state(load_balancer, self.state)
results = load_balancer_to_dict(load_balancer)
self.log(results, pretty_print=True)
if self.state == 'present':
update_tags, results['tags'] = self.update_tags(
results['tags'])
if update_tags:
changed = True
except CloudError:
self.log('Load balancer {} does not exist'.format(self.name))
if self.state == 'present':
self.log(
'CHANGED: load balancer {} does not exist but requested status \'present\''
.format(self.name))
changed = True
backend_address_pool_name = random_name('beap')
backend_addr_pool_id = backend_address_pool_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=backend_address_pool_name)
load_balancer_props['backend_address_pools'] = [
BackendAddressPool(name=backend_address_pool_name)
]
probe_name = random_name('probe')
prb_id = probe_id(subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=probe_name)
if self.probe_protocol:
load_balancer_props['probes'] = [
Probe(name=probe_name,
protocol=self.probe_protocol,
port=self.probe_port,
interval_in_seconds=self.probe_interval,
number_of_probes=self.probe_fail_count,
request_path=self.probe_request_path)
]
load_balancing_rule_name = random_name('lbr')
if self.protocol:
load_balancer_props['load_balancing_rules'] = [
LoadBalancingRule(
name=load_balancing_rule_name,
frontend_ip_configuration=SubResource(
id=frontend_ip_config_id),
backend_address_pool=SubResource(id=backend_addr_pool_id),
probe=SubResource(id=prb_id),
protocol=self.protocol,
load_distribution=self.load_distribution,
frontend_port=self.frontend_port,
backend_port=self.backend_port,
idle_timeout_in_minutes=self.idle_timeout,
enable_floating_ip=False)
]
inbound_nat_pool_name = random_name('inp')
if frontend_ip_config_id and self.natpool_protocol:
load_balancer_props['inbound_nat_pools'] = [
InboundNatPool(
name=inbound_nat_pool_name,
frontend_ip_configuration=Subnet(id=frontend_ip_config_id),
protocol=self.natpool_protocol,
frontend_port_range_start=self.natpool_frontend_port_start,
frontend_port_range_end=self.natpool_frontend_port_end,
backend_port=self.natpool_backend_port)
]
self.results['changed'] = changed
self.results['state'] = (results if results else load_balancer_to_dict(
LoadBalancer(**load_balancer_props)))
if self.check_mode:
return self.results
try:
self.network_client.load_balancers.create_or_update(
resource_group_name=self.resource_group,
load_balancer_name=self.name,
parameters=LoadBalancer(**load_balancer_props)).wait()
except CloudError as err:
self.fail('Error creating load balancer {}'.format(err))
return self.results
def exec_module(self, **kwargs):
"""Main module execution method"""
for key in list(self.module_args.keys()) + ['tags']:
setattr(self, key, kwargs[key])
if self.state == 'absent':
try:
self.network_client.load_balancers.delete(
resource_group_name=self.resource_group,
load_balancer_name=self.name).wait()
changed = True
except CloudError:
changed = False
self.results['changed'] = changed
return self.results
# From now on, suppose state==present
# INPUT CHECK TO BE COMPLETED!!!
results = dict()
changed = False
pip = None
subnet = None
load_balancer_props = dict()
try:
resource_group = self.get_resource_group(self.resource_group)
except CloudError:
self.fail('resource group {0} not found'.format(
self.resource_group))
if not self.location:
self.location = resource_group.location
load_balancer_props['location'] = self.location
# CHECK INPUT AND SET DEFAULT VALUE:
self.frontnamelist = []
for front in self.frontend_ip_configs:
if not front.get('name') or front['name'] in self.frontnamelist:
self.fail(
'name is not provided correctly in one of frontend_ip_configs.'
)
self.frontnamelist.append(front['name'])
if not front.get('public_ip_name') and not (
front.get('subnet_name') and front.get('vnet_name')):
self.fail(
'frontend_ip_configs error: neither public_ip_name nor the combination of subnet_name and vnet_name is provided.'
)
if not front.get('resource_group'):
front['resource_group'] = self.resource_group
self.probenamelist = []
for probe in self.health_probes:
if not probe.get('name') or probe['name'] in self.probenamelist:
self.fail(
'name is not provided correctly in one of health_probes.')
self.probenamelist.append(probe['name'])
if not probe.get('fail_count'):
probe['fail_count'] = 3
if not probe.get('interval'):
probe['interval'] = 15
if not probe.get('port'):
probe['port'] = 80
if not probe.get('protocol'):
probe['protocol'] = 'Tcp'
if not probe.get('request_path'):
probe['request_path'] = '/'
self.rulenamelist = []
for rule in self.load_balancing_rules:
if not rule.get('name') or rule['name'] in self.rulenamelist:
self.fail(
'name is not provided in one of load_balancing_rules.')
self.rulenamelist.append(rule['name'])
if not rule.get('frontend_name') or rule[
'frontend_name'] not in self.frontnamelist:
self.fail(
'frontend_name is not provied correctly in one of load_balancing_rules.'
)
if not rule.get('backend_name') or rule[
'backend_name'] not in self.backend_pools:
self.fail(
'backend_name is not provied correctly in one of load_balancing_rules.'
)
if not rule.get('probe_name'
) or rule['probe_name'] not in self.probenamelist:
self.fail(
'probe_name is not provied correctly in one of load_balancing_rules.'
)
if not rule.get('load_distribution'):
rule['load_distribution'] = 'Default'
if not rule.get('frontend_port'):
rule['frontend_port'] = 80
if not rule.get('backend_port'):
rule['backend_port'] = rule['frontend_port']
if not rule.get('protocol'):
rule['protocol'] = 'Tcp'
if rule.get('enable_floating_ip') in [
'True', 'true', 'Yes', 'yes'
]:
rule['enable_floating_ip'] = True
else:
rule['enable_floating_ip'] = False
if not rule.get('idle_timeout'):
rule['idle_timeout'] = 15
self.natnamelist = []
for nat in self.inbound_nat_rules:
if not nat.get('name') or nat['name'] in self.natnamelist:
self.fail('name is not provided in one of inbound_nat_rules.')
self.natnamelist.append(nat['name'])
if not nat.get('frontend_name'
) or nat['frontend_name'] not in self.frontnamelist:
self.fail(
'frontend_name is not provided correctly in one of inbound_nat_rules.'
)
if not nat.get('frontend_port'):
self.fail(
'frontend_port is not provided in one of inbound_nat_rules.'
)
if not nat.get('backend_port'):
self.fail(
'backend_port is not provided in one of inbound_nat_rules.'
)
if not nat.get('protocol'):
nat['protocol'] = 'Tcp'
if nat.get('enable_floating_ip') in ['True', 'true', 'Yes', 'yes']:
nat['enable_floating_ip'] = True
else:
nat['enable_floating_ip'] = False
if not nat.get('idle_timeout'):
nat['idle_timeout'] = 4
# handle present status
try:
# before we do anything, we need to attempt to retrieve the load balancer and compare with current parameters
self.log('Fetching load balancer {0}'.format(self.name))
load_balancer = self.network_client.load_balancers.get(
self.resource_group, self.name)
self.log('Load balancer {0} exists'.format(self.name))
self.check_provisioning_state(load_balancer, self.state)
results = load_balancer_to_dict(load_balancer)
self.log(results, pretty_print=True)
update_tags, load_balancer_props['tags'] = self.update_tags(
results['tags'])
if update_tags:
changed = True
# Check difference with current status
# Check frontend ip configurations: subnet_id, name, public_ip_address, private_ip_address, private_ip_allocation_method.
param_fronts = list_to_dict(self.frontend_ip_configs, 'name')
results_fronts = list_to_dict(
results['frontend_ip_configurations'], 'name')
for front in param_fronts.keys():
results_fronts[front].update(
azureid_to_dict(results_fronts[front]['subnet']['id']))
if param_fronts[front].get('public_ip_name') and param_fronts[
front]['public_ip_name'] != results_fronts[front][
'public_ip_address']:
raise DiffErr(
'Load balancer {0} frontend {1} parameter public_ip_name differs: {2} vs {3}'
.format(self.name, front,
param_fronts[front]['public_ip_name'],
results_fronts[front]['public_ip_address']))
if param_fronts[front].get('private_ip_address'):
if param_fronts[front]['private_ip_address'] != results_fronts[front]['private_ip_address'] or \
results_fronts[front]['private_ip_allocation_method'] != 'Static':
raise DiffErr(
'Load balancer {0} frontend {1} parameter private_ip_address differs: {2} vs {3}'
.format(
self.name, front,
param_fronts[front]['private_ip_address'],
results_fronts[front]['private_ip_address']))
else:
if results_fronts[front][
'private_ip_allocation_method'] != 'Dynamic':
raise DiffErr(
'Load balancer {0} frontend {1} differs. None private ip means dynamic!'
.format(self.name, front))
if param_fronts[front].get(
'subnet_name') and param_fronts[front][
'subnet_name'] != results_fronts[front]['subnets']:
raise DiffErr(
'Load balancer {0} frontend {1} parameter subnet_name differs: {2} vs {3}'
.format(self.name, front,
param_fronts[front]['subnet_name'],
results_fronts[front]['subnets']))
if param_fronts[front].get('vnet_name') and param_fronts[
front]['vnet_name'] != results_fronts[front][
'virtualNetworks']:
raise DiffErr(
'Load balancer {0} frontend {1} parameter vnet_name differs: {2} vs {3}'
.format(self.name, front,
param_fronts[front]['vnet_name'],
results_fronts[front]['virtualNetworks']))
if param_fronts[front].get('resource_group') and param_fronts[
front]['resource_group'] != results_fronts[front][
'resourceGroups']:
raise DiffErr(
'Load balancer {0} frontend {1} parameter resource_group differs: {2} vs {3}'
.format(self.name, front,
param_fronts[front]['resource_group'],
results_fronts[front]['resourceGroups']))
# Check backend address pool configuration: name only, which will be used by NIC module
if self.backend_pools:
results_backs = list_to_dict(results['backend_address_pools'],
'name').keys()
results_backs.sort()
self.backend_pools.sort()
if results_backs[0] != self.backend_pools[0]:
raise DiffErr(
'Load balancer {0} backend name list differs!'.format(
self.name))
# Check probe configurations: port, protocol, interval, number of probes, request_path, name
param_probes = list_to_dict(self.health_probes, 'name')
results_probes = list_to_dict(results['probes'], 'name')
for probe in param_probes.keys():
if param_probes[probe].get('port') and param_probes[probe][
'port'] != results_probes[probe]['port']:
raise DiffErr(
'Load balancer {0} probe {1} parameter port differs: {2} vs {3}'
.format(self.name, probe, param_probes[probe]['port'],
results_probes[probe]['port']))
if param_probes[probe].get('protocol') and param_probes[probe][
'protocol'] != results_probes[probe]['protocol']:
raise DiffErr(
'Load balancer {0} probe {1} parameter protocal differs: {2} vs {3}'
.format(self.name, probe,
param_probes[probe]['protocol'],
results_probes[probe]['protocol']))
if param_probes[probe].get('interval') and param_probes[probe][
'interval'] != results_probes[probe][
'interval_in_seconds']:
raise DiffErr(
'Load balancer {0} probe {1} parameter interval differs: {2} vs {3}'
.format(self.name, probe,
param_probes[probe]['interval'],
results_probes[probe]['interval_in_seconds']))
if param_probes[probe].get('fail_count') and param_probes[
probe]['fail_count'] != results_probes[probe][
'number_of_probes']:
raise DiffErr(
'Load balancer {0} probe {1} fail_count differs: {2} vs {3}'
.format(self.name, probe,
param_probes[probe]['fail_count'],
results_probes[probe]['number_of_probes']))
if param_probes[probe].get('protocol') == 'Http' and param_probes[probe].get('request_path') and \
param_probes[probe]['request_path'] != results_probes[probe]['request_path']:
raise DiffErr(
'Load balancer {0} probe {1} requst_path differs: {2} vs {3}'
.format(self.name, probe,
param_probes[probe]['request_path'],
results_probes['request_path']))
# Check load balancing rule configurations: protocol, distribution, frontend port, backend port, idle, name
param_rules = list_to_dict(self.load_balancing_rules, 'name')
results_rules = list_to_dict(results['load_balancing_rules'],
'name')
for rule in param_rules.keys():
results_rules[rule].update(
azureid_to_dict(
results_rules[rule]['frontend_ip_configuration_id']))
results_rules[rule].update(
azureid_to_dict(results_rules[rule]['probe_id']))
results_rules[rule].update(
azureid_to_dict(
results_rules[rule]['backend_address_pool_id']))
if param_rules[rule].get('frontend_name') and param_rules[
rule]['frontend_name'] != results_rules[rule][
'frontendIPConfigurations']:
raise DiffErr(
'Load balancer {0} rule {1} frontend_name differs: {2} vs {3}!'
.format(
self.name, rule,
param_rules[rule]['frontend_name'],
results_rules[rule]['frontendIPConfigurations']))
if param_rules[rule].get('backend_name') and param_rules[rule][
'backend_name'] != results_rules[rule][
'backendAddressPools']:
raise DiffErr(
'Load balancer {0} rule {1} backend_name differs: {2} vs {3}!'
.format(self.name, rule,
param_rules[rule]['backend_name'],
results_rules[rule]['backendAddressPools']))
if param_rules[rule].get('probe_name') and param_rules[rule][
'probe_name'] != results_rules[rule]['probes']:
raise DiffErr(
'Load balancer {0} rule {1} probe_name differs: {2} vs {3}!'
.format(self.name, rule,
param_rules[rule]['probe_name'],
results_rules[rule]['probes']))
if param_rules[rule].get('protocol') and param_rules[rule][
'protocol'] != results_rules[rule]['protocol']:
raise DiffErr(
'Load balancer {0} rule {1} protocol differs: {2} vs {3}!'
.format(self.name, rule, param_rules[rule]['protocol'],
results_rules[rule]['protocol']))
if param_rules[rule].get('load_distribution') and param_rules[
rule]['load_distribution'] != results_rules[rule][
'load_distribution']:
raise DiffErr(
'Load balancer {0} rule {1} load_distribution differs: {2} vs {3}!'
.format(self.name, rule,
param_rules[rule]['load_distribution'],
results_rules[rule]['load_distribution']))
if param_rules[rule].get('frontend_port') and param_rules[
rule]['frontend_port'] != results_rules[rule][
'frontend_port']:
raise DiffErr(
'Load balancer {0} rule {1} frontend_port differs: {2} vs {3}!'
.format(self.name, rule,
param_rules[rule]['frontend_port'],
results_rules[rule]['frontend_port']))
if param_rules[rule].get('backend_port') and param_rules[rule][
'backend_port'] != results_rules[rule]['backend_port']:
raise DiffErr(
'Load balancer {0} rule {1} backend_port differs: {2} vs {3}!'
.format(self.name, rule,
param_rules[rule]['backend_port'],
results_rules[rule]['backend_port']))
if param_rules[rule].get('idle_timeout') and param_rules[rule][
'idle_timeout'] != results_rules[rule][
'idle_timeout_in_minutes']:
raise DiffErr(
'Load balancer {0} rule {1} idle_timeout differs: {2} vs {3}!'
.format(
self.name, rule, param_rules[rule]['idle_timeout'],
results_rules[rule]['idle_timeout_in_minutes']))
if param_rules[rule].get('enable_floating_ip') and param_rules[
rule]['enable_floating_ip'] != results_rules[rule][
'enable_floating_ip']:
raise DiffErr(
'Load balancer {0} rule {1} enable_floating_ip differs: {2} vs {3}!'
.format(self.name, rule,
param_rules[rule]['enable_floating_ip'],
results_rules[rule]['enable_floating_ip']))
# Check inbound nat rule:
param_nats = list_to_dict(self.inbound_nat_rules, 'name')
results_nats = list_to_dict(results['inbound_nat_rules'], 'name')
for nat in param_nats:
results_nats[nat].update(
azureid_to_dict(
results_nats[nat]['frontend_ip_configuration_id']))
if param_nats[nat].get('protocol') and param_nats[nat][
'protocol'] != results_nats[nat]['protocol']:
raise DiffErr(
'Load balancer {0} NAT {1} protocol differs: {2} vs {3}!'
.format(self.name, nat, param_nats[nat]['protocol'],
results_nats[nat]['protocol']))
if param_nats[nat].get('frontend_port') and param_nats[nat][
'frontend_port'] != results_nats[nat]['frontend_port']:
raise DiffErr(
'Load balancer {0} NAT {1} frontend_port differs: {2} vs {3}!'
.format(self.name, nat,
param_nats[nat]['frontend_port'],
results_nats[nat]['frontend_port']))
if param_nats[nat].get('backend_port') and param_nats[nat][
'backend_port'] != results_nats[nat]['backend_port']:
raise DiffErr(
'Load balancer {0} NAT {1} backend_port differs: {2} vs {3}!'
.format(self.name, nat,
param_nats[nat]['backend_port'],
results_nats[nat]['backend_port']))
if param_nats[nat].get('frontend_name') and param_nats[nat][
'frontend_name'] != results_nats[nat][
'frontendIPConfigurations']:
raise DiffErr(
'Load balancer {0} NAT {1} frontend_name differs: {2} vs {3}!'
.format(self.name, nat,
param_nats[nat]['frontend_name'],
results_nats[nat]['frontendIPConfigurations']))
if param_nats[nat].get('idle_timeout') and param_nats[nat][
'idle_timeout'] != results_nats[nat][
'idle_timeout_in_minutes']:
raise DiffErr(
'Load balancer {0} NAT {1} idle_timeout differs: {2} vs {3}!'
.format(self.name, nat,
param_nats[nat]['idle_timeout'],
results_nats[nat]['idle_timeout_in_minutes']))
# DUE TO SDK LIBRARY ERROR, enable_floating_ip is not checked.
# if param_nats[nat].get('enable_floating_ip') and param_nats[nat]['enable_floating_ip'] != results_nats[nat]['enable_floating_point_ip']:
# raise DiffErr('Load balancer {0} NAT {1} enable_floating_ip differs: {2} vs {3}!'.format(
# self.name, nat, param_nats[nat]['enable_floating_ip'], results_nats[nat]['enable_floating_point_ip']))
except (IndexError, KeyError, DiffErr) as e:
self.log('CHANGED: {0}'.format(e))
changed = True
except CloudError:
self.log(
'CHANGED: load balancer {0} does not exist but requested status \'present\''
.format(self.name))
changed = True
if not changed or self.check_mode:
self.results['changed'] = changed
self.results['state'] = results
return self.results
# From now changed==True
if self.tags:
load_balancer_props['tags'] = self.tags
if self.frontend_ip_configs:
load_balancer_props['frontend_ip_configurations'] = []
for front in self.frontend_ip_configs:
if front.get('public_ip_name'):
pip = self.get_public_ip_address(front['public_ip_name'])
load_balancer_props['frontend_ip_configurations'].append(
FrontendIPConfiguration(name=front['name'],
public_ip_address=pip))
elif front.get('vnet_name') and front.get('subnet_name'):
if front.get('private_ip_address'):
load_balancer_props[
'frontend_ip_configurations'].append(
FrontendIPConfiguration(
name=front['name'],
private_ip_address=front[
'private_ip_address'],
private_ip_allocation_method='Static',
subnet=get_subnet(self,
front['resource_group'],
front['vnet_name'],
front['subnet_name'])))
else:
load_balancer_props[
'frontend_ip_configurations'].append(
FrontendIPConfiguration(
name=front['name'],
private_ip_allocation_method='Dynamic',
subnet=get_subnet(self,
front['resource_group'],
front['vnet_name'],
front['subnet_name'])))
if self.backend_pools:
load_balancer_props['backend_address_pools'] = []
for backend in self.backend_pools:
load_balancer_props['backend_address_pools'].append(
BackendAddressPool(name=backend))
if self.health_probes:
load_balancer_props['probes'] = []
for probe in self.health_probes:
if probe['protocol'] == 'Http':
load_balancer_props['probes'].append(
Probe(name=probe['name'],
protocol=probe['protocol'],
port=probe['port'],
interval_in_seconds=probe['interval'],
number_of_probes=probe['fail_count'],
request_path=probe['request_path']))
else:
load_balancer_props['probes'].append(
Probe(name=probe['name'],
protocol=probe['protocol'],
port=probe['port'],
interval_in_seconds=probe['interval'],
number_of_probes=probe['fail_count']))
if self.load_balancing_rules:
load_balancer_props['load_balancing_rules'] = []
for rule in self.load_balancing_rules:
frontend_ip_config_id = frontend_ip_configuration_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=rule['frontend_name'])
backend_addr_pool_id = backend_address_pool_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=rule['backend_name'])
prb_id = probe_id(subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=rule['probe_name'])
load_balancer_props['load_balancing_rules'].append(
LoadBalancingRule(
name=rule['name'],
frontend_ip_configuration=SubResource(
id=frontend_ip_config_id),
backend_address_pool=SubResource(
id=backend_addr_pool_id),
probe=SubResource(id=prb_id),
protocol=rule['protocol'],
load_distribution=rule['load_distribution'],
frontend_port=rule['frontend_port'],
backend_port=rule['backend_port'],
idle_timeout_in_minutes=rule['idle_timeout'],
enable_floating_ip=rule['enable_floating_ip']))
if self.inbound_nat_rules:
load_balancer_props['inbound_nat_rules'] = []
for nat in self.inbound_nat_rules:
frontend_ip_config_id = frontend_ip_configuration_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=nat['frontend_name'])
load_balancer_props['inbound_nat_rules'].append(
InboundNatRule(
name=nat['name'],
frontend_ip_configuration=SubResource(
id=frontend_ip_config_id),
frontend_port=nat['frontend_port'],
backend_port=nat['backend_port'],
protocol=nat['protocol'],
enable_floating_ip=nat['enable_floating_ip'],
idle_timeout_in_minutes=nat['idle_timeout']))
self.results['changed'] = changed
self.results['state'] = load_balancer_to_dict(
LoadBalancer(**load_balancer_props))
try:
self.network_client.load_balancers.create_or_update(
resource_group_name=self.resource_group,
load_balancer_name=self.name,
parameters=LoadBalancer(**load_balancer_props)).wait()
except CloudError as err:
self.fail('Error creating load balancer {0}'.format(err))
return self.results
def exec_module(self, **kwargs):
"""Main module execution method"""
for key in list(self.module_args.keys()) + ['tags']:
setattr(self, key, kwargs[key])
if self.state == 'absent':
try:
self.network_client.load_balancers.delete(resource_group_name=self.resource_group, load_balancer_name=self.name).wait()
changed = True
except CloudError:
changed = False
self.results['changed'] = changed
return self.results
# From now on, suppose state==present
if bool(self.subnet_name) != bool(self.virtual_network_name):
self.fail('subnet_name and virtual_network_name must come together. The current values are {0} and {1}'.format(
self.subnet_name, self.virtual_network_name))
if not self.subnet_resource_group:
self.subnet_resource_group = self.resource_group
if self.protocol:
if not self.frontend_port:
self.fail('frontend_port is {0} but some of the following are missing: frontend_port, backend_port'.format(self.protocol))
if not self.backend_port:
self.backend_port = self.frontend_port
if self.nat_protocol:
if not self.nat_frontend_port:
self.fail("nat_protocol is {0} but some of the following are missing: nat_frontend_port, nat_backend_port".format(self.nat_protocol))
if not self.nat_backend_port:
self.nat_backend_port = self.nat_frontend_port
if not self.public_ip_address_name and (not self.subnet_name or not self.virtual_network_name):
self.fail('subnet_name and virtual_network_name must be given when using priviate ip frontend!')
if not self.public_ip_address_name and not self.private_ip_address and self.private_ip_allocation_method == 'Static':
self.fail('private_ip_allocation_method must be Dynamic when neither public_ip_address_name nor private_ip_address is given!')
results = dict()
changed = False
pip = None
subnet = None
load_balancer_props = dict()
try:
resource_group = self.get_resource_group(self.resource_group)
except CloudError:
self.fail('resource group {} not found'.format(self.resource_group))
if not self.location:
self.location = resource_group.location
load_balancer_props['location'] = self.location
if self.subnet_name and self.virtual_network_name:
subnet = get_subnet(self, self.subnet_resource_group, self.virtual_network_name, self.subnet_name)
# handle present status
try:
# before we do anything, we need to attempt to retrieve the load balancer and compare with current parameters
self.log('Fetching load balancer {}'.format(self.name))
load_balancer = self.network_client.load_balancers.get(self.resource_group, self.name)
self.log('Load balancer {} exists'.format(self.name))
self.check_provisioning_state(load_balancer, self.state)
results = load_balancer_to_dict(load_balancer)
self.log(results, pretty_print=True)
update_tags, load_balancer_props['tags'] = self.update_tags(results['tags'])
if update_tags:
changed = True
# check difference with current status
# check frontend ip configurations: subnet_id, name, public_ip_address, private_ip_address, private_ip_allocation_method.
if not results['frontend_ip_configurations']: # a frontend must be there
raise DiffErr('load balancer {0} frontend'.format(self.name))
if self.subnet_name and subnet.id != results['frontend_ip_configurations'][0]['subnet']['id']:
raise DiffErr('load balancer {0} subnet id'.format(self.name))
if self.frontend_ip_config_name and self.frontend_ip_config_name != results['frontend_ip_configurations'][0]['name']:
raise DiffErr('load balancer {0} probe request frontend_ip_config_name'.format(self.name))
if self.public_ip_address_name and self.public_ip_address_name != results['frontend_ip_configurations'][0]['public_ip_address']:
raise DiffErr('load balancer {0} public ip'.format(self.name))
if self.private_ip_address and self.private_ip_address != results['frontend_ip_configurations'][0]['private_ip_address']:
raise DiffErr('load balancer {0} private ip'.format(self.name))
if self.private_ip_allocation_method and self.private_ip_allocation_method != \
results['frontend_ip_configurations'][0]['private_ip_allocation_method']:
raise DiffErr('load balancer {0} probe request private_ip_allocation_method'.format(self.name))
# check probe configurations: port, protocol, interval, number of probes, request_path, name
if self.probe_protocol and not results['probes']:
raise DiffErr('load balancer {0} probe'.format(self.name))
if self.probe_port and self.probe_port != results['probes'][0]['port']:
raise DiffErr('load balancer {0} probe_port'.format(self.name))
if self.probe_protocol and self.probe_protocol != results['probes'][0]['protocol']:
raise DiffErr('load balancer {0} probe_protocol'.format(self.name))
if self.probe_interval and self.probe_interval != results['probes'][0]['interval_in_seconds']:
raise DiffErr('load balancer {0} probe_interval'.format(self.name))
if self.probe_fail_count and self.probe_fail_count != results['probes'][0]['number_of_probes']:
raise DiffErr('load balancer {0} probe_fail_count'.format(self.name))
if self.probe_protocol == 'Http' and self.probe_request_path and self.probe_request_path != results['probes'][0]['request_path']:
raise DiffErr('load balancer {0} probe_request_path'.format(self.name))
if self.probe_name and self.probe_name != results['probes'][0]['name']:
raise DiffErr('load balancer {0} probe request probe_name'.format(self.name))
# check load balancing rule configurations: protocol, distribution, frontend port, backend port, idle, name
if self.protocol:
if not results['load_balancing_rules']:
raise DiffErr('load balancer {0} load balancing rule'.format(self.name))
if self.protocol != results['load_balancing_rules'][0]['protocol']:
raise DiffErr('load balancer {0} probe request protocol'.format(self.name))
if self.load_distribution != results['load_balancing_rules'][0]['load_distribution']:
raise DiffErr('load balancer {0} probe request load_distribution'.format(self.name))
if self.frontend_port and self.frontend_port != results['load_balancing_rules'][0]['frontend_port']:
raise DiffErr('load balancer {0} probe request frontend_port'.format(self.name))
if self.backend_port != results['load_balancing_rules'][0]['backend_port']:
raise DiffErr('load balancer {0} probe request backend_port'.format(self.name))
if self.idle_timeout != results['load_balancing_rules'][0]['idle_timeout_in_minutes']:
raise DiffErr('load balancer {0} probe request idel_timeout'.format(self.name))
if self.load_balancing_rule_name != results['load_balancing_rules'][0]['name']:
raise DiffErr('load balancer {0} probe request load_balancing_rule_name'.format(self.name))
# check backend address pool configuration: name only, which will be used by NIC module
if self.backend_address_pool_name and not results['backend_address_pools']:
raise DiffErr('load balancer {0} backend address pool'.format(self.name))
if self.backend_address_pool_name and self.backend_address_pool_name != results['backend_address_pools'][0]['name']:
raise DiffErr('load balancer {0} probe request backend_address_pool_name'.format(self.name))
# check inbound nat rule:
if self.nat_protocol:
if not results['inbound_nat_rules']:
raise DiffErr('load balancer {0} inbound nat rule'.format(self.name))
if self.nat_protocol != results['inbound_nat_rules'][0]['protocol']:
raise DiffErr('load balancer {0} inbound nat_protocol'.format(self.name))
if self.nat_name != results['inbound_nat_rules'][0]['name']:
raise DiffErr('load balancer {0} inbound nat_name'.format(self.name))
if self.nat_frontend_port != results['inbound_nat_rules'][0]['frontend_port']:
raise DiffErr('load balancer {0} inbound nat_frontend_port'.format(self.name))
if self.nat_backend_port != results['inbound_nat_rules'][0]['backend_port']:
raise DiffErr('load balancer {0} inbound nat_backend_port'.format(self.name))
except (IndexError, KeyError, DiffErr) as e:
self.log('CHANGED: {0}'.format(e))
changed = True
except CloudError:
self.log('CHANGED: load balancer {} does not exist but requested status \'present\''.format(self.name))
changed = True
if not changed or self.check_mode:
self.results['changed'] = changed
self.results['state'] = results
return self.results
# From now changed==True
if self.tags:
load_balancer_props['tags'] = self.tags
frontend_ip_config_id = frontend_ip_configuration_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=self.frontend_ip_config_name
)
if self.public_ip_address_name:
pip = self.get_public_ip_address(self.public_ip_address_name)
load_balancer_props['frontend_ip_configurations'] = [
FrontendIPConfiguration(
name=self.frontend_ip_config_name,
public_ip_address=pip
)
]
elif self.private_ip_address or self.private_ip_allocation_method == 'Dynamic':
load_balancer_props['frontend_ip_configurations'] = [
FrontendIPConfiguration(
name=self.frontend_ip_config_name,
private_ip_address=self.private_ip_address,
private_ip_allocation_method=self.private_ip_allocation_method,
subnet=get_subnet(self, self.subnet_resource_group, self.virtual_network_name, self.subnet_name)
)
]
backend_addr_pool_id = backend_address_pool_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=self.backend_address_pool_name
)
load_balancer_props['backend_address_pools'] = [BackendAddressPool(name=self.backend_address_pool_name)]
prb_id = probe_id(
subscription_id=self.subscription_id,
resource_group_name=self.resource_group,
load_balancer_name=self.name,
name=self.probe_name
)
if self.probe_protocol:
load_balancer_props['probes'] = [
Probe(
name=self.probe_name,
protocol=self.probe_protocol,
port=self.probe_port,
interval_in_seconds=self.probe_interval,
number_of_probes=self.probe_fail_count,
request_path=self.probe_request_path
)
]
if self.protocol:
load_balancer_props['load_balancing_rules'] = [
LoadBalancingRule(
name=self.load_balancing_rule_name,
frontend_ip_configuration=SubResource(id=frontend_ip_config_id),
backend_address_pool=SubResource(id=backend_addr_pool_id),
probe=SubResource(id=prb_id),
protocol=self.protocol,
load_distribution=self.load_distribution,
frontend_port=self.frontend_port,
backend_port=self.backend_port,
idle_timeout_in_minutes=self.idle_timeout,
enable_floating_ip=False
)
]
if self.nat_protocol:
load_balancer_props['inbound_nat_rules'] = [
InboundNatRule(
name=self.nat_name,
frontend_ip_configuration=SubResource(id=frontend_ip_config_id),
frontend_port=self.nat_frontend_port,
backend_port=self.nat_backend_port,
protocol=self.nat_protocol,
enable_floating_ip=False
)
]
if frontend_ip_config_id and self.natpool_protocol:
load_balancer_props['inbound_nat_pools'] = [
InboundNatPool(
name=self.inbound_nat_pool_name,
frontend_ip_configuration=Subnet(id=frontend_ip_config_id),
protocol=self.natpool_protocol,
frontend_port_range_start=self.natpool_frontend_port_start,
frontend_port_range_end=self.natpool_frontend_port_end,
backend_port=self.natpool_backend_port
)
]
self.results['changed'] = changed
self.results['state'] = load_balancer_to_dict(LoadBalancer(**load_balancer_props))
try:
self.network_client.load_balancers.create_or_update(
resource_group_name=self.resource_group,
load_balancer_name=self.name,
parameters=LoadBalancer(**load_balancer_props)
).wait()
except CloudError as err:
self.fail('Error creating load balancer {}'.format(err))
return self.results