ansible-core 2.17.4rc1__py3-none-any.whl → 2.18.0b1__py3-none-any.whl

ansible/module_utils/facts/default_collectors.py

@@ -53,6 +53,7 @@ from ansible.module_utils.facts.system.python import PythonFactCollector
 from ansible.module_utils.facts.system.selinux import SelinuxFactCollector
 from ansible.module_utils.facts.system.service_mgr import ServiceMgrFactCollector
 from ansible.module_utils.facts.system.ssh_pub_keys import SshPubKeyFactCollector
+from ansible.module_utils.facts.system.systemd import SystemdFactCollector
 from ansible.module_utils.facts.system.user import UserFactCollector
 
 from ansible.module_utils.facts.hardware.base import HardwareCollector
@@ -118,7 +119,8 @@ _general = [
     EnvFactCollector,
     LoadAvgFactCollector,
     SshPubKeyFactCollector,
-    UserFactCollector
+    UserFactCollector,
+    SystemdFactCollector
 ]  # type: t.List[t.Type[BaseFactCollector]]
 
 # virtual, this might also limit hardware/networking

ansible/module_utils/facts/hardware/aix.py

@@ -195,34 +195,35 @@ class AIXHardware(Hardware):
         # AIX does not have mtab but mount command is only source of info (or to use
         # api calls to get same info)
         mount_path = self.module.get_bin_path('mount')
-        rc, mount_out, err = self.module.run_command(mount_path)
-        if mount_out:
-            for line in mount_out.split('\n'):
-                fields = line.split()
-                if len(fields) != 0 and fields[0] != 'node' and fields[0][0] != '-' and re.match('^/.*|^[a-zA-Z].*|^[0-9].*', fields[0]):
-                    if re.match('^/', fields[0]):
-                        # normal mount
-                        mount = fields[1]
-                        mount_info = {'mount': mount,
-                                      'device': fields[0],
-                                      'fstype': fields[2],
-                                      'options': fields[6],
-                                      'time': '%s %s %s' % (fields[3], fields[4], fields[5])}
-                        mount_info.update(get_mount_size(mount))
-                    else:
-                        # nfs or cifs based mount
-                        # in case of nfs if no mount options are provided on command line
-                        # add into fields empty string...
-                        if len(fields) < 8:
-                            fields.append("")
-
-                        mount_info = {'mount': fields[2],
-                                      'device': '%s:%s' % (fields[0], fields[1]),
-                                      'fstype': fields[3],
-                                      'options': fields[7],
-                                      'time': '%s %s %s' % (fields[4], fields[5], fields[6])}
-
-                    mounts.append(mount_info)
+        if mount_path:
+            rc, mount_out, err = self.module.run_command(mount_path)
+            if mount_out:
+                for line in mount_out.split('\n'):
+                    fields = line.split()
+                    if len(fields) != 0 and fields[0] != 'node' and fields[0][0] != '-' and re.match('^/.*|^[a-zA-Z].*|^[0-9].*', fields[0]):
+                        if re.match('^/', fields[0]):
+                            # normal mount
+                            mount = fields[1]
+                            mount_info = {'mount': mount,
+                                          'device': fields[0],
+                                          'fstype': fields[2],
+                                          'options': fields[6],
+                                          'time': '%s %s %s' % (fields[3], fields[4], fields[5])}
+                            mount_info.update(get_mount_size(mount))
+                        else:
+                            # nfs or cifs based mount
+                            # in case of nfs if no mount options are provided on command line
+                            # add into fields empty string...
+                            if len(fields) < 8:
+                                fields.append("")
+
+                            mount_info = {'mount': fields[2],
+                                          'device': '%s:%s' % (fields[0], fields[1]),
+                                          'fstype': fields[3],
+                                          'options': fields[7],
+                                          'time': '%s %s %s' % (fields[4], fields[5], fields[6])}
+
+                        mounts.append(mount_info)
 
         mount_facts['mounts'] = mounts
 
@@ -232,30 +233,31 @@ class AIXHardware(Hardware):
         device_facts = {}
         device_facts['devices'] = {}
 
-        lsdev_cmd = self.module.get_bin_path('lsdev', True)
-        lsattr_cmd = self.module.get_bin_path('lsattr', True)
-        rc, out_lsdev, err = self.module.run_command(lsdev_cmd)
-
-        for line in out_lsdev.splitlines():
-            field = line.split()
-
-            device_attrs = {}
-            device_name = field[0]
-            device_state = field[1]
-            device_type = field[2:]
-            lsattr_cmd_args = [lsattr_cmd, '-E', '-l', device_name]
-            rc, out_lsattr, err = self.module.run_command(lsattr_cmd_args)
-            for attr in out_lsattr.splitlines():
-                attr_fields = attr.split()
-                attr_name = attr_fields[0]
-                attr_parameter = attr_fields[1]
-                device_attrs[attr_name] = attr_parameter
-
-            device_facts['devices'][device_name] = {
-                'state': device_state,
-                'type': ' '.join(device_type),
-                'attributes': device_attrs
-            }
+        lsdev_cmd = self.module.get_bin_path('lsdev')
+        lsattr_cmd = self.module.get_bin_path('lsattr')
+        if lsdev_cmd and lsattr_cmd:
+            rc, out_lsdev, err = self.module.run_command(lsdev_cmd)
+
+            for line in out_lsdev.splitlines():
+                field = line.split()
+
+                device_attrs = {}
+                device_name = field[0]
+                device_state = field[1]
+                device_type = field[2:]
+                lsattr_cmd_args = [lsattr_cmd, '-E', '-l', device_name]
+                rc, out_lsattr, err = self.module.run_command(lsattr_cmd_args)
+                for attr in out_lsattr.splitlines():
+                    attr_fields = attr.split()
+                    attr_name = attr_fields[0]
+                    attr_parameter = attr_fields[1]
+                    device_attrs[attr_name] = attr_parameter
+
+                device_facts['devices'][device_name] = {
+                    'state': device_state,
+                    'type': ' '.join(device_type),
+                    'attributes': device_attrs
+                }
 
         return device_facts
 

ansible/module_utils/facts/hardware/darwin.py

@@ -19,7 +19,6 @@ from __future__ import annotations
 import struct
 import time
 
-from ansible.module_utils.common.process import get_bin_path
 from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
 from ansible.module_utils.facts.sysctl import get_sysctl
 
@@ -41,7 +40,7 @@ class DarwinHardware(Hardware):
     def populate(self, collected_facts=None):
         hardware_facts = {}
 
-        self.sysctl = get_sysctl(self.module, ['hw', 'machdep', 'kern'])
+        self.sysctl = get_sysctl(self.module, ['hw', 'machdep', 'kern', 'hw.model'])
         mac_facts = self.get_mac_facts()
         cpu_facts = self.get_cpu_facts()
         memory_facts = self.get_memory_facts()
@@ -67,9 +66,8 @@ class DarwinHardware(Hardware):
 
     def get_mac_facts(self):
         mac_facts = {}
-        rc, out, err = self.module.run_command("sysctl hw.model")
-        if rc == 0:
-            mac_facts['model'] = mac_facts['product_name'] = out.splitlines()[-1].split()[1]
+        if 'hw.model' in self.sysctl:
+            mac_facts['model'] = mac_facts['product_name'] = self.sysctl['hw.model']
         mac_facts['osversion'] = self.sysctl['kern.osversion']
         mac_facts['osrevision'] = self.sysctl['kern.osrevision']
 
@@ -96,44 +94,49 @@ class DarwinHardware(Hardware):
 
         total_used = 0
         page_size = 4096
-        try:
-            vm_stat_command = get_bin_path('vm_stat')
-        except ValueError:
+
+        vm_stat_command = self.module.get_bin_path('vm_stat')
+        if vm_stat_command is None:
             return memory_facts
 
-        rc, out, err = self.module.run_command(vm_stat_command)
-        if rc == 0:
-            # Free = Total - (Wired + active + inactive)
-            # Get a generator of tuples from the command output so we can later
-            # turn it into a dictionary
-            memory_stats = (line.rstrip('.').split(':', 1) for line in out.splitlines())
-
-            # Strip extra left spaces from the value
-            memory_stats = dict((k, v.lstrip()) for k, v in memory_stats)
-
-            for k, v in memory_stats.items():
-                try:
-                    memory_stats[k] = int(v)
-                except ValueError:
-                    # Most values convert cleanly to integer values but if the field does
-                    # not convert to an integer, just leave it alone.
-                    pass
-
-            if memory_stats.get('Pages wired down'):
-                total_used += memory_stats['Pages wired down'] * page_size
-            if memory_stats.get('Pages active'):
-                total_used += memory_stats['Pages active'] * page_size
-            if memory_stats.get('Pages inactive'):
-                total_used += memory_stats['Pages inactive'] * page_size
-
-            memory_facts['memfree_mb'] = memory_facts['memtotal_mb'] - (total_used // 1024 // 1024)
+        if vm_stat_command:
+            rc, out, err = self.module.run_command(vm_stat_command)
+            if rc == 0:
+                # Free = Total - (Wired + active + inactive)
+                # Get a generator of tuples from the command output so we can later
+                # turn it into a dictionary
+                memory_stats = (line.rstrip('.').split(':', 1) for line in out.splitlines())
+
+                # Strip extra left spaces from the value
+                memory_stats = dict((k, v.lstrip()) for k, v in memory_stats)
+
+                for k, v in memory_stats.items():
+                    try:
+                        memory_stats[k] = int(v)
+                    except ValueError:
+                        # Most values convert cleanly to integer values but if the field does
+                        # not convert to an integer, just leave it alone.
+                        pass
+
+                if memory_stats.get('Pages wired down'):
+                    total_used += memory_stats['Pages wired down'] * page_size
+                if memory_stats.get('Pages active'):
+                    total_used += memory_stats['Pages active'] * page_size
+                if memory_stats.get('Pages inactive'):
+                    total_used += memory_stats['Pages inactive'] * page_size
+
+                memory_facts['memfree_mb'] = memory_facts['memtotal_mb'] - (total_used // 1024 // 1024)
 
         return memory_facts
 
     def get_uptime_facts(self):
+
         # On Darwin, the default format is annoying to parse.
         # Use -b to get the raw value and decode it.
         sysctl_cmd = self.module.get_bin_path('sysctl')
+        if not sysctl_cmd:
+            return {}
+
         cmd = [sysctl_cmd, '-b', 'kern.boottime']
 
         # We need to get raw bytes, not UTF-8.

ansible/module_utils/facts/hardware/freebsd.py

@@ -23,7 +23,6 @@ import time
 
 from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
 from ansible.module_utils.facts.timeout import TimeoutError, timeout
-
 from ansible.module_utils.facts.utils import get_file_content, get_mount_size
 
 
@@ -173,13 +172,50 @@ class FreeBSDHardware(Hardware):
 
         sysdir = '/dev'
         device_facts['devices'] = {}
-        drives = re.compile(r'(ada?\d+|da\d+|a?cd\d+)')  # TODO: rc, disks, err = self.module.run_command("/sbin/sysctl kern.disks")
-        slices = re.compile(r'(ada?\d+s\d+\w*|da\d+s\d+\w*)')
+        # TODO: rc, disks, err = self.module.run_command("/sbin/sysctl kern.disks")
+        drives = re.compile(
+            r"""(?x)(
+              (?:
+                ada?   # ATA/SATA disk device
+                |da    # SCSI disk device
+                |a?cd  # SCSI CDROM drive
+                |amrd  # AMI MegaRAID drive
+                |idad  # Compaq RAID array
+                |ipsd  # IBM ServeRAID RAID array
+                |md    # md(4) disk device
+                |mfid  # LSI MegaRAID SAS array
+                |mlxd  # Mylex RAID disk
+                |twed  # 3ware ATA RAID array
+                |vtbd  # VirtIO Block Device
+              )\d+
+            )
+            """
+        )
+
+        slices = re.compile(
+            r"""(?x)(
+              (?:
+                ada?   # ATA/SATA disk device
+                |a?cd  # SCSI CDROM drive
+                |amrd  # AMI MegaRAID drive
+                |da    # SCSI disk device
+                |idad  # Compaq RAID array
+                |ipsd  # IBM ServeRAID RAID array
+                |md    # md(4) disk device
+                |mfid  # LSI MegaRAID SAS array
+                |mlxd  # Mylex RAID disk
+                |twed  # 3ware ATA RAID array
+                |vtbd  # VirtIO Block Device
+              )\d+[ps]\d+\w*
+            )
+            """
+        )
+
         if os.path.isdir(sysdir):
             dirlist = sorted(os.listdir(sysdir))
             for device in dirlist:
                 d = drives.match(device)
-                if d:
+                if d and d.group(1) not in device_facts['devices']:
                     device_facts['devices'][d.group(1)] = []
                 s = slices.match(device)
                 if s:
@@ -216,18 +252,22 @@ class FreeBSDHardware(Hardware):
             'product_version': 'system-version',
             'system_vendor': 'system-manufacturer',
         }
+        if dmi_bin is None:
+            dmi_facts = dict.fromkeys(
+                DMI_DICT.keys(),
+                'NA'
+            )
+            return dmi_facts
+
         for (k, v) in DMI_DICT.items():
-            if dmi_bin is not None:
-                (rc, out, err) = self.module.run_command('%s -s %s' % (dmi_bin, v))
-                if rc == 0:
-                    # Strip out commented lines (specific dmidecode output)
-                    # FIXME: why add the fact and then test if it is json?
-                    dmi_facts[k] = ''.join([line for line in out.splitlines() if not line.startswith('#')])
-                    try:
-                        json.dumps(dmi_facts[k])
-                    except UnicodeDecodeError:
-                        dmi_facts[k] = 'NA'
-                else:
+            (rc, out, err) = self.module.run_command('%s -s %s' % (dmi_bin, v))
+            if rc == 0:
+                # Strip out commented lines (specific dmidecode output)
+                # FIXME: why add the fact and then test if it is json?
+                dmi_facts[k] = ''.join([line for line in out.splitlines() if not line.startswith('#')])
+                try:
+                    json.dumps(dmi_facts[k])
+                except UnicodeDecodeError:
                     dmi_facts[k] = 'NA'
             else:
                 dmi_facts[k] = 'NA'

ansible/module_utils/facts/hardware/hpux.py

@@ -40,6 +40,9 @@ class HPUXHardware(Hardware):
     def populate(self, collected_facts=None):
         hardware_facts = {}
 
+        # TODO: very inefficient calls to machinfo,
+        # should just make one and then deal with finding the data (see facts/sysctl)
+        # but not going to change unless there is hp/ux for testing
         cpu_facts = self.get_cpu_facts(collected_facts=collected_facts)
         memory_facts = self.get_memory_facts()
         hw_facts = self.get_hw_facts()

ansible/module_utils/facts/hardware/linux.py

@@ -24,12 +24,9 @@ import re
 import sys
 import time
 
-from multiprocessing import cpu_count
-from multiprocessing.pool import ThreadPool
-
-from ansible.module_utils.common.text.converters import to_text
+from ansible.module_utils._internal._concurrent import _futures
 from ansible.module_utils.common.locale import get_best_parsable_locale
-from ansible.module_utils.common.process import get_bin_path
+from ansible.module_utils.common.text.converters import to_text
 from ansible.module_utils.common.text.formatters import bytes_to_human
 from ansible.module_utils.facts.hardware.base import Hardware, HardwareCollector
 from ansible.module_utils.facts.utils import get_file_content, get_file_lines, get_mount_size
@@ -91,6 +88,7 @@ class LinuxHardware(Hardware):
         cpu_facts = self.get_cpu_facts(collected_facts=collected_facts)
         memory_facts = self.get_memory_facts()
         dmi_facts = self.get_dmi_facts()
+        sysinfo_facts = self.get_sysinfo_facts()
         device_facts = self.get_device_facts()
         uptime_facts = self.get_uptime_facts()
         lvm_facts = self.get_lvm_facts()
@@ -104,6 +102,7 @@ class LinuxHardware(Hardware):
         hardware_facts.update(cpu_facts)
         hardware_facts.update(memory_facts)
         hardware_facts.update(dmi_facts)
+        hardware_facts.update(sysinfo_facts)
         hardware_facts.update(device_facts)
         hardware_facts.update(uptime_facts)
         hardware_facts.update(lvm_facts)
@@ -208,6 +207,9 @@ class LinuxHardware(Hardware):
                     if 'vme' not in val:
                         xen_paravirt = True
 
+            if key == "flags":
+                cpu_facts['flags'] = val.split()
+
             # model name is for Intel arch, Processor (mind the uppercase P)
             # works for some ARM devices, like the Sheevaplug.
             if key in ['model name', 'Processor', 'vendor_id', 'cpu', 'Vendor', 'processor']:
@@ -300,12 +302,9 @@ class LinuxHardware(Hardware):
             )
         except AttributeError:
             # In Python < 3.3, os.sched_getaffinity() is not available
-            try:
-                cmd = get_bin_path('nproc')
-            except ValueError:
-                pass
-            else:
-                rc, out, _err = self.module.run_command(cmd)
+            nproc_cmd = self.module.get_bin_path('nproc')
+            if nproc_cmd is not None:
+                rc, out, _err = self.module.run_command(nproc_cmd)
                 if rc == 0:
                     cpu_facts['processor_nproc'] = int(out)
 
@@ -370,7 +369,6 @@ class LinuxHardware(Hardware):
 
         else:
             # Fall back to using dmidecode, if available
-            dmi_bin = self.module.get_bin_path('dmidecode')
             DMI_DICT = {
                 'bios_date': 'bios-release-date',
                 'bios_vendor': 'bios-vendor',
@@ -391,25 +389,54 @@ class LinuxHardware(Hardware):
                 'product_version': 'system-version',
                 'system_vendor': 'system-manufacturer',
             }
+            dmi_bin = self.module.get_bin_path('dmidecode')
+            if dmi_bin is None:
+                dmi_facts = dict.fromkeys(
+                    DMI_DICT.keys(),
+                    'NA'
+                )
+                return dmi_facts
+
             for (k, v) in DMI_DICT.items():
-                if dmi_bin is not None:
-                    (rc, out, err) = self.module.run_command('%s -s %s' % (dmi_bin, v))
-                    if rc == 0:
-                        # Strip out commented lines (specific dmidecode output)
-                        thisvalue = ''.join([line for line in out.splitlines() if not line.startswith('#')])
-                        try:
-                            json.dumps(thisvalue)
-                        except UnicodeDecodeError:
-                            thisvalue = "NA"
+                (rc, out, err) = self.module.run_command('%s -s %s' % (dmi_bin, v))
+                if rc == 0:
+                    # Strip out commented lines (specific dmidecode output)
+                    thisvalue = ''.join([line for line in out.splitlines() if not line.startswith('#')])
+                    try:
+                        json.dumps(thisvalue)
+                    except UnicodeDecodeError:
+                        thisvalue = "NA"
 
-                        dmi_facts[k] = thisvalue
-                    else:
-                        dmi_facts[k] = 'NA'
+                    dmi_facts[k] = thisvalue
                 else:
                     dmi_facts[k] = 'NA'
 
         return dmi_facts
 
+    def get_sysinfo_facts(self):
+        """Fetch /proc/sysinfo facts from s390 Linux on IBM Z"""
+        if not os.path.exists('/proc/sysinfo'):
+            return {}
+
+        sysinfo_facts = dict.fromkeys(
+            ('system_vendor', 'product_version', 'product_serial', 'product_name', 'product_uuid'),
+            'NA'
+        )
+        sysinfo_re = re.compile(
+            r'''
+                ^
+                    (?:Manufacturer:\s+(?P<system_vendor>.+))|
+                    (?:Type:\s+(?P<product_name>.+))|
+                    (?:Sequence\ Code:\s+0+(?P<product_serial>.+))
+                $
+            ''',
+            re.VERBOSE | re.MULTILINE
+        )
+        data = get_file_content('/proc/sysinfo')
+        for match in sysinfo_re.finditer(data):
+            sysinfo_facts.update({k: v for k, v in match.groupdict().items() if v is not None})
+        return sysinfo_facts
+
     def _run_lsblk(self, lsblk_path):
         # call lsblk and collect all uuids
         # --exclude 2 makes lsblk ignore floppy disks, which are slower to answer than typical timeouts
@@ -548,7 +575,7 @@ class LinuxHardware(Hardware):
 
         # start threads to query each mount
         results = {}
-        pool = ThreadPool(processes=min(len(mtab_entries), cpu_count()))
+        executor = _futures.DaemonThreadPoolExecutor()
         maxtime = timeout.GATHER_TIMEOUT or timeout.DEFAULT_GATHER_TIMEOUT
         for fields in mtab_entries:
             # Transform octal escape sequences
@@ -572,30 +599,29 @@ class LinuxHardware(Hardware):
                 if not self.MTAB_BIND_MOUNT_RE.match(options):
                     mount_info['options'] += ",bind"
 
-            results[mount] = {'info': mount_info,
-                              'extra': pool.apply_async(self.get_mount_info, (mount, device, uuids)),
-                              'timelimit': time.time() + maxtime}
+            results[mount] = {'info': mount_info, 'timelimit': time.monotonic() + maxtime}
+            results[mount]['extra'] = executor.submit(self.get_mount_info, mount, device, uuids)
 
-        pool.close()  # done with new workers, start gc
+        # done with spawning new workers, start gc
+        executor.shutdown()
 
-        # wait for workers and get results
-        while results:
+        while results:  # wait for workers and get results
             for mount in list(results):
                 done = False
                 res = results[mount]['extra']
                 try:
-                    if res.ready():
+                    if res.done():
                         done = True
-                        if res.successful():
-                            mount_size, uuid = res.get()
+                        if res.exception() is None:
+                            mount_size, uuid = res.result()
                             if mount_size:
                                 results[mount]['info'].update(mount_size)
                             results[mount]['info']['uuid'] = uuid or 'N/A'
                         else:
                             # failed, try to find out why, if 'res.successful' we know there are no exceptions
-                            results[mount]['info']['note'] = 'Could not get extra information: %s.' % (to_text(res.get()))
+                            results[mount]['info']['note'] = f'Could not get extra information: {res.exception()}'
 
-                    elif time.time() > results[mount]['timelimit']:
+                    elif time.monotonic() > results[mount]['timelimit']:
                         done = True
                         self.module.warn("Timeout exceeded when getting mount info for %s" % mount)
                         results[mount]['info']['note'] = 'Could not get extra information due to timeout'
@@ -744,10 +770,24 @@ class LinuxHardware(Hardware):
                 if serial:
                     d['serial'] = serial
 
-            for key, test in [('removable', '/removable'),
-                              ('support_discard', '/queue/discard_granularity'),
-                              ]:
-                d[key] = get_file_content(sysdir + test)
+            d['removable'] = get_file_content(sysdir + '/removable')
+
+            # Historically, `support_discard` simply returned the value of
+            # `/sys/block/{device}/queue/discard_granularity`. When its value
+            # is `0`, then the block device doesn't support discards;
+            # _however_, it being greater than zero doesn't necessarily mean
+            # that the block device _does_ support discards.
+            #
+            # Another indication that a block device doesn't support discards
+            # is `/sys/block/{device}/queue/discard_max_hw_bytes` being equal
+            # to `0` (with the same caveat as above). So if either of those are
+            # `0`, set `support_discard` to zero, otherwise set it to the value
+            # of `discard_granularity` for backwards compatibility.
+            d['support_discard'] = (
+                '0'
+                if get_file_content(sysdir + '/queue/discard_max_hw_bytes') == '0'
+                else get_file_content(sysdir + '/queue/discard_granularity')
+            )
 
             if diskname in devs_wwn:
                 d['wwn'] = devs_wwn[diskname]
@@ -765,12 +805,12 @@ class LinuxHardware(Hardware):
                         part['links'][link_type] = link_values.get(partname, [])
 
                     part['start'] = get_file_content(part_sysdir + "/start", 0)
-                    part['sectors'] = get_file_content(part_sysdir + "/size", 0)
-
                     part['sectorsize'] = get_file_content(part_sysdir + "/queue/logical_block_size")
                     if not part['sectorsize']:
                         part['sectorsize'] = get_file_content(part_sysdir + "/queue/hw_sector_size", 512)
-                    part['size'] = bytes_to_human((float(part['sectors']) * 512.0))
+                    # sysfs sectorcount assumes 512 blocksize. Convert using the correct sectorsize
+                    part['sectors'] = int(get_file_content(part_sysdir + "/size", 0)) * 512 // int(part['sectorsize'])
+                    part['size'] = bytes_to_human(float(part['sectors']) * float(part['sectorsize']))
                     part['uuid'] = get_partition_uuid(partname)
                     self.get_holders(part, part_sysdir)
 
@@ -784,13 +824,14 @@ class LinuxHardware(Hardware):
                 if m:
                     d['scheduler_mode'] = m.group(2)
 
-            d['sectors'] = get_file_content(sysdir + "/size")
-            if not d['sectors']:
-                d['sectors'] = 0
             d['sectorsize'] = get_file_content(sysdir + "/queue/logical_block_size")
             if not d['sectorsize']:
                 d['sectorsize'] = get_file_content(sysdir + "/queue/hw_sector_size", 512)
-            d['size'] = bytes_to_human(float(d['sectors']) * 512.0)
+            # sysfs sectorcount assumes 512 blocksize. Convert using the correct sectorsize
+            d['sectors'] = int(get_file_content(sysdir + "/size")) * 512 // int(d['sectorsize'])
+            if not d['sectors']:
+                d['sectors'] = 0
+            d['size'] = bytes_to_human(float(d['sectors']) * float(d['sectorsize']))
 
             d['host'] = ""
 
@@ -833,21 +874,24 @@ class LinuxHardware(Hardware):
         """ Get LVM Facts if running as root and lvm utils are available """
 
         lvm_facts = {'lvm': 'N/A'}
+        vgs_cmd = self.module.get_bin_path('vgs')
+        if vgs_cmd is None:
+            return lvm_facts
 
-        if os.getuid() == 0 and self.module.get_bin_path('vgs'):
+        if os.getuid() == 0:
             lvm_util_options = '--noheadings --nosuffix --units g --separator ,'
 
-            vgs_path = self.module.get_bin_path('vgs')
             # vgs fields: VG #PV #LV #SN Attr VSize VFree
             vgs = {}
-            if vgs_path:
-                rc, vg_lines, err = self.module.run_command('%s %s' % (vgs_path, lvm_util_options))
-                for vg_line in vg_lines.splitlines():
-                    items = vg_line.strip().split(',')
-                    vgs[items[0]] = {'size_g': items[-2],
-                                     'free_g': items[-1],
-                                     'num_lvs': items[2],
-                                     'num_pvs': items[1]}
+            rc, vg_lines, err = self.module.run_command('%s %s' % (vgs_cmd, lvm_util_options))
+            for vg_line in vg_lines.splitlines():
+                items = vg_line.strip().split(',')
+                vgs[items[0]] = {
+                    'size_g': items[-2],
+                    'free_g': items[-1],
+                    'num_lvs': items[2],
+                    'num_pvs': items[1]
+                }
 
             lvs_path = self.module.get_bin_path('lvs')
             # lvs fields:

ansible/module_utils/facts/hardware/netbsd.py

@@ -162,6 +162,9 @@ class NetBSDHardware(Hardware):
     def get_uptime_facts(self):
         # On NetBSD, we need to call sysctl with -n to get this value as an int.
         sysctl_cmd = self.module.get_bin_path('sysctl')
+        if sysctl_cmd is None:
+            return {}
+
         cmd = [sysctl_cmd, '-n', 'kern.boottime']
 
         rc, out, err = self.module.run_command(cmd)