Merge pull request #486 from wojtek0806/fixes_378_474_452

Multibugfixes_ #378, #452, #474, #481, #484, #485, #491

Author: zancas

f5/bigip/mixins.py

@@ -16,9 +16,10 @@
 #
 # NOTE:  Code taken from Effective Python Item 26
 
-import logging
 
+from distutils.version import LooseVersion
 from f5.sdk_exception import F5SDKError
+import logging
 
 
 class InvalidCommand(F5SDKError):
@@ -117,10 +118,13 @@ def __getattr__(container, name):
 
     def _check_supported_versions(container, attribute):
         tmos_v = container._meta_data['bigip'].tmos_version
-        if tmos_v not in attribute._meta_data['supported_versions']:
+        minimum = attribute._meta_data['minimum_version']
+        if LooseVersion(tmos_v) < LooseVersion(minimum):
             error = "There was an attempt to access API which " \
                     "has not been implemented or supported " \
-                    "in the device's TMOS version: {}".format(tmos_v)
+                    "in the device's TMOS version: {}. "\
+                    "Minimum TMOS version supported is {}".format(
+                        tmos_v, minimum)
             raise UnsupportedTmosVersion(error)
 
 
@@ -250,7 +254,9 @@ def _exec_cmd(self, command, **kwargs):
         '''
 
         kwargs['command'] = command
+        self._check_exclusive_parameters(**kwargs)
         requests_params = self._handle_requests_params(kwargs)
+        self._check_command_parameters(**kwargs)
         session = self._meta_data['bigip']._meta_data['icr_session']
         response = session.post(
             self._meta_data['uri'], json=kwargs, **requests_params)

f5/bigip/resource.py

@@ -87,12 +87,18 @@
 from requests.exceptions import HTTPError
 
 
-class MissingUpdateParameter(F5SDKError):
-    """Raises this when update requires specific
+class MissingRequiredCommandParameter(F5SDKError):
+    """Various values MUST be provided to execute a command."""
+    pass
 
-    parameters together
 
-    """
+class ExclusiveAttributesPresent(F5SDKError):
+    """Raises this when exclusive attributes are present."""
+    pass
+
+
+class MissingUpdateParameter(F5SDKError):
+    """Raises this when update requires specific parameters together."""
     pass
 
 
@@ -173,7 +179,13 @@ def __init__(self, container):
         self._set_meta_data_uri()
         # Supported versions for each class will be defined here.
         # List can be modified downstream in each sub-class
-        self._meta_data['supported_versions'] = set(['11.6.0', '12.0.0'])
+        self._meta_data['minimum_version'] = '11.6.0'
+        # Commands you can run on a resource or collection, we define it here
+        self._meta_data['allowed_commands'] = []
+        # Define required command parameters
+        self._meta_data['required_command_parameters'] = set()
+        # You can't have more than one of the attributes in any of these sets.
+        self._meta_data['exclusive_attributes'] = []
 
     def _set_meta_data_uri(self):
         base_uri = self.__class__.__name__.lower()
@@ -190,19 +202,41 @@ def _set_meta_data_uri(self):
         self._meta_data['uri'] = final_uri
 
     def _check_load_parameters(self, **kwargs):
-        '''Params given to load should at least satisfy required params.
+        """Params given to load should at least satisfy required params.
 
         :params: kwargs
         :raises: MissingRequiredReadParameter
-        '''
-        key_set = set(kwargs.keys())
-        required_minus_received =\
-            self._meta_data['required_load_parameters'] - key_set
-        if required_minus_received != set():
-            error_message = 'Missing required params: %r'\
-                % required_minus_received
+        """
+        rset = self._meta_data['required_load_parameters']
+        check = self._missing_required_parameters(rset, **kwargs)
+        if check:
+            error_message = 'Missing required params: %s' % check
             raise MissingRequiredReadParameter(error_message)
 
+    def _check_create_parameters(self, **kwargs):
+        """Params given to create should satisfy required params.
+
+        :params: kwargs
+        :raises: MissingRequiredCreateParameter
+        """
+        rset = self._meta_data['required_creation_parameters']
+        check = self._missing_required_parameters(rset, **kwargs)
+        if check:
+            error_message = 'Missing required params: %s' % check
+            raise MissingRequiredCreationParameter(error_message)
+
+    def _check_command_parameters(self, **kwargs):
+        """Params given to exec_cmd should satisfy required params.
+
+        :params: kwargs
+        :raises: MissingRequiredCommandParameter
+        """
+        rset = self._meta_data['required_command_parameters']
+        check = self._missing_required_parameters(rset, **kwargs)
+        if check:
+            error_message = 'Missing required params: %s' % check
+            raise MissingRequiredCommandParameter(error_message)
+
     def _local_update(self, rdict):
         """Call this with a response dictionary to update instance attrs.
 
@@ -295,6 +329,37 @@ def _handle_requests_params(self, kwargs):
             requests_params.update({'params': params})
         return requests_params
 
+    def _check_exclusive_parameters(self, **kwargs):
+        """Check for mutually exclusive attributes in kwargs.
+
+        :raises ExclusiveAttributesPresent
+        """
+        if len(self._meta_data['exclusive_attributes']) > 0:
+            attr_set = set(kwargs.keys())
+            ex_set = set(self._meta_data['exclusive_attributes'][0])
+            common_set = attr_set.intersection(ex_set)
+            if len(common_set) > 1:
+                cset = ', '.join(common_set)
+                error = 'Mutually exclusive arguments submitted. ' \
+                        'The following arguments cannot be set ' \
+                        'together: "%s".' % cset
+                raise ExclusiveAttributesPresent(error)
+
+    @staticmethod
+    def _missing_required_parameters(rqset, **kwargs):
+        """Helper function to do operation on sets.
+
+        Checks for any missing required parameters.
+        Returns non-empty or empty list. With empty
+        list being False.
+
+        ::returns list
+        """
+        key_set = set(kwargs.keys())
+        required_minus_received = rqset - key_set
+        if required_minus_received != set():
+            return list(required_minus_received)
+
     @property
     def raw(self):
         """Display the attributes that the current object has and their values.
@@ -362,8 +427,6 @@ def __init__(self, container):
         :param container: instance is an attribute of a ResourceBase container
         """
         super(ResourceBase, self).__init__(container)
-        # Commands you can run on a resource or collection, we define it here
-        self._meta_data['allowed_commands'] = []
 
     def _update(self, **kwargs):
         """wrapped with update, override that in a subclass to customize"""
@@ -603,8 +666,6 @@ def __init__(self, container):
         self._meta_data['required_creation_parameters'] = set(('name',))
         # Refresh fails without these.
         self._meta_data['required_load_parameters'] = set(('name',))
-        # You can't have more than one of the attrs in any of these sets.
-        self._meta_data['exclusive_attributes'] = []
         # You can't set these attributes, only 'read' them.
         self._meta_data['read_only_attributes'] = []
 
@@ -665,14 +726,9 @@ def _create(self, **kwargs):
                     "resource, the _meta_data['uri'] is %s and it should"\
                     " not be changed." % (self._meta_data['uri'])
             raise URICreationCollision(error)
+        self._check_exclusive_parameters(**kwargs)
         requests_params = self._handle_requests_params(kwargs)
-        key_set = set(kwargs.keys())
-        required_minus_received =\
-            self._meta_data['required_creation_parameters'] - key_set
-        if required_minus_received != set():
-            error_message = 'Missing required params: %r'\
-                % required_minus_received
-            raise MissingRequiredCreationParameter(error_message)
+        self._check_create_parameters(**kwargs)
 
         # Make convenience variable with short names for this method.
         _create_uri = self._meta_data['container']._meta_data['uri']

f5/bigip/test/test_resource.py

@@ -18,13 +18,16 @@
 
 from f5.bigip.resource import Collection
 from f5.bigip.resource import DeviceProvidesIncompatibleKey
+from f5.bigip.resource import ExclusiveAttributesPresent
 from f5.bigip.resource import GenerationMismatch
 from f5.bigip.resource import InvalidForceType
 from f5.bigip.resource import InvalidResource
 from f5.bigip.resource import KindTypeMismatch
+from f5.bigip.resource import MissingRequiredCommandParameter
 from f5.bigip.resource import MissingRequiredCreationParameter
 from f5.bigip.resource import MissingRequiredReadParameter
 from f5.bigip.resource import OrganizingCollection
+from f5.bigip.resource import PathElement
 from f5.bigip.resource import RequestParamKwargCollision
 from f5.bigip.resource import Resource
 from f5.bigip.resource import ResourceBase
@@ -96,7 +99,7 @@ def test_missing_required_creation_parameter(self):
         with pytest.raises(MissingRequiredCreationParameter) as MRCPEIO:
             r.create(partition="Common", name='CreateTest')
         assert MRCPEIO.value.message ==\
-            "Missing required params: set(['NONEMPTY'])"
+            "Missing required params: ['NONEMPTY']"
 
     def test_KindTypeMismatch(self):
         r = Resource(mock.MagicMock())
@@ -290,7 +293,7 @@ def test_missing_required_params(self):
         with pytest.raises(MissingRequiredReadParameter) as MRREIO:
             r.load(partition='Common', name='test_load')
         assert MRREIO.value.message ==\
-            "Missing required params: set(['IMPOSSIBLE'])"
+            "Missing required params: ['IMPOSSIBLE']"
 
     def test_requests_params_collision(self):
         r = Resource(mock.MagicMock())
@@ -443,3 +446,64 @@ def test_collection_s():
     }
     tc_s = Under_s(MC)
     assert tc_s._meta_data['uri'] == 'BASEURI/under/'
+
+
+class TestPathElement(object):
+
+    def test_missing_req_param_true(self):
+        p = PathElement(mock.MagicMock())
+        rqset = set(['FOOPAR1', 'FOOPAR2'])
+        fakearg = {'FOOPAR1': 'FOOVAL'}
+        mrq = p._missing_required_parameters(rqset, **fakearg)
+        assert mrq
+        assert mrq == ['FOOPAR2']
+
+    def test_missing_req_param_false(self):
+        p = PathElement(mock.MagicMock())
+        rqset = set(['FOOPAR1'])
+        fakearg = {'FOOPAR1': 'FOOVAL'}
+        mrq = p._missing_required_parameters(rqset, **fakearg)
+        assert not mrq
+
+    def test_check_load_parameters_fail(self):
+        p = PathElement(mock.MagicMock())
+        p._meta_data['required_load_parameters'] = set(['FAKELOAD'])
+        with pytest.raises(MissingRequiredReadParameter) as RLPEIO:
+            p._check_load_parameters(FOOLOAD='FOOVAL')
+        assert "['FAKELOAD']" in RLPEIO.value.message
+
+    def test_check_create_parameters_fail(self):
+        p = PathElement(mock.MagicMock())
+        p._meta_data['required_creation_parameters'] = set(['FAKECREATE'])
+        with pytest.raises(MissingRequiredCreationParameter) as RCPEIO:
+            p._check_create_parameters(FOOCREATE='FOOVAL')
+        assert "['FAKECREATE']" in RCPEIO.value.message
+
+    def test_check_command_parameters_fail(self):
+        p = PathElement(mock.MagicMock())
+        p._meta_data['required_command_parameters'] = set(['FAKECOMMAND'])
+        with pytest.raises(MissingRequiredCommandParameter) as RCPEIO:
+            p._check_command_parameters(BARCOMMAND='FOOVAL')
+        assert "['FAKECOMMAND']" in RCPEIO.value.message
+
+    def test_check_exclusive_parameters_empty_attr(self):
+        p = PathElement(mock.MagicMock())
+        p._meta_data['exclusive_attributes'] = []
+        fakearg = {'FOOEX': 'FOOVAL'}
+        # Check that any other exception is not thrown
+        p._check_exclusive_parameters(**fakearg)
+
+    def test_check_exclusive_parameters_pass(self):
+        p = PathElement(mock.MagicMock())
+        p._meta_data['exclusive_attributes'] = [('FOOEX', 'BAREX')]
+        fakearg = {'FOOEX': 'FOOVAL'}
+        # Check ExclusiveAttributesPresent is not thrown
+        p._check_exclusive_parameters(**fakearg)
+
+    def test_check_exclusive_parameters_fail(self):
+        p = PathElement(mock.MagicMock())
+        p._meta_data['exclusive_attributes'] = [('FOOEX', 'BAREX')]
+        fakearg = {'FOOEX': 'FOOVAL', 'BAREX': 'BARVAL'}
+        with pytest.raises(ExclusiveAttributesPresent) as EAEIO:
+            p._check_exclusive_parameters(**fakearg)
+        assert 'FOOEX, BAREX' in EAEIO.value.message

f5/bigip/tm/cm/device_group.py

@@ -35,9 +35,6 @@ class Device_Groups(Collection):
     """BIG-IP® cluster device-groups collection."""
     def __init__(self, cm):
         super(Device_Groups, self).__init__(cm)
-        endpoint = 'device-group'
-        self._meta_data['uri'] =\
-            self._meta_data['container']._meta_data['uri'] + endpoint + '/'
         self._meta_data['allowed_lazy_attributes'] = [Device_Group]
         self._meta_data['attribute_registry'] =\
             {'tm:cm:device:device-groupstate': Device_Group}

f5/bigip/tm/cm/sync_status.py

@@ -28,17 +28,14 @@
 """
 
 from f5.bigip.mixins import UnnamedResourceMixin
-from f5.bigip.resource import Resource
+from f5.bigip.resource import ResourceBase
 
 
-class Sync_Status(Resource, UnnamedResourceMixin):
+class Sync_Status(ResourceBase, UnnamedResourceMixin):
     '''A Resource concrete subclass.'''
     def __init__(self, cm):
         '''Autogenerated constructor.'''
         super(Sync_Status, self).__init__(cm)
-        base_uri = type(self).__name__.replace('_', '-').lower()
-        self._meta_data['uri'] =\
-            self._meta_data['container']._meta_data['uri'] + base_uri
         self._meta_data['template_generated'] = True
         self._meta_data['required_json_kind'] =\
             u"tm:cm:sync-status:sync-statusstats"

f5/bigip/tm/cm/traffic_group.py

@@ -35,9 +35,6 @@ class Traffic_Groups(Collection):
     """BIG-IP® cluster traffic-group collection"""
     def __init__(self, cm):
         super(Traffic_Groups, self).__init__(cm)
-        endpoint = 'traffic-group'
-        self._meta_data['uri'] =\
-            self._meta_data['container']._meta_data['uri'] + endpoint + '/'
         self._meta_data['allowed_lazy_attributes'] = [Traffic_Group]
         self._meta_data['attribute_registry'] =\
             {'tm:cm:traffic-group:traffic-groupstate': Traffic_Group}

f5/bigip/tm/cm/trust.py

@@ -18,11 +18,11 @@
 from f5.bigip.mixins import CommandExecutionMixin
 from f5.bigip.mixins import ExclusiveAttributesMixin
 from f5.bigip.mixins import UnnamedResourceMixin
-from f5.bigip.resource import Resource
+from f5.bigip.resource import PathElement
 
 
-class Add_To_Trust(UnnamedResourceMixin, ExclusiveAttributesMixin,
-                   CommandExecutionMixin, Resource):
+class Add_To_Trust(PathElement, UnnamedResourceMixin, ExclusiveAttributesMixin,
+                   CommandExecutionMixin):
     """BIG-IP® Add-To-Trust resource
 
     Use this object to set or overwrite device trust
@@ -33,15 +33,16 @@ def __init__(self, cm):
         super(Add_To_Trust, self).__init__(cm)
         self._meta_data['exclusive_attributes'].append(
             ('caDevice', 'nonCaDevice'))
-        self._meta_data['required_creation_parameters'].update(
-            ('device', 'deviceName', 'username', 'password'))
+        self._meta_data['required_command_parameters'].update(
+            ('name', 'device', 'deviceName', 'username', 'password'))
         self._meta_data['required_json_kind'] = \
             'tm:cm:add-to-trust:runstate'
         self._meta_data['allowed_commands'].append('run')
-        self._meta_data['supported_versions'].discard('11.6.0')
+        self._meta_data['minimum_version'] = '12.0.0'
 
 
-class Remove_From_Trust(UnnamedResourceMixin, CommandExecutionMixin, Resource):
+class Remove_From_Trust(PathElement, UnnamedResourceMixin,
+                        CommandExecutionMixin):
     """BIG-IP®« Remove-From-Trust resource
 
     Use this object to remove device trust
@@ -55,9 +56,9 @@ class Remove_From_Trust(UnnamedResourceMixin, CommandExecutionMixin, Resource):
 
     def __init__(self, cm):
         super(Remove_From_Trust, self).__init__(cm)
-        self._meta_data['required_creation_parameters'].update(
-            ('deviceName',))
+        self._meta_data['required_command_parameters'].update(
+            ('deviceName', 'name'))
         self._meta_data['required_json_kind'] = \
             'tm:cm:remove-from-trust:runstate'
         self._meta_data['allowed_commands'].append('run')
-        self._meta_data['supported_versions'].discard('11.6.0')
+        self._meta_data['minimum_version'] = '12.0.0'

f5/bigip/tm/cm/trust_domain.py

@@ -36,9 +36,6 @@ class Trust_Domains(Collection):
 
     def __init__(self, cm):
         super(Trust_Domains, self).__init__(cm)
-        endpoint = 'trust-domain'
-        self._meta_data['uri'] =\
-            self._meta_data['container']._meta_data['uri'] + endpoint + '/'
         self._meta_data['allowed_lazy_attributes'] = [Trust_Domain]
         self._meta_data['attribute_registry'] = \
             {'tm:cm:trust-domain:trust-domainstate': Trust_Domain}