Clusters, vlans, tm clusters , filters

meta/runtime.yml

@@ -73,6 +73,12 @@ action_groups:
   - ntnx_ndb_register_database
   - ntnx_ndb_db_server_vms
   - ntnx_ndb_clusters_info
+  - ntnx_ndb_clusters
+  - ntnx_ndb_snapshots_info
+  - ntnx_ndb_vlans
+  - ntnx_ndb_vlans_info
+  - ntnx_ndb_stretched_vlans
+  - ntnx_ndb_time_machine_clusters
   - ntnx_ndb_tags
   - ntnx_ndb_database_clones
   - ntnx_ndb_database_snapshots
@@ -83,6 +89,7 @@ action_groups:
   - ntnx_ndb_database_restore
   - ntnx_ndb_database_scale
   - ntnx_ndb_linked_databases
+  - ntnx_ndb_database_replicate_snapshots
   - ntnx_ndb_register_db_server_vm
   - ntnx_ndb_maintenance_tasks
   - ntnx_ndb_maintenance_window

plugins/module_utils/ndb/clusters.py

@@ -4,14 +4,70 @@
 
 __metaclass__ = type
 
+from copy import deepcopy
 
 from .nutanix_database import NutanixDatabase
 
 
 class Cluster(NutanixDatabase):
+
     def __init__(self, module):
         resource_type = "/clusters"
         super(Cluster, self).__init__(module, resource_type=resource_type)
+        self.build_spec_methods = {
+            "name": self._build_spec_name,
+            "desc": self._build_spec_desc,
+            "name_prefix": self._build_spec_name_prefix,
+            "cluster_ip": self._build_spec_cluster_ip,
+            "cluster_credentials": self._build_spec_cluster_credentials,
+            "agent_network": self._build_spec_agent_network,
+            "vlan_access": self._build_spec_vlan_access,
+            "storage_container": self._build_spec_storage_container,
+        }
+
+    def update(
+        self,
+        data=None,
+        uuid=None,
+        endpoint=None,
+        query=None,
+        raise_error=True,
+        no_response=False,
+        timeout=30,
+        method="PATCH",
+    ):
+        return super().update(
+            data, uuid, endpoint, query, raise_error, no_response, timeout, method
+        )
+
+    def delete(
+        self,
+        uuid=None,
+        endpoint=None,
+        query=None,
+        raise_error=True,
+        no_response=False,
+        timeout=30,
+        data=None,
+    ):
+        if not self._validate_cluster_deleting(uuid):
+            err = "NDB is unable to remove the Nutanix Cluster at this time. Check dependencies"
+            return None, err
+        if not data:
+            data = {"deleteRemoteSites": False}
+        return (
+            super().delete(
+                uuid, endpoint, query, raise_error, no_response, timeout, data
+            ),
+            None,
+        )
+
+    def get_cluster_by_ip(self, cluster_ip):
+        clusters = self.read()
+        for cluster in clusters:
+            if cluster_ip in cluster["ipAddresses"]:
+                return cluster
+        return None
 
     def get_uuid(
         self,
@@ -28,13 +84,13 @@ def get_uuid(
 
     def get_cluster(self, uuid=None, name=None):
         if uuid:
-            resp = self.read(uuid=uuid)
+            resp = self.read(uuid=uuid, raise_error=False)
         elif name:
             endpoint = "{0}/{1}".format("name", name)
-            resp = self.read(endpoint=endpoint)
+            resp = self.read(endpoint=endpoint, raise_error=False)
 
             # we fetch cluster using ID again to get complete info.
-            if resp and resp.get("id"):
+            if resp and not resp.get("errorCode") and resp.get("id"):
                 resp = self.read(uuid=resp["id"])
 
         else:
@@ -43,8 +99,155 @@ def get_cluster(self, uuid=None, name=None):
                 "Please provide either uuid or name for fetching cluster details",
             )
 
+        if isinstance(resp, dict) and resp.get("errorCode"):
+            self.module.fail_json(
+                msg="Failed fetching cluster info",
+                error=resp.get("message"),
+                response=resp,
+            )
+
         return resp, None
 
+    def _get_default_spec(self):
+        return deepcopy(
+            {
+                "clusterName": "",
+                "clusterIP": "",
+                "storageContainer": "",
+                "agentVMPrefix": "",
+                "port": 9440,
+                "protocol": "https",
+                "clusterType": "NTNX",
+                "version": "v2",
+                "credentialsInfo": [],
+                "agentNetworkInfo": [],
+                "networksInfo": [],
+            }
+        )
+
+    def get_default_update_spec(self, override_spec=None):
+        spec = deepcopy(
+            {
+                "name": "",
+                "description": "",
+                "ipAddresses": [],
+            }
+        )
+        if override_spec:
+            for key in spec.keys():
+                if override_spec.get(key):
+                    spec[key] = deepcopy(override_spec[key])
+
+        return spec
+
+    def _build_spec_name(self, payload, name):
+        if self.module.params.get("uuid"):
+            payload["name"] = name
+        else:
+            payload["clusterName"] = name
+        return payload, None
+
+    def _build_spec_name_prefix(self, payload, prefix):
+        payload["agentVMPrefix"] = prefix
+        return payload, None
+
+    def _build_spec_desc(self, payload, desc):
+        if self.module.params.get("uuid"):
+            payload["description"] = desc
+        else:
+            payload["clusterDescription"] = desc
+        return payload, None
+
+    def _build_spec_cluster_ip(self, payload, cluster_ip):
+        if self.module.params.get("uuid"):
+            payload["ipAddresses"] = [cluster_ip]
+        else:
+            payload["clusterIP"] = cluster_ip
+        return payload, None
+
+    def _build_spec_cluster_credentials(self, payload, credentials):
+        if self.module.params.get("uuid"):
+            payload["username"] = credentials["username"]
+            payload["password"] = credentials["password"]
+        else:
+            payload["credentialsInfo"] = [
+                {"name": "username", "value": credentials["username"]},
+                {"name": "password", "value": credentials["password"]},
+            ]
+        return payload, None
+
+    def _build_spec_agent_network(self, payload, agent_network):
+        payload["agentNetworkInfo"] = [
+            {"name": "dns", "value": ",".join(agent_network["dns_servers"])},
+            {"name": "ntp", "value": ",".join(agent_network["ntp_servers"])},
+        ]
+        return payload, None
+
+    def _build_spec_vlan_access(self, payload, vlans_config):
+        networks_info = []
+        prism_vlan = self._generate_vlan_access_spec(vlans_config["prism_vlan"])
+        prism_vlan["accessType"] = ["PRISM"]
+
+        if vlans_config.get("dsip_vlan"):
+            dsip_vlan = self._generate_vlan_access_spec(vlans_config["dsip_vlan"])
+            dsip_vlan["accessType"] = ["DSIP"]
+            networks_info.append(dsip_vlan)
+        else:
+            prism_vlan["accessType"].append("DSIP")
+
+        if vlans_config.get("dbserver_vlan"):
+            dbserver_vlan = self._generate_vlan_access_spec(vlans_config["dbserver_vlan"])
+            dbserver_vlan["accessType"] = ["DBSERVER"]
+            networks_info.append(dbserver_vlan)
+        else:
+            prism_vlan["accessType"].append("DBSERVER")
+        networks_info.append(prism_vlan)
+
+        payload["networksInfo"] = networks_info
+        return payload, None
+
+    @staticmethod
+    def _generate_vlan_access_spec(vlan):
+        vlan_spec = {
+                "type": vlan["vlan_type"],
+                "networkInfo": [
+                    {
+                        "name": "vlanName",
+                        "value": vlan["vlan_name"],
+                    },
+                    {
+                        "name": "staticIP",
+                        "value": vlan["static_ip"],
+                    },
+                    {
+                        "name": "gateway",
+                        "value": vlan["gateway"],
+                    },
+                    {
+                        "name": "subnetMask",
+                        "value": vlan["subnet_mask"],
+                    },
+                ],
+            }
+        return vlan_spec
+
+    def _build_spec_storage_container(self, payload, storage_container):
+        payload["storageContainer"] = storage_container
+        return payload, None
+
+    def _validate_cluster_deleting(self, cluster_uuid):
+        query = {"count_entities": True}
+        cluster = self.read(cluster_uuid, query=query)
+
+        if cluster.get("entityCounts"):
+            if cluster["entityCounts"].get("dbServers") != 0:
+                return False
+            elif cluster["entityCounts"].get("engineCounts"):
+                for engine in cluster["entityCounts"]["engineCounts"].values():
+                    if engine["timeMachines"] != 0:
+                        return False
+        return True
+
     def get_all_clusters_uuid_name_map(self):
         resp = self.read()
         uuid_name_map = {}

plugins/module_utils/ndb/database_instances.py

@@ -196,13 +196,15 @@ def get_default_restore_spec(self):
             }
         )
 
-    def get_database(self, name=None, uuid=None):
-        default_query = {"detailed": True}
+    def get_database(self, name=None, uuid=None, query=None):
         if uuid:
-            resp = self.read(uuid=uuid, query=default_query)
+            resp = self.read(uuid=uuid, query=query, raise_error=False)
         elif name:
-            query = {"value-type": "name", "value": name}
-            query.update(deepcopy(default_query))
+            query_params = {"value-type": "name", "value": name}
+            if query:
+                query.update(query_params)
+            else:
+                query = query_params
             resp = self.read(query=query)
             if not resp:
                 return None, "Database with name {0} not found".format(name)

plugins/module_utils/ndb/db_server_vm.py

@@ -77,14 +77,18 @@ def get_all_db_servers_name_uuid_map(self):
 
         return name_uuid_map
 
-    def get_db_server(self, name=None, uuid=None, ip=None):
+    def get_db_server(self, name=None, uuid=None, ip=None, query=None):
         resp = None
         if uuid:
-            resp = self.read(uuid=uuid)
+            resp = self.read(uuid=uuid, query=query)
         elif name or ip:
             key = "name" if name else "ip"
             val = name if name else ip
-            query = {"value-type": key, "value": val}
+            query_params = {"value-type": key, "value": val}
+            if query:
+                query.update(query_params)
+            else:
+                query = query_params
             resp = self.read(query=query)
             if not resp:
                 return None, "Database server with {0} {1} not found".format(key, val)

plugins/module_utils/ndb/profiles/profiles.py

@@ -23,9 +23,6 @@ def __init__(self, module):
             "database_type": self.build_spec_database_type,
         }
 
-    def get_type(self):
-        return self._type
-
     def get_profile_uuid(self, data, type=None):
         uuid = ""
         if data.get("name"):

plugins/module_utils/ndb/snapshots.py

@@ -59,11 +59,10 @@ def get_snapshot(self, time_machine_uuid, name):
 
     def get_snapshot_uuid(self, time_machine_uuid, name):
         query = {
-            "value-type": time_machine_uuid,
-            "detailed": False,
-            "load-database": False,
-            "load-clones": False,
-            "time-zone": "UTC",
+            "value-type": "time-machine",
+            "value": time_machine_uuid,
+            "detailed": True,
+            "all": True
         }
 
         snapshots = self.read(query=query)
@@ -175,3 +174,23 @@ def resolve_cluster_uuids(self, clusters):
             specs.append(uuid)
 
         return specs, None
+
+    def _build_query_params(self, query_params):
+        if query_params.get("database-ids"):
+            db_ids = ",".join(query_params["database-ids"])
+            query_params["database-ids"] = db_ids
+        return query_params
+
+    def get_snapshots(self, query_params=None):
+        if query_params:
+            queries = self._build_query_params(query_params)
+            resp = self.read(query=queries)
+        else:
+            resp = self.read()
+
+        return resp
+
+    def get_snapshot_files(self, uuid):
+        endpoint = "files"
+        resp = self.read(uuid=uuid, endpoint=endpoint)
+        return resp