pyinfra 3.0b2__py2.py3-none-any.whl → 3.0b4__py2.py3-none-any.whl

pyinfra/connectors/ssh.py

@@ -122,14 +122,18 @@ class SSHConnector(BaseConnector):
     .. code:: python
 
         hosts = (
-            [
-                "my-host-1.net",
-                "my-host-2.net",
-            ],
-            {
-                "ssh_username": "ssh-user",
-            },
+            ["my-host-1.net", "my-host-2.net"],
+            {"ssh_username": "ssh-user"},
         )
+
+    Multiple hosts with different SSH usernames:
+
+    .. code:: python
+
+        hosts = [
+            ("my-host-1.net", {"ssh_username": "ssh-user"}),
+            ("my-host-2.net", {"ssh_username": "other-user"}),
+        ]
     """
 
     handles_execution = True

pyinfra/facts/docker.py

@@ -86,3 +86,19 @@ class DockerNetwork(DockerSingleMixin):
     """
 
     docker_type = "network"
+
+
+class DockerVolumes(DockerFactBase):
+    """
+    Returns ``docker inspect`` output for all Docker volumes.
+    """
+
+    command = "docker volume inspect `docker volume ls -q`"
+
+
+class DockerVolume(DockerSingleMixin):
+    """
+    Returns ``docker inspect`` output for a single Docker container.
+    """
+
+    docker_type = "volume"

pyinfra/facts/runit.py

@@ -0,0 +1,68 @@
+from pyinfra.api import FactBase
+
+
+class RunitStatus(FactBase):
+    """
+    Returns a dict of name -> status for runit services.
+
+    + service: optionally check only for a single service
+    + svdir: alternative ``SVDIR``
+
+    .. code:: python
+
+        {
+            'agetty-tty1': True,     # service is running
+            'dhcpcd': False,         # service is down
+            'wpa_supplicant': None,  # service is managed, but not running or down,
+                                     # possibly in a fail state
+        }
+    """
+
+    requires_command = "sv"
+    default = dict
+
+    def command(self, service=None, svdir="/var/service"):
+        if service is None:
+            return (
+                'export SVDIR="{0}" && '
+                'cd "$SVDIR" && find * -maxdepth 0 -exec sv status {{}} + 2>/dev/null'
+            ).format(svdir)
+        else:
+            return 'SVDIR="{0}" sv status "{1}"'.format(svdir, service)
+
+    def process(self, output):
+        services = {}
+        for line in output:
+            statusstr, service, _ = line.split(sep=": ", maxsplit=2)
+            status = None
+
+            if statusstr == "run":
+                status = True
+            elif statusstr == "down":
+                status = False
+            # another observable state is "fail"
+            # report as ``None`` for now
+
+            services[service] = status
+
+        return services
+
+
+class RunitManaged(FactBase):
+    """
+    Returns a set of all services managed by runit
+
+    + service: optionally check only for a single service
+    + svdir: alternative ``SVDIR``
+    """
+
+    default = set
+
+    def command(self, service=None, svdir="/var/service"):
+        if service is None:
+            return 'cd "{0}" && find -mindepth 1 -maxdepth 1 -type l -printf "%f\n"'.format(svdir)
+        else:
+            return 'cd "{0}" && test -h "{1}" && echo "{1}" || true'.format(svdir, service)
+
+    def process(self, output):
+        return set(output)

pyinfra/operations/docker.py

@@ -0,0 +1,339 @@
+"""
+Manager Docker Containers, Volumes and Networks
+"""
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.docker import DockerContainers, DockerNetworks, DockerVolumes
+
+from .util.docker import handle_docker
+
+
+@operation()
+def container(
+    container,
+    image="",
+    ports=None,
+    networks=None,
+    volumes=None,
+    env_vars=None,
+    pull_always=False,
+    present=True,
+    force=False,
+    start=True,
+):
+    """
+    Manage Docker containers
+
+    + container: name to identify the container
+    + image: container image and tag ex: nginx:alpine
+    + networks: network list to attach on container
+    + ports: port list to expose
+    + volumes: volume list to map on container
+    + env_vars: environment varible list to inject on container
+    + pull_always: force image pull
+    + force: remove a contaner with same name and create a new one
+    + present: whether the container should be up and running
+    + start: start or stop the container
+
+    **Examples:**
+
+    .. code:: python
+
+        # Run a container
+        docker.container(
+            name="Deploy Nginx container",
+            container="nginx",
+            image="nginx:alpine",
+            ports=["80:80"],
+            present=True,
+            force=True,
+            networks=["proxy", "services"],
+            volumes=["nginx_data:/usr/share/nginx/html"],
+            pull_always=True,
+        )
+
+        # Stop a container
+        docker.container(
+            name="Stop Nginx container",
+            container="nginx",
+            start=False,
+        )
+
+        # Start a container
+        docker.container(
+            name="Start Nginx container",
+            container="nginx",
+            start=True,
+        )
+    """
+
+    existent_container = [c for c in host.get_fact(DockerContainers) if container in c["Name"]]
+
+    if force:
+        if existent_container:
+            yield handle_docker(
+                resource="container",
+                command="remove",
+                container=container,
+            )
+
+    if present:
+        if not existent_container or force:
+            yield handle_docker(
+                resource="container",
+                command="create",
+                container=container,
+                image=image,
+                ports=ports,
+                networks=networks,
+                volumes=volumes,
+                env_vars=env_vars,
+                pull_always=pull_always,
+                present=present,
+                force=force,
+                start=start,
+            )
+
+    if existent_container and start:
+        if existent_container[0]["State"]["Status"] != "running":
+            yield handle_docker(
+                resource="container",
+                command="start",
+                container=container,
+            )
+
+    if existent_container and not start:
+        if existent_container[0]["State"]["Status"] == "running":
+            yield handle_docker(
+                resource="container",
+                command="stop",
+                container=container,
+            )
+
+    if existent_container and not present:
+        yield handle_docker(
+            resource="container",
+            command="remove",
+            container=container,
+        )
+
+
+@operation(is_idempotent=False)
+def image(image, present=True):
+    """
+    Manage Docker images
+
+    + image: Image and tag ex: nginx:alpine
+    + present: whether the Docker image should be exist
+
+    **Examples:**
+
+    .. code:: python
+
+        # Pull a Docker image
+        docker.image(
+            name="Pull nginx image",
+            image="nginx:alpine",
+            present=True,
+        )
+
+        # Remove a Docker image
+        docker.image(
+            name="Remove nginx image",
+            image:"nginx:image",
+            present=False,
+        )
+    """
+
+    if present:
+        yield handle_docker(
+            resource="image",
+            command="pull",
+            image=image,
+        )
+
+    else:
+        yield handle_docker(
+            resource="image",
+            command="remove",
+            image=image,
+        )
+
+
+@operation()
+def volume(volume, driver="", labels=None, present=True):
+    """
+    Manage Docker volumes
+
+    + volume: Volume name
+    + driver: Docker volume storage driver
+    + labels: Label list to attach in the volume
+    + present: whether the Docker volume should exist
+
+    **Examples:**
+
+    .. code:: python
+
+        # Create a Docker volume
+        docker.volume(
+            name="Create nginx volume",
+            volume="nginx_data",
+            present=True
+        )
+    """
+
+    existent_volume = [v for v in host.get_fact(DockerVolumes) if v["Name"] == volume]
+
+    if present:
+
+        if existent_volume:
+            host.noop("Volume alredy exist!")
+            return
+
+        yield handle_docker(
+            resource="volume",
+            command="create",
+            volume=volume,
+            driver=driver,
+            labels=labels,
+            present=present,
+        )
+
+    else:
+        if existent_volume is None:
+            host.noop("There is no {0} volume!".format(volume))
+            return
+
+        yield handle_docker(
+            resource="volume",
+            command="remove",
+            volume=volume,
+        )
+
+
+@operation()
+def network(
+    network,
+    driver="",
+    gateway="",
+    ip_range="",
+    ipam_driver="",
+    subnet="",
+    scope="",
+    opts=None,
+    ipam_opts=None,
+    labels=None,
+    ingress=False,
+    attachable=False,
+    present=True,
+):
+    """
+    Manage docker networks
+
+    + network_name: Image name
+    + driver: Container image and tag ex: nginx:alpine
+    + gateway: IPv4 or IPv6 Gateway for the master subnet
+    + ip_range: Allocate container ip from a sub-range
+    + ipam_driver: IP Address Management Driver
+    + subnet: Subnet in CIDR format that represents a network segment
+    + scope: Control the network's scope
+    + opts: Set driver specific options
+    + ipam_opts: Set IPAM driver specific options
+    + labels: Label list to attach in the network
+    + ingress: Create swarm routing-mesh network
+    + attachable: Enable manual container attachment
+    + present: whether the Docker network should exist
+
+    **Examples:**
+
+    .. code:: python
+
+        # Create Docker network
+        docker.network(
+            name="Create nginx network",
+            network_name="nginx",
+            attachable=True,
+            present=True,
+        )
+    """
+    existent_network = [n for n in host.get_fact(DockerNetworks) if n["Name"] == network]
+
+    if present:
+        if existent_network:
+            host.noop("Alredy exist a network with {0} name!".format(network))
+            return
+
+        yield handle_docker(
+            resource="network",
+            command="create",
+            network=network,
+            driver=driver,
+            gateway=gateway,
+            ip_range=ip_range,
+            ipam_driver=ipam_driver,
+            subnet=subnet,
+            scope=scope,
+            opts=opts,
+            ipam_opts=ipam_opts,
+            labels=labels,
+            ingress=ingress,
+            attachable=attachable,
+            present=present,
+        )
+
+    else:
+        if existent_network is None:
+            host.noop("Ther is not network with {0} name!".format(network))
+            return
+
+        yield handle_docker(
+            resource="network",
+            command="create",
+            network=network,
+        )
+
+
+@operation(is_idempotent=False)
+def prune(
+    all=False,
+    volume=False,
+    filter="",
+):
+    """
+    Execute a docker system prune.
+
+    + all: Remove all unused images not just dangling ones
+    + volumes: Prune anonymous volumes
+    + filter: Provide filter values (e.g. "label=<key>=<value>" or "until=24h")
+
+    **Examples:**
+
+    .. code:: python
+
+        # Remove dangling images
+        docker.prune(
+            name="remove dangling images",
+        )
+
+        # Remove all images and volumes
+        docker.prune(
+            name="Remove all images and volumes",
+            all=True,
+            volumes=True,
+        )
+
+        # Remove images older than 90 days
+        docker.prune(
+            name="Remove unused older than 90 days",
+            filter="until=2160h"
+        )
+    """
+
+    yield handle_docker(
+        resource="system",
+        command="prune",
+        all=all,
+        volume=volume,
+        filter=filter,
+    )

pyinfra/operations/runit.py

@@ -0,0 +1,182 @@
+"""
+Manage runit services.
+"""
+
+from typing import Optional
+
+from pyinfra import host
+from pyinfra.api import operation
+from pyinfra.facts.files import File
+from pyinfra.facts.runit import RunitManaged, RunitStatus
+
+from .files import file, link
+from .util.service import handle_service_control
+
+
+@operation()
+def service(
+    service: str,
+    running: bool = True,
+    restarted: bool = False,
+    reloaded: bool = False,
+    command: Optional[str] = None,
+    enabled: Optional[bool] = None,
+    managed: bool = True,
+    svdir: str = "/var/service",
+    sourcedir: str = "/etc/sv",
+):
+    """
+    Manage the state of runit 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: ``sv <command> <service>``
+    + enabled: whether this service should be enabled/disabled on boot
+    + managed: whether runit should manage this service
+
+      For services to be controlled, they first need to be managed by runit by
+      adding a symlink to the service in ``SVDIR``.
+      By setting ``managed=False`` the symlink will be removed.
+      Other options won't have any effect after that.
+      Although the ``<service>/down`` file can still be controlled with the
+      ``enabled`` option.
+
+    + svdir: alternative ``SVDIR``
+
+      An alternative ``SVDIR`` can be specified. This can be used for user services.
+
+    + sourcedir: where to search for available services
+
+      An alternative directory for available services can be specified.
+      Example: ``sourcedir=/etc/sv.local`` for services managed by the administrator.
+    """
+
+    was_managed = service in host.get_fact(RunitManaged, service=service, svdir=svdir)
+    was_auto = not host.get_fact(File, path="{0}/{1}/down".format(sourcedir, service))
+
+    # Disable autostart for previously unmanaged services.
+    #
+    # Where ``running=False`` is requested, this prevents one case of briefly
+    # starting and stopping the service.
+    if not was_managed and managed and was_auto:
+        yield from auto._inner(
+            service=service,
+            auto=False,
+            sourcedir=sourcedir,
+        )
+
+    yield from manage._inner(
+        service=service,
+        managed=managed,
+        svdir=svdir,
+        sourcedir=sourcedir,
+    )
+
+    # Service wasn't managed before, so wait for ``runsv`` to start.
+    # ``runsvdir`` will check at least every 5 seconds for new services.
+    # Wait for at most 10 seconds for the service to be managed, otherwise fail.
+    if not was_managed and managed:
+        yield from wait_runsv._inner(
+            service=service,
+            svdir=svdir,
+        )
+
+    if isinstance(enabled, bool):
+        yield from auto._inner(
+            service=service,
+            auto=enabled,
+            sourcedir=sourcedir,
+        )
+    else:
+        # restore previous state of ``<service>/down``
+        yield from auto._inner(
+            service=service,
+            auto=was_auto,
+            sourcedir=sourcedir,
+        )
+
+    # Services need to be managed by ``runit`` for the other options to make sense.
+    if not managed:
+        return
+
+    yield from handle_service_control(
+        host,
+        service,
+        host.get_fact(RunitStatus, service=service, svdir=svdir),
+        "SVDIR={0} sv {{1}} {{0}}".format(svdir),
+        running,
+        restarted,
+        reloaded,
+        command,
+    )
+
+
+@operation()
+def manage(
+    service: str,
+    managed: bool = True,
+    svdir: str = "/var/service",
+    sourcedir: str = "/etc/sv",
+):
+    """
+    Manage runit svdir links.
+
+    + service: name of the service to manage
+    + managed: whether the link should exist
+    + svdir: alternative ``SVDIR``
+    + sourcedir: where to search for available services
+    """
+
+    yield from link._inner(
+        path="{0}/{1}".format(svdir, service),
+        target="{0}/{1}".format(sourcedir, service),
+        present=managed,
+        create_remote_dir=False,
+    )
+
+
+@operation(is_idempotent=False)
+def wait_runsv(
+    service: str,
+    svdir: str = "/var/service",
+    timeout: int = 10,
+):
+    """
+    Wait for runsv for ``service`` to be available.
+
+    + service: name of the service to manage
+    + svdir: alternative ``SVDIR``
+    + timeout: time in seconds to wait
+    """
+
+    yield (
+        "export SVDIR={0}\n"
+        "for i in $(seq {1}); do\n"
+        "    sv status {2} > /dev/null && exit 0\n"
+        "    sleep 1;\n"
+        "done\n"
+        "exit 1"
+    ).format(svdir, timeout, service)
+
+
+@operation()
+def auto(
+    service: str,
+    auto: bool = True,
+    sourcedir: str = "/etc/sv",
+):
+    """
+    Start service automatically by managing the ``service/down`` file.
+
+    + service: name of the service to manage
+    + auto: whether the service should start automatically
+    + sourcedir: where to search for available services
+    """
+
+    yield from file._inner(
+        path="{0}/{1}/down".format(sourcedir, service),
+        present=not auto,
+        create_remote_dir=False,
+    )

pyinfra/operations/server.py

@@ -41,6 +41,7 @@ from . import (
     openrc,
     pacman,
     pkg,
+    runit,
     systemd,
     sysvinit,
     upstart,
@@ -492,6 +493,9 @@ def service(
     elif host.get_fact(Which, command="initctl"):
         service_operation = upstart.service
 
+    elif host.get_fact(Which, command="sv"):
+        service_operation = runit.service
+
     elif (
         host.get_fact(Which, command="service")
         or host.get_fact(Link, path="/etc/init.d")

pyinfra/operations/systemd.py

@@ -4,6 +4,8 @@ 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
@@ -140,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/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/service.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import shlex
+
 from pyinfra.api import Host
 
 
@@ -19,26 +21,26 @@ def handle_service_control(
     # Need down but running
     if running is False:
         if is_running:
-            yield formatter.format(name, "stop")
+            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 is_running:
-            yield formatter.format(name, "start")
+            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 is_running:
-        yield formatter.format(name, "restart")
+        yield formatter.format(shlex.quote(name), "restart")
 
     # Only reload if the service is already reloaded
     if reloaded and is_running:
-        yield formatter.format(name, "reload")
+        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)

{pyinfra-3.0b2.dist-info → pyinfra-3.0b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyinfra
-Version: 3.0b2
+Version: 3.0b4
 Summary: pyinfra automates/provisions/manages/deploys infrastructure.
 Home-page: https://pyinfra.com
 Author: Nick / Fizzadar
@@ -56,7 +56,7 @@ Requires-Dist: types-paramiko ; extra == 'dev'
 Requires-Dist: types-python-dateutil ; extra == 'dev'
 Requires-Dist: types-PyYAML ; extra == 'dev'
 Requires-Dist: types-setuptools ; extra == 'dev'
-Requires-Dist: pyinfra-guzzle-sphinx-theme ==0.15 ; extra == 'dev'
+Requires-Dist: pyinfra-guzzle-sphinx-theme ==0.16 ; extra == 'dev'
 Requires-Dist: myst-parser ==2.0.0 ; extra == 'dev'
 Requires-Dist: sphinx ==6.2.1 ; extra == 'dev'
 Requires-Dist: wheel ; extra == 'dev'
@@ -67,7 +67,7 @@ Requires-Dist: ipdbplugin ; extra == 'dev'
 Requires-Dist: flake8-spellcheck ==0.12.1 ; extra == 'dev'
 Requires-Dist: redbaron ; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: pyinfra-guzzle-sphinx-theme ==0.15 ; extra == 'docs'
+Requires-Dist: pyinfra-guzzle-sphinx-theme ==0.16 ; extra == 'docs'
 Requires-Dist: myst-parser ==2.0.0 ; extra == 'docs'
 Requires-Dist: sphinx ==6.2.1 ; extra == 'docs'
 Provides-Extra: test

{pyinfra-3.0b2.dist-info → pyinfra-3.0b4.dist-info}/RECORD

@@ -27,7 +27,7 @@ pyinfra/connectors/chroot.py,sha256=Xd72I8T58KIwKOoc0LXCw91AoEIaiHfRLDcDVTHGJ0o,
 pyinfra/connectors/docker.py,sha256=2UNHhXS4hpLo7I19ixDeSd7JR8SNo43VgqsaUIZQZJ4,8741
 pyinfra/connectors/dockerssh.py,sha256=VWHY--jqs3yf-RuPUZXav4vLeON9SzoVC9CUyOJo1rg,8919
 pyinfra/connectors/local.py,sha256=vYOBQS_5rf-dVaPeG4dJlLwBHqkxAzLjj3aDEgbAsx8,6900
-pyinfra/connectors/ssh.py,sha256=ESCZwehJ0Ve6gkjbqGTJrNEGZlu3ItjKLMkmCWq-Z3Y,20989
+pyinfra/connectors/ssh.py,sha256=kUtp86GlIteM_bqXtoPtdQE1--AmxzAtBOXv5oK0IOI,21136
 pyinfra/connectors/ssh_util.py,sha256=CN_5AdTA3RpiWCnXTrRBjez1NsN59hITDzQmXIkZvoE,3683
 pyinfra/connectors/terraform.py,sha256=G7lK168Fz0jNFetc_7_bPT-RnoaRDksJat0R26fqkUk,3617
 pyinfra/connectors/util.py,sha256=0bvoMsGMD-Tbfaer8NUhWJjBnaNKdmE83PDg48BYjcU,11374
@@ -44,7 +44,7 @@ pyinfra/facts/cargo.py,sha256=mHtT2Yxoqx_g0akDq6jkHFN5VWNHQu70vKvNLZ10-b8,567
 pyinfra/facts/choco.py,sha256=Tf7_DuQY0eZ4SIxV0rlyulrBCg7A0qyPbtTcHgkVP_0,739
 pyinfra/facts/deb.py,sha256=dy5PKdQqy1oLdCUd6iTxCa6yG8agsaxZrPVsjvlDi74,1756
 pyinfra/facts/dnf.py,sha256=7YNicP8EbRvWJQKU0OcwcW3bnIxx9GJ1Fy4qdCFnI0Y,898
-pyinfra/facts/docker.py,sha256=uaY2ui98t3p0a6F6DQq5FiA6y8pOCwsrkFK4JTRlj3Y,1714
+pyinfra/facts/docker.py,sha256=Vr0rIEXSpK33yc2dDGct2lKhPQamvKEztxIAfwN0sk0,2046
 pyinfra/facts/files.py,sha256=ki9-NQnYyt1VzuqKwEOYpX1nz5gJ_ph-ruq-4DS1VLg,11511
 pyinfra/facts/gem.py,sha256=U1oF32LeiBo3ruaFm6hfF3XwNmgyhqamFUAeGn4cD3k,509
 pyinfra/facts/git.py,sha256=rk4NS2SQJiosI6eY2eCy_p9kOP4O8UARRjFi16ObE2w,1294
@@ -63,6 +63,7 @@ pyinfra/facts/pkgin.py,sha256=Q1q7m4CCs_na92dDdQIjTuQnJ3axYv5qUdxnAy7e_XY,517
 pyinfra/facts/postgres.py,sha256=M7ppmVvUXy8HSNPqrc8zLPyt8JamAyGs2IO2ocbzSZ8,4187
 pyinfra/facts/postgresql.py,sha256=4nusMVvGhtku86KX4O4vjSxh_MamxZy_kmTQvvy0GhE,223
 pyinfra/facts/rpm.py,sha256=v9OCfTlTSqs4UQWDwnt2tVJkqHOmHZvj7Cd1g4mZ3WI,2091
+pyinfra/facts/runit.py,sha256=uqwftOBmjWma09hNhIZ9ZF2QqqgdcA5NzrbBtP95lRM,1965
 pyinfra/facts/selinux.py,sha256=N0zbJrAtBeRBtxZFUHbYTLQ2L4mRV7_Oj3Cj3OA1Npw,4272
 pyinfra/facts/server.py,sha256=ocUPIIveHWfe4K4-7mt7Je7TswWbKmjdu1xAF2VxaD8,19798
 pyinfra/facts/snap.py,sha256=MnZDllRZ1JKLw0SKRFQ1tI6Wi05gvipQPo7m4gpL4fI,1946
@@ -85,6 +86,7 @@ pyinfra/operations/bsdinit.py,sha256=okQUQDr2H8Z-cAdfdbPJiuGujsHLuV5gpuMZ1UlICEM
 pyinfra/operations/cargo.py,sha256=mXWd6pb0IR6kzJMmPHwXZN-VJ-B_y8AdOFlrRzDQOZI,1104
 pyinfra/operations/choco.py,sha256=8nG0wc1tZEA0L0HTIjgR00IDiONARokyzHyKj-R3xmo,1515
 pyinfra/operations/dnf.py,sha256=3154Rer6dejVB1AK-CqyJhpMVn_djaSDJrVMs62GNcE,5599
+pyinfra/operations/docker.py,sha256=Mra-m2iayXkc2LgCk2tuE6M7lZHhOGNJD3WQIPM9t2I,8396
 pyinfra/operations/files.py,sha256=9O_HKgmVD_z74jtSivY4pKBPrCDKKHDSy0jAB9QERHU,53639
 pyinfra/operations/gem.py,sha256=2C85sOwIRMHGvmPg4uAlUVf6MokhiA7LLPqzdJRHsBg,1132
 pyinfra/operations/git.py,sha256=b26tQF_4hykTy0FtxiuCkqPk9i8JdZaz-RBhH4X96yw,11789
@@ -102,11 +104,12 @@ pyinfra/operations/postgres.py,sha256=LRoedDevQqiM5eX5Lmzb5mr_E9Od0ROVC0j18ZqaR0
 pyinfra/operations/postgresql.py,sha256=agZjL2W4yxigk9ThIC0V_3wvmcWVdX308aJO24WkN6g,833
 pyinfra/operations/puppet.py,sha256=eDe8D9jQbHYQ4_r4-dmEZfMASKQvj36BR8z_h8aDfw8,861
 pyinfra/operations/python.py,sha256=u569cdPrPesrmzU09nwIPA3bk6TZ-Qv2QP0lJLcO_bw,2021
+pyinfra/operations/runit.py,sha256=jRR5kt1OUCLbYktnu7yl3YvSiTW51VvEvOuB0yfd7Ww,5126
 pyinfra/operations/selinux.py,sha256=khqWJsr9MOTyZmxP9P4dQ_7KUNlAfo5fx3Nv7kWm49w,5961
-pyinfra/operations/server.py,sha256=TUJ_E61ar1sOYUykX35mYUuwtJRqOpiDZ22HYDP6Vys,36315
+pyinfra/operations/server.py,sha256=wc5pNDQzEiwl9XEz1cG1m-51z1TV-5P39eMvSig90tY,36414
 pyinfra/operations/snap.py,sha256=a-QtNE4Dlsavqq425TUIwpEJu4oGw8UlLRkdTFyT1F8,3049
 pyinfra/operations/ssh.py,sha256=wocoaYDlOhhItItAVQCEfnVowTtkg3AP0hQ3mnpUnl0,5634
-pyinfra/operations/systemd.py,sha256=89bq9VMpQ-qnupTa6U8OsBFFoDWUNwWvrLP_LN8uaxE,3944
+pyinfra/operations/systemd.py,sha256=hPHTjASj6N_fRAzLr3DNHnxxIbiiTIIT9UStSxKDkTk,3984
 pyinfra/operations/sysvinit.py,sha256=WzzthkmWL46MNNY6LsBZ90e37yPj0w2QyUtEAlGBwqY,4078
 pyinfra/operations/upstart.py,sha256=pHb9RGnVhT14A_y6OezfOH-lmniKpiyJqpeoOJl0beE,1978
 pyinfra/operations/vzctl.py,sha256=2u2CDkuDjzHBRQ54HfyfLpLrsbT8U7_05EEjbbhKUiU,3110
@@ -114,9 +117,10 @@ pyinfra/operations/xbps.py,sha256=ru3_srMBUyUXGzAsPo7WwoomfM0AeDglFv8CDqB33B0,15
 pyinfra/operations/yum.py,sha256=Ig7AzQy1C7I8XM37lWbw0nI5lzFGMoX30P8FV8-V5uA,5600
 pyinfra/operations/zypper.py,sha256=z1CWv2uwWBlCLIhHna7U5DojVoKZYoUYpezJ_FM_xK8,5555
 pyinfra/operations/util/__init__.py,sha256=ZAHjeCXtLo0TIOSfZ9h0Sh5IXXRCspfHs3RR1l8tQCE,366
+pyinfra/operations/util/docker.py,sha256=6CvQgeFAXH_lDqKb7RxWpMvlCDwEAXlBaDZoJ8LxrYg,4596
 pyinfra/operations/util/files.py,sha256=Zcet3ydNVbdT9jss0BDm6RJFyR_s6XTr0isDR60Zubw,3622
 pyinfra/operations/util/packaging.py,sha256=xFtOlEX46ms7g3gDvOOInRVR1RVfgsmhLzFzsJAL_eU,9381
-pyinfra/operations/util/service.py,sha256=RQjnByy-x_KdOSjOLweS12x8pOXpLkTPLlaHsntpYQE,1230
+pyinfra/operations/util/service.py,sha256=kJd1zj4-sAaGIp5Ts7yAJznogWaGr8oQTztwenLAr7Y,1309
 pyinfra_cli/__init__.py,sha256=G0X7tNdqT45uWuK3aHIKxMdDeCgJ7zHo6vbxoG6zy_8,284
 pyinfra_cli/__main__.py,sha256=8tjq8HUll8P8naFw7pGlygwSz7u9je_MQ-0pqcDlENY,881
 pyinfra_cli/commands.py,sha256=J-mCJYvDebJ8M7o3HreB2zToa871-xO6_KjVhPLeHho,1832
@@ -155,9 +159,9 @@ tests/test_connectors/test_sshuserclient.py,sha256=2PQNLPhNL6lBACc6tQuXmPoog-9L6
 tests/test_connectors/test_terraform.py,sha256=Z5MhgDeRDFumu-GlbjMD0ZRkecwBIPP8C8ZVg-mq7C8,3743
 tests/test_connectors/test_util.py,sha256=hQir0WyjH0LEF6xvIyHNyqdI5pkJX6qUR9287MgO2bY,4647
 tests/test_connectors/test_vagrant.py,sha256=27qRB7ftjEPaj4ejBNZ-rR4Ou1AD1VyVcf2XjwZPG3M,3640
-pyinfra-3.0b2.dist-info/LICENSE.md,sha256=gwC95tUll0gwB32tHNkTAasN7Sb6vjWzXa305NwClbI,1076
-pyinfra-3.0b2.dist-info/METADATA,sha256=lISn-ii_LETvqwvTJMl5HZ4oa1jNndtp6M-Q1Q8TSzk,8322
-pyinfra-3.0b2.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
-pyinfra-3.0b2.dist-info/entry_points.txt,sha256=BraEFyquy05M8ch33HZXOHoH_m2BTqejL3xX3NrpzOM,471
-pyinfra-3.0b2.dist-info/top_level.txt,sha256=2K6D1mK35JTSEBgOfEPV-N-uA2SDErxGiE0J-HUMMVI,26
-pyinfra-3.0b2.dist-info/RECORD,,
+pyinfra-3.0b4.dist-info/LICENSE.md,sha256=gwC95tUll0gwB32tHNkTAasN7Sb6vjWzXa305NwClbI,1076
+pyinfra-3.0b4.dist-info/METADATA,sha256=L9PyC6qdNCq30gCNvpPpl41jLlqacs9n-IlbHHO-lwc,8322
+pyinfra-3.0b4.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+pyinfra-3.0b4.dist-info/entry_points.txt,sha256=BraEFyquy05M8ch33HZXOHoH_m2BTqejL3xX3NrpzOM,471
+pyinfra-3.0b4.dist-info/top_level.txt,sha256=2K6D1mK35JTSEBgOfEPV-N-uA2SDErxGiE0J-HUMMVI,26
+pyinfra-3.0b4.dist-info/RECORD,,