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

lib/ansible/modules/network/f5/bigip_monitor_http.py

@@ -2,96 +2,67 @@
 # -*- coding: utf-8 -*-
 #
 # 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)
 
-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
-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:
-  state:
-    description:
-      - Monitor state
-    required: false
-    default: 'present'
-    choices:
-      - present
-      - absent
   name:
     description:
-      - Monitor name
+      - Monitor name.
-    required: true
+    required: True
-    default: null
     aliases:
       - monitor
-  partition:
-    description:
-      - Partition for the monitor
-    required: false
-    default: 'Common'
   parent:
     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:
     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:
     description:
-      - The receive string for the monitor call
+      - The receive string for the monitor call.
-    required: true
-    default: none
   receive_disable:
     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:
     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:
     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:
     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:
     description:
       - 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
         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
-        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:
     description:
       - 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
         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
+author:
+  - Tim Rupp (@caphrim007)
 '''
 
-EXAMPLES = '''
+EXAMPLES = r'''
-- name: BIGIP F5 | Create HTTP Monitor
+- name: Create HTTP Monitor
   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
 
-- name: BIGIP F5 | Remove HTTP Monitor
+- name: Remove HTTP Monitor
   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
 '''
 
-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:
-            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 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:
-            # 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
-        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():
-    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:
-        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__':
     main()

test/units/modules/network/f5/fixtures/load_ltm_monitor_http.json

@@ -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"
+}

test/units/modules/network/f5/test_bigip_monitor_http.py

@@ -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