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

pyinfra/operations/postgresql.py

@@ -1,347 +1,30 @@
-"""
-The PostgreSQL modules manage PostgreSQL databases, users and privileges.
+from __future__ import annotations
 
-Requires the ``psql`` CLI executable on the target host(s).
+from pyinfra.api import operation
 
-All operations in this module take four optional arguments:
-    + ``psql_user``: the username to connect to postgresql to
-    + ``psql_password``: the password for the connecting user
-    + ``psql_host``: the hostname of the server to connect to
-    + ``psql_port``: the port of the server to connect to
+from . import postgres
 
-See example/postgresql.py for detailed example
 
-"""
+@operation(is_idempotent=False, is_deprecated=True, deprecated_for="postgres.sql")
+def sql(*args, **kwargs):
+    yield from postgres.sql._inner(*args, **kwargs)
 
-from pyinfra import host
-from pyinfra.api import MaskString, StringCommand, operation
-from pyinfra.facts.postgresql import (
-    PostgresqlDatabases,
-    PostgresqlRoles,
-    make_execute_psql_command,
-    make_psql_command,
-)
 
+@operation(is_idempotent=False, is_deprecated=True, deprecated_for="postgres.role")
+def role(*args, **kwargs):
+    yield from postgres.role._inner(*args, **kwargs)
 
-@operation(is_idempotent=False)
-def sql(
-    sql,
-    database=None,
-    # Details for speaking to PostgreSQL via `psql` CLI
-    psql_user=None,
-    psql_password=None,
-    psql_host=None,
-    psql_port=None,
-):
-    """
-    Execute arbitrary SQL against PostgreSQL.
 
-    + sql: SQL command(s) to execute
-    + database: optional database to execute against
-    + psql_*: global module arguments, see above
-    """
+@operation(is_idempotent=False, is_deprecated=True)
+def database(*args, **kwargs):
+    yield from postgres.database._inner(*args, **kwargs)
 
-    yield make_execute_psql_command(
-        sql,
-        database=database,
-        user=psql_user,
-        password=psql_password,
-        host=psql_host,
-        port=psql_port,
-    )
 
+@operation(is_idempotent=False, is_deprecated=True)
+def dump(*args, **kwargs):
+    yield from postgres.dump._inner(*args, **kwargs)
 
-@operation()
-def role(
-    role,
-    present=True,
-    password=None,
-    login=True,
-    superuser=False,
-    inherit=False,
-    createdb=False,
-    createrole=False,
-    replication=False,
-    connection_limit=None,
-    # Details for speaking to PostgreSQL via `psql` CLI
-    psql_user=None,
-    psql_password=None,
-    psql_host=None,
-    psql_port=None,
-):
-    """
-    Add/remove PostgreSQL roles.
 
-    + role: name of the role
-    + present: whether the role should be present or absent
-    + password: the password for the role
-    + login: whether the role can login
-    + superuser: whether role will be a superuser
-    + inherit: whether the role inherits from other roles
-    + createdb: whether the role is allowed to create databases
-    + createrole: whether the role is allowed to create new roles
-    + replication: whether this role is allowed to replicate
-    + connection_limit: the connection limit for the role
-    + psql_*: global module arguments, see above
-
-    Updates:
-        pyinfra will not attempt to change existing roles - it will either
-        create or drop roles, but not alter them (if the role exists this
-        operation will make no changes).
-
-    **Example:**
-
-    .. code:: python
-
-        postgresql.role(
-            name="Create the pyinfra PostgreSQL role",
-            role="pyinfra",
-            password="somepassword",
-            superuser=True,
-            login=True,
-            sudo_user="postgres",
-        )
-
-    """
-
-    roles = host.get_fact(
-        PostgresqlRoles,
-        psql_user=psql_user,
-        psql_password=psql_password,
-        psql_host=psql_host,
-        psql_port=psql_port,
-    )
-
-    is_present = role in roles
-
-    # User not wanted?
-    if not present:
-        if is_present:
-            yield make_execute_psql_command(
-                'DROP ROLE "{0}"'.format(role),
-                user=psql_user,
-                password=psql_password,
-                host=psql_host,
-                port=psql_port,
-            )
-        else:
-            host.noop("postgresql role {0} does not exist".format(role))
-        return
-
-    # If we want the user and they don't exist
-    if not is_present:
-        sql_bits = ['CREATE ROLE "{0}"'.format(role)]
-
-        for key, value in (
-            ("LOGIN", login),
-            ("SUPERUSER", superuser),
-            ("INHERIT", inherit),
-            ("CREATEDB", createdb),
-            ("CREATEROLE", createrole),
-            ("REPLICATION", replication),
-        ):
-            if value:
-                sql_bits.append(key)
-
-        if connection_limit:
-            sql_bits.append("CONNECTION LIMIT {0}".format(connection_limit))
-
-        if password:
-            sql_bits.append(MaskString("PASSWORD '{0}'".format(password)))
-
-        yield make_execute_psql_command(
-            StringCommand(*sql_bits),
-            user=psql_user,
-            password=psql_password,
-            host=psql_host,
-            port=psql_port,
-        )
-    else:
-        host.noop("postgresql role {0} exists".format(role))
-
-
-@operation()
-def database(
-    database,
-    present=True,
-    owner=None,
-    template=None,
-    encoding=None,
-    lc_collate=None,
-    lc_ctype=None,
-    tablespace=None,
-    connection_limit=None,
-    # Details for speaking to PostgreSQL via `psql` CLI
-    psql_user=None,
-    psql_password=None,
-    psql_host=None,
-    psql_port=None,
-):
-    """
-    Add/remove PostgreSQL databases.
-
-    + name: name of the database
-    + present: whether the database should exist or not
-    + owner: the PostgreSQL role that owns the database
-    + template: name of the PostgreSQL template to use
-    + encoding: encoding of the database
-    + lc_collate: lc_collate of the database
-    + lc_ctype: lc_ctype of the database
-    + tablespace: the tablespace to use for the template
-    + connection_limit: the connection limit to apply to the database
-    + psql_*: global module arguments, see above
-
-    Updates:
-        pyinfra will not attempt to change existing databases - it will either
-        create or drop databases, but not alter them (if the db exists this
-        operation will make no changes).
-
-    **Example:**
-
-    .. code:: python
-
-        postgresql.database(
-            name="Create the pyinfra_stuff database",
-            database="pyinfra_stuff",
-            owner="pyinfra",
-            encoding="UTF8",
-            sudo_user="postgres",
-        )
-
-    """
-
-    current_databases = host.get_fact(
-        PostgresqlDatabases,
-        psql_user=psql_user,
-        psql_password=psql_password,
-        psql_host=psql_host,
-        psql_port=psql_port,
-    )
-
-    is_present = database in current_databases
-
-    if not present:
-        if is_present:
-            yield make_execute_psql_command(
-                'DROP DATABASE "{0}"'.format(database),
-                user=psql_user,
-                password=psql_password,
-                host=psql_host,
-                port=psql_port,
-            )
-        else:
-            host.noop("postgresql database {0} does not exist".format(database))
-        return
-
-    # We want the database but it doesn't exist
-    if present and not is_present:
-        sql_bits = ['CREATE DATABASE "{0}"'.format(database)]
-
-        for key, value in (
-            ("OWNER", '"{0}"'.format(owner) if owner else owner),
-            ("TEMPLATE", template),
-            ("ENCODING", encoding),
-            ("LC_COLLATE", lc_collate),
-            ("LC_CTYPE", lc_ctype),
-            ("TABLESPACE", tablespace),
-            ("CONNECTION LIMIT", connection_limit),
-        ):
-            if value:
-                sql_bits.append("{0} {1}".format(key, value))
-
-        yield make_execute_psql_command(
-            StringCommand(*sql_bits),
-            user=psql_user,
-            password=psql_password,
-            host=psql_host,
-            port=psql_port,
-        )
-    else:
-        host.noop("postgresql database {0} exists".format(database))
-
-
-@operation(is_idempotent=False)
-def dump(
-    dest,
-    database=None,
-    # Details for speaking to PostgreSQL via `psql` CLI
-    psql_user=None,
-    psql_password=None,
-    psql_host=None,
-    psql_port=None,
-):
-    """
-    Dump a PostgreSQL database into a ``.sql`` file. Requires ``pg_dump``.
-
-    + dest: name of the file to dump the SQL to
-    + database: name of the database to dump
-    + psql_*: global module arguments, see above
-
-    **Example:**
-
-    .. code:: python
-
-        postgresql.dump(
-            name="Dump the pyinfra_stuff database",
-            dest="/tmp/pyinfra_stuff.dump",
-            database="pyinfra_stuff",
-            sudo_user="postgres",
-        )
-
-    """
-
-    yield StringCommand(
-        make_psql_command(
-            executable="pg_dump",
-            database=database,
-            user=psql_user,
-            password=psql_password,
-            host=psql_host,
-            port=psql_port,
-        ),
-        ">",
-        dest,
-    )
-
-
-@operation(is_idempotent=False)
-def load(
-    src,
-    database=None,
-    # Details for speaking to PostgreSQL via `psql` CLI
-    psql_user=None,
-    psql_password=None,
-    psql_host=None,
-    psql_port=None,
-):
-    """
-    Load ``.sql`` file into a database.
-
-    + src: the filename to read from
-    + database: name of the database to import into
-    + psql_*: global module arguments, see above
-
-    **Example:**
-
-    .. code:: python
-
-        postgresql.load(
-            name="Import the pyinfra_stuff dump into pyinfra_stuff_copy",
-            src="/tmp/pyinfra_stuff.dump",
-            database="pyinfra_stuff_copy",
-            sudo_user="postgres",
-        )
-
-    """
-
-    yield StringCommand(
-        make_psql_command(
-            database=database,
-            user=psql_user,
-            password=psql_password,
-            host=psql_host,
-            port=psql_port,
-        ),
-        "<",
-        src,
-    )
+@operation(is_idempotent=False, is_deprecated=True)
+def load(*args, **kwargs):
+    yield from postgres.load._inner(*args, **kwargs)

pyinfra/operations/puppet.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 from pyinfra.api import operation
 
 
 @operation(is_idempotent=False)
-def agent(server=None, port=None):
+def agent(server: str | None = None, port: int | None = None):
     """
     Run puppet agent
 

pyinfra/operations/python.py

@@ -2,11 +2,15 @@
 The Python module allows you to execute Python code within the context of a deploy.
 """
 
+from __future__ import annotations
+
+from typing import Callable
+
 from pyinfra.api import FunctionCommand, operation
 
 
 @operation(is_idempotent=False, _set_in_op=False)
-def call(function, *args, **kwargs):
+def call(function: Callable, *args, **kwargs):
     """
     Execute a Python function within a deploy.
 
@@ -43,7 +47,7 @@ def call(function, *args, **kwargs):
 
 
 @operation(is_idempotent=False, _set_in_op=False)
-def raise_exception(exception, *args, **kwargs):
+def raise_exception(exception: Exception, *args, **kwargs):
     """
     Raise a Python exception within a deploy.
 
@@ -63,6 +67,6 @@ def raise_exception(exception, *args, **kwargs):
     """
 
     def raise_exc(*args, **kwargs):  # pragma: no cover
-        raise exception(*args, **kwargs)
+        raise exception(*args, **kwargs)  # type: ignore[operator]
 
     yield FunctionCommand(raise_exc, args, kwargs)

pyinfra/operations/selinux.py

@@ -1,19 +1,36 @@
 """
 Provides operations to set SELinux file contexts, booleans and port types.
 """
+
+from __future__ import annotations
+
+from enum import Enum
+
 from pyinfra import host
-from pyinfra.api import QuoteString, StringCommand, operation
+from pyinfra.api import OperationValueError, QuoteString, StringCommand, operation
 from pyinfra.facts.selinux import FileContext, FileContextMapping, SEBoolean, SEPort, SEPorts
 from pyinfra.facts.server import Which
 
 
+class Boolean(Enum):
+    ON = "on"
+    OFF = "off"
+
+
+class Protocol(Enum):
+    UDP = "udp"
+    TCP = "tcp"
+    SCTP = "sctp"
+    DCCP = "dccp"
+
+
 @operation()
-def boolean(bool_name, value, persistent=False):
+def boolean(bool_name: str, value: Boolean, persistent=False):
     """
     Set the specified SELinux boolean to the desired state.
 
     + boolean: name of an SELinux boolean
-    + state: 'on' or 'off'
+    + value: desired state of the boolean
     + persistent: whether to write updated policy or not
 
     Note: This operation requires root privileges.
@@ -25,26 +42,31 @@ def boolean(bool_name, value, persistent=False):
         selinux.boolean(
             name='Allow Apache to connect to LDAP server',
             'httpd_can_network_connect',
-            'on',
+            Boolean.ON,
             persistent=True
         )
     """
-    _valid_states = ["on", "off"]
 
-    if value not in _valid_states:
-        raise ValueError(
-            f'\'value\' must be one of \'{",".join(_valid_states)}\' but found \'{value}\'',
-        )
+    value_str: str
+    if value in ["on", "off"]:  # compatibility with the old version
+        assert isinstance(value, str)
+        value_str = value
+    elif value is Boolean.ON:
+        value_str = "on"
+    elif value is Boolean.OFF:
+        value_str = "off"
+    else:
+        raise OperationValueError(f"Invalid value '{value}' for boolean operation")
 
-    if host.get_fact(SEBoolean, boolean=bool_name) != value:
+    if host.get_fact(SEBoolean, boolean=bool_name) != value_str:
         persist = "-P " if persistent else ""
-        yield StringCommand("setsebool", f"{persist}{bool_name}", value)
+        yield StringCommand("setsebool", f"{persist}{bool_name}", value_str)
     else:
-        host.noop(f"boolean '{bool_name}' already had the value '{value}'")
+        host.noop(f"boolean '{bool_name}' already had the value '{value_str}'")
 
 
 @operation()
-def file_context(path, se_type):
+def file_context(path: str, se_type: str):
     """
     Set the SELinux type for the specified path to the specified value.
 
@@ -70,7 +92,7 @@ def file_context(path, se_type):
 
 
 @operation()
-def file_context_mapping(target, se_type=None, present=True):
+def file_context_mapping(target: str, se_type: str | None = None, present=True):
     """
     Set the SELinux file context mapping for paths matching the target.
 
@@ -110,7 +132,7 @@ def file_context_mapping(target, se_type=None, present=True):
 
 
 @operation()
-def port(protocol, port_num, se_type=None, present=True):
+def port(protocol: Protocol | str, port_num: int, se_type: str | None = None, present=True):
     """
     Set the SELinux type for the specified protocol and port.
 
@@ -127,12 +149,16 @@ def port(protocol, port_num, se_type=None, present=True):
 
         selinux.port(
             name='Allow Apache to provide service on port 2222',
-            'tcp',
+            Protocol.TCP,
             2222,
             'http_port_t',
         )
     """
 
+    if protocol is Protocol:
+        assert isinstance(protocol, Protocol)
+        protocol = protocol.value
+
     if present and (se_type is None):
         raise ValueError("se_type must have a valid value if present is set")