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

pyinfra/facts/yum.py

@@ -1,53 +1,47 @@
-import re
+from __future__ import annotations
 
-from pyinfra.api import FactBase
+from typing_extensions import override
 
-from .util.packaging import parse_packages
+from pyinfra.api import FactBase
 
-rpm_regex = r'^([a-zA-Z0-9_\-\+]+)\-([0-9a-z\.\-]+)\.[a-z0-9_\.]+$'
+from .util import make_cat_files_command
+from .util.packaging import parse_yum_repositories
 
 
-class RPMPackages(FactBase):
-    '''
-    Returns a dict of installed rpm packages:
+class YumRepositories(FactBase):
+    """
+    Returns a list of installed yum repositories:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
-
-    command = 'rpm -qa'
-    default = dict
-
-    def process(self, output):
-        return parse_packages(
-            rpm_regex, output,
-            # yum packages are case-sensitive
-            lower=False,
+        [
+            {
+                "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/yum.conf",
+            "/etc/yum.repos.d/*.repo",
         )
 
+    @override
+    def requires_command(self) -> str:
+        return "yum"
 
-class RpmPackage(FactBase):
-    '''
-    Returns information on a .rpm file:
-
-    .. code:: python
-
-        {
-            'name': 'my_package',
-            'version': '1.0.0'
-        }
-    '''
-
-    def command(self, name):
-        return 'rpm -qp {0}'.format(name)
+    default = list
 
+    @override
     def process(self, output):
-        for line in output:
-            matches = re.match(rpm_regex, line)
-            if matches:
-                return {
-                    'name': matches.group(1),
-                    'version': matches.group(2),
-                }
+        return parse_yum_repositories(output)

pyinfra/facts/zfs.py

@@ -0,0 +1,77 @@
+"""
+Gather information about ZFS filesystems.
+"""
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase, ShortFactBase
+
+
+def _process_zfs_props_table(output):
+    datasets: dict = {}
+    for line in output:
+        dataset, property, value, source = tuple(line.split("\t"))
+        if dataset not in datasets:
+            datasets[dataset] = {}
+        datasets[dataset][property] = value
+    return datasets
+
+
+class ZfsPools(FactBase):
+    @override
+    def command(self) -> str:
+        return "zpool get -H all"
+
+    @override
+    def requires_command(self) -> str:
+        return "zpool"
+
+    @override
+    def process(self, output):
+        return _process_zfs_props_table(output)
+
+
+class ZfsDatasets(FactBase):
+    @override
+    def command(self) -> str:
+        return "zfs get -H all"
+
+    @override
+    def requires_command(self) -> str:
+        return "zfs"
+
+    @override
+    def process(self, output):
+        return _process_zfs_props_table(output)
+
+
+class ZfsFilesystems(ShortFactBase):
+    fact = ZfsDatasets
+
+    @override
+    def process_data(self, data):
+        return {name: props for name, props in data.items() if props.get("type") == "filesystem"}
+
+
+class ZfsSnapshots(ShortFactBase):
+    fact = ZfsDatasets
+
+    @override
+    def process_data(self, data):
+        return {name: props for name, props in data.items() if props.get("type") == "snapshot"}
+
+
+class ZfsVolumes(ShortFactBase):
+    fact = ZfsDatasets
+
+    @override
+    def process_data(self, data):
+        return {name: props for name, props in data.items() if props.get("type") == "volume"}
+
+
+# TODO: remove these in v4! Or flip the convention and remove all the other fact prefixes!
+Pools = ZfsPools
+Datasets = ZfsDatasets
+Filesystems = ZfsFilesystems
+Snapshots = ZfsSnapshots
+Volumes = ZfsVolumes

pyinfra/facts/zypper.py

@@ -0,0 +1,42 @@
+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_zypper_repositories
+
+
+class ZypperRepositories(FactBase):
+    """
+    Returns a list of installed zypper repositories:
+
+    .. code:: python
+
+        [
+            {
+                "repoid": "repo-oss",
+                "name": "Main Repository",
+                "enabled": "1",
+                "autorefresh": "1",
+                "baseurl": "http://download.opensuse.org/distribution/leap/$releasever/repo/oss/"
+            },
+        ]
+    """
+
+    @override
+    def command(self) -> str:
+        return make_cat_files_command(
+            "/etc/zypp/repos.d/*.repo",
+        )
+
+    @override
+    def requires_command(self) -> str:
+        return "zypper"
+
+    default = list
+
+    @override
+    def process(self, output):
+        return parse_zypper_repositories(output)

pyinfra/local.py

@@ -1,134 +1,96 @@
 from os import path
-from subprocess import PIPE, Popen, STDOUT
+from typing import Optional
 
-from gevent.queue import Queue
+import click
 
 import pyinfra
+from pyinfra import config, host, logger, state
+from pyinfra.api.exceptions import PyinfraError
+from pyinfra.api.util import get_file_path
+from pyinfra.connectors.util import run_local_process
+from pyinfra.context import ctx_state
 
-from . import logger, pseudo_host, pseudo_state
-from .api.exceptions import PyinfraError
-from .api.util import ensure_host_list, get_caller_frameinfo, read_buffer
 
-
-def include(filename, hosts=False, when=True):
-    '''
-    Executes a local python file within the ``pyinfra.pseudo_state.deploy_dir``
+def include(filename: str, data: Optional[dict] = None):
+    """
+    Executes a local python file within the ``pyinfra.state.cwd``
     directory.
-
-    Args:
-        hosts (string, list): group name or list of hosts to limit this include to
-        when (bool): indicate whether to trigger operations in this include
-    '''
+    """
 
     if not pyinfra.is_cli:
-        raise PyinfraError('local.include is only available in CLI mode.')
+        raise PyinfraError("local.include is only available in CLI mode.")
 
-    if not when:
-        return
+    filename = get_file_path(state, filename)
 
-    if hosts is not False:
-        hosts = ensure_host_list(hosts, inventory=pseudo_state.inventory)
-        if pseudo_host not in hosts:
-            return
+    logger.debug("Including local file: %s", filename)
 
-    if pseudo_state.deploy_dir:
-        filename = path.join(pseudo_state.deploy_dir, filename)
-
-    frameinfo = get_caller_frameinfo()
-
-    logger.debug('Including local file: {0}'.format(filename))
+    config_state = config.get_current_state()
 
     try:
         # Fixes a circular import because `pyinfra.local` is really a CLI
         # only thing (so should be `pyinfra_cli.local`). It is kept here
-        # to maintain backwards compatability and the nicer public import
+        # to maintain backwards compatibility and the nicer public import
         # (ideally users never need to import from `pyinfra_cli`).
 
-        from pyinfra_cli.config import extract_file_config
         from pyinfra_cli.util import exec_file
 
-        # Load any config defined in the file and setup like a @deploy
-        config_data = extract_file_config(filename)
-        kwargs = {
-            key.lower(): value
-            for key, value in config_data.items()
-            if key in [
-                'SUDO', 'SUDO_USER', 'SU_USER',
-                'PRESERVE_SUDO_ENV', 'IGNORE_ERRORS',
-            ]
-        }
-        with pseudo_state.deploy(
-            filename, kwargs, None, frameinfo.lineno,
-            in_deploy=False,
-        ):
+        with host.deploy(path.relpath(filename, state.cwd), None, data, in_deploy=False):
             exec_file(filename)
 
         # One potential solution to the above is to add local as an actual
-        # module, ie `pyinfra.modules.local`.
+        # module, ie `pyinfra.operations.local`.
 
-    except IOError as e:
-        raise PyinfraError(
-            'Could not include local file: {0}\n{1}'.format(filename, e),
-        )
+    finally:
+        config.set_current_state(config_state)
 
 
-def shell(commands, splitlines=False, ignore_errors=False):
-    '''
+def shell(
+    commands,
+    splitlines: bool = False,
+    ignore_errors: bool = False,
+    print_output: bool = False,
+    print_input: bool = False,
+):
+    """
     Subprocess based implementation of pyinfra/api/ssh.py's ``run_shell_command``.
 
     Args:
         commands (string, list): command or list of commands to execute
-        spltlines (bool): optionally have the output split by lines
+        splitlines (bool): optionally have the output split by lines
         ignore_errors (bool): ignore errors when executing these commands
-    '''
+    """
 
     if isinstance(commands, str):
         commands = [commands]
 
     all_stdout = []
 
-    # Checking for pseudo_state means this function works outside a deploy
-    # eg the vagrant connector.
-    print_output = (
-        pseudo_state.print_output
-        if pseudo_state.isset()
-        else False
-    )
+    # Checking for state context being set means this function works outside a deploy
+    # e.g.: the vagrant connector.
+    if ctx_state.isset():
+        print_output = state.print_output
+        print_input = state.print_input
 
     for command in commands:
-        print_prefix = 'localhost: '
+        print_prefix = "localhost: "
 
-        if print_output:
-            print('{0}>>> {1}'.format(print_prefix, command))
+        if print_input:
+            click.echo("{0}>>> {1}".format(print_prefix, command), err=True)
 
-        process = Popen(command, shell=True, stdout=PIPE, stderr=STDOUT)
-
-        stdout_queue = Queue()
-
-        read_buffer(
-            'stdout',
-            process.stdout,
-            stdout_queue,
+        return_code, output = run_local_process(
+            command,
             print_output=print_output,
-            print_func=lambda line: '{0}{1}'.format(print_prefix, line),
+            print_prefix=print_prefix,
         )
 
-        stdout = [line for _, line in stdout_queue.queue]
-
-        # Get & check result
-        result = process.wait()
-
-        # Close any open file descriptor
-        process.stdout.close()
-
-        if result > 0 and not ignore_errors:
+        if return_code > 0 and not ignore_errors:
             raise PyinfraError(
-                'Local command failed: {0}\n{1}'.format(command, stdout),
+                "Local command failed: {0}\n{1}".format(command, output.stderr),
             )
 
-        all_stdout.extend(stdout)
+        all_stdout.extend(output.stdout_lines)
 
     if not splitlines:
-        return '\n'.join(all_stdout)
+        return "\n".join(all_stdout)
 
     return all_stdout

pyinfra/operations/__init__.py

@@ -0,0 +1,12 @@
+# This file only exists to support:
+# from pyinfra import operations
+# operations.X.Y
+
+from glob import glob
+from os import path
+
+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__"]
+
+from . import *  # noqa

pyinfra/operations/apk.py

@@ -0,0 +1,99 @@
+"""
+Manage apk packages. (Alpine Linux)
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.apk import ApkPackages
+
+from .util.packaging import ensure_packages
+
+
+@operation(is_idempotent=False)
+def upgrade(available: bool = False):
+    """
+    Upgrades all apk packages.
+
+    + available: force all packages to be upgraded (recommended on whole Alpine version upgrades)
+    """
+
+    if available:
+        yield "apk upgrade --available"
+    else:
+        yield "apk upgrade"
+
+
+_upgrade = upgrade._inner  # noqa: E305
+
+
+@operation(is_idempotent=False)
+def update():
+    """
+    Updates apk repositories.
+    """
+
+    yield "apk update"
+
+
+_update = update._inner  # noqa: E305
+
+
+@operation()
+def packages(
+    packages: str | list[str] | None = None,
+    present=True,
+    latest=False,
+    update=False,
+    upgrade=False,
+):
+    """
+    Add/remove/update apk packages.
+
+    + packages: list of packages to ensure
+    + present: whether the packages should be installed
+    + latest: whether to upgrade packages without a specified version
+    + update: run ``apk update`` before installing packages
+    + upgrade: run ``apk upgrade`` before installing packages
+
+    Versions:
+        Package versions can be pinned like apk: ``<pkg>=<version>``.
+
+    **Examples:**
+
+    .. code:: python
+
+        from pyinfra.operations import apk
+        # Update package list and install packages
+        apk.packages(
+            name="Install Asterisk and Vim",
+            packages=["asterisk", "vim"],
+            update=True,
+        )
+
+        # Install the latest versions of packages (always check)
+        apk.packages(
+            name="Install latest Vim",
+            packages=["vim"],
+            latest=True,
+        )
+    """
+
+    if update:
+        yield from _update()
+
+    if upgrade:
+        yield from _upgrade()
+
+    yield from ensure_packages(
+        host,
+        packages,
+        host.get_fact(ApkPackages),
+        present,
+        install_command="apk add",
+        uninstall_command="apk del",
+        upgrade_command="apk upgrade",
+        version_join="=",
+        latest=latest,
+    )