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

fb_vmware/app/get_storage_cluster_list.py

@@ -24,6 +24,10 @@ 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
 from . import VmwareAppError
@@ -32,7 +36,7 @@ from ..ds_cluster import VsphereDsClusterDict
 from ..errors import VSphereExpectedError
 from ..xlate import XLATOR
 
-__version__ = "1.3.1"
+__version__ = "1.5.0"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -60,6 +64,8 @@ class GetStorageClusterListApp(BaseVmwareApplication):
     )
     default_sort_keys = ["vsphere_name", "cluster_name"]
 
+    show_simulate_option = False
+
     # -------------------------------------------------------------------------
     def __init__(
         self,
@@ -120,8 +126,6 @@ class GetStorageClusterListApp(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def init_arg_parser(self):
         """Public available method to initiate the argument parser."""
-        super(GetStorageClusterListApp, self).init_arg_parser()
-
         output_options = self.arg_parser.add_argument_group(_("Output options"))
 
         output_options.add_argument(
@@ -148,6 +152,8 @@ class GetStorageClusterListApp(BaseVmwareApplication):
             ),
         )
 
+        super(GetStorageClusterListApp, self).init_arg_parser()
+
     # -------------------------------------------------------------------------
     def perform_arg_parser(self):
         """Evaluate command line parameters."""
@@ -243,6 +249,8 @@ class GetStorageClusterListApp(BaseVmwareApplication):
                 cluster["vsphere_name"] = vsphere_name
                 cluster["dc"] = cl.dc_name
 
+                cluster["storage_type"] = cl.storage_type
+
                 cluster["capacity"] = cl.capacity_gb
                 cluster["capacity_gb"] = format_decimal(cl.capacity_gb, format="#,##0")
                 total_capacity += cl.capacity_gb
@@ -260,104 +268,50 @@ class GetStorageClusterListApp(BaseVmwareApplication):
                     cluster["usage_pc"] = usage_pc
                     cluster["usage_pc_out"] = format_decimal(usage_pc, format="0.0 %")
                 else:
+                    cluster["usage_pc"] = None
                     cluster["usage_pc_out"] = "- %"
 
                 cluster_list.append(cluster)
 
-        if self.print_total:
-            total_used = total_capacity - total_free
-            total_used_pc = None
-            total_used_pc_out = "- %"
-            if total_capacity:
-                total_used_pc = total_used / total_capacity
-                total_used_pc_out = format_decimal(total_used_pc, format="0.0 %")
-
-            self.totals = {
-                "cluster_name": _("Total"),
-                "vsphere_name": "",
-                "dc": "",
-                "is_total": True,
-                "capacity_gb": format_decimal(total_capacity, format="#,##0"),
-                "free_space_gb": format_decimal(total_free, format="#,##0"),
-                "usage_gb": format_decimal(total_used, format="#,##0"),
-                "usage_pc_out": total_used_pc_out,
-            }
-            if not self.quiet:
-                self.totals["cluster_name"] += ":"
+        total_used = total_capacity - total_free
+        total_used_pc = None
+        total_used_pc_out = "- %"
+        if total_capacity:
+            total_used_pc = total_used / total_capacity
+            total_used_pc_out = format_decimal(total_used_pc, format="0.0 %")
+
+        self.totals = {
+            "cluster_name": _("Total"),
+            "storage_type": "",
+            "vsphere_name": "",
+            "dc": "",
+            "is_total": True,
+            "capacity_gb": format_decimal(total_capacity, format="#,##0"),
+            "free_space_gb": format_decimal(total_free, format="#,##0"),
+            "usage_gb": format_decimal(total_used, format="#,##0"),
+            "usage_pc_out": total_used_pc_out,
+        }
+        if not self.quiet:
+            self.totals["cluster_name"] += ":"
 
         return cluster_list
 
-    # -------------------------------------------------------------------------
-    def _get_cluster_fields_len(self, cluster_list, labels):
-
-        field_length = {}
-
-        for label in labels.keys():
-            field_length[label] = len(labels[label])
-
-        for cluster in cluster_list:
-            for label in labels.keys():
-                field = cluster[label]
-                if len(field) > field_length[label]:
-                    field_length[label] = len(field)
-
-        if self.totals:
-            for label in labels.keys():
-                field = self.totals[label]
-                if len(field) > field_length[label]:
-                    field_length[label] = len(field)
-
-        return field_length
-
     # -------------------------------------------------------------------------
     def print_clusters(self, clusters):
         """Print on STDOUT all information about all datastore clusters."""
-        labels = {
-            "cluster_name": "Cluster",
-            "vsphere_name": "vSphere",
-            "dc": _("Data Center"),
-            "capacity_gb": _("Capacity in GB"),
-            "free_space_gb": _("Free space in GB"),
-            "usage_gb": _("Calculated usage in GB"),
-            "usage_pc_out": _("Usage in percent"),
-        }
-
-        label_list = (
-            "cluster_name",
-            "vsphere_name",
-            "dc",
-            "capacity_gb",
-            "usage_gb",
-            "usage_pc_out",
-            "free_space_gb",
-        )
+        show_footer = False
+        if self.print_total and not self.quiet:
+            show_footer = True
+
+        show_header = True
+        table_title = _("All datastore clusters") + "\n"
+        box_style = box.ROUNDED
+        if self.quiet:
+            show_header = False
+            table_title = None
+            box_style = None
 
         cluster_list = self._get_cluster_list(clusters)
-        field_length = self._get_cluster_fields_len(cluster_list, labels)
-
-        max_len = 0
-        count = len(cluster_list)
-
-        for label in labels.keys():
-            if max_len:
-                max_len += 2
-            max_len += field_length[label]
-
-        if self.verbose > 2:
-            LOG.debug("Label length:\n" + pp(field_length))
-            LOG.debug("Max line length: {} chars".format(max_len))
-            LOG.debug("Datastore clusters:\n" + pp(cluster_list))
-
-        tpl = ""
-        for label in label_list:
-            if tpl != "":
-                tpl += "  "
-            if label in ("cluster_name", "vsphere_name", "dc"):
-                tpl += "{{{la}:<{le}}}".format(la=label, le=field_length[label])
-            else:
-                tpl += "{{{la}:>{le}}}".format(la=label, le=field_length[label])
-        if self.verbose > 1:
-            LOG.debug(_("Line template: {}").format(tpl))
 
         if self.sort_keys:
             LOG.debug("Sorting keys: " + pp(self.sort_keys))
@@ -368,31 +322,70 @@ class GetStorageClusterListApp(BaseVmwareApplication):
                 else:
                     cluster_list.sort(key=itemgetter(key), reverse=True)
 
-        if not self.quiet:
-            print()
-            print(tpl.format(**labels))
-            print("-" * max_len)
-
-        for cluster in cluster_list:
-            print(tpl.format(**cluster))
-
-        if self.totals:
-            if not self.quiet:
-                print("-" * max_len)
-            print(tpl.format(**self.totals))
-
-        if not self.quiet:
-            print()
+        if self.quiet:
+            caption = None
+        else:
+            count = len(cluster_list)
             if count:
-                msg = ngettext(
+                caption = "\n" + ngettext(
                     "Found one VMware storage cluster.",
                     "Found {} VMware storage clusters.",
                     count,
                 ).format(count)
             else:
-                msg = _("No VMware storage clusters found.")
+                caption = "\n" + _("No VMware storage clusters found.")
+
+        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="Cluster", footer=_("Total"))
+        table.add_column(header=_("Type"), justify="center", footer="")
+        table.add_column(header=_("vSphere"), footer="")
+        table.add_column(header=_("Data Center"), footer="")
+        table.add_column(
+            header=_("Capacity in GB"), footer=self.totals["capacity_gb"], justify="right"
+        )
+        table.add_column(
+            header=_("Calculated usage in GB"), footer=self.totals["usage_gb"], justify="right"
+        )
+        table.add_column(
+            header=_("Usage in percent"), footer=self.totals["usage_pc_out"], justify="right"
+        )
+        table.add_column(
+            header=_("Free space in GB"), footer=self.totals["free_space_gb"], justify="right"
+        )
 
-            print(msg)
+        for cluster in cluster_list:
+            used_pc_out = Text(cluster["usage_pc_out"])
+            if cluster["usage_pc"] is None:
+                used_pc_out.stylize("bold magenta")
+            elif cluster["usage_pc"] >= 0.9:
+                used_pc_out.stylize("bold red")
+            elif cluster["usage_pc"] >= 0.8:
+                used_pc_out.stylize("bold yellow")
+
+            table.add_row(
+                cluster["cluster_name"],
+                cluster["storage_type"],
+                cluster["vsphere_name"],
+                cluster["dc"],
+                cluster["capacity_gb"],
+                cluster["usage_gb"],
+                used_pc_out,
+                cluster["free_space_gb"],
+            )
+
+        self.rich_console.print(table)
+
+        if not self.quiet:
             print()
 
 

fb_vmware/app/get_storage_list.py

@@ -24,6 +24,10 @@ 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
 from . import VmwareAppError
@@ -32,7 +36,7 @@ from ..datastore import VsphereDatastoreDict
 from ..errors import VSphereExpectedError
 from ..xlate import XLATOR
 
-__version__ = "1.0.2"
+__version__ = "1.3.0"
 LOG = logging.getLogger(__name__)
 
 _ = XLATOR.gettext
@@ -62,6 +66,8 @@ class GetStorageListApp(BaseVmwareApplication):
     )
     default_sort_keys = ["vsphere_name", "dc", "ds_name"]
 
+    show_simulate_option = False
+
     # -------------------------------------------------------------------------
     def __init__(
         self,
@@ -83,6 +89,7 @@ class GetStorageListApp(BaseVmwareApplication):
         self._print_total = True
         self._no_local = False
         self.totals = None
+        self._detailled = False
         self.sort_keys = self.default_sort_keys
 
         super(GetStorageListApp, self).__init__(
@@ -108,6 +115,12 @@ class GetStorageListApp(BaseVmwareApplication):
         """Don't print out local datastores on the ESX hosts."""
         return self._no_local
 
+    # -------------------------------------------------------------------------
+    @property
+    def detailled(self):
+        """Print out a more detailled info about the datastores."""
+        return self._detailled
+
     # -------------------------------------------------------------------------
     def as_dict(self, short=True):
         """
@@ -120,6 +133,7 @@ class GetStorageListApp(BaseVmwareApplication):
         @rtype:  dict
         """
         res = super(GetStorageListApp, self).as_dict(short=short)
+        res["detailled"] = self.detailled
         res["no_local"] = self.no_local
         res["print_total"] = self.print_total
 
@@ -128,8 +142,6 @@ class GetStorageListApp(BaseVmwareApplication):
     # -------------------------------------------------------------------------
     def init_arg_parser(self):
         """Public available method to initiate the argument parser."""
-        super(GetStorageListApp, self).init_arg_parser()
-
         output_options = self.arg_parser.add_argument_group(_("Output options"))
 
         output_options.add_argument(
@@ -148,6 +160,17 @@ class GetStorageListApp(BaseVmwareApplication):
             help=_("Don't print the totals of all datastores."),
         )
 
+        output_options.add_argument(
+            "-D",
+            "--detailled",
+            action="store_true",
+            dest="detailled",
+            help=_(
+                "Print out a more detailled info about the datastores, e.g. the number of "
+                "connected hosts. Tooks significant more time to retrieve the data from vSphere."
+            ),
+        )
+
         output_options.add_argument(
             "-S",
             "--sort",
@@ -164,6 +187,8 @@ class GetStorageListApp(BaseVmwareApplication):
             ),
         )
 
+        super(GetStorageListApp, self).init_arg_parser()
+
     # -------------------------------------------------------------------------
     def perform_arg_parser(self):
         """Evaluate command line parameters."""
@@ -178,6 +203,9 @@ class GetStorageListApp(BaseVmwareApplication):
         if getattr(self.args, "no_local", False):
             self._no_local = True
 
+        if getattr(self.args, "detailled", False):
+            self._detailled = True
+
     # -------------------------------------------------------------------------
     def _run(self):
 
@@ -201,7 +229,7 @@ class GetStorageListApp(BaseVmwareApplication):
         if self.no_local:
             no_local_ds = True
         try:
-            vsphere.get_datastores(no_local_ds=no_local_ds)
+            vsphere.get_datastores(no_local_ds=no_local_ds, detailled=self.detailled)
         except VSphereExpectedError as e:
             LOG.error(str(e))
             self.exit(6)
@@ -253,15 +281,29 @@ class GetStorageListApp(BaseVmwareApplication):
         total_capacity = 0.0
         total_free = 0.0
 
+        first = True
+
         for vsphere_name in datastores.keys():
             for ds_name in datastores[vsphere_name].keys():
 
                 ds = datastores[vsphere_name][ds_name]
+
+                if self.verbose == 2 and first:
+                    LOG.debug("First found datastore:\n" + pp(ds.as_dict()))
+                    first = False
+
                 datastore = {}
                 datastore["is_total"] = False
 
+                datastore["storage_type"] = ds.storage_type
+
                 datastore["ds_name"] = ds_name
 
+                if hasattr(ds, "hosts"):
+                    datastore["hosts"] = str(len(ds.hosts))
+                else:
+                    datastore["hosts"] = "~"
+
                 datastore["vsphere_name"] = vsphere_name
                 datastore["dc"] = ds.dc_name
                 datastore["cluster"] = "~"
@@ -285,107 +327,51 @@ class GetStorageListApp(BaseVmwareApplication):
                     datastore["usage_pc"] = usage_pc
                     datastore["usage_pc_out"] = format_decimal(usage_pc, format="0.0 %")
                 else:
+                    datastore["usage_pc"] = None
                     datastore["usage_pc_out"] = "- %"
 
                 datastore_list.append(datastore)
 
-        if self.print_total:
-            total_used = total_capacity - total_free
-            total_used_pc = None
-            total_used_pc_out = "- %"
-            if total_capacity:
-                total_used_pc = total_used / total_capacity
-                total_used_pc_out = format_decimal(total_used_pc, format="0.0 %")
-
-            self.totals = {
-                "ds_name": _("Total"),
-                "vsphere_name": "",
-                "dc": "",
-                "cluster": "",
-                "is_total": True,
-                "capacity_gb": format_decimal(total_capacity, format="#,##0"),
-                "free_space_gb": format_decimal(total_free, format="#,##0"),
-                "usage_gb": format_decimal(total_used, format="#,##0"),
-                "usage_pc_out": total_used_pc_out,
-            }
-            if not self.quiet:
-                self.totals["ds_name"] += ":"
+        total_used = total_capacity - total_free
+        total_used_pc = None
+        total_used_pc_out = "- %"
+        if total_capacity:
+            total_used_pc = total_used / total_capacity
+            total_used_pc_out = format_decimal(total_used_pc, format="0.0 %")
+
+        self.totals = {
+            "ds_name": _("Total"),
+            "vsphere_name": "",
+            "hosts": "",
+            "dc": "",
+            "cluster": "",
+            "is_total": True,
+            "capacity_gb": format_decimal(total_capacity, format="#,##0"),
+            "free_space_gb": format_decimal(total_free, format="#,##0"),
+            "usage_gb": format_decimal(total_used, format="#,##0"),
+            "usage_pc_out": total_used_pc_out,
+        }
+        if not self.quiet:
+            self.totals["ds_name"] += ":"
 
         return datastore_list
 
-    # -------------------------------------------------------------------------
-    def _get_ds_fields_len(self, datastore_list, labels):
-
-        field_length = {}
-
-        for label in labels.keys():
-            field_length[label] = len(labels[label])
-
-        for ds in datastore_list:
-            for label in labels.keys():
-                field = ds[label]
-                if len(field) > field_length[label]:
-                    field_length[label] = len(field)
-
-        if self.totals:
-            for label in labels.keys():
-                field = self.totals[label]
-                if len(field) > field_length[label]:
-                    field_length[label] = len(field)
-
-        return field_length
-
     # -------------------------------------------------------------------------
     def print_datastores(self, all_datastores):
         """Print on STDOUT all information about all datastore clusters."""
-        labels = {
-            "ds_name": _("Datastore"),
-            "vsphere_name": "vSphere",
-            "dc": _("Data Center"),
-            "cluster": _("Cluster"),
-            "capacity_gb": _("Capacity in GB"),
-            "free_space_gb": _("Free space in GB"),
-            "usage_gb": _("Calculated usage in GB"),
-            "usage_pc_out": _("Usage in percent"),
-        }
-
-        label_list = (
-            "ds_name",
-            "vsphere_name",
-            "dc",
-            "cluster",
-            "capacity_gb",
-            "usage_gb",
-            "usage_pc_out",
-            "free_space_gb",
-        )
+        show_footer = False
+        if self.print_total and not self.quiet:
+            show_footer = True
+
+        show_header = True
+        table_title = _("All datastores") + "\n"
+        box_style = box.ROUNDED
+        if self.quiet:
+            show_header = False
+            table_title = None
+            box_style = None
 
         datastore_list = self._get_datastore_list(all_datastores)
-        field_length = self._get_ds_fields_len(datastore_list, labels)
-
-        max_len = 0
-        count = len(datastore_list)
-
-        for label in labels.keys():
-            if max_len:
-                max_len += 2
-            max_len += field_length[label]
-
-        if self.verbose > 2:
-            LOG.debug("Label length:\n" + pp(field_length))
-            LOG.debug("Max line length: {} chars".format(max_len))
-            LOG.debug("Datastore clusters:\n" + pp(datastore_list))
-
-        tpl = ""
-        for label in label_list:
-            if tpl != "":
-                tpl += "  "
-            if label in ("ds_name", "vsphere_name", "dc", "cluster"):
-                tpl += "{{{la}:<{le}}}".format(la=label, le=field_length[label])
-            else:
-                tpl += "{{{la}:>{le}}}".format(la=label, le=field_length[label])
-        if self.verbose > 1:
-            LOG.debug(_("Line template: {}").format(tpl))
 
         if self.sort_keys:
             LOG.debug("Sorting keys: " + pp(self.sort_keys))
@@ -396,31 +382,74 @@ class GetStorageListApp(BaseVmwareApplication):
                 else:
                     datastore_list.sort(key=itemgetter(key), reverse=True)
 
-        if not self.quiet:
-            print()
-            print(tpl.format(**labels))
-            print("-" * max_len)
-
-        for datastore in datastore_list:
-            print(tpl.format(**datastore))
-
-        if self.totals:
-            if not self.quiet:
-                print("-" * max_len)
-            print(tpl.format(**self.totals))
-
-        if not self.quiet:
-            print()
+        if self.quiet:
+            caption = None
+        else:
+            count = len(datastore_list)
             if count:
-                msg = ngettext(
+                caption = "\n" + ngettext(
                     "Found one VMware datastore.",
                     "Found {} VMware datastores.",
                     count,
                 ).format(count)
             else:
-                msg = _("No VMware datastores found.")
+                caption = "\n" + _("No VMware datastores found.")
+
+        ds_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,
+        )
+
+        ds_table.add_column(header=_("Datastore"), footer=_("Total"))
+        ds_table.add_column(header=_("Type"), footer="", justify="center")
+        ds_table.add_column(header=_("vSphere"), footer="")
+        ds_table.add_column(header=_("Data Center"), footer="")
+        ds_table.add_column(header=_("Cluster"), footer="")
+        ds_table.add_column(header=_("Connected Hosts"), footer="", justify="right")
+        ds_table.add_column(
+            header=_("Capacity in GB"), footer=self.totals["capacity_gb"], justify="right"
+        )
+        ds_table.add_column(
+            header=_("Calculated usage in GB"), footer=self.totals["usage_gb"], justify="right"
+        )
+        ds_table.add_column(
+            header=_("Usage in percent"), footer=self.totals["usage_pc_out"], justify="right"
+        )
+        ds_table.add_column(
+            header=_("Free space in GB"), footer=self.totals["free_space_gb"], justify="right"
+        )
 
-            print(msg)
+        for datastore in datastore_list:
+            used_pc_out = Text(datastore["usage_pc_out"])
+            if datastore["usage_pc"] is None:
+                used_pc_out.stylize("bold magenta")
+            elif datastore["usage_pc"] >= 0.9:
+                used_pc_out.stylize("bold red")
+            elif datastore["usage_pc"] >= 0.8:
+                used_pc_out.stylize("bold yellow")
+
+            ds_table.add_row(
+                datastore["ds_name"],
+                datastore["storage_type"],
+                datastore["vsphere_name"],
+                datastore["dc"],
+                datastore["cluster"],
+                datastore["hosts"],
+                datastore["capacity_gb"],
+                datastore["usage_gb"],
+                used_pc_out,
+                datastore["free_space_gb"],
+            )
+
+        self.rich_console.print(ds_table)
+
+        if not self.quiet:
             print()
 
 
@@ -438,7 +467,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)
 
     return 0