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

pyinfra/facts/iptables.py

@@ -1,56 +1,53 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
 from pyinfra.api import FactBase
 
 # Mapping for iptables code arguments to variable names
 IPTABLES_ARGS = {
-    '-A': 'chain',
-    '-j': 'jump',
-
+    "-A": "chain",
+    "-j": "jump",
     # Boolean matches
-    '-p': 'protocol',
-    '-s': 'source',
-    '-d': 'destination',
-    '-i': 'in_interface',
-    '-o': 'out_interface',
-
+    "-p": "protocol",
+    "-s": "source",
+    "-d": "destination",
+    "-i": "in_interface",
+    "-o": "out_interface",
     # Logging
-    '--log-prefix': 'log_prefix',
-
+    "--log-prefix": "log_prefix",
     # NAT exit rules
-    '--to-destination': 'to_destination',
-    '--to-source': 'to_source',
-    '--to-ports': 'to_ports',
+    "--to-destination": "to_destination",
+    "--to-source": "to_source",
+    "--to-ports": "to_ports",
 }
 
 
 def parse_iptables_rule(line):
-    '''
+    """
     Parse one iptables rule. Returns a dict where each iptables code argument
     is mapped to a name using IPTABLES_ARGS.
-    '''
+    """
 
     bits = line.split()
 
-    definition = {}
+    definition: dict = {}
 
     key = None
-    args = []
+    args: list[str] = []
     not_arg = False
 
-    def add_args():
-        arg_string = ' '.join(args)
+    def add_args() -> None:
+        arg_string = " ".join(args)
 
-        if key in IPTABLES_ARGS:
-            definition_key = (
-                'not_{0}'.format(IPTABLES_ARGS[key])
-                if not_arg
-                else IPTABLES_ARGS[key]
-            )
+        if key and key in IPTABLES_ARGS:
+            definition_key = "not_{0}".format(IPTABLES_ARGS[key]) if not_arg else IPTABLES_ARGS[key]
             definition[definition_key] = arg_string
         else:
-            definition.setdefault('extras', []).extend((key, arg_string))
+            definition.setdefault("extras", []).extend((key, arg_string))
 
     for bit in bits:
-        if bit == '!':
+        if bit == "!":
             if key:
                 add_args()
                 args = []
@@ -58,7 +55,7 @@ def parse_iptables_rule(line):
 
             not_arg = True
 
-        elif bit.startswith('-'):
+        elif bit.startswith("-"):
             if key:
                 add_args()
                 args = []
@@ -72,74 +69,85 @@ def parse_iptables_rule(line):
     if key:
         add_args()
 
-    if 'extras' in definition:
-        definition['extras'] = set(definition['extras'])
+    if "extras" in definition:
+        definition["extras"] = set(definition["extras"])
 
     return definition
 
 
 class IptablesRules(FactBase):
-    '''
+    """
     Returns a list of iptables rules for a specific table:
 
     .. code:: python
 
-        {
-            'chain': 'PREROUTING',
-            'jump': 'DNAT'
-        },
-        ...
-    '''
+        [
+            {
+                "chain": "PREROUTING",
+                "jump": "DNAT",
+            },
+        ]
+    """
 
     default = list
 
-    def command(self, table='filter'):
-        return 'iptables-save -t {0}'.format(table)
+    @override
+    def command(self, table="filter"):
+        return "iptables-save -t {0}".format(table)
 
+    @override
     def process(self, output):
         rules = []
 
         for line in output:
-            if line.startswith('-'):
+            if line.startswith("-"):
                 rules.append(parse_iptables_rule(line))
 
         return rules
 
 
 class Ip6tablesRules(IptablesRules):
-    '''
+    """
     Returns a list of ip6tables rules for a specific table:
 
     .. code:: python
 
-        {
-            'chain': 'PREROUTING',
-            'jump': 'DNAT'
-        },
-        ...
-    '''
+        [
+            {
+                "chain": "PREROUTING",
+                "jump": "DNAT",
+            },
+        ]
+    """
 
-    def command(self, table='filter'):
-        return 'ip6tables-save -t {0}'.format(table)
+    @override
+    def command(self, table="filter"):
+        return "ip6tables-save -t {0}".format(table)
 
 
-class IptablesChains(IptablesRules):
-    '''
+class IptablesChains(FactBase):
+    """
     Returns a dict of iptables chains & policies:
 
     .. code:: python
 
-        'NAME': 'POLICY',
-        ...
-    '''
+        {
+            "NAME": "POLICY",
+        }
+    """
 
     default = dict
 
+    @override
+    def command(self, table="filter"):
+        return "iptables-save -t {0}".format(table)
+
+    @override
     def process(self, output):
         chains = {}
 
         for line in output:
-            if line.startswith(':'):
+            if line.startswith(":"):
                 line = line[1:]
 
                 name, policy, _ = line.split()
@@ -149,14 +157,16 @@ class IptablesChains(IptablesRules):
 
 
 class Ip6tablesChains(IptablesChains):
-    '''
+    """
     Returns a dict of ip6tables chains & policies:
 
     .. code:: python
 
-        'NAME': 'POLICY',
-        ...
-    '''
+        {
+            "NAME": "POLICY",
+        }
+    """
 
-    def command(self, table='filter'):
-        return 'ip6tables-save -t {0}'.format(table)
+    @override
+    def command(self, table="filter"):
+        return "ip6tables-save -t {0}".format(table)

pyinfra/facts/launchd.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing_extensions import override
+
+from pyinfra.api import FactBase
+
+
+class LaunchdStatus(FactBase):
+    """
+    Returns a dict of name -> status for launchd managed services.
+    """
+
+    @override
+    def command(self) -> str:
+        return "launchctl list"
+
+    @override
+    def requires_command(self) -> str:
+        return "launchctl"
+
+    default = dict
+
+    @override
+    def process(self, output):
+        services = {}
+
+        for line in output:
+            bits = line.split()
+
+            if not bits or bits[0] == "PID":
+                continue
+
+            name = bits[2]
+            status = False
+
+            try:
+                int(bits[0])
+                status = True
+            except ValueError:
+                pass
+
+            services[name] = status
+
+        return services

pyinfra/facts/lxd.py

@@ -1,16 +1,29 @@
+from __future__ import annotations
+
 import json
 
+from typing_extensions import override
+
 from pyinfra.api import FactBase
 
 
-class LXDContainers(FactBase):
-    '''
+class LxdContainers(FactBase):
+    """
     Returns a list of running LXD containers
-    '''
+    """
+
+    @override
+    def command(self) -> str:
+        return "lxc list --format json --fast"
+
+    @override
+    def requires_command(self) -> str:
+        return "lxc"
 
-    command = 'lxc list --format json --fast'
     default = list
 
+    @override
     def process(self, output):
+        output = list(output)
         assert len(output) == 1
         return json.loads(output[0])

pyinfra/facts/mysql.py

@@ -1,20 +1,23 @@
-import re
+from __future__ import annotations
 
+import re
 from collections import defaultdict
 
-from pyinfra.api import FactBase
+from typing_extensions import override
+
+from pyinfra.api import FactBase, MaskString, QuoteString, StringCommand
 from pyinfra.api.util import try_int
 
 from .util.databases import parse_columns_and_rows
 
 
 def make_mysql_command(
-    database=None,
-    user=None,
-    password=None,
-    host=None,
-    port=None,
-    executable='mysql',
+    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]
 
@@ -27,35 +30,56 @@ def make_mysql_command(
 
     if password:
         # Quote the password as it may contain special characters
-        target_bits.append('-p"{0}"'.format(password))
+        target_bits.append(MaskString('-p"{0}"'.format(password)))
 
     if host:
-        target_bits.append('-h{0}'.format(host))
+        target_bits.append("-h{0}".format(host))
 
     if port:
-        target_bits.append('-P{0}'.format(port))
+        target_bits.append("-P{0}".format(port))
 
-    return ' '.join(target_bits)
+    return StringCommand(*target_bits)
 
 
-def make_execute_mysql_command(command, **mysql_kwargs):
-    return '{0} -Be "{1}"'.format(
+def make_execute_mysql_command(
+    command: str | StringCommand,
+    ignore_errors=False,
+    **mysql_kwargs,
+):
+    commands_bits = [
         make_mysql_command(**mysql_kwargs),
-        command.replace('"', '\\"'),
-    )
+        "-Be",
+        QuoteString(command),  # quote this whole item as a single shell argument
+    ]
+
+    if ignore_errors:
+        commands_bits.extend(["||", "true"])
+
+    return StringCommand(*commands_bits)
 
 
 class MysqlFactBase(FactBase):
     abstract = True
 
+    mysql_command: str
+    ignore_errors = False
+
+    @override
+    def requires_command(self, *args, **kwargs) -> str:
+        return "mysql"
+
+    @override
     def command(
         self,
         # Details for speaking to MySQL via `mysql` CLI via `mysql` CLI
-        mysql_user=None, mysql_password=None,
-        mysql_host=None, mysql_port=None,
-    ):
+        mysql_user=None,
+        mysql_password=None,
+        mysql_host=None,
+        mysql_port=None,
+    ) -> StringCommand:
         return make_execute_mysql_command(
             self.mysql_command,
+            ignore_errors=self.ignore_errors,
             user=mysql_user,
             password=mysql_password,
             host=mysql_host,
@@ -64,130 +88,142 @@ class MysqlFactBase(FactBase):
 
 
 class MysqlDatabases(MysqlFactBase):
-    '''
+    """
     Returns a dict of existing MySQL databases and associated data:
 
     .. code:: python
 
-        'mysql': {
-            'character_set': 'latin1',
-            'collation_name': 'latin1_swedish_ci'
-        },
-        ...
-    '''
+        {
+            "mysql": {
+                "character_set": "latin1",
+                "collation_name": "latin1_swedish_ci"
+            },
+        }
+    """
 
     default = dict
-    mysql_command = 'SELECT * FROM information_schema.SCHEMATA'
+    mysql_command = "SELECT * FROM information_schema.SCHEMATA"
 
+    @override
     def process(self, output):
         rows = parse_columns_and_rows(
-            output, '\t',
+            output,
+            "\t",
             title_parser=lambda title: title.lower(),
         )
 
         databases = {}
 
         for details in rows:
-            databases[details.pop('schema_name')] = {
-                'character_set': details['default_character_set_name'],
-                'collation_name': details['default_collation_name'],
+            databases[details.pop("schema_name")] = {
+                "character_set": details["default_character_set_name"],
+                "collation_name": details["default_collation_name"],
             }
 
         return databases
 
 
 class MysqlUsers(MysqlFactBase):
-    '''
+    """
     Returns a dict of MySQL ``user@host``'s and their associated data:
 
     .. code:: python
 
-        'user@host': {
-            'privileges': ['Alter', 'Grant'],
-            'max_connections': 5,
-            ...
-        },
-        ...
-    '''
+        {
+            "user@host": {
+                "privileges": ["Alter", "Grant"],
+                'max_connections': 5,
+                ...
+            },
+        }
+    """
 
     default = dict
-    mysql_command = 'SELECT * FROM mysql.user'
+    mysql_command = "SELECT * FROM mysql.user"
 
-    @staticmethod
-    def process(output):
-        rows = parse_columns_and_rows(output, '\t')
+    @override
+    def process(self, output):
+        rows = parse_columns_and_rows(output, "\t")
 
         users = {}
 
         for details in rows:
-            if details.get('Host') is None or details.get('User') is None:
+            if details.get("Host") is None or details.get("User") is None:
                 continue  # pragma: no cover
 
             privileges = []
 
             for key, value in list(details.items()):
-                if key.endswith('_priv') and details.pop(key) == 'Y':
-                    privileges.append(key.replace('_priv', ''))
+                if key.endswith("_priv") and details.pop(key) == "Y":
+                    privileges.append(key.replace("_priv", ""))
 
-                if key.startswith('max_'):
+                if key.startswith("max_"):
                     details[key] = try_int(value)
 
-                if key in ('password_expired', 'is_role'):
-                    details[key] = value == 'Y'
+                if key in ("password_expired", "is_role"):
+                    details[key] = value == "Y"
 
-            details['privileges'] = sorted(privileges)
+            details["privileges"] = sorted(privileges)
 
             # Attach the user in the format user@host
-            users['{0}@{1}'.format(
-                details.pop('User'), details.pop('Host'),
-            )] = details
+            users[
+                "{0}@{1}".format(
+                    details.pop("User"),
+                    details.pop("Host"),
+                )
+            ] = details
 
         return users
 
 
-MYSQL_GRANT_REGEX = re.compile(
-    r"^GRANT ([A-Z,\s]+) ON (\*|`[a-z_\\]+`\.\*|'[a-z_]+') TO '[a-z_]+'@'[a-z]+'(.*)",
+MYSQL_GRANT_REGEX = (
+    r"^GRANT ([A-Z,\s]+) ON ((?:\*|`[a-z_\\]+`)\.(?:\*|`[a-z_]+`)) "
+    r"TO `[A-Z0-9a-z_\-]+`@`(?:%|[A-Z0-9a-z_\.\-]+)`(.*)"
 )
 
 
 class MysqlUserGrants(MysqlFactBase):
-    '''
-    Returns a dict of ``<database>`.<table>`` with granted privileges for each:
+    """
+    Returns a dict of ``<database>`.<table>`` with a set of granted privileges for each:
 
     .. code:: python
 
-        '`pyinfra_stuff`.*': {
-            'privileges': [
-                'SELECT',
-                'INSERT'
-            ],
-            "with_grant_option": false
-        },
-        ...
-    '''
+        {
+            "`pyinfra_stuff`.*": {
+                "SELECT",
+                "INSERT",
+                "GRANT OPTION",
+            },
+        }
+    """
 
     default = dict
+    # Ignore errors as SHOW GRANTS will error if the user does not exist
+    ignore_errors = True
 
-    def command(
-        self, user,
-        hostname='localhost',
+    @override
+    def command(  # type: ignore[override]
+        self,
+        user,
+        hostname="localhost",
         # Details for speaking to MySQL via `mysql` CLI via `mysql` CLI
-        mysql_user=None, mysql_password=None,
-        mysql_host=None, mysql_port=None,
-    ):
+        mysql_user=None,
+        mysql_password=None,
+        mysql_host=None,
+        mysql_port=None,
+    ) -> StringCommand:
         self.mysql_command = 'SHOW GRANTS FOR "{0}"@"{1}"'.format(user, hostname)
 
-        return super(MysqlUserGrants, self).command(
-            mysql_user, mysql_password,
-            mysql_host, mysql_port,
+        return super().command(
+            mysql_user,
+            mysql_password,
+            mysql_host,
+            mysql_port,
         )
 
-    @staticmethod
-    def process(output):
-        database_table_privileges = defaultdict(lambda: {
-            'privileges': set(),
-            'with_grant_option': False,
-        })
+    @override
+    def process(self, output):
+        database_table_privileges = defaultdict(set)
 
         for line in output:
             matches = re.match(MYSQL_GRANT_REGEX, line)
@@ -197,13 +233,13 @@ class MysqlUserGrants(MysqlFactBase):
             privileges, database_table, extras = matches.groups()
 
             # MySQL outputs this pre-escaped
-            database_table = database_table.replace('\\\\', '\\')
+            database_table = database_table.replace("\\\\", "\\")
 
-            for privilege in privileges.split(','):
+            for privilege in privileges.split(","):
                 privilege = privilege.strip()
-                database_table_privileges[database_table]['privileges'].add(privilege)
+                database_table_privileges[database_table].add(privilege)
 
-            if 'WITH GRANT OPTION' in extras:
-                database_table_privileges[database_table]['with_grant_option'] = True
+            if "WITH GRANT OPTION" in extras:
+                database_table_privileges[database_table].add("GRANT OPTION")
 
         return database_table_privileges

pyinfra/facts/npm.py

@@ -1,30 +1,38 @@
 # encoding: utf8
+from __future__ import annotations
+
+from typing_extensions import override
 
 from pyinfra.api import FactBase
 
 from .util.packaging import parse_packages
 
-NPM_REGEX = r'^[└├]\─\─\s([a-zA-Z0-9\-]+)@([0-9\.]+)$'
+NPM_REGEX = r"^[└├]\─\─\s([a-zA-Z0-9\-]+)@([0-9\.]+)$"
 
 
 class NpmPackages(FactBase):
-    '''
+    """
     Returns a dict of installed npm packages globally or in a given directory:
 
     .. code:: python
 
-        'package_name': ['version'],
-        ...
-    '''
+        {
+            "package_name": ["version"],
+        }
+    """
 
-    command = 'npm list -g --depth=0'
     default = dict
 
+    @override
+    def requires_command(self, directory=None) -> str:
+        return "npm"
+
+    @override
     def command(self, directory=None):
         if directory:
-            return 'cd {0} && npm list -g --depth=0'.format(directory)
-        else:
-            return 'npm list -g --depth=0'
+            return ("cd {0} && npm list -g --depth=0").format(directory)
+        return "npm list -g --depth=0"
 
+    @override
     def process(self, output):
         return parse_packages(NPM_REGEX, output)