pyinfra 3.0b1__py2.py3-none-any.whl → 3.0b3__py2.py3-none-any.whl

pyinfra/operations/systemd.py

@@ -2,6 +2,10 @@
 Manage systemd services.
 """
 
+from __future__ import annotations
+
+import shlex
+
 from pyinfra import host
 from pyinfra.api import StringCommand, operation
 from pyinfra.facts.systemd import SystemdEnabled, SystemdStatus, _make_systemctl_cmd
@@ -10,7 +14,7 @@ from .util.service import handle_service_control
 
 
 @operation(is_idempotent=False)
-def daemon_reload(user_mode=False, machine=None, user_name=None):
+def daemon_reload(user_mode=False, machine: str | None = None, user_name: str | None = None):
     """
     Reload the systemd daemon to read unit file changes.
 
@@ -33,16 +37,16 @@ _daemon_reload = daemon_reload._inner  # noqa: E305
 
 @operation()
 def service(
-    service,
+    service: str,
     running=True,
     restarted=False,
     reloaded=False,
-    command=None,
-    enabled=None,
+    command: str | None = None,
+    enabled: bool | None = None,
     daemon_reload=False,
     user_mode=False,
-    machine=None,
-    user_name=None,
+    machine: str | None = None,
+    user_name: str | None = None,
 ):
     """
     Manage the state of systemd managed units.
@@ -138,8 +142,8 @@ def service(
 
         # Isn't enabled and want enabled?
         if not is_enabled and enabled is True:
-            yield "{0} enable {1}".format(systemctl_cmd, service)
+            yield "{0} enable {1}".format(systemctl_cmd, shlex.quote(service))
 
         # Is enabled and want disabled?
         elif is_enabled and enabled is False:
-            yield "{0} disable {1}".format(systemctl_cmd, service)
+            yield "{0} disable {1}".format(systemctl_cmd, shlex.quote(service))

pyinfra/operations/sysvinit.py

@@ -2,6 +2,8 @@
 Manage sysvinit services (``/etc/init.d``).
 """
 
+from __future__ import annotations
+
 from pyinfra import host
 from pyinfra.api import operation
 from pyinfra.facts.files import FindLinks
@@ -14,12 +16,12 @@ from .util.service import handle_service_control
 
 @operation()
 def service(
-    service,
+    service: str,
     running=True,
     restarted=False,
     reloaded=False,
-    enabled=None,
-    command=None,
+    enabled: bool | None = None,
+    command: str | None = None,
 ):
     """
     Manage the state of SysV Init (/etc/init.d) services.
@@ -95,7 +97,7 @@ def service(
 
 @operation()
 def enable(
-    service,
+    service: str,
     start_priority=20,
     stop_priority=80,
     start_levels=(2, 3, 4, 5),

pyinfra/operations/upstart.py

@@ -2,6 +2,8 @@
 Manage upstart services.
 """
 
+from __future__ import annotations
+
 from io import StringIO
 
 from pyinfra import host
@@ -14,12 +16,12 @@ from .util.service import handle_service_control
 
 @operation()
 def service(
-    service,
+    service: str,
     running=True,
     restarted=False,
     reloaded=False,
-    command=None,
-    enabled=None,
+    command: str | None = None,
+    enabled: bool | None = None,
 ):
     """
     Manage the state of upstart managed services.

pyinfra/operations/util/docker.py

@@ -0,0 +1,177 @@
+from pyinfra.api import OperationError
+
+
+def _create_container(**kwargs):
+    command = []
+
+    networks = kwargs["networks"] if kwargs["networks"] else []
+    ports = kwargs["ports"] if kwargs["ports"] else []
+    volumes = kwargs["volumes"] if kwargs["volumes"] else []
+    env_vars = kwargs["env_vars"] if kwargs["env_vars"] else []
+
+    if kwargs["image"] == "":
+        raise OperationError("missing 1 required argument: 'image'")
+
+    command.append("docker container create --name {0}".format(kwargs["container"]))
+
+    for network in networks:
+        command.append("--network {0}".format(network))
+
+    for port in ports:
+        command.append("-p {0}".format(port))
+
+    for volume in volumes:
+        command.append("-v {0}".format(volume))
+
+    for env_var in env_vars:
+        command.append("-e {0}".format(env_var))
+
+    if kwargs["pull_always"]:
+        command.append("--pull always")
+
+    command.append(kwargs["image"])
+
+    if kwargs["start"]:
+        command.append("; {0}".format(_start_container(container=kwargs["container"])))
+
+    return " ".join(command)
+
+
+def _remove_container(**kwargs):
+    return "docker container rm -f {0}".format(kwargs["container"])
+
+
+def _start_container(**kwargs):
+    return "docker container start {0}".format(kwargs["container"])
+
+
+def _stop_container(**kwargs):
+    return "docker container stop {0}".format(kwargs["container"])
+
+
+def _pull_image(**kwargs):
+    return "docker image pull {0}".format(kwargs["image"])
+
+
+def _remove_image(**kwargs):
+    return "docker image rm {0}".format(kwargs["image"])
+
+
+def _prune_command(**kwargs):
+    command = ["docker system prune"]
+
+    if kwargs["all"]:
+        command.append("-a")
+
+    if kwargs["filter"] != "":
+        command.append("--filter={0}".format(kwargs["filter"]))
+
+    if kwargs["volumes"]:
+        command.append("--volumes")
+
+    command.append("-f")
+
+    return " ".join(command)
+
+
+def _create_volume(**kwargs):
+    command = []
+    labels = kwargs["labels"] if kwargs["labels"] else []
+
+    command.append("docker volume create {0}".format(kwargs["volume"]))
+
+    if kwargs["driver"] != "":
+        command.append("-d {0}".format(kwargs["driver"]))
+
+    for label in labels:
+        command.append("--label {0}".format(label))
+
+    return " ".join(command)
+
+
+def _remove_volume(**kwargs):
+    return "docker image rm {0}".format(kwargs["volume"])
+
+
+def _create_network(**kwargs):
+    command = []
+    opts = kwargs["opts"] if kwargs["opts"] else []
+    ipam_opts = kwargs["ipam_opts"] if kwargs["ipam_opts"] else []
+    labels = kwargs["labels"] if kwargs["labels"] else []
+
+    command.append("docker network create {0}".format(kwargs["network"]))
+    if kwargs["driver"] != "":
+        command.append("-d {0}".format(kwargs["driver"]))
+
+    if kwargs["gateway"] != "":
+        command.append("--gateway {0}".format(kwargs["gateway"]))
+
+    if kwargs["ip_range"] != "":
+        command.append("--ip-range {0}".format(kwargs["ip_range"]))
+
+    if kwargs["ipam_driver"] != "":
+        command.append("--ipam-driver {0}".format(kwargs["ipam_driver"]))
+
+    if kwargs["subnet"] != "":
+        command.append("--subnet {0}".format(kwargs["subnet"]))
+
+    if kwargs["scope"] != "":
+        command.append("--scope {0}".format(kwargs["scope"]))
+
+    if kwargs["ingress"]:
+        command.append("--ingress")
+
+    if kwargs["attachable"]:
+        command.append("--attachable")
+
+    for opt in opts:
+        command.append("--opt {0}".format(opt))
+
+    for opt in ipam_opts:
+        command.append("--ipam-opt {0}".format(opt))
+
+    for label in labels:
+        command.append("--label {0}".format(label))
+    return " ".join(command)
+
+
+def _remove_network(**kwargs):
+    return "docker network rm {0}".format(kwargs["network"])
+
+
+def handle_docker(resource, command, **kwargs):
+    container_commands = {
+        "create": _create_container,
+        "remove": _remove_container,
+        "start": _start_container,
+        "stop": _stop_container,
+    }
+
+    image_commands = {
+        "pull": _pull_image,
+        "remove": _remove_image,
+    }
+
+    volume_commands = {
+        "create": _create_volume,
+        "remove": _remove_volume,
+    }
+
+    network_commands = {
+        "create": _create_network,
+        "remove": _remove_network,
+    }
+
+    system_commands = {
+        "prune": _prune_command,
+    }
+
+    docker_commands = {
+        "container": container_commands,
+        "image": image_commands,
+        "volume": volume_commands,
+        "network": network_commands,
+        "system": system_commands,
+    }
+
+    return docker_commands[resource][command](**kwargs)

pyinfra/operations/util/files.py

@@ -1,16 +1,18 @@
+from __future__ import annotations
+
 import re
 from datetime import datetime
 
 from pyinfra.api import QuoteString, StringCommand
 
 
-def unix_path_join(*path_parts):
-    parts = list(path_parts)
-    parts[0:-1] = [part.rstrip("/") for part in parts[0:-1]]
-    return "/".join(parts)
+def unix_path_join(*parts) -> str:
+    part_list = list(parts)
+    part_list[0:-1] = [part.rstrip("/") for part in part_list[0:-1]]
+    return "/".join(part_list)
 
 
-def ensure_mode_int(mode):
+def ensure_mode_int(mode: str | int | None) -> int | str | None:
     # Already an int (/None)?
     if isinstance(mode, int) or mode is None:
         return mode
@@ -26,19 +28,19 @@ def ensure_mode_int(mode):
     return mode
 
 
-def get_timestamp():
+def get_timestamp() -> str:
     return datetime.now().strftime("%y%m%d%H%M")
 
 
 def sed_replace(
-    filename,
-    line,
-    replace,
-    flags=None,
+    filename: str,
+    line: str,
+    replace: str,
+    flags: list[str] | None = None,
     backup=False,
     interpolate_variables=False,
-):
-    flags = "".join(flags) if flags else ""
+) -> StringCommand:
+    flags_str = "".join(flags) if flags else ""
 
     line = line.replace("/", r"\/")
     replace = str(replace)
@@ -57,7 +59,7 @@ def sed_replace(
         replace = replace.replace("'", "'\"'\"'")
         sed_script_formatter = "'s/{0}/{1}/{2}'"
 
-    sed_script = sed_script_formatter.format(line, replace, flags)
+    sed_script = sed_script_formatter.format(line, replace, flags_str)
 
     sed_command = StringCommand(
         "sed",
@@ -73,7 +75,7 @@ def sed_replace(
     return sed_command
 
 
-def chmod(target, mode, recursive=False):
+def chmod(target: str, mode: str | int, recursive=False) -> StringCommand:
     args = ["chmod"]
     if recursive:
         args.append("-R")
@@ -83,7 +85,13 @@ def chmod(target, mode, recursive=False):
     return StringCommand(" ".join(args), QuoteString(target))
 
 
-def chown(target, user, group=None, recursive=False, dereference=True):
+def chown(
+    target: str,
+    user: str | None = None,
+    group: str | None = None,
+    recursive=False,
+    dereference=True,
+) -> StringCommand:
     command = "chown"
     user_group = None
 
@@ -107,7 +115,7 @@ def chown(target, user, group=None, recursive=False, dereference=True):
     return StringCommand(" ".join(args), user_group, QuoteString(target))
 
 
-def adjust_regex(line, escape_regex_characters):
+def adjust_regex(line: str, escape_regex_characters: bool) -> str:
     """
     Ensure the regex starts with '^' and ends with '$' and escape regex characters if requested
     """

pyinfra/operations/util/packaging.py

@@ -1,19 +1,29 @@
+from __future__ import annotations
+
 import shlex
 from collections import defaultdict
 from io import StringIO
+from typing import Callable
 from urllib.parse import urlparse
 
+from pyinfra.api import Host, State
 from pyinfra.facts.files import File
 from pyinfra.facts.rpm import RpmPackage
+from pyinfra.operations import files
 
 
-def _package_name(package):
+def _package_name(package: list[str] | str) -> str:
     if isinstance(package, list):
         return package[0]
     return package
 
 
-def _has_package(package, packages, expand_package_fact=None, match_any=False):
+def _has_package(
+    package: str | list[str],
+    packages: dict[str, set[str]],
+    expand_package_fact: Callable[[str], list[str | list[str]]] | None = None,
+    match_any=False,
+) -> tuple[bool, dict]:
     def in_packages(pkg_name, pkg_versions):
         if not pkg_versions:
             return pkg_name in packages
@@ -21,9 +31,12 @@ def _has_package(package, packages, expand_package_fact=None, match_any=False):
             version in packages[pkg_name] for version in pkg_versions
         )
 
-    packages_to_check = [package]
+    packages_to_check: list[str | list[str]] = [package]
     if expand_package_fact:
-        packages_to_check = expand_package_fact(package) or packages_to_check
+        if isinstance(package, list):
+            packages_to_check = expand_package_fact(package[0]) or packages_to_check
+        else:
+            packages_to_check = expand_package_fact(package) or packages_to_check
 
     package_name_to_versions = defaultdict(set)
     for pkg in packages_to_check:
@@ -43,16 +56,16 @@ def _has_package(package, packages, expand_package_fact=None, match_any=False):
 
 
 def ensure_packages(
-    host,
-    packages,
-    current_packages,
-    present,
-    install_command,
-    uninstall_command,
+    host: Host,
+    packages_to_ensure: str | list[str] | None,
+    current_packages: dict[str, set[str]],
+    present: bool,
+    install_command: str,
+    uninstall_command: str,
     latest=False,
-    upgrade_command=None,
-    version_join=None,
-    expand_package_fact=None,
+    upgrade_command: str | None = None,
+    version_join: str | None = None,
+    expand_package_fact: Callable[[str], list[str | list[str]]] | None = None,
 ):
     """
     Handles this common scenario:
@@ -64,7 +77,7 @@ def ensure_packages(
     + Optionally upgrades packages w/o specified version when present
 
     Args:
-        packages (list): list of packages or package/versions
+        packages_to_ensure (list): list of packages or package/versions
         current_packages (fact): fact returning dict of package names -> version
         present (bool): whether packages should exist or not
         install_command (str): command to prefix to list of packages to install
@@ -73,18 +86,21 @@ def ensure_packages(
         upgrade_command (str): as above for upgrading
         version_join (str): the package manager specific "joiner", ie ``=`` for \
             ``<apt_pkg>=<version>``
+        expand_package_fact: fact returning packages providing a capability \
+            (ie ``yum whatprovides``)
     """
 
-    if packages is None:
+    if packages_to_ensure is None:
         return
+    if isinstance(packages_to_ensure, str):
+        packages_to_ensure = [packages_to_ensure]
 
-    if isinstance(packages, str):
-        packages = [packages]
+    packages: list[str | list[str]] = packages_to_ensure  # type: ignore[assignment]
 
     if version_join:
         packages = [
             package[0] if len(package) == 1 else package
-            for package in [package.rsplit(version_join, 1) for package in packages]
+            for package in [package.rsplit(version_join, 1) for package in packages]  # type: ignore[union-attr] # noqa
         ]
 
     diff_packages = []
@@ -140,7 +156,7 @@ def ensure_packages(
         command = install_command if present else uninstall_command
 
         joined_packages = [
-            version_join.join(package) if isinstance(package, list) else package
+            version_join.join(package) if isinstance(package, list) else package  # type: ignore[union-attr] # noqa
             for package in diff_packages
         ]
 
@@ -156,7 +172,7 @@ def ensure_packages(
         )
 
 
-def ensure_rpm(state, host, files, source, present, package_manager_command):
+def ensure_rpm(state: State, host: Host, source: str, present: bool, package_manager_command: str):
     original_source = source
 
     # If source is a url
@@ -165,18 +181,18 @@ def ensure_rpm(state, host, files, source, present, package_manager_command):
         temp_filename = "{0}.rpm".format(host.get_temp_filename(source))
 
         # Ensure it's downloaded
-        yield from files.download._inner(source, temp_filename)
+        yield from files.download._inner(src=source, dest=temp_filename)
 
         # Override the source with the downloaded file
         source = temp_filename
 
     # Check for file .rpm information
-    info = host.get_fact(RpmPackage, name=source)
+    info = host.get_fact(RpmPackage, package=source)
     exists = False
 
     # We have info!
     if info:
-        current_package = host.get_fact(RpmPackage, name=info["name"])
+        current_package = host.get_fact(RpmPackage, package=info["name"])
         if current_package and current_package["version"] == info["version"]:
             exists = True
 
@@ -204,18 +220,16 @@ def ensure_rpm(state, host, files, source, present, package_manager_command):
 
 
 def ensure_yum_repo(
-    state,
-    host,
-    files,
-    name_or_url,
-    baseurl,
-    present,
-    description,
-    enabled,
-    gpgcheck,
-    gpgkey,
+    host: Host,
+    name_or_url: str,
+    baseurl: str | None,
+    present: bool,
+    description: str | None,
+    enabled: bool,
+    gpgcheck: bool,
+    gpgkey: str | None,
     repo_directory="/etc/yum.repos.d/",
-    type_=None,
+    type_: str | None = None,
 ):
     url = None
     url_parts = urlparse(name_or_url)
@@ -229,15 +243,17 @@ def ensure_yum_repo(
 
     # If we don't want the repo, just remove any existing file
     if not present:
-        yield from files.file._inner(filename, present=False)
+        yield from files.file._inner(path=filename, present=False)
         return
 
     # If we're a URL, download the repo if it doesn't exist
     if url:
         if not host.get_fact(File, path=filename):
-            yield from files.download._inner(url, filename)
+            yield from files.download._inner(src=url, dest=filename)
         return
 
+    assert isinstance(baseurl, str)
+
     # Description defaults to name
     description = description or name_or_url
 
@@ -261,4 +277,4 @@ def ensure_yum_repo(
     repo_file = StringIO(repo)
 
     # Ensure this is the file on the server
-    yield from files.put._inner(repo_file, filename)
+    yield from files.put._inner(src=repo_file, dest=filename)

pyinfra/operations/util/service.py

@@ -1,39 +1,46 @@
+from __future__ import annotations
+
+import shlex
+
+from pyinfra.api import Host
+
+
 def handle_service_control(
-    host,
-    name,
-    statuses,
-    formatter,
-    running,
-    restarted,
-    reloaded,
-    command,
+    host: Host,
+    name: str,
+    statuses: dict[str, bool],
+    formatter: str,
+    running: bool | None = None,
+    restarted: bool | None = None,
+    reloaded: bool | None = None,
+    command: str | None = None,
     status_argument="status",
 ):
-    status = statuses.get(name, None)
+    is_running = statuses.get(name, None)
 
     # Need down but running
     if running is False:
-        if status:
-            yield formatter.format(name, "stop")
+        if is_running:
+            yield formatter.format(shlex.quote(name), "stop")
         else:
             host.noop("service {0} is stopped".format(name))
 
     # Need running but down
     if running is True:
-        if not status:
-            yield formatter.format(name, "start")
+        if not is_running:
+            yield formatter.format(shlex.quote(name), "start")
         else:
             host.noop("service {0} is running".format(name))
 
     # Only restart if the service is already running
-    if restarted and status:
-        yield formatter.format(name, "restart")
+    if restarted and is_running:
+        yield formatter.format(shlex.quote(name), "restart")
 
     # Only reload if the service is already reloaded
-    if reloaded and status:
-        yield formatter.format(name, "reload")
+    if reloaded and is_running:
+        yield formatter.format(shlex.quote(name), "reload")
 
     # Always execute arbitrary commands as these may or may not rely on the service
     # being up or down
     if command:
-        yield formatter.format(name, command)
+        yield formatter.format(shlex.quote(name), command)