Adds bigip_trunk (#39208)

This patch adds a new module for managing trunks on a bigip
pull/39211/head
Tim Rupp 7 years ago committed by GitHub
parent 3b11def7d0
commit 37e114756d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -0,0 +1,513 @@
#!/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': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = r'''
---
module: bigip_trunk
short_description: Manage trunks on a BIG-IP
description:
- Manages trunks on a BIG-IP.
version_added: 2.6
options:
name:
description:
- Specifies the name of the trunk.
required: True
interfaces:
description:
- The interfaces that are part of the trunk.
- To clear the list of interfaces, specify an empty list.
link_selection_policy:
description:
- Specifies, once the trunk is configured, the policy that the trunk uses to determine
which member link (interface) can handle new traffic.
- When creating a new trunk, if this value is not specific, the default is C(auto).
- When C(auto), specifies that the system automatically determines which interfaces
can handle new traffic. For the C(auto) option, the member links must all be the
same media type and speed.
- When C(maximum-bandwidth), specifies that the system determines which interfaces
can handle new traffic based on the members' maximum bandwidth.
choices:
- auto
- maximum-bandwidth
frame_distribution_hash:
description:
- Specifies the basis for the hash that the system uses as the frame distribution
algorithm. The system uses the resulting hash to determine which interface to
use for forwarding traffic.
- When creating a new trunk, if this parameter is not specified, the default is
C(source-destination-ip).
- When C(source-destination-mac), specifies that the system bases the hash on the
combined MAC addresses of the source and the destination.
- When C(destination-mac), specifies that the system bases the hash on the MAC
address of the destination.
- When C(source-destination-ip), specifies that the system bases the hash on the
combined IP addresses of the source and the destination.
choices:
- destination-mac
- source-destination-ip
- source-destination-mac
lacp_enabled:
description:
- When C(yes), specifies that the system supports the link aggregation control
protocol (LACP), which monitors the trunk by exchanging control packets over
the member links to determine the health of the links.
- If LACP detects a failure in a member link, it removes the link from the link
aggregation.
- When creating a new trunk, if this parameter is not specified, LACP is C(no).
- LACP is disabled by default for backward compatibility. If this does not apply
to your network, we recommend that you enable LACP.
type: bool
lacp_mode:
description:
- Specifies the operation mode for link aggregation control protocol (LACP),
if LACP is enabled for the trunk.
- When creating a new trunk, if this parameter is not specified, the default
is C(active).
- When C(active), specifies that the system periodically sends control packets
regardless of whether the partner system has issued a request.
- When C(passive), specifies that the system sends control packets only when
the partner system has issued a request.
choices:
- active
- passive
lacp_timeout:
description:
- Specifies the rate at which the system sends the LACP control packets.
- When creating a new trunk, if this parameter is not specified, the default is
C(long).
- When C(long), specifies that the system sends an LACP control packet every 30 seconds.
- When C(short), specifies that the system sends an LACP control packet every 1 seconds.
choices:
- long
- short
state:
description:
- When C(present), ensures that the resource exists.
- When C(absent), ensures the resource is removed.
default: present
choices:
- present
- absent
extends_documentation_fragment: f5
author:
- Tim Rupp (@caphrim007)
'''
EXAMPLES = r'''
- name: Create a ...
bigip_trunk:
name: foo
password: secret
server: lb.mydomain.com
state: present
user: admin
delegate_to: localhost
'''
RETURN = r'''
param1:
description: The new param1 value of the resource.
returned: changed
type: bool
sample: true
param2:
description: The new param2 value of the resource.
returned: changed
type: string
sample: Foo is bar
'''
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.basic import env_fallback
try:
from library.module_utils.network.f5.bigip import HAS_F5SDK
from library.module_utils.network.f5.bigip import F5Client
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 cleanup_tokens
from library.module_utils.network.f5.common import fq_name
from library.module_utils.network.f5.common import f5_argument_spec
try:
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
except ImportError:
HAS_F5SDK = False
except ImportError:
from ansible.module_utils.network.f5.bigip import HAS_F5SDK
from ansible.module_utils.network.f5.bigip import F5Client
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import AnsibleF5Parameters
from ansible.module_utils.network.f5.common import cleanup_tokens
from ansible.module_utils.network.f5.common import fq_name
from ansible.module_utils.network.f5.common import f5_argument_spec
try:
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
except ImportError:
HAS_F5SDK = False
class Parameters(AnsibleF5Parameters):
api_map = {
'lacpMode': 'lacp_mode',
'lacpTimeout': 'lacp_timeout',
'linkSelectPolicy': 'link_selection_policy',
'distributionHash': 'frame_distribution_hash',
'lacp': 'lacp_enabled'
}
api_attributes = [
'lacp',
'lacpMode',
'lacpTimeout',
'linkSelectPolicy',
'distributionHash',
'interfaces',
]
returnables = [
'lacp_mode',
'lacp_timeout',
'link_selection_policy',
'frame_distribution_hash',
'lacp_enabled',
'interfaces'
]
updatables = [
'lacp_mode',
'lacp_timeout',
'link_selection_policy',
'frame_distribution_hash',
'lacp_enabled',
'interfaces'
]
class ApiParameters(Parameters):
@property
def lacp_enabled(self):
if self._values['lacp_enabled'] is None:
return None
if self._values['lacp_enabled'] == 'enabled':
return True
return False
@property
def interfaces(self):
if self._values['interfaces'] is None:
return None
result = list(set(self._values['interfaces']))
result.sort()
return result
class ModuleParameters(Parameters):
@property
def frame_distribution_hash(self):
if self._values['frame_distribution_hash'] is None:
return None
elif self._values['frame_distribution_hash'] == 'source-destination-ip':
return 'src-dst-ipport'
elif self._values['frame_distribution_hash'] == 'source-destination-mac':
return 'src-dst-mac'
elif self._values['frame_distribution_hash'] == 'destination-mac':
return 'dst-mac'
@property
def interfaces(self):
if self._values['interfaces'] is None:
return None
if len(self._values['interfaces']) == 1 and self._values['interfaces'][0] == '':
return ''
result = [str(x) for x in self._values['interfaces']]
result = list(set(result))
result.sort()
return result
class Changes(Parameters):
def to_return(self):
result = {}
try:
for returnable in self.returnables:
result[returnable] = getattr(self, returnable)
result = self._filter_params(result)
except Exception:
pass
return result
class UsableChanges(Changes):
@property
def lacp_enabled(self):
if self._values['lacp_enabled'] is None:
return None
if self._values['lacp_enabled']:
return 'enabled'
return 'disabled'
class ReportableChanges(Changes):
@property
def frame_distribution_hash(self):
if self._values['frame_distribution_hash'] is None:
return None
elif self._values['frame_distribution_hash'] == 'src-dst-ipport':
return 'source-destination-ip'
elif self._values['frame_distribution_hash'] == 'src-dst-mac':
return 'source-destination-mac'
elif self._values['frame_distribution_hash'] == 'dst-mac':
return 'destination-mac'
@property
def lacp_enabled(self):
if self._values['lacp_enabled'] is None:
return None
if self._values['lacp_enabled'] == 'enabled':
return True
return False
class Difference(object):
def __init__(self, want, have=None):
self.want = want
self.have = have
def compare(self, param):
try:
result = getattr(self, param)
return result
except AttributeError:
return self.__default(param)
def __default(self, param):
attr1 = getattr(self.want, param)
try:
attr2 = getattr(self.have, param)
if attr1 != attr2:
return attr1
except AttributeError:
return attr1
@property
def interfaces(self):
if self.want.interfaces is None:
return None
if self.have.interfaces is None and self.want.interfaces == '':
return None
if self.have.interfaces is not None and self.want.interfaces == '':
return []
if self.have.interfaces is None:
return self.want.interfaces
if set(self.want.interfaces) != set(self.have.interfaces):
return self.want.interfaces
class ModuleManager(object):
def __init__(self, *args, **kwargs):
self.module = kwargs.get('module', None)
self.client = kwargs.get('client', None)
self.want = ModuleParameters(params=self.module.params)
self.have = ApiParameters()
self.changes = UsableChanges()
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 = UsableChanges(params=changed)
def _update_changed_options(self):
diff = Difference(self.want, self.have)
updatables = Parameters.updatables
changed = dict()
for k in updatables:
change = diff.compare(k)
if change is None:
continue
else:
if isinstance(change, dict):
changed.update(change)
else:
changed[k] = change
if changed:
self.changes = UsableChanges(params=changed)
return True
return False
def should_update(self):
result = self._update_changed_options()
if result:
return True
return False
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))
reportable = ReportableChanges(params=self.changes.to_return())
changes = reportable.to_return()
result.update(**changes)
result.update(dict(changed=changed))
self._announce_deprecations(result)
return result
def _announce_deprecations(self, result):
warnings = result.pop('__warnings', [])
for warning in warnings:
self.client.module.deprecate(
msg=warning['msg'],
version=warning['version']
)
def present(self):
if self.exists():
return self.update()
else:
return self.create()
def exists(self):
result = self.client.api.tm.net.trunks.trunk.exists(
name=self.want.name
)
return result
def update(self):
self.have = self.read_current_from_device()
if not self.should_update():
return False
if self.module.check_mode:
return True
self.update_on_device()
return True
def remove(self):
if self.module.check_mode:
return True
self.remove_from_device()
if self.exists():
raise F5ModuleError("Failed to delete the resource.")
return True
def create(self):
if self.want.link_selection_policy is None:
self.want.update({'link_selection_policy': 'auto'})
if self.want.frame_distribution_hash is None:
self.want.update({'frame_distribution_hash': 'source-destination-ip'})
if self.want.lacp_enabled is None:
self.want.update({'lacp_enabled': False})
if self.want.lacp_mode is None:
self.want.update({'lacp_mode': 'active'})
if self.want.lacp_timeout is None:
self.want.update({'lacp_timeout': 'long'})
self._set_changed_options()
if self.module.check_mode:
return True
self.create_on_device()
return True
def create_on_device(self):
params = self.changes.api_params()
self.client.api.tm.net.trunks.trunk.create(
name=self.want.name,
**params
)
def update_on_device(self):
params = self.changes.api_params()
resource = self.client.api.tm.net.trunks.trunk.load(
name=self.want.name
)
resource.modify(**params)
def absent(self):
if self.exists():
return self.remove()
return False
def remove_from_device(self):
resource = self.client.api.tm.net.trunks.trunk.load(
name=self.want.name
)
if resource:
resource.delete()
def read_current_from_device(self):
resource = self.client.api.tm.net.trunks.trunk.load(
name=self.want.name
)
result = resource.attrs
return ApiParameters(params=result)
class ArgumentSpec(object):
def __init__(self):
self.supports_check_mode = True
argument_spec = dict(
name=dict(required=True),
interfaces=dict(type='list'),
link_selection_policy=dict(
choices=['auto', 'maximum-bandwidth']
),
frame_distribution_hash=dict(
choices=['destination-mac', 'source-destination-ip', 'source-destination-mac']
),
lacp_enabled=dict(type='bool'),
lacp_mode=dict(choices=['active', 'passive']),
lacp_timeout=dict(choices=['short', 'long']),
state=dict(
default='present',
choices=['absent', 'present']
)
)
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")
try:
client = F5Client(**module.params)
mm = ModuleManager(module=module, client=client)
results = mm.exec_module()
cleanup_tokens(client)
module.exit_json(**results)
except F5ModuleError as ex:
cleanup_tokens(client)
module.fail_json(msg=str(ex))
if __name__ == '__main__':
main()

@ -0,0 +1,141 @@
# -*- 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
import os
import json
import pytest
import sys
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 Mock
from ansible.compat.tests.mock import patch
from ansible.module_utils.basic import AnsibleModule
try:
from library.modules.bigip_trunk import ApiParameters
from library.modules.bigip_trunk import ModuleParameters
from library.modules.bigip_trunk import ModuleManager
from library.modules.bigip_trunk import ArgumentSpec
from library.module_utils.network.f5.common import F5ModuleError
from library.module_utils.network.f5.common import iControlUnexpectedHTTPError
from test.unit.modules.utils import set_module_args
except ImportError:
try:
from ansible.modules.network.f5.bigip_trunk import ApiParameters
from ansible.modules.network.f5.bigip_trunk import ModuleParameters
from ansible.modules.network.f5.bigip_trunk import ModuleManager
from ansible.modules.network.f5.bigip_trunk import ArgumentSpec
from ansible.module_utils.network.f5.common import F5ModuleError
from ansible.module_utils.network.f5.common import iControlUnexpectedHTTPError
from units.modules.utils import set_module_args
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 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',
interfaces=[
'1.3', '1.1'
],
link_selection_policy='auto',
frame_distribution_hash='destination-mac',
lacp_enabled=True,
lacp_mode='active',
lacp_timeout='long'
)
p = ModuleParameters(params=args)
assert p.name == 'foo'
assert p.interfaces == ['1.1', '1.3']
assert p.link_selection_policy == 'auto'
assert p.frame_distribution_hash == 'dst-mac'
assert p.lacp_enabled is True
assert p.lacp_mode == 'active'
assert p.lacp_timeout == 'long'
def test_api_parameters(self):
args = load_fixture('load_tm_net_trunk_1.json')
p = ApiParameters(params=args)
assert p.name == 'foo'
assert p.frame_distribution_hash == 'dst-mac'
assert p.lacp_enabled is False
assert p.lacp_mode == 'active'
assert p.lacp_timeout == 'long'
assert p.interfaces == ['1.3']
assert p.link_selection_policy == 'maximum-bandwidth'
@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(self, *args):
set_module_args(dict(
name='foo',
interfaces=[
'1.3', '1.1'
],
link_selection_policy='auto',
frame_distribution_hash='destination-mac',
lacp_enabled=True,
lacp_mode='active',
lacp_timeout='long',
server='localhost',
password='password',
user='admin'
))
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode
)
# Override methods to force specific logic in the module to happen
mm = ModuleManager(module=module)
mm.create_on_device = Mock(return_value=True)
mm.exists = Mock(return_value=False)
results = mm.exec_module()
assert results['changed'] is True
assert results['link_selection_policy'] == 'auto'
assert results['frame_distribution_hash'] == 'destination-mac'
assert results['lacp_enabled'] is True
assert results['lacp_mode'] == 'active'
assert results['lacp_timeout'] == 'long'
Loading…
Cancel
Save