pyinfra 3.0.dev0__py2.py3-none-any.whl → 3.0.1__py2.py3-none-any.whl

pyinfra/facts/server.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
 import os
 import re
 import shutil
 from datetime import datetime
 from tempfile import mkdtemp
+from typing import Dict, List, Optional, Union
 
 from dateutil.parser import parse as parse_date
 from distro import distro
+from typing_extensions import NotRequired, TypedDict
 
 from pyinfra.api import FactBase, ShortFactBase
 from pyinfra.api.util import try_int
@@ -18,15 +22,18 @@ class User(FactBase):
     Returns the name of the current user.
     """
 
-    command = "echo $USER"
+    def command(self):
+        return "echo $USER"
 
 
-class Home(FactBase):
+class Home(FactBase[Optional[str]]):
     """
-    Returns the home directory of the current user.
+    Returns the home directory of the given user, or the current user if no user is given.
     """
 
-    command = "echo $HOME"
+    @staticmethod
+    def command(user=""):
+        return f"echo ~{user}"
 
 
 class Path(FactBase):
@@ -34,7 +41,17 @@ class Path(FactBase):
     Returns the path environment variable of the current user.
     """
 
-    command = "echo $PATH"
+    def command(self):
+        return "echo $PATH"
+
+
+class TmpDir(FactBase):
+    """
+    Returns the temporary directory of the current server, if configured.
+    """
+
+    def command(self):
+        return "echo $TMPDIR"
 
 
 class Hostname(FactBase):
@@ -42,7 +59,8 @@ class Hostname(FactBase):
     Returns the current hostname of the server.
     """
 
-    command = "uname -n"
+    def command(self):
+        return "uname -n"
 
 
 class Kernel(FactBase):
@@ -50,7 +68,8 @@ class Kernel(FactBase):
     Returns the kernel name according to ``uname``.
     """
 
-    command = "uname -s"
+    def command(self):
+        return "uname -s"
 
 
 class KernelVersion(FactBase):
@@ -58,11 +77,12 @@ class KernelVersion(FactBase):
     Returns the kernel version according to ``uname``.
     """
 
-    command = "uname -r"
+    def command(self):
+        return "uname -r"
 
 
 # Deprecated/renamed -> Kernel
-class Os(FactBase):
+class Os(FactBase[str]):
     """
     Returns the OS name according to ``uname``.
 
@@ -70,11 +90,12 @@ class Os(FactBase):
         This fact is deprecated/renamed, please use the ``server.Kernel`` fact.
     """
 
-    command = "uname -s"
+    def command(self):
+        return "uname -s"
 
 
 # Deprecated/renamed -> KernelVersion
-class OsVersion(FactBase):
+class OsVersion(FactBase[str]):
     """
     Returns the OS version according to ``uname``.
 
@@ -82,20 +103,22 @@ class OsVersion(FactBase):
         This fact is deprecated/renamed, please use the ``server.KernelVersion`` fact.
     """
 
-    command = "uname -r"
+    def command(self):
+        return "uname -r"
 
 
-class Arch(FactBase):
+class Arch(FactBase[str]):
     """
     Returns the system architecture according to ``uname``.
     """
 
     # ``uname -p`` is not portable and returns ``unknown`` on Debian.
     # ``uname -m`` works on most Linux and BSD systems.
-    command = "uname -m"
+    def command(self):
+        return "uname -m"
 
 
-class Command(FactBase):
+class Command(FactBase[str]):
     """
     Returns the raw output lines of a given command.
     """
@@ -105,39 +128,49 @@ class Command(FactBase):
         return command
 
 
-class Which(FactBase):
+class Which(FactBase[Optional[str]]):
     """
-    Returns the path of a given command, if available.
+    Returns the path of a given command according to `command -v`, if available.
     """
 
     @staticmethod
     def command(command):
-        return "which {0} || true".format(command)
+        return "command -v {0} || true".format(command)
 
 
-class Date(FactBase):
+class Date(FactBase[datetime]):
     """
     Returns the current datetime on the server.
     """
 
-    command = f"date +'{ISO_DATE_FORMAT}'"
     default = datetime.now
 
-    @staticmethod
-    def process(output):
-        return datetime.strptime(output[0], ISO_DATE_FORMAT)
+    def command(self):
+        return f"date +'{ISO_DATE_FORMAT}'"
 
+    def process(self, output) -> datetime:
+        return datetime.strptime(list(output)[0], ISO_DATE_FORMAT)
 
-class MacosVersion(FactBase):
+
+class MacosVersion(FactBase[str]):
     """
     Returns the installed MacOS version.
     """
 
-    command = "sw_vers -productVersion"
-    requires_command = "sw_vers"
+    def requires_command(self) -> str:
+        return "sw_vers"
+
+    def command(self):
+        return "sw_vers -productVersion"
 
 
-class Mounts(FactBase):
+class MountsDict(TypedDict):
+    device: str
+    type: str
+    options: list[str]
+
+
+class Mounts(FactBase[Dict[str, MountsDict]]):
     """
     Returns a dictionary of mounted filesystems and information.
 
@@ -155,12 +188,13 @@ class Mounts(FactBase):
         }
     """
 
-    command = "mount"
     default = dict
 
-    @staticmethod
-    def process(output):
-        devices = {}
+    def command(self):
+        return "mount"
+
+    def process(self, output) -> dict[str, MountsDict]:
+        devices: dict[str, MountsDict] = {}
 
         for line in output:
             is_map = False
@@ -204,11 +238,12 @@ class KernelModules(FactBase):
         }
     """
 
-    command = "! test -f /proc/modules || cat /proc/modules"
+    def command(self):
+        return "! test -f /proc/modules || cat /proc/modules"
+
     default = dict
 
-    @staticmethod
-    def process(output):
+    def process(self, output):
         modules = {}
 
         for line in output:
@@ -244,11 +279,13 @@ class LsbRelease(FactBase):
         }
     """
 
-    command = "lsb_release -ca"
-    requires_command = "lsb_release"
+    def command(self):
+        return "lsb_release -ca"
 
-    @staticmethod
-    def process(output):
+    def requires_command(self):
+        return "lsb_release"
+
+    def process(self, output):
         items = {}
 
         for line in output:
@@ -285,11 +322,14 @@ class Sysctl(FactBase):
         }
     """
 
-    command = "sysctl -a"
     default = dict
 
-    @staticmethod
-    def process(output):
+    def command(self, keys=None):
+        if keys is None:
+            return "sysctl -a"
+        return f"sysctl {' '.join(keys)}"
+
+    def process(self, output):
         sysctls = {}
 
         for line in output:
@@ -317,17 +357,18 @@ class Sysctl(FactBase):
         return sysctls
 
 
-class Groups(FactBase):
+class Groups(FactBase[List[str]]):
     """
     Returns a list of groups on the system.
     """
 
-    command = "cat /etc/group"
+    def command(self):
+        return "cat /etc/group"
+
     default = list
 
-    @staticmethod
-    def process(output):
-        groups = []
+    def process(self, output) -> list[str]:
+        groups: list[str] = []
 
         for line in output:
             if ":" in line:
@@ -336,7 +377,17 @@ class Groups(FactBase):
         return groups
 
 
-class Crontab(FactBase):
+class CrontabDict(TypedDict):
+    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: Optional[list[str]]
+    special_time: NotRequired[str]
+
+
+class Crontab(FactBase[Dict[str, CrontabDict]]):
     """
     Returns a dictionary of cron command -> execution time.
 
@@ -358,17 +409,16 @@ class Crontab(FactBase):
 
     default = dict
 
-    requires_command = "crontab"
+    def requires_command(self, user=None) -> str:
+        return "crontab"
 
-    @staticmethod
-    def command(user=None):
+    def command(self, user=None):
         if user:
             return "crontab -l -u {0} || true".format(user)
         return "crontab -l || true"
 
-    @staticmethod
-    def process(output):
-        crons = {}
+    def process(self, output):
+        crons: dict[str, CrontabDict] = {}
         current_comments = []
 
         for line in output:
@@ -417,16 +467,20 @@ class Users(FactBase):
                 "uid": user_id,
                 "gid": main_user_group_id,
                 "lastlog": last_login_time,
+                "password": encrypted_password,
             },
         }
     """
 
-    command = """
+    def command(self):
+        return """
+
         for i in `cat /etc/passwd | cut -d: -f1`; do
             ENTRY=`grep ^$i: /etc/passwd`;
             LASTLOG_RAW=`(lastlog -u $i 2> /dev/null || lastlogin $i 2> /dev/null)`;
             LASTLOG=`echo $LASTLOG_RAW | grep ^$i | tr -s ' '`;
-            echo "$ENTRY|`id -gn $i`|`id -Gn $i`|$LASTLOG";
+            PASSWORD=`grep ^$i: /etc/shadow | cut -d: -f2`;
+            echo "$ENTRY|`id -gn $i`|`id -Gn $i`|$LASTLOG|$PASSWORD";
         done
     """.strip()
 
@@ -437,7 +491,7 @@ class Users(FactBase):
         rex = r"[A-Z][a-z]{2} [A-Z][a-z]{2} {1,2}\d+ .+$"
 
         for line in output:
-            entry, group, user_groups, lastlog = line.split("|")
+            entry, group, user_groups, lastlog, password = line.rsplit("|", 4)
 
             if entry:
                 # Parse out the comment/home/shell
@@ -470,12 +524,20 @@ class Users(FactBase):
                     "gid": int(entries[3]),
                     "lastlog": raw_login_time,
                     "login_time": login_time,
+                    "password": password,
                 }
 
         return users
 
 
-class LinuxDistribution(FactBase):
+class LinuxDistributionDict(TypedDict):
+    name: Optional[str]
+    major: Optional[int]
+    minor: Optional[int]
+    release_meta: Dict
+
+
+class LinuxDistribution(FactBase[LinuxDistributionDict]):
     """
     Returns a dict of the Linux distribution version. Ubuntu, Debian, CentOS,
     Fedora & Gentoo currently. Also contains any key/value items located in
@@ -495,11 +557,12 @@ class LinuxDistribution(FactBase):
         }
     """
 
-    command = (
-        "cd /etc/ && for file in $(ls -pdL *-release | grep -v /); "
-        'do echo "/etc/${file}"; cat "/etc/${file}"; echo ---; '
-        "done"
-    )
+    def command(self) -> str:
+        return (
+            "cd /etc/ && for file in $(ls -pdL *-release | grep -v /); "
+            'do echo "/etc/${file}"; cat "/etc/${file}"; echo ---; '
+            "done"
+        )
 
     name_to_pretty_name = {
         "alpine": "Alpine",
@@ -513,7 +576,7 @@ class LinuxDistribution(FactBase):
     }
 
     @staticmethod
-    def default():
+    def default() -> LinuxDistributionDict:
         return {
             "name": None,
             "major": None,
@@ -521,7 +584,7 @@ class LinuxDistribution(FactBase):
             "release_meta": {},
         }
 
-    def process(self, output):
+    def process(self, output) -> LinuxDistributionDict:
         parts = {}
         for part in "\n".join(output).strip().split("---"):
             if not part.strip():
@@ -575,7 +638,7 @@ class LinuxDistribution(FactBase):
         return release_info
 
 
-class LinuxName(ShortFactBase):
+class LinuxName(ShortFactBase[str]):
     """
     Returns the name of the Linux distribution. Shortcut for
     ``host.get_fact(LinuxDistribution)['name']``.
@@ -583,12 +646,15 @@ class LinuxName(ShortFactBase):
 
     fact = LinuxDistribution
 
-    @staticmethod
-    def process_data(data):
+    def process_data(self, data) -> str:
         return data["name"]
 
 
-class Selinux(FactBase):
+class SelinuxDict(TypedDict):
+    mode: Optional[str]
+
+
+class Selinux(FactBase[SelinuxDict]):
     """
     Discovers the SELinux related facts on the target host.
 
@@ -599,16 +665,19 @@ class Selinux(FactBase):
         }
     """
 
-    command = "sestatus"
-    requires_command = "sestatus"
+    def command(self):
+        return "sestatus"
+
+    def requires_command(self) -> str:
+        return "sestatus"
 
     @staticmethod
-    def default():
+    def default() -> SelinuxDict:
         return {
             "mode": None,
         }
 
-    def process(self, output):
+    def process(self, output) -> SelinuxDict:
         selinux_info = self.default()
 
         match = re.match(r"^SELinux status:\s+(\S+)", "\n".join(output))
@@ -621,12 +690,14 @@ class Selinux(FactBase):
         return selinux_info
 
 
-class LinuxGui(FactBase):
+class LinuxGui(FactBase[List[str]]):
     """
     Returns a list of available Linux GUIs.
     """
 
-    command = "ls /usr/bin/*session || true"
+    def command(self):
+        return "ls /usr/bin/*session || true"
+
     default = list
 
     known_gui_binaries = {
@@ -637,7 +708,7 @@ class LinuxGui(FactBase):
         "/usr/bin/xfce4-session": "XFCE 4",
     }
 
-    def process(self, output):
+    def process(self, output) -> list[str]:
         gui_names = []
 
         for line in output:
@@ -648,19 +719,18 @@ class LinuxGui(FactBase):
         return gui_names
 
 
-class HasGui(ShortFactBase):
+class HasGui(ShortFactBase[bool]):
     """
     Returns a boolean indicating the remote side has GUI capabilities. Linux only.
     """
 
     fact = LinuxGui
 
-    @staticmethod
-    def process_data(data):
+    def process_data(self, data) -> bool:
         return len(data) > 0
 
 
-class Locales(FactBase):
+class Locales(FactBase[List[str]]):
     """
     Returns installed locales on the target host.
 
@@ -669,11 +739,99 @@ class Locales(FactBase):
         ["C.UTF-8", "en_US.UTF-8"]
     """
 
-    command = "locale -a"
-    requires_command = "locale"
+    def command(self) -> str:
+        return "locale -a"
+
+    def requires_command(self) -> str:
+        return "locale"
+
     default = list
 
-    def process(self, output):
+    def process(self, output) -> list[str]:
         # replace utf8 with UTF-8 to match names in /etc/locale.gen
         # return a list of enabled locales
         return [line.replace("utf8", "UTF-8") for line in output]
+
+
+class SecurityLimits(FactBase):
+    """
+    Returns a list of security limits on the target host.
+
+    .. code:: python
+
+        [
+            {
+                "domain": "*",
+                "limit_type": "soft",
+                "item": "nofile",
+                "value": "1048576"
+            },
+            {
+                "domain": "*",
+                "limit_type": "hard",
+                "item": "nofile",
+                "value": "1048576"
+            },
+            {
+                "domain": "root",
+                "limit_type": "soft",
+                "item": "nofile",
+                "value": "1048576"
+            },
+            {
+                "domain": "root",
+                "limit_type": "hard",
+                "item": "nofile",
+                "value": "1048576"
+            },
+            {
+                "domain": "*",
+                "limit_type": "soft",
+                "item": "memlock",
+                "value": "unlimited"
+            },
+            {
+                "domain": "*",
+                "limit_type": "hard",
+                "item": "memlock",
+                "value": "unlimited"
+            },
+            {
+                "domain": "root",
+                "limit_type": "soft",
+                "item": "memlock",
+                "value": "unlimited"
+            },
+            {
+                "domain": "root",
+                "limit_type": "hard",
+                "item": "memlock",
+                "value": "unlimited"
+            }
+        ]
+    """
+
+    def command(self):
+        return "cat /etc/security/limits.conf"
+
+    default = list
+
+    def process(self, output):
+        limits = []
+
+        for line in output:
+            if line.startswith("#") or not len(line.strip()):
+                continue
+
+            domain, limit_type, item, value = line.split()
+
+            limits.append(
+                {
+                    "domain": domain,
+                    "limit_type": limit_type,
+                    "item": item,
+                    "value": value,
+                },
+            )
+
+        return limits

pyinfra/facts/snap.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api import FactBase
@@ -5,7 +7,9 @@ from pyinfra.api import FactBase
 
 class SnapBaseFact(FactBase):
     abstract = True
-    requires_command = "snap"
+
+    def requires_command(self, *args, **kwargs) -> str:
+        return "snap"
 
 
 class SnapPackage(SnapBaseFact):
@@ -62,7 +66,9 @@ class SnapPackages(SnapBaseFact):
     """
 
     default = list
-    command = "snap list"
+
+    def command(self) -> str:
+        return "snap list"
 
     def process(self, output):
         # Discard header output line from snap list command