linuxfabrik-lib 4.2.0__tar.gz → 4.3.0__tar.gz

{linuxfabrik_lib-4.2.0 → linuxfabrik_lib-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linuxfabrik-lib
-Version: 4.2.0
+Version: 4.3.0
 Summary: Python libraries used in various Linuxfabrik projects, including the 'Linuxfabrik Monitoring Plugins' project.
 Author-email: "Linuxfabrik GmbH, Zurich, Switzerland" <info@linuxfabrik.ch>
 License: This is free and unencumbered software released into the public domain.

{linuxfabrik_lib-4.2.0 → linuxfabrik_lib-4.3.0}/db_mysql.py

@@ -10,19 +10,18 @@
 
 """Library for accessing MySQL/MariaDB servers."""
 
-import warnings
-
-warnings.filterwarnings('ignore', category=UserWarning, module='pymysql')
-
-__author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
-__version__ = '2026051803'
-
 import re
 import sys
+import warnings
 
 from . import base
 from .globals import STATE_UNKNOWN
 
+warnings.filterwarnings('ignore', category=UserWarning, module='pymysql')
+
+__author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
+__version__ = '2026060201'
+
 try:
     import pymysql.cursors
 except ImportError:
@@ -538,7 +537,9 @@ def get_server_info(banner=None):
             return {'flavor': flavor, 'version': version}
         return None
 
-    from . import shell  # local import to keep db_mysql usable without shell at module load
+    # local import to keep db_mysql usable without shell at module load
+    from . import shell
+
     for command in (
         'mysqld --version',
         'mariadbd --version',

{linuxfabrik_lib-4.2.0 → linuxfabrik_lib-4.3.0}/db_sqlite.py

@@ -28,7 +28,7 @@ This is one typical use case of this library (taken from `disk-io`):
 """
 
 __author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
-__version__ = '2026060102'
+__version__ = '2026060201'
 
 import csv
 import hashlib
@@ -557,10 +557,7 @@ def delete(conn, sql, data=None, delete_db_on_operational_error=True):
 
     c = conn.cursor()
     try:
-        if data:
-            rowcount = c.execute(sql, data).rowcount
-        else:
-            rowcount = c.execute(sql).rowcount
+        rowcount = c.execute(sql, data).rowcount if data else c.execute(sql).rowcount
         return True, rowcount
     except sqlite3.OperationalError as e:
         if delete_db_on_operational_error:
@@ -938,7 +935,7 @@ def insert(conn, data, table='perfdata', delete_db_on_operational_error=True):
     # table is sanitized via __filter_str() above; keys come from the caller's
     # data dict (column names, not values); VALUES use parameterized binds
     keys = ','.join(data.keys())
-    binds = ','.join(f':{key}' for key in data.keys())
+    binds = ','.join(f':{key}' for key in data)
     sql = f'INSERT INTO "{table}" ({keys}) VALUES ({binds});'  # nosec B608
 
     c = conn.cursor()
@@ -1161,7 +1158,7 @@ def replace(conn, data, table='perfdata', delete_db_on_operational_error=True):
     table = __filter_str(table)
 
     keys = ','.join(data.keys())
-    binds = ','.join(f':{key}' for key in data.keys())
+    binds = ','.join(f':{key}' for key in data)
     sql = f'REPLACE INTO "{table}" ({keys}) VALUES ({binds});'
 
     c = conn.cursor()

{linuxfabrik_lib-4.2.0 → linuxfabrik_lib-4.3.0}/disk.py

@@ -13,11 +13,12 @@ partitions, grepping a file, etc.
 """
 
 __author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
-__version__ = '2026060101'
+__version__ = '2026060601'
 
 import csv
 import os
 import re
+import shutil
 import tempfile
 
 from . import shell
@@ -55,6 +56,65 @@ def bd2dmd(device):
     return mapped_device if os.path.islink(mapped_device) else ''
 
 
+def copy_dir(src, dst):
+    """
+    Recursively copy a directory tree.
+
+    Wraps `shutil.copytree()` and reports the outcome in the same
+    `(success, error)` style as the other disk helpers, so callers do not have to
+    handle exceptions themselves.
+
+    ### Parameters
+    - **src** (`str`): Source directory.
+    - **dst** (`str`): Destination directory (must not exist yet).
+
+    ### Returns
+    - **tuple**:
+        - tuple[0] (**bool**): True if the copy succeeded, otherwise False.
+        - tuple[1] (**None or str**): None on success, otherwise an error message.
+
+    ### Example
+    >>> copy_dir('/usr/share/lynis', '/tmp/lynis')
+    (True, None)
+    """
+    try:
+        shutil.copytree(src, dst)
+        return True, None
+    except (OSError, shutil.Error) as e:
+        return False, f'Error copying directory {src} to {dst}: {e}'
+    except Exception as e:
+        return False, f'Unknown error copying directory {src} to {dst}: {e}'
+
+
+def copy_file(src, dst):
+    """
+    Copy a single file, preserving its metadata.
+
+    Wraps `shutil.copy2()` and reports the outcome in the same `(success, error)`
+    style as the other disk helpers.
+
+    ### Parameters
+    - **src** (`str`): Source file.
+    - **dst** (`str`): Destination file or directory.
+
+    ### Returns
+    - **tuple**:
+        - tuple[0] (**bool**): True if the copy succeeded, otherwise False.
+        - tuple[1] (**None or str**): None on success, otherwise an error message.
+
+    ### Example
+    >>> copy_file('/etc/lynis/default.prf', '/tmp/lynis/default.prf')
+    (True, None)
+    """
+    try:
+        shutil.copy2(src, dst)
+        return True, None
+    except OSError as e:
+        return False, f'OS error "{e.strerror}" while copying {src} to {dst}'
+    except Exception as e:
+        return False, f'Unknown error copying {src} to {dst}: {e}'
+
+
 def dir_exists(path):
     """
     Check if a directory exists at the given path.
@@ -120,6 +180,79 @@ def file_exists(path, allow_empty=False):
     return os.path.getsize(path) > 0
 
 
+# Block-device name prefixes that never carry meaningful I/O for monitoring
+# (loopback, RAM disks, compressed RAM, floppy and optical devices). They are
+# skipped by get_block_devices().
+_PSEUDO_DEVICE_PREFIXES = ('fd', 'loop', 'ram', 'sr', 'zram')
+
+
+def get_block_devices():
+    """
+    Return all local block devices that expose I/O counters, mounted or not.
+
+    Unlike `get_real_disks()`, which is limited to block devices that currently have a mounted
+    filesystem, this also includes devices without a mounted filesystem, for example raw devices
+    backing a database or storage layer, or unmounted multipath/SAN volumes. Devices are
+    enumerated from `/proc/diskstats`, so their names line up with the per-device I/O counters
+    exposed there.
+
+    Each device is represented as a dictionary with:
+    - 'bd' : Block device path (e.g. '/dev/sda' or '/dev/dm-7').
+    - 'dmd': Device-mapper path if the device is a device-mapper target (e.g.
+      '/dev/mapper/data'), otherwise an empty string.
+    - 'mp' : Mount point(s), space-separated if mounted in several places, or an empty string if
+      the device is not mounted.
+
+    Pseudo devices that never carry meaningful I/O are skipped by name prefix: loopback (`loop`),
+    RAM disks (`ram`), compressed RAM (`zram`), floppy (`fd`) and optical (`sr`) devices.
+
+    ### Parameters
+    - None
+
+    ### Returns
+    - **list of dict**: One entry per block device, including unmounted ones. Empty list on
+      systems without `/proc/diskstats` (e.g. non-Linux).
+
+    ### Example
+    >>> get_block_devices()
+    [{'bd': '/dev/dm-7', 'dmd': '/dev/mapper/data', 'mp': ''},
+     {'bd': '/dev/sda1', 'dmd': '', 'mp': '/boot'}]
+    """
+    success, diskstats = read_file('/proc/diskstats')
+    if not success:
+        return []
+
+    # map every mounted block-device path to its mount point(s)
+    mountpoints = {}
+    mounts_ok, mounts_content = read_file('/proc/mounts')
+    if mounts_ok:
+        for line in mounts_content.splitlines():
+            if not line.startswith('/dev/'):
+                continue
+            parts = line.split()
+            device_path, mount_point = parts[0], parts[1]
+            if device_path in mountpoints:
+                mountpoints[device_path] += f' {mount_point}'
+            else:
+                mountpoints[device_path] = mount_point
+
+    disks = []
+    for line in diskstats.splitlines():
+        parts = line.split()
+        if len(parts) < 3:
+            continue
+        name = parts[2]
+        if name.startswith(_PSEUDO_DEVICE_PREFIXES):
+            continue
+        bd = f'/dev/{name}'
+        dmd = bd2dmd(name)
+        # a device can be mounted under its block-device path or its device-mapper path
+        mp = mountpoints.get(bd, '') or (mountpoints.get(dmd, '') if dmd else '')
+        disks.append({'bd': bd, 'dmd': dmd, 'mp': mp})
+
+    return disks
+
+
 def get_cwd():
     """
     Get the current working directory.
@@ -168,7 +301,7 @@ def get_owner(file):
     """
     try:
         return os.stat(file).st_uid
-    except:
+    except OSError:
         return -1
 
 
@@ -302,6 +435,67 @@ def grep_file(filename, pattern):
     return True, ''
 
 
+def make_temp_dir(prefix=''):
+    """
+    Create a unique temporary directory and return its path.
+
+    Wraps `tempfile.mkdtemp()` and reports the outcome in the same
+    `(success, result)` style as the other disk helpers.
+
+    ### Parameters
+    - **prefix** (`str`, optional): Prefix for the directory name. Defaults to ''.
+
+    ### Returns
+    - **tuple**:
+        - tuple[0] (**bool**): True on success, otherwise False.
+        - tuple[1] (**str**): The created directory path on success, otherwise an
+          error message.
+
+    ### Example
+    >>> make_temp_dir(prefix='myapp-')
+    (True, '/tmp/myapp-abcd1234')
+    """
+    try:
+        return True, tempfile.mkdtemp(prefix=prefix)
+    except OSError as e:
+        return False, f'OS error "{e.strerror}" while creating a temporary directory'
+    except Exception as e:
+        return False, f'Unknown error creating a temporary directory: {e}'
+
+
+def mkdir(path, mode=0o755, exist_ok=True):
+    """
+    Create a directory, including any missing parent directories.
+
+    Wraps `os.makedirs()` and reports the outcome in the same `(success, error)`
+    style as the other disk helpers, so callers do not have to handle exceptions
+    themselves.
+
+    ### Parameters
+    - **path** (`str`): Directory path to create.
+    - **mode** (`int`, optional): Permission bits for newly created directories.
+      Defaults to `0o755`.
+    - **exist_ok** (`bool`, optional): If `True`, an already existing directory is
+      not an error. Defaults to `True`.
+
+    ### Returns
+    - **tuple**:
+        - tuple[0] (**bool**): True if the directory exists afterwards, else False.
+        - tuple[1] (**None or str**): None on success, otherwise an error message.
+
+    ### Example
+    >>> mkdir('/tmp/example/sub')
+    (True, None)
+    """
+    try:
+        os.makedirs(path, mode=mode, exist_ok=exist_ok)
+        return True, None
+    except OSError as e:
+        return False, f'OS error "{e.strerror}" while creating {path}'
+    except Exception as e:
+        return False, f'Unknown error creating {path}: {e}'
+
+
 def read_csv(
     filename,
     delimiter=',',
@@ -444,6 +638,34 @@ def read_file(filename):
         return False, f'Unknown error opening or reading {filename}: {e}'
 
 
+def rm_dir(path):
+    """
+    Recursively delete a directory tree.
+
+    Wraps `shutil.rmtree()` and reports the outcome in the same `(success, error)`
+    style as `rm_file()`.
+
+    ### Parameters
+    - **path** (`str`): Directory tree to delete.
+
+    ### Returns
+    - **tuple**:
+        - tuple[0] (**bool**): True if deletion succeeded, otherwise False.
+        - tuple[1] (**None or str**): None on success, otherwise an error message.
+
+    ### Example
+    >>> rm_dir('/tmp/lynis')
+    (True, None)
+    """
+    try:
+        shutil.rmtree(path)
+        return True, None
+    except OSError as e:
+        return False, f'OS error "{e.strerror}" while deleting {path}'
+    except Exception as e:
+        return False, f'Unknown error deleting {path}: {e}'
+
+
 def rm_file(filename):
     """
     Delete or remove a file.

{linuxfabrik_lib-4.2.0 → linuxfabrik_lib-4.3.0}/dmidecode.py

@@ -14,7 +14,7 @@ Copied and refactored from py-dmidecode (https://github.com/zaibon/py-dmidecode)
 """
 
 __author__ = 'Linuxfabrik GmbH, Zurich/Switzerland'
-__version__ = '2025090901'
+__version__ = '2026060201'
 
 import re
 
@@ -260,9 +260,7 @@ def dmidecode_parse(output):
         if 'no module installed' in size:
             return True
         # Sometimes vendors encode 0-sized entries
-        if size.startswith('0 ') or size == '0':
-            return True
-        return False
+        return bool(size.startswith('0 ') or size == '0')
 
     # Fields to ignore by DMI type when constructing fingerprints (order-independent)
     IGNORE_BY_TYPE = {
@@ -382,7 +380,7 @@ def dmidecode_parse(output):
             seen[fp] = (dmi_handle, rep)
             data[dmi_handle] = rep
         else:
-            first_handle, rep = seen[fp]
+            _, rep = seen[fp]
             rep['dedup_count'] = int(rep.get('dedup_count', 1)) + 1
             rep['dedup_handles'].append(dmi_handle[0])
             # enrich socket/slot lists
@@ -517,7 +515,7 @@ def get_data():
     if not success:
         return False
 
-    stdout, stderr, retc = result
+    stdout, _, retc = result
     if retc != 0:
         return False