ansible/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2024-09-14 20:13:21 +02:00
Code Releases Activity

small fixes and additions to bigip_virtual_address (#40362)

Browse source 
* Updated parameter names to match updated features in BIGIP
* Added support for route domains
This commit is contained in:
Tim Rupp 2018-05-17 20:45:53 -07:00 committed by GitHub
parent 9eb2a6b41b
commit f87cda8a54
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2 changed files with 186 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

222
lib/ansible/modules/network/f5/bigip_virtual_address.py
View file

@ -90,7 +90,7 @@ options:
- absent
- enabled
- disabled
advertise_route:
availability_calculation:
description:
- Specifies what routes of the virtual address the system advertises.
When C(when_any_available), advertises the route when any virtual
@ -101,12 +101,46 @@ options:
- always
- when_all_available
- when_any_available
aliases: ['advertise_route']
version_added: 2.6
use_route_advertisement:
description:
- Specifies whether the system uses route advertisement for this
virtual address. When disabled, the system does not advertise
routes for this virtual address.
virtual address.
- When disabled, the system does not advertise routes for this virtual address.
- Deprecated. Use the C(route_advertisement) parameter instead.
type: bool
route_advertisement:
description:
- Specifies whether the system uses route advertisement for this
virtual address.
- When disabled, the system does not advertise routes for this virtual address.
- The majority of these options are only supported on versions 13.0.0-HF1 or
higher. On versions less than this, all choices expect C(disabled) will
translate to C(enabled).
- When C(always), the BIG-IP system will always advertise the route for the
virtual address, regardless of availability status. This requires an C(enabled)
virtual address.
- When C(enabled), the BIG-IP system will advertise the route for the available
virtual address, based on the calculation method in the availability calculation.
- When C(disabled), the BIG-IP system will not advertise the route for the virtual
address, regardless of the availability status.
- When C(selective), you can also selectively enable ICMP echo responses, which
causes the BIG-IP system to internally enable or disable responses based on
virtual server state. Either C(any) virtual server, C(all) virtual servers, or
C(always), regardless of the state of any virtual server.
- When C(any), the BIG-IP system will advertise the route for the virtual address
when any virtual server is available.
- When C(all), the BIG-IP system will advertise the route for the virtual address
when all virtual servers are available.
choices:
- disabled
- enabled
- always
- selective
- any
- all
version_added: 2.6
partition:
description:
- Device partition to manage resources on.
@ -118,6 +152,11 @@ options:
if this value is not specified, the default of C(/Common/traffic-group-1)
will be used.
version_added: 2.5
route_domain:
description:
- The route domain of the C(address) that you want to use.
- This value cannot be modified after it is set.
version_added: 2.6
notes:
- Requires the netaddr Python package on the host. This is as easy as pip
install netaddr.
@ -197,6 +236,7 @@ from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.basic import env_fallback
from ansible.module_utils.parsing.convert_bool import BOOLEANS_TRUE
from ansible.module_utils.parsing.convert_bool import BOOLEANS_FALSE
from distutils.version import LooseVersion
try:
from library.module_utils.network.f5.bigip import HAS_F5SDK
@ -232,24 +272,24 @@ except ImportError:
class Parameters(AnsibleF5Parameters):
api_map = {
'routeAdvertisement': 'use_route_advertisement',
'routeAdvertisement': 'route_advertisement_type',
'autoDelete': 'auto_delete',
'icmpEcho': 'icmp_echo',
'connectionLimit': 'connection_limit',
'serverScope': 'advertise_route',
'serverScope': 'availability_calculation',
'mask': 'netmask',
'arp': 'arp_state',
'trafficGroup': 'traffic_group',
}
updatables = [
'use_route_advertisement', 'auto_delete', 'icmp_echo', 'connection_limit',
'arp_state', 'enabled', 'advertise_route', 'traffic_group', 'address'
'route_advertisement_type', 'auto_delete', 'icmp_echo', 'connection_limit',
'arp_state', 'enabled', 'availability_calculation', 'traffic_group'
]
returnables = [
'use_route_advertisement', 'auto_delete', 'icmp_echo', 'connection_limit',
'netmask', 'arp_state', 'address', 'state', 'traffic_group'
'route_advertisement_type', 'auto_delete', 'icmp_echo', 'connection_limit',
'netmask', 'arp_state', 'address', 'state', 'traffic_group', 'route_domain'
]
api_attributes = [
@ -258,14 +298,14 @@ class Parameters(AnsibleF5Parameters):
]
@property
def advertise_route(self):
if self._values['advertise_route'] is None:
def availability_calculation(self):
if self._values['availability_calculation'] is None:
return None
elif self._values['advertise_route'] in ['any', 'when_any_available']:
elif self._values['availability_calculation'] in ['any', 'when_any_available']:
return 'any'
elif self._values['advertise_route'] in ['all', 'when_all_available']:
elif self._values['availability_calculation'] in ['all', 'when_all_available']:
return 'all'
elif self._values['advertise_route'] in ['none', 'always']:
elif self._values['availability_calculation'] in ['none', 'always']:
return 'none'
@property
@ -274,17 +314,6 @@ class Parameters(AnsibleF5Parameters):
return None
return int(self._values['connection_limit'])
@property
def use_route_advertisement(self):
if self._values['use_route_advertisement'] is None:
return None
elif self._values['use_route_advertisement'] in BOOLEANS_TRUE:
return 'enabled'
elif self._values['use_route_advertisement'] == 'enabled':
return 'enabled'
else:
return 'disabled'
@property
def enabled(self):
if self._values['state'] in ['enabled', 'present']:
@ -298,18 +327,6 @@ class Parameters(AnsibleF5Parameters):
else:
return None
@property
def address(self):
if self._values['address'] is None:
return None
try:
ip = netaddr.IPAddress(self._values['address'])
return str(ip)
except netaddr.core.AddrFormatError:
raise F5ModuleError(
"The provided 'address' is not a valid IP address"
)
@property
def netmask(self):
if self._values['netmask'] is None:
@ -355,6 +372,39 @@ class Parameters(AnsibleF5Parameters):
"Traffic groups can only exist in /Common"
)
@property
def route_advertisement_type(self):
if self.use_route_advertisement:
return self.use_route_advertisement
elif self.route_advertisement:
return self.route_advertisement
else:
return self._values['route_advertisement_type']
@property
def use_route_advertisement(self):
if self._values['use_route_advertisement'] is None:
return None
if self._values['use_route_advertisement'] in BOOLEANS_TRUE:
return 'enabled'
elif self._values['use_route_advertisement'] == 'enabled':
return 'enabled'
else:
return 'disabled'
@property
def route_advertisement(self):
if self._values['route_advertisement'] is None:
return None
version = self.client.api.tmos_version
if LooseVersion(version) <= LooseVersion('13.0.0'):
if self._values['route_advertisement'] == 'disabled':
return 'disabled'
else:
return 'enabled'
else:
return self._values['route_advertisement']
def to_return(self):
result = {}
for returnable in self.returnables:
@ -368,11 +418,51 @@ class ApiParameters(Parameters):
class ModuleParameters(Parameters):
@property
def address(self):
if self._values['address'] is None:
return None
try:
ip = netaddr.IPAddress(self._values['address'])
return str(ip)
except netaddr.core.AddrFormatError:
raise F5ModuleError(
"The provided 'address' is not a valid IP address"
)
@property
def route_domain(self):
if self._values['route_domain'] is None:
return None
try:
return int(self._values['route_domain'])
except ValueError:
try:
rd = self.client.api.tm.net.route_domains.route_domain.load(
name=self._values['route_domain'],
partition=self.partition
)
return int(rd.id)
except iControlUnexpectedHTTPError:
raise F5ModuleError(
"The specified 'route_domain' was not found."
)
@property
def full_address(self):
if self.route_domain is not None:
return '{0}%{1}'.format(self.address, self.route_domain)
return self.address
@property
def name(self):
if self._values['name'] is None:
return str(self.address)
return self._values['name']
result = str(self.address)
if self.route_domain:
result = "{0}%{1}".format(result, self.route_domain)
else:
result = self._values['name']
return result
class Changes(Parameters):
@ -380,7 +470,14 @@ class Changes(Parameters):
class UsableChanges(Changes):
pass
@property
def address(self):
if self._values['address'] is None:
return None
if self._values['route_domain'] is None:
return self._values['address']
result = "{0}%{1}".format(self._values['address'], self._values['route_domain'])
return result
class ReportableChanges(Changes):
@ -485,16 +582,23 @@ class ModuleManager(object):
return changed
def read_current_from_device(self):
name = self.want.name
name = name.replace('%', '%25')
resource = self.client.api.tm.ltm.virtual_address_s.virtual_address.load(
name=self.want.name,
name=name,
partition=self.want.partition
)
result = resource.attrs
return ApiParameters(params=result)
def exists(self):
# This addresses cases where the name includes a % sign. The URL in the REST
# API escapes a % sign as %25. If you don't do this, you will get errors in
# the exists() method.
name = self.want.name
name = name.replace('%', '%25')
result = self.client.api.tm.ltm.virtual_address_s.virtual_address.exists(
name=self.want.name,
name=name,
partition=self.want.partition
)
return result
@ -508,7 +612,7 @@ class ModuleManager(object):
"the virtual address if you need to do this."
)
if self.want.address is not None:
if self.have.address != self.want.address:
if self.have.address != self.want.full_address:
raise F5ModuleError(
"The address cannot be changed. Delete and recreate "
"the virtual address if you need to do this."
@ -522,8 +626,10 @@ class ModuleManager(object):
def update_on_device(self):
params = self.changes.api_params()
name = self.want.name
name = name.replace('%', '%25')
resource = self.client.api.tm.ltm.virtual_address_s.virtual_address.load(
name=self.want.name,
name=name,
partition=self.want.partition
)
resource.modify(**params)
@ -545,7 +651,7 @@ class ModuleManager(object):
self.client.api.tm.ltm.virtual_address_s.virtual_address.create(
name=self.want.name,
partition=self.want.partition,
address=self.want.address,
address=self.changes.address,
**params
)
@ -558,8 +664,10 @@ class ModuleManager(object):
return True
def remove_from_device(self):
name = self.want.name
name = name.replace('%', '%25')
resource = self.client.api.tm.ltm.virtual_address_s.virtual_address.load(
name=self.want.name,
name=name,
partition=self.want.partition
)
resource.delete()
@ -591,17 +699,30 @@ class ArgumentSpec(object):
icmp_echo=dict(
choices=['enabled', 'disabled', 'selective'],
),
advertise_route=dict(
availability_calculation=dict(
choices=['always', 'when_all_available', 'when_any_available'],
aliases=['advertise_route']
),
use_route_advertisement=dict(
type='bool'
type='bool',
removed_in_version=2.9,
),
route_advertisement=dict(
choices=[
'disabled',
'enabled',
'always',
'selective',
'any',
'all',
]
),
traffic_group=dict(),
partition=dict(
default='Common',
fallback=(env_fallback, ['F5_PARTITION'])
)
),
route_domain=dict()
)
self.argument_spec = {}
self.argument_spec.update(f5_argument_spec)
@ -609,6 +730,9 @@ class ArgumentSpec(object):
self.required_one_of = [
['name', 'address']
]
self.mutually_exclusive = [
['use_route_advertisement', 'route_advertisement']
]
def main():

24
test/units/modules/network/f5/test_bigip_virtual_address.py
View file

@ -21,6 +21,7 @@ from ansible.module_utils.basic import AnsibleModule
try:
from library.modules.bigip_virtual_address import Parameters
from library.modules.bigip_virtual_address import ModuleParameters
from library.modules.bigip_virtual_address import ModuleManager
from library.modules.bigip_virtual_address import ArgumentSpec
from library.module_utils.network.f5.common import F5ModuleError
@ -29,6 +30,7 @@ try:
except ImportError:
try:
from ansible.modules.network.f5.bigip_virtual_address import Parameters
from ansible.modules.network.f5.bigip_virtual_address import ModuleParameters
from ansible.modules.network.f5.bigip_virtual_address import ModuleManager
from ansible.modules.network.f5.bigip_virtual_address import ArgumentSpec
from ansible.module_utils.network.f5.common import F5ModuleError
@ -69,10 +71,10 @@ class TestParameters(unittest.TestCase):
arp_state='enabled',
auto_delete='enabled',
icmp_echo='enabled',
advertise_route='always',
availability_calculation='always',
use_route_advertisement='yes'
)
p = Parameters(params=args)
p = ModuleParameters(params=args)
assert p.state == 'present'
assert p.address == '1.1.1.1'
assert p.netmask == '2.2.2.2'
@ -80,8 +82,8 @@ class TestParameters(unittest.TestCase):
assert p.arp_state == 'enabled'
assert p.auto_delete is True
assert p.icmp_echo == 'enabled'
assert p.advertise_route == 'none'
assert p.use_route_advertisement == 'enabled'
assert p.availability_calculation == 'none'
assert p.route_advertisement_type == 'enabled'
def test_api_parameters(self):
args = load_fixture('load_ltm_virtual_address_default.json')
@ -94,22 +96,22 @@ class TestParameters(unittest.TestCase):
assert p.state == 'enabled'
assert p.icmp_echo == 'enabled'
assert p.netmask == '255.255.255.255'
assert p.use_route_advertisement == 'disabled'
assert p.advertise_route == 'any'
assert p.route_advertisement_type == 'disabled'
assert p.availability_calculation == 'any'
def test_module_parameters_advertise_route_all(self):
args = dict(
advertise_route='when_all_available'
availability_calculation='when_all_available'
)
p = Parameters(params=args)
assert p.advertise_route == 'all'
assert p.availability_calculation == 'all'
def test_module_parameters_advertise_route_any(self):
args = dict(
advertise_route='when_any_available'
availability_calculation='when_any_available'
)
p = Parameters(params=args)
assert p.advertise_route == 'any'
assert p.availability_calculation == 'any'
def test_module_parameters_icmp_echo_disabled(self):
args = dict(
@ -143,7 +145,7 @@ class TestParameters(unittest.TestCase):
args = dict(
use_route_advertisement='no'
)
p = Parameters(params=args)
p = ModuleParameters(params=args)
assert p.use_route_advertisement == 'disabled'
def test_module_parameters_state_present(self):