Support two member cluster only in first clustering release

Issues:
Fixes #471

Problem:
In order to minimize feature creep and the ability for users to shoot
themselves in the foot, I would like to limit clustering support to
handle only two devices. This will be reflected in the code with tests
and documentation.

Analysis:
Modified the code to only allow up to four devices to be clustered, yet the
functional tests are there for up to two devices. Four devices is not yet
supported. This will be made clear in the customer-facing documentation.
It is already clear in the code documentation.

Tests:
All clustering tests pass against 11.6 and 12.0 VE images

Author: Paul Breaux

f5/multi_device/cluster/__init__.py

@@ -1,3 +1,4 @@
+# coding=utf-8
 # Copyright 2016 F5 Networks Inc.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,9 +19,9 @@
 
 Definitions:
     Cluster: The manager of the TrustDomain and DeviceGroup objects.
-    TrustDomain: a group of BIG-IP devices that have exchanged certificates
+    TrustDomain: a group of BIG-IP® devices that have exchanged certificates
                  and trust one another
-    DeviceGroup: a group of BIG-IP device that sync configuration data and
+    DeviceGroup: a group of BIG-IP® device that sync configuration data and
                  failover connections.
 
 Clustering is broken down into three component parts: a cluster manager, a
@@ -33,6 +34,9 @@
 to the group. After this step, a cluster exists.
 
 Currently the only supported type of cluster is a 'sync-failover' cluster.
+The number of devices supported officially is currently two, for an
+active-standby cluster, but the code below can accommodate a four-member
+cluster.
 
 Methods:
 
@@ -85,7 +89,7 @@
 
 
 class ClusterManager(object):
-    '''Manage a cluster of BigIPs.
+    '''Manage a cluster of BIG-IP® devices.
 
     This is accomplished with REST URI calls only, but some operations are
     only permitted via tmsh commands (such as adding cm/trust-domain peers).
@@ -120,12 +124,12 @@ def __getattr__(self, name):
         raise AttributeError(name)
 
     def _check_device_number(self, devices):
-        '''Check if number of devices is < 2 or > 8.
+        '''Check if number of devices is between 2 and 4
 
         :param kwargs: dict -- keyword args in dict
         '''
 
-        if len(devices) < 2 or len(devices) > 8:
+        if len(devices) < 2 or len(devices) > 4:
             msg = 'The number of devices to cluster is not supported.'
             raise ClusterNotSupported(msg)
 
@@ -144,7 +148,7 @@ def manage_extant(self, **kwargs):
         self.cluster = Cluster(**kwargs)
 
     def create(self, **kwargs):
-        '''Create a cluster of BigIP devices.
+        '''Create a cluster of BIG-IP® devices.
 
         :param kwargs: dict -- keyword arguments for cluster manager
         '''
@@ -163,7 +167,7 @@ def create(self, **kwargs):
         self.cluster = Cluster(**kwargs)
 
     def teardown(self):
-        '''Teardown the cluster of BigIP devices.'''
+        '''Teardown the cluster of BIG-IP® devices.'''
 
         print('Tearing down the cluster...')
         self.device_group.teardown()

f5/multi_device/device_group.py

@@ -79,8 +79,14 @@ class DeviceGroup(object):
     above and also may take some other action to enforce the expected state,
     such as syncing config.
 
+    The pollster is used heavliy here for 'check' and 'get' methods, since we
+    are often waiting for the device or devices to respond to some action.
+
     Example:
 
+        * dg = self._get_device_group()
+        * self._check_all_devices_in_sync()
+        * self.ensure_all_devices_in_sync()
 
     '''
 
@@ -189,7 +195,8 @@ def _get_device_names_in_group(self):
         dg = pollster(self._get_device_group)(self.devices[0])
         members = dg.devices_s.get_collection()
         for member in members:
-            device_names.append(member.name)
+            member_name = member.name.replace('/%s/' % self.partition, '')
+            device_names.append(member_name)
         return device_names
 
     def _get_device_group(self, device):
@@ -222,9 +229,9 @@ def _add_device_to_device_group(self, device):
 
         device_name = get_device_info(device).name
         dg = pollster(self._get_device_group)(device)
+        print('Adding following device to group: ' + device_name)
         dg.devices_s.devices.create(name=device_name, partition=self.partition)
         pollster(self._check_device_exists_in_device_group)(device_name)
-        print('added following device to group: ' + device_name)
 
     def _check_device_exists_in_device_group(self, device_name):
         '''Check whether a device exists in the device group
@@ -235,25 +242,14 @@ def _check_device_exists_in_device_group(self, device_name):
         dg = self._get_device_group(self.devices[0])
         dg.devices_s.devices.load(name=device_name, partition=self.partition)
 
-    def _delete_all_devices_from_device_group(self, device):
-        '''Remove all devices from device service cluster group.
-
-        :param device: ManagementRoot object -- device from which to remove
-        '''
-
-        dg = pollster(self._get_device_group)(device)
-        dg_devices = dg.devices_s.get_collection()
-        for device in dg_devices:
-            device.delete()
-        return dg
-
     def _delete_device_from_device_group(self, device):
         '''Remove device from device service cluster group.
 
         :param device: ManagementRoot object -- device to delete from group
         '''
 
         device_name = get_device_info(device).name
+        print('Deleting following device from group: %s ' % device_name)
         dg = pollster(self._get_device_group)(device)
         device_to_remove = dg.devices_s.devices.load(
             name=device_name, partition=self.partition

f5/multi_device/test/test_device_group.py

@@ -17,6 +17,7 @@
 from f5.multi_device.exceptions import DeviceGroupNotSupported
 from f5.multi_device.exceptions import DeviceGroupOperationNotSupported
 from f5.multi_device.exceptions import MissingRequiredDeviceGroupParameter
+from f5.multi_device.exceptions import UnexpectedDeviceGroupDevices
 from f5.multi_device.exceptions import UnexpectedDeviceGroupState
 from f5.multi_device.exceptions import UnexpectedDeviceGroupType
 
@@ -28,6 +29,7 @@ class MockDeviceInfo(object):
     def __init__(self, name):
         self.name = name
         self.selfDevice = 'true'
+        self.type = 'sync-failover'
 
 
 class FakeActDevice(object):
@@ -162,3 +164,40 @@ def test__check_all_devices_in_sync_unexpected(DeviceGroupCreateNew):
         dg._check_all_devices_in_sync()
     assert "Expected all devices in group to have 'In Sync' status." == \
         ex.value.message
+
+
+@mock.patch(
+    'f5.multi_device.device_group.DeviceGroup._get_device_group',
+    return_value=MockDeviceInfo('test')
+)
+@mock.patch(
+    'f5.multi_device.device_group.DeviceGroup._get_device_names_in_group',
+    return_value=['test', 'test', 'test', 'test']
+)
+@mock.patch(
+    'f5.multi_device.device_group.DeviceGroup.ensure_all_devices_in_sync'
+)
+def test_validate(mock_get_dg, mock_dev_map, mock_in_sync, BigIPs):
+    dg = DeviceGroup(
+        devices=BigIPs, device_group_name='test',
+        device_group_type='sync-failover', device_group_partition='Common')
+    assert dg.devices == BigIPs
+    assert dg.name == 'test'
+    assert dg.type == 'sync-failover'
+    assert dg.partition == 'Common'
+    assert dg.ensure_all_devices_in_sync.call_args == mock.call()
+
+
+@mock.patch(
+    'f5.multi_device.device_group.DeviceGroup._get_device_group',
+    return_value=MockDeviceInfo('test')
+)
+@mock.patch(
+    'f5.multi_device.device_group.DeviceGroup._get_device_names_in_group',
+)
+def test_validate_given_devices_dont_match(mock_get_dg, mock_dev_map, BigIPs):
+    with pytest.raises(UnexpectedDeviceGroupDevices) as ex:
+        DeviceGroup(
+            devices=BigIPs, device_group_name='device_not_found',
+            device_group_type='sync-failover', device_group_partition='Common')
+    assert 'Given devices does not match queried devices.' in ex.value.message

f5/multi_device/test/test_trust_domain.py

@@ -14,6 +14,7 @@
 #
 
 from f5.multi_device.cluster import TrustDomain
+from f5.multi_device.exceptions import DeviceAlreadyInTrustDomain
 from f5.multi_device.exceptions import DeviceNotTrusted
 
 import mock
@@ -54,3 +55,77 @@ def test_validate_device_not_trusted(TrustDomainCreateNew):
         td.validate()
     assert "'test' is not trusted by 'test', which trusts: []" in \
         ex.value.message
+
+
+@mock.patch('f5.multi_device.trust_domain.TrustDomain._set_attributes')
+@mock.patch('f5.multi_device.trust_domain.TrustDomain.validate')
+def test___init__(mock_set_attr, mock_validate, BigIPs):
+    mock_bigips = BigIPs
+    td = TrustDomain(devices=mock_bigips)
+    assert td._set_attributes.call_args == mock.call(devices=mock_bigips)
+
+
+def test__set_attributes(BigIPs):
+    mock_bigips = BigIPs
+    td = TrustDomain()
+    td._set_attributes(devices=mock_bigips, partition='test')
+    assert td.devices == mock_bigips
+    assert td.partition == 'test'
+    assert td.device_group_name == 'device_trust_group'
+    assert td.device_group_type == 'sync-only'
+
+
+@mock.patch('f5.multi_device.trust_domain.TrustDomain._add_trustee')
+@mock.patch('f5.multi_device.trust_domain.pollster')
+def test_create(mock_add_trustee, mock_pollster, TrustDomainCreateNew):
+    td, mock_bigips = TrustDomainCreateNew
+    td.create(devices=mock_bigips, partition='test')
+    assert td.devices == mock_bigips
+    assert td.partition == 'test'
+    assert td._add_trustee.call_args_list == \
+        [
+            mock.call(mock_bigips[1]),
+            mock.call(mock_bigips[2]),
+            mock.call(mock_bigips[3])
+        ]
+
+
+@mock.patch('f5.multi_device.trust_domain.TrustDomain._add_trustee')
+@mock.patch('f5.multi_device.trust_domain.pollster')
+@mock.patch('f5.multi_device.trust_domain.TrustDomain._remove_trustee')
+def test_teardown(
+        mock_add_trustee, mock_pollster, mock_rem_trustee, TrustDomainCreateNew
+):
+    td, mock_bigips = TrustDomainCreateNew
+    td.create(devices=mock_bigips, partition='test')
+    td.teardown()
+    assert td.domain == {}
+    assert td._remove_trustee.call_args_list == \
+        [
+            mock.call(mock_bigips[0]),
+            mock.call(mock_bigips[1]),
+            mock.call(mock_bigips[2]),
+            mock.call(mock_bigips[3])
+        ]
+
+
+@mock.patch('f5.multi_device.trust_domain.get_device_info')
+@mock.patch('f5.multi_device.trust_domain.TrustDomain._modify_trust')
+def test__add_trustee(mock_dev_info, mock_mod_trust, TrustDomainCreateNew):
+    td, mock_bigips = TrustDomainCreateNew
+    td._set_attributes(devices=mock_bigips, partition='test')
+    td._add_trustee(mock_bigips[1])
+    assert td._modify_trust.call_args == \
+        mock.call(mock_bigips[0], td._get_add_trustee_cmd, mock_bigips[1])
+
+
+@mock.patch('f5.multi_device.trust_domain.TrustDomain._modify_trust')
+def test__add_trustee_already_in_domain(
+        mock_mod_trust, TrustDomainCreateNew
+):
+    td, mock_bigips = TrustDomainCreateNew
+    td._set_attributes(devices=mock_bigips, partition='test')
+    td.domain = {'test': 'device'}
+    with pytest.raises(DeviceAlreadyInTrustDomain) as ex:
+        td._add_trustee(mock_bigips[1])
+    assert "Device: 'test' is already in this trust domain" in ex.value.message

f5/multi_device/trust_domain.py

@@ -54,7 +54,7 @@
 
 
 class TrustDomain(object):
-    '''Manages the trusted peers of a BigIP device.'''
+    '''Manages the trust domain of a BIG-IP® device.'''
 
     iapp_actions = {'definition': {'implementation': None, 'presentation': ''}}
 
@@ -234,6 +234,9 @@ def _deploy_iapp(self, iapp_name, actions, deploying_device):
         tmpl = deploying_device.tm.sys.applications.templates.template
         serv = deploying_device.tm.sys.applications.services.service
         tmpl.create(name=iapp_name, partition=self.partition, actions=actions)
+        pollster(deploying_device.tm.sys.applications.templates.template.load)(
+            name=iapp_name, partition=self.partition
+        )
         serv.create(
             name=iapp_name,
             partition=self.partition,

requirements.test.txt

@@ -2,6 +2,7 @@
 -e .
 
 # Test Requirements
+git+https://github.com/F5Networks/pytest-symbols.git
 hacking==0.10.2
 mock==1.3.0
 pytest==2.9.1

test/functional/cluster/test_cluster.py

@@ -45,21 +45,12 @@ def BigIPSetup():
         symbols.bigip2['netloc'],
         symbols.bigip2['username'],
         symbols.bigip2['password'])
-    c = ManagementRoot(
-        symbols.bigip3['netloc'],
-        symbols.bigip3['username'],
-        symbols.bigip3['password'])
-    d = ManagementRoot(
-        symbols.bigip4['netloc'],
-        symbols.bigip4['username'],
-        symbols.bigip4['password']
-    )
-    return a, b, c, d
+    return a, b
 
 
 @pytest.fixture
 def TwoBigIPTeardownSyncFailover(request, BigIPSetup):
-    a, b, c, d = BigIPSetup
+    a, b = BigIPSetup
     bigip_list = [a, b]
 
     def teardown_cluster():
@@ -74,8 +65,8 @@ def teardown_cluster():
 
 @pytest.fixture
 def ThreeBigIPTeardownSyncFailover(request, BigIPSetup):
-    a, b, c, d = BigIPSetup
-    bigip_list = [a, b, c]
+    a, b = BigIPSetup
+    bigip_list = [a, b]
 
     def teardown_cluster():
         cm = ClusterManager(
@@ -94,44 +85,20 @@ def teardown_cluster():
                     "'run_cluster_tests: True'")
 class TestCluster(object):
     def test_new_failover_cluster_two_member(self, BigIPSetup):
-        a, b, c, d = BigIPSetup
+        a, b = BigIPSetup
         bigip_list = [a, b]
-        cm = ClusterManager()
-
-        cm.create(
-            devices=bigip_list,
-            device_group_name=DEVICE_GROUP_NAME,
-            device_group_partition=PARTITION,
-            device_group_type='sync-failover')
-        cm.teardown()
-
-    def test_new_failover_cluster_three_member(self, BigIPSetup):
-        a, b, c, d = BigIPSetup
-        bigip_list = [a, b, c]
-        cm = ClusterManager()
-
-        cm.create(
-            devices=bigip_list,
-            device_group_name=DEVICE_GROUP_NAME,
-            device_group_partition=PARTITION,
-            device_group_type='sync-failover')
-        cm.teardown()
+        for x in range(5):
+            cm = ClusterManager()
 
-    def test_new_failover_cluster_four_member(self, BigIPSetup):
-        a, b, c, d = BigIPSetup
-        bigip_list = [a, b, c, d]
-        cm = ClusterManager()
-
-        cm.create(
-            devices=bigip_list,
-            device_group_name=DEVICE_GROUP_NAME,
-            device_group_partition=PARTITION,
-            device_group_type='sync-failover'
-        )
-        cm.teardown()
+            cm.create(
+                devices=bigip_list,
+                device_group_name=DEVICE_GROUP_NAME,
+                device_group_partition=PARTITION,
+                device_group_type='sync-failover')
+            cm.teardown()
 
     def test_existing_failover_cluster(self, BigIPSetup):
-        a, b, c, d = BigIPSetup
+        a, b = BigIPSetup
         bigip_list = [a, b]
         cm = ClusterManager()
         kwargs = {'devices': bigip_list,