django-dbbackup 5.3.0__tar.gz → 5.4.0__tar.gz

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: django-dbbackup
-Version: 5.3.0
+Version: 5.4.0
 Summary: Management commands to help backup and restore a project database and media.
 Project-URL: Changelog, https://archmonger.github.io/django-dbbackup/latest/changelog/
 Project-URL: Documentation, https://archmonger.github.io/django-dbbackup

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/dbbackup/__init__.py

@@ -1,3 +1,3 @@
 """Management commands to help backup and restore a project database and media"""
 
-__version__ = "5.3.0"
+__version__ = "5.4.0"

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/dbbackup/db/base.py

@@ -40,9 +40,16 @@ if settings.CUSTOM_CONNECTOR_MAPPING:
     CONNECTOR_MAPPING.update(settings.CUSTOM_CONNECTOR_MAPPING)
 
 
-def get_connector(database_name=None):
+def get_connector(database_name: str | None = None, *, connector_path: str | None = None):
     """
     Get a connector from its database key in settings.
+
+    :param database_name: Database alias from ``DATABASES``, defaults to Django's default alias.
+    :param connector_path: Dotted path to the connector class to instantiate, for when the
+        connector is already known (e.g. from a backup's metadata file). When omitted it is
+        resolved from ``DBBACKUP_CONNECTORS[database_name]["CONNECTOR"]``, falling back to the
+        engine mapping. Either way the connector is always instantiated with the
+        ``DBBACKUP_CONNECTORS[database_name]`` options applied.
     """
     from django.db import DEFAULT_DB_ALIAS, connections
 
@@ -53,7 +60,8 @@ def get_connector(database_name=None):
     connector_settings = settings.CONNECTORS.get(database_name, {})
 
     # Use Django connector as fallback for unmapped engines
-    connector_path = connector_settings.get("CONNECTOR", CONNECTOR_MAPPING.get(engine, DEFAULT_CONNECTOR))
+    if not connector_path:
+        connector_path = connector_settings.get("CONNECTOR", CONNECTOR_MAPPING.get(engine, DEFAULT_CONNECTOR))
 
     connector_module_path = ".".join(connector_path.split(".")[:-1])
     module = import_module(connector_module_path)
@@ -71,6 +79,12 @@ class BaseDBConnector:
     extension = "dump"
     exclude: ClassVar[list[Any]] = []
 
+    #: Attributes which either hold a mutable class default or are bound to the very
+    #: list/dict objects the user put in ``DBBACKUP_CONNECTORS``. They are copied per
+    #: instance so mutating one connector can neither leak into another connector nor
+    #: into the user's settings.
+    MUTABLE_ATTRIBUTES: ClassVar[tuple[str, ...]] = ("exclude", "schemas", "env", "dump_env", "restore_env")
+
     def __init__(self, database_name=None, **kwargs):
         from django.db import DEFAULT_DB_ALIAS, connections
 
@@ -78,6 +92,12 @@ class BaseDBConnector:
         self.connection = connections[self.database_name]
         for attr, value in kwargs.items():
             setattr(self, attr.lower(), value)
+        for attr in self.MUTABLE_ATTRIBUTES:
+            value = getattr(self, attr, None)
+            if isinstance(value, list):
+                setattr(self, attr, list(value))
+            elif isinstance(value, dict):
+                setattr(self, attr, dict(value))
 
     @property
     def settings(self):

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/dbbackup/db/postgresql.py

@@ -9,6 +9,47 @@ from dbbackup.db.base import BaseCommandDBConnector
 
 logger = logging.getLogger("dbbackup.command")
 
+# Connection options understood by the PostgreSQL command line tools, mapped to
+# the ``libpq`` environment variable carrying each one. It mirrors
+# ``settings_to_cmd_args_env`` in ``django/db/backends/postgresql/client.py``,
+# so that ``pg_dump``, ``psql`` and ``pg_restore`` connect with the same TLS,
+# client certificate, password file and service settings as the ORM does.
+PG_OPTIONS_ENV_VARS: dict[str, str] = {
+    "sslmode": "PGSSLMODE",
+    "sslrootcert": "PGSSLROOTCERT",
+    "sslcert": "PGSSLCERT",
+    "sslkey": "PGSSLKEY",
+    "passfile": "PGPASSFILE",
+    "service": "PGSERVICE",
+}
+
+
+def _host_requires_uri_quoting(host: str) -> bool:
+    # Match *nix paths (e.g. /run/postgres) and Windows paths (e.g. C:\path\to\socket)
+    return host.startswith(("/", "@")) or (
+        len(host) >= 3 and host[0].isalpha() and host[1] == ":" and host[2] in ("/", "\\")
+    )
+
+
+def parse_postgres_options_env(connector: PgDumpBinaryConnector | PgDumpConnector) -> dict[str, str]:
+    """
+    Translate the ``OPTIONS`` setting of a Postgres connection into the ``libpq``
+    environment variables understood by the command line tools.
+
+    The options are passed through the environment rather than appended to the
+    connection URI because ``libpq`` expands ``%XX`` triplets only: a path
+    encoded with ``quote_plus`` semantics would reach the tools with its spaces
+    turned into ``+`` and would not be found.
+
+    Args:
+        connector: Database connector instance with settings
+
+    Returns:
+        dict: Environment variables to apply to the command
+    """
+    options = connector.settings.get("OPTIONS") or {}
+    return {env_var: str(options[option]) for option, env_var in PG_OPTIONS_ENV_VARS.items() if options.get(option)}
+
 
 def parse_postgres_settings(connector: PgDumpBinaryConnector | PgDumpConnector) -> tuple[str, dict[Any, Any]]:
     """
@@ -22,7 +63,11 @@ def parse_postgres_settings(connector: PgDumpBinaryConnector | PgDumpConnector)
     Returns:
         tuple: (cmd_part, environment_dict)
     """
-    host = connector.settings.get("HOST", "localhost")
+    host = connector.settings.get("HOST")
+    if host is None:
+        host = "localhost"
+    elif _host_requires_uri_quoting(host):
+        host = quote(host, safe="")
     cmd_part = connector.settings.get("NAME", "")
     user = quote(connector.settings.get("USER") or "")
     password = connector.settings.get("PASSWORD", -1)
@@ -30,7 +75,7 @@ def parse_postgres_settings(connector: PgDumpBinaryConnector | PgDumpConnector)
         host = f"@{host}"
     port = f":{connector.settings.get('PORT')}" if connector.settings.get("PORT") else ""
     cmd_part = f"--dbname=postgresql://{user}{host}{port}/{cmd_part}"
-    env = {}
+    env = parse_postgres_options_env(connector)
     if password is None:
         cmd_part += " --no-password"
     elif password not in ("", -1):
@@ -112,7 +157,17 @@ class PgDumpGisConnector(PgDumpConnector):
         if self.settings.get("PORT"):
             cmd += f" --port={shlex.quote(str(self.settings['PORT']))}"
 
-        return self.run_command(cmd)
+        # This is a separate psql invocation: it needs the same TLS settings as
+        # the restore it precedes, otherwise it cannot authenticate with a
+        # client certificate and the PostGIS activation fails.
+        env = {**self.restore_env, **parse_postgres_options_env(self)}
+        # "--no-password" only forbids the interactive prompt, libpq still
+        # reads PGPASSWORD, so the credentials of ADMIN_USER go there.
+        admin_password = self.settings.get("ADMIN_PASSWORD")
+        if admin_password:
+            env["PGPASSWORD"] = str(admin_password)
+
+        return self.run_command(cmd, env=env)
 
     def _restore_dump(self, dump):
         if self.settings.get("ADMIN_USER"):
@@ -191,6 +246,6 @@ class PgDumpBinaryConnector(PgDumpConnector):
             cmd.extend(self.restore_suffix if isinstance(self.restore_suffix, list) else [self.restore_suffix])
 
         cmd_str = " ".join(cmd)
-        stdout, _ = self.run_command(cmd_str, stdin=dump, env={**self.dump_env, **pg_env})
+        stdout, _ = self.run_command(cmd_str, stdin=dump, env={**self.restore_env, **pg_env})
 
         return stdout

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/dbbackup/management/commands/_base.py

@@ -85,6 +85,19 @@ class BaseDbBackupCommand(BaseCommand):
         level = 60 if self.quiet else LOGGING_VERBOSITY[int(self.verbosity)]
         self.logger.setLevel(level)
 
+        # Find or create a StreamHandler for console output so that
+        # --verbosity works regardless of the user's Django LOGGING
+        # configuration. Only add one handler to avoid duplicates.
+        for handler in self.logger.handlers:
+            if isinstance(handler, logging.StreamHandler):
+                handler.setLevel(level)
+                break
+        else:
+            handler = logging.StreamHandler(sys.stderr)
+            handler.setLevel(level)
+            handler.setFormatter(logging.Formatter("%(levelname)s %(message)s"))
+            self.logger.addHandler(handler)
+
     def _ask_confirmation(self):
         answer = input("Are you sure you want to continue? [Y/n] ")
         if answer.lower().startswith("n"):

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/dbbackup/management/commands/dbrestore.py

@@ -8,7 +8,6 @@ import io
 import json
 import os
 import sys
-from importlib import import_module
 
 from django.conf import settings
 from django.core.management.base import CommandError
@@ -227,11 +226,7 @@ class Command(BaseDbBackupCommand):
         if metadata and "connector" in metadata:
             connector_path = metadata["connector"]
             try:
-                module_name = ".".join(connector_path.split(".")[:-1])
-                class_name = connector_path.split(".")[-1]
-                module = import_module(module_name)
-                connector_class = getattr(module, class_name)
-                self.connector = connector_class(self.database_name)
+                self.connector = get_connector(self.database_name, connector_path=connector_path)
                 self.logger.info("Using connector from metadata: '%s'", connector_path)
             except (ImportError, AttributeError):
                 self.logger.warning(
@@ -250,8 +245,13 @@ class Command(BaseDbBackupCommand):
 
         if self.schemas:
             self.connector.schemas = self.schemas
-        self.connector.drop = not self.no_drop
-        self.connector.pg_options = self.pg_options
+        # Only override connector attributes when the flag was actually passed, otherwise
+        # options configured through DBBACKUP_CONNECTORS (e.g. DROP or PG_OPTIONS) are
+        # silently discarded in favour of the option defaults.
+        if self.no_drop:
+            self.connector.drop = False
+        if self.pg_options:
+            self.connector.pg_options = self.pg_options
         self.connector.restore_dump(input_file)
 
         # Send post_restore signal

{django_dbbackup-5.3.0 → django_dbbackup-5.4.0}/dbbackup/settings.py

@@ -29,7 +29,7 @@ FILENAME_TEMPLATE = getattr(
 )
 MEDIA_FILENAME_TEMPLATE = getattr(settings, "DBBACKUP_MEDIA_FILENAME_TEMPLATE", "{servername}-{datetime}.{extension}")
 GPG_ALWAYS_TRUST = getattr(settings, "DBBACKUP_GPG_ALWAYS_TRUST", False)
-GPG_RECIPIENT = GPG_ALWAYS_TRUST = getattr(settings, "DBBACKUP_GPG_RECIPIENT", None)
+GPG_RECIPIENT = getattr(settings, "DBBACKUP_GPG_RECIPIENT", None)
 STORAGES_DBBACKUP_ALIAS = "dbbackup"
 DJANGO_STORAGES = getattr(settings, "STORAGES", {})
 storage: dict = DJANGO_STORAGES.get(STORAGES_DBBACKUP_ALIAS, {})