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

pyinfra/context.py

@@ -0,0 +1,145 @@
+"""
+The `ContextObject` and `ContextManager` provide context specific variables that
+are imported and used throughout pyinfra and end user deploy code (CLI mode).
+
+These variables always represent the current executing pyinfra context.
+"""
+
+from contextlib import contextmanager
+from types import ModuleType
+from typing import TYPE_CHECKING
+
+from gevent.local import local
+from typing_extensions import override
+
+if TYPE_CHECKING:
+    from pyinfra.api.config import Config
+    from pyinfra.api.host import Host
+    from pyinfra.api.inventory import Inventory
+    from pyinfra.api.state import State
+
+
+class container:
+    module = None
+
+
+class ContextObject:
+    _container_cls = container
+    _base_cls: ModuleType
+
+    def __init__(self) -> None:
+        self._container = self._container_cls()
+        self._container.module = None
+
+    def _get_module(self):
+        return self._container.module
+
+    @override
+    def __repr__(self):
+        return "ContextObject({0}):{1}".format(
+            self._base_cls.__name__,
+            repr(self._get_module()),
+        )
+
+    @override
+    def __str__(self):
+        return str(self._get_module())
+
+    @override
+    def __dir__(self):
+        return dir(self._base_cls)
+
+    def __getattr__(self, key):
+        if self._get_module() is None:
+            return getattr(self._base_cls, key)
+        return getattr(self._get_module(), key)
+
+    @override
+    def __setattr__(self, key, value):
+        if key in ("_container", "_base_cls"):
+            return super().__setattr__(key, value)
+
+        mod = self._get_module()
+        if mod is None:
+            raise TypeError("Cannot assign to context base module")
+        return setattr(mod, key, value)
+
+    def __iter__(self):
+        mod = self._get_module()
+        if mod is None:
+            raise ValueError("Context not set")
+        return iter(mod)
+
+    def __len__(self):
+        mod = self._get_module()
+        if mod is None:
+            raise ValueError("Context not set")
+        return len(mod)
+
+    @override
+    def __eq__(self, other):
+        return self._get_module() == other
+
+    @override
+    def __hash__(self):
+        return hash(self._get_module())
+
+
+class LocalContextObject(ContextObject):
+    _container_cls = local
+
+
+class ContextManager:
+    def __init__(self, key, context_cls):
+        self.context = context_cls()
+
+    def get(self):
+        return getattr(self.context._container, "module", None)
+
+    def set(self, module):
+        self.context._container.module = module
+
+    def set_base(self, module):
+        self.context._base_cls = module
+
+    def reset(self) -> None:
+        self.context._container.module = None
+
+    def isset(self):
+        return self.get() is not None
+
+    @contextmanager
+    def use(self, module):
+        old_module = self.get()
+        if old_module is module:
+            yield  # if we're double-setting, nothing to do
+            return
+        self.set(module)
+        yield
+        self.set(old_module)
+
+
+ctx_state = ContextManager("state", ContextObject)
+state: "State" = ctx_state.context
+
+ctx_inventory = ContextManager("inventory", ContextObject)
+inventory: "Inventory" = ctx_inventory.context
+
+# Config can be modified mid-deploy, so we use a local object here which
+# is based on a copy of the state config.
+ctx_config = ContextManager("config", LocalContextObject)
+config: "Config" = ctx_config.context
+
+# Hosts are prepared in parallel each in a greenlet, so we use a local to
+# point at different host objects in each greenlet.
+ctx_host = ContextManager("host", LocalContextObject)
+host: "Host" = ctx_host.context
+
+
+def init_base_classes() -> None:
+    from pyinfra.api import Config, Host, Inventory, State
+
+    ctx_config.set_base(Config)
+    ctx_inventory.set_base(Inventory)
+    ctx_host.set_base(Host)
+    ctx_state.set_base(State)

pyinfra/facts/__init__.py

@@ -1,11 +1,12 @@
+# This file only exists to support:
+# from pyinfra import facts
+# facts.X.Y
+
 from glob import glob
 from os import path
 
-
-module_filenames = glob(path.join(path.dirname(__file__), '*.py'))
+module_filenames = glob(path.join(path.dirname(__file__), "*.py"))
 module_names = [path.basename(name)[:-3] for name in module_filenames]
-__all__ = [name for name in module_names if name != '__init__']
-
+__all__ = [name for name in module_names if name != "__init__"]
 
-# Actually triggers __all__ imports to builds facts index
-from . import * # noqa
+from . import *  # noqa

pyinfra/facts/apk.py

@@ -1,22 +1,37 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
 
-APK_REGEX = r'^([a-zA-Z\-]+)-([0-9\.]+\-?[a-z0-9]*)\s'
+# Source: https://superuser.com/a/1472405
+# Modified to return version and release inside a single group and removed extra capturing groups
+APK_REGEX = r"(.+)-([^-]+-r[^-]+) \S+ \{\S+\} \(.+?\)"
 
 
 class ApkPackages(FactBase):
-    '''
+    """
     Returns a dict of installed apk packages:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    @override
+    def command(self) -> str:
+        return "apk list --installed"
+
+    @override
+    def requires_command(self) -> str:
+        return "apk"
 
-    command = 'apk list --installed'
-    deafult = dict
+    default = dict
 
+    @override
     def process(self, output):
         return parse_packages(APK_REGEX, output)

pyinfra/facts/apt.py

@@ -1,12 +1,39 @@
+from __future__ import annotations
+
 import re
 
+from typing_extensions import TypedDict, override
+
 from pyinfra.api import FactBase
 
-from .util.packaging import parse_packages
+from .gpg import GpgFactBase
+from .util import make_cat_files_command
+
+
+def noninteractive_apt(command: str, force=False):
+    args = ["DEBIAN_FRONTEND=noninteractive apt-get -y"]
+
+    if force:
+        args.append("--force-yes")
+
+    args.extend(
+        (
+            '-o Dpkg::Options::="--force-confdef"',
+            '-o Dpkg::Options::="--force-confold"',
+            command,
+        ),
+    )
+
+    return " ".join(args)
+
+
+APT_CHANGES_RE = re.compile(
+    r"^(\d+) upgraded, (\d+) newly installed, (\d+) to remove and (\d+) not upgraded.$"
+)
 
 
 def parse_apt_repo(name):
-    regex = r'^(deb(?:-src)?)(?:\s+\[([a-zA-Z0-9=,\s]+)\])?\s+([^\s]+)\s+([a-z-]+)\s+([a-z-\s]*)$'
+    regex = r"^(deb(?:-src)?)(?:\s+\[([^\]]+)\])?\s+([^\s]+)\s+([^\s]+)\s+([a-z-\s\d]*)$"
 
     matches = re.match(regex, name)
 
@@ -18,39 +45,51 @@ def parse_apt_repo(name):
     options_string = matches.group(2)
     if options_string:
         for option in options_string.split():
-            key, value = option.split('=', 1)
-            if ',' in value:
-                value = value.split(',')
+            key, value = option.split("=", 1)
+            if "," in value:
+                value = value.split(",")
 
             options[key] = value
 
     return {
-        'options': options,
-        'type': matches.group(1),
-        'url': matches.group(3),
-        'distribution': matches.group(4),
-        'components': set(matches.group(5).split()),
+        "options": options,
+        "type": matches.group(1),
+        "url": matches.group(3),
+        "distribution": matches.group(4),
+        "components": list(matches.group(5).split()),
     }
 
 
 class AptSources(FactBase):
-    '''
+    """
     Returns a list of installed apt sources:
 
     .. code:: python
 
-        {
-            'type': 'deb',
-            'url': 'http://archive.ubuntu.org',
-            'distribution': 'trusty',
-            'components', ['main', 'multiverse']
-        },
-        ...
-    '''
-
-    command = 'cat /etc/apt/sources.list /etc/apt/sources.list.d/*.list || true'
+        [
+            {
+                "type": "deb",
+                "url": "http://archive.ubuntu.org",
+                "distribution": "trusty",
+                "components", ["main", "multiverse"],
+            },
+        ]
+    """
+
+    @override
+    def command(self) -> str:
+        return make_cat_files_command(
+            "/etc/apt/sources.list",
+            "/etc/apt/sources.list.d/*.list",
+        )
+
+    @override
+    def requires_command(self) -> str:
+        return "apt"  # if apt installed, above should exist
+
     default = list
 
+    @override
     def process(self, output):
         repos = []
 
@@ -62,46 +101,64 @@ class AptSources(FactBase):
         return repos
 
 
-class DebPackages(FactBase):
-    '''
-    Returns a dict of installed dpkg packages:
+class AptKeys(GpgFactBase):
+    """
+    Returns information on GPG keys apt has in its keychain:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
-
-    command = 'dpkg -l'
-    regex = r'^ii\s+([a-zA-Z0-9\+\-\.]+):?[a-zA-Z0-9]*\s+([a-zA-Z0-9:~\.\-\+]+).+$'
-    default = dict
-
-    def process(self, output):
-        return parse_packages(self.regex, output)
-
-
-class DebPackage(FactBase):
-    '''
-    Returns information on a .deb file.
-    '''
-
-    _regexes = {
-        'name': r'^Package: ([a-zA-Z0-9\-]+)$',
-        'version': r'^Version: ([0-9\:\.\-]+)$',
-    }
-
-    def command(self, name):
-        return 'dpkg -I {0}'.format(name)
-
-    def process(self, output):
-        data = {}
-
+        {
+            "KEY-ID": {
+                "length": 4096,
+                "uid": "Oxygem <hello@oxygem.com>"
+            },
+        }
+    """
+
+    # This requires both apt-key *and* apt-key itself requires gpg
+    @override
+    def command(self) -> str:
+        return "! command -v gpg || apt-key list --with-colons"
+
+    @override
+    def requires_command(self) -> str:
+        return "apt-key"
+
+
+class AptSimulationDict(TypedDict):
+    upgraded: int
+    newly_installed: int
+    removed: int
+    not_upgraded: int
+
+
+class SimulateOperationWillChange(FactBase[AptSimulationDict]):
+    """
+    Simulate an 'apt-get' operation and try to detect if any changes would be performed.
+    """
+
+    @override
+    def command(self, command: str) -> str:
+        # LC_ALL=C: Ensure the output is in english, as we want to parse it
+        return "LC_ALL=C " + noninteractive_apt(f"{command} --dry-run")
+
+    @override
+    def requires_command(self, command: str) -> str:
+        return "apt-get"
+
+    @override
+    def process(self, output) -> AptSimulationDict:
+        # We are looking for a line similar to
+        # "3 upgraded, 0 newly installed, 0 to remove and 0 not upgraded."
         for line in output:
-            for key, regex in self._regexes.items():
-                matches = re.match(regex, line)
-                if matches:
-                    value = matches.group(1)
-                    data[key] = value
-                    break
-
-        return data
+            result = APT_CHANGES_RE.match(line)
+            if result is not None:
+                return {
+                    "upgraded": int(result[1]),
+                    "newly_installed": int(result[2]),
+                    "removed": int(result[3]),
+                    "not_upgraded": int(result[4]),
+                }
+
+        # We did not find the line we expected:
+        raise Exception("Did not find proposed changes in output")

pyinfra/facts/brew.py

@@ -1,46 +1,131 @@
+from __future__ import annotations
+
+import re
+
+from typing_extensions import override
+
+from pyinfra import logger
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
 
-BREW_REGEX = r'^([a-zA-Z\-]+)\s([0-9\._+a-z\-]+)'
+BREW_REGEX = r"^([^\s]+)\s([0-9\._+a-z\-]+)"
+
+
+def new_cask_cli(version):
+    """
+    Returns true if brew is version 2.6.0 or later and thus has the new CLI for casks.
+    i.e. we need to use brew list --cask instead of brew cask list
+    See https://brew.sh/2020/12/01/homebrew-2.6.0/
+    The version string returned by BrewVersion is a list of major, minor, patch version numbers
+    """
+    return (version[0] >= 3) or ((version[0] >= 2) and version[1] >= 6)
+
+
+VERSION_MATCHER = re.compile(r"^Homebrew\s+(?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+).*$")
+
+
+def unknown_version():
+    return [0, 0, 0]
+
+
+class BrewVersion(FactBase):
+    """
+    Returns the version of brew installed as a semantic versioning tuple:
+
+    .. code:: python
+
+        [major, minor, patch]
+
+    """
+
+    @override
+    def command(self) -> str:
+        return "brew --version"
+
+    @override
+    def requires_command(self) -> str:
+        return "brew"
+
+    @override
+    @staticmethod
+    def default():
+        return [0, 0, 0]
+
+    @override
+    def process(self, output):
+        out = list(output)[0]
+        m = VERSION_MATCHER.match(out)
+        if m is not None:
+            return [int(m.group(key)) for key in ["major", "minor", "patch"]]
+        logger.warning("could not parse version string from brew: %s", out)
+        return self.default()
 
 
 class BrewPackages(FactBase):
-    '''
+    """
     Returns a dict of installed brew packages:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    @override
+    def command(self) -> str:
+        return "brew list --versions"
+
+    @override
+    def requires_command(self) -> str:
+        return "brew"
 
-    command = 'brew list --versions'
-    deafult = dict
+    default = dict
 
+    @override
     def process(self, output):
         return parse_packages(BREW_REGEX, output)
 
 
 class BrewCasks(BrewPackages):
-    '''
+    """
     Returns a dict of installed brew casks:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
+        {
+            "package_name": ["version"],
+        }
+    """
 
-    command = 'brew cask list --versions'
+    @override
+    def command(self) -> str:
+        return (
+            r'if brew --version | grep -q -e "Homebrew\ +(1\.|2\.[0-5]).*" 1>/dev/null;'
+            r"then brew cask list --versions; else brew list --cask --versions; fi"
+        )
+
+    @override
+    def requires_command(self) -> str:
+        return "brew"
 
 
 class BrewTaps(FactBase):
-    '''
+    """
     Returns a list of brew taps.
-    '''
+    """
+
+    @override
+    def command(self) -> str:
+        return "brew tap"
+
+    @override
+    def requires_command(self) -> str:
+        return "brew"
 
-    command = 'brew tap'
+    default = list
 
+    @override
     def process(self, output):
         return output

pyinfra/facts/bsdinit.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+from .sysvinit import InitdStatus
+
+
+class RcdStatus(InitdStatus):
+    """
+    Same as ``initd_status`` but for BSD (/etc/rc.d) systems. Unlike Linux/init.d,
+    BSD init scripts are well behaved and as such their output can be trusted.
+    """
+
+    @override
+    def command(self) -> str:
+        return """
+            for SERVICE in `find /etc/rc.d /usr/local/etc/rc.d -type f`; do
+                $SERVICE status 2> /dev/null || $SERVICE check 2> /dev/null
+                echo "`basename $SERVICE`=$?"
+            done
+        """
+
+    default = dict

pyinfra/facts/cargo.py

@@ -0,0 +1,37 @@
+# encoding: utf8
+
+from __future__ import annotations
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+from .util.packaging import parse_packages
+
+CARGO_REGEX = r"^([a-zA-Z0-9\-]+)\sv([0-9\.]+)"
+
+
+class CargoPackages(FactBase):
+    """
+    Returns a dict of installed cargo packages globally:
+
+    .. code:: python
+
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    default = dict
+
+    @override
+    def command(self) -> str:
+        return "cargo install --list"
+
+    @override
+    def requires_command(self) -> str:
+        return "cargo"
+
+    @override
+    def process(self, output):
+        return parse_packages(CARGO_REGEX, output)

pyinfra/facts/choco.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+from .util.packaging import parse_packages
+
+CHOCO_REGEX = r"^([a-zA-Z0-9\.\-\+\_]+)\s([0-9\.]+)$"
+
+
+class ChocoPackages(FactBase):
+    """
+    Returns a dict of installed choco (Chocolatey) packages:
+
+    .. code:: python
+
+        {
+            "package_name": ["version"],
+        }
+    """
+
+    @override
+    def command(self) -> str:
+        return "choco list"
+
+    shell_executable = "ps"
+
+    default = dict
+
+    @override
+    def process(self, output):
+        return parse_packages(CHOCO_REGEX, output)
+
+
+class ChocoVersion(FactBase):
+    """
+    Returns the choco (Chocolatey) version.
+    """
+
+    @override
+    def command(self) -> str:
+        return "choco --version"
+
+    @override
+    def process(self, output):
+        return "".join(output).replace("\n", "")