Rewrite of na_ontap_cluster and unit tests. (#49780)

* changes to clusteR

* Revert "changes to clusteR"

This reverts commit 33ee1b71e4bc8435fb315762a871f8c4cb6c5f80.

* ontap cluster changes

lib/ansible/modules/storage/netapp/na_ontap_cluster.py

@@ -20,6 +20,7 @@ version_added: '2.6'
 author: NetApp Ansible Team (@carchi8py) <ng-ansibleteam@netapp.com>
 description:
 - Create or join or apply licenses to ONTAP clusters
+- Cluster join can be performed using only one of the parameters, either cluster_name or cluster_ip_address
 options:
   state:
     description:
@@ -63,11 +64,17 @@ EXAMPLES = """
     - name: Join cluster
       na_ontap_cluster:
         state: present
-        cluster_name: FPaaS-A300
         cluster_ip_address: 10.61.184.181
         hostname: "{{ netapp_hostname }}"
         username: "{{ netapp_username }}"
         password: "{{ netapp_password }}"
+    - name: Join cluster
+      na_ontap_cluster:
+        state: present
+        cluster_name: FPaaS-A300-01
+        hostname: "{{ netapp_hostname }}"
+        username: "{{ netapp_username }}"
+        password: "{{ netapp_password }}"
 """
 
 RETURN = """
@@ -78,10 +85,22 @@ import traceback
 from ansible.module_utils.basic import AnsibleModule
 from ansible.module_utils._text import to_native
 import ansible.module_utils.netapp as netapp_utils
+from ansible.module_utils.netapp_module import NetAppModule
 
 HAS_NETAPP_LIB = netapp_utils.has_netapp_lib()
 
 
+def local_cmp(a, b):
+    """
+    compares with only values and not keys, keys should be the same for both dicts
+    :param a: dict 1
+    :param b: dict 2
+    :return: difference of values in both dicts
+    """
+    diff = [key for key in a if a[key] != b[key]]
+    return len(diff)
+
+
 class NetAppONTAPCluster(object):
     """
     object initialize and class methods
@@ -102,78 +121,101 @@ class NetAppONTAPCluster(object):
             supports_check_mode=True,
             required_together=[
                 ['license_package', 'node_serial_number']
-            ],
-            mutually_exclusive=[
-                ['cluster_name', 'cluster_ip_address'],
             ]
         )
 
-        parameters = self.module.params
-
-        # set up state variables
-        self.state = parameters['state']
-        self.cluster_ip_address = parameters['cluster_ip_address']
-        self.cluster_name = parameters['cluster_name']
-        self.license_code = parameters['license_code']
-        self.license_package = parameters['license_package']
-        self.node_serial_number = parameters['node_serial_number']
+        self.na_helper = NetAppModule()
+        self.parameters = self.na_helper.set_parameters(self.module.params)
 
         if HAS_NETAPP_LIB is False:
             self.module.fail_json(msg="the python NetApp-Lib module is required")
         else:
             self.server = netapp_utils.setup_na_ontap_zapi(module=self.module)
 
+    def get_licensing_status(self):
+        """
+            Check licensing status
+
+            :return: package (key) and licensing status (value)
+            :rtype: dict
+        """
+        license_status = netapp_utils.zapi.NaElement(
+            'license-v2-status-list-info')
+        try:
+            result = self.server.invoke_successfully(license_status,
+                                                     enable_tunneling=True)
+        except netapp_utils.zapi.NaApiError as error:
+            self.module.fail_json(msg="Error checking license status: %s" %
+                                  to_native(error), exception=traceback.format_exc())
+
+        return_dictionary = {}
+        license_v2_status = result.get_child_by_name('license-v2-status')
+        if license_v2_status:
+            for license_v2_status_info in license_v2_status.get_children():
+                package = license_v2_status_info.get_child_content('package')
+                status = license_v2_status_info.get_child_content('method')
+                return_dictionary[package] = status
+
+        return return_dictionary
+
     def create_cluster(self):
         """
         Create a cluster
         """
         cluster_create = netapp_utils.zapi.NaElement.create_node_with_children(
-            'cluster-create', **{'cluster-name': self.cluster_name})
+            'cluster-create', **{'cluster-name': self.parameters['cluster_name']})
 
         try:
             self.server.invoke_successfully(cluster_create,
                                             enable_tunneling=True)
-            return True
         except netapp_utils.zapi.NaApiError as error:
             # Error 36503 denotes node already being used.
             if to_native(error.code) == "36503":
                 return False
             else:
                 self.module.fail_json(msg='Error creating cluster %s: %s'
-                                      % (self.cluster_name, to_native(error)),
+                                      % (self.parameters['cluster_name'], to_native(error)),
                                       exception=traceback.format_exc())
+        return True
 
     def cluster_join(self):
         """
         Add a node to an existing cluster
         """
-        cluster_add_node = netapp_utils.zapi.NaElement.create_node_with_children(
-            'cluster-join', **{'cluster-ip-address': self.cluster_ip_address})
-
+        if self.parameters.get('cluster_ip_address') is not None:
+            cluster_add_node = netapp_utils.zapi.NaElement.create_node_with_children(
+                'cluster-join', **{'cluster-ip-address': self.parameters['cluster_ip_address']})
+            for_fail_attribute = self.parameters.get('cluster_ip_address')
+        elif self.parameters.get('cluster_name') is not None:
+            cluster_add_node = netapp_utils.zapi.NaElement.create_node_with_children(
+                'cluster-join', **{'cluster-name': self.parameters['cluster_name']})
+            for_fail_attribute = self.parameters.get('cluster_name')
+        else:
+            return False
         try:
             self.server.invoke_successfully(cluster_add_node, enable_tunneling=True)
-            return True
         except netapp_utils.zapi.NaApiError as error:
             # Error 36503 denotes node already being used.
             if to_native(error.code) == "36503":
                 return False
             else:
                 self.module.fail_json(msg='Error adding node to cluster %s: %s'
-                                      % (self.cluster_name, to_native(error)),
+                                      % (for_fail_attribute, to_native(error)),
                                       exception=traceback.format_exc())
+        return True
 
     def license_v2_add(self):
         """
         Apply a license to cluster
         """
         license_add = netapp_utils.zapi.NaElement.create_node_with_children('license-v2-add')
-        license_add.add_node_with_children('codes', **{'license-code-v2': self.license_code})
+        license_add.add_node_with_children('codes', **{'license-code-v2': self.parameters['license_code']})
         try:
             self.server.invoke_successfully(license_add, enable_tunneling=True)
 
         except netapp_utils.zapi.NaApiError as error:
-            self.module.fail_json(msg='Error adding license to the cluster %s: %s'
-                                  % (self.cluster_name, to_native(error)),
+            self.module.fail_json(msg='Error adding license %s: %s'
+                                  % (self.parameters['license_code'], to_native(error)),
                                   exception=traceback.format_exc())
 
     def license_v2_delete(self):
@@ -181,15 +223,23 @@ class NetAppONTAPCluster(object):
         Delete license from cluster
         """
         license_delete = netapp_utils.zapi.NaElement.create_node_with_children(
-            'license-v2-delete', **{'package': self.license_package,
-                                    'serial-number': self.node_serial_number})
+            'license-v2-delete', **{'package': self.parameters['license_package'],
+                                    'serial-number': self.parameters['node_serial_number']})
         try:
             self.server.invoke_successfully(license_delete, enable_tunneling=True)
         except netapp_utils.zapi.NaApiError as error:
-            self.module.fail_json(msg='Error deleting license from cluster %s : %s'
-                                  % (self.cluster_name, to_native(error)),
+            self.module.fail_json(msg='Error deleting license : %s' % (to_native(error)),
                                   exception=traceback.format_exc())
 
+    def autosupport_log(self):
+        """
+        Autosupport log for cluster
+        :return:
+        """
+        results = netapp_utils.get_cserver(self.server)
+        cserver = netapp_utils.setup_na_ontap_zapi(module=self.module, vserver=results)
+        netapp_utils.ems_log_event("na_ontap_cluster", cserver)
+
     def apply(self):
         """
         Apply action to cluster
@@ -197,28 +247,30 @@ class NetAppONTAPCluster(object):
         property_changed = False
         create_flag = False
         join_flag = False
-        changed = False
 
-        if self.state == 'absent':
+        self.autosupport_log()
+        license_status = self.get_licensing_status()
+
+        if self.module.check_mode:
             pass
-        elif self.state == 'present':  # license add, delete
-            changed = True
-
-        if changed:
-            if self.module.check_mode:
-                pass
-            else:
-                if self.state == 'present':
-                    if self.cluster_name is not None:
-                        create_flag = self.create_cluster()
-                    if self.cluster_ip_address is not None:
-                        join_flag = self.cluster_join()
-                    if self.license_code is not None:
-                        self.license_v2_add()
-                        property_changed = True
-                    if self.license_package is not None and self.node_serial_number is not None:
+        else:
+            if self.parameters.get('state') == 'present':
+                if self.parameters.get('cluster_name') is not None:
+                    create_flag = self.create_cluster()
+                if not create_flag:
+                    join_flag = self.cluster_join()
+                if self.parameters.get('license_code') is not None:
+                    self.license_v2_add()
+                    property_changed = True
+                if self.parameters.get('license_package') is not None and\
+                        self.parameters.get('node_serial_number') is not None:
+                    if license_status.get(str(self.parameters.get('license_package')).lower()) != 'none':
                         self.license_v2_delete()
                         property_changed = True
+                if property_changed:
+                    new_license_status = self.get_licensing_status()
+                    if local_cmp(license_status, new_license_status) == 0:
+                        property_changed = False
         changed = property_changed or create_flag or join_flag
         self.module.exit_json(changed=changed)
 
@@ -227,8 +279,8 @@ def main():
     """
     Create object and call apply
     """
-    rule_obj = NetAppONTAPCluster()
-    rule_obj.apply()
+    cluster_obj = NetAppONTAPCluster()
+    cluster_obj.apply()
 
 
 if __name__ == '__main__':