pyinfra 0.11.dev3__py3-none-any.whl → 3.5.1__py3-none-any.whl

pyinfra/facts/snap.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import re
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+
+class SnapBaseFact(FactBase):
+    abstract = True
+
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "snap"
+
+
+class SnapPackage(SnapBaseFact):
+    """
+    Returns information for an installed snap package
+
+    .. code:: python
+
+        {
+            "name": "lxd",
+            "publisher": "Canonical✓",
+            "snap-id": "J60k4JY0HppjwOjW8dZdYc8obXKxujRu",
+            "channel": "4.0/stable",
+            "version": "4.0.9"
+        }
+    """
+
+    default = dict
+    _regexes = {
+        "name": "^name:[ ]+(.*)",
+        "publisher": r"^publisher:[ ]+(.*)",
+        "snap-id": r"^snap-id:[ ]+(.*)",
+        "channel": r"^tracking:[ ]+([\w\d.-]+/[\w\d.-]+)[/]?.*$",
+        "version": r"^installed:[ ]+([\w\d.-]+).*$",
+    }
+
+    @override
+    def command(self, package):
+        return f"snap info {package}"
+
+    @override
+    def process(self, output):
+        data = {}
+        for line in output:
+            for regex_name, regex in self._regexes.items():
+                matches = re.match(regex, line)
+                if matches:
+                    data[regex_name] = matches.group(1)
+
+        return data
+
+
+class SnapPackages(SnapBaseFact):
+    """
+    Returns a list of installed snap packages:
+
+    .. code:: python
+
+        [
+            "core",
+            "core18",
+            "core20",
+            "lxd",
+            "snapd"
+        ]
+    """
+
+    default = list
+
+    @override
+    def command(self) -> str:
+        return "snap list"
+
+    @override
+    def process(self, output):
+        # Discard header output line from snap list command
+        # 'snap list' command example output lines:
+        #    $ snap list
+        #    Name              Version        Rev    Tracking         Publisher     Notes
+        #    core              16-2.57.2      13886  latest/stable    canonical✓    core
+        #    lxd               4.0.9          22753  4.0/stable/…     canonical✓    -
+        #
+        return [snap.split()[0] for snap in output[1:]]

pyinfra/facts/systemd.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import re
+from typing import Dict, Iterable
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase, QuoteString, StringCommand
+
+# Valid unit names consist of a "name prefix" and a dot and a suffix specifying the unit type.
+# The "unit prefix" must consist of one or more valid characters
+# (ASCII letters, digits, ":", "-", "_", ".", and "\").
+# The total length of the unit name including the suffix must not exceed 256 characters.
+# The type suffix must be one of
+# ".service", ".socket", ".device", ".mount", ".automount",
+# ".swap", ".target", ".path", ".timer", ".slice", or ".scope".
+# Units names can be parameterized by a single argument called the "instance name".
+# A template unit must have a single "@" at the end of the name (right before the type suffix).
+# The name of the full unit is formed by inserting the instance name
+# between "@" and the unit type suffix.
+SYSTEMD_UNIT_NAME_REGEX = (
+    r"[a-zA-Z0-9\:\-\_\.\\\@]+\."
+    r"(?:service|socket|device|mount|automount|swap|target|path|timer|slice|scope)"
+)
+
+
+def _make_systemctl_cmd(user_mode=False, machine=None, user_name=None):
+    # base command for normal and user mode
+    systemctl_cmd = ["systemctl --user"] if user_mode else ["systemctl"]
+
+    # add user and machine flag if given in args
+    if machine is not None:
+        if user_name is not None:
+            systemctl_cmd.append("--machine={1}@{0}".format(machine, user_name))
+        else:
+            systemctl_cmd.append("--machine={0}".format(machine))
+    elif user_name is not None:
+        # If only the user is given, assume that the connection should be made to the local machine
+        systemctl_cmd.append("--machine={0}@.host".format(user_name))
+
+    return StringCommand(*systemctl_cmd)
+
+
+class SystemdStatus(FactBase[Dict[str, bool]]):
+    """
+    Returns a dictionary map of systemd units to booleans indicating whether they are active.
+
+    + user_mode: whether to use user mode
+    + machine: machine name
+
+    .. code:: python
+
+        {
+            "ssh.service": True,
+            "containerd.service": True,
+            "apt-daily.timer": False,
+        }
+    """
+
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "systemctl"
+
+    default = dict
+
+    state_key = "SubState"
+    state_values = ["running", "waiting", "exited", "listening", "mounted"]
+
+    @override
+    def command(
+        self,
+        user_mode: bool = False,
+        machine: str | None = None,
+        user_name: str | None = None,
+        services: str | list[str] | None = None,
+    ) -> StringCommand:
+        fact_cmd = _make_systemctl_cmd(
+            user_mode=user_mode,
+            machine=machine,
+            user_name=user_name,
+        )
+
+        if services is None:
+            service_strs = [QuoteString("*")]
+        elif isinstance(services, str):
+            service_strs = [QuoteString(services)]
+        elif isinstance(services, Iterable):
+            service_strs = [QuoteString(s) for s in services]
+
+        return StringCommand(
+            fact_cmd,
+            "show",
+            "--all",
+            "--property",
+            "Id",
+            "--property",
+            self.state_key,
+            *service_strs,
+        )
+
+    @override
+    def process(self, output) -> Dict[str, bool]:
+        services: Dict[str, bool] = {}
+
+        current_unit = None
+        for line in output:
+            line = line.strip()
+
+            try:
+                key, value = line.split("=", 1)
+            except ValueError:
+                current_unit = None  # reset current_unit just in case
+                continue
+
+            if key == "Id" and re.match(SYSTEMD_UNIT_NAME_REGEX, value):
+                current_unit = value
+                continue
+
+            if key == self.state_key and current_unit:
+                services[current_unit] = value in self.state_values
+
+        return services
+
+
+class SystemdEnabled(SystemdStatus):
+    """
+    Returns a dictionary map of systemd units to booleans indicating whether they are enabled.
+
+    .. code:: python
+
+        {
+            "ssh.service": True,
+            "containerd.service": True,
+            "apt-daily.timer": False,
+        }
+    """
+
+    state_key = "UnitFileState"
+    state_values = ["enabled", "static"]

pyinfra/facts/sysvinit.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+
+class InitdStatus(FactBase):
+    """
+    Low level check for every /etc/init.d/* script. Unfortunately many of these
+    misbehave and return exit status 0 while also displaying the help info/not
+    offering status support.
+
+    Returns a dict of name -> status.
+
+    Expected codes found at:
+        http://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html
+    """
+
+    @override
+    def command(self) -> str:
+        return """
+        for SERVICE in `ls /etc/init.d/`; do
+            _=`cat /etc/init.d/$SERVICE | grep "### BEGIN INIT INFO"`
+
+            if [ "$?" = "0" ]; then
+                STATUS=`/etc/init.d/$SERVICE status`
+                echo "$SERVICE=$?"
+            fi
+        done
+    """
+
+    regex = r"([a-zA-Z0-9\-]+)=([0-9]+)"
+    default = dict
+
+    @override
+    def process(self, output) -> dict[str, Optional[bool]]:
+        services: dict[str, Optional[bool]] = {}
+
+        for line in output:
+            matches = re.match(self.regex, line)
+            if matches:
+                intstatus = int(matches.group(2))
+                status: Optional[bool] = None
+
+                # Exit code 0 = OK/running
+                if intstatus == 0:
+                    status = True
+
+                # Exit codes 1-3 = DOWN/not running
+                elif intstatus < 4:
+                    status = False
+
+                services[matches.group(1)] = status
+
+        return services

pyinfra/facts/upstart.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import re
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+
+class UpstartStatus(FactBase):
+    """
+    Returns a dict of name -> status for upstart managed services.
+    """
+
+    @override
+    def requires_command(self) -> str:
+        return "initctl"
+
+    regex = r"^([a-z\-]+) [a-z]+\/([a-z]+)"
+    default = dict
+
+    @override
+    def command(self):
+        return "initctl list"
+
+    @override
+    def process(self, output):
+        services = {}
+
+        for line in output:
+            matches = re.match(self.regex, line)
+            if matches:
+                services[matches.group(1)] = matches.group(2) == "running"
+
+        return services

pyinfra/facts/util/__init__.py

@@ -0,0 +1,17 @@
+from typing import Iterable
+
+
+def make_cat_files_command(*filenames: Iterable[str]) -> str:
+    commands = []
+
+    for filename in filenames:
+        if "*" in filename:
+            # There's no way to test against a glob expression, so accept anything here
+            commands.append("cat {0} || true".format(filename))
+        else:
+            commands.append("! test -f {0} || cat {0}".format(filename))
+
+    if len(commands) > 1:  # if we have multiple, wrap them
+        commands = ["({0})".format(command) for command in commands]
+
+    return " && ".join(commands)

pyinfra/facts/util/databases.py

@@ -1,12 +1,13 @@
 def _remove_prefix(title, remove_prefix):
     if title.startswith(remove_prefix):
-        return title[len(remove_prefix):]
+        return title[len(remove_prefix) :]
 
     return title
 
 
 def parse_columns_and_rows(
-    lines, delimiter,
+    lines,
+    delimiter,
     remove_column_prefix=None,
     title_parser=None,
 ):
@@ -17,10 +18,7 @@ def parse_columns_and_rows(
         titles = [title_parser(title) for title in titles]
 
     if remove_column_prefix:
-        titles = [
-            _remove_prefix(title, remove_column_prefix)
-            for title in titles
-        ]
+        titles = [_remove_prefix(title, remove_column_prefix) for title in titles]
 
     rows = []
 

pyinfra/facts/util/packaging.py

@@ -1,19 +1,50 @@
+from __future__ import annotations
+
 import re
+from typing import Iterable
 
 
-def parse_packages(regex, output, lower=True):
-    packages = {}
+def parse_packages(regex: str, output: Iterable[str]) -> dict[str, set[str]]:
+    packages: dict[str, set[str]] = {}
 
     for line in output:
         matches = re.match(regex, line)
 
         if matches:
-            # Sort out name
             name = matches.group(1)
-            if lower:
-                name = name.lower()
-
             packages.setdefault(name, set())
             packages[name].add(matches.group(2))
 
     return packages
+
+
+def _parse_yum_or_zypper_repositories(output):
+    repos = []
+
+    current_repo: dict[str, str] = {}
+    for line in output:
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+
+        if line.startswith("["):
+            if current_repo:
+                repos.append(current_repo)
+                current_repo = {}
+
+            current_repo["repoid"] = line[1:-1]
+            current_repo["name"] = line[1:-1]
+
+        if current_repo and "=" in line:
+            key, value = re.split(r"\s*=\s*", line, maxsplit=1)
+            current_repo[key] = value
+
+    if current_repo:
+        repos.append(current_repo)
+
+    return repos
+
+
+parse_yum_repositories = _parse_yum_or_zypper_repositories
+
+parse_zypper_repositories = _parse_yum_or_zypper_repositories

pyinfra/facts/util/units.py

@@ -0,0 +1,30 @@
+# from https://stackoverflow.com/a/60708339, but with a few modifications
+from __future__ import annotations  # for | in type hints
+
+import re
+
+units = {
+    "B": 1,
+    "KB": 10**3,
+    "MB": 10**6,
+    "GB": 10**9,
+    "TB": 10**12,
+    "KIB": 2**10,
+    "MIB": 2**20,
+    "GIB": 2**30,
+    "TIB": 2**40,
+}
+
+
+def parse_human_readable_size(size: str) -> int:
+    size = size.upper()
+    if not re.match(r" ", size):
+        size = re.sub(r"([KMGT]?I?[B])", r" \1", size)
+    number, unit = [string.strip() for string in size.split()]
+    return int(float(number) * units[unit])
+
+
+def parse_size(size: str | int) -> int:
+    if isinstance(size, int):
+        return size
+    return parse_human_readable_size(size)

pyinfra/facts/util/win_files.py

@@ -0,0 +1,99 @@
+import re
+from datetime import datetime
+
+WIN_LS_REGEX = re.compile(
+    (
+        # filetype and mode
+        r"^([darhsl\-]{6})\s+"
+        # Windows date
+        r"([0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4})\s+([0-9]{1,2}:[0-9]{1,2}\s[AP][M])\s+"
+        # Size (Note: no size on directories)
+        r"([0-9]+)?\s+"
+        # Size and Filename
+        r"([\w\/\.@-]+)"
+    ),
+)
+
+WIN_FLAG_TO_TYPE = {
+    "d": "directory",
+    "-": "file",
+}
+
+WIN_FLAG_TO_ATTR = {
+    "a": "archive",
+    "r": "readonly",
+    "h": "hidden",
+    "s": "system",
+    "l": "link",
+    "-": "none",
+}
+
+
+def _parse_time(time):
+    # Try matching windows format
+    try:
+        tmp = datetime.strptime(time, "%m/%d/%Y %H:%M %p")
+        return tmp
+    except ValueError:
+        pass
+
+
+def parse_win_ls_output(output, wanted_type):
+    if output:
+        matches = re.match(WIN_LS_REGEX, output)
+        if matches:
+            if output[5] == "l":
+                type = "link"
+            else:
+                type = WIN_FLAG_TO_TYPE[output[0]]
+
+            if type != wanted_type:
+                return False
+
+            hidden = False
+            system = False
+            readonly = False
+            archive = False
+            link = False
+
+            mode_without_first = matches.group(1)[1:]
+
+            for c in mode_without_first:
+                tmp = WIN_FLAG_TO_ATTR[c]
+                if tmp != "none":
+                    if tmp == "hidden":
+                        hidden = True
+                    if tmp == "readonly":
+                        readonly = True
+                    if tmp == "archive":
+                        archive = True
+                    if tmp == "system":
+                        system = True
+                    if tmp == "link":
+                        link = True
+
+            mode = {
+                "archive": archive,
+                "hidden": hidden,
+                "readonly": readonly,
+                "system": system,
+                "link": link,
+            }
+
+            date_and_time = "{} {}".format(matches.group(2), matches.group(3))
+
+            size = "0"
+            if type == "file":
+                size = matches.group(4)
+
+            out = {
+                "type": type,
+                "mode": mode,
+                "mtime": _parse_time(date_and_time),
+                "size": size,
+                "name": matches.group(5),
+                # TODO: You will need to run another powershell command to
+                #       get the link target, so bailing on that for now.
+            }
+
+            return out

pyinfra/facts/vzctl.py

@@ -1,33 +1,40 @@
+from __future__ import annotations
+
 import json
 
+from typing_extensions import override
+
 from pyinfra.api import FactBase
 
 
 class OpenvzContainers(FactBase):
-    '''
+    """
     Returns a dict of running OpenVZ containers by CTID:
 
     .. code:: python
 
         {
             666: {
-                'ip': [],
-                'ostemplate': 'ubuntu...',
+                "ip": [],
+                "ostemplate": "ubuntu...",
                 ...
             },
-            ...
         }
-    '''
+    """
+
+    @override
+    def command(self) -> str:
+        return "vzlist -a -j"
+
+    @override
+    def requires_command(self) -> str:
+        return "vzlist"
 
-    command = 'vzlist -a -j'
     default = dict
 
-    @staticmethod
-    def process(output):
-        combined_json = ''.join(output)
+    @override
+    def process(self, output):
+        combined_json = "".join(output)
         vz_data = json.loads(combined_json)
 
-        return {
-            int(vz.pop('ctid')): vz
-            for vz in vz_data
-        }
+        return {int(vz.pop("ctid")): vz for vz in vz_data}

pyinfra/facts/xbps.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+from .util.packaging import parse_packages
+
+
+class XbpsPackages(FactBase):
+    """
+    Returns a dict of installed XBPS packages:
+
+    .. code:: python
+
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    @override
+    def requires_command(self) -> str:
+        return "xbps-query"
+
+    default = dict
+
+    regex = r"^.. ([a-zA-Z0-9_\-\+\.]+)\-([0-9a-z\.]+_[0-9]+)"
+
+    @override
+    def command(self):
+        return "xbps-query -l"
+
+    @override
+    def process(self, output):
+        return parse_packages(self.regex, output)