Adds a refactored bigip_monitor_http module. (#30998)

This patch refactors the bigip_monitor_http module to use REST
instead of SOAP. It additionally adds unit tests and current F5
code conventions.

Integration tests can be found here
* https://github.com/F5Networks/f5-ansible/blob/devel/test/integration/bigip_monitor_http.yaml
* https://github.com/F5Networks/f5-ansible/tree/devel/test/integration/targets/bigip_monitor_http/tasks
This commit is contained in:
Tim Rupp 2017-10-12 17:02:05 -07:00 committed by GitHub
commit 381b18fd80
3 changed files with 1014 additions and 352 deletions

View file

@ -2,96 +2,67 @@
# -*- coding: utf-8 -*- # -*- coding: utf-8 -*-
# #
# Copyright (c) 2017 F5 Networks Inc. # Copyright (c) 2017 F5 Networks Inc.
# Copyright (c) 2013 Matt Hite <mhite@hotmail.com>
# Copyright (c) 2013 Serge van Ginderachter <serge@vanginderachter.be>
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) # GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
ANSIBLE_METADATA = {'metadata_version': '1.1', from __future__ import absolute_import, division, print_function
'status': ['preview'], __metaclass__ = type
'supported_by': 'community'}
DOCUMENTATION = '''
ANSIBLE_METADATA = {
'status': ['preview'],
'supported_by': 'community',
'metadata_version': '1.1'
}
DOCUMENTATION = r'''
--- ---
module: bigip_monitor_http module: bigip_monitor_http
short_description: "Manages F5 BIG-IP LTM http monitors" short_description: Manages F5 BIG-IP LTM http monitors
description: description: Manages F5 BIG-IP LTM http monitors.
- Manages F5 BIG-IP LTM monitors via iControl SOAP API version_added: "2.5"
version_added: "1.4"
author:
- Serge van Ginderachter (@srvg)
- Tim Rupp (@caphrim007)
notes:
- "Requires BIG-IP software version >= 11"
- "F5 developed module 'bigsuds' required (see http://devcentral.f5.com)"
- "Best run as a local_action in your playbook"
- "Monitor API documentation: https://devcentral.f5.com/wiki/iControl.LocalLB__Monitor.ashx"
requirements:
- bigsuds
options: options:
state:
description:
- Monitor state
required: false
default: 'present'
choices:
- present
- absent
name: name:
description: description:
- Monitor name - Monitor name.
required: true required: True
default: null
aliases: aliases:
- monitor - monitor
partition:
description:
- Partition for the monitor
required: false
default: 'Common'
parent: parent:
description: description:
- The parent template of this monitor template - The parent template of this monitor template. Once this value has
required: false been set, it cannot be changed. By default, this value is the C(http)
default: 'http' parent on the C(Common) partition.
parent_partition: default: "/Common/http"
description:
- Partition for the parent monitor
required: false
default: 'Common'
send: send:
description: description:
- The send string for the monitor call - The send string for the monitor call. When creating a new monitor, if
required: true this value is not provided, the default C(GET /\r\n) will be used.
default: none
receive: receive:
description: description:
- The receive string for the monitor call - The receive string for the monitor call.
required: true
default: none
receive_disable: receive_disable:
description: description:
- The receive disable string for the monitor call - This setting works like C(receive), except that the system marks the node
required: true or pool member disabled when its response matches the C(receive_disable)
default: none string but not C(receive). To use this setting, you must specify both
C(receive_disable) and C(receive).
ip: ip:
description: description:
- IP address part of the ipport definition. The default API setting - IP address part of the IP/port definition. If this parameter is not
is "0.0.0.0". provided when creating a new monitor, then the default value will be
required: false '*'.
default: none
port: port:
description: description:
- Port address part of the ip/port definition. The default API - Port address part of the IP/port definition. If this parameter is not
setting is 0. provided when creating a new monitor, then the default value will be
required: false '*'. Note that if specifying an IP address, a value between 1 and 65535
default: none must be specified.
interval: interval:
description: description:
- The interval specifying how frequently the monitor instance - The interval specifying how frequently the monitor instance of this
of this template will run. By default, this interval is used for up and template will run. If this parameter is not provided when creating
down states. The default API setting is 5. a new monitor, then the default value will be 5. This value B(must)
required: false be less than the C(timeout) value.
default: none
timeout: timeout:
description: description:
- The number of seconds in which the node or service must respond to - The number of seconds in which the node or service must respond to
@ -99,335 +70,541 @@ options:
period, it is considered up. If the target does not respond within period, it is considered up. If the target does not respond within
the set time period, it is considered down. You can change this the set time period, it is considered down. You can change this
number to any number you want, however, it should be 3 times the number to any number you want, however, it should be 3 times the
interval number of seconds plus 1 second. The default API setting interval number of seconds plus 1 second. If this parameter is not
is 16. provided when creating a new monitor, then the default value will be 16.
required: false
default: none
time_until_up: time_until_up:
description: description:
- Specifies the amount of time in seconds after the first successful - Specifies the amount of time in seconds after the first successful
response before a node will be marked up. A value of 0 will cause a response before a node will be marked up. A value of 0 will cause a
node to be marked up immediately after a valid response is received node to be marked up immediately after a valid response is received
from the node. The default API setting is 0. from the node. If this parameter is not provided when creating
required: false a new monitor, then the default value will be 0.
default: none target_username:
description:
- Specifies the user name, if the monitored target requires authentication.
target_password:
description:
- Specifies the password, if the monitored target requires authentication.
partition:
description:
- Device partition to manage resources on.
default: Common
version_added: 2.5
notes:
- Requires the f5-sdk Python package on the host. This is as easy as pip
install f5-sdk.
- Requires BIG-IP software version >= 12
requirements:
- f5-sdk >= 2.2.3
extends_documentation_fragment: f5 extends_documentation_fragment: f5
author:
- Tim Rupp (@caphrim007)
''' '''
EXAMPLES = ''' EXAMPLES = r'''
- name: BIGIP F5 | Create HTTP Monitor - name: Create HTTP Monitor
bigip_monitor_http: bigip_monitor_http:
state: "present" state: present
server: "lb.mydomain.com" ip: 10.10.10.10
user: "admin" server: lb.mydomain.com
password: "secret" user: admin
name: "my_http_monitor" password: secret
send: "http string to send" name: my_http_monitor
receive: "http string to receive"
delegate_to: localhost delegate_to: localhost
- name: BIGIP F5 | Remove HTTP Monitor - name: Remove HTTP Monitor
bigip_monitor_http: bigip_monitor_http:
state: "absent" state: absent
server: "lb.mydomain.com" server: lb.mydomain.com
user: "admin" user: admin
password: "secret" password: secret
name: "my_http_monitor" name: my_http_monitor
delegate_to: localhost
- name: Include a username and password in the HTTP monitor
bigip_monitor_http:
state: absent
server: lb.mydomain.com
user: admin
password: secret
name: my_http_monitor
target_username: monitor_user
target_password: monitor_pass
delegate_to: localhost delegate_to: localhost
''' '''
TEMPLATE_TYPE = 'TTYPE_HTTP' RETURN = r'''
DEFAULT_PARENT_TYPE = 'http' parent:
description: New parent template of the monitor.
returned: changed
type: string
sample: http
ip:
description: The new IP of IP/port definition.
returned: changed
type: string
sample: 10.12.13.14
interval:
description: The new interval in which to run the monitor check.
returned: changed
type: int
sample: 2
timeout:
description: The new timeout in which the remote system must respond to the monitor.
returned: changed
type: int
sample: 10
time_until_up:
description: The new time in which to mark a system as up after first successful response.
returned: changed
type: int
sample: 2
'''
import os
try:
import netaddr
HAS_NETADDR = True
except ImportError:
HAS_NETADDR = False
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import AnsibleF5Parameters
from ansible.module_utils.f5_utils import HAS_F5SDK
from ansible.module_utils.f5_utils import F5ModuleError
from ansible.module_utils.six import iteritems
from collections import defaultdict
try:
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
except ImportError:
HAS_F5SDK = False
def check_monitor_exists(module, api, monitor, parent): class Parameters(AnsibleF5Parameters):
# hack to determine if monitor exists api_map = {
result = False 'timeUntilUp': 'time_until_up',
try: 'defaultsFrom': 'parent',
ttype = api.LocalLB.Monitor.get_template_type(template_names=[monitor])[0] 'recv': 'receive'
parent2 = api.LocalLB.Monitor.get_parent_template(template_names=[monitor])[0] }
if ttype == TEMPLATE_TYPE and parent == parent2:
result = True api_attributes = [
'timeUntilUp', 'defaultsFrom', 'interval', 'timeout', 'recv', 'send',
'destination', 'username', 'password'
]
returnables = [
'parent', 'send', 'receive', 'ip', 'port', 'interval', 'timeout',
'time_until_up'
]
updatables = [
'destination', 'send', 'receive', 'interval', 'timeout', 'time_until_up',
'target_username', 'target_password'
]
def __init__(self, params=None):
self._values = defaultdict(lambda: None)
self._values['__warnings'] = []
if params:
self.update(params=params)
def update(self, params=None):
if params:
for k, v in iteritems(params):
if self.api_map is not None and k in self.api_map:
map_key = self.api_map[k]
else:
map_key = k
# Handle weird API parameters like `dns.proxy.__iter__` by
# using a map provided by the module developer
class_attr = getattr(type(self), map_key, None)
if isinstance(class_attr, property):
# There is a mapped value for the api_map key
if class_attr.fset is None:
# If the mapped value does not have
# an associated setter
self._values[map_key] = v
else:
# The mapped value has a setter
setattr(self, map_key, v)
else:
# If the mapped value is not a @property
self._values[map_key] = v
def to_return(self):
result = {}
try:
for returnable in self.returnables:
result[returnable] = getattr(self, returnable)
result = self._filter_params(result)
return result
except Exception:
return result
def api_params(self):
result = {}
for api_attribute in self.api_attributes:
if self.api_map is not None and api_attribute in self.api_map:
result[api_attribute] = getattr(self, self.api_map[api_attribute])
else:
result[api_attribute] = getattr(self, api_attribute)
result = self._filter_params(result)
return result
@property
def username(self):
return self._values['target_username']
@property
def password(self):
return self._values['target_password']
@property
def destination(self):
if self.ip is None and self.port is None:
return None
destination = '{0}:{1}'.format(self.ip, self.port)
return destination
@destination.setter
def destination(self, value):
ip, port = value.split(':')
self._values['ip'] = ip
self._values['port'] = port
@property
def interval(self):
if self._values['interval'] is None:
return None
# Per BZ617284, the BIG-IP UI does not raise a warning about this.
# So I do
if 1 > int(self._values['interval']) > 86400:
raise F5ModuleError(
"Interval value must be between 1 and 86400"
)
return int(self._values['interval'])
@property
def timeout(self):
if self._values['timeout'] is None:
return None
return int(self._values['timeout'])
@property
def ip(self):
if self._values['ip'] is None:
return None
try:
if self._values['ip'] in ['*', '0.0.0.0']:
return '*'
result = str(netaddr.IPAddress(self._values['ip']))
return result
except netaddr.core.AddrFormatError:
raise F5ModuleError(
"The provided 'ip' parameter is not an IP address."
)
@property
def port(self):
if self._values['port'] is None:
return None
elif self._values['port'] == '*':
return '*'
return int(self._values['port'])
@property
def time_until_up(self):
if self._values['time_until_up'] is None:
return None
return int(self._values['time_until_up'])
@property
def parent(self):
if self._values['parent'] is None:
return None
if self._values['parent'].startswith('/'):
parent = os.path.basename(self._values['parent'])
result = '/{0}/{1}'.format(self.partition, parent)
else: else:
module.fail_json(msg='Monitor already exists, but has a different type (%s) or parent(%s)' % (ttype, parent)) result = '/{0}/{1}'.format(self.partition, self._values['parent'])
except bigsuds.OperationFailed as e: return result
if "was not found" in str(e):
result = False @property
else: def type(self):
# genuine exception return 'http'
raise
return result
def create_monitor(api, monitor, template_attributes): class Difference(object):
try: def __init__(self, want, have=None):
api.LocalLB.Monitor.create_template( self.want = want
templates=[{ self.have = have
'template_name': monitor,
'template_type': TEMPLATE_TYPE def compare(self, param):
}], try:
template_attributes=[template_attributes] result = getattr(self, param)
) return result
except bigsuds.OperationFailed as e: except AttributeError:
if "already exists" in str(e): result = self.__default(param)
return False return result
else:
# genuine exception @property
raise def parent(self):
return True if self.want.parent != self.want.parent:
raise F5ModuleError(
"The parent monitor cannot be changed"
)
@property
def destination(self):
if self.want.ip is None and self.want.port is None:
return None
if self.want.port is None:
self.want.update({'port': self.have.port})
if self.want.ip is None:
self.want.update({'ip': self.have.ip})
if self.want.port in [None, '*'] and self.want.ip != '*':
raise F5ModuleError(
"Specifying an IP address requires that a port number be specified"
)
if self.want.destination != self.have.destination:
return self.want.destination
@property
def interval(self):
if self.want.timeout is not None and self.want.interval is not None:
if self.want.interval >= self.want.timeout:
raise F5ModuleError(
"Parameter 'interval' must be less than 'timeout'."
)
elif self.want.timeout is not None:
if self.have.interval >= self.want.timeout:
raise F5ModuleError(
"Parameter 'interval' must be less than 'timeout'."
)
elif self.want.interval is not None:
if self.want.interval >= self.have.timeout:
raise F5ModuleError(
"Parameter 'interval' must be less than 'timeout'."
)
if self.want.interval != self.have.interval:
return self.want.interval
def __default(self, param):
attr1 = getattr(self.want, param)
try:
attr2 = getattr(self.have, param)
if attr1 != attr2:
return attr1
except AttributeError:
return attr1
def delete_monitor(api, monitor): class ModuleManager(object):
try: def __init__(self, client):
api.LocalLB.Monitor.delete_template(template_names=[monitor]) self.client = client
except bigsuds.OperationFailed as e: self.have = None
# maybe it was deleted since we checked self.want = Parameters(self.client.module.params)
if "was not found" in str(e): self.changes = Parameters()
return False
else:
# genuine exception
raise
return True
def _set_changed_options(self):
changed = {}
for key in Parameters.returnables:
if getattr(self.want, key) is not None:
changed[key] = getattr(self.want, key)
if changed:
self.changes = Parameters(changed)
def check_string_property(api, monitor, str_property): def _update_changed_options(self):
try: diff = Difference(self.want, self.have)
template_prop = api.LocalLB.Monitor.get_template_string_property( updatables = Parameters.updatables
[monitor], [str_property['type']] changed = dict()
)[0] for k in updatables:
return str_property == template_prop change = diff.compare(k)
except bigsuds.OperationFailed as e: if change is None:
# happens in check mode if not created yet continue
if "was not found" in str(e): else:
changed[k] = change
if changed:
self.changes = Parameters(changed)
return True return True
return False
def _announce_deprecations(self):
warnings = []
if self.want:
warnings += self.want._values.get('__warnings', [])
if self.have:
warnings += self.have._values.get('__warnings', [])
for warning in warnings:
self.client.module.deprecate(
msg=warning['msg'],
version=warning['version']
)
def exec_module(self):
changed = False
result = dict()
state = self.want.state
try:
if state == "present":
changed = self.present()
elif state == "absent":
changed = self.absent()
except iControlUnexpectedHTTPError as e:
raise F5ModuleError(str(e))
changes = self.changes.to_return()
result.update(**changes)
result.update(dict(changed=changed))
self._announce_deprecations()
return result
def present(self):
if self.exists():
return self.update()
else: else:
# genuine exception return self.create()
raise
def create(self):
def set_string_property(api, monitor, str_property): self._set_changed_options()
api.LocalLB.Monitor.set_template_string_property( if self.want.timeout is None:
template_names=[monitor], self.want.update({'timeout': 16})
values=[str_property] if self.want.interval is None:
) self.want.update({'interval': 5})
if self.want.time_until_up is None:
self.want.update({'time_until_up': 0})
def check_integer_property(api, monitor, int_property): if self.want.ip is None:
try: self.want.update({'ip': '*'})
template_prop = api.LocalLB.Monitor.get_template_integer_property( if self.want.port is None:
[monitor], [int_property['type']] self.want.update({'port': '*'})
)[0] if self.want.send is None:
return int_property == template_prop self.want.update({'send': 'GET /\r\n'})
except bigsuds.OperationFailed as e: if self.client.check_mode:
# happens in check mode if not created yet
if "was not found" in str(e):
return True return True
else: self.create_on_device()
# genuine exception return True
raise
def should_update(self):
result = self._update_changed_options()
if result:
return True
return False
def set_integer_property(api, monitor, int_property): def update(self):
api.LocalLB.Monitor.set_template_integer_property( self.have = self.read_current_from_device()
template_names=[monitor], if not self.should_update():
values=[int_property] return False
) if self.client.check_mode:
return True
self.update_on_device()
return True
def absent(self):
if self.exists():
return self.remove()
return False
def update_monitor_properties(api, module, monitor, template_string_properties, template_integer_properties): def remove(self):
changed = False if self.client.check_mode:
for str_property in template_string_properties: return True
if str_property['value'] is not None and not check_string_property(api, monitor, str_property): self.remove_from_device()
if not module.check_mode: if self.exists():
set_string_property(api, monitor, str_property) raise F5ModuleError("Failed to delete the monitor.")
changed = True return True
for int_property in template_integer_properties:
if int_property['value'] is not None and not check_integer_property(api, monitor, int_property):
if not module.check_mode:
set_integer_property(api, monitor, int_property)
changed = True
return changed def read_current_from_device(self):
resource = self.client.api.tm.ltm.monitor.https.http.load(
name=self.want.name,
def get_ipport(api, monitor): partition=self.want.partition
return api.LocalLB.Monitor.get_template_destination(template_names=[monitor])[0]
def set_ipport(api, monitor, ipport):
try:
api.LocalLB.Monitor.set_template_destination(
template_names=[monitor], destinations=[ipport]
) )
return True, "" result = resource.attrs
except bigsuds.OperationFailed as e: return Parameters(result)
if "Cannot modify the address type of monitor" in str(e):
return False, "Cannot modify the address type of monitor if already assigned to a pool." def exists(self):
else: result = self.client.api.tm.ltm.monitor.https.http.exists(
# genuine exception name=self.want.name,
raise partition=self.want.partition
)
return result
def update_on_device(self):
params = self.want.api_params()
result = self.client.api.tm.ltm.monitor.https.http.load(
name=self.want.name,
partition=self.want.partition
)
result.modify(**params)
def create_on_device(self):
params = self.want.api_params()
self.client.api.tm.ltm.monitor.https.http.create(
name=self.want.name,
partition=self.want.partition,
**params
)
def remove_from_device(self):
result = self.client.api.tm.ltm.monitor.https.http.load(
name=self.want.name,
partition=self.want.partition
)
if result:
result.delete()
class ArgumentSpec(object):
def __init__(self):
self.supports_check_mode = True
self.argument_spec = dict(
name=dict(required=True),
parent=dict(default='http'),
send=dict(),
receive=dict(),
receive_disable=dict(required=False),
ip=dict(),
port=dict(type='int'),
interval=dict(type='int'),
timeout=dict(type='int'),
time_until_up=dict(type='int'),
target_username=dict(),
target_password=dict(no_log=True),
# Deprecated params
parent_partition=dict(
removed_in_version='2.4'
)
)
self.f5_product_name = 'bigip'
def main(): def main():
argument_spec = f5_argument_spec() spec = ArgumentSpec()
meta_args = dict( client = AnsibleF5Client(
name=dict(required=True), argument_spec=spec.argument_spec,
parent=dict(default=DEFAULT_PARENT_TYPE), supports_check_mode=spec.supports_check_mode,
parent_partition=dict(default='Common'), f5_product_name=spec.f5_product_name
send=dict(required=False),
receive=dict(required=False),
receive_disable=dict(required=False),
ip=dict(required=False),
port=dict(required=False, type='int'),
interval=dict(required=False, type='int'),
timeout=dict(required=False, type='int'),
time_until_up=dict(required=False, type='int', default=0)
) )
argument_spec.update(meta_args)
module = AnsibleModule(
argument_spec=argument_spec,
supports_check_mode=True
)
server = module.params['server']
server_port = module.params['server_port']
user = module.params['user']
password = module.params['password']
state = module.params['state']
partition = module.params['partition']
validate_certs = module.params['validate_certs']
parent_partition = module.params['parent_partition']
name = module.params['name']
parent = fq_name(parent_partition, module.params['parent'])
monitor = fq_name(partition, name)
send = module.params['send']
receive = module.params['receive']
receive_disable = module.params['receive_disable']
ip = module.params['ip']
port = module.params['port']
interval = module.params['interval']
timeout = module.params['timeout']
time_until_up = module.params['time_until_up']
# end monitor specific stuff
api = bigip_api(server, user, password, validate_certs, port=server_port)
monitor_exists = check_monitor_exists(module, api, monitor, parent)
# ipport is a special setting
if monitor_exists:
cur_ipport = get_ipport(api, monitor)
if ip is None:
ip = cur_ipport['ipport']['address']
if port is None:
port = cur_ipport['ipport']['port']
else:
if interval is None:
interval = 5
if timeout is None:
timeout = 16
if ip is None:
ip = '0.0.0.0'
if port is None:
port = 0
if send is None:
send = ''
if receive is None:
receive = ''
if receive_disable is None:
receive_disable = ''
# define and set address type
if ip == '0.0.0.0' and port == 0:
address_type = 'ATYPE_STAR_ADDRESS_STAR_PORT'
elif ip == '0.0.0.0' and port != 0:
address_type = 'ATYPE_STAR_ADDRESS_EXPLICIT_PORT'
elif ip != '0.0.0.0' and port != 0:
address_type = 'ATYPE_EXPLICIT_ADDRESS_EXPLICIT_PORT'
else:
address_type = 'ATYPE_UNSET'
ipport = {'address_type': address_type,
'ipport': {'address': ip,
'port': port}}
template_attributes = {'parent_template': parent,
'interval': interval,
'timeout': timeout,
'dest_ipport': ipport,
'is_read_only': False,
'is_directly_usable': True}
# monitor specific stuff
template_string_properties = [{'type': 'STYPE_SEND',
'value': send},
{'type': 'STYPE_RECEIVE',
'value': receive},
{'type': 'STYPE_RECEIVE_DRAIN',
'value': receive_disable}]
template_integer_properties = [
{
'type': 'ITYPE_INTERVAL',
'value': interval
},
{
'type': 'ITYPE_TIMEOUT',
'value': timeout
},
{
'type': 'ITYPE_TIME_UNTIL_UP',
'value': time_until_up
}
]
# main logic, monitor generic
try: try:
result = {'changed': False} # default if not HAS_F5SDK:
raise F5ModuleError("The python f5-sdk module is required")
if state == 'absent': if not HAS_NETADDR:
if monitor_exists: raise F5ModuleError("The python netaddr module is required")
if not module.check_mode:
# possible race condition if same task
# on other node deleted it first
result['changed'] |= delete_monitor(api, monitor)
else:
result['changed'] |= True
else:
# check for monitor itself
if not monitor_exists:
if not module.check_mode:
# again, check changed status here b/c race conditions
# if other task already created it
result['changed'] |= create_monitor(api, monitor, template_attributes)
else:
result['changed'] |= True
# check for monitor parameters mm = ModuleManager(client)
# whether it already existed, or was just created, now update results = mm.exec_module()
# the update functions need to check for check mode but client.module.exit_json(**results)
# cannot update settings if it doesn't exist which happens in check mode except F5ModuleError as e:
result['changed'] |= update_monitor_properties(api, module, monitor, client.module.fail_json(msg=str(e))
template_string_properties,
template_integer_properties)
# we just have to update the ipport if monitor already exists and it's different
if monitor_exists and cur_ipport != ipport:
set_ipport(api, monitor, ipport)
result['changed'] |= True
# else: monitor doesn't exist (check mode) or ipport is already ok
except Exception as e:
module.fail_json(msg="received exception: %s" % e)
module.exit_json(**result)
# import module snippets
from ansible.module_utils.basic import *
from ansible.module_utils.f5_utils import *
if __name__ == '__main__': if __name__ == '__main__':
main() main()

View file

@ -0,0 +1,28 @@
{
"kind": "tm:ltm:monitor:http:httpstate",
"name": "asdf",
"partition": "Common",
"fullPath": "/Common/asdf",
"generation": 0,
"selfLink": "https://localhost/mgmt/tm/ltm/monitor/http/~Common~asdf?ver=13.0.0",
"adaptive": "disabled",
"adaptiveDivergenceType": "relative",
"adaptiveDivergenceValue": 25,
"adaptiveLimit": 200,
"adaptiveSamplingTimespan": 300,
"defaultsFrom": "/Common/http",
"description": "this is a description",
"destination": "1.1.1.1:389",
"interval": 5,
"ipDscp": 0,
"manualResume": "disabled",
"password": "$M$7T$DpzEUVHt5rKkAfqrBh1PTA==",
"recv": "hello world",
"reverse": "enabled",
"send": "GET /\\r\\n",
"timeUntilUp": 0,
"timeout": 16,
"transparent": "disabled",
"upInterval": 0,
"username": "john"
}

View file

@ -0,0 +1,457 @@
# -*- coding: utf-8 -*-
#
# Copyright 2017 F5 Networks Inc.
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public Liccense for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible. If not, see <http://www.gnu.org/licenses/>.
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
import os
import json
import sys
import pytest
from nose.plugins.skip import SkipTest
if sys.version_info < (2, 7):
raise SkipTest("F5 Ansible modules require Python >= 2.7")
from ansible.compat.tests import unittest
from ansible.compat.tests.mock import patch, Mock
from ansible.module_utils import basic
from ansible.module_utils._text import to_bytes
from ansible.module_utils.f5_utils import AnsibleF5Client
from ansible.module_utils.f5_utils import F5ModuleError
try:
from library.bigip_monitor_http import Parameters
from library.bigip_monitor_http import ModuleManager
from library.bigip_monitor_http import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
except ImportError:
try:
from ansible.modules.network.f5.bigip_monitor_http import Parameters
from ansible.modules.network.f5.bigip_monitor_http import ModuleManager
from ansible.modules.network.f5.bigip_monitor_http import ArgumentSpec
from ansible.module_utils.f5_utils import iControlUnexpectedHTTPError
except ImportError:
raise SkipTest("F5 Ansible modules require the f5-sdk Python library")
fixture_path = os.path.join(os.path.dirname(__file__), 'fixtures')
fixture_data = {}
def set_module_args(args):
args = json.dumps({'ANSIBLE_MODULE_ARGS': args})
basic._ANSIBLE_ARGS = to_bytes(args)
def load_fixture(name):
path = os.path.join(fixture_path, name)
if path in fixture_data:
return fixture_data[path]
with open(path) as f:
data = f.read()
try:
data = json.loads(data)
except Exception:
pass
fixture_data[path] = data
return data
class TestParameters(unittest.TestCase):
def test_module_parameters(self):
args = dict(
name='foo',
parent='parent',
send='this is a send string',
receive='this is a receive string',
ip='10.10.10.10',
port=80,
interval=20,
timeout=30,
time_until_up=60,
partition='Common'
)
p = Parameters(args)
assert p.name == 'foo'
assert p.parent == '/Common/parent'
assert p.send == 'this is a send string'
assert p.receive == 'this is a receive string'
assert p.ip == '10.10.10.10'
assert p.type == 'http'
assert p.port == 80
assert p.destination == '10.10.10.10:80'
assert p.interval == 20
assert p.timeout == 30
assert p.time_until_up == 60
def test_module_parameters_ints_as_strings(self):
args = dict(
name='foo',
parent='parent',
send='this is a send string',
receive='this is a receive string',
ip='10.10.10.10',
port='80',
interval='20',
timeout='30',
time_until_up='60',
partition='Common'
)
p = Parameters(args)
assert p.name == 'foo'
assert p.parent == '/Common/parent'
assert p.send == 'this is a send string'
assert p.receive == 'this is a receive string'
assert p.ip == '10.10.10.10'
assert p.type == 'http'
assert p.port == 80
assert p.destination == '10.10.10.10:80'
assert p.interval == 20
assert p.timeout == 30
assert p.time_until_up == 60
def test_api_parameters(self):
args = dict(
name='foo',
defaultsFrom='/Common/parent',
send='this is a send string',
recv='this is a receive string',
destination='10.10.10.10:80',
interval=20,
timeout=30,
timeUntilUp=60
)
p = Parameters(args)
assert p.name == 'foo'
assert p.parent == '/Common/parent'
assert p.send == 'this is a send string'
assert p.receive == 'this is a receive string'
assert p.ip == '10.10.10.10'
assert p.type == 'http'
assert p.port == 80
assert p.destination == '10.10.10.10:80'
assert p.interval == 20
assert p.timeout == 30
assert p.time_until_up == 60
@patch('ansible.module_utils.f5_utils.AnsibleF5Client._get_mgmt_root',
return_value=True)
class TestManager(unittest.TestCase):
def setUp(self):
self.spec = ArgumentSpec()
def test_create_monitor(self, *args):
set_module_args(dict(
name='foo',
parent='parent',
send='this is a send string',
receive='this is a receive string',
ip='10.10.10.10',
port=80,
interval=20,
timeout=30,
time_until_up=60,
partition='Common',
server='localhost',
password='password',
user='admin'
))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(side_effect=[False, True])
mm.create_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['parent'] == '/Common/parent'
def test_create_monitor_idempotent(self, *args):
set_module_args(dict(
name='asdf',
parent='http',
send='GET /\\r\\n',
receive='hello world',
ip='1.1.1.1',
port=389,
interval=5,
timeout=16,
time_until_up=0,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
results = mm.exec_module()
assert results['changed'] is False
def test_update_port(self, *args):
set_module_args(dict(
name='asdf',
port=800,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['port'] == 800
def test_update_interval(self, *args):
set_module_args(dict(
name='foo',
interval=10,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['interval'] == 10
def test_update_interval_larger_than_existing_timeout(self, *args):
set_module_args(dict(
name='asdf',
interval=30,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
with pytest.raises(F5ModuleError) as ex:
mm.exec_module()
assert "must be less than" in str(ex)
def test_update_interval_larger_than_new_timeout(self, *args):
set_module_args(dict(
name='asdf',
interval=10,
timeout=5,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
with pytest.raises(F5ModuleError) as ex:
mm.exec_module()
assert "must be less than" in str(ex)
def test_update_send(self, *args):
set_module_args(dict(
name='asdf',
send='this is another send string',
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['send'] == 'this is another send string'
def test_update_receive(self, *args):
set_module_args(dict(
name='asdf',
receive='this is another receive string',
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['receive'] == 'this is another receive string'
def test_update_timeout(self, *args):
set_module_args(dict(
name='asdf',
timeout=300,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['timeout'] == 300
def test_update_time_until_up(self, *args):
set_module_args(dict(
name='asdf',
time_until_up=300,
partition='Common',
server='localhost',
password='password',
user='admin'
))
current = Parameters(load_fixture('load_ltm_monitor_http.json'))
client = AnsibleF5Client(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode,
f5_product_name=self.spec.f5_product_name
)
# Override methods in the specific type of manager
mm = ModuleManager(client)
mm.exists = Mock(return_value=True)
mm.read_current_from_device = Mock(return_value=current)
mm.update_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert results['time_until_up'] == 300