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

fb_vmware/app/get_vm_info.py

@@ -16,6 +16,9 @@ import pathlib
 import sys
 from operator import attrgetter
 
+# Third party modules
+from fb_tools.spinner import Spinner
+
 # Own modules
 from . import BaseVmwareApplication, VmwareAppError
 from .. import __version__ as GLOBAL_VERSION
@@ -24,7 +27,7 @@ from ..errors import VSphereExpectedError
 from ..ether import VsphereEthernetcard
 from ..xlate import XLATOR
 
-__version__ = "1.8.0"
+__version__ = "1.10.0"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -132,11 +135,23 @@ class GetVmApplication(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def show_vm(self, vm_name):
         """Show a particular VM on STDOUT."""
-        print("\n{}: ".format(vm_name), end="")
+        print()
+        msg_tpl = _("Getting data of VM {} ... ")
         if self.verbose:
-            print()
-
-        vm = self._get_vm_data(vm_name)
+            msg = msg_tpl.format(self.colored(vm_name, "CYAN"))
+            print(msg)
+            vm = self._get_vm_data(vm_name)
+        else:
+            msg_len = len(msg_tpl.format(vm_name))
+            spin_prompt = msg_tpl.format(self.colored(vm_name, "CYAN"))
+            spinner_name = self.get_random_spinner_name()
+            with Spinner(spin_prompt, spinner_name):
+                vm = self._get_vm_data(vm_name)
+            sys.stdout.write(" " * msg_len)
+            sys.stdout.write("\r")
+            sys.stdout.flush()
+
+        print("{}: ".format(vm_name), end="")
         if not vm:
             print(self.colored(_("NOT FOUND"), "RED"))
             return False
@@ -190,6 +205,24 @@ class GetVmApplication(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def _print_ctrlrs(self, vm):
 
+        ctrl_lbl = _("Controller") + ":"
+        len_ctrl_lbl = len(ctrl_lbl)
+
+        len_no_disk = 1
+        len_ctrl_no = 1
+        for ctrlr in filter(lambda x: x.scsi_ctrl_nr is not None, vm.controllers):
+            nr_disks = len(ctrlr.devices)
+            no_disk = ngettext("{nr:>2} disk ", "{nr:>2} disks", nr_disks).format(nr=nr_disks)
+            if len(no_disk) > len_no_disk:
+                len_no_disk = len(no_disk)
+            if len(str(ctrlr.bus_nr)) > len_ctrl_no:
+                len_ctrl_no = len(str(ctrlr.bus_nr))
+
+        line_template = (
+            f"    {{la:<{len_ctrl_lbl}}}  {{nr:>{len_ctrl_no}}} - {{di:<{len_no_disk}}} - {{ty}}"
+        )
+        # LOG.debug(f"Line template: {line_template!r}")
+
         first = True
         for ctrlr in sorted(
             filter(lambda x: x.scsi_ctrl_nr is not None, vm.controllers), key=attrgetter("bus_nr")
@@ -198,28 +231,46 @@ class GetVmApplication(BaseVmwareApplication):
                 continue
             label = ""
             if first:
-                label = "Controller:"
+                label = ctrl_lbl
             first = False
             ctype = _("Unknown")
             nr_disks = len(ctrlr.devices)
             if ctrlr.ctrl_type in VsphereDiskController.type_names.keys():
                 ctype = VsphereDiskController.type_names[ctrlr.ctrl_type]
             no_disk = ngettext("{nr:>2} disk ", "{nr:>2} disks", nr_disks).format(nr=nr_disks)
-            # no_disk = _("{nr:>2} disks").format(nr=len(ctrlr.devices))
-            # if len(ctrlr.devices) == 1:
-            #     no_disk = _(" 1 disk ")
-            msg = "    {la:<15}  {nr:>2} - {di} - {ty}".format(
-                la=label, nr=ctrlr.bus_nr, di=no_disk, ty=ctype
-            )
+            msg = line_template.format(la=label, nr=ctrlr.bus_nr, di=no_disk, ty=ctype)
             print(msg)
 
     # -------------------------------------------------------------------------
     def _print_disks(self, vm):
 
         if not vm.disks:
-            print("    Disks:       {}".format(_("None")))
+            print("    " + _("Disks") + ":       " + _("None"))
             return
 
+        ctrl_lbl = _("Controller")
+        file_lbl = _("File")
+        len_disk_lbl = 1
+        len_ctrl_lbl = len(ctrl_lbl)
+        len_ctrlr_nr = 1
+
+        for disk in vm.disks:
+            if len(disk.label) > len_disk_lbl:
+                len_disk_lbl = len(disk.label)
+            ctrlr_nr = -1
+            for ctrlr in vm.controllers:
+                if disk.key in ctrlr.devices:
+                    ctrlr_nr = ctrlr.bus_nr
+                    break
+            if len(str(ctrlr_nr)) > len_ctrlr_nr:
+                len_ctrlr_nr = len(str(ctrlr_nr))
+
+        line_template = f"    {{la}}  {{n:<{len_disk_lbl}}}"
+        line_template += f" - {{s:7.1f}} GiB - {{ctrl_lbl:<{len_ctrl_lbl}}}"
+        line_template += f" {{c:>{len_ctrlr_nr}}}"
+        line_template += " - {file_lbl} {f}"
+        # LOG.debug(f"Line template: {line_template!r}")
+
         total_gb = 0.0
         first = True
         for disk in vm.disks:
@@ -233,8 +284,14 @@ class GetVmApplication(BaseVmwareApplication):
                 if disk.key in ctrlr.devices:
                     ctrlr_nr = ctrlr.bus_nr
                     break
-            msg = "    {la}  {n:<15} - {s:7.1f} GiB - Controller {c:>2} - File {f}".format(
-                la=label, n=disk.label, s=disk.size_gb, c=ctrlr_nr, f=disk.file_name
+            msg = line_template.format(
+                la=label,
+                n=disk.label,
+                s=disk.size_gb,
+                ctrl_lbl=ctrl_lbl,
+                c=ctrlr_nr,
+                file_lbl=file_lbl,
+                f=disk.file_name,
             )
             print(msg)
         if len(vm.disks) > 1:
@@ -303,7 +360,8 @@ class GetVmApplication(BaseVmwareApplication):
                     vm=self.colored(vm_name, "CYAN"), vs=self.colored(vsphere_name, "CYAN")
                 )
             )
-            vm = vsphere.get_vm(vm_name, vsphere_name=vsphere_name, no_error=True, as_obj=True)
+            vm = vsphere.get_vm_direct(vm_name, vsphere_name=vsphere_name, no_error=True)
+            # vm = vsphere.get_vm(vm_name, vsphere_name=vsphere_name, no_error=True)
             if not vm:
                 continue
 
@@ -337,7 +395,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)
 

fb_vmware/app/get_vm_list.py

@@ -10,6 +10,7 @@
 from __future__ import absolute_import, print_function
 
 # Standard modules
+import argparse
 import locale
 import logging
 import pathlib
@@ -19,10 +20,16 @@ from operator import attrgetter, itemgetter
 
 # Third party modules
 from fb_tools.argparse_actions import RegexOptionAction
-from fb_tools.common import pp, to_bool
+from fb_tools.common import is_sequence
+from fb_tools.common import pp
+from fb_tools.common import to_bool
 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
@@ -30,7 +37,7 @@ from ..errors import VSphereExpectedError
 from ..vm import VsphereVm
 from ..xlate import XLATOR
 
-__version__ = "1.9.0"
+__version__ = "1.12.1"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -44,6 +51,51 @@ class GetVmListAppError(VmwareAppError):
     pass
 
 
+# =============================================================================
+class RegexListOptionAction(argparse.Action):
+    """An argparse action for regular expressions."""
+
+    # -------------------------------------------------------------------------
+    def __init__(self, option_strings, topic, re_options=None, *args, **kwargs):
+        """Initialise a RegexListOptionAction object."""
+        self._topic = topic
+        self._re_options = None
+        if re_options is not None:
+            self._re_options = re_options
+
+        super(RegexListOptionAction, self).__init__(*args, option_strings=option_strings, **kwargs)
+
+    # -------------------------------------------------------------------------
+    def __call__(self, parser, namespace, pattern, option_string=None):
+        """Parse the regular expression option."""
+        try:
+            if is_sequence(pattern):
+                if len(pattern) > 1:
+                    used_pattern = []
+                    for pat in pattern:
+                        used_pattern.append("(" + pat + ")")
+                    pattern_all = "|".join(used_pattern)
+                elif len(pattern) == 1:
+                    pattern_all = pattern[0]
+                else:
+                    pattern_all = None
+            else:
+                pattern_all = pattern
+
+            if pattern_all is not None:
+                if self._re_options is None:
+                    re_test = re.compile(pattern_all)  # noqa
+                else:
+                    re_test = re.compile(pattern_all, self._re_options)  # noqa
+        except Exception as e:
+            msg = _("Got a {c} for pattern {p!r}: {e}").format(
+                c=e.__class__.__name__, p=pattern_all, e=e
+            )
+            raise argparse.ArgumentError(self, msg)
+
+        setattr(namespace, self.dest, pattern_all)
+
+
 # =============================================================================
 class GetVmListApplication(BaseVmwareApplication):
     """Class for the application objects."""
@@ -83,6 +135,7 @@ class GetVmListApplication(BaseVmwareApplication):
 
         self._vm_pattern = self.default_vm_pattern
         self._details = False
+        self.count_templates = None
 
         self.sort_keys = self.default_sort_keys
 
@@ -156,12 +209,10 @@ class GetVmListApplication(BaseVmwareApplication):
         filter_group = self.arg_parser.add_argument_group(_("Filter options"))
 
         filter_group.add_argument(
-            "-p",
-            "--pattern",
-            "--search-pattern",
             dest="vm_pattern",
+            nargs="*",
             metavar="REGEX",
-            action=RegexOptionAction,
+            action=RegexListOptionAction,
             topic=_("for names of VMs"),
             re_options=re.IGNORECASE,
             help=_(
@@ -295,7 +346,7 @@ class GetVmListApplication(BaseVmwareApplication):
                     else:
                         LOG.warn(
                             _(
-                                "Sorting key {!r} not usable, if not detailed output " "was given."
+                                "Sorting key {!r} not usable, if not detailed output was given."
                             ).format(key)
                         )
                 if not self.sort_keys:
@@ -335,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):
@@ -351,99 +402,101 @@ class GetVmListApplication(BaseVmwareApplication):
         if self.verbose > 1:
             LOG.debug(_("Using sorting keys:") + " " + format_list(self.sort_keys, do_repr=True))
 
-        if self.details:
-            self.print_vms_detailed(all_vms)
-        else:
-            self.print_vms(all_vms)
+        self.print_virtual_machines(all_vms)
 
         return ret
 
     # -------------------------------------------------------------------------
-    def print_vms(self, all_vms):
+    def print_virtual_machines(self, all_vms):
         """Print out on STDOUT the list of found VMs."""
-        label_list = ("name", "vsphere", "dc", "path")
-        labels = {
-            "name": _("Host"),
-            "vsphere": "vSphere",
-            "dc": _("Data Center"),
-            "path": _("Path"),
-        }
-
-        self._print_vms(all_vms, label_list, labels)
-
-    # -------------------------------------------------------------------------
-    def print_vms_detailed(self, all_vms):
-        """Print out on STDOUT the list of found VMs in a detailled way."""
-        label_list = self.avail_sort_keys
-        labels = {
-            "name": "VM/Template",
-            "vsphere": "vSphere",
-            "dc": _("Data Center"),
-            "cluster": _("Cluster"),
-            "path": _("Path"),
-            "type": _("Type"),
-            "onl_str": _("Online Status"),
-            "cfg_ver": _("Config Version"),
-            "os": _("Operating System"),
-        }
-
-        self._print_vms(all_vms, label_list, labels)
-
-    # -------------------------------------------------------------------------
-    def _print_vms(self, all_vms, label_list, labels):
-
-        str_lengths = {}
-        for label in labels.keys():
-            str_lengths[label] = len(labels[label])
-
-        max_len = 0
-        count = 0
-        for cdata in all_vms:
-            for field in ("cluster", "path", "type", "cfg_ver", "os"):
-                if field in labels and cdata[field] is None:
-                    cdata[field] = "~"
-            for label in labels.keys():
-                val = cdata[label]
-                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 += "  "
-            tpl += "{{{la}:<{le}}}".format(la=label, le=str_lengths[label])
-        if self.verbose > 1:
-            LOG.debug(_("Line template: {}").format(tpl))
-
-        if not self.quiet:
-            print()
-            print(tpl.format(**labels))
-            print("-" * max_len)
+            LOG.debug("Print out VM list: " + pp(all_vms))
 
         all_vms.sort(key=itemgetter(*self.sort_keys))
 
-        for cdata in all_vms:
-            count += 1
+        show_header = True
+        title = _("Virtual Machines")
+        title += "\n" + ("=" * len(title))
+        box_style = box.ROUNDED
+        if self.quiet:
+            show_header = False
+            title = None
+            box_style = None
+
+        if self.quiet:
+            caption = None
+        else:
+            count = len(all_vms)
+            if count:
+                caption = "\n" + ngettext(
+                    "Found one virtual machine.",
+                    "Found {} virtual machines.",
+                    count,
+                ).format(count)
+            else:
+                caption = "\n" + _("No virtual machines found.")
+
+            if self.count_templates is not None:
+                if self.count_templates:
+                    caption += "\n" + ngettext(
+                        "One VM of them is a template.",
+                        "{} VMs of them are templates.",
+                        self.count_templates,
+                    ).format(self.count_templates)
+            caption += "\n"
+
+        table = Table(
+            title=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,
+        )
+
+        table.add_column(header="VM/Template")
+        table.add_column(header="vSphere")
+        table.add_column(header=_("Data Center"))
+        if self.details:
+            table.add_column(header=_("Cluster"))
+        table.add_column(header=_("Path"))
+        if self.details:
+            table.add_column(header=_("Type"))
+            table.add_column(header=_("Online Status"))
+            table.add_column(header=_("Config Version"))
+            table.add_column(header=_("Operating System"))
 
-            print(tpl.format(**cdata))
+        for vm in all_vms:
 
-        if not self.quiet:
-            print()
-            if count == 0:
-                msg = _("Found no VMware VMs.")
+            if self.details:
+                online_status = Text(vm["onl_str"], style="bold green")
+                if vm["is_template"]:
+                    online_status = Text(vm["onl_str"], style="bold cyan")
+                elif not vm["is_online"]:
+                    online_status = Text(vm["onl_str"], style="bold red")
+
+                table.add_row(
+                    vm["name"],
+                    vm["vsphere"],
+                    vm["dc"],
+                    vm["cluster"],
+                    vm["path"],
+                    vm["type"],
+                    online_status,
+                    vm["cfg_ver"],
+                    vm["os"],
+                )
             else:
-                msg = ngettext("Found one VMware VM.", "Found {} VMware VMs.", count).format(count)
-            print(msg)
-            print()
+                table.add_row(
+                    vm["name"],
+                    vm["vsphere"],
+                    vm["dc"],
+                    vm["path"],
+                )
+
+        self.rich_console.print(table)
 
     # -------------------------------------------------------------------------
     def get_vms(self, vsphere_name, re_name=None):
@@ -455,10 +508,16 @@ class GetVmListApplication(BaseVmwareApplication):
             re_name = re.compile(self.vm_pattern, re.IGNORECASE)
 
         if self.details:
-            vm_list = vsphere.get_vms(re_name, vsphere_name=vsphere_name, as_obj=True)
+            # vm_list = vsphere.get_vms(re_name, vsphere_name=vsphere_name, as_obj=True)
+            vm_list = vsphere.get_vm_list(
+                re_name, vsphere_name=vsphere_name, name_only=False, disconnect=True
+            )
             vms = self.mangle_vmlist_details(vm_list, vsphere_name)
         else:
-            vm_list = vsphere.get_vms(re_name, vsphere_name=vsphere_name, name_only=True)
+            # vm_list = vsphere.get_vms(re_name, vsphere_name=vsphere_name, name_only=True)
+            vm_list = vsphere.get_vm_list(
+                re_name, vsphere_name=vsphere_name, name_only=True, disconnect=True
+            )
             vms = self.mangle_vmlist_no_details(vm_list, vsphere_name)
 
         return vms
@@ -466,6 +525,8 @@ class GetVmListApplication(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def mangle_vmlist_no_details(self, vm_list, vsphere_name):
         """Prepare the non-detailled data about found VMs for output."""
+        if self.verbose > 1:
+            LOG.debug(_("Performing VM list ..."))
         if self.verbose > 3:
             LOG.debug("Mangling VM list:\n" + pp(vm_list))
 
@@ -485,7 +546,7 @@ class GetVmListApplication(BaseVmwareApplication):
             }
 
             if cdata["path"]:
-                cdata["path"] = "/" + cdata["path"]
+                cdata["path"] = cdata["path"]
             else:
                 cdata["path"] = "/"
 
@@ -501,8 +562,12 @@ class GetVmListApplication(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def mangle_vmlist_details(self, vm_list, vsphere_name):
         """Prepare the detailled data about found VMs for output."""
+        if self.verbose > 1:
+            LOG.debug(_("Performing detailled VM list ..."))
         vms = []
 
+        self.count_templates = 0
+
         first = True
         for vm in sorted(vm_list, key=attrgetter("name", "path")):
 
@@ -571,10 +636,12 @@ class GetVmListApplication(BaseVmwareApplication):
             "onl_str": "Online",
             "cfg_ver": vm.config_version,
             "os": vm.guest_id,
+            "is_online": True,
+            "is_template": False,
         }
 
         if cdata["path"]:
-            cdata["path"] = "/" + cdata["path"]
+            cdata["path"] = cdata["path"]
         else:
             cdata["path"] = "/"
 
@@ -586,9 +653,12 @@ class GetVmListApplication(BaseVmwareApplication):
 
         if not vm.online:
             cdata["onl_str"] = "Offline"
+            cdata["is_online"] = False
 
         if vm.template:
             cdata["type"] = "VMware Template"
+            cdata["is_template"] = True
+            self.count_templates += 1
 
         return cdata
 
@@ -607,7 +677,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)