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

pyinfra/operations/bsdinit.py

@@ -0,0 +1,59 @@
+"""
+Manage BSD init services (``/etc/rc.d``, ``/usr/local/etc/rc.d``).
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.bsdinit import RcdStatus
+from pyinfra.facts.server import Os
+
+from . import files
+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,
+):
+    """
+    Manage the state of BSD init 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: ``/etc/rc.d/<service> <command>``
+    + enabled: whether this service should be enabled/disabled on boot
+    """
+
+    status_argument = "status"
+    if host.get_fact(Os) == "OpenBSD":
+        status_argument = "check"
+
+    yield from handle_service_control(
+        host,
+        service,
+        host.get_fact(RcdStatus),
+        "test -e /etc/rc.d/{0} && /etc/rc.d/{0} {1} || /usr/local/etc/rc.d/{0} {1}",
+        running,
+        restarted,
+        reloaded,
+        command,
+        status_argument=status_argument,
+    )
+
+    # BSD init is simple, just add/remove <service>_enabled="YES"
+    if isinstance(enabled, bool):
+        yield from files.line._inner(
+            path="/etc/rc.conf.local",
+            line="^{0}_enable=".format(service),
+            replace='{0}_enable="YES"'.format(service),
+            present=enabled,
+        )

pyinfra/operations/cargo.py

@@ -0,0 +1,45 @@
+"""
+Manage cargo (aka Rust) packages.
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.cargo import CargoPackages
+
+from .util.packaging import ensure_packages
+
+
+@operation()
+def packages(packages: str | list[str] | None = None, present=True, latest=False):
+    """
+    Install/remove/update cargo packages.
+
+    + packages: list of packages to ensure
+    + present: whether the packages should be present
+    + latest: whether to upgrade packages without a specified version
+
+    Versions:
+        Package versions can be pinned like cargo: ``<pkg>@<version>``.
+    """
+
+    current_packages = host.get_fact(CargoPackages)
+
+    install_command = "cargo install"
+
+    uninstall_command = "cargo uninstall"
+
+    upgrade_command = "cargo install"
+
+    yield from ensure_packages(
+        host,
+        packages,
+        current_packages,
+        present,
+        install_command=install_command,
+        uninstall_command=uninstall_command,
+        upgrade_command=upgrade_command,
+        version_join="@",
+        latest=latest,
+    )

pyinfra/operations/choco.py

@@ -0,0 +1,61 @@
+"""
+Manage ``choco`` (Chocolatey) packages (https://chocolatey.org).
+"""
+
+from __future__ import annotations
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.choco import ChocoPackages
+
+from .util.packaging import ensure_packages
+
+
+@operation()
+def packages(packages: str | list[str] | None = None, present=True, latest=False):
+    """
+    Add/remove/update ``choco`` packages.
+
+    + packages: list of packages to ensure
+    + present: whether the packages should be installed
+    + latest: whether to upgrade packages without a specified version
+
+    Versions:
+        Package versions can be pinned like gem: ``<pkg>:<version>``.
+
+    **Example:**
+
+    .. code:: python
+
+        # Note: Assumes that 'choco' is installed and
+        #       user has Administrator permission.
+        choco.packages(
+            name="Install Notepad++",
+            packages=["notepadplusplus"],
+        )
+    """
+
+    yield from ensure_packages(
+        host,
+        packages,
+        host.get_fact(ChocoPackages),
+        present,
+        install_command="choco install -y",
+        uninstall_command="choco uninstall -y -x",
+        upgrade_command="choco update -y",
+        version_join=":",
+        latest=latest,
+    )
+
+
+@operation(is_idempotent=False)
+def install():
+    """
+    Install ``choco`` (Chocolatey).
+    """
+
+    yield (
+        "Set-ExecutionPolicy Bypass -Scope Process -Force ;"
+        "iex ((New-Object System.Net.WebClient).DownloadString"
+        '("https://chocolatey.org/install.ps1"))'
+    )  # noqa

pyinfra/operations/crontab.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+import shlex
+
+from pyinfra import logger
+from pyinfra.api.command import StringCommand
+from pyinfra.api.operation import operation
+from pyinfra.api.util import try_int
+from pyinfra.context import host
+from pyinfra.facts.crontab import Crontab, CrontabFile
+from pyinfra.operations.util.files import sed_delete, sed_replace
+
+
+@operation()
+def crontab(
+    command: str,
+    present=True,
+    user: str | None = None,
+    cron_name: str | None = None,
+    minute="*",
+    hour="*",
+    month="*",
+    day_of_week="*",
+    day_of_month="*",
+    special_time: str | None = None,
+    interpolate_variables=False,
+):
+    """
+    Add/remove/update crontab entries.
+
+    + command: the command for the cron
+    + present: whether this cron command should exist
+    + user: the user whose crontab to manage
+    + cron_name: name the cronjob so future changes to the command will overwrite
+    + modify_cron_name: modify the cron name
+    + minute: which minutes to execute the cron
+    + hour: which hours to execute the cron
+    + month: which months to execute the cron
+    + day_of_week: which day of the week to execute the cron
+    + day_of_month: which day of the month to execute the cron
+    + special_time: cron "nickname" time (@reboot, @daily, etc), overrides others
+    + interpolate_variables: whether to interpolate variables in ``command``
+
+    Cron commands:
+        Unless ``name`` is specified the command is used to identify crontab entries.
+        This means commands must be unique within a given users crontab. If you require
+        multiple identical commands, provide a different name argument for each.
+
+    Special times:
+        When provided, ``special_time`` will be used instead of any values passed in
+        for ``minute``/``hour``/``month``/``day_of_week``/``day_of_month``.
+
+    **Example:**
+
+    .. code:: python
+
+        # simple example for a crontab
+        crontab.crontab(
+            name="Backup /etc weekly",
+            command="/bin/tar cf /tmp/etc_bup.tar /etc",
+            name="backup_etc",
+            day_of_week=0,
+            hour=1,
+            minute=0,
+        )
+    """
+
+    def comma_sep(value):
+        if isinstance(value, (list, tuple)):
+            return ",".join("{0}".format(v) for v in value)
+        return value
+
+    minute = comma_sep(minute)
+    hour = comma_sep(hour)
+    month = comma_sep(month)
+    day_of_week = comma_sep(day_of_week)
+    day_of_month = comma_sep(day_of_month)
+
+    ctb0: CrontabFile | dict = host.get_fact(Crontab, user=user)
+    # facts from test are in dict
+    if isinstance(ctb0, dict):
+        ctb = CrontabFile(ctb0)
+    else:
+        ctb = ctb0
+    name_comment = "# pyinfra-name={0}".format(cron_name)
+
+    existing_crontab = ctb.get_command(command=command, name=cron_name)
+    existing_crontab_command = existing_crontab["command"] if existing_crontab else command
+    existing_crontab_match = existing_crontab["command"] if existing_crontab else command
+
+    exists = existing_crontab is not None
+    exists_name = existing_crontab is not None and name_comment in existing_crontab.get(
+        "comments", ""
+    )
+
+    edit_commands: list[str | StringCommand] = []
+    temp_filename = host.get_temp_filename()
+
+    if special_time:
+        new_crontab_line = "{0} {1}".format(special_time, command)
+    else:
+        new_crontab_line = "{minute} {hour} {day_of_month} {month} {day_of_week} {command}".format(
+            minute=minute,
+            hour=hour,
+            day_of_month=day_of_month,
+            month=month,
+            day_of_week=day_of_week,
+            command=command,
+        )
+
+    existing_crontab_match = ".*{0}.*".format(existing_crontab_match)
+
+    # Don't want the cron and it does exist? Remove the line
+    if not present and exists:
+        edit_commands.append(
+            sed_delete(
+                temp_filename,
+                existing_crontab_match,
+                "",
+                interpolate_variables=interpolate_variables,
+            ),
+        )
+
+    # Want the cron but it doesn't exist? Append the line
+    elif present and not exists:
+        logger.debug(f"present: {present}, exists: {exists}")
+        if ctb:  # append a blank line if cron entries already exist
+            edit_commands.append("echo '' >> {0}".format(temp_filename))
+        if cron_name:
+            edit_commands.append(
+                "echo {0} >> {1}".format(
+                    shlex.quote(name_comment),
+                    temp_filename,
+                ),
+            )
+
+        edit_commands.append(
+            "echo {0} >> {1}".format(
+                shlex.quote(new_crontab_line),
+                temp_filename,
+            ),
+        )
+
+    # We have the cron and it exists, do it's details? If not, replace the line
+    elif present and exists:
+        assert existing_crontab is not None
+        if any(
+            (
+                exists_name != (cron_name is not None),
+                special_time != existing_crontab.get("special_time"),
+                try_int(minute) != existing_crontab.get("minute"),
+                try_int(hour) != existing_crontab.get("hour"),
+                try_int(month) != existing_crontab.get("month"),
+                try_int(day_of_week) != existing_crontab.get("day_of_week"),
+                try_int(day_of_month) != existing_crontab.get("day_of_month"),
+                existing_crontab_command != command,
+            ),
+        ):
+            if not exists_name and cron_name:
+                new_crontab_line = f"{name_comment}\\n{new_crontab_line}"
+            edit_commands.append(
+                sed_replace(
+                    temp_filename,
+                    existing_crontab_match,
+                    new_crontab_line,
+                    interpolate_variables=interpolate_variables,
+                ),
+            )
+
+    if edit_commands:
+        crontab_args = []
+        if user:
+            crontab_args.append("-u {0}".format(user))
+
+        # List the crontab into a temporary file if it exists
+        if ctb:
+            yield "crontab -l {0} > {1}".format(" ".join(crontab_args), temp_filename)
+
+        # Now yield any edits
+        for edit_command in edit_commands:
+            yield edit_command
+
+        # Finally, use the tempfile to write a new crontab
+        yield "crontab {0} {1}".format(" ".join(crontab_args), temp_filename)
+    else:
+        host.noop(
+            "crontab {0} {1}".format(
+                command,
+                "exists" if present else "does not exist",
+            ),
+        )

pyinfra/operations/dnf.py

@@ -0,0 +1,210 @@
+"""
+Manage dnf packages and repositories. Note that dnf package names are case-sensitive.
+"""
+
+from __future__ import annotations
+
+from pyinfra import host, state
+from pyinfra.api import operation
+from pyinfra.facts.rpm import RpmPackageProvides, RpmPackages
+
+from .util.packaging import ensure_packages, ensure_rpm, ensure_yum_repo
+
+
+@operation(is_idempotent=False)
+def key(src: str):
+    """
+    Add dnf gpg keys with ``rpm``.
+
+    + key: filename or URL
+
+    Note:
+        always returns one command, not idempotent
+
+    **Example:**
+
+    .. code:: python
+
+        linux_id = host.get_fact(LinuxDistribution)["release_meta"].get("ID")
+        dnf.key(
+            name="Add the Docker CentOS gpg key",
+            src=f"https://download.docker.com/linux/{linux_id}/gpg",
+        )
+
+    """
+
+    yield "rpm --import {0}".format(src)
+
+
+@operation()
+def repo(
+    src: str,
+    present=True,
+    baseurl: str | None = None,
+    description: str | None = None,
+    enabled=True,
+    gpgcheck=True,
+    gpgkey: str | None = None,
+):
+    # NOTE: if updating this docstring also update `yum.repo`
+    """
+    Add/remove/update dnf repositories.
+
+    + src: URL or name for the ``.repo``   file
+    + present: whether the ``.repo`` file should be present
+    + baseurl: the baseurl of the repo (if ``name`` is not a URL)
+    + description: optional verbose description
+    + enabled: whether this repo is enabled
+    + gpgcheck: whether set ``gpgcheck=1``
+    + gpgkey: the URL to the gpg key for this repo
+
+    ``Baseurl``/``description``/``gpgcheck``/``gpgkey``:
+        These are only valid when ``name`` is a filename (ie not a URL). This is
+        for manual construction of repository files. Use a URL to download and
+        install remote repository files.
+
+    **Examples:**
+
+    .. code:: python
+
+        # Download a repository file
+        dnf.rpm(
+            name="Install Docker-CE repo via URL",
+            src="https://download.docker.com/linux/centos/docker-ce.repo",
+        )
+
+        # Create the repository file from baseurl/etc
+        dnf.repo(
+            name="Add the Docker CentOS repo",
+            src="DockerCE",
+            baseurl="https://download.docker.com/linux/centos/7/$basearch/stable",
+        )
+    """
+
+    yield from ensure_yum_repo(
+        host,
+        src,
+        baseurl,
+        present,
+        description,
+        enabled,
+        gpgcheck,
+        gpgkey,
+    )
+
+
+@operation()
+def rpm(src: str, present=True):
+    # NOTE: if updating this docstring also update `yum.rpm`
+    """
+    Add/remove ``.rpm`` file packages.
+
+    + src: filename or URL of the ``.rpm`` package
+    + present: whether ore not the package should exist on the system
+
+    URL sources with ``present=False``:
+        If the ``.rpm`` file isn't downloaded, pyinfra can't remove any existing
+        package as the file won't exist until mid-deploy.
+
+    **Example:**
+
+    .. code:: python
+
+        major_centos_version = host.get_fact(LinuxDistribution)["major"]
+        dnf.rpm(
+           name="Install EPEL rpm to enable EPEL repo",
+           src=f"https://dl.fedoraproject.org/pub/epel/epel-release-latest-{major_centos_version}.noarch.rpm",
+        )
+    """
+
+    yield from ensure_rpm(state, host, src, present, "dnf")
+
+
+@operation(is_idempotent=False)
+def update():
+    """
+    Updates all dnf packages.
+    """
+
+    yield "dnf update -y"
+
+
+_update = update._inner  # noqa: E305 (for use below where update is a kwarg)
+
+
+@operation()
+def packages(
+    packages: str | list[str] | None = None,
+    present=True,
+    latest=False,
+    update=False,
+    clean=False,
+    nobest=False,
+    extra_install_args: str | None = None,
+    extra_uninstall_args: str | None = None,
+):
+    """
+    Install/remove/update dnf packages & updates.
+
+    + packages: packages to ensure
+    + present: whether the packages should be installed
+    + latest: whether to upgrade packages without a specified version
+    + update: run ``dnf update`` before installing packages
+    + clean: run ``dnf clean`` before installing packages
+    + nobest: add the no best option to install
+    + extra_install_args: additional arguments to the dnf install command
+    + extra_uninstall_args: additional arguments to the dnf uninstall command
+
+    Versions:
+        Package versions can be pinned as follows: ``<pkg>=<version>``
+
+    **Examples:**
+
+    .. code:: python
+
+        # Update package list and install packages
+        dnf.packages(
+            name='Install Vim and Vim enhanced',
+            packages=["vim-enhanced", "vim"],
+            update=True,
+        )
+
+        # Install the latest versions of packages (always check)
+        dnf.packages(
+            name="Install latest Vim",
+            packages=["vim"],
+            latest=True,
+        )
+    """
+
+    if clean:
+        yield "dnf clean all"
+
+    if update:
+        yield from _update()
+
+    install_command = ["dnf", "install", "-y"]
+
+    if nobest:
+        install_command.append("--nobest")
+
+    if extra_install_args:
+        install_command.append(extra_install_args)
+
+    uninstall_command = ["dnf", "remove", "-y"]
+
+    if extra_uninstall_args:
+        uninstall_command.append(extra_uninstall_args)
+
+    yield from ensure_packages(
+        host,
+        packages,
+        host.get_fact(RpmPackages),
+        present,
+        install_command=" ".join(install_command),
+        uninstall_command=" ".join(uninstall_command),
+        upgrade_command="dnf update -y",
+        version_join="=",
+        latest=latest,
+        expand_package_fact=lambda package: host.get_fact(RpmPackageProvides, package=package),
+    )