pyinfra 2.9.1__py2.py3-none-any.whl → 3.0__py2.py3-none-any.whl

pyinfra/operations/postgresql.py

@@ -1,391 +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, logger
-from pyinfra.api import MaskString, StringCommand, operation
-from pyinfra.facts.postgresql import (
-    PostgresqlDatabases,
-    PostgresqlRoles,
-    make_execute_psql_command,
-    make_psql_command,
-)
 
-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, deprecated_for="postgres.role")
+def role(*args, **kwargs):
+    yield from postgres.role._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)
+@operation(is_idempotent=False, is_deprecated=True)
+def database(*args, **kwargs):
+    yield from postgres.database._inner(*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/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,15 +2,15 @@
 The Python module allows you to execute Python code within the context of a deploy.
 """
 
-from inspect import getfullargspec
+from __future__ import annotations
+
+from typing import Callable
 
-from pyinfra import logger
 from pyinfra.api import FunctionCommand, operation
-from pyinfra.api.util import get_call_location
 
 
-@operation(is_idempotent=False)
-def call(function, *args, **kwargs):
+@operation(is_idempotent=False, _set_in_op=False)
+def call(function: Callable, *args, **kwargs):
     """
     Execute a Python function within a deploy.
 
@@ -43,20 +43,11 @@ 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)
-def raise_exception(exception, *args, **kwargs):
+@operation(is_idempotent=False, _set_in_op=False)
+def raise_exception(exception: Exception, *args, **kwargs):
     """
     Raise a Python exception within a deploy.
 
@@ -76,8 +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]
 
-    kwargs.pop("state", None)
-    kwargs.pop("host", None)
     yield FunctionCommand(raise_exc, args, kwargs)

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,
+    )