mirror of
https://github.com/ansible-collections/community.general.git
synced 2024-09-14 20:13:21 +02:00
986 lines
31 KiB
Python
986 lines
31 KiB
Python
#!/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.network.f5.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.network.f5.common import F5ModuleError
|
|
from ansible_collections.f5networks.f5_modules.plugins.module_utils.network.f5.common import AnsibleF5Parameters
|
|
from ansible_collections.f5networks.f5_modules.plugins.module_utils.network.f5.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()
|