community.general/plugins/modules/network/f5/bigip_gtm_facts.py

#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Copyright: (c) 2017, F5 Networks Inc.
# GNU General Public License v3.0 (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)

from __future__ import absolute_import, division, print_function
__metaclass__ = type


ANSIBLE_METADATA = {'metadata_version': '1.1',
                    'status': ['deprecated'],
                    'supported_by': 'certified'}

DOCUMENTATION = r'''
---
module: bigip_gtm_facts
short_description: Collect facts from F5 BIG-IP GTM devices
description:
  - Collect facts from F5 BIG-IP GTM devices.
options:
  include:
    description:
      - Fact category to collect.
    required: True
    choices:
      - pool
      - wide_ip
      - server
  filter:
    description:
      - Perform regex filter of response. Filtering is done on the name of
        the resource. Valid filters are anything that can be provided to
        Python's C(re) module.
deprecated:
  removed_in: '2.11'
  alternative: bigip_device_info
  why: >
    The bigip_gtm_facts module is an outlier as all facts are being collected
    in the bigip_device_info module. Additionally, the M(bigip_device_info)
    module is easier to maintain and use.
extends_documentation_fragment:
- f5networks.f5_modules.f5

notes:
  - This module is deprecated. Use the C(bigip_device_info) module instead.
author:
  - Tim Rupp (@caphrim007)
'''

EXAMPLES = r'''
- name: Get pool facts
  bigip_gtm_facts:
    server: lb.mydomain.com
    user: admin
    password: secret
    include: pool
    filter: my_pool
  delegate_to: localhost
'''

RETURN = r'''
wide_ip:
  description:
    Contains the lb method for the wide ip and the pools that are within the wide ip.
  returned: changed
  type: list
  sample:
    wide_ip:
      - enabled: True
        failure_rcode: noerror
        failure_rcode_response: disabled
        failure_rcode_ttl: 0
        full_path: /Common/foo.ok.com
        last_resort_pool: ""
        minimal_response: enabled
        name: foo.ok.com
        partition: Common
        persist_cidr_ipv4: 32
        persist_cidr_ipv6: 128
        persistence: disabled
        pool_lb_mode: round-robin
        pools:
          - name: d3qw
            order: 0
            partition: Common
            ratio: 1
        ttl_persistence: 3600
        type: naptr
pool:
  description: Contains the pool object status and enabled status.
  returned: changed
  type: list
  sample:
    pool:
      - alternate_mode: round-robin
        dynamic_ratio: disabled
        enabled: True
        fallback_mode: return-to-dns
        full_path: /Common/d3qw
        load_balancing_mode: round-robin
        manual_resume: disabled
        max_answers_returned: 1
        members:
          - disabled: True
            flags: a
            full_path: ok3.com
            member_order: 0
            name: ok3.com
            order: 10
            preference: 10
            ratio: 1
            service: 80
        name: d3qw
        partition: Common
        qos_hit_ratio: 5
        qos_hops: 0
        qos_kilobytes_second: 3
        qos_lcs: 30
        qos_packet_rate: 1
        qos_rtt: 50
        qos_topology: 0
        qos_vs_capacity: 0
        qos_vs_score: 0
        availability_state: offline
        enabled_state: disabled
        ttl: 30
        type: naptr
        verify_member_availability: disabled
server:
  description:
    Contains the virtual server enabled and availability status, and address.
  returned: changed
  type: list
  sample:
    server:
      - addresses:
          - device_name: /Common/qweqwe
            name: 10.10.10.10
            translation: none
        datacenter: /Common/xfxgh
        enabled: True
        expose_route_domains: no
        full_path: /Common/qweqwe
        iq_allow_path: yes
        iq_allow_service_check: yes
        iq_allow_snmp: yes
        limit_cpu_usage: 0
        limit_cpu_usage_status: disabled
        limit_max_bps: 0
        limit_max_bps_status: disabled
        limit_max_connections: 0
        limit_max_connections_status: disabled
        limit_max_pps: 0
        limit_max_pps_status: disabled
        limit_mem_avail: 0
        limit_mem_avail_status: disabled
        link_discovery: disabled
        monitor: /Common/bigip
        name: qweqwe
        partition: Common
        product: single-bigip
        virtual_server_discovery: disabled
        virtual_servers:
          - destination: 10.10.10.10:0
            enabled: True
            full_path: jsdfhsd
            limit_max_bps: 0
            limit_max_bps_status: disabled
            limit_max_connections: 0
            limit_max_connections_status: disabled
            limit_max_pps: 0
            limit_max_pps_status: disabled
            name: jsdfhsd
            translation_address: none
            translation_port: 0
'''

import re

from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.six import iteritems
from ansible.module_utils.parsing.convert_bool import BOOLEANS_TRUE
from distutils.version import LooseVersion

try:
    from f5.bigip import ManagementRoot
    from icontrol.exceptions import iControlUnexpectedHTTPError
    from f5.utils.responses.handlers import Stats
    HAS_F5SDK = True
except ImportError:
    HAS_F5SDK = False

try:
    from library.module_utils.network.f5.common import F5BaseClient
except ImportError:
    from ansible_collections.f5networks.f5_modules.plugins.module_utils.common import F5BaseClient

try:
    from library.module_utils.network.f5.common import F5ModuleError
    from library.module_utils.network.f5.common import AnsibleF5Parameters
    from library.module_utils.network.f5.common import f5_argument_spec
except ImportError:
    from ansible_collections.f5networks.f5_modules.plugins.module_utils.common import F5ModuleError
    from ansible_collections.f5networks.f5_modules.plugins.module_utils.common import AnsibleF5Parameters
    from ansible_collections.f5networks.f5_modules.plugins.module_utils.common import f5_argument_spec


class F5Client(F5BaseClient):
    def __init__(self, *args, **kwargs):
        super(F5Client, self).__init__(*args, **kwargs)
        self.provider = self.merge_provider_params()

    @property
    def api(self):
        if self._client:
            return self._client

        try:
            result = ManagementRoot(
                self.provider['server'],
                self.provider['user'],
                self.provider['password'],
                port=self.provider['server_port'],
                verify=self.provider['validate_certs'],
                token='tmos'
            )
            self._client = result
            return self._client
        except Exception as ex:
            error = 'Unable to connect to {0} on port {1}. The reported error was "{2}".'.format(
                self.provider['server'], self.provider['server_port'], str(ex)
            )
            raise F5ModuleError(error)


class BaseManager(object):
    def __init__(self, *args, **kwargs):
        self.module = kwargs.get('module', None)
        self.client = kwargs.get('client', None)
        self.kwargs = kwargs

        self.types = dict(
            a_s='a',
            aaaas='aaaa',
            cnames='cname',
            mxs='mx',
            naptrs='naptr',
            srvs='srv'
        )

    def filter_matches_name(self, name):
        if self.want.filter is None:
            return True
        matches = re.match(self.want.filter, str(name))
        if matches:
            return True
        else:
            return False

    def version_is_less_than_12(self):
        version = self.client.api.tmos_version
        if LooseVersion(version) < LooseVersion('12.0.0'):
            return True
        else:
            return False

    def get_facts_from_collection(self, collection, collection_type=None):
        results = []
        for item in collection:
            if not self.filter_matches_name(item.name):
                continue
            facts = self.format_facts(item, collection_type)
            results.append(facts)
        return results

    def read_stats_from_device(self, resource):
        stats = Stats(resource.stats.load())
        return stats.stat


class UntypedManager(BaseManager):
    def exec_module(self):
        results = []
        facts = self.read_facts()
        for item in facts:
            attrs = item.to_return()
            filtered = [(k, v) for k, v in iteritems(attrs) if self.filter_matches_name(k)]
            if filtered:
                results.append(dict(filtered))
        return results


class TypedManager(BaseManager):
    def exec_module(self):
        results = []
        for collection, type in iteritems(self.types):
            facts = self.read_facts(collection)
            if not facts:
                continue
            for x in facts:
                x.update({'type': type})
            for item in facts:
                attrs = item.to_return()
                filtered = [(k, v) for k, v in iteritems(attrs) if self.filter_matches_name(k)]
                if filtered:
                    results.append(dict(filtered))
        return results


class Parameters(AnsibleF5Parameters):
    @property
    def include(self):
        requested = self._values['include']
        valid = ['pool', 'wide_ip', 'server', 'all']

        if any(x for x in requested if x not in valid):
            raise F5ModuleError(
                "The valid 'include' choices are {0}".format(', '.join(valid))
            )

        if 'all' in requested:
            return ['all']
        else:
            return requested


class BaseParameters(Parameters):
    @property
    def enabled(self):
        if self._values['enabled'] is None:
            return None
        elif self._values['enabled'] in BOOLEANS_TRUE:
            return True
        else:
            return False

    @property
    def disabled(self):
        if self._values['disabled'] is None:
            return None
        elif self._values['disabled'] in BOOLEANS_TRUE:
            return True
        else:
            return False

    def _remove_internal_keywords(self, resource):
        resource.pop('kind', None)
        resource.pop('generation', None)
        resource.pop('selfLink', None)
        resource.pop('isSubcollection', None)
        resource.pop('fullPath', None)

    def to_return(self):
        result = {}
        for returnable in self.returnables:
            result[returnable] = getattr(self, returnable)
        result = self._filter_params(result)
        return result


class PoolParameters(BaseParameters):
    api_map = {
        'alternateMode': 'alternate_mode',
        'dynamicRatio': 'dynamic_ratio',
        'fallbackMode': 'fallback_mode',
        'fullPath': 'full_path',
        'loadBalancingMode': 'load_balancing_mode',
        'manualResume': 'manual_resume',
        'maxAnswersReturned': 'max_answers_returned',
        'qosHitRatio': 'qos_hit_ratio',
        'qosHops': 'qos_hops',
        'qosKilobytesSecond': 'qos_kilobytes_second',
        'qosLcs': 'qos_lcs',
        'qosPacketRate': 'qos_packet_rate',
        'qosRtt': 'qos_rtt',
        'qosTopology': 'qos_topology',
        'qosVsCapacity': 'qos_vs_capacity',
        'qosVsScore': 'qos_vs_score',
        'verifyMemberAvailability': 'verify_member_availability',
        'membersReference': 'members'
    }

    returnables = [
        'alternate_mode', 'dynamic_ratio', 'enabled', 'disabled', 'fallback_mode',
        'load_balancing_mode', 'manual_resume', 'max_answers_returned', 'members',
        'name', 'partition', 'qos_hit_ratio', 'qos_hops', 'qos_kilobytes_second',
        'qos_lcs', 'qos_packet_rate', 'qos_rtt', 'qos_topology', 'qos_vs_capacity',
        'qos_vs_score', 'ttl', 'type', 'full_path', 'availability_state',
        'enabled_state', 'availability_status'
    ]

    @property
    def max_answers_returned(self):
        if self._values['max_answers_returned'] is None:
            return None
        return int(self._values['max_answers_returned'])

    @property
    def members(self):
        result = []
        if self._values['members'] is None or 'items' not in self._values['members']:
            return result
        for item in self._values['members']['items']:
            self._remove_internal_keywords(item)
            if 'disabled' in item:
                if item['disabled'] in BOOLEANS_TRUE:
                    item['disabled'] = True
                else:
                    item['disabled'] = False
            if 'enabled' in item:
                if item['enabled'] in BOOLEANS_TRUE:
                    item['enabled'] = True
                else:
                    item['enabled'] = False
            if 'fullPath' in item:
                item['full_path'] = item.pop('fullPath')
            if 'memberOrder' in item:
                item['member_order'] = int(item.pop('memberOrder'))
            # Cast some attributes to integer
            for x in ['order', 'preference', 'ratio', 'service']:
                if x in item:
                    item[x] = int(item[x])
            result.append(item)
        return result

    @property
    def qos_hit_ratio(self):
        if self._values['qos_hit_ratio'] is None:
            return None
        return int(self._values['qos_hit_ratio'])

    @property
    def qos_hops(self):
        if self._values['qos_hops'] is None:
            return None
        return int(self._values['qos_hops'])

    @property
    def qos_kilobytes_second(self):
        if self._values['qos_kilobytes_second'] is None:
            return None
        return int(self._values['qos_kilobytes_second'])

    @property
    def qos_lcs(self):
        if self._values['qos_lcs'] is None:
            return None
        return int(self._values['qos_lcs'])

    @property
    def qos_packet_rate(self):
        if self._values['qos_packet_rate'] is None:
            return None
        return int(self._values['qos_packet_rate'])

    @property
    def qos_rtt(self):
        if self._values['qos_rtt'] is None:
            return None
        return int(self._values['qos_rtt'])

    @property
    def qos_topology(self):
        if self._values['qos_topology'] is None:
            return None
        return int(self._values['qos_topology'])

    @property
    def qos_vs_capacity(self):
        if self._values['qos_vs_capacity'] is None:
            return None
        return int(self._values['qos_vs_capacity'])

    @property
    def qos_vs_score(self):
        if self._values['qos_vs_score'] is None:
            return None
        return int(self._values['qos_vs_score'])

    @property
    def availability_state(self):
        if self._values['stats'] is None:
            return None
        try:
            result = self._values['stats']['status_availabilityState']
            return result['description']
        except AttributeError:
            return None

    @property
    def enabled_state(self):
        if self._values['stats'] is None:
            return None
        try:
            result = self._values['stats']['status_enabledState']
            return result['description']
        except AttributeError:
            return None

    @property
    def availability_status(self):
        # This fact is a combination of the availability_state and enabled_state
        #
        # The purpose of the fact is to give a higher-level view of the availability
        # of the pool, that can be used in playbooks. If you need further detail,
        # consider using the following facts together.
        #
        # - availability_state
        # - enabled_state
        #
        if self.enabled_state == 'enabled':
            if self.availability_state == 'offline':
                return 'red'
            elif self.availability_state == 'available':
                return 'green'
            elif self.availability_state == 'unknown':
                return 'blue'
            else:
                return 'none'
        else:
            # disabled
            return 'black'


class WideIpParameters(BaseParameters):
    api_map = {
        'fullPath': 'full_path',
        'failureRcode': 'failure_return_code',
        'failureRcodeResponse': 'failure_return_code_response',
        'failureRcodeTtl': 'failure_return_code_ttl',
        'lastResortPool': 'last_resort_pool',
        'minimalResponse': 'minimal_response',
        'persistCidrIpv4': 'persist_cidr_ipv4',
        'persistCidrIpv6': 'persist_cidr_ipv6',
        'poolLbMode': 'pool_lb_mode',
        'ttlPersistence': 'ttl_persistence'
    }

    returnables = [
        'full_path', 'description', 'enabled', 'disabled', 'failure_return_code',
        'failure_return_code_response', 'failure_return_code_ttl', 'last_resort_pool',
        'minimal_response', 'persist_cidr_ipv4', 'persist_cidr_ipv6', 'pool_lb_mode',
        'ttl_persistence', 'pools'
    ]

    @property
    def pools(self):
        result = []
        if self._values['pools'] is None:
            return []
        for pool in self._values['pools']:
            del pool['nameReference']
            for x in ['order', 'ratio']:
                if x in pool:
                    pool[x] = int(pool[x])
            result.append(pool)
        return result

    @property
    def failure_return_code_ttl(self):
        if self._values['failure_return_code_ttl'] is None:
            return None
        return int(self._values['failure_return_code_ttl'])

    @property
    def persist_cidr_ipv4(self):
        if self._values['persist_cidr_ipv4'] is None:
            return None
        return int(self._values['persist_cidr_ipv4'])

    @property
    def persist_cidr_ipv6(self):
        if self._values['persist_cidr_ipv6'] is None:
            return None
        return int(self._values['persist_cidr_ipv6'])

    @property
    def ttl_persistence(self):
        if self._values['ttl_persistence'] is None:
            return None
        return int(self._values['ttl_persistence'])


class ServerParameters(BaseParameters):
    api_map = {
        'fullPath': 'full_path',
        'exposeRouteDomains': 'expose_route_domains',
        'iqAllowPath': 'iq_allow_path',
        'iqAllowServiceCheck': 'iq_allow_service_check',
        'iqAllowSnmp': 'iq_allow_snmp',
        'limitCpuUsage': 'limit_cpu_usage',
        'limitCpuUsageStatus': 'limit_cpu_usage_status',
        'limitMaxBps': 'limit_max_bps',
        'limitMaxBpsStatus': 'limit_max_bps_status',
        'limitMaxConnections': 'limit_max_connections',
        'limitMaxConnectionsStatus': 'limit_max_connections_status',
        'limitMaxPps': 'limit_max_pps',
        'limitMaxPpsStatus': 'limit_max_pps_status',
        'limitMemAvail': 'limit_mem_available',
        'limitMemAvailStatus': 'limit_mem_available_status',
        'linkDiscovery': 'link_discovery',
        'proberFallback': 'prober_fallback',
        'proberPreference': 'prober_preference',
        'virtualServerDiscovery': 'virtual_server_discovery',
        'devicesReference': 'devices',
        'virtualServersReference': 'virtual_servers'
    }

    returnables = [
        'datacenter', 'enabled', 'disabled', 'expose_route_domains', 'iq_allow_path',
        'full_path', 'iq_allow_service_check', 'iq_allow_snmp', 'limit_cpu_usage',
        'limit_cpu_usage_status', 'limit_max_bps', 'limit_max_bps_status',
        'limit_max_connections', 'limit_max_connections_status', 'limit_max_pps',
        'limit_max_pps_status', 'limit_mem_available', 'limit_mem_available_status',
        'link_discovery', 'monitor', 'product', 'prober_fallback', 'prober_preference',
        'virtual_server_discovery', 'addresses', 'devices', 'virtual_servers'
    ]

    @property
    def product(self):
        if self._values['product'] is None:
            return None
        if self._values['product'] in ['single-bigip', 'redundant-bigip']:
            return 'bigip'
        return self._values['product']

    @property
    def devices(self):
        result = []
        if self._values['devices'] is None or 'items' not in self._values['devices']:
            return result
        for item in self._values['devices']['items']:
            self._remove_internal_keywords(item)
            if 'fullPath' in item:
                item['full_path'] = item.pop('fullPath')
            result.append(item)
        return result

    @property
    def virtual_servers(self):
        result = []
        if self._values['virtual_servers'] is None or 'items' not in self._values['virtual_servers']:
            return result
        for item in self._values['virtual_servers']['items']:
            self._remove_internal_keywords(item)
            if 'disabled' in item:
                if item['disabled'] in BOOLEANS_TRUE:
                    item['disabled'] = True
                else:
                    item['disabled'] = False
            if 'enabled' in item:
                if item['enabled'] in BOOLEANS_TRUE:
                    item['enabled'] = True
                else:
                    item['enabled'] = False
            if 'fullPath' in item:
                item['full_path'] = item.pop('fullPath')
            if 'limitMaxBps' in item:
                item['limit_max_bps'] = int(item.pop('limitMaxBps'))
            if 'limitMaxBpsStatus' in item:
                item['limit_max_bps_status'] = item.pop('limitMaxBpsStatus')
            if 'limitMaxConnections' in item:
                item['limit_max_connections'] = int(item.pop('limitMaxConnections'))
            if 'limitMaxConnectionsStatus' in item:
                item['limit_max_connections_status'] = item.pop('limitMaxConnectionsStatus')
            if 'limitMaxPps' in item:
                item['limit_max_pps'] = int(item.pop('limitMaxPps'))
            if 'limitMaxPpsStatus' in item:
                item['limit_max_pps_status'] = item.pop('limitMaxPpsStatus')
            if 'translationAddress' in item:
                item['translation_address'] = item.pop('translationAddress')
            if 'translationPort' in item:
                item['translation_port'] = int(item.pop('translationPort'))
            result.append(item)
        return result

    @property
    def limit_cpu_usage(self):
        if self._values['limit_cpu_usage'] is None:
            return None
        return int(self._values['limit_cpu_usage'])

    @property
    def limit_max_bps(self):
        if self._values['limit_max_bps'] is None:
            return None
        return int(self._values['limit_max_bps'])

    @property
    def limit_max_connections(self):
        if self._values['limit_max_connections'] is None:
            return None
        return int(self._values['limit_max_connections'])

    @property
    def limit_max_pps(self):
        if self._values['limit_max_pps'] is None:
            return None
        return int(self._values['limit_max_pps'])

    @property
    def limit_mem_available(self):
        if self._values['limit_mem_available'] is None:
            return None
        return int(self._values['limit_mem_available'])


class PoolFactManager(BaseManager):
    def __init__(self, *args, **kwargs):
        self.module = kwargs.get('module', None)
        self.client = kwargs.get('client', None)
        super(PoolFactManager, self).__init__(**kwargs)
        self.kwargs = kwargs

    def exec_module(self):
        if self.version_is_less_than_12():
            manager = self.get_manager('untyped')
        else:
            manager = self.get_manager('typed')
        facts = manager.exec_module()
        result = dict(pool=facts)
        return result

    def get_manager(self, type):
        if type == 'typed':
            return TypedPoolFactManager(**self.kwargs)
        elif type == 'untyped':
            return UntypedPoolFactManager(**self.kwargs)


class TypedPoolFactManager(TypedManager):
    def __init__(self, *args, **kwargs):
        self.module = kwargs.get('module', None)
        self.client = kwargs.get('client', None)
        super(TypedPoolFactManager, self).__init__(**kwargs)
        self.want = PoolParameters(params=self.module.params)

    def read_facts(self, collection):
        results = []
        collection = self.read_collection_from_device(collection)
        for resource in collection:
            attrs = resource.attrs
            attrs['stats'] = self.read_stats_from_device(resource)
            params = PoolParameters(params=attrs)
            results.append(params)
        return results

    def read_collection_from_device(self, collection_name):
        pools = self.client.api.tm.gtm.pools
        collection = getattr(pools, collection_name)
        result = collection.get_collection(
            requests_params=dict(
                params='expandSubcollections=true'
            )
        )
        return result


class UntypedPoolFactManager(UntypedManager):
    def __init__(self, *args, **kwargs):
        self.client = kwargs.get('client', None)
        self.module = kwargs.get('module', None)
        super(UntypedPoolFactManager, self).__init__(**kwargs)
        self.want = PoolParameters(params=self.module.params)

    def read_facts(self):
        results = []
        collection = self.read_collection_from_device()
        for resource in collection:
            attrs = resource.attrs
            attrs['stats'] = self.read_stats_from_device(resource)
            params = PoolParameters(params=attrs)
            results.append(params)
        return results

    def read_collection_from_device(self):
        result = self.client.api.tm.gtm.pools.get_collection(
            requests_params=dict(
                params='expandSubcollections=true'
            )
        )
        return result


class WideIpFactManager(BaseManager):
    def exec_module(self):
        if self.version_is_less_than_12():
            manager = self.get_manager('untyped')
        else:
            manager = self.get_manager('typed')
        facts = manager.exec_module()
        result = dict(wide_ip=facts)
        return result

    def get_manager(self, type):
        if type == 'typed':
            return TypedWideIpFactManager(**self.kwargs)
        elif type == 'untyped':
            return UntypedWideIpFactManager(**self.kwargs)


class TypedWideIpFactManager(TypedManager):
    def __init__(self, *args, **kwargs):
        self.client = kwargs.get('client', None)
        self.module = kwargs.get('module', None)
        super(TypedWideIpFactManager, self).__init__(**kwargs)
        self.want = WideIpParameters(params=self.module.params)

    def read_facts(self, collection):
        results = []
        collection = self.read_collection_from_device(collection)
        for resource in collection:
            attrs = resource.attrs
            params = WideIpParameters(params=attrs)
            results.append(params)
        return results

    def read_collection_from_device(self, collection_name):
        wideips = self.client.api.tm.gtm.wideips
        collection = getattr(wideips, collection_name)
        result = collection.get_collection(
            requests_params=dict(
                params='expandSubcollections=true'
            )
        )
        return result


class UntypedWideIpFactManager(UntypedManager):
    def __init__(self, *args, **kwargs):
        self.client = kwargs.get('client', None)
        self.module = kwargs.get('module', None)
        super(UntypedWideIpFactManager, self).__init__(**kwargs)
        self.want = WideIpParameters(params=self.module.params)

    def read_facts(self):
        results = []
        collection = self.read_collection_from_device()
        for resource in collection:
            attrs = resource.attrs
            params = WideIpParameters(params=attrs)
            results.append(params)
        return results

    def read_collection_from_device(self):
        result = self.client.api.tm.gtm.wideips.get_collection(
            requests_params=dict(
                params='expandSubcollections=true'
            )
        )
        return result


class ServerFactManager(UntypedManager):
    def __init__(self, *args, **kwargs):
        self.client = kwargs.get('client', None)
        self.module = kwargs.get('module', None)
        super(ServerFactManager, self).__init__(**kwargs)
        self.want = ServerParameters(params=self.module.params)

    def exec_module(self):
        facts = super(ServerFactManager, self).exec_module()
        result = dict(server=facts)
        return result

    def read_facts(self):
        results = []
        collection = self.read_collection_from_device()
        for resource in collection:
            attrs = resource.attrs
            params = ServerParameters(params=attrs)
            results.append(params)
        return results

    def read_collection_from_device(self):
        result = self.client.api.tm.gtm.servers.get_collection(
            requests_params=dict(
                params='expandSubcollections=true'
            )
        )
        return result


class ModuleManager(object):
    def __init__(self, *args, **kwargs):
        self.module = kwargs.get('module', None)
        self.client = kwargs.get('client', None)
        self.kwargs = kwargs
        self.want = Parameters(params=self.module.params)

    def exec_module(self):
        if not self.gtm_provisioned():
            raise F5ModuleError(
                "GTM must be provisioned to use this module."
            )

        if 'all' in self.want.include:
            names = ['pool', 'wide_ip', 'server']
        else:
            names = self.want.include
        managers = [self.get_manager(name) for name in names]
        result = self.execute_managers(managers)
        if result:
            result['changed'] = True
        else:
            result['changed'] = False
        self._announce_deprecations()
        return result

    def _announce_deprecations(self):
        warnings = []
        if self.want:
            warnings += self.want._values.get('__warnings', [])
        for warning in warnings:
            self.module.deprecate(
                msg=warning['msg'],
                version=warning['version']
            )

    def execute_managers(self, managers):
        results = dict()
        for manager in managers:
            result = manager.exec_module()
            results.update(result)
        return results

    def get_manager(self, which):
        if 'pool' == which:
            return PoolFactManager(**self.kwargs)
        if 'wide_ip' == which:
            return WideIpFactManager(**self.kwargs)
        if 'server' == which:
            return ServerFactManager(**self.kwargs)

    def gtm_provisioned(self):
        resource = self.client.api.tm.sys.dbs.db.load(
            name='provisioned.cpu.gtm'
        )
        if int(resource.value) == 0:
            return False
        return True


class ArgumentSpec(object):
    def __init__(self):
        self.supports_check_mode = False
        argument_spec = dict(
            include=dict(
                type='list',
                choices=[
                    'pool',
                    'wide_ip',
                    'server',
                ],
                required=True
            ),
            filter=dict()
        )
        self.argument_spec = {}
        self.argument_spec.update(f5_argument_spec)
        self.argument_spec.update(argument_spec)


def main():
    spec = ArgumentSpec()

    module = AnsibleModule(
        argument_spec=spec.argument_spec,
        supports_check_mode=spec.supports_check_mode
    )
    if not HAS_F5SDK:
        module.fail_json(msg="The python f5-sdk module is required")

    client = F5Client(**module.params)

    try:
        mm = ModuleManager(module=module, client=client)
        results = mm.exec_module()
        module.exit_json(**results)
    except F5ModuleError as ex:
        module.fail_json(msg=str(ex))


if __name__ == '__main__':
    main()