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

pyinfra/facts/flatpak.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import re
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+
+class FlatpakBaseFact(FactBase):
+    abstract = True
+
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "flatpak"
+
+
+class FlatpakPackage(FlatpakBaseFact):
+    """
+    Returns information for an installed flatpak package
+
+    .. code:: python
+
+        {
+            "id": "org.signal.Signal",
+            "ref": "app/org.signal.Signal/x86_64/stable",
+            "version": "7.12.0"
+        }
+    """
+
+    default = dict
+    _regexes = {
+        "id": "^[ ]+ID:[ ]+(.*)$",
+        "ref": r"^[ ]+Ref:[ ]+(.*)$",
+        "version": r"^[ ]+Version:[ ]+([\w\d.-]+).*$",
+    }
+
+    @override
+    def command(self, package):
+        return f"flatpak 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 FlatpakPackages(FlatpakBaseFact):
+    """
+    Returns a list of installed flatpak packages:
+
+    .. code:: python
+
+        [
+            "org.gnome.Platform",
+            "org.kde.Platform",
+            "org.kde.Sdk",
+            "org.libreoffice.LibreOffice",
+            "org.videolan.VLC"
+        ]
+    """
+
+    default = list
+
+    @override
+    def command(self):
+        return "flatpak list --columns=application"
+
+    @override
+    def process(self, output):
+        return [flatpak for flatpak in output[1:]]

pyinfra/facts/freebsd.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing_extensions import Optional, override
+
+from pyinfra.api import FactBase
+from pyinfra.api.command import QuoteString, StringCommand, make_formatted_string_command
+
+
+class ServiceScript(FactBase):
+    @override
+    def command(self, srvname: str, jail: Optional[str] = None) -> StringCommand:
+        if jail is None:
+            jail = ""
+
+        return make_formatted_string_command(
+            (
+                "for service in `service -j {0} -l`; do "
+                'if [ {1} = \\"$service\\" ]; '
+                'then echo \\"$service\\"; '
+                "fi; "
+                "done"
+            ),
+            QuoteString(jail),
+            QuoteString(srvname),
+        )
+
+
+class ServiceStatus(FactBase):
+    @override
+    def command(self, srvname: str, jail: Optional[str] = None) -> StringCommand:
+        if jail is None:
+            jail = ""
+
+        return make_formatted_string_command(
+            ("service -j {0} {1} status > /dev/null 2>&1; if [ $? -eq 0 ]; then echo running; fi"),
+            QuoteString(jail),
+            QuoteString(srvname),
+        )
+
+
+class Sysrc(FactBase):
+    @override
+    def command(self, parameter: str, jail: Optional[str] = None) -> StringCommand:
+        if jail is None:
+            command = make_formatted_string_command(
+                ("sysrc -in -- {0} || true"), QuoteString(parameter)
+            )
+        else:
+            command = make_formatted_string_command(
+                ("sysrc -j {0} -in -- {1} || true"), QuoteString(jail), QuoteString(parameter)
+            )
+
+        return command
+
+
+class PkgPackage(FactBase):
+    @override
+    def command(self, package: str, jail: Optional[str] = None) -> StringCommand:
+        if jail is None:
+            command = make_formatted_string_command(
+                ("pkg info -E -- {0} 2> /dev/null || true"), QuoteString(package)
+            )
+        else:
+            command = make_formatted_string_command(
+                ("pkg -j {0} info -E -- {1} 2> /dev/null || true"),
+                QuoteString(jail),
+                QuoteString(package),
+            )
+
+        return command

pyinfra/facts/gem.py

@@ -1,22 +1,35 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
 
-GEM_REGEX = r'^([a-zA-Z0-9\-\+\_]+)\s\(([0-9\.]+)\)$'
+GEM_REGEX = r"^([a-zA-Z0-9\-\+\_]+)\s\(([0-9\.]+)\)$"
 
 
 class GemPackages(FactBase):
-    '''
+    """
     Returns a dict of installed gem packages:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
+        {
+            'package_name': ['version'],
+        }
+    """
+
+    @override
+    def command(self) -> str:
+        return "gem list --local"
+
+    @override
+    def requires_command(self) -> str:
+        return "gem"
 
-    command = 'gem list --local'
     default = dict
 
+    @override
     def process(self, output):
         return parse_packages(GEM_REGEX, output)

pyinfra/facts/git.py

@@ -1,26 +1,71 @@
+from __future__ import annotations
+
+import re
+
+from typing_extensions import override
+
 from pyinfra.api.facts import FactBase
 
 
-class GitBranch(FactBase):
-    @staticmethod
-    def command(repo):
-        return 'cd {0} && git rev-parse --abbrev-ref HEAD'.format(repo)
+class GitFactBase(FactBase):
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "git"
+
+
+class GitBranch(GitFactBase):
+    @override
+    def command(self, repo) -> str:
+        return "! test -d {0} || (cd {0} && git describe --all)".format(repo)
+
+    @override
+    def process(self, output):
+        return re.sub(r"(heads|tags)/", r"", "\n".join(output))
+
 
+class GitTag(GitFactBase):
+    @override
+    def command(self, repo) -> str:
+        return "! test -d {0} || (cd {0} && git tag)".format(repo)
 
-class GitConfig(FactBase):
-    @staticmethod
-    def command(repo=None):
+    @override
+    def process(self, output):
+        return output
+
+
+class GitConfig(GitFactBase):
+    default = dict
+
+    @override
+    def command(self, repo=None, system=False) -> str:
         if repo is None:
-            return 'git config --global -l'
+            level = "--system" if system else "--global"
+            return f"git config {level} -l || true"
 
-        return 'cd {0} && git config --local -l'.format(repo)
+        return "! test -d {0} || (cd {0} && git config --local -l)".format(repo)
 
-    @staticmethod
-    def process(output):
-        items = {}
+    @override
+    def process(self, output):
+        items: dict[str, list[str]] = {}
 
         for line in output:
-            key, value = line.split('=', 1)
-            items[key] = value
+            key, value = line.split("=", 1)
+            items.setdefault(key, []).append(value)
 
         return items
+
+
+class GitTrackingBranch(GitFactBase):
+    @override
+    def command(self, repo) -> str:
+        return r"! test -d {0} || (cd {0} && git status --branch --porcelain)".format(repo)
+
+    @override
+    def process(self, output):
+        if not output:
+            return None
+
+        m = re.search(r"\.{3}(\S+)\b", list(output)[0])
+        if m:
+            return m.group(1)
+        return None

pyinfra/facts/gpg.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+
+class GpgFactBase(FactBase):
+    abstract = True
+
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "gpg"
+
+    key_record_type = "pub"
+    subkey_record_type = "sub"
+
+    @override
+    def process(self, output):
+        # For details on the field values see:
+        # https://git.gnupg.org/cgi-bin/gitweb.cgi?p=gnupg.git;a=blob_plain;f=doc/DETAILS
+        keys = []
+
+        current_key = None
+        current_subkey = None
+
+        for line in output:
+            if not line:
+                continue
+
+            bits = line.split(":")
+
+            if bits[0] in (self.key_record_type, self.subkey_record_type):
+                key_details = {
+                    "validity": bits[1],
+                    "length": int(bits[2]),
+                    "id": bits[4],
+                }
+
+                if bits[0] == self.key_record_type:
+                    key_details["subkeys"] = []
+
+                    if current_key:
+                        if current_subkey:
+                            current_key["subkeys"].append(current_subkey)
+
+                        keys.append(current_key)
+
+                    current_key = key_details
+                    current_subkey = None
+                elif current_key:
+                    current_subkey = key_details
+
+            elif current_subkey or current_key:
+                target = current_subkey or current_key
+                assert target is not None
+                if bits[0] == "fpr":
+                    target["fingerprint"] = bits[9]  # fingerprint = field 10
+                elif bits[0] == "uid":
+                    target["uid_hash"] = bits[7]
+                    target["uid"] = bits[9]
+
+        if current_key:
+            if current_subkey:
+                current_key["subkeys"].append(current_subkey)
+
+            keys.append(current_key)
+
+        # Return as a dictionary of keyID -> details
+        keys_by_id = {}
+        for key in keys:
+            if "subkeys" in key:
+                key["subkeys"] = {subkey.pop("id"): subkey for subkey in key["subkeys"]}
+            keys_by_id[key.pop("id")] = key
+
+        return keys_by_id
+
+
+class GpgKey(GpgFactBase):
+    """
+    Returns information on one or more GPG keys found in a file or URL.
+
+    .. code:: python
+
+        {
+            "KEY-ID": {
+                "length": 4096,
+                "uid": "Oxygem <hello@oxygem.com>"
+            },
+        }
+    """
+
+    @override
+    def command(self, src):
+        if urlparse(src).scheme:
+            return ("(wget -O - {0} || curl -sSLf {0}) | gpg --with-colons").format(src)
+
+        return "gpg --with-colons {0}".format(src)
+
+
+class GpgKeys(GpgFactBase):
+    """
+    Returns information on all public keys in a keychain.
+
+    .. code:: python
+
+        {
+            "KEY-ID": {
+                "length": 4096,
+                "uid": "Oxygem <hello@oxygem.com>"
+            },
+        }
+    """
+
+    @override
+    def command(self, keyring=None):
+        if not keyring:
+            return "gpg --list-keys --with-colons"
+
+        return ("gpg --list-keys --with-colons --keyring {0} --no-default-keyring").format(keyring)
+
+
+class GpgSecretKeys(GpgFactBase):
+    """
+    Returns information on all secret keys in a keychain.
+
+    .. code:: python
+
+        {
+            "KEY-ID": {
+                "length": 4096,
+                "fingerprint": "ABC",
+                "uid": "Oxygem <hello@oxygem.com>"
+            },
+        }
+    """
+
+    key_record_type = "sec"
+    subkey_record_type = "ssb"
+
+    @override
+    def command(self, keyring=None):
+        if not keyring:
+            return "gpg --list-secret-keys --with-colons"
+
+        return ("gpg --list-secret-keys --with-colons --keyring {0} --no-default-keyring").format(
+            keyring,
+        )