fb-vmware 1.7.1__py3-none-any.whl → 1.8.1__py3-none-any.whl

fb_vmware/__init__.py

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

fb_vmware/app/__init__.py

@@ -25,10 +25,14 @@ from fb_tools.multi_config import DEFAULT_ENCODING
 
 import pytz
 
+from rich.console import Console
+from rich.prompt import InvalidResponse, Prompt, PromptBase, PromptType
+
 # Own modules
 from .. import __version__ as GLOBAL_VERSION
 from ..config import VmwareConfiguration
 from ..connect import VsphereConnection
+from ..ds_cluster import VsphereDsCluster
 from ..errors import VSphereExpectedError
 from ..xlate import DOMAIN
 from ..xlate import LOCALE_DIR
@@ -38,13 +42,18 @@ from ..xlate import __lib_dir__ as __xlate_lib_dir__
 from ..xlate import __mo_file__ as __xlate_mo_file__
 from ..xlate import __module_dir__ as __xlate_module_dir__
 
-__version__ = "1.3.0"
+__version__ = "1.7.2"
 LOG = logging.getLogger(__name__)
 TZ = pytz.timezone("Europe/Berlin")
 
 _ = XLATOR.gettext
 ngettext = XLATOR.ngettext
 
+Prompt.validate_error_message = "[prompt.invalid]" + _("Please enter a valid value")
+Prompt.illegal_choice_message = "[prompt.invalid.choice]" + _(
+    "Please select one of the available options"
+)
+
 
 # =============================================================================
 class VmwareAppError(FbAppError):
@@ -53,10 +62,56 @@ class VmwareAppError(FbAppError):
     pass
 
 
+# =============================================================================
+class PositiveIntPrompt(PromptBase[int]):
+    """A prompt that returns an positive integer greater than zero.
+
+    Example:
+        >>> burrito_count = PositiveIntPrompt.ask("How many burritos do you want to order")
+
+    """
+
+    response_type = int
+    validate_error_message = "[prompt.invalid]" + _(
+        "Please enter a valid positive integer number greater than zero."
+    )
+
+    # -------------------------------------------------------------------------
+    def process_response(self, value: str) -> PromptType:
+        """Process response from user, convert to prompt type.
+
+        Args:
+            value (str): String typed by user.
+
+        Raises:
+            InvalidResponse: If ``value`` is invalid.
+
+        Returns:
+            PromptType: The value to be returned from ask method.
+        """
+        value = value.strip()
+        try:
+            return_value: PromptType = self.response_type(value)
+            if return_value <= 0:
+                raise InvalidResponse(self.validate_error_message)
+        except ValueError:
+            raise InvalidResponse(self.validate_error_message)
+
+        return return_value
+
+
 # =============================================================================
 class BaseVmwareApplication(FbConfigApplication):
     """Base class for all VMware/vSphere application classes."""
 
+    term_colors = {
+        "kitty": "256",
+        "256color": "256",
+        "16color": "standard",
+    }
+
+    default_all_vspheres = True
+
     # -------------------------------------------------------------------------
     def __init__(
         self,
@@ -81,6 +136,7 @@ class BaseVmwareApplication(FbConfigApplication):
         """Initialize a BaseVmwareApplication object."""
         self.req_vspheres = None
         self.do_vspheres = []
+        self.rich_console = None
 
         if base_dir is None:
             base_dir = pathlib.Path(os.getcwd()).resolve()
@@ -107,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()
 
     # -------------------------------------------------------------------------
@@ -153,6 +209,23 @@ class BaseVmwareApplication(FbConfigApplication):
         if self.verbose > 2:
             LOG.debug(_("{what} of {app} ...").format(what="post_init()", app=self.appname))
 
+        args_color = getattr(self.args, "color", "auto")
+        if args_color == "auto":
+            self.rich_console = Console()
+        else:
+            color_system = None
+            if args_color == "yes":
+                color_term = os.environ.get("COLORTERM", "").strip().lower()
+                if color_term in ("truecolor", "24bit"):
+                    color_system = "truecolor"
+                else:
+                    color_system = "standard"
+                    term = os.environ.get("TERM", "").strip().lower()
+                    _term_name, _hyphen, colors = term.rpartition("-")
+                    color_system = self.term_colors.get(colors, "standard")
+
+            self.rich_console = Console(color_system=color_system)
+
         if not self.cfg.vsphere.keys():
             msg = _("Did not found any configured vSphere environments.")
             LOG.error(msg)
@@ -178,18 +251,22 @@ class BaseVmwareApplication(FbConfigApplication):
 
         if self.req_vspheres:
             self.do_vspheres = copy.copy(self.req_vspheres)
-        else:
+        elif self.default_all_vspheres:
             for vs_name in self.cfg.vsphere.keys():
                 self.do_vspheres.append(vs_name)
 
-        self.init_vsphere_handlers()
-
     # -------------------------------------------------------------------------
     def init_arg_parser(self):
         """Initiate the argument parser."""
+        self.add_vsphere_argument()
         super(BaseVmwareApplication, self).init_arg_parser()
 
-        self.arg_parser.add_argument(
+    # -------------------------------------------------------------------------
+    def add_vsphere_argument(self):
+        """Add a commandline option for selecting the vSphere to use."""
+        vsphere_options = self.arg_parser.add_argument_group(_("vSphere options"))
+
+        vsphere_options.add_argument(
             "--vs",
             "--vsphere",
             dest="req_vsphere",
@@ -203,6 +280,208 @@ class BaseVmwareApplication(FbConfigApplication):
         if self.verbose > 2:
             LOG.debug(_("Got command line arguments:") + "\n" + pp(self.args))
 
+    # -------------------------------------------------------------------------
+    def pre_run(self):
+        """Execute some actions before the main routine."""
+        LOG.debug(_("Actions before running main routine."))
+
+        self.init_vsphere_handlers()
+
+    # -------------------------------------------------------------------------
+    def select_storage_type(self, storage_type=None):
+        """Select a storage type for a virtual disk to create."""
+        types = {}
+        type_list = []
+        for st_type in VsphereDsCluster.valid_storage_types:
+            types[st_type.lower()] = st_type
+            type_list.append(st_type.lower())
+        types["any"] = "Any"
+        type_list.append("any")
+
+        if storage_type is not None:
+            if self.verbose > 2:
+                LOG.debug(f"Checking for storage type {storage_type!r} ...")
+            st_type = storage_type.lower()
+            if st_type in types:
+                return types[st_type]
+            msg = _("Invalid storage type {} given.").format(self.colored(st_type, "RED"))
+            raise VmwareAppError(msg)
+
+        if len(types) == 1:
+            idx = [types.keys()][0]
+            st_type = types[idx]
+            if self.verbose > 0:
+                LOG.debug(
+                    f"Automatic select of storage type {st_type!r}, because it is the only one."
+                )
+            return st_type
+
+        st_type = Prompt.ask(
+            _("Select a storage type to search for the a storage location"),
+            choices=type_list,
+            show_choices=True,
+            case_sensitive=False,
+            console=self.rich_console,
+        )
+
+        return types[st_type.lower()]
+
+    # -------------------------------------------------------------------------
+    def select_vsphere(self):
+        """Select exact one of the configured vSpheres."""
+        if self.do_vspheres and len(self.do_vspheres) == 1:
+            return self.do_vspheres[0]
+
+        if self.do_vspheres:
+            msg = _("There are multiple vSpheres selected on commandline.")
+            raise VmwareAppError(msg)
+
+        if not self.cfg.vsphere.keys():
+            msg = _("There are no configured vSpheres available.")
+            raise VmwareAppError(msg)
+
+        vspheres = []
+        for vs_name in self.cfg.vsphere.keys():
+            vspheres.append(vs_name)
+
+        vsphere = Prompt.ask(
+            _("Select the vSphere to search for the a storage location"),
+            choices=vspheres,
+            show_choices=True,
+            console=self.rich_console,
+        )
+
+        return vsphere
+
+    # -------------------------------------------------------------------------
+    def select_datacenter(self, vs_name, dc_name=None):
+        """Select a virtual datacenter from given vSphere."""
+        if not vs_name:
+            raise VmwareAppError(_("No vSphere name given."))
+        if vs_name not in self.vsphere:
+            raise VmwareAppError(
+                _("vSphere {} is not an active vSphere.").format(self.colored(vs_name, "RED"))
+            )
+
+        vsphere = self.vsphere[vs_name]
+        vsphere.get_datacenters()
+        dc_list = []
+        for _dc_name in vsphere.datacenters.keys():
+            dc_list.append(_dc_name)
+
+        if not len(dc_list):
+            msg = _("Did not found virtual datacenters in vSphere {}.").format(
+                self.colored(vs_name, "RED")
+            )
+            LOG.error(msg)
+            return None
+
+        if self.verbose > 2:
+            LOG.debug(f"Found datacenters in vSphere {vs_name}:\n" + pp(dc_list))
+
+        if dc_name:
+            if dc_name in dc_list:
+                return dc_name
+            msg = _("Datacenter {dc} does not exists in vSphere {vs}.").format(
+                dc=self.colored(dc_name, "RED"), vs=self.colored(vs_name, "CYAN")
+            )
+            LOG.error(msg)
+            return None
+
+        if len(dc_list) == 1:
+            if self.verbose > 0:
+                LOG.debug(
+                    f"Automatic select of datacenter {dc_list[0]!r}, because it is the only one."
+                )
+            return dc_list[0]
+
+        dc_name = Prompt.ask(
+            _("Select a virtual datacenter to search for the storage location"),
+            choices=sorted(dc_list, key=str.lower),
+            show_choices=True,
+            console=self.rich_console,
+        )
+
+        return dc_name
+
+    # -------------------------------------------------------------------------
+    def select_computing_cluster(self, vs_name, dc_name, cluster_name=None):
+        """Select a cluster computing resource or computing resource in a datacenter."""
+        if not vs_name:
+            raise VmwareAppError(_("No vSphere name given."))
+        if vs_name not in self.vsphere:
+            raise VmwareAppError(
+                _("vSphere {} is not an active vSphere.").format(self.colored(vs_name, "RED"))
+            )
+        vsphere = self.vsphere[vs_name]
+
+        if not dc_name:
+            raise VmwareAppError(_("No virtual datacenter name given."))
+        vsphere.get_datacenters()
+        if dc_name not in vsphere.datacenters:
+            msg = _("Datacenter {dc} not found in vSphere {vs}.").format(
+                dc=self.colored(dc_name, "RED"), vs=self.colored(vs_name, "CYAN")
+            )
+
+        cluster_list = []
+        cluster_type = {}
+        vsphere.get_clusters(search_in_dc=dc_name)
+        for _cluster in vsphere.clusters:
+            cluster_list.append(_cluster.name)
+            cluster_type[_cluster.name] = _("cluster computing resource")
+            if _cluster.standalone:
+                cluster_type[_cluster.name] = _("host computing resource")
+
+        if not len(cluster_list):
+            msg = _("Did not found computing resources in dc {dc} in vSphere {vs}.").format(
+                dc=self.colored(dc_name, "RED"),
+                vs=self.colored(vs_name, "RED"),
+            )
+            LOG.error(msg)
+            return (None, None)
+
+        if self.verbose > 1:
+            msg = f"Found computing resources in datacenter {dc_name} in vSphere {vs_name}:\n"
+            msg += pp(cluster_type)
+            LOG.debug(msg)
+
+        if cluster_name:
+            if cluster_name in cluster_list:
+                return (cluster_name, cluster_type[cluster_name])
+            msg = _(
+                "Computing resource {cl} does not exists in datacenter {dc} in vSphere {vs}."
+            ).format(
+                cl=self.colored(cluster_name, "RED"),
+                dc=self.colored(dc_name, "CYAN"),
+                vs=self.colored(vs_name, "CYAN"),
+            )
+            LOG.error(msg)
+            return (None, None)
+
+        if len(cluster_list) == 1:
+            if self.verbose > 0:
+                LOG.debug(
+                    f"Automatic select of computing resource {cluster_list[0]!r}, "
+                    "because it is the only one."
+                )
+            cluster_name = cluster_list[0]
+            return (cluster_name, cluster_type[cluster_name])
+
+        cluster_name = Prompt.ask(
+            _("Select a computing resource, which should be connected with the storage location"),
+            choices=sorted(cluster_list, key=str.lower),
+            show_choices=True,
+            console=self.rich_console,
+        )
+
+        return (cluster_name, cluster_type[cluster_name])
+
+    # -------------------------------------------------------------------------
+    def prompt_for_disk_size(self):
+        """Ask for the size of a virtual disk in GiByte."""
+        disk_size_gb = PositiveIntPrompt.ask(_("Get the size of the virtual disk in GiByte"))
+        return disk_size_gb
+
     # -------------------------------------------------------------------------
     def init_vsphere_handlers(self):
         """Initialize all vSphere handlers."""

fb_vmware/app/get_host_list.py

@@ -18,18 +18,25 @@ import sys
 from operator import itemgetter
 
 # Third party modules
+from babel.numbers import format_decimal
+
 from fb_tools.argparse_actions import RegexOptionAction
 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 ..host import VsphereHost
 from ..xlate import XLATOR
 
-__version__ = "1.4.0"
+__version__ = "1.5.6"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -66,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
@@ -112,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(
@@ -165,6 +168,8 @@ class GetHostsListApplication(BaseVmwareApplication):
             ),
         )
 
+        super(GetHostsListApplication, self).init_arg_parser()
+
     # -------------------------------------------------------------------------
     def perform_arg_parser(self):
         """Evaluate command line parameters."""
@@ -206,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):
@@ -269,6 +274,7 @@ class GetHostsListApplication(BaseVmwareApplication):
         summary["online"] = host.online
         summary["no_portgroups"] = str(len(host.portgroups))
         summary["power_state"] = host.power_state
+        summary["standby"] = host.standby
         summary["os_name"] = host.product.name
         summary["os_version"] = host.product.os_version
         summary["quarantaine"] = host.quarantaine
@@ -278,108 +284,113 @@ class GetHostsListApplication(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def print_hosts(self, hosts):
         """Print on STDOUT all information about all hosts in a human readable format."""
-        labels = {
-            "vsphere": "vSphere",
-            "dc": "DC",
-            "cluster": "Cluster",
-            "name": "Host",
-            "connection_state": _("Connect state"),
-            "cpus": _("CPU cores/threads"),
-            "memory_gb": _("Memory in GiB"),
-            "vendor": _("Vendor"),
-            "model": _("Model"),
-            "maintenance": _("Maintenance"),
-            "online": _("Online"),
-            # 'no_portgroups': _('Portgroups'),
-            "power_state": _("Power State"),
-            "os_name": _("OS Name"),
-            "os_version": _("OS Version"),
-            # 'quarantaine': _('Quarantaine'),
-        }
-
-        label_list = (
-            "name",
-            "dc",
-            "vsphere",
-            "cluster",
-            "vendor",
-            "model",
-            "os_name",
-            "os_version",
-            "cpus",
-            "memory_gb",
-            "power_state",
-            "connection_state",
-            "online",
-            "maintenance",
+        hosts.sort(key=itemgetter(*self.sort_keys))
+
+        show_header = True
+        table_title = _("All physical hosts") + "\n"
+        box_style = box.ROUNDED
+        if self.quiet:
+            show_header = False
+            table_title = None
+            box_style = None
+
+        if self.quiet:
+            caption = None
+        else:
+            count = len(hosts)
+            if count:
+                caption = "\n" + ngettext(
+                    "Found one VMware host.",
+                    "Found {} VMware hosts.",
+                    count,
+                ).format(count)
+            else:
+                caption = "\n" + _("Found no VMware hosts.")
+
+        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=False,
         )
 
-        str_lengths = {}
-        for label in labels:
-            str_lengths[label] = len(labels[label])
+        table.add_column(header=_("Host"))
+        table.add_column(header=_("vSphere"))
+        table.add_column(header=_("Data Center"))
+        table.add_column(header=_("Cluster"))
+        table.add_column(header=_("Vendor"))
+        table.add_column(header=_("Model"))
+        table.add_column(header=_("OS Name"))
+        table.add_column(header=_("OS Version"))
+        table.add_column(header=_("CPU cores/threads"), justify="right")
+        table.add_column(header=_("Memory in GiB"), justify="right")
+        table.add_column(header=_("Power State"))
+        table.add_column(header=_("Connect state"))
+        table.add_column(header=_("StandBy state"), justify="center")
+        table.add_column(header=_("Maintenance"), justify="center")
 
-        max_len = 0
-        count = 0
         for host in hosts:
-            for label in labels.keys():
-                val = host[label]
-                if val is None:
-                    val = "-"
-                    host[label] = val
-                else:
-                    if label == "memory_gb":
-                        val = "{:7.1f}".format(val)
-                        host[label] = val
-                    elif label in ("connection_state", "maintenance", "online", "quarantaine"):
-                        if val:
-                            val = _("Yes")
-                        else:
-                            val = _("No")
-                        host[label] = val
-                if len(val) > str_lengths[label]:
-                    str_lengths[label] = len(val)
-
-        for label in labels.keys():
-            if max_len:
-                max_len += 2
-            max_len += str_lengths[label]
-
-        if self.verbose > 1:
-            LOG.debug("Label length:\n" + pp(str_lengths))
-            LOG.debug("Max line length: {} chars".format(max_len))
-
-        tpl = ""
-        for label in label_list:
-            if tpl != "":
-                tpl += "  "
-            if label in ("memory_gb", "cpus", "no_portgroups"):
-                tpl += "{{{la}:>{le}}}".format(la=label, le=str_lengths[label])
+            row = []
+
+            row.append(host["name"])
+            row.append(host["vsphere"])
+            row.append(host["dc"])
+            row.append(host["cluster"])
+            row.append(host["vendor"])
+            row.append(host["model"])
+            row.append(host["os_name"])
+            row.append(host["os_version"])
+            row.append(host["cpus"])
+            row.append(format_decimal(host["memory_gb"], format="#,##0"))
+
+            power_state = host["power_state"]
+            if power_state in VsphereHost.power_state_label:
+                power_state = VsphereHost.power_state_label[power_state]
+            p_state = Text(power_state)
+            if host["power_state"].lower() == "poweredon":
+                p_state.stylize("bold green")
+            elif host["power_state"].lower() == "poweredoff":
+                p_state.stylize("bold red")
+            elif host["power_state"].lower() == "standby":
+                p_state.stylize("bold blue")
             else:
-                tpl += "{{{la}:<{le}}}".format(la=label, le=str_lengths[label])
-        if self.verbose > 1:
-            LOG.debug(_("Line template: {}").format(tpl))
+                p_state.stylize("bold magenta")
+            row.append(p_state)
+
+            connection_state = host["connection_state"]
+            if connection_state in VsphereHost.connect_state_label:
+                connection_state = VsphereHost.connect_state_label[connection_state]
+            c_state = Text(connection_state)
+            if host["connection_state"].lower() == "connected":
+                c_state.stylize("bold green")
+            elif host["connection_state"].lower() == "disconnected":
+                c_state.stylize("bold red")
+            else:
+                c_state.stylize("bold magenta")
+            row.append(c_state)
 
-        if not self.quiet:
-            print()
-            print(tpl.format(**labels))
-            print("-" * max_len)
+            standby = host["standby"]
+            if standby == "none":
+                standby = "~"
+            if standby in VsphereHost.standby_mode_label:
+                standby = VsphereHost.standby_mode_label[standby]
+            row.append(standby)
 
-        hosts.sort(key=itemgetter(*self.sort_keys))
+            m_state = Text(_("No"), style="bold green")
+            if host["maintenance"]:
+                m_state = Text(_("Yes"), style="bold yellow")
+            row.append(m_state)
 
-        for host in hosts:
-            count += 1
-            print(tpl.format(**host))
+            table.add_row(*row)
+
+        self.rich_console.print(table)
 
         if not self.quiet:
             print()
-            if count == 0:
-                msg = _("Found no VMware hosts.")
-            else:
-                msg = ngettext("Found one VMware host.", "Found {} VMware hosts.", count).format(
-                    count
-                )
-            print(msg)
-            print()
 
     # -------------------------------------------------------------------------
     def get_hosts(self, vsphere_name):
@@ -416,7 +427,11 @@ def main():
     if app.verbose > 2:
         print(_("{c}-Object:\n{a}").format(c=app.__class__.__name__, a=app), file=sys.stderr)
 
-    app()
+    try:
+        app()
+    except KeyboardInterrupt:
+        print("\n" + app.colored(_("User interrupt."), "YELLOW"))
+        sys.exit(5)
 
     sys.exit(0)