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

pyinfra/operations/openrc.py

@@ -0,0 +1,63 @@
+"""
+Manage OpenRC init services.
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.openrc import OpenrcEnabled, OpenrcStatus
+
+from .util.service import handle_service_control
+
+
+@operation()
+def service(
+    service: str,
+    running=True,
+    restarted=False,
+    reloaded=False,
+    command: str | None = None,
+    enabled: bool | None = None,
+    runlevel="default",
+):
+    """
+    Manage the state of OpenRC services.
+
+    + service: name of the service to manage
+    + running: whether the service should be running
+    + restarted: whether the service should be restarted
+    + reloaded: whether the service should be reloaded
+    + command: custom command to pass like: ``rc-service <service> <command>``
+    + enabled: whether this service should be enabled/disabled on boot
+    + runlevel: runlevel to manage services for
+    """
+
+    yield from handle_service_control(
+        host,
+        service,
+        host.get_fact(OpenrcStatus, runlevel=runlevel),
+        "rc-service {0} {1}",
+        running,
+        restarted,
+        reloaded,
+        command,
+    )
+
+    if isinstance(enabled, bool):
+        openrc_enabled = host.get_fact(OpenrcEnabled, runlevel=runlevel)
+        is_enabled = openrc_enabled.get(service, False)
+
+        if enabled is True:
+            if not is_enabled:
+                yield "rc-update add {0} {1}".format(service, runlevel)
+                openrc_enabled[service] = True
+            else:
+                host.noop("service {0} is enabled".format(service))
+
+        if enabled is False:
+            if is_enabled:
+                yield "rc-update del {0} {1}".format(service, runlevel)
+                openrc_enabled[service] = False
+            else:
+                host.noop("service {0} is disabled".format(service))

pyinfra/operations/opkg.py

@@ -0,0 +1,89 @@
+"""
+Manage packages on OpenWrt using opkg
+    + ``update`` - update local copy of package information
+    + ``packages`` -  install and remove packages
+
+see https://openwrt.org/docs/guide-user/additional-software/opkg
+OpenWrt recommends against upgrading all packages  thus there is no ``opkg.upgrade`` function
+"""
+
+from typing import List, Union
+
+from pyinfra import host
+from pyinfra.api import StringCommand, operation
+from pyinfra.facts.opkg import OpkgPackages
+from pyinfra.operations.util.packaging import ensure_packages
+
+EQUALS = "="
+
+
+@operation(is_idempotent=False)
+def update():
+    """
+    Update the local opkg information.
+    """
+
+    yield StringCommand("opkg update")
+
+
+_update = update
+
+
+@operation()
+def packages(
+    packages: Union[str, List[str]] = "",
+    present: bool = True,
+    latest: bool = False,
+    update: bool = True,
+):
+    """
+    Add/remove/update opkg packages.
+
+    + packages: package or list of packages to that must/must not be present
+    + present: whether the package(s) should be installed (default True) or removed
+    + latest: whether to attempt to upgrade the specified package(s) (default False)
+    + update: run ``opkg update`` before installing packages (default True)
+
+    Not Supported:
+        Opkg does not support version pinning, i.e. ``<pkg>=<version>`` is not allowed
+        and will cause an exception.
+
+    **Examples:**
+
+    .. code:: python
+
+        from pyinfra.operations import opkg
+        # Ensure packages are installed (will not force package upgrade)
+        opkg.packages(['asterisk', 'vim'], name="Install Asterisk and Vim")
+
+        # Install the latest versions of packages (always check)
+        opkg.packages(
+            'vim',
+            latest=True,
+            name="Ensure we have the latest version of Vim"
+        )
+    """
+    if str(packages) == "" or (
+        isinstance(packages, list) and (len(packages) < 1 or all(len(p) < 1 for p in packages))
+    ):
+        host.noop("empty or invalid package list provided to opkg.packages")
+        return
+
+    pkg_list = packages if isinstance(packages, list) else [packages]
+    have_equals = ",".join([pkg.split(EQUALS)[0] for pkg in pkg_list if EQUALS in pkg])
+    if len(have_equals) > 0:
+        raise ValueError(f"opkg does not support version pinning but found for: '{have_equals}'")
+
+    if update:
+        yield from _update._inner()
+
+    yield from ensure_packages(
+        host,
+        pkg_list,
+        host.get_fact(OpkgPackages),
+        present,
+        install_command="opkg install",
+        upgrade_command="opkg upgrade",
+        uninstall_command="opkg remove",
+        latest=latest,
+    )

pyinfra/operations/pacman.py

@@ -0,0 +1,82 @@
+"""
+Manage pacman packages. (Arch Linux package manager)
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.pacman import PacmanPackages, PacmanUnpackGroup
+
+from .util.packaging import ensure_packages
+
+
+@operation(is_idempotent=False)
+def upgrade():
+    """
+    Upgrades all pacman packages.
+    """
+
+    yield "pacman --noconfirm -Su"
+
+
+_upgrade = upgrade._inner  # noqa: E305
+
+
+@operation(is_idempotent=False)
+def update():
+    """
+    Updates pacman repositories.
+    """
+
+    yield "pacman -Sy"
+
+
+_update = update._inner  # noqa: E305
+
+
+@operation()
+def packages(
+    packages: str | list[str] | None = None,
+    present=True,
+    update=False,
+    upgrade=False,
+):
+    """
+    Add/remove pacman packages.
+
+    + packages: list of packages to ensure
+    + present: whether the packages should be installed
+    + update: run ``pacman -Sy`` before installing packages
+    + upgrade: run ``pacman -Su`` before installing packages
+
+    Versions:
+        Package versions can be pinned like pacman: ``<pkg>=<version>``.
+
+    **Example:**
+
+    .. code:: python
+
+        from pyinfra.operations import pacman
+        pacman.packages(
+            name="Install Vim and a plugin",
+            packages=["vim-fugitive", "vim"],
+            update=True,
+        )
+    """
+
+    if update:
+        yield from _update()
+
+    if upgrade:
+        yield from _upgrade()
+
+    yield from ensure_packages(
+        host,
+        packages,
+        host.get_fact(PacmanPackages),
+        present,
+        install_command="pacman --noconfirm -S",
+        uninstall_command="pacman --noconfirm -R",
+        expand_package_fact=lambda package: host.get_fact(PacmanUnpackGroup, package=package),
+    )

pyinfra/operations/pip.py

@@ -0,0 +1,206 @@
+"""
+Manage pip (python) packages. Compatible globally or inside
+a virtualenv (virtual environment).
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.files import File
+from pyinfra.facts.pip import PipPackages
+
+from . import files
+from .util.packaging import PkgInfo, ensure_packages
+
+
+@operation()
+def virtualenv(
+    path: str,
+    python: str | None = None,
+    venv=False,
+    site_packages=False,
+    always_copy=False,
+    present=True,
+):
+    """
+    Add/remove Python virtualenvs.
+
+    + python: python interpreter to use
+    + venv: use standard venv module instead of virtualenv
+    + site_packages: give access to the global site-packages
+    + always_copy: always copy files rather than symlinking
+    + present: whether the virtualenv should exist
+
+    **Example:**
+
+    .. code:: python
+
+        from pyinfra.operations import pip
+        pip.virtualenv(
+            name="Create a virtualenv",
+            path="/usr/local/bin/venv",
+        )
+    """
+
+    # Check for *contents* of a virtualenv, ie don't accept an empty directory
+    # as a valid virtualenv but ensure the activate script exists.
+    activate_script_path = "{0}/bin/activate".format(path)
+
+    if present is False:
+        if host.get_fact(File, path=activate_script_path):
+            yield from files.directory._inner(path, present=False)
+        else:
+            host.noop("virtualenv {0} does not exist".format(path))
+
+    if present:
+        if not host.get_fact(File, path=activate_script_path):
+            # Create missing virtualenv
+            command = ["virtualenv"]
+
+            if venv:
+                command = [python or "python", "-m", "venv"]
+
+            if python and not venv:
+                command.append("-p {0}".format(python))
+
+            if site_packages:
+                command.append("--system-site-packages")
+
+            if always_copy and not venv:
+                command.append("--always-copy")
+            elif always_copy and venv:
+                command.append("--copies")
+
+            command.append(path)
+
+            yield " ".join(command)
+        else:
+            host.noop("virtualenv {0} exists".format(path))
+
+
+_virtualenv = virtualenv._inner  # noqa
+
+
+@operation()
+def venv(
+    path: str,
+    python: str | None = None,
+    site_packages=False,
+    always_copy=False,
+    present=True,
+):
+    """
+    Add/remove Python virtualenvs.
+
+    + python: python interpreter to use
+    + site_packages: give access to the global site-packages
+    + always_copy: always copy files rather than symlinking
+    + present: whether the virtualenv should exist
+
+    **Example:**
+
+    .. code:: python
+
+        pip.venv(
+            name="Create a virtualenv",
+            path="/usr/local/bin/venv",
+        )
+    """
+
+    yield from _virtualenv(
+        venv=True,
+        path=path,
+        python=python,
+        site_packages=site_packages,
+        always_copy=always_copy,
+        present=present,
+    )
+
+
+@operation()
+def packages(
+    packages: str | list[str] | None = None,
+    present=True,
+    latest=False,
+    requirements: str | None = None,
+    pip="pip",
+    virtualenv: str | None = None,
+    virtualenv_kwargs: dict | None = None,
+    extra_install_args: str | None = None,
+):
+    """
+    Install/remove/update pip packages.
+
+    + packages: list of packages to ensure
+    + present: whether the packages should be installed
+    + latest: whether to upgrade packages without a specified version
+    + requirements: location of requirements file to install/uninstall
+    + pip: name or path of the pip directory to use
+    + virtualenv: root directory of virtualenv to work in
+    + virtualenv_kwargs: dictionary of arguments to pass to ``pip.virtualenv``
+    + extra_install_args: additional arguments to the pip install command
+
+    Virtualenv:
+        This will be created if it does not exist already. ``virtualenv_kwargs``
+        will be passed to ``pip.virtualenv`` which can be used to control how
+        the env is created.
+
+    Versions:
+        Package versions can be pinned like pip: ``<pkg>==<version>``.
+
+    **Example:**
+
+    .. code:: python
+
+        pip.packages(
+            name="Install pyinfra into a virtualenv",
+            packages=["pyinfra"],
+            virtualenv="/usr/local/bin/venv",
+        )
+    """
+
+    virtualenv_kwargs = virtualenv_kwargs or {}
+
+    # Ensure any virtualenv
+    if virtualenv:
+        yield from _virtualenv(virtualenv, **virtualenv_kwargs)
+
+        # And update pip path
+        virtualenv = virtualenv.rstrip("/")
+        pip = "{0}/bin/{1}".format(virtualenv, pip)
+
+    install_command_args = [pip, "install"]
+    if extra_install_args:
+        install_command_args.append(extra_install_args)
+    install_command = " ".join(install_command_args)
+
+    upgrade_command = "{0} --upgrade".format(install_command)
+    uninstall_command = " ".join([pip, "uninstall", "--yes"])
+
+    # (un)Install requirements
+    if requirements is not None:
+        if present:
+            yield "{0} -r {1}".format(upgrade_command if latest else install_command, requirements)
+        else:
+            yield "{0} -r {1}".format(uninstall_command, requirements)
+
+    # Handle passed in packages
+    if packages:
+        if isinstance(packages, str):
+            packages = [packages]
+        # PEP-0426 states that Python packages should be compared using lowercase, so lowercase the
+        # current packages. PkgInfo.from_pep508 takes care of the package name
+        current_packages = host.get_fact(PipPackages, pip=pip)
+        current_packages = {pkg.lower(): versions for pkg, versions in current_packages.items()}
+
+        yield from ensure_packages(
+            host,
+            list(filter(None, (PkgInfo.from_pep508(package) for package in packages))),
+            current_packages,
+            present,
+            install_command=install_command,
+            uninstall_command=uninstall_command,
+            upgrade_command=upgrade_command,
+            latest=latest,
+        )

pyinfra/operations/pipx.py

@@ -0,0 +1,103 @@
+"""
+Manage pipx (python) applications.
+"""
+
+from typing import Optional, Union
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.pipx import PipxEnvironment, PipxPackages
+from pyinfra.facts.server import Path
+
+from .util.packaging import PkgInfo, ensure_packages
+
+
+@operation()
+def packages(
+    packages: Optional[Union[str, list[str]]] = None,
+    present=True,
+    latest=False,
+    extra_args: Optional[str] = None,
+):
+    """
+    Install/remove/update pipx packages.
+
+    + packages: list of packages (PEP-508 format) to ensure
+    + present: whether the packages should be installed
+    + latest: whether to upgrade packages without a specified version
+    + extra_args: additional arguments to the pipx command
+
+    Versions:
+        Package versions can be pinned like pip: ``<pkg>==<version>``.
+
+    **Example:**
+
+    .. code:: python
+
+        from pyinfra.operations import pipx
+        pipx.packages(
+            name="Install ",
+            packages=["pyinfra"],
+        )
+    """
+    if packages is None:
+        host.noop("no package list provided to pipx.packages")
+        return
+
+    prep_install_command = ["pipx", "install"]
+
+    if extra_args:
+        prep_install_command.append(extra_args)
+    install_command = " ".join(prep_install_command)
+
+    uninstall_command = "pipx uninstall"
+    upgrade_command = "pipx upgrade"
+
+    # PEP-0426 states that Python packages should be compared using lowercase, so lowercase the
+    # current packages.  PkgInfo.from_pep508 takes care of it for the package names
+    current_packages = {
+        pkg.lower(): version for pkg, version in host.get_fact(PipxPackages).items()
+    }
+    if isinstance(packages, str):
+        packages = [packages]
+
+    # pipx support only one package name at a time
+    for package in packages:
+        if (pkg_info := PkgInfo.from_pep508(package)) is None:
+            continue  # from_pep508 logged a warning
+        yield from ensure_packages(
+            host,
+            [pkg_info],
+            current_packages,
+            present,
+            install_command=install_command,
+            uninstall_command=uninstall_command,
+            upgrade_command=upgrade_command,
+            latest=latest,
+        )
+
+
+@operation()
+def upgrade_all():
+    """
+    Upgrade all pipx packages.
+    """
+    yield "pipx upgrade-all"
+
+
+@operation()
+def ensure_path():
+    """
+    Ensure pipx bin dir is in the PATH.
+    """
+
+    # Fetch the current user's PATH
+    path = host.get_fact(Path)
+    # Fetch the pipx environment variables
+    pipx_env = host.get_fact(PipxEnvironment)
+
+    # If the pipx bin dir is already in the user's PATH, we're done
+    if "PIPX_BIN_DIR" in pipx_env and pipx_env["PIPX_BIN_DIR"] in path.split(":"):
+        host.noop("pipx bin dir is already in the PATH")
+    else:
+        yield "pipx ensurepath"

pyinfra/operations/pkg.py

@@ -0,0 +1,71 @@
+"""
+Manage BSD packages and repositories. Note that BSD package names are case-sensitive.
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.files import File
+from pyinfra.facts.pkg import PkgPackages
+from pyinfra.facts.server import Arch, Os, OsVersion, Which
+
+from .util.packaging import ensure_packages
+
+
+@operation()
+def packages(packages: str | list[str] | None = None, present=True, pkg_path: str | None = None):
+    """
+    Install/remove/update pkg packages. This will use ``pkg ...`` where available
+    (FreeBSD) and the ``pkg_*`` variants elsewhere.
+
+    + packages: list of packages to ensure
+    + present: whether the packages should be installed
+    + pkg_path: the PKG_PATH environment variable to set
+
+    pkg_path:
+        By default this is autogenerated as follows (tested/working for OpenBSD):
+        ``http://ftp.<OS>.org/pub/<OS>/<VERSION>/packages/<ARCH>/``. Note that OpenBSD's
+        official mirrors only hold the latest two versions packages.
+
+        NetBSD/FreeBSD helpfully use their own directory structures, so the default won't
+        work.
+
+    **Example:**
+
+    .. code:: python
+
+        from pyinfra.operations import pkg
+        pkg.packages(
+            name="Install Vim and Vim Addon Manager",
+            packages=["vim-addon-manager", "vim"],
+        )
+
+    """
+
+    if present is True:
+        if not pkg_path and not host.get_fact(File, path="/etc/installurl"):
+            host_os = host.get_fact(Os) or ""
+            pkg_path = "http://ftp.{http}.org/pub/{os}/{version}/packages/{arch}/".format(
+                http=host_os.lower(),
+                os=host_os,
+                version=host.get_fact(OsVersion),
+                arch=host.get_fact(Arch),
+            )
+
+    # FreeBSD used "pkg ..." and OpenBSD uses "pkg_[add|delete]"
+    is_pkg = host.get_fact(Which, command="pkg")
+    install_command = "pkg install -y" if is_pkg else "pkg_add"
+    uninstall_command = "pkg delete -y" if is_pkg else "pkg_delete"
+
+    if pkg_path:
+        install_command = "PKG_PATH={0} {1}".format(pkg_path, install_command)
+
+    yield from ensure_packages(
+        host,
+        packages,
+        host.get_fact(PkgPackages),
+        present,
+        install_command=install_command,
+        uninstall_command=uninstall_command,
+    )

pyinfra/operations/pkgin.py

@@ -0,0 +1,92 @@
+"""
+Manage pkgin packages.
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.pkgin import PkginPackages
+
+from .util.packaging import ensure_packages
+
+
+@operation(is_idempotent=False)
+def upgrade():
+    """
+    Upgrades all pkgin packages.
+    """
+
+    yield "pkgin -y upgrade"
+
+
+_upgrade = upgrade._inner  # noqa: E305
+
+
+@operation(is_idempotent=False)
+def update():
+    """
+    Updates pkgin repositories.
+    """
+
+    yield "pkgin -y 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 pkgin 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 ``pkgin update`` before installing packages
+    + upgrade: run ``pkgin upgrade`` before installing packages
+
+    **Examples:**
+
+    .. code:: python
+
+        from pyinfra.operations import pkgin
+        # Update package list and install packages
+        pkgin.packages(
+            name="Install tmux and Vim",
+            packages=["tmux", "vim"],
+            update=True,
+        )
+
+        # Install the latest versions of packages (always check)
+        pkgin.packages(
+            name="Install latest Vim",
+            packages=["vim"],
+            latest=True,
+        )
+    """
+
+    if update:
+        yield from _update()
+
+    if upgrade:
+        yield from _upgrade()
+
+    # TODO support glob for specific versions (it isn't as simple
+    # as apt-s, as pkgin supports something like 'mysql-server>=5.6<5.7')
+    yield from ensure_packages(
+        host,
+        packages,
+        host.get_fact(PkginPackages),
+        present,
+        install_command="pkgin -y install",
+        uninstall_command="pkgin -y remove",
+        upgrade_command="pkgin -y upgrade",
+        latest=latest,
+    )