pyinfra 2.9.2__py2.py3-none-any.whl → 3.0b1__py2.py3-none-any.whl

pyinfra/operations/postgresql.py

@@ -1,391 +1,28 @@
-"""
-The PostgreSQL modules manage PostgreSQL databases, users and privileges.
+from pyinfra.api import operation
 
-Requires the ``psql`` CLI executable on the target host(s).
+from . import postgres
 
-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
 
-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, logger
-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)
 
-LEGACY_ARG_MAP = {
-    "postgresql_user": "psql_user",
-    "postgresql_password": "psql_password",
-    "postgresql_host": "psql_host",
-    "postgresql_port": "psql_port",
-}
 
+@operation(is_idempotent=False, is_deprecated=True)
+def database(*args, **kwargs):
+    yield from postgres.database._inner(*args, **kwargs)
 
-def _translate_legacy_args(func):
-    def decorated_func(*args, **kwargs):
-        for legacy_key, key in LEGACY_ARG_MAP.items():
-            if legacy_key in kwargs:
-                kwargs[key] = kwargs.pop(legacy_key)
-                logger.warning(
-                    (
-                        f"The `{legacy_key}` has been replaced "
-                        f"by `{key}` in `postgresql.*` operations."
-                    ),
-                )
-        return func(*args, **kwargs)
 
-    decorated_func._pyinfra_op = func
-    return decorated_func
+@operation(is_idempotent=False, is_deprecated=True)
+def dump(*args, **kwargs):
+    yield from postgres.dump._inner(*args, **kwargs)
 
 
-@operation(is_idempotent=False)
-@_translate_legacy_args
-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
-    """
-
-    yield make_execute_psql_command(
-        sql,
-        database=database,
-        user=psql_user,
-        password=psql_password,
-        host=psql_host,
-        port=psql_port,
-    )
-
-
-@operation
-@_translate_legacy_args
-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,
-            )
-            roles.pop(role)
-        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,
-        )
-        roles[role] = {
-            "super": superuser,
-            "createdb": createdb,
-            "createrole": createrole,
-        }
-    else:
-        host.noop("postgresql role {0} exists".format(role))
-
-
-@operation
-@_translate_legacy_args
-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,
-            )
-            current_databases.pop(database)
-        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,
-        )
-        current_databases[database] = {
-            "template": template,
-            "encoding": encoding,
-            "lc_collate": lc_collate,
-            "lc_ctype": lc_ctype,
-            "tablespace": tablespace,
-            "connection_limit": connection_limit,
-        }
-    else:
-        host.noop("postgresql database {0} exists".format(database))
-
-
-@operation(is_idempotent=False)
-@_translate_legacy_args
-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)
-@_translate_legacy_args
-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/python.py

@@ -2,14 +2,10 @@
 The Python module allows you to execute Python code within the context of a deploy.
 """
 
-from inspect import getfullargspec
-
-from pyinfra import logger
 from pyinfra.api import FunctionCommand, operation
-from pyinfra.api.util import get_call_location
 
 
-@operation(is_idempotent=False)
+@operation(is_idempotent=False, _set_in_op=False)
 def call(function, *args, **kwargs):
     """
     Execute a Python function within a deploy.
@@ -43,19 +39,10 @@ def call(function, *args, **kwargs):
 
     """
 
-    argspec = getfullargspec(function)
-    if "state" in argspec.args and "host" in argspec.args:
-        logger.warning(
-            "Callback functions used in `python.call` operations no "
-            f"longer take `state` and `host` arguments: {get_call_location(frame_offset=3)}",
-        )
-
-    kwargs.pop("state", None)
-    kwargs.pop("host", None)
     yield FunctionCommand(function, args, kwargs)
 
 
-@operation(is_idempotent=False)
+@operation(is_idempotent=False, _set_in_op=False)
 def raise_exception(exception, *args, **kwargs):
     """
     Raise a Python exception within a deploy.
@@ -78,6 +65,4 @@ def raise_exception(exception, *args, **kwargs):
     def raise_exc(*args, **kwargs):  # pragma: no cover
         raise exception(*args, **kwargs)
 
-    kwargs.pop("state", None)
-    kwargs.pop("host", None)
     yield FunctionCommand(raise_exc, args, kwargs)

pyinfra/operations/selinux.py

@@ -7,9 +7,7 @@ from pyinfra.facts.selinux import FileContext, FileContextMapping, SEBoolean, SE
 from pyinfra.facts.server import Which
 
 
-@operation(
-    pipeline_facts={"seboolean": "bool_name"},
-)
+@operation()
 def boolean(bool_name, value, persistent=False):
     """
     Set the specified SELinux boolean to the desired state.
@@ -41,14 +39,11 @@ def boolean(bool_name, value, persistent=False):
     if host.get_fact(SEBoolean, boolean=bool_name) != value:
         persist = "-P " if persistent else ""
         yield StringCommand("setsebool", f"{persist}{bool_name}", value)
-        host.create_fact(SEBoolean, kwargs={"boolean": bool_name}, data=value)
     else:
         host.noop(f"boolean '{bool_name}' already had the value '{value}'")
 
 
-@operation(
-    pipeline_facts={"filecontext": "path"},
-)
+@operation()
 def file_context(path, se_type):
     """
     Set the SELinux type for the specified path to the specified value.
@@ -70,18 +65,11 @@ def file_context(path, se_type):
     current = host.get_fact(FileContext, path=path) or {}
     if se_type != current.get("type", ""):
         yield StringCommand("chcon", "-t", se_type, QuoteString(path))
-        host.create_fact(
-            FileContext,
-            kwargs={"path": path},
-            data=dict(current, **{"type": se_type}),
-        )
     else:
         host.noop(f"file_context: '{path}' already had type '{se_type}'")
 
 
-@operation(
-    pipeline_facts={"filecontextmapping": "target"},
-)
+@operation()
 def file_context_mapping(target, se_type=None, present=True):
     """
     Set the SELinux file context mapping for paths matching the target.
@@ -108,29 +96,20 @@ def file_context_mapping(target, se_type=None, present=True):
         raise ValueError("se_type must have a valid value if present is set")
 
     current = host.get_fact(FileContextMapping, target=target)
-    kwargs = {"target": target}
     if present:
         option = "-a" if len(current) == 0 else ("-m" if current.get("type") != se_type else "")
         if option != "":
             yield StringCommand("semanage", "fcontext", option, "-t", se_type, QuoteString(target))
-            host.create_fact(
-                FileContextMapping,
-                kwargs=kwargs,
-                data=dict(current, **{"type": se_type}),
-            )
         else:
             host.noop(f"mapping for '{target}' -> '{se_type}' already present")
     else:
         if len(current) > 0:
             yield StringCommand("semanage", "fcontext", "-d", QuoteString(target))
-            host.create_fact(FileContextMapping, kwargs=kwargs, data={})
         else:
             host.noop(f"no existing mapping for '{target}'")
 
 
-@operation(
-    pipeline_facts={"which": "sepolicy"},
-)
+@operation()
 def port(protocol, port_num, se_type=None, present=True):
     """
     Set the SELinux type for the specified protocol and port.
@@ -178,9 +157,7 @@ def port(protocol, port_num, se_type=None, present=True):
             host.noop(f"setype for '{protocol}/{port_num}' is already unset")
 
     if (present and (option != "")) or (not present and (current != "")):
-        if direct_get:
-            host.create_fact(SEPort, kwargs={"protocol": protocol, "port": port_num}, data=new_type)
-        else:
+        if not direct_get:
             if protocol not in port_info:
                 port_info[protocol] = {}
             port_info[protocol][str(port_num)] = new_type