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

pyinfra/facts/crontab.py

@@ -0,0 +1,195 @@
+import re
+from typing import Dict, List, Optional, TypedDict, Union
+
+from typing_extensions import NotRequired, override
+
+from pyinfra.api import FactBase
+from pyinfra.api.util import try_int
+
+
+class CrontabDict(TypedDict):
+    command: NotRequired[str]
+    # handles cases like CRON_TZ=UTC
+    env: NotRequired[str]
+    minute: NotRequired[Union[int, str]]
+    hour: NotRequired[Union[int, str]]
+    month: NotRequired[Union[int, str]]
+    day_of_month: NotRequired[Union[int, str]]
+    day_of_week: NotRequired[Union[int, str]]
+    comments: NotRequired[List[str]]
+    special_time: NotRequired[str]
+
+
+# for compatibility, also keeps a dict of command -> crontab dict
+class CrontabFile:
+    commands: List[CrontabDict]
+
+    def __init__(self, input_dict: Optional[Dict[str, CrontabDict]] = None):
+        super().__init__()
+        self.commands = []
+        if input_dict:
+            for command, others in input_dict.items():
+                val = others.copy()
+                val["command"] = command
+                self.add_item(val)
+
+    def add_item(self, item: CrontabDict):
+        self.commands.append(item)
+
+    def __len__(self):
+        return len(self.commands)
+
+    def __bool__(self):
+        return len(self) > 0
+
+    def items(self):
+        return {item.get("command") or item.get("env"): item for item in self.commands}
+
+    def get_command(
+        self, command: Optional[str] = None, name: Optional[str] = None
+    ) -> Optional[CrontabDict]:
+        assert command or name, "Either command or name must be provided"
+
+        name_comment = "# pyinfra-name={0}".format(name)
+        for cmd in self.commands:
+            if cmd.get("command") == command:
+                return cmd
+            if cmd.get("comments") and name_comment in cmd["comments"]:
+                return cmd
+        return None
+
+    def get_env(self, env: str) -> Optional[CrontabDict]:
+        for cmd in self.commands:
+            if cmd.get("env") == env:
+                return cmd
+        return None
+
+    def get(self, item: str) -> Optional[CrontabDict]:
+        return self.get_command(command=item, name=item) or self.get_env(item)
+
+    def __getitem__(self, item) -> Optional[CrontabDict]:
+        return self.get(item)
+
+    @override
+    def __repr__(self):
+        return f"CrontabResult({self.commands})"
+
+    # noinspection PyMethodMayBeStatic
+    def format_item(self, item: CrontabDict):
+        lines = []
+        for comment in item.get("comments", []):
+            lines.append(comment)
+
+        if "env" in item:
+            lines.append(item["env"])
+        elif "special_time" in item:
+            lines.append(f"{item['special_time']} {item['command']}")
+        else:
+            lines.append(
+                f"{item['minute']} {item['hour']} "
+                f"{item['day_of_month']} {item['month']} {item['day_of_week']} "
+                f"{item['command']}"
+            )
+        return "\n".join(lines)
+
+    @override
+    def __str__(self):
+        return "\n".join(self.format_item(item) for item in self.commands)
+
+    def to_json(self):
+        return self.commands
+
+
+_crontab_env_re = re.compile(r"^\s*([A-Z_]+)=(.*)$")
+
+
+class Crontab(FactBase[CrontabFile]):
+    """
+    Returns a dictionary of CrontabFile.
+
+    .. code:: python
+
+        # CrontabFile.items()
+        {
+            "/path/to/command": {
+                "minute": "*",
+                "hour": "*",
+                "month": "*",
+                "day_of_month": "*",
+                "day_of_week": "*",
+            },
+            "echo another command": {
+                "special_time": "@daily",
+            },
+        }
+        # or CrontabFile.to_json()
+        [
+            {
+                "command": "/path/to/command",
+                "minute": "*",
+                "hour": "*",
+                "month": "*",
+                "day_of_month": "*",
+                "day_of_week": "*",
+            },
+            {
+                "command": "echo another command",
+                "special_time": "@daily",
+            }
+        ]
+    """
+
+    default = CrontabFile
+
+    @override
+    def requires_command(self, user=None) -> str:
+        return "crontab"
+
+    @override
+    def command(self, user=None):
+        if user:
+            return "crontab -l -u {0} || true".format(user)
+        return "crontab -l || true"
+
+    @override
+    def process(self, output):
+        crons = CrontabFile()
+        current_comments = []
+
+        for line in output:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                current_comments.append(line)
+                continue
+
+            if line.startswith("@"):
+                special_time, command = line.split(None, 1)
+                item = CrontabDict(
+                    command=command,
+                    special_time=special_time,
+                    comments=current_comments,
+                )
+                crons.add_item(item)
+
+            elif _crontab_env_re.match(line):
+                # handle environment variables
+                item = CrontabDict(
+                    env=line,
+                    comments=current_comments,
+                )
+                crons.add_item(item)
+            else:
+                minute, hour, day_of_month, month, day_of_week, command = line.split(None, 5)
+                item = CrontabDict(
+                    command=command,
+                    minute=try_int(minute),
+                    hour=try_int(hour),
+                    month=try_int(month),
+                    day_of_month=try_int(day_of_month),
+                    day_of_week=try_int(day_of_week),
+                    comments=current_comments,
+                )
+                crons.add_item(item)
+
+            current_comments = []
+        return crons

pyinfra/facts/deb.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import re
+import shlex
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+from .util.packaging import parse_packages
+
+DEB_PACKAGE_NAME_REGEX = r"[a-zA-Z0-9\+\-\.]+"
+DEB_PACKAGE_VERSION_REGEX = r"[a-zA-Z0-9:~\.\-\+]+"
+
+
+class DebArch(FactBase):
+    """
+    Returns the architecture string used in apt repository sources, eg ``amd64``.
+    """
+
+    @override
+    def command(self) -> str:
+        return "dpkg --print-architecture"
+
+    @override
+    def requires_command(self) -> str:
+        return "dpkg"
+
+
+class DebPackages(FactBase):
+    """
+    Returns a dict of installed dpkg packages:
+
+    .. code:: python
+
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    @override
+    def command(self) -> str:
+        return "dpkg -l"
+
+    @override
+    def requires_command(self) -> str:
+        return "dpkg"
+
+    default = dict
+
+    regex = r"^[i|h]i\s+({0}):?[a-zA-Z0-9]*\s+({1}).+$".format(
+        DEB_PACKAGE_NAME_REGEX,
+        DEB_PACKAGE_VERSION_REGEX,
+    )
+
+    @override
+    def process(self, output):
+        return parse_packages(self.regex, output)
+
+
+class DebPackage(FactBase):
+    """
+    Returns information on a .deb archive or installed package.
+    """
+
+    _regexes = {
+        "name": r"^Package:\s+({0})$".format(DEB_PACKAGE_NAME_REGEX),
+        "version": r"^Version:\s+({0})$".format(DEB_PACKAGE_VERSION_REGEX),
+    }
+
+    @override
+    def requires_command(self, package) -> str:
+        return "dpkg"
+
+    @override
+    def command(self, package):
+        return "! test -e {0} && (dpkg -s {0} 2>/dev/null || true) || dpkg -I {0}".format(
+            shlex.quote(package)
+        )
+
+    @override
+    def process(self, output):
+        data = {}
+
+        for line in output:
+            line = line.strip()
+            for key, regex in self._regexes.items():
+                matches = re.match(regex, line)
+                if matches:
+                    value = matches.group(1)
+                    data[key] = value
+                    break
+
+        return data

pyinfra/facts/dnf.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+from .util import make_cat_files_command
+from .util.packaging import parse_yum_repositories
+
+
+class DnfRepositories(FactBase):
+    """
+    Returns a list of installed dnf repositories:
+
+    .. code:: python
+
+        [
+            {
+                "repoid": "baseos",
+                "name": "AlmaLinux $releasever - BaseOS",
+                "mirrorlist": "https://mirrors.almalinux.org/mirrorlist/$releasever/baseos",
+                "enabled": "1",
+                "gpgcheck": "1",
+                "countme": "1",
+                "gpgkey": "file:///etc/pki/rpm-gpg/RPM-GPG-KEY-AlmaLinux-9",
+                "metadata_expire": "86400",
+                "enabled_metadata": "1"
+            },
+        ]
+    """
+
+    @override
+    def command(self) -> str:
+        return make_cat_files_command(
+            "/etc/dnf.conf",
+            "/etc/dnf.repos.d/*.repo",
+            "/etc/yum.repos.d/*.repo",
+        )
+
+    @override
+    def requires_command(self) -> str:
+        return "dnf"
+
+    default = list
+
+    @override
+    def process(self, output):
+        return parse_yum_repositories(output)

pyinfra/facts/docker.py

@@ -1,78 +1,151 @@
+"""
+Facts about Docker containers, volumes and networks. These facts give you information from the view
+of the current inventory host. See the :doc:`../connectors/docker` to use Docker containers as
+inventory directly.
+"""
+
+from __future__ import annotations
+
 import json
 
+from typing_extensions import override
+
 from pyinfra.api import FactBase
 
 
 class DockerFactBase(FactBase):
     abstract = True
 
+    docker_type: str
+
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "docker"
+
+    @override
     def process(self, output):
-        output = ''.join(output)
+        output = "".join(output)
         return json.loads(output)
 
 
 class DockerSystemInfo(DockerFactBase):
-    '''
+    """
     Returns ``docker system info`` output in JSON format.
-    '''
+    """
 
-    command = 'docker system info --format="{{json .}}"'
+    @override
+    def command(self) -> str:
+        return 'docker system info --format="{{json .}}"'
 
 
 # All Docker objects
 #
 
+
 class DockerContainers(DockerFactBase):
-    '''
+    """
     Returns ``docker inspect`` output for all Docker containers.
-    '''
+    """
 
-    command = 'docker container inspect `docker ps -qa`'
+    @override
+    def command(self) -> str:
+        return """
+        ids=$(docker ps -qa) && [ -n "$ids" ] && docker container inspect $ids || echo "[]"
+        """.strip()
 
 
 class DockerImages(DockerFactBase):
-    '''
+    """
     Returns ``docker inspect`` output for all Docker images.
-    '''
+    """
 
-    command = 'docker image inspect `docker images -q`'
+    @override
+    def command(self) -> str:
+        return """
+        ids=$(docker images -q) && [ -n "$ids" ] && docker image inspect $ids || echo "[]"
+        """.strip()
 
 
 class DockerNetworks(DockerFactBase):
-    '''
+    """
     Returns ``docker inspect`` output for all Docker networks.
-    '''
+    """
+
+    @override
+    def command(self) -> str:
+        return "docker network inspect `docker network ls -q`"
+
+
+class DockerVolumes(DockerFactBase):
+    """
+    Returns ``docker inspect`` output for all Docker volumes.
+    """
+
+    @override
+    def command(self) -> str:
+        return "docker volume inspect `docker volume ls -q`"
 
-    command = 'docker network inspect `docker network ls -q`'
+
+class DockerPlugins(DockerFactBase):
+    """
+    Returns ``docker plugin inspect`` output for all Docker plugins.
+    """
+
+    @override
+    def command(self) -> str:
+        return """
+        ids=$(docker plugin ls -q) && [ -n "$ids" ] && docker plugin inspect $ids || echo "[]"
+        """.strip()
 
 
 # Single Docker objects
 #
 
+
 class DockerSingleMixin(DockerFactBase):
+    @override
     def command(self, object_id):
-        return 'docker {0} inspect {1}'.format(self.docker_type, object_id)
+        return "docker {0} inspect {1} 2>&- || true".format(
+            self.docker_type,
+            object_id,
+        )
 
 
 class DockerContainer(DockerSingleMixin):
-    '''
+    """
     Returns ``docker inspect`` output for a single Docker container.
-    '''
+    """
 
-    docker_type = 'container'
+    docker_type = "container"
 
 
 class DockerImage(DockerSingleMixin):
-    '''
+    """
     Returns ``docker inspect`` output for a single Docker image.
-    '''
+    """
 
-    docker_type = 'image'
+    docker_type = "image"
 
 
 class DockerNetwork(DockerSingleMixin):
-    '''
+    """
     Returns ``docker inspect`` output for a single Docker network.
-    '''
+    """
+
+    docker_type = "network"
+
+
+class DockerVolume(DockerSingleMixin):
+    """
+    Returns ``docker inspect`` output for a single Docker container.
+    """
+
+    docker_type = "volume"
+
+
+class DockerPlugin(DockerSingleMixin):
+    """
+    Returns ``docker plugin inspect`` output for a single Docker plugin.
+    """
 
-    docker_type = 'network'
+    docker_type = "plugin"

pyinfra/facts/efibootmgr.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Optional, Tuple, TypedDict
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+BootEntry = Tuple[bool, str]
+EFIBootMgrInfoDict = TypedDict(
+    "EFIBootMgrInfoDict",
+    {
+        "BootNext": Optional[int],
+        "BootCurrent": Optional[int],
+        "Timeout": Optional[int],
+        "BootOrder": Optional[List[int]],
+        "Entries": Dict[int, BootEntry],
+    },
+)
+
+
+class EFIBootMgr(FactBase[Optional[EFIBootMgrInfoDict]]):
+    """
+    Returns information about the UEFI boot variables:
+
+    .. code:: python
+
+        {
+            "BootNext": 6,
+            "BootCurrent": 6,
+            "Timeout": 0,
+            "BootOrder": [1,4,3],
+            "Entries": {
+                1: (True, "myefi1"),
+                2: (False, "myefi2.efi"),
+                3: (True, "myefi3.efi"),
+                4: (True, "grub2.efi"),
+            },
+        }
+    """
+
+    @override
+    def requires_command(self, *args: Any, **kwargs: Any) -> str:
+        return "efibootmgr"
+
+    @override
+    def command(self) -> str:
+        # FIXME: Use '|| true' to properly handle the case where
+        #        'efibootmgr' is run on a non-UEFI system
+        return "efibootmgr || true"
+
+    @override
+    def process(self, output: Iterable[str]) -> Optional[EFIBootMgrInfoDict]:
+        # This parsing code closely follows the printing code of efibootmgr
+        # at <https://github.com/rhboot/efibootmgr/blob/main/src/efibootmgr.c#L2020-L2048>
+
+        info: EFIBootMgrInfoDict = {
+            "BootNext": None,
+            "BootCurrent": None,
+            "Timeout": None,
+            "BootOrder": [],
+            "Entries": {},
+        }
+
+        output = iter(output)
+
+        line: Optional[str] = next(output, None)
+
+        if line is None:
+            # efibootmgr run on a non-UEFI system, likely printed
+            # "EFI variables are not supported on this system."
+            # to stderr
+            return None
+
+        # 1. Maybe have BootNext
+        if line and line.startswith("BootNext: "):
+            info["BootNext"] = int(line[len("BootNext: ") :], 16)
+            line = next(output, None)
+
+        # 2. Maybe have BootCurrent
+        if line and line.startswith("BootCurrent: "):
+            info["BootCurrent"] = int(line[len("BootCurrent: ") :], 16)
+            line = next(output, None)
+
+        # 3. Maybe have Timeout
+        if line and line.startswith("Timeout: "):
+            info["Timeout"] = int(line[len("Timeout: ") : -len(" seconds")])
+            line = next(output, None)
+
+        # 4. `show_order`
+        if line and line.startswith("BootOrder: "):
+            entries = line[len("BootOrder: ") :]
+            info["BootOrder"] = list(map(lambda x: int(x, 16), entries.split(",")))
+            line = next(output, None)
+
+        # 5. `show_vars`: The actual boot entries
+        while line is not None and line.startswith("Boot"):
+            number = int(line[4:8], 16)
+
+            # Entries marked with a * are active
+            active = line[8:9] == "*"
+
+            # TODO: Maybe split and parse (name vs. arguments ?), might require --verbose ?
+            entry = line[10:]
+            info["Entries"][number] = (active, entry)
+            line = next(output, None)
+
+        # 6. `show_mirror`
+        # Currently not implemented, since I haven't actually encountered this in the wild.
+        if line is not None:
+            raise ValueError(f"Unexpected line '{line}' while parsing")
+
+        return info