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

pyinfra/operations/util/docker.py

@@ -0,0 +1,251 @@
+import dataclasses
+from typing import Any, Dict, List
+
+from pyinfra.api import OperationError
+
+
+@dataclasses.dataclass
+class ContainerSpec:
+    image: str = ""
+    ports: List[str] = dataclasses.field(default_factory=list)
+    networks: List[str] = dataclasses.field(default_factory=list)
+    volumes: List[str] = dataclasses.field(default_factory=list)
+    env_vars: List[str] = dataclasses.field(default_factory=list)
+    pull_always: bool = False
+
+    def container_create_args(self):
+        args = []
+        for network in self.networks:
+            args.append("--network {0}".format(network))
+
+        for port in self.ports:
+            args.append("-p {0}".format(port))
+
+        for volume in self.volumes:
+            args.append("-v {0}".format(volume))
+
+        for env_var in self.env_vars:
+            args.append("-e {0}".format(env_var))
+
+        if self.pull_always:
+            args.append("--pull always")
+
+        args.append(self.image)
+
+        return args
+
+    def diff_from_inspect(self, inspect_dict: Dict[str, Any]) -> List[str]:
+        # TODO(@minor-fixes): Diff output of "docker inspect" against this spec
+        # to determine if the container needs to be recreated. Currently, this
+        # function will never recreate when attributes change, which is
+        # consistent with prior behavior.
+        del inspect_dict
+        return []
+
+
+def _create_container(**kwargs):
+    if "spec" not in kwargs:
+        raise OperationError("missing 1 required argument: 'spec'")
+
+    spec = kwargs["spec"]
+
+    if not spec.image:
+        raise OperationError("Docker image not specified")
+
+    command = [
+        "docker container create --name {0}".format(kwargs["container"])
+    ] + spec.container_create_args()
+
+    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 = []
+    aux_addresses = kwargs["aux_addresses"] if kwargs["aux_addresses"] else {}
+    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 host, address in aux_addresses.items():
+        command.append("--aux-address '{0}={1}'".format(host, address))
+
+    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 _install_plugin(**kwargs):
+    command = ["docker plugin install {0} --grant-all-permissions".format(kwargs["plugin"])]
+
+    plugin_options = kwargs["plugin_options"] if kwargs["plugin_options"] else {}
+
+    if kwargs["alias"]:
+        command.append("--alias {0}".format(kwargs["alias"]))
+
+    if not kwargs["enabled"]:
+        command.append("--disable")
+
+    for option, value in plugin_options.items():
+        command.append("{0}={1}".format(option, value))
+
+    return " ".join(command)
+
+
+def _remove_plugin(**kwargs):
+    return "docker plugin rm -f {0}".format(kwargs["plugin"])
+
+
+def _enable_plugin(**kwargs):
+    return "docker plugin enable {0}".format(kwargs["plugin"])
+
+
+def _disable_plugin(**kwargs):
+    return "docker plugin disable {0}".format(kwargs["plugin"])
+
+
+def _set_plugin_options(**kwargs):
+    command = ["docker plugin set {0}".format(kwargs["plugin"])]
+    existent_options = kwargs.get("existing_options", {})
+    required_options = kwargs.get("required_options", {})
+    options_to_set = existent_options | required_options
+    for option, value in options_to_set.items():
+        command.append("{0}={1}".format(option, value))
+    return " ".join(command)
+
+
+def handle_docker(resource: str, command: str, **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,
+    }
+
+    plugin_commands = {
+        "install": _install_plugin,
+        "remove": _remove_plugin,
+        "enable": _enable_plugin,
+        "disable": _disable_plugin,
+        "set": _set_plugin_options,
+    }
+
+    docker_commands = {
+        "container": container_commands,
+        "image": image_commands,
+        "volume": volume_commands,
+        "network": network_commands,
+        "system": system_commands,
+        "plugin": plugin_commands,
+    }
+
+    return docker_commands[resource][command](**kwargs)

pyinfra/operations/util/files.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import difflib
+import re
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Callable, Generator
+
+import click
+
+from pyinfra.api import QuoteString, StringCommand
+
+
+class MetadataTimeField(Enum):
+    ATIME = "atime"
+    MTIME = "mtime"
+
+
+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: str | int | None) -> int | str | None:
+    # Already an int (/None)?
+    if isinstance(mode, int) or mode is None:
+        return mode
+
+    try:
+        # Try making an int ('700' -> 700)
+        return int(mode)
+
+    except (TypeError, ValueError):
+        pass
+
+    # Return as-is (ie +x which we don't need to normalise, it always gets run)
+    return mode
+
+
+def get_timestamp() -> str:
+    return datetime.now().strftime("%y%m%d%H%M")
+
+
+_sed_ignore_case = re.compile("[iI]")
+
+
+def _sed_delete_builder(line: str, replace: str, flags: str, interpolate_variables: bool) -> str:
+    return (
+        '"/{0}/{1}d"'
+        if interpolate_variables
+        # fmt: skip
+        else "'/{0}/{1}d'"
+    ).format(line, "I" if _sed_ignore_case.search(flags) else "")
+
+
+def sed_delete(
+    filename: str,
+    line: str,
+    replace: str,
+    flags: list[str] | None = None,
+    backup=False,
+    interpolate_variables=False,
+) -> StringCommand:
+    return _sed_command(**locals(), sed_script_builder=_sed_delete_builder)
+
+
+def _sed_replace_builder(line: str, replace: str, flags: str, interpolate_variables: bool) -> str:
+    return (
+        '"s/{0}/{1}/{2}"'
+        if interpolate_variables
+        # fmt: skip
+        else "'s/{0}/{1}/{2}'"
+    ).format(line, replace, flags)
+
+
+def sed_replace(
+    filename: str,
+    line: str,
+    replace: str,
+    flags: list[str] | None = None,
+    backup=False,
+    interpolate_variables=False,
+) -> StringCommand:
+    return _sed_command(**locals(), sed_script_builder=_sed_replace_builder)
+
+
+def _sed_command(
+    filename: str,
+    line: str,
+    replace: str,
+    flags: list[str] | None = None,
+    backup=False,
+    interpolate_variables=False,
+    # Python requires a default value here, so use _sed_replace_builder for
+    # backwards compatibility.
+    sed_script_builder: Callable[[str, str, str, bool], str] = _sed_replace_builder,
+) -> StringCommand:
+    flags_str = "".join(flags) if flags else ""
+
+    line = line.replace("/", r"\/")
+    replace = str(replace)
+    replace = replace.replace("/", r"\/")
+    replace = replace.replace("&", r"\&")
+    backup_extension = get_timestamp()
+
+    if interpolate_variables:
+        line = line.replace('"', '\\"')
+        replace = replace.replace('"', '\\"')
+    else:
+        # Single quotes cannot contain other single quotes, even when escaped , so turn
+        # each ' into '"'"' (end string, double quote the single quote, (re)start string)
+        line = line.replace("'", "'\"'\"'")
+        replace = replace.replace("'", "'\"'\"'")
+
+    sed_script = sed_script_builder(line, replace, flags_str, interpolate_variables)
+
+    sed_command = StringCommand(
+        "sed",
+        "-i.{0}".format(backup_extension),
+        sed_script,
+        QuoteString(filename),
+    )
+
+    if not backup:  # if we're not backing up, remove the file *if* sed succeeds
+        backup_filename = "{0}.{1}".format(filename, backup_extension)
+        sed_command = StringCommand(sed_command, "&&", "rm", "-f", QuoteString(backup_filename))
+
+    return sed_command
+
+
+def chmod(target: str, mode: str | int, recursive=False) -> StringCommand:
+    args = ["chmod"]
+    if recursive:
+        args.append("-R")
+
+    args.append("{0}".format(mode))
+
+    return StringCommand(" ".join(args), QuoteString(target))
+
+
+def chown(
+    target: str,
+    user: str | None = None,
+    group: str | None = None,
+    recursive=False,
+    dereference=True,
+) -> StringCommand:
+    command = "chown"
+    user_group = None
+
+    if user and group:
+        user_group = "{0}:{1}".format(user, group)
+
+    elif user:
+        user_group = user
+
+    elif group:
+        command = "chgrp"
+        user_group = group
+
+    args = [command]
+    if recursive:
+        args.append("-R")
+
+    if not dereference:
+        args.append("-h")
+
+    return StringCommand(" ".join(args), user_group, QuoteString(target))
+
+
+# like the touch command, but only supports setting one field at a time, and expects any
+#   reference times to have been read from the reference file metadata and turned into
+#   aware datetimes
+def touch(
+    target: str,
+    timefield: MetadataTimeField,
+    timesrc: datetime,
+    dereference=True,
+) -> StringCommand:
+    args = ["touch"]
+
+    if timefield is MetadataTimeField.ATIME:
+        args.append("-a")
+    else:
+        args.append("-m")
+
+    if not dereference:
+        args.append("-h")
+
+    # don't reinvent the wheel; use isoformat()
+    timestr = timesrc.astimezone(timezone.utc).isoformat()
+    # but replace the ISO format TZ offset with "Z" for BSD
+    timestr = timestr.replace("+00:00", "Z")
+    args.extend(["-d", timestr])
+
+    return StringCommand(" ".join(args), QuoteString(target))
+
+
+def adjust_regex(line: str, escape_regex_characters: bool) -> str:
+    """
+    Ensure the regex starts with '^' and ends with '$' and escape regex characters if requested
+    """
+    match_line = line
+
+    if escape_regex_characters:
+        match_line = re.sub(r"([\.\\\+\*\?\[\^\]\$\(\)\{\}\-])", r"\\\1", match_line)
+
+    # Ensure we're matching a whole line, note: match may be a partial line so we
+    # put any matches on either side.
+    if not match_line.startswith("^"):
+        match_line = "^.*{0}".format(match_line)
+    if not match_line.endswith("$"):
+        match_line = "{0}.*$".format(match_line)
+
+    return match_line
+
+
+def generate_color_diff(
+    current_lines: list[str], desired_lines: list[str]
+) -> Generator[str, None, None]:
+    def _format_range_unified(start: int, stop: int) -> str:
+        beginning = start + 1  # lines start numbering with one
+        length = stop - start
+        if length == 1:
+            return "{}".format(beginning)
+        if not length:
+            beginning -= 1  # empty ranges begin at line just before the range
+        return "{},{}".format(beginning, length)
+
+    for group in difflib.SequenceMatcher(None, current_lines, desired_lines).get_grouped_opcodes(2):
+        first, last = group[0], group[-1]
+        file1_range = _format_range_unified(first[1], last[2])
+        file2_range = _format_range_unified(first[3], last[4])
+        yield "@@ -{} +{} @@".format(file1_range, file2_range)
+
+        for tag, i1, i2, j1, j2 in group:
+            if tag == "equal":
+                for line in current_lines[i1:i2]:
+                    yield "  " + line.rstrip()
+                continue
+            if tag in {"replace", "delete"}:
+                for line in current_lines[i1:i2]:
+                    yield click.style("- " + line.rstrip(), "red")
+            if tag in {"replace", "insert"}:
+                for line in desired_lines[j1:j2]:
+                    yield click.style("+ " + line.rstrip(), "green")