fb-vmware 1.8.0__tar.gz → 1.8.1__tar.gz

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fb_vmware
-Version: 1.8.0
+Version: 1.8.1
 Summary: @summary: The module for a base vSphere handler object.
 Author-email: Frank Brehm <frank@brehm-online.com>
 Requires-Python: >=3.8

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/pyproject.toml

@@ -48,6 +48,7 @@ name = "fb_vmware"
 directory = "data"
 
 [project.scripts]
+get-vsphere-cluster-list = "fb_vmware.app.get_rpool_list:main"
 get-vsphere-host-list = "fb_vmware.app.get_host_list:main"
 get-vsphere-network-list = "fb_vmware.app.get_network_list:main"
 get-vsphere-storage-cluster-info =  "fb_vmware.app.get_storage_cluster_info:main"

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/__init__.py

@@ -56,7 +56,7 @@ from .vm import VsphereVmList
 from .xlate import XLATOR
 
 
-__version__ = "1.8.0"
+__version__ = "1.8.1"
 
 LOG = logging.getLogger(__name__)
 

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/app/__init__.py

@@ -163,7 +163,7 @@ class BaseVmwareApplication(FbConfigApplication):
     # -------------------------------------------------------------------------
     def __del__(self):
         """Clean up in emergency case."""
-        if self.vsphere.keys():
+        if hasattr(self, "vsphere") and self.vsphere.keys():
             self.cleaning_up()
 
     # -------------------------------------------------------------------------

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/app/get_host_list.py

@@ -36,7 +36,7 @@ from ..errors import VSphereExpectedError
 from ..host import VsphereHost
 from ..xlate import XLATOR
 
-__version__ = "1.5.3"
+__version__ = "1.5.6"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -73,9 +73,7 @@ class GetHostsListApplication(BaseVmwareApplication):
         env_prefix=None,
     ):
         """Initialize a GetHostsListApplication object."""
-        desc = _(
-            "Tries to get a list of all physical hosts in " "VMware vSphere and print it out."
-        )
+        desc = _("Tries to get a list of all physical hosts in VMware vSphere and print it out.")
 
         self._host_pattern = self.default_host_pattern
         self.sort_keys = self.default_sort_keys
@@ -119,8 +117,6 @@ class GetHostsListApplication(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def init_arg_parser(self):
         """Public available method to initiate the argument parser."""
-        super(GetHostsListApplication, self).init_arg_parser()
-
         filter_group = self.arg_parser.add_argument_group(_("Filter options"))
 
         filter_group.add_argument(
@@ -172,6 +168,8 @@ class GetHostsListApplication(BaseVmwareApplication):
             ),
         )
 
+        super(GetHostsListApplication, self).init_arg_parser()
+
     # -------------------------------------------------------------------------
     def perform_arg_parser(self):
         """Evaluate command line parameters."""
@@ -213,10 +211,10 @@ class GetHostsListApplication(BaseVmwareApplication):
         ret = 0
         all_hosts = []
 
-        if self.verbose:
+        if self.verbose or self.quiet:
             for vsphere_name in self.vsphere:
                 all_hosts += self.get_hosts(vsphere_name)
-        elif not self.quiet:
+        else:
             spin_prompt = _("Getting all vSphere hosts ...") + " "
             spinner_name = self.get_random_spinner_name()
             with Spinner(spin_prompt, spinner_name):

fb_vmware-1.8.1/src/fb_vmware/app/get_rpool_list.py

@@ -0,0 +1,386 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@summary: Print a list of all resouce pools in a VMware vSphere.
+
+@author: Frank Brehm
+@contact: frank@brehm-online.com
+@copyright: © 2026 by Frank Brehm, Berlin
+"""
+from __future__ import absolute_import, print_function
+
+# Standard modules
+import locale
+import logging
+import pathlib
+import sys
+from operator import attrgetter
+
+# Third party modules
+from babel.numbers import format_decimal
+
+from fb_tools.common import pp
+from fb_tools.spinner import Spinner
+from fb_tools.xlate import format_list
+
+from rich import box
+from rich.table import Table
+from rich.text import Text
+
+# Own modules
+from . import BaseVmwareApplication, VmwareAppError
+from .. import __version__ as GLOBAL_VERSION
+from ..errors import VSphereExpectedError
+from ..xlate import XLATOR
+
+__version__ = "1.1.1"
+LOG = logging.getLogger(__name__)
+
+_ = XLATOR.gettext
+ngettext = XLATOR.ngettext
+
+
+# =============================================================================
+class GetResPoolAppError(VmwareAppError):
+    """Base exception class for all exceptions in this application."""
+
+    pass
+
+
+# =============================================================================
+class GetResPoolListApplication(BaseVmwareApplication):
+    """Class for the application object."""
+
+    avail_sort_keys = ("name", "vsphere", "dc_name")
+    default_sort_keys = ["vsphere", "dc_name", "name"]
+
+    # -------------------------------------------------------------------------
+    def __init__(
+        self,
+        appname=None,
+        verbose=0,
+        version=GLOBAL_VERSION,
+        base_dir=None,
+        initialized=False,
+        usage=None,
+        description=None,
+        argparse_epilog=None,
+        argparse_prefix_chars="-",
+        env_prefix=None,
+    ):
+        """Initialize a GetResPoolListApplication object."""
+        desc = _(
+            "Tries to get a list of all resource pools (a.k.a. computing resource and cluster "
+            "computing resource) in VMware vSphere and print it out."
+        )
+
+        self.sort_keys = self.default_sort_keys
+
+        super(GetResPoolListApplication, self).__init__(
+            appname=appname,
+            verbose=verbose,
+            version=version,
+            base_dir=base_dir,
+            description=desc,
+            initialized=False,
+        )
+
+        self.initialized = True
+
+    # -------------------------------------------------------------------------
+    def init_arg_parser(self):
+        """Public available method to initiate the argument parser."""
+        output_options = self.arg_parser.add_argument_group(_("Output options"))
+
+        output_options.add_argument(
+            "-S",
+            "--sort",
+            metavar="KEY",
+            nargs="+",
+            dest="sort_keys",
+            choices=self.avail_sort_keys,
+            help=_(
+                "The keys for sorting the output. Available keys are: {avail}. "
+                "The default sorting keys are: {default}."
+            ).format(
+                avail=format_list(self.avail_sort_keys, do_repr=True),
+                default=format_list(self.default_sort_keys, do_repr=True),
+            ),
+        )
+
+        super(GetResPoolListApplication, self).init_arg_parser()
+
+    # -------------------------------------------------------------------------
+    def perform_arg_parser(self):
+        """Evaluate command line parameters."""
+        super(GetResPoolListApplication, self).perform_arg_parser()
+
+        if self.args.sort_keys:
+            self.sort_keys = self.args.sort_keys
+
+    # -------------------------------------------------------------------------
+    def _run(self):
+
+        LOG.debug(_("Starting {a!r}, version {v!r} ...").format(a=self.appname, v=self.version))
+
+        ret = 0
+        try:
+            ret = self.get_all_resource_pools()
+        except VSphereExpectedError as e:
+            LOG.error(str(e))
+            self.exit(6)
+        finally:
+            self.cleaning_up()
+
+        self.exit(ret)
+
+    # -------------------------------------------------------------------------
+    def get_all_resource_pools(self):
+        """Collect all resource pools, a.k.a. (cluster) computing resources."""
+        ret = 0
+        all_rpools = []
+
+        if self.verbose or self.quiet:
+            for vsphere_name in self.vsphere:
+                all_rpools += self.get_resource_pools(vsphere_name)
+        else:
+            spin_prompt = _("Getting all vSphere hosts ...") + " "
+            spinner_name = self.get_random_spinner_name()
+            with Spinner(spin_prompt, spinner_name):
+                for vsphere_name in self.vsphere:
+                    all_rpools += self.get_resource_pools(vsphere_name)
+            sys.stdout.write(" " * len(spin_prompt))
+            sys.stdout.write("\r")
+            sys.stdout.flush()
+
+        all_rpools.sort(key=attrgetter(*self.sort_keys))
+
+        if len(all_rpools):
+            out_list = []
+            out = ""
+            if self.verbose == 2:
+                LOG.debug(_("First computing resource:") + "\n" + pp(all_rpools[0].as_dict()))
+                for rpool in all_rpools:
+                    out_list.append(
+                        f" * Vsphere {rpool.vsphere:<10} - DC {rpool.dc_name:<12} - {rpool.name}"
+                    )
+                out = "\n".join(out_list)
+            elif self.verbose > 2:
+                for rpool in all_rpools:
+                    out_list.append(rpool.as_dict())
+                out = pp(out_list)
+            if self.verbose >= 2:
+                LOG.debug("All computing resources:\n{}".format(out))
+
+            self.print_rpools(all_rpools)
+        else:
+            LOG.error(_("Did not found any resource pools or cluster resource pools."))
+            if not self.quiet:
+                print()
+            ret = 3
+
+        return ret
+
+    # -------------------------------------------------------------------------
+    def get_resource_pools(self, vsphere_name):
+        """Get all host of all (cluster) computing resources in a VMware vSphere."""
+        clusters = []
+
+        vsphere = self.vsphere[vsphere_name]
+
+        vsphere.get_clusters(vsphere_name=vsphere_name)
+
+        for cluster in sorted(vsphere.clusters):
+            clusters.append(cluster)
+
+        return clusters
+
+    # -------------------------------------------------------------------------
+    def print_rpools(self, rpools):
+        """Print on STDOUT all information about cluster) computing resources."""
+        show_header = True
+        show_footer = True
+        table_title = _("All compute resources and cluster compute resources") + "\n"
+        box_style = box.ROUNDED
+
+        if self.quiet:
+            show_header = False
+            show_footer = False
+            table_title = None
+            box_style = None
+
+        if self.quiet:
+            caption = None
+        else:
+            count = len(rpools)
+            if count:
+                caption = "\n" + ngettext(
+                    "Found one compute resource.",
+                    "Found {} compute resources.",
+                    count,
+                ).format(count)
+            else:
+                caption = "\n" + _("Found no compute resources.")
+
+        totals = self._get_totals(rpools)
+
+        table = Table(
+            title=table_title,
+            title_style="bold cyan",
+            caption=caption,
+            caption_style="default on default",
+            caption_justify="left",
+            box=box_style,
+            show_header=show_header,
+            show_footer=show_footer,
+        )
+
+        table.add_column(header=_("vSphere"), footer=_("Total:"))
+        table.add_column(header=_("Data Center"), footer="")
+        table.add_column(header=_("Name"), footer="")
+        table.add_column(header=_("Cluster"), footer="")
+        table.add_column(header=_("Pool name"), footer="")
+        table.add_column(
+            header=_("Hosts total"),
+            justify="right",
+            footer=self._prepare_number(totals["hosts_total"], warn_on_value1=True),
+        )
+        table.add_column(
+            header=_("Hosts available"),
+            justify="right",
+            footer=self._prepare_number(
+                totals["hosts_avail"],
+                warn_on_value1=True,
+                compare_val=totals["hosts_total"],
+            ),
+        )
+        table.add_column(
+            header=_("CPU cores"),
+            justify="right",
+            footer=self._prepare_number(totals["cpu_cores"]),
+        )
+        table.add_column(
+            header=_("CPU threads"),
+            justify="right",
+            footer=self._prepare_number(totals["cpu_threads"]),
+        )
+        table.add_column(
+            header=_("Memory total"),
+            justify="right",
+            footer=self._prepare_number(totals["mem_total"]),
+        )
+        table.add_column(
+            header=_("Memory available"),
+            justify="right",
+            footer=self._prepare_number(totals["mem_avail"], compare_val=totals["mem_total"]),
+        )
+
+        for rpool in rpools:
+            row = []
+            row.append(rpool.vsphere)
+            row.append(rpool.dc_name)
+            row.append(rpool.name)
+
+            is_cluster = Text(_("Yes"), style="bold green")
+            if rpool.standalone:
+                is_cluster = Text(_("No"), style="green")
+
+            row.append(is_cluster)
+            row.append(rpool.base_resource_pool_name)
+            row.append(self._prepare_number(rpool.hosts_total, warn_on_value1=True))
+            row.append(
+                self._prepare_number(
+                    rpool.hosts_effective,
+                    warn_on_value1=True,
+                    compare_val=rpool.hosts_total,
+                )
+            )
+            row.append(self._prepare_number(rpool.cpu_cores))
+            row.append(self._prepare_number(rpool.cpu_threads))
+            row.append(self._prepare_number(rpool.mem_mb_total))
+            row.append(
+                self._prepare_number(rpool.mem_mb_effective, compare_val=rpool.mem_mb_total)
+            )
+
+            table.add_row(*row)
+
+        self.rich_console.print(table)
+
+        if not self.quiet:
+            print()
+
+    # -------------------------------------------------------------------------
+    def _get_totals(self, rpools):
+
+        totals = {
+            "hosts_total": 0,
+            "hosts_avail": 0,
+            "cpu_cores": 0,
+            "cpu_threads": 0,
+            "mem_total": 0,
+            "mem_avail": 0,
+        }
+
+        for rpool in rpools:
+            totals["hosts_total"] += rpool.hosts_total
+            totals["hosts_avail"] += rpool.hosts_effective
+            totals["cpu_cores"] += rpool.cpu_cores
+            totals["cpu_threads"] += rpool.cpu_threads
+            totals["mem_total"] += rpool.mem_mb_total
+            totals["mem_avail"] += rpool.mem_mb_effective
+
+        return totals
+
+    # -------------------------------------------------------------------------
+    def _prepare_number(self, value, may_zero=False, warn_on_value1=False, compare_val=None):
+
+        if value is None:
+            return ""
+
+        try:
+            int_val = int(value)
+        except ValueError:
+            return value
+
+        val_str = format_decimal(int_val, format="#,##0")
+        if not may_zero and int_val == 0:
+            val_str = Text(val_str, style="bold red")
+        elif warn_on_value1 and int_val == 1:
+            val_str = Text(val_str, style="bold yellow")
+        elif compare_val is not None and int_val < compare_val:
+            val_str = Text(val_str, style="bold yellow")
+
+        return val_str
+
+
+# =============================================================================
+def main():
+    """Entrypoint for get-vsphere-cluster-list."""
+    my_path = pathlib.Path(__file__)
+    appname = my_path.name
+
+    locale.setlocale(locale.LC_ALL, "")
+
+    app = GetResPoolListApplication(appname=appname)
+    app.initialized = True
+
+    if app.verbose > 2:
+        print(_("{c}-Object:\n{a}").format(c=app.__class__.__name__, a=app), file=sys.stderr)
+
+    try:
+        app()
+    except KeyboardInterrupt:
+        print("\n" + app.colored(_("User interrupt."), "YELLOW"))
+        sys.exit(5)
+
+    sys.exit(0)
+
+
+# =============================================================================
+if __name__ == "__main__":
+
+    pass
+
+# =============================================================================
+
+# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4 list

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/app/get_vm_list.py

@@ -37,7 +37,7 @@ from ..errors import VSphereExpectedError
 from ..vm import VsphereVm
 from ..xlate import XLATOR
 
-__version__ = "1.12.0"
+__version__ = "1.12.1"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -386,10 +386,10 @@ class GetVmListApplication(BaseVmwareApplication):
 
         re_name = re.compile(self.vm_pattern, re.IGNORECASE)
 
-        if self.verbose:
+        if self.verbose or self.quiet:
             for vsphere_name in self.vsphere:
                 all_vms += self.get_vms(vsphere_name, re_name)
-        elif not self.quiet:
+        else:
             spin_prompt = _("Getting all vSphere VMs ...") + " "
             spinner_name = self.get_random_spinner_name()
             with Spinner(spin_prompt, spinner_name):

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/argparse_actions.py

@@ -11,6 +11,7 @@ from __future__ import absolute_import
 # Standard modules
 import argparse
 import logging
+
 # import os
 # from pathlib import Path
 
@@ -20,7 +21,7 @@ import logging
 # Own modules
 from .xlate import XLATOR
 
-__version__ = "0.1.1"
+__version__ = "0.1.2"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -40,7 +41,9 @@ class NonNegativeIntegerOptionAction(argparse.Action):
         self.may_zero = bool(may_zero)
 
         super(NonNegativeIntegerOptionAction, self).__init__(
-            *args, **kwargs, option_strings=option_strings,
+            *args,
+            **kwargs,
+            option_strings=option_strings,
         )
 
     # -------------------------------------------------------------------------

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/cluster.py

@@ -19,12 +19,13 @@ from fb_tools.xlate import format_list
 from pyVmomi import vim
 
 # Own modules
+from .errors import VSphereHandlerError
 from .errors import VSphereNameError
 from .obj import DEFAULT_OBJ_STATUS
 from .obj import VsphereObject
 from .xlate import XLATOR
 
-__version__ = "1.7.0"
+__version__ = "1.9.2"
 LOG = logging.getLogger(__name__)
 
 
@@ -35,6 +36,8 @@ _ = XLATOR.gettext
 class VsphereCluster(VsphereObject):
     """An object for encapsulating a vSphere calculation cluster object."""
 
+    default_resource_pool_name = "Resources"
+
     # -------------------------------------------------------------------------
     def __init__(
         self,
@@ -43,9 +46,11 @@ class VsphereCluster(VsphereObject):
         version=__version__,
         base_dir=None,
         initialized=None,
+        vsphere=None,
         dc_name=None,
         name=None,
         status=DEFAULT_OBJ_STATUS,
+        resource_pool_name=None,
         cpu_cores=0,
         cpu_threads=0,
         config_status=DEFAULT_OBJ_STATUS,
@@ -80,7 +85,9 @@ class VsphereCluster(VsphereObject):
         self._mem_mb_effective = None
         self._mem_total = None
         self._standalone = False
+        self._vsphere = None
         self._dc_name = None
+        self._resource_pool_name = self.default_resource_pool_name
         self.networks = []
         self.datastores = []
         self.resource_pool = None
@@ -98,6 +105,8 @@ class VsphereCluster(VsphereObject):
         )
 
         self.dc_name = dc_name
+        if vsphere is not None:
+            self.vsphere = vsphere
         self.cpu_cores = cpu_cores
         self.cpu_threads = cpu_threads
         self.hosts_effective = hosts_effective
@@ -106,9 +115,31 @@ class VsphereCluster(VsphereObject):
         self.mem_total = mem_total
         self.standalone = standalone
 
+        if resource_pool_name is not None and str(resource_pool_name).strip() != "":
+            self._resource_pool_name = str(resource_pool_name).strip()
+
         if initialized is not None:
             self.initialized = initialized
 
+    # -----------------------------------------------------------
+    @property
+    def vsphere(self):
+        """Return the name of the vSphere from configuration of the cluster."""
+        return self._vsphere
+
+    @vsphere.setter
+    def vsphere(self, value):
+        if value is None:
+            self._vsphere = None
+            return
+
+        val = str(value).strip()
+        if val == "":
+            msg = _("The name of the vSphere may not be empty.")
+            raise VSphereHandlerError(msg)
+
+        self._vsphere = val
+
     # -----------------------------------------------------------
     @property
     def dc_name(self):
@@ -128,11 +159,17 @@ class VsphereCluster(VsphereObject):
 
         self._dc_name = val
 
+    # -----------------------------------------------------------
+    @property
+    def base_resource_pool_name(self):
+        """Return the base name of the default resource pool of this cluster."""
+        return self._resource_pool_name
+
     # -----------------------------------------------------------
     @property
     def resource_pool_name(self):
         """Return the name of the default resource pool of this cluster."""
-        return self.name + "/Resources"
+        return f"{self.name}/{self.base_resource_pool_name}"
 
     # -----------------------------------------------------------
     @property
@@ -306,7 +343,9 @@ class VsphereCluster(VsphereObject):
         """
         res = super(VsphereCluster, self).as_dict(short=short)
 
+        res["vsphere"] = self.vsphere
         res["dc_name"] = self.dc_name
+        res["base_resource_pool_name"] = self.base_resource_pool_name
         res["resource_pool_name"] = self.resource_pool_name
         res["resource_pool_var"] = self.resource_pool_var
         res["cpu_cores"] = self.cpu_cores
@@ -339,7 +378,9 @@ class VsphereCluster(VsphereObject):
             base_dir=self.base_dir,
             initialized=self.initialized,
             name=self.name,
+            vsphere=self.vsphere,
             dc_name=self.dc_name,
+            resource_pool_name=self.base_resource_pool_name,
             standalone=self.standalone,
             status=self.status,
             cpu_cores=self.cpu_cores,
@@ -359,9 +400,10 @@ class VsphereCluster(VsphereObject):
         if not isinstance(other, VsphereCluster):
             return False
 
+        if self.vsphere != other.vsphere:
+            return False
         if self.dc_name != other.dc_name:
             return False
-
         if self.name != other.name:
             return False
 
@@ -370,7 +412,14 @@ class VsphereCluster(VsphereObject):
     # -------------------------------------------------------------------------
     @classmethod
     def from_summary(
-        cls, data, dc_name=None, appname=None, verbose=0, base_dir=None, test_mode=False
+        cls,
+        data,
+        vsphere=None,
+        dc_name=None,
+        appname=None,
+        verbose=0,
+        base_dir=None,
+        test_mode=False,
     ):
         """Create a new VsphereCluster object based on the appropriate data from pyvomi."""
         if test_mode:
@@ -387,7 +436,9 @@ class VsphereCluster(VsphereObject):
             "verbose": verbose,
             "base_dir": base_dir,
             "initialized": True,
+            "vsphere": vsphere,
             "dc_name": dc_name,
+            "resource_pool_name": cls.default_resource_pool_name,
             "name": data.name,
             "status": data.overallStatus,
             "config_status": data.configStatus,
@@ -402,6 +453,18 @@ class VsphereCluster(VsphereObject):
         if isinstance(data, vim.ClusterComputeResource):
             params["standalone"] = False
 
+        if hasattr(data, "resourcePool"):
+            rname = data.resourcePool.summary.name
+            if verbose > 0:
+                LOG.debug(f"Name of resource pool of {data.name!r}: {rname!r}")
+            params["resource_pool_name"] = rname
+        else:
+            msg = _(
+                "Could not access to resource pool of compute resource {cc!r} in vSphere {vs!r}, "
+                "datacenter {dc!r}."
+            ).format(cc=data.name, vs=vsphere, dc=dc_name)
+            LOG.warn(msg)
+
         if verbose > 2:
             LOG.debug(_("Creating {} object from:").format(cls.__name__) + "\n" + pp(params))
 

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/connect.py

@@ -55,7 +55,7 @@ from .network import VsphereNetwork, VsphereNetworkDict
 from .vm import VsphereVm, VsphereVmList
 from .xlate import XLATOR
 
-__version__ = "2.11.1"
+__version__ = "2.11.3"
 LOG = logging.getLogger(__name__)
 
 DEFAULT_OS_VERSION = "rhel9_64Guest"
@@ -279,12 +279,15 @@ class VsphereConnection(BaseVsphereHandler):
         return
 
     # -------------------------------------------------------------------------
-    def get_clusters(self, search_in_dc=None, disconnect=False):
+    def get_clusters(self, vsphere_name=None, search_in_dc=None, disconnect=False):
         """Get all computing clusters from vSphere as VsphereCluster objects."""
         LOG.debug(_("Trying to get all clusters from vSphere ..."))
 
         self.clusters = []
 
+        if vsphere_name is None:
+            vsphere_name = self.name
+
         try:
 
             if not self.service_instance:
@@ -302,7 +305,7 @@ class VsphereConnection(BaseVsphereHandler):
                 dc = self.get_obj(content, [vim.Datacenter], dc_name)
 
                 for child in dc.hostFolder.childEntity:
-                    self._get_clusters(child, dc_name=dc_name)
+                    self._get_clusters(child, vsphere_name=vsphere_name, dc_name=dc_name)
 
         finally:
             if disconnect:
@@ -320,13 +323,21 @@ class VsphereConnection(BaseVsphereHandler):
             LOG.debug(_("Found clusters:") + "\n" + pp(out))
 
     # -------------------------------------------------------------------------
-    def _get_clusters(self, child, dc_name=None, depth=1):
+    def _get_clusters(self, child, vsphere_name=None, dc_name=None, depth=1):
+
+        if vsphere_name is None:
+            vsphere_name = self.name
 
         if hasattr(child, "childEntity"):
             if depth > self.max_search_depth:
                 return
             for sub_child in child.childEntity:
-                self._get_clusters(sub_child, dc_name, depth + 1)
+                self._get_clusters(
+                    sub_child,
+                    vsphere_name=vsphere_name,
+                    dc_name=dc_name,
+                    depth=(depth + 1),
+                )
             return
 
         if isinstance(child, (vim.ClusterComputeResource, vim.ComputeResource)):
@@ -335,6 +346,7 @@ class VsphereConnection(BaseVsphereHandler):
                 appname=self.appname,
                 verbose=self.verbose,
                 base_dir=self.base_dir,
+                vsphere=vsphere_name,
                 dc_name=dc_name,
             )
             if self.verbose > 1:
@@ -891,6 +903,7 @@ class VsphereConnection(BaseVsphereHandler):
         if isinstance(child, (vim.ClusterComputeResource, vim.ComputeResource)):
             cluster = VsphereCluster.from_summary(
                 child,
+                vsphere=vsphere_name,
                 dc_name=dc_name,
                 appname=self.appname,
                 verbose=self.verbose,

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/host.py

@@ -394,7 +394,7 @@ class VsphereHost(VsphereObject):
     # -----------------------------------------------------------
     @property
     def vsphere(self):
-        """Return the name of the vSphere from configuration, of thr host."""
+        """Return the name of the vSphere from configuration of the host."""
         return self._vsphere
 
     @vsphere.setter

{fb_vmware-1.8.0 → fb_vmware-1.8.1}/src/fb_vmware/host_port_group.py

@@ -20,7 +20,6 @@ except ImportError:
 
 # Third party modules
 from fb_tools.common import pp
-# from fb_tools.common import to_bool
 from fb_tools.obj import FbBaseObject
 from fb_tools.xlate import format_list
 
@@ -29,7 +28,7 @@ from pyVmomi import vim
 # Own modules
 from .xlate import XLATOR
 
-__version__ = "1.0.2"
+__version__ = "1.0.3"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext