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

pyinfra/connectors/ssh.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import shlex
-from distutils.spawn import find_executable
+from random import uniform
+from shutil import which
 from socket import error as socket_error, gaierror
+from time import sleep
 from typing import TYPE_CHECKING, Any, Iterable, Optional, Tuple
 
 import click
@@ -48,6 +50,10 @@ class ConnectorData(TypedDict):
 
     ssh_paramiko_connect_kwargs: dict
 
+    ssh_connect_retries: int
+    ssh_connect_retry_min_delay: float
+    ssh_connect_retry_max_delay: float
+
 
 connector_data_meta: dict[str, DataMeta] = {
     "ssh_hostname": DataMeta("SSH hostname"),
@@ -77,6 +83,15 @@ connector_data_meta: dict[str, DataMeta] = {
     "ssh_paramiko_connect_kwargs": DataMeta(
         "Override keyword arguments passed into Paramiko's ``SSHClient.connect``"
     ),
+    "ssh_connect_retries": DataMeta("Number of tries to connect via ssh", 0),
+    "ssh_connect_retry_min_delay": DataMeta(
+        "Lower bound for random delay between retries",
+        0.1,
+    ),
+    "ssh_connect_retry_max_delay": DataMeta(
+        "Upper bound for random delay between retries",
+        0.5,
+    ),
 }
 
 
@@ -125,8 +140,9 @@ class SSHConnector(BaseConnector):
 
     client: Optional[SSHClient] = None
 
-    def make_names_data(hostname):
-        yield "@ssh/{0}".format(hostname), {"ssh_hostname": hostname}, []
+    @staticmethod
+    def make_names_data(name):
+        yield "@ssh/{0}".format(name), {"ssh_hostname": name}, []
 
     def make_paramiko_kwargs(self) -> dict[str, Any]:
         kwargs = {
@@ -172,6 +188,29 @@ class SSHConnector(BaseConnector):
         return kwargs
 
     def connect(self) -> None:
+        retries = self.data["ssh_connect_retries"]
+
+        try:
+            while True:
+                try:
+                    return self._connect()
+                except (SSHException, gaierror, socket_error, EOFError):
+                    if retries == 0:
+                        raise
+                    retries -= 1
+                    min_delay = self.data["ssh_connect_retry_min_delay"]
+                    max_delay = self.data["ssh_connect_retry_max_delay"]
+                    sleep(uniform(min_delay, max_delay))
+        except SSHException as e:
+            raise_connect_error(self.host, "SSH error", e)
+        except gaierror as e:
+            raise_connect_error(self.host, "Could not resolve hostname", e)
+        except socket_error as e:
+            raise_connect_error(self.host, "Could not connect", e)
+        except EOFError as e:
+            raise_connect_error(self.host, "EOF error", e)
+
+    def _connect(self) -> None:
         """
         Connect to a single host. Returns the SSH client if successful. Stateless by
         design so can be run in parallel.
@@ -221,18 +260,6 @@ class SSHConnector(BaseConnector):
                 f"Host key for {e.hostname} does not match.",
             )
 
-        except SSHException as e:
-            raise_connect_error(self.host, "SSH error", e)
-
-        except gaierror:
-            raise_connect_error(self.host, "Could not resolve hostname", hostname)
-
-        except socket_error as e:
-            raise_connect_error(self.host, "Could not connect", e)
-
-        except EOFError as e:
-            raise_connect_error(self.host, "EOF error", e)
-
     def run_shell_command(
         self,
         command: StringCommand,
@@ -450,16 +477,10 @@ class SSHConnector(BaseConnector):
             self._put_file(filename_or_io, temp_file)
 
             # Make sure our sudo/su user can access the file
-            if _su_user:
-                command = StringCommand("setfacl", "-m", "u:{0}:r".format(_su_user), temp_file)
-            elif _sudo_user:
-                command = StringCommand("setfacl", "-m", "u:{0}:r".format(_sudo_user), temp_file)
-            elif _doas_user:
-                command = StringCommand("setfacl", "-m", "u:{0}:r".format(_doas_user), temp_file)
-
-            if _su_user or _sudo_user or _doas_user:
+            other_user = _su_user or _sudo_user or _doas_user
+            if other_user:
                 status, output = self.run_shell_command(
-                    command,
+                    StringCommand("setfacl", "-m", f"u:{other_user}:r", temp_file),
                     print_output=print_output,
                     print_input=print_input,
                     **arguments,
@@ -518,7 +539,7 @@ class SSHConnector(BaseConnector):
         if self.data["ssh_password"]:
             raise NotImplementedError("Rsync does not currently work with SSH passwords.")
 
-        if not find_executable("rsync"):
+        if not which("rsync"):
             raise NotImplementedError("The `rsync` binary is not available on this system.")
 
     def rsync(

pyinfra/connectors/terraform.py

@@ -28,7 +28,8 @@ def _flatten_dict(d: dict, parent_key: str = "", sep: str = "."):
 
 class TerraformInventoryConnector(BaseConnector):
     """
-    Generate one or more SSH hosts from a Terraform output variable. The variable must be a list of hostnames or dictionaries.
+    Generate one or more SSH hosts from a Terraform output variable. The variable
+    must be a list of hostnames or dictionaries.
 
     Output is fetched from a flattened JSON dictionary output from ``terraform output
     -json``. For example the following object:
@@ -77,21 +78,23 @@ class TerraformInventoryConnector(BaseConnector):
     """
 
     @staticmethod
-    def make_names_data(output_key=None):
+    def make_names_data(name=None):
         show_warning()
 
-        if not output_key:
-            raise InventoryError("No Terraform output key!")
+        if not name:
+            name = ""
 
         with progress_spinner({"fetch terraform output"}):
             tf_output_raw = local.shell("terraform output -json")
 
+        assert isinstance(tf_output_raw, str)
         tf_output = json.loads(tf_output_raw)
         tf_output = _flatten_dict(tf_output)
 
-        tf_output_value = tf_output.get(output_key)
+        tf_output_value = tf_output.get(name)
         if tf_output_value is None:
-            raise InventoryError(f"No Terraform output with key: `{output_key}`")
+            keys = "\n".join(f"   - {k}" for k in tf_output.keys())
+            raise InventoryError(f"No Terraform output with key: `{name}`, valid keys:\n{keys}")
 
         if not isinstance(tf_output_value, list):
             raise InventoryError(

pyinfra/connectors/util.py

@@ -40,7 +40,7 @@ def run_local_process(
     stdin=None,
     timeout: Optional[int] = None,
     print_output: bool = False,
-    print_prefix=None,
+    print_prefix: str = "",
 ) -> tuple[int, "CommandOutput"]:
     process = Popen(command, shell=True, stdout=PIPE, stderr=PIPE, stdin=PIPE)
 
@@ -274,12 +274,11 @@ def make_unix_command_for_host(
         # If no sudo, we've nothing to do here
         return make_unix_command(command, **command_arguments)
 
-    # Ensure the sudo password is set from either the direct arguments or any
-    # connector data value.
-    command_arguments["_sudo_password"] = command_arguments.get(
-        "_sudo_password",
-        host.connector_data.get("prompted_sudo_password"),
-    )
+    # If the sudo password is not set in the direct arguments,
+    # set it from the connector data value.
+    if "_sudo_password" not in command_arguments or not command_arguments["_sudo_password"]:
+        command_arguments["_sudo_password"] = host.connector_data.get("prompted_sudo_password")
+
     if command_arguments["_sudo_password"]:
         # Ensure the askpass path is correctly set and passed through
         _ensure_sudo_askpass_set_for_host(host)
@@ -339,7 +338,7 @@ def make_unix_command(
             [
                 "env",
                 "SUDO_ASKPASS={0}".format(_sudo_askpass_path),
-                MaskString("{0}={1}".format(SUDO_ASKPASS_ENV_VAR, _sudo_password)),
+                MaskString("{0}={1}".format(SUDO_ASKPASS_ENV_VAR, shlex.quote(_sudo_password))),
             ],
         )
 

pyinfra/connectors/vagrant.py

@@ -93,13 +93,13 @@ def _make_name_data(host):
         "ssh_hostname": host["HostName"],
     }
 
-    for config_key, data_key in (
-        ("Port", "ssh_port"),
-        ("User", "ssh_user"),
-        ("IdentityFile", "ssh_key"),
+    for config_key, data_key, data_cast in (
+        ("Port", "ssh_port", int),
+        ("User", "ssh_user", str),
+        ("IdentityFile", "ssh_key", str),
     ):
         if config_key in host:
-            data[data_key] = host[config_key]
+            data[data_key] = data_cast(host[config_key])
 
     # Update any configured JSON data
     if vagrant_host in vagrant_options.get("data", {}):
@@ -132,8 +132,8 @@ class VagrantInventoryConnector(BaseConnector):
     """
 
     @staticmethod
-    def make_names_data(limit=None):
-        vagrant_ssh_info = get_vagrant_config(limit)
+    def make_names_data(name=None):
+        vagrant_ssh_info = get_vagrant_config(name)
 
         logger.debug("Got Vagrant SSH info: \n%s", vagrant_ssh_info)
 
@@ -170,10 +170,11 @@ class VagrantInventoryConnector(BaseConnector):
             hosts.append(_make_name_data(current_host))
 
         if not hosts:
-            if limit:
+            if name:
                 raise InventoryError(
-                    "No running Vagrant instances matching `{0}` found!".format(limit)
+                    "No running Vagrant instances matching `{0}` found!".format(name)
                 )
             raise InventoryError("No running Vagrant instances found!")
 
-        return hosts
+        for host in hosts:
+            yield host

pyinfra/context.py

@@ -4,6 +4,7 @@ are imported and used throughout pyinfra and end user deploy code (CLI mode).
 
 These variables always represent the current executing pyinfra context.
 """
+
 from contextlib import contextmanager
 from types import ModuleType
 from typing import TYPE_CHECKING

pyinfra/facts/apk.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/apt.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api import FactBase

pyinfra/facts/brew.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra import logger

pyinfra/facts/bsdinit.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from .sysvinit import InitdStatus
 
 

pyinfra/facts/cargo.py

@@ -1,5 +1,7 @@
 # encoding: utf8
 
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/choco.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
@@ -16,7 +18,7 @@ class ChocoPackages(FactBase):
         }
     """
 
-    command = "choco list --local-only"
+    command = "choco list"
     shell_executable = "ps"
 
     default = dict

pyinfra/facts/deb.py

@@ -1,4 +1,7 @@
+from __future__ import annotations
+
 import re
+import shlex
 
 from pyinfra.api import FactBase
 
@@ -48,14 +51,16 @@ class DebPackage(FactBase):
     """
 
     _regexes = {
-        "name": r"^Package: ({0})$".format(DEB_PACKAGE_NAME_REGEX),
-        "version": r"^Version: ({0})$".format(DEB_PACKAGE_VERSION_REGEX),
+        "name": r"^Package:\s+({0})$".format(DEB_PACKAGE_NAME_REGEX),
+        "version": r"^Version:\s+({0})$".format(DEB_PACKAGE_VERSION_REGEX),
     }
 
     requires_command = "dpkg"
 
-    def command(self, name):
-        return "! test -e {0} && (dpkg -s {0} 2>/dev/null || true) || dpkg -I {0}".format(name)
+    def command(self, package):
+        return "! test -e {0} && (dpkg -s {0} 2>/dev/null || true) || dpkg -I {0}".format(
+            shlex.quote(package)
+        )
 
     def process(self, output):
         data = {}

pyinfra/facts/dnf.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util import make_cat_files_command

pyinfra/facts/docker.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 
 from pyinfra.api import FactBase

pyinfra/facts/files.py

@@ -2,6 +2,8 @@
 The files facts provide information about the filesystem and it's contents on the target host.
 """
 
+from __future__ import annotations
+
 import re
 import stat
 from datetime import datetime

pyinfra/facts/gem.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/gpg.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from urllib.parse import urlparse
 
 from pyinfra.api import FactBase

pyinfra/facts/hardware.py

@@ -195,28 +195,36 @@ class NetworkDevices(FactBase):
         output = "\n".join(map(str.strip, output))
 
         # Splitting the output into sections per network device
-        device_sections = re.split(r"\n(?=\d+: \w|\w+:.*mtu.*)", output)
+        device_sections = re.split(r"\n(?=\d+: [^\s/:]|[^\s/:]+:.*mtu )", output)
 
         # Dictionary to hold all device information
         all_devices = {}
 
         for section in device_sections:
             # Extracting the device name
-            device_name_match = re.match(r"^(?:\d+: )?([\w@]+):", section)
+            device_name_match = re.match(r"^(?:\d+: )?([^\s/:]+):", section)
             if not device_name_match:
                 continue
             device_name = device_name_match.group(1)
 
             # Regular expressions to match different parts of the output
-            ether_re = re.compile(r"([0-9A-Fa-f:]{17})")
+            ether_re = re.compile(r"ether ([0-9A-Fa-f:]{17})")
             mtu_re = re.compile(r"mtu (\d+)")
             ipv4_re = (
+                # ip a
                 re.compile(
-                    r"inet (\d+\.\d+\.\d+\.\d+)/(\d+)(?: brd (\d+\.\d+\.\d+\.\d+))"
-                ),  # ip a output,
+                    r"inet (?P<address>\d+\.\d+\.\d+\.\d+)/(?P<mask>\d+)(?: metric \d+)?(?: brd (?P<broadcast>\d+\.\d+\.\d+\.\d+))?"  # noqa: E501
+                ),
+                # ifconfig -a
                 re.compile(
-                    r"inet (\d+\.\d+\.\d+\.\d+)\s+netmask\s+((?:\d+\.\d+\.\d+\.\d+)|(?:[0-9a-fA-FxX]+))(?:\s+broadcast\s+(\d+\.\d+\.\d+\.\d+))"  # noqa: E501
-                ),  # ifconfig -a output
+                    r"inet (?P<address>\d+\.\d+\.\d+\.\d+)\s+netmask\s+(?P<mask>(?:\d+\.\d+\.\d+\.\d+)|(?:[0-9a-fA-FxX]+))(?:\s+broadcast\s+(?P<broadcast>\d+\.\d+\.\d+\.\d+))?"  # noqa: E501
+                ),
+            )
+            ipv6_re = (
+                # ip a
+                re.compile(r"inet6\s+(?P<address>[0-9a-fA-F:]+)/(?P<mask>\d+)"),
+                # ifconfig -a
+                re.compile(r"inet6\s+(?P<address>[0-9a-fA-F:]+)\s+prefixlen\s+(?P<mask>\d+)"),
             )
 
             # Parsing the output
@@ -235,18 +243,22 @@ class NetworkDevices(FactBase):
             )
 
             # IPv4 Addresses
+            ipv4_matches: list[re.Match[str]]
             for ipv4_re_ in ipv4_re:
-                ipv4_matches = ipv4_re_.findall(section)
-                if ipv4_matches:
+                ipv4_matches = list(ipv4_re_.finditer(section))
+                if len(ipv4_matches):
                     break
 
-            if ipv4_matches:
+            if len(ipv4_matches):
                 ipv4_info = []
                 for ipv4 in ipv4_matches:
-                    address = ipv4[0]
-                    mask_value = ipv4[1]
+                    address = ipv4.group("address")
+                    mask_value = ipv4.group("mask")
                     mask_bits, netmask = mask(mask_value)
-                    broadcast = ipv4[2] if len(ipv4) == 3 else None
+                    try:
+                        broadcast = ipv4.group("broadcast")
+                    except IndexError:
+                        broadcast = None
 
                     ipv4_info.append(
                         {
@@ -261,21 +273,17 @@ class NetworkDevices(FactBase):
                     device_info["ipv4"]["additional_ips"] = ipv4_info[1:]  # type: ignore[index]
 
             # IPv6 Addresses
-            ipv6_re = (
-                re.compile(r"inet6\s+([0-9a-fA-F:]+)/(\d+)"),
-                re.compile(r"inet6\s+([0-9a-fA-F:]+)\s+prefixlen\s+(\d+)"),
-            )
-
+            ipv6_matches: list[re.Match[str]]
             for ipv6_re_ in ipv6_re:
-                ipv6_matches = ipv6_re_.findall(section)
+                ipv6_matches = list(ipv6_re_.finditer(section))
                 if ipv6_matches:
                     break
 
-            if ipv6_matches:
+            if len(ipv6_matches):
                 ipv6_info = []
                 for ipv6 in ipv6_matches:
-                    address = ipv6[0]
-                    mask_bits = ipv6[1] or ipv6[2]
+                    address = ipv6.group("address")
+                    mask_bits = ipv6.group("mask")
                     ipv6_info.append({"address": address, "mask_bits": int(mask_bits)})
                 device_info["ipv6"] = ipv6_info[0]
                 if len(ipv6_matches) > 1:

pyinfra/facts/launchd.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 

pyinfra/facts/lxd.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 
 from pyinfra.api import FactBase

pyinfra/facts/mysql.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from collections import defaultdict
 
@@ -8,11 +10,11 @@ from .util.databases import parse_columns_and_rows
 
 
 def make_mysql_command(
-    database=None,
-    user=None,
-    password=None,
-    host=None,
-    port=None,
+    database: str | None = None,
+    user: str | None = None,
+    password: str | None = None,
+    host: str | None = None,
+    port: int | None = None,
     executable="mysql",
 ):
     target_bits = [executable]
@@ -37,7 +39,11 @@ def make_mysql_command(
     return StringCommand(*target_bits)
 
 
-def make_execute_mysql_command(command, ignore_errors=False, **mysql_kwargs):
+def make_execute_mysql_command(
+    command: str | StringCommand,
+    ignore_errors=False,
+    **mysql_kwargs,
+):
     commands_bits = [
         make_mysql_command(**mysql_kwargs),
         "-Be",

pyinfra/facts/npm.py

@@ -1,4 +1,5 @@
 # encoding: utf8
+from __future__ import annotations
 
 from pyinfra.api import FactBase
 

pyinfra/facts/openrc.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 
 from pyinfra.api import FactBase

pyinfra/facts/pacman.py

@@ -1,3 +1,7 @@
+from __future__ import annotations
+
+import shlex
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
@@ -21,9 +25,9 @@ class PacmanUnpackGroup(FactBase):
 
     default = list
 
-    def command(self, name):
+    def command(self, package):
         # Accept failure here (|| true) for invalid/unknown packages
-        return 'pacman -S --print-format "%n" {0} || true'.format(name)
+        return 'pacman -S --print-format "%n" {0} || true'.format(shlex.quote(package))
 
     def process(self, output):
         return output

pyinfra/facts/pip.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/pkg.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages

pyinfra/facts/pkgin.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages