dar-backup 0.6.16__py3-none-any.whl → 0.6.18__py3-none-any.whl

dar_backup/dar_backup_systemd.py

@@ -0,0 +1,119 @@
+from pathlib import Path
+import subprocess
+import argparse
+
+SERVICE_TEMPLATE = """[Unit]
+Description=dar-backup {mode}
+StartLimitIntervalSec=120
+StartLimitBurst=1
+
+[Service]
+Type=oneshot
+TimeoutSec=infinity
+RemainAfterExit=no
+ExecStart=/bin/bash -c '{exec_command}'
+"""
+
+TIMER_TEMPLATE = """[Unit]
+Description=dar-backup {mode} timer
+
+[Timer]
+OnCalendar={calendar}
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+"""
+
+CLEANUP_SERVICE_TEMPLATE = """[Unit]
+Description=cleanup up old DIFF & INCR backups
+StartLimitIntervalSec=120
+StartLimitBurst=1
+
+[Service]
+Type=oneshot
+TimeoutSec=60
+RemainAfterExit=no
+ExecStart=/bin/bash -c '{exec_command}'
+"""
+
+CLEANUP_TIMER = """[Unit]
+Description=dar-cleanup DIFF & INCR timer
+
+[Timer]
+OnCalendar=*-*-* 21:07:00
+
+[Install]
+WantedBy=timers.target
+"""
+
+TIMINGS = {
+    "FULL": "*-12-30 10:03:00",
+    "DIFF": "*-*-01 19:03:00",
+    "INCR": "*-*-04/3 19:03:00"
+}
+
+FLAGS = {
+    "FULL": "-F",
+    "DIFF": "-D",
+    "INCR": "-I"
+}
+
+def build_exec_command(venv, flag, dar_path=None, tool='dar-backup'):
+    if dar_path:
+        return f"PATH={dar_path}:$PATH && . {venv}/bin/activate && {tool} {flag} --verbose --log-stdout"
+    return f". {venv}/bin/activate && {tool} {flag} --verbose --log-stdout"
+
+def generate_service(mode, venv, dar_path):
+    exec_command = build_exec_command(venv, FLAGS[mode], dar_path)
+    return SERVICE_TEMPLATE.format(mode=mode, exec_command=exec_command)
+
+def generate_timer(mode):
+    return TIMER_TEMPLATE.format(mode=mode, calendar=TIMINGS[mode])
+
+def generate_cleanup_service(venv, dar_path):
+    exec_command = build_exec_command(venv, "", dar_path, tool='cleanup').strip()
+    return CLEANUP_SERVICE_TEMPLATE.format(exec_command=exec_command)
+
+def write_unit_file(path, filename, content):
+    file_path = path / filename
+    file_path.write_text(content)
+    print(f"Generated {filename}")
+
+def enable_and_start_unit(unit_name):
+    subprocess.run(["systemctl", "--user", "enable", unit_name], check=False)
+    subprocess.run(["systemctl", "--user", "start", unit_name], check=False)
+
+def write_unit_files(venv, dar_path, install=False):
+    output_path = Path.home() / ".config/systemd/user" if install else Path.cwd()
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    for mode in FLAGS:
+        service_name = f"dar-{mode.lower()}-backup.service"
+        timer_name = f"dar-{mode.lower()}-backup.timer"
+        write_unit_file(output_path, service_name, generate_service(mode, venv, dar_path))
+        write_unit_file(output_path, timer_name, generate_timer(mode))
+        print(f"  → Fires on: {TIMINGS[mode]}")
+
+    write_unit_file(output_path, "dar-cleanup.service", generate_cleanup_service(venv, dar_path))
+    write_unit_file(output_path, "dar-cleanup.timer", CLEANUP_TIMER)
+    print(f"  → Fires on: *-*-* 21:07:00")
+
+    if install:
+        for mode in FLAGS:
+            enable_and_start_unit(f"dar-{mode.lower()}-backup.timer")
+        enable_and_start_unit("dar-cleanup.timer")
+        subprocess.run(["systemctl", "--user", "daemon-reexec"], check=False)
+        subprocess.run(["systemctl", "--user", "daemon-reload"], check=False)
+        print("Systemd `dar-backup` units and timers installed and user daemon reloaded.")
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate systemd service and timer units for dar-backup.")
+    parser.add_argument("--venv",     required=True,       help="Path to the Python venv with dar-backup")
+    parser.add_argument("--dar-path",                      help="Optional path to dar binary's directory")
+    parser.add_argument("--install",  action="store_true", help="Install the units to ~/.config/systemd/user")
+    args = parser.parse_args()
+    write_unit_files(args.venv, args.dar_path, install=args.install)
+
+if __name__ == "__main__":
+    main()

dar_backup/installer.py

@@ -63,6 +63,7 @@ BACKUP_DEFINITION = '''
 --cache-directory-tagging
 '''
 
+
 def main():
     parser = argparse.ArgumentParser(
         description="Set up `dar-backup` on your system.",
@@ -72,7 +73,6 @@ def main():
         action="store_true",
         help="Deploy a simple config file, use ~/dar-backup/ for log file, archives and restore tests."
     )
-
     parser.add_argument(
         "-v", "--version",
         action="version",
@@ -85,38 +85,54 @@ def main():
         errors = []
         if os.path.exists(CONFIG_DIR):
             errors.append(f"Config directory '{CONFIG_DIR}' already exists.")
-
         if os.path.exists(DAR_BACKUP_DIR):
             errors.append(f"Directory '{DAR_BACKUP_DIR}' already exists.")
 
-        if len(errors) > 0:
+        if errors:
             for error in errors:
                 print(f"Error: {error}")
-            sys.exit(1) 
-
-        os.makedirs(DAR_BACKUP_DIR, exist_ok=False)
-        os.makedirs(os.path.join(DAR_BACKUP_DIR, "backups"), exist_ok=False)
-        os.makedirs(os.path.join(DAR_BACKUP_DIR, "restore"), exist_ok=False)
-        os.makedirs(CONFIG_DIR, exist_ok=False)
-        os.makedirs(os.path.join(CONFIG_DIR, "backup.d"), exist_ok=False)
-        print(f"Directories created: `{DAR_BACKUP_DIR}` and `{CONFIG_DIR}`")
-
-        script_dir = Path(__file__).parent
-        source_file = script_dir / "dar-backup.conf"
-        destination_file = Path(CONFIG_DIR) / "dar-backup.conf"
-        shutil.copy(source_file, destination_file)
-        print(f"Config file deployed to {destination_file}")
-
-
-        backup_definition = BACKUP_DEFINITION.replace("@@HOME_DIR@@", os.path.expanduser("~"))
-        with open(os.path.join(CONFIG_DIR, "backup.d", "default"), "w") as f:
-            f.write(backup_definition)
-        print(f"Default backup definition file deployed to {os.path.join(CONFIG_DIR, 'backup.d', 'default')}")
+            sys.exit(1)
+
+        try:
+            os.makedirs(DAR_BACKUP_DIR, exist_ok=False)
+            os.makedirs(os.path.join(DAR_BACKUP_DIR, "backups"), exist_ok=False)
+            os.makedirs(os.path.join(DAR_BACKUP_DIR, "restore"), exist_ok=False)
+            os.makedirs(CONFIG_DIR, exist_ok=False)
+            os.makedirs(os.path.join(CONFIG_DIR, "backup.d"), exist_ok=False)
+            print(f"Directories created: `{DAR_BACKUP_DIR}` and `{CONFIG_DIR}`")
+
+            script_dir = Path(__file__).parent
+            source_file = script_dir / "dar-backup.conf"
+            destination_file = Path(CONFIG_DIR) / "dar-backup.conf"
+
+            try:
+                shutil.copy2(source_file, destination_file)
+                print(f"Config file deployed to {destination_file}")
+            except Exception as e:
+                print(f"Error: Could not copy config file: {e}")
+                sys.exit(1)
+
+
+            backup_definition = BACKUP_DEFINITION.replace("@@HOME_DIR@@", os.path.expanduser("~"))
+
+            try:
+                with open(os.path.join(CONFIG_DIR, "backup.d", "default"), "w") as f:
+                    f.write(backup_definition)
+                print(f"Default backup definition file deployed to {os.path.join(CONFIG_DIR, 'backup.d', 'default')}")
+            except Exception as e:
+                print(f"Error: Could not write default backup definition: {e}")
+                sys.exit(1)
+        except Exception as e:
+            print(f"Installation failed: {e}")
+            sys.exit(1)
+
         print("1. Now run `manager --create` to create the catalog database.")
         print("2. Then you can run `dar-backup --full-backup` to create a backup.")
         print("3. List backups with `dar-backup --list`")
         print("4. List contents of a backup with `dar-backup --list-contents <backup-name>`")
 
+    sys.exit(0)
+
 
 if __name__ == "__main__":
     main()

dar_backup/manager.py

@@ -29,9 +29,12 @@ import sys
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
-from dar_backup.util import run_command
 from dar_backup.util import setup_logging
 from dar_backup.util import CommandResult
+from dar_backup.util import get_logger
+
+from dar_backup.command_runner import CommandRunner   
+from dar_backup.command_runner import CommandResult
 
 from datetime import datetime
 from time import time
@@ -44,6 +47,7 @@ SCRIPTDIRPATH = os.path.dirname(SCRIPTPATH)
 DB_SUFFIX = ".db"
 
 logger = None
+runner = None
 
 def show_more_help():
     help_text = f"""
@@ -66,7 +70,7 @@ def create_db(backup_def: str, config_settings: ConfigSettings):
     else:
         logger.info(f'Create catalog database: "{database_path}"')
         command = ['dar_manager', '--create' , database_path]
-        process = run_command(command)
+        process = runner.run(command)
         logger.debug(f"return code from 'db created': {process.returncode}")
         if process.returncode == 0:
             logger.info(f'Database created: "{database_path}"')
@@ -95,16 +99,19 @@ def list_catalogs(backup_def: str, config_settings: ConfigSettings) -> NamedTupl
     if not os.path.exists(database_path):
         error_msg = f'Database not found: "{database_path}"'
         logger.error(error_msg)
-        commandResult = CommandResult(
-        process=None,
-        stdout='',
-        stderr=error_msg,
-        returncode=1,
-        timeout=1,
-        command=[])
-        return commandResult
+        return CommandResult(1, '', error_msg)
+
+        # commandResult = CommandResult(
+        # process=None,
+        # stdout='',
+        # stderr=error_msg,
+        # returncode=1,
+        # timeout=1,
+        # command=[])
+
+        # return commandResult
     command = ['dar_manager', '--base', database_path, '--list']
-    process = run_command(command)
+    process = runner.run(command)
     stdout, stderr = process.stdout, process.stderr 
     if process.returncode != 0:
         logger.error(f'Error listing catalogs for: "{database_path}"')
@@ -132,7 +139,7 @@ def cat_no_for_name(archive: str, config_settings: ConfigSettings) -> int:
     for line in process.stdout.splitlines():
         #print(f"{line_no}: '{line}'")
         line_no += 1
-        search = re.search(f".*?(\d+)\s+.*?({archive}).*", line)
+        search = re.search(rf".*?(\d+)\s+.*?({archive}).*", line)
         if search:
             #print(f"FOUND: archive: {search.group(2)}, catalog #: '{search.group(1)}'")
             logger.info(f"Found archive: '{archive}', catalog #: '{search.group(1)}'")
@@ -156,7 +163,7 @@ def list_archive_contents(archive: str, config_settings: ConfigSettings) -> int
         logger.error(f"archive: '{archive}' not found in database: '{database_path}'")
         return 1
     command = ['dar_manager', '--base', database_path, '-u', f"{cat_no}"]
-    process = run_command(command)
+    process = runner.run(command)
     stdout, stderr = process.stdout, process.stderr 
     if process.returncode != 0:
         logger.error(f'Error listing catalogs for: "{database_path}"')
@@ -178,7 +185,7 @@ def list_catalog_contents(catalog_number: int, backup_def: str, config_settings:
         logger.error(f'Catalog database not found: "{database_path}"')
         return 1
     command = ['dar_manager', '--base', database_path, '-u', f"{catalog_number}"]
-    process = run_command(command)
+    process = runner.run(command)
     stdout, stderr = process.stdout, process.stderr 
     if process.returncode != 0:
         logger.error(f'Error listing catalogs for: "{database_path}"')
@@ -199,7 +206,7 @@ def find_file(file, backup_def, config_settings):
         logger.error(f'Database not found: "{database_path}"')
         return 1
     command = ['dar_manager', '--base', database_path, '-f', f"{file}"]
-    process = run_command(command)
+    process = runner.run(command)
     stdout, stderr = process.stdout, process.stderr 
     if process.returncode != 0:
         logger.error(f'Error finding file: {file} in: "{database_path}"')
@@ -234,7 +241,7 @@ def add_specific_archive(archive: str, config_settings: ConfigSettings, director
     logger.info(f'Add "{archive_path}" to catalog: "{database}"')
     
     command = ['dar_manager', '--base', database_path, "--add", archive_path, "-Q"]
-    process = run_command(command)
+    process = runner.run(command)
     stdout, stderr = process.stdout, process.stderr
 
     if process.returncode == 0:
@@ -338,7 +345,7 @@ def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> in
     cat_no:int = cat_no_for_name(archive, config_settings)
     if cat_no >= 0:
         command = ['dar_manager', '--base', database_path, "--delete", str(cat_no)]
-        process: CommandResult = run_command(command)
+        process: CommandResult = runner.run(command)
         logger.info(f"CommandResult: {process}")
     else:
         logger.warning(f"archive: '{archive}' not found in it's catalog database: {database_path}")
@@ -353,15 +360,7 @@ def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> in
         return 1    
 
 
-
-def main():
-    global logger 
-
-    MIN_PYTHON_VERSION = (3, 9)
-    if sys.version_info < MIN_PYTHON_VERSION:
-        sys.stderr.write(f"Error: This script requires Python {'.'.join(map(str, MIN_PYTHON_VERSION))} or higher.\n")
-        sys.exit(1)
-
+def build_arg_parser():
     parser = argparse.ArgumentParser(description="Creates/maintains `dar` database catalogs")
     parser.add_argument('-c', '--config-file', type=str, help="Path to 'dar-backup.conf'", default='~/.config/dar-backup/dar-backup.conf')
     parser.add_argument('--create-db', action='store_true', help='Create missing databases for all backup definitions')
@@ -380,11 +379,30 @@ def main():
     parser.add_argument('--more-help', action='store_true', help='Show extended help message')
     parser.add_argument('--version', action='store_true', help='Show version & license')
 
+    return parser
+
+
+
+
+def main():
+    global logger, runner 
+
+    MIN_PYTHON_VERSION = (3, 9)
+    if sys.version_info < MIN_PYTHON_VERSION:
+        sys.stderr.write(f"Error: This script requires Python {'.'.join(map(str, MIN_PYTHON_VERSION))} or higher.\n")
+        sys.exit(1)
+        return
+
+    parser = argparse.ArgumentParser(description="Creates/maintains `dar` database catalogs")
+    # [parser.add_argument(...) as before...]
+
+    parser = build_arg_parser()
     args = parser.parse_args()
 
     if args.more_help:
         show_more_help()
         sys.exit(0)
+        return
 
     if args.version:
         print(f"{SCRIPTNAME} {about.__version__}")
@@ -393,84 +411,93 @@ def main():
 THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW, not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 See section 15 and section 16 in the supplied "LICENSE" file.''')
         sys.exit(0)
+        return
 
-    # setup logging
     args.config_file = os.path.expanduser(os.path.expandvars(args.config_file))
     config_settings = ConfigSettings(args.config_file)
     if not os.path.dirname(config_settings.logfile_location):
         print(f"Directory for log file '{config_settings.logfile_location}' does not exist, exiting")
-        sys.exit(1) 
+        sys.exit(1)
+        return
 
-#    command_output_log = os.path.join(config_settings.logfile_location.removesuffix("dar-backup.log"), "dar-backup-commands.log")
     command_output_log = config_settings.logfile_location.replace("dar-backup.log", "dar-backup-commands.log")
     logger = setup_logging(config_settings.logfile_location, command_output_log, args.log_level, args.log_stdout)
+    command_logger = get_logger(command_output_logger=True)
+    runner = CommandRunner(logger=logger, command_logger=command_logger)
 
-
-    start_time=int(time())
+    start_time = int(time())
     logger.info(f"=====================================")
     logger.info(f"{SCRIPTNAME} started, version: {about.__version__}")
     logger.info(f"START TIME: {start_time}")
     logger.debug(f"`args`:\n{args}")
     logger.debug(f"`config_settings`:\n{config_settings}")
 
-
-    # Sanity checks before starting
+    # --- Sanity checks ---
     if args.add_dir and not args.add_dir.strip():
         logger.error("archive dir not given, exiting")
         sys.exit(1)
+        return
 
-    if args.add_specific_archive and not args.add_specific_archive.strip():
+    if args.add_specific_archive is not None and not args.add_specific_archive.strip():
         logger.error("specific archive to add not given, exiting")
         sys.exit(1)
+        return
 
     if args.remove_specific_archive and not args.remove_specific_archive.strip():
         logger.error("specific archive to remove not given, exiting")
         sys.exit(1)
+        return
 
     if args.add_specific_archive and args.remove_specific_archive:
         logger.error("you can't add and remove archives in the same operation, exiting")
         sys.exit(1)
+        return
 
     if args.add_dir and args.add_specific_archive:
         logger.error("you cannot add both a directory and an archive")
         sys.exit(1)
+        return
 
     if args.backup_def and not args.backup_def.strip():
         logger.error(f"No backup definition given to --backup-def")
+        sys.exit(1)
+        return
 
     if args.backup_def:
         backup_def_path = os.path.join(config_settings.backup_d_dir, args.backup_def)
         if not os.path.exists(backup_def_path):
             logger.error(f"Backup definition {args.backup_def} does not exist, exiting")
             sys.exit(1)
-
+            return
 
     if args.list_archive_contents and not args.list_archive_contents.strip():
         logger.error(f"--list-archive-contents <param> not given, exiting")
         sys.exit(1)
-
+        return
 
     if args.list_catalog_contents and not args.backup_def:
         logger.error(f"--list-catalog-contents requires the --backup-def, exiting")
         sys.exit(1)
+        return
 
     if args.find_file and not args.backup_def:
         logger.error(f"--find-file requires the --backup-def, exiting")
         sys.exit(1)
-    
-
+        return
 
-    # Modify config settings based on the arguments
+    # --- Modify settings ---
     if args.alternate_archive_dir:
         if not os.path.exists(args.alternate_archive_dir):
             logger.error(f"Alternate archive dir '{args.alternate_archive_dir}' does not exist, exiting")
             sys.exit(1)
+            return
         config_settings.backup_dir = args.alternate_archive_dir
 
-
+    # --- Functional logic ---
     if args.create_db:
         if args.backup_def:
             sys.exit(create_db(args.backup_def, config_settings))
+            return
         else:
             for root, dirs, files in os.walk(config_settings.backup_d_dir):
                 for file in files:
@@ -479,19 +506,19 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
                     result = create_db(current_backupdef, config_settings)
                     if result != 0:
                         sys.exit(result)
+                        return
 
     if args.add_specific_archive:
         sys.exit(add_specific_archive(args.add_specific_archive, config_settings))
+        return
 
     if args.add_dir:
         sys.exit(add_directory(args, config_settings))
-
+        return
 
     if args.remove_specific_archive:
         return remove_specific_archive(args.remove_specific_archive, config_settings)
 
-
-
     if args.list_catalogs:
         if args.backup_def:
             process = list_catalogs(args.backup_def, config_settings)
@@ -504,19 +531,22 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
                     if list_catalogs(current_backupdef, config_settings).returncode != 0:
                         result = 1
         sys.exit(result)
-
+        return
 
     if args.list_archive_contents:
         result = list_archive_contents(args.list_archive_contents, config_settings)
         sys.exit(result)
+        return
 
     if args.list_catalog_contents:
         result = list_catalog_contents(args.list_catalog_contents, args.backup_def, config_settings)
         sys.exit(result)
+        return
 
     if args.find_file:
         result = find_file(args.find_file, args.backup_def, config_settings)
         sys.exit(result)
+        return
 
 
 if __name__ == "__main__":

dar_backup/rich_progress.py

@@ -0,0 +1,101 @@
+import os
+import time
+from threading import Event
+from rich.console import Console, Group
+from rich.live import Live
+from rich.text import Text
+
+def is_terminal():
+    return Console().is_terminal
+
+def tail_log_file(log_path, stop_event, session_marker=None):
+    """Yields new lines from the log file, starting only after the session_marker is found."""
+    last_size = 0
+    marker_found = session_marker is None
+
+    while not stop_event.is_set():
+        if not os.path.exists(log_path):
+            time.sleep(0.5)
+            continue
+
+        try:
+            with open(log_path, "r") as f:
+                if last_size > os.path.getsize(log_path):
+                    f.seek(0)
+                else:
+                    f.seek(last_size)
+
+                while not stop_event.is_set():
+                    line = f.readline()
+                    if not line:
+                        break
+
+                    line = line.strip()
+                    last_size = f.tell()
+
+                    if not marker_found:
+                        if session_marker in line:
+                            marker_found = True
+                        continue
+
+                    yield line
+
+        except Exception as e:
+            print(f"[!] Error reading log: {e}")
+
+        time.sleep(0.5)
+
+def get_green_shade(step, max_width):
+    """Returns a green color from light to dark across the bar."""
+    start = 180
+    end = 20
+    value = int(start - ((start - end) * (step / max_width)))
+    return f"rgb(0,{value},0)"
+
+def show_log_driven_bar(log_path: str, stop_event: Event, session_marker: str, max_width=50):
+    console = Console()
+
+    if not console.is_terminal:
+        console.log("[~] Not a terminal — progress bar skipped.")
+        return
+
+    progress = 0
+    dir_count = 0
+    last_dir = "Waiting for directory..."
+
+
+
+    with Live(console=console, refresh_per_second=5) as live:
+        for line in tail_log_file(log_path, stop_event, session_marker):
+            lowered = line.lower()
+
+            updated = False
+
+            # Update directory name on "Inspecting"
+            if "inspecting directory" in lowered and "finished" not in lowered:
+                last_dir = line.split("Inspecting directory")[-1].strip()
+                updated = True
+
+            # Advance progress on "Finished"
+            if "finished inspecting directory" in lowered:
+                dir_count += 1
+                progress = (progress + 1) % (max_width + 1)
+                updated = True
+
+            if updated:
+                bar_text = ""
+                for i in range(max_width):
+                    if i < progress:
+                        color = get_green_shade(i, max_width)
+                        bar_text += f"[{color}]#[/{color}]"
+                    else:
+                        bar_text += "-"
+
+                bar = Text.from_markup(f"[white][{bar_text}][/white] [dim]Dirs: {dir_count}[/dim]")
+                dir_display = Text(f"📂 {last_dir}", style="dim")
+
+                live.update(Group(bar, dir_display))
+
+            if stop_event.is_set():
+                break
+