backup-docker-to-local 1.0.0__tar.gz → 1.1.1__tar.gz

{backup_docker_to_local-1.0.0/src/backup_docker_to_local.egg-info → backup_docker_to_local-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backup-docker-to-local
-Version: 1.0.0
+Version: 1.1.1
 Summary: Backup Docker volumes to local with rsync and optional DB dumps.
 Author: Kevin Veen-Birkenbach
 License: AGPL-3.0-or-later

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "backup-docker-to-local"
-version = "1.0.0"
+version = "1.1.1"
 description = "Backup Docker volumes to local with rsync and optional DB dumps."
 readme = "README.md"
 requires-python = ">=3.9"

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1/src/backup_docker_to_local.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: backup-docker-to-local
-Version: 1.0.0
+Version: 1.1.1
 Summary: Backup Docker volumes to local with rsync and optional DB dumps.
 Author: Kevin Veen-Birkenbach
 License: AGPL-3.0-or-later

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/backup/app.py

@@ -51,7 +51,9 @@ def is_image_ignored(container: str, images_no_backup_required: list[str]) -> bo
     return any(pat in img for pat in images_no_backup_required)
 
 
-def volume_is_fully_ignored(containers: list[str], images_no_backup_required: list[str]) -> bool:
+def volume_is_fully_ignored(
+    containers: list[str], images_no_backup_required: list[str]
+) -> bool:
     """
     Skip file backup only if all containers linked to the volume are ignored.
     """
@@ -70,28 +72,27 @@ def requires_stop(containers: list[str], images_no_stop_required: list[str]) ->
             return True
     return False
 
-
 def backup_mariadb_or_postgres(
     *,
     container: str,
     volume_dir: str,
     databases_df: "pandas.DataFrame",
     database_containers: list[str],
-) -> bool:
+) -> tuple[bool, bool]:
     """
-    Returns True if the container is a DB container we handled.
+    Returns (is_db_container, dumped_any)
     """
     for img in ["mariadb", "postgres"]:
         if has_image(container, img):
-            backup_database(
+            dumped = backup_database(
                 container=container,
                 volume_dir=volume_dir,
                 db_type=img,
                 databases_df=databases_df,
                 database_containers=database_containers,
             )
-            return True
-    return False
+            return True, dumped
+    return False, False
 
 
 def _backup_dumps_for_volume(
@@ -100,21 +101,26 @@ def _backup_dumps_for_volume(
     vol_dir: str,
     databases_df: "pandas.DataFrame",
     database_containers: list[str],
-) -> bool:
+) -> tuple[bool, bool]:
     """
-    Create DB dumps for any mariadb/postgres containers attached to this volume.
-    Returns True if at least one dump was produced.
+    Returns (found_db_container, dumped_any)
     """
+    found_db = False
     dumped_any = False
+
     for c in containers:
-        if backup_mariadb_or_postgres(
+        is_db, dumped = backup_mariadb_or_postgres(
             container=c,
             volume_dir=vol_dir,
             databases_df=databases_df,
             database_containers=database_containers,
-        ):
+        )
+        if is_db:
+            found_db = True
+        if dumped:
             dumped_any = True
-    return dumped_any
+
+    return found_db, dumped_any
 
 
 def main() -> int:
@@ -135,18 +141,26 @@ def main() -> int:
         containers = containers_using_volume(volume_name)
 
         vol_dir = create_volume_directory(version_dir, volume_name)
-
-        # Old behavior: DB dumps are additional to file backups.
-        _backup_dumps_for_volume(
+            
+        found_db, dumped_any = _backup_dumps_for_volume(
             containers=containers,
             vol_dir=vol_dir,
             databases_df=databases_df,
             database_containers=args.database_containers,
         )
 
-        # dump-only: skip ALL file rsync backups
+        # dump-only logic:
         if args.dump_only:
-            continue
+            if found_db and not dumped_any:
+                print(
+                    f"WARNING: dump-only requested but no DB dump was produced for DB volume '{volume_name}'. Falling back to file backup.",
+                    flush=True,
+                )
+                # continue to file backup below
+            else:
+                # keep old behavior: skip file backups
+                continue
+
 
         # skip file backup if all linked containers are ignored
         if volume_is_fully_ignored(containers, args.images_no_backup_required):
@@ -178,6 +192,8 @@ def main() -> int:
     print("Finished volume backups.", flush=True)
 
     print("Handling Docker Compose services...", flush=True)
-    handle_docker_compose_services(args.compose_dir, args.docker_compose_hard_restart_required)
+    handle_docker_compose_services(
+        args.compose_dir, args.docker_compose_hard_restart_required
+    )
 
     return 0

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/backup/cli.py

@@ -2,22 +2,6 @@ from __future__ import annotations
 
 import argparse
 import os
-from pathlib import Path
-
-
-def _default_repo_name() -> str:
-    """
-    Derive the repository name from the folder that contains `src/`.
-
-    Expected layout:
-      <repo-root>/src/baudolo/backup/cli.py
-
-    => parents[0]=backup, [1]=baudolo, [2]=src, [3]=repo-root
-    """
-    try:
-        return Path(__file__).resolve().parents[3].name
-    except Exception:
-        return "backup-docker-to-local"
 
 
 def parse_args() -> argparse.Namespace:
@@ -41,7 +25,7 @@ def parse_args() -> argparse.Namespace:
 
     p.add_argument(
         "--repo-name",
-        default=_default_repo_name(),
+        default="backup-docker-to-local",
         help="Backup repo folder name under <backups-dir>/<machine-id>/ (default: git repo folder name)",
     )
     p.add_argument(
@@ -51,8 +35,8 @@ def parse_args() -> argparse.Namespace:
     )
     p.add_argument(
         "--backups-dir",
-        default="/Backups",
-        help="Backup root directory (default: /Backups)",
+        default="/var/lib/backup/",
+        help="Backup root directory (default: /var/lib/backup/)",
     )
 
     p.add_argument(

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/backup/compose.py

@@ -10,7 +10,9 @@ def hard_restart_docker_services(dir_path: str) -> None:
     subprocess.run(["docker-compose", "up", "-d"], cwd=dir_path, check=True)
 
 
-def handle_docker_compose_services(parent_directory: str, hard_restart_required: list[str]) -> None:
+def handle_docker_compose_services(
+    parent_directory: str, hard_restart_required: list[str]
+) -> None:
     for entry in os.scandir(parent_directory):
         if not entry.is_dir():
             continue

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/backup/db.py

@@ -3,11 +3,13 @@ from __future__ import annotations
 import os
 import pathlib
 import re
-
+import logging
 import pandas
 
 from .shell import BackupException, execute_shell_command
 
+log = logging.getLogger(__name__)
+
 
 def get_instance(container: str, database_containers: list[str]) -> str:
     if container in database_containers:
@@ -30,19 +32,25 @@ def backup_database(
     db_type: str,
     databases_df: "pandas.DataFrame",
     database_containers: list[str],
-) -> None:
+) -> bool:
+    """
+    Returns True if at least one dump file was produced, else False.
+    """
     instance_name = get_instance(container, database_containers)
     entries = databases_df.loc[databases_df["instance"] == instance_name]
     if entries.empty:
-        raise BackupException(f"No entry found for instance '{instance_name}'")
+        log.warning("No entry found for instance '%s' (skipping DB dump)", instance_name)
+        return False
 
     out_dir = os.path.join(volume_dir, "sql")
     pathlib.Path(out_dir).mkdir(parents=True, exist_ok=True)
 
-    for row in entries.iloc:
-        db_name = row["database"]
-        user = row["username"]
-        password = row["password"]
+    produced = False
+
+    for row in entries.itertuples(index=False):
+        db_name = row.database
+        user = row.username
+        password = row.password
 
         dump_file = os.path.join(out_dir, f"{db_name}.backup.sql")
 
@@ -52,13 +60,15 @@ def backup_database(
                 f"-u {user} -p{password} {db_name} > {dump_file}"
             )
             execute_shell_command(cmd)
+            produced = True
             continue
 
         if db_type == "postgres":
             cluster_file = os.path.join(out_dir, f"{instance_name}.cluster.backup.sql")
+
             if not db_name:
                 fallback_pg_dumpall(container, user, password, cluster_file)
-                return
+                return True
 
             try:
                 cmd = (
@@ -66,8 +76,15 @@ def backup_database(
                     f"pg_dump -U {user} -d {db_name} -h localhost > {dump_file}"
                 )
                 execute_shell_command(cmd)
+                produced = True
             except BackupException as e:
                 print(f"pg_dump failed: {e}", flush=True)
-                print(f"Falling back to pg_dumpall for instance '{instance_name}'", flush=True)
+                print(
+                    f"Falling back to pg_dumpall for instance '{instance_name}'",
+                    flush=True,
+                )
                 fallback_pg_dumpall(container, user, password, cluster_file)
+                produced = True
             continue
+
+    return produced

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/backup/docker.py

@@ -37,7 +37,9 @@ def change_containers_status(containers: list[str], status: str) -> None:
 def docker_volume_exists(volume: str) -> bool:
     # Avoid throwing exceptions for exists checks.
     try:
-        execute_shell_command(f"docker volume inspect {volume} >/dev/null 2>&1 && echo OK")
+        execute_shell_command(
+            f"docker volume inspect {volume} >/dev/null 2>&1 && echo OK"
+        )
         return True
     except Exception:
         return False

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/backup/volume.py

@@ -13,7 +13,9 @@ def get_storage_path(volume_name: str) -> str:
     return f"{path}/"
 
 
-def get_last_backup_dir(versions_dir: str, volume_name: str, current_backup_dir: str) -> str | None:
+def get_last_backup_dir(
+    versions_dir: str, volume_name: str, current_backup_dir: str
+) -> str | None:
     versions = sorted(os.listdir(versions_dir), reverse=True)
     for version in versions:
         candidate = os.path.join(versions_dir, version, volume_name, "files", "")
@@ -37,6 +39,8 @@ def backup_volume(versions_dir: str, volume_name: str, volume_dir: str) -> None:
         execute_shell_command(cmd)
     except BackupException as e:
         if "file has vanished" in str(e):
-            print("Warning: Some files vanished before transfer. Continuing.", flush=True)
+            print(
+                "Warning: Some files vanished before transfer. Continuing.", flush=True
+            )
         else:
             raise

backup_docker_to_local-1.1.1/src/baudolo/restore/__init__.py

@@ -0,0 +1 @@
+__all__ = ["main"]

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/restore/__main__.py

@@ -66,7 +66,9 @@ def main(argv: list[str] | None = None) -> int:
     # ------------------------------------------------------------------
     # mariadb
     # ------------------------------------------------------------------
-    p_mdb = sub.add_parser("mariadb", help="Restore a single MariaDB/MySQL-compatible dump")
+    p_mdb = sub.add_parser(
+        "mariadb", help="Restore a single MariaDB/MySQL-compatible dump"
+    )
     _add_common_backup_args(p_mdb)
     p_mdb.add_argument("--container", required=True)
     p_mdb.add_argument("--db-name", required=True)

backup_docker_to_local-1.1.1/src/baudolo/restore/db/__init__.py

@@ -0,0 +1 @@
+"""Database restore handlers (Postgres, MariaDB/MySQL)."""

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/restore/db/mariadb.py

@@ -23,7 +23,9 @@ exit 42
             raise RuntimeError("empty client detection output")
         return out
     except Exception as e:
-        print("ERROR: neither 'mariadb' nor 'mysql' found in container.", file=sys.stderr)
+        print(
+            "ERROR: neither 'mariadb' nor 'mysql' found in container.", file=sys.stderr
+        )
         raise e
 
 
@@ -47,7 +49,14 @@ def restore_mariadb_sql(
         # MariaDB 11 images may not contain the mysql binary at all.
         docker_exec(
             container,
-            [client, "-u", user, f"--password={password}", "-e", "SET FOREIGN_KEY_CHECKS=0;"],
+            [
+                client,
+                "-u",
+                user,
+                f"--password={password}",
+                "-e",
+                "SET FOREIGN_KEY_CHECKS=0;",
+            ],
         )
 
         result = docker_exec(
@@ -80,10 +89,19 @@ def restore_mariadb_sql(
 
         docker_exec(
             container,
-            [client, "-u", user, f"--password={password}", "-e", "SET FOREIGN_KEY_CHECKS=1;"],
+            [
+                client,
+                "-u",
+                user,
+                f"--password={password}",
+                "-e",
+                "SET FOREIGN_KEY_CHECKS=1;",
+            ],
         )
 
     with open(sql_path, "rb") as f:
-        docker_exec(container, [client, "-u", user, f"--password={password}", db_name], stdin=f)
+        docker_exec(
+            container, [client, "-u", user, f"--password={password}", db_name], stdin=f
+        )
 
     print(f"MariaDB/MySQL restore complete for db '{db_name}'.")

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/restore/files.py

@@ -6,7 +6,9 @@ import sys
 from .run import run, docker_volume_exists
 
 
-def restore_volume_files(volume_name: str, backup_files_dir: str, *, rsync_image: str) -> int:
+def restore_volume_files(
+    volume_name: str, backup_files_dir: str, *, rsync_image: str
+) -> int:
     if not os.path.isdir(backup_files_dir):
         print(f"ERROR: backup files dir not found: {backup_files_dir}", file=sys.stderr)
         return 2

{backup_docker_to_local-1.0.0 → backup_docker_to_local-1.1.1}/src/baudolo/seed/__main__.py

@@ -2,21 +2,24 @@ import pandas as pd
 import argparse
 import os
 
+
 def check_and_add_entry(file_path, instance, database, username, password):
     # Check if the file exists and is not empty
     if os.path.exists(file_path) and os.path.getsize(file_path) > 0:
         # Read the existing CSV file with header
-        df = pd.read_csv(file_path, sep=';')
+        df = pd.read_csv(file_path, sep=";")
     else:
         # Create a new DataFrame with columns if file does not exist
-        df = pd.DataFrame(columns=['instance', 'database', 'username', 'password'])
+        df = pd.DataFrame(columns=["instance", "database", "username", "password"])
 
     # Check if the entry exists and remove it
     mask = (
-        (df['instance'] == instance) &
-        ((df['database'] == database) |
-        (((df['database'].isna()) | (df['database'] == '')) & (database == ''))) &
-        (df['username'] == username)
+        (df["instance"] == instance)
+        & (
+            (df["database"] == database)
+            | (((df["database"].isna()) | (df["database"] == "")) & (database == ""))
+        )
+        & (df["username"] == username)
     )
 
     if not df[mask].empty:
@@ -26,25 +29,40 @@ def check_and_add_entry(file_path, instance, database, username, password):
         print("Adding new entry.")
 
     # Create a new DataFrame for the new entry
-    new_entry = pd.DataFrame([{'instance': instance, 'database': database, 'username': username, 'password': password}])
+    new_entry = pd.DataFrame(
+        [
+            {
+                "instance": instance,
+                "database": database,
+                "username": username,
+                "password": password,
+            }
+        ]
+    )
 
     # Add (or replace) the entry using concat
     df = pd.concat([df, new_entry], ignore_index=True)
 
     # Save the updated CSV file
-    df.to_csv(file_path, sep=';', index=False)
+    df.to_csv(file_path, sep=";", index=False)
+
 
 def main():
-    parser = argparse.ArgumentParser(description="Check and replace (or add) a database entry in a CSV file.")
+    parser = argparse.ArgumentParser(
+        description="Check and replace (or add) a database entry in a CSV file."
+    )
     parser.add_argument("file_path", help="Path to the CSV file")
     parser.add_argument("instance", help="Database instance")
     parser.add_argument("database", help="Database name")
     parser.add_argument("username", help="Username")
-    parser.add_argument("password", nargs='?', default="", help="Password (optional)")
+    parser.add_argument("password", nargs="?", default="", help="Password (optional)")
 
     args = parser.parse_args()
 
-    check_and_add_entry(args.file_path, args.instance, args.database, args.username, args.password)
+    check_and_add_entry(
+        args.file_path, args.instance, args.database, args.username, args.password
+    )
+
 
 if __name__ == "__main__":
     main()

backup_docker_to_local-1.0.0/src/baudolo/restore/__init__.py

@@ -1 +0,0 @@
-__all__ = ["main"]

backup_docker_to_local-1.0.0/src/baudolo/restore/db/__init__.py

@@ -1 +0,0 @@
-"""Database restore handlers (Postgres, MariaDB/MySQL)."""