split containerized disk check into separate check

roles/openshift_health_checker/openshift_checks/disk_availability.py

@@ -1,77 +1,47 @@
 # pylint: disable=missing-docstring
 from openshift_checks import OpenShiftCheck, get_var
+from openshift_checks.mixins import NotContainerizedMixin
 
 
-class DiskAvailability(OpenShiftCheck):
-    """Check that recommended disk space is available."""
+class DiskAvailability(NotContainerizedMixin, OpenShiftCheck):
+    """Check that recommended disk space is available before a first-time install."""
 
     name = "disk_availability"
     tags = ["preflight"]
 
+    # all values are base-10 as they are taken, as is, from
+    # the latest requirements for an OpenShift installation
+    # https://docs.openshift.org/latest/install_config/install/prerequisites.html#system-requirements
     recommended_diskspace = {
         "nodes": 15*10**9,
         "masters": 40*10**9,
         "etcd": 20*10**9,
     }
 
-    minimum_docker_space_percent = 5.0
-    supported_docker_dev_driver = "devicemapper"
-
     def run(self, tmp, task_vars):
-        self.minimum_docker_space_percent = get_var(task_vars,
-                                                    "healthcheck_minimum_docker_diskspace_percent",
-                                                    default=self.minimum_docker_space_percent)
-
-        is_containerized = get_var(task_vars, "openshift", "common", "is_containerized")
         ansible_mounts = get_var(task_vars, "ansible_mounts")
-
-        if is_containerized:
-            failed, msg = self.containerized_volume_check(task_vars)
-            if failed:
-                return {"failed": True, "msg": msg}
-
-            return {"changed": False}
-
-        failed, msg = self.noncontainerized_volume_check(ansible_mounts, task_vars)
+        self.recommended_diskspace["nodes"] = get_var(task_vars,
+                                                      "min_recommended_diskspace_node",
+                                                      default=self.recommended_diskspace["nodes"])
+        self.recommended_diskspace["masters"] = get_var(task_vars,
+                                                        "min_recommended_diskspace_master",
+                                                        default=self.recommended_diskspace["masters"])
+        self.recommended_diskspace["etcd"] = get_var(task_vars,
+                                                     "min_recommended_diskspace_etcd",
+                                                     default=self.recommended_diskspace["etcd"])
+
+        failed, msg = self.volume_check(ansible_mounts, task_vars)
         return {"failed": failed, "msg": msg}
 
-    def containerized_volume_check(self, task_vars):
-        docker_facts = self.module_executor("docker_facts", {}, task_vars)
-        info = docker_facts.get("docker_facts", {})
-        status = dict(info.get("DriverStatus", {}))
-
-        if not status:
-            msg = "Unable to retrieve storage driver information for {driver}."
-            return {"failed": True, "msg": msg.format(driver=self.supported_docker_dev_driver)}
-
-        # ensure that the docker host is using a storage driver that our installation
-        # is known to support. The only supported driver is currently "devicemapper"
-        if info.get("Driver", "") == self.supported_docker_dev_driver:
-            disktotal = self.to_bytes(status.get("Data Space Total", ""))
-            diskavail = self.to_bytes(status.get("Data Space Available", ""))
-
-            if not disktotal or not diskavail:
-                msg = "Unable to retrieve storage driver information for {driver}."
-                return True, msg.format(driver=self.supported_docker_dev_driver)
-
-            diskleft_percent = diskavail / disktotal * 100
-
-            # fail if available diskspace is less than minimum docker threshold
-            if diskleft_percent < self.minimum_docker_space_percent:
-                msg = ("Amount of data space remaining ({remaining}%%) "
-                       "for the docker storage driver is below minimum threshold ({min}%%)")
-                return True, msg.format(remaining=diskleft_percent,
-                                        min=self.minimum_docker_space_percent)
-
-    def noncontainerized_volume_check(self, ansible_mounts, task_vars):
+    def volume_check(self, ansible_mounts, task_vars):
         group_names = get_var(task_vars, "group_names", default=[])
 
         recommended_diskspace_bytes = max(self.recommended_diskspace.get(group, 0) for group in group_names)
         openshift_diskfree_bytes = self.get_openshift_disk_availability(ansible_mounts)
 
         if openshift_diskfree_bytes < recommended_diskspace_bytes:
-            msg = ("Available disk space ({diskfree} GB) for OpenShift volume below recommended storage. "
-                   "Minimum required disk space: {recommended} GB")
+            msg = ("Available disk space ({diskfree} GB) for the volume containing \"/var\" is "
+                   "below recommended storage. Minimum required disk space: {recommended} GB")
             return True, msg.format(diskfree=self.to_gigabytes(openshift_diskfree_bytes),
                                     recommended=self.to_gigabytes(recommended_diskspace_bytes))
 
@@ -117,5 +87,5 @@ def to_bytes(strfmt):
         if not units.get(segments[1]):
             return 0
 
-        byte_size = float(segments[0]) * float(units.get(segments[1]))
+        byte_size = int(segments[0]) * int(units.get(segments[1]))
         return byte_size

roles/openshift_health_checker/openshift_checks/memory_availability.py

@@ -9,20 +9,20 @@ class MemoryAvailability(OpenShiftCheck):
     tags = ["preflight"]
 
     recommended_memory_mb = {
-        "nodes": 8000.0,
-        "masters": 16000.0,
-        "etcd": 20000.0,
+        "nodes": 8 * 1024,
+        "masters": 16 * 1024,
+        "etcd": 10 * 1024,
     }
 
     def run(self, tmp, task_vars):
         group_names = get_var(task_vars, "group_names", default=[])
-        memoryfree = get_var(task_vars, "ansible_memtotal_mb")
+        total_memory = get_var(task_vars, "ansible_memtotal_mb")
 
         recommended_memory_mb = max(self.recommended_memory_mb.get(group, 0) for group in group_names)
 
-        if memoryfree < recommended_memory_mb:
+        if total_memory < recommended_memory_mb:
             msg = ("Available memory ({available} GB) below recommended storage. "
                    "Minimum required memory: {recommended} GB")
-            return {"failed": True, "msg": msg.format(available=memoryfree, recommended=recommended_memory_mb)}
+            return {"failed": True, "msg": msg.format(available=total_memory, recommended=recommended_memory_mb)}
 
         return {"changed": False}