VRAE-3223: get datastore info (#192)

* allow pytest to run from other directories by looking for vcenter.conf relative to conftest.py

* rename get_mors_type to get_parent_of_type

* added get_cluster and get_clusters

* VRAE-3223: get info about datastores

* use existing cluster.get_cluster

* move get_clusters to utils/cluster.py

* fix bug in _find_filtered object to raise if datacenter_name isn't present when cluster_name is the most specific name

* restructure datastore utils code and tests

* comment: we are so bad (vcenter.conf)

Author: dhiltonp

src/saltext/vmware/modules/datastore.py

@@ -2,8 +2,7 @@
 # SPDX-License: Apache-2.0
 import logging
 
-import salt.exceptions
-import saltext.vmware.utils.common as utils_common
+import saltext.vmware.utils.datastore as utils_datastore
 from saltext.vmware.utils.connect import get_service_instance
 
 log = logging.getLogger(__name__)
@@ -40,11 +39,12 @@ def maintenance_mode(datastore_name, datacenter_name=None, service_instance=None
     """
     if service_instance is None:
         service_instance = get_service_instance(opts=__opts__, pillar=__pillar__)
-    dc_ref = None
-    if datacenter_name:
-        dc_ref = utils_common.get_datacenter(service_instance, datacenter_name)
-    ds = utils_common.get_datastore(datastore_name, dc_ref, service_instance)
-    ret = utils_common.datastore_enter_maintenance_mode(ds)
+    assert isinstance(datastore_name, str)
+    datastores = utils_datastore.get_datastores(
+        service_instance, datastore_name=datastore_name, datacenter_name=datacenter_name
+    )
+    ds = datastores[0] if datastores else None
+    ret = utils_datastore.enter_maintenance_mode(ds)
     if ret:
         return {"maintenanceMode": "inMaintenance"}
     return {"maintenanceMode": "failed to enter maintenance mode"}
@@ -65,11 +65,68 @@ def exit_maintenance_mode(datastore_name, datacenter_name=None, service_instance
     """
     if service_instance is None:
         service_instance = get_service_instance(opts=__opts__, pillar=__pillar__)
-    dc_ref = None
-    if datacenter_name:
-        dc_ref = utils_common.get_datacenter(service_instance, datacenter_name)
-    ds = utils_common.get_datastore(datastore_name, dc_ref, service_instance)
-    ret = utils_common.datastore_exit_maintenance_mode(ds)
+    assert isinstance(datastore_name, str)
+    datastores = utils_datastore.get_datastores(
+        service_instance, datastore_name=datastore_name, datacenter_name=datacenter_name
+    )
+    ds = datastores[0] if datastores else None
+    ret = utils_datastore.exit_maintenance_mode(ds)
     if ret:
         return {"maintenanceMode": "normal"}
     return {"maintenanceMode": "failed to exit maintenance mode"}
+
+
+def get(
+    datastore_name=None,
+    datacenter_name=None,
+    cluster_name=None,
+    host_name=None,
+    service_instance=None,
+):
+    """
+    Return info about datastores.
+
+    datacenter_name
+        Filter by this datacenter name (required when cluster is not specified)
+
+    datacenter_name
+        Filter by this datacenter name (required when cluster is not specified)
+
+    cluster_name
+        Filter by this cluster name (required when datacenter is not specified)
+
+    host_name
+        Filter by this ESXi hostname (optional).
+
+    service_instance
+        Use this vCenter service connection instance instead of creating a new one. (optional).
+
+    """
+    log.debug(f"Running {__virtualname__}.get")
+    ret = []
+    if not service_instance:
+        service_instance = get_service_instance(opts=__opts__, pillar=__pillar__)
+    datastores = utils_datastore.get_datastores(
+        service_instance,
+        datastore_name=datastore_name,
+        datacenter_name=datacenter_name,
+        cluster_name=cluster_name,
+        host_name=host_name,
+    )
+
+    for datastore in datastores:
+        summary = datastore.summary
+        info = {
+            "accessible": summary.accessible,
+            "capacity": summary.capacity,
+            "freeSpace": summary.freeSpace,
+            "maintenanceMode": summary.maintenanceMode,
+            "multipleHostAccess": summary.multipleHostAccess,
+            "name": summary.name,
+            "type": summary.type,
+            "url": summary.url,
+            "uncommitted": summary.uncommitted if summary.uncommitted else 0,
+        }
+        ret.append(info)
+
+    return ret

src/saltext/vmware/modules/vm.py

@@ -5,6 +5,7 @@
 import salt.utils.platform
 import saltext.vmware.utils.common as utils_common
 import saltext.vmware.utils.connect as connect
+import saltext.vmware.utils.datastore as utils_datastore
 import saltext.vmware.utils.vm as utils_vm
 
 log = logging.getLogger(__name__)
@@ -509,9 +510,11 @@ def relocate(vm_name, new_host_name, datastore_name, service_instance=None):
         service_instance = connect.get_service_instance(opts=__opts__, pillar=__pillar__)
     vm_ref = utils_common.get_mor_by_property(service_instance, vim.VirtualMachine, vm_name)
     resources = utils_common.deployment_resources(new_host_name, service_instance)
-    datastore_ref = utils_common.get_datastore(
-        datastore_name, resources["datacenter"], service_instance
+    assert isinstance(datastore_name, str)
+    datastores = utils_datastore.get_datastores(
+        service_instance, datastore_name=datastore_name, datacenter_name=datacenter_name
     )
+    datastore_ref = datastores[0] if datastores else None
     ret = utils_vm.relocate(
         vm_ref, resources["destination_host"], datastore_ref, resources["resource_pool"]
     )

src/saltext/vmware/states/datastore.py

@@ -1,10 +1,8 @@
 # SPDX-License-Identifier: Apache-2.0
 import logging
 
-import saltext.vmware.utils.common as utils_common
 import saltext.vmware.utils.connect as connect
-import saltext.vmware.utils.vm as utils_vm
-from saltext.vmware.modules.tag import update
+import saltext.vmware.utils.datastore as utils_datastore
 
 log = logging.getLogger(__name__)
 
@@ -45,10 +43,11 @@ def maintenance_mode(name, enter_maintenance_mode, datacenter_name=None, service
     if service_instance is None:
         service_instance = connect.get_service_instance(opts=__opts__, pillar=__pillar__)
     ret = {"name": name, "changes": {}, "result": True, "comment": ""}
-    dc_ref = None
-    if datacenter_name:
-        dc_ref = utils_common.get_datacenter(service_instance, datacenter_name)
-    ds = utils_common.get_datastore(name, dc_ref, service_instance)
+    assert isinstance(name, str)
+    datastores = utils_datastore.get_datastores(
+        service_instance, datastore_name=name, datacenter_name=datacenter_name
+    )
+    ds = datastores[0] if datastores else None
     status = ds.summary.maintenanceMode
     if enter_maintenance_mode:
         if status == "inMaintenance":
@@ -61,7 +60,7 @@ def maintenance_mode(name, enter_maintenance_mode, datacenter_name=None, service
             ret["comment"] = "These options are set to change."
             return ret
 
-        mode = utils_common.datastore_enter_maintenance_mode(ds)
+        mode = utils_datastore.enter_maintenance_mode(ds)
         if mode:
             ret["changes"] = {"new": f"datastore {name} is in maintenance mode."}
             ret["comment"] = "These options changed."
@@ -80,7 +79,7 @@ def maintenance_mode(name, enter_maintenance_mode, datacenter_name=None, service
             ret["comment"] = "These options are set to change."
             return ret
 
-        mode = utils_common.datastore_exit_maintenance_mode(ds)
+        mode = utils_datastore.exit_maintenance_mode(ds)
         if mode:
             ret["changes"] = {"new": f"datastore {name} exited maintenance mode."}
             ret["comment"] = "These options changed."

src/saltext/vmware/states/vm.py

@@ -3,6 +3,7 @@
 
 import saltext.vmware.utils.common as utils_common
 import saltext.vmware.utils.connect as connect
+import saltext.vmware.utils.datastore as utils_datastore
 import saltext.vmware.utils.vm as utils_vm
 
 log = logging.getLogger(__name__)
@@ -244,9 +245,11 @@ def relocate(name, new_host_name, datastore_name, service_instance=None):
         ret["comment"] = f"{name} virtual machine is already on host {new_host_name}"
         return ret
     resources = utils_common.deployment_resources(new_host_name, service_instance)
-    datastore_ref = utils_common.get_datastore(
-        datastore_name, resources["datacenter"], service_instance
+    assert isinstance(datastore_name, str)
+    datastores = utils_datastore.get_datastores(
+        service_instance, datastore_name=datastore_name, datacenter_name=resources["datacenter"]
     )
+    datastore_ref = datastores[0] if datastores else None
     if __opts__["test"]:
         ret["changes"]["new"] = f"{name} virtual machine will be moved to host {new_host_name}"
         ret["comment"] = "These options are set to change."

src/saltext/vmware/utils/cluster.py

@@ -15,6 +15,40 @@
 log = logging.getLogger(__name__)
 
 
+def get_clusters(service_instance, datacenter_name=None, cluster_name=None):
+    """
+    Returns clusters in a vCenter.
+
+    service_instance
+        The Service Instance Object from which to obtain cluster.
+
+    datacenter_name
+        (Optional) Datacenter name to filter by.
+
+    cluster_name
+        (Optional) Exact cluster name to filter by. Requires datacenter_name.
+    """
+    if cluster_name and not datacenter_name:
+        raise salt.exceptions.ArgumentValueError(
+            "datacenter_name is required when looking up by cluster_name"
+        )
+
+    clusters = []
+    for cluster in utils_common.get_mors_with_properties(
+        service_instance, vim.ClusterComputeResource, property_list=["name"]
+    ):
+        if cluster_name and cluster_name != cluster["name"]:
+            continue
+        if (
+            datacenter_name
+            and datacenter_name
+            != utils_common.get_parent_of_type(cluster["object"], vim.Datacenter).name
+        ):
+            continue
+        clusters.append(cluster["object"])
+    return clusters
+
+
 def get_cluster(dc_ref, cluster):
     """
     Returns a cluster in a datacenter.

src/saltext/vmware/utils/common.py

@@ -15,7 +15,6 @@
 import salt.utils.platform
 import salt.utils.stringutils
 
-
 try:
     from pyVmomi import vim, vmodl
 
@@ -435,6 +434,8 @@ def get_resource_pools(
     if not resource_pool_names:
         resource_pool_names = []
     if datacenter_name:
+        import saltext.vmware.utils.datacenter as utils_datacenter
+
         container_ref = utils_datacenter.get_datacenter(service_instance, datacenter_name)
     else:
         container_ref = get_root_folder(service_instance)
@@ -737,84 +738,67 @@ def delete_datacenter(service_instance, datacenter_name):
     wait_for_task(task, datacenter_name, "DeleteDatacenterTask")
 
 
-def get_vm_datacenter(*, vm):
+def get_parent_of_type(mors, type):
     """
-    Return a datacenter from vm
-    """
-    datacenter = None
-    while True:
-        if isinstance(vm, vim.Datacenter):
-            datacenter = vm
-            break
-        try:
-            vm = vm.parent
-        except AttributeError:
-            break
-    return datacenter
-
+    Finds the first parent of a managed object that matches the type specified.
 
-def get_mors_type(obj, type):
+    `None` is returned if no object is found.
     """
-    Return a vim type from managed object reference
-    """
-    datacenter = None
     while True:
-        if isinstance(obj, type):
-            datacenter = obj
-            break
+        if isinstance(mors, type):
+            return mors
         try:
-            obj = obj.parent
+            mors = mors.parent
         except AttributeError:
-            break
-    return datacenter
+            return None
 
 
-def get_datastore(name, datacenter, service_instance):
+def find_filtered_object(service_instance, datacenter_name=None, cluster_name=None, host_name=None):
     """
-    Returns reference of datastore.
-
-    name
-        Name of datastore.
-
-    datacenter
-        Reference to datacenter.
+    Finds zero or one matching objects: plug in almost any combination of datacenter, cluster, and/or host name.
 
-    service_instance
-        The Service Instance from which to obtain managed object references.
-    """
-    if datacenter is None:
-        ds = get_mor_by_property(service_instance, vim.Datastore, name)
-    else:
-        ds = get_mor_by_property(service_instance, vim.Datastore, name, "name", datacenter)
-    return ds
+    If cluster_name is passed, datacenter_name must also be passed.
 
+    At least one of the optional parameters must be set.
 
-def datastore_enter_maintenance_mode(datastore_ref):
-    """
-    Put datastore in maintenance mode.
+    The most specific object will be returned (if you pass host_name and datacenter_name, the host will be returned).
 
-    datastore_ref
-        Reference to datastore.
-    """
-    ret = datastore_ref.DatastoreEnterMaintenanceMode()
-    if ret.task.info.state == "success":
-        return True
-    else:
-        return False
+    service_instance
+        The Service Instance Object from which to obtain cluster.
 
+    datacenter_name
+        (Optional) Datacenter name to filter by.
 
-def datastore_exit_maintenance_mode(datastore_ref):
-    """
-    Take datastore out of maintenance mode.
+    cluster_name
+        (Optional) Exact cluster name to filter by. If used, datacenter_name is required.
 
-    datastore_ref
-        Reference to datastore.
+    host_name
+        (Optional) Exact host name name to filter by.
     """
-    task = datastore_ref.DatastoreExitMaintenanceMode_Task()
-    wait_for_task(task, datastore_ref.name, "Take datastore out of maintenance mode")
-    if datastore_ref.summary.maintenanceMode == "normal":
-        return True
-    return False
+    try:
+        if host_name:
+            import saltext.vmware.utils.esxi as utils_esxi
+
+            hosts = utils_esxi.get_hosts(
+                service_instance,
+                datacenter_name=datacenter_name,
+                cluster_name=cluster_name,
+                host_names=[host_name],
+            )
+            return hosts[0] if hosts else None
+        elif cluster_name and datacenter_name:
+            import saltext.vmware.utils.cluster as utils_cluster
+
+            datacenter = get_datacenter(service_instance, datacenter_name)
+            return utils_cluster.get_cluster(datacenter, cluster_name)
+        elif datacenter_name:
+            return get_datacenter(service_instance, datacenter_name=datacenter_name)
+        else:
+            raise salt.exceptions.ArgumentValueError(
+                "find_filtered_object requires at least one of datacenter_name, host_name, or cluster_name with datacenter_name"
+            )
+    except salt.exceptions.VMwareObjectRetrievalError:
+        return None
 
 
 def get_license_mgrs(service_instance, license_mgr_names=None, get_all_license_mgrs=False):