dar-backup 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

dar_backup/cleanup.py

@@ -24,24 +24,29 @@ import sys
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")))
 
 
-
 from datetime import datetime, timedelta
 from inputimeout import inputimeout, TimeoutOccurred
+from pathlib import Path
+from sys import stderr
 from time import time
 from typing import Dict, List, NamedTuple, Tuple
+import glob
 
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
 from dar_backup.util import list_backups
 from dar_backup.util import setup_logging
+from dar_backup.util import get_config_file
 from dar_backup.util import get_logger
 from dar_backup.util import requirements
 from dar_backup.util import show_version
 from dar_backup.util import get_invocation_command_line
 from dar_backup.util import print_aligned_settings
 from dar_backup.util import backup_definition_completer, list_archive_completer
+from dar_backup.util import is_archive_name_allowed
 from dar_backup.util import is_safe_filename
+from dar_backup.util import safe_remove_file
 from dar_backup.util import show_scriptname
 
 from dar_backup.command_runner import CommandRunner   
@@ -50,7 +55,73 @@ from dar_backup.command_runner import CommandResult
 logger = None 
 runner = None
 
-def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=None):
+def _delete_par2_files(
+    archive_name: str,
+    backup_dir: str,
+    config_settings: ConfigSettings = None,
+    backup_definition: str = None,
+    dry_run: bool = False,
+) -> None:
+    if config_settings and hasattr(config_settings, "get_par2_config"):
+        par2_config = config_settings.get_par2_config(backup_definition)
+    else:
+        par2_config = {
+            "par2_dir": None,
+            "par2_mode": None,
+        }
+
+    par2_dir = par2_config.get("par2_dir") or backup_dir
+    par2_dir = os.path.expanduser(os.path.expandvars(par2_dir))
+    if not os.path.isdir(par2_dir):
+        logger.warning(f"PAR2 directory not found, skipping cleanup: {par2_dir}")
+        return
+
+    par2_mode = (par2_config.get("par2_mode") or "per-slice").lower()
+
+    if par2_mode == "per-archive":
+        par2_glob = os.path.join(par2_dir, f"{archive_name}*.par2")
+        targets = glob.glob(par2_glob)
+        manifest_path = os.path.join(par2_dir, f"{archive_name}.par2.manifest.ini")
+        if os.path.exists(manifest_path):
+            targets.append(manifest_path)
+        if not targets:
+            logger.info("No par2 files matched the per-archive cleanup pattern.")
+            return
+        for file_path in sorted(set(targets)):
+            try:
+                if dry_run:
+                    logger.info(f"Dry run: would delete PAR2 file: {file_path}")
+                else:
+                    safe_remove_file(file_path, base_dir=Path(par2_dir))
+                    logger.info(f"Deleted PAR2 file: {file_path}")
+            except Exception as e:
+                logger.error(f"Error deleting PAR2 file {file_path}: {e}")
+        return
+
+    if par2_mode != "per-slice":
+        logger.error(f"Unsupported PAR2_MODE during cleanup: {par2_mode}")
+        return
+
+    par2_regex = re.compile(rf"^{re.escape(archive_name)}\.[0-9]+\.dar.*\.par2$")
+    files_deleted = False
+    for filename in sorted(os.listdir(par2_dir)):
+        if par2_regex.match(filename):
+            file_path = os.path.join(par2_dir, filename)
+            try:
+                if dry_run:
+                    logger.info(f"Dry run: would delete PAR2 file: {file_path}")
+                else:
+                    safe_remove_file(file_path, base_dir=Path(par2_dir))
+                    logger.info(f"Deleted PAR2 file: {file_path}")
+                    files_deleted = True
+            except Exception as e:
+                logger.error(f"Error deleting PAR2 file {file_path}: {e}")
+
+    if not files_deleted:
+        logger.info("No .par2 matched the regex for deletion.")
+
+
+def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=None, config_settings: ConfigSettings = None):
     """
     Delete backups older than the specified age in days.
     Only .dar and .par2 files are considered for deletion.
@@ -66,8 +137,9 @@ def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=Non
 
     archives_deleted = {}
 
+    dry_run = getattr(args, "dry_run", False) is True
     for filename in sorted(os.listdir(backup_dir)):
-        if not (filename.endswith('.dar') or filename.endswith('.par2')):
+        if not filename.endswith('.dar'):
             continue
         if backup_definition and not filename.startswith(backup_definition):
             continue
@@ -82,8 +154,11 @@ def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=Non
             if file_date < cutoff_date:
                 file_path = os.path.join(backup_dir, filename)
                 try:
-                    is_safe_filename(file_path) and os.remove(file_path)
-                    logger.info(f"Deleted {backup_type} backup: {file_path}")
+                    if dry_run:
+                        logger.info(f"Dry run: would delete {backup_type} backup: {file_path}")
+                    else:
+                        safe_remove_file(file_path, base_dir=Path(backup_dir))
+                        logger.info(f"Deleted {backup_type} backup: {file_path}")
                     archive_name = filename.split('.')[0]
                     if not archive_name in archives_deleted:
                         logger.debug(f"Archive name: '{archive_name}' added to catalog deletion list")
@@ -92,10 +167,17 @@ def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=Non
                     logger.error(f"Error deleting file {file_path}: {e}")
 
     for archive_name in archives_deleted.keys():
-        delete_catalog(archive_name, args)
+        if not is_archive_name_allowed(archive_name):
+            raise ValueError(f"Refusing unsafe archive name: {archive_name}")
+        archive_definition = archive_name.split('_')[0]
+        _delete_par2_files(archive_name, backup_dir, config_settings, archive_definition, dry_run=dry_run)
+        if dry_run:
+            logger.info(f"Dry run: would run manager to delete archive '{archive_name}'")
+        else:
+            delete_catalog(archive_name, args)
 
 
-def delete_archive(backup_dir, archive_name, args):
+def delete_archive(backup_dir, archive_name, args, config_settings: ConfigSettings = None):
     """
     Delete all .dar and .par2 files in the backup directory for the given archive name.
 
@@ -107,36 +189,30 @@ def delete_archive(backup_dir, archive_name, args):
     
     # Delete the specified .dar files according to the naming convention
     files_deleted = False
+    dry_run = getattr(args, "dry_run", False) is True
     for filename in sorted(os.listdir(backup_dir)):
         if archive_regex.match(filename):
             file_path = os.path.join(backup_dir, filename)
             try:
-                is_safe_filename(file_path) and os.remove(file_path)
-                logger.info(f"Deleted archive slice: {file_path}")
+                if dry_run:
+                    logger.info(f"Dry run: would delete archive slice: {file_path}")
+                else:
+                    is_safe_filename(file_path) and os.remove(file_path)
+                    logger.info(f"Deleted archive slice: {file_path}")
                 files_deleted = True
             except Exception as e:
                 logger.error(f"Error deleting archive slice {file_path}: {e}")
     
     if files_deleted:
-            delete_catalog(archive_name, args)
+            if dry_run:
+                logger.info(f"Dry run: would run manager to delete archive '{archive_name}'")
+            else:
+                delete_catalog(archive_name, args)
     else:
         logger.info("No .dar files matched the regex for deletion.")
 
-    # Delete associated .par2 files
-    par2_regex = re.compile(rf"^{re.escape(archive_name)}\.[0-9]+\.dar.*\.par2$")
-    files_deleted = False
-    for filename in sorted(os.listdir(backup_dir)):
-        if par2_regex.match(filename):
-            file_path = os.path.join(backup_dir, filename)
-            try:
-                is_safe_filename(file_path) and os.remove(file_path)
-                logger.info(f"Deleted PAR2 file: {file_path}")
-                files_deleted = True
-            except Exception as e:
-                logger.error(f"Error deleting PAR2 file {file_path}: {e}")
-
-    if not files_deleted:
-        logger.info("No .par2 matched the regex for deletion.")
+    archive_definition = archive_name.split('_')[0]
+    _delete_par2_files(archive_name, backup_dir, config_settings, archive_definition, dry_run=dry_run)
 
 
 def delete_catalog(catalog_name: str, args: NamedTuple) -> bool:
@@ -190,27 +266,48 @@ def main():
 
     parser = argparse.ArgumentParser(description="Cleanup old archives according to AGE configuration.")
     parser.add_argument('-d', '--backup-definition', help="Specific backup definition to cleanup.").completer = backup_definition_completer
-    parser.add_argument('-c', '--config-file', '-c', type=str, help="Path to 'dar-backup.conf'", default='~/.config/dar-backup/dar-backup.conf')
+    parser.add_argument('-c', '--config-file', '-c', type=str, help="Path to 'dar-backup.conf'", default=None)
     parser.add_argument('-v', '--version', action='store_true', help="Show version information.")
     parser.add_argument('--alternate-archive-dir', type=str, help="Cleanup in this directory instead of the default one.")
-    parser.add_argument('--cleanup-specific-archives', type=str, help="Comma separated list of archives to cleanup").completer = list_archive_completer 
+    parser.add_argument(
+        '--cleanup-specific-archives',
+        type=str,
+        nargs='?',
+        const="",
+        default=None,
+        help="Comma separated list of archives to cleanup",
+    ).completer = list_archive_completer 
+    parser.add_argument(
+        'cleanup_specific_archives_list',
+        nargs='*',
+        help=argparse.SUPPRESS,
+    ).completer = list_archive_completer
     parser.add_argument('-l', '--list', action='store_true', help="List available archives.")
     parser.add_argument('--verbose', action='store_true', help="Print various status messages to screen")
     parser.add_argument('--log-level', type=str, help="`debug` or `trace`, default is `info`", default="info")
     parser.add_argument('--log-stdout', action='store_true', help='also print log messages to stdout')
     parser.add_argument('--test-mode', action='store_true', help='Read envvars in order to run some pytest cases')
+    parser.add_argument('--dry-run', action='store_true', help='Show what would be deleted without removing files')
 
-    argcomplete.autocomplete(parser)
+    comp_line = os.environ.get("COMP_LINE", "")
+    only_archives = "--cleanup-specific-archives" in comp_line
+    argcomplete.autocomplete(parser, always_complete_options=not only_archives)
 
     args = parser.parse_args()
 
-    args.config_file = os.path.expanduser(os.path.expandvars(args.config_file))
-    
-
     if args.version:
         show_version()
         sys.exit(0)
 
+    config_settings_path = get_config_file(args)
+    if not (os.path.isfile(config_settings_path) and os.access(config_settings_path, os.R_OK)):
+        if args.test_mode or os.getenv("PYTEST_CURRENT_TEST"):
+            args.config_file = config_settings_path
+        else:
+            print(f"Config file {config_settings_path} must exist and be readable.", file=stderr)
+            raise SystemExit(127)
+    args.config_file = config_settings_path
+
     config_settings = ConfigSettings(args.config_file)
 
     start_time=int(time())
@@ -225,7 +322,6 @@ def main():
 
     start_msgs.append((f"{show_scriptname()}:", about.__version__))
 
-    logger.info(f"START TIME: {start_time}")
     logger.debug(f"Command line: {get_invocation_command_line()}")
     logger.debug(f"`args`:\n{args}")
     logger.debug(f"`config_settings`:\n{config_settings}")
@@ -239,6 +335,7 @@ def main():
     args.verbose and start_msgs.append(("Logfile backup count:", config_settings.logfile_backup_count))
     args.verbose and start_msgs.append(("--alternate-archive-dir:", args.alternate_archive_dir))
     args.verbose and start_msgs.append(("--cleanup-specific-archives:", args.cleanup_specific_archives)) 
+    args.verbose and start_msgs.append(("--dry-run:", args.dry_run))
 
     dangerous_keywords = ["--cleanup", "_FULL_"] # TODO: add more dangerous keywords
     print_aligned_settings(start_msgs, highlight_keywords=dangerous_keywords, quiet=not args.verbose)
@@ -258,16 +355,20 @@ def main():
     if args.cleanup_specific_archives is None and args.test_mode:
         logger.info("No --cleanup-specific-archives provided; skipping specific archive deletion in test mode.")
 
-    if args.cleanup_specific_archives:
-        logger.info(f"Cleaning up specific archives: {args.cleanup_specific_archives}")
-        archive_names = args.cleanup_specific_archives.split(',')
+    if args.cleanup_specific_archives or args.cleanup_specific_archives_list:
+        combined = []
+        if args.cleanup_specific_archives:
+            combined.extend(args.cleanup_specific_archives.split(','))
+        combined.extend(args.cleanup_specific_archives_list or [])
+        archive_names = [name.strip() for name in combined if name.strip()]
+        logger.info(f"Cleaning up specific archives: {', '.join(archive_names)}")
         for archive_name in archive_names:
             if "_FULL_" in archive_name:
                 if not confirm_full_archive_deletion(archive_name, args.test_mode):
                     continue
             archive_path = os.path.join(config_settings.backup_dir, archive_name.strip())
             logger.info(f"Deleting archive: {archive_path}")
-            delete_archive(config_settings.backup_dir, archive_name.strip(), args)
+            delete_archive(config_settings.backup_dir, archive_name.strip(), args, config_settings)
     elif args.list:
         list_backups(config_settings.backup_dir, args.backup_definition)
     else:
@@ -280,8 +381,22 @@ def main():
                     backup_definitions.append(file.split('.')[0])
 
         for definition in backup_definitions:
-            delete_old_backups(config_settings.backup_dir, config_settings.diff_age, 'DIFF', args, definition)
-            delete_old_backups(config_settings.backup_dir, config_settings.incr_age, 'INCR', args, definition)
+            delete_old_backups(
+                config_settings.backup_dir,
+                config_settings.diff_age,
+                'DIFF',
+                args,
+                backup_definition=definition,
+                config_settings=config_settings
+            )
+            delete_old_backups(
+                config_settings.backup_dir,
+                config_settings.incr_age,
+                'INCR',
+                args,
+                backup_definition=definition,
+                config_settings=config_settings
+            )
 
     # run POST scripts
     requirements('POSTREQ', config_settings)

dar_backup/command_runner.py

@@ -8,6 +8,10 @@ import os
 import re
 import shlex
 import sys
+try:
+    import termios
+except ImportError:
+    termios = None
 import tempfile
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
 from typing import List, Optional, Union
@@ -125,124 +129,153 @@ class CommandRunner:
         timeout: Optional[int] = None,
         check: bool = False,
         capture_output: bool = True,
-        text: bool = True
+        text: bool = True,
+        cwd: Optional[str] = None,
+        stdin: Optional[int] = subprocess.DEVNULL
     ) -> CommandResult:
-        self._text_mode = text 
+        self._text_mode = text
         timeout = timeout or self.default_timeout
 
-        cmd_sanitized = None
-
-        try:
-            cmd_sanitized = sanitize_cmd(cmd)
-        except ValueError as e:
-            stack = traceback.format_exc()
-            self.logger.error(f"Command sanitation failed: {e}")
-            return CommandResult(
-                returncode=-1,
-                note=f"Sanitizing failed: command: {' '.join(cmd)}",
-                stdout='',
-                stderr=str(e),
-                stack=stack,
-
-            )
-        finally:
-            cmd = cmd_sanitized
-
-        #command = f"Executing command: {' '.join(cmd)} (timeout={timeout}s)"
-        command = f"Executing command: {' '.join(shlex.quote(arg) for arg in cmd)} (timeout={timeout}s)"
-
-
-        self.command_logger.info(command)
-        self.logger.debug(command)
-
-        stdout_lines = []
-        stderr_lines = []
+        tty_fd = None
+        tty_file = None
+        saved_tty_attrs = None
+        if termios is not None:
+            try:
+                if os.path.exists("/dev/tty"):
+                    tty_file = open("/dev/tty")
+                    tty_fd = tty_file.fileno()
+                elif sys.stdin and sys.stdin.isatty():
+                    tty_fd = sys.stdin.fileno()
+                if tty_fd is not None:
+                    saved_tty_attrs = termios.tcgetattr(tty_fd)
+            except Exception:
+                tty_fd = None
+                saved_tty_attrs = None
+                if tty_file:
+                    tty_file.close()
+                    tty_file = None
 
         try:
-            process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE if capture_output else None,
-                stderr=subprocess.PIPE if capture_output else None,
-                text=False,
-                bufsize=-1
-            )
-        except Exception as e:
-            stack = traceback.format_exc()
-            return CommandResult(
-                returncode=-1,
-                stdout='',
-                stderr=str(e),
-                stack=stack
-            )
+            cmd_sanitized = None
 
-        def stream_output(stream, lines, level):
             try:
-                while True:
-                    chunk = stream.read(1024)
-                    if not chunk:
-                        break
-                    if self._text_mode:
-                        decoded = chunk.decode('utf-8', errors='replace')
-                        lines.append(decoded)
-                        self.command_logger.log(level, decoded.strip())
-                    else:
-                        lines.append(chunk)
-                        # Avoid logging raw binary data to prevent garbled logs
-            except Exception as e:
-                self.logger.warning(f"stream_output decode error: {e}")
+                cmd_sanitized = sanitize_cmd(cmd)
+            except ValueError as e:
+                stack = traceback.format_exc()
+                self.logger.error(f"Command sanitation failed: {e}")
+                return CommandResult(
+                    returncode=-1,
+                    note=f"Sanitizing failed: command: {' '.join(cmd)}",
+                    stdout='',
+                    stderr=str(e),
+                    stack=stack,
+
+                )
             finally:
-                stream.close()
+                cmd = cmd_sanitized
 
+            #command = f"Executing command: {' '.join(cmd)} (timeout={timeout}s)"
+            command = f"Executing command: {' '.join(shlex.quote(arg) for arg in cmd)} (timeout={timeout}s)"
 
 
-        threads = []
-        if capture_output and process.stdout:
-            t_out = threading.Thread(target=stream_output, args=(process.stdout, stdout_lines, logging.INFO))
-            t_out.start()
-            threads.append(t_out)
-        if capture_output and process.stderr:
-            t_err = threading.Thread(target=stream_output, args=(process.stderr, stderr_lines, logging.ERROR))
-            t_err.start()
-            threads.append(t_err)
-
-        try:
-            process.wait(timeout=timeout)
-        except subprocess.TimeoutExpired:
-            process.kill()
-            log_msg = f"Command timed out after {timeout} seconds: {' '.join(cmd)}:\n"
-            self.logger.error(log_msg)
-            return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines))
-        except Exception as e:
-            stack = traceback.format_exc()
-            log_msg = f"Command execution failed: {' '.join(cmd)} with error: {e}\n"
-            self.logger.error(log_msg)
-            return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines), stack)  
-
-        for t in threads:
-            t.join()
-
+            self.command_logger.info(command)
+            self.logger.debug(command)
 
+            stdout_lines = []
+            stderr_lines = []
 
-        if self._text_mode:
-            stdout_combined = ''.join(stdout_lines)
-            stderr_combined = ''.join(stderr_lines)
-        else:
-            stdout_combined = b''.join(stdout_lines)
-            stderr_combined = b''.join(stderr_lines)
+            try:
+                process = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE if capture_output else None,
+                    stderr=subprocess.PIPE if capture_output else None,
+                    stdin=stdin,
+                    text=False,
+                    bufsize=-1,
+                    cwd=cwd
+                )
+            except Exception as e:
+                stack = traceback.format_exc()
+                return CommandResult(
+                    returncode=-1,
+                    stdout='',
+                    stderr=str(e),
+                    stack=stack
+                )
+
+            def stream_output(stream, lines, level):
+                try:
+                    while True:
+                        chunk = stream.read(1024)
+                        if not chunk:
+                            break
+                        if self._text_mode:
+                            decoded = chunk.decode('utf-8', errors='replace')
+                            lines.append(decoded)
+                            self.command_logger.log(level, decoded.strip())
+                        else:
+                            lines.append(chunk)
+                            # Avoid logging raw binary data to prevent garbled logs
+                except Exception as e:
+                    self.logger.warning(f"stream_output decode error: {e}")
+                finally:
+                    stream.close()
+
+            threads = []
+            if capture_output and process.stdout:
+                t_out = threading.Thread(target=stream_output, args=(process.stdout, stdout_lines, logging.INFO))
+                t_out.start()
+                threads.append(t_out)
+            if capture_output and process.stderr:
+                t_err = threading.Thread(target=stream_output, args=(process.stderr, stderr_lines, logging.ERROR))
+                t_err.start()
+                threads.append(t_err)
 
+            try:
+                process.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                log_msg = f"Command timed out after {timeout} seconds: {' '.join(cmd)}:\n"
+                self.logger.error(log_msg)
+                return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines))
+            except Exception as e:
+                stack = traceback.format_exc()
+                log_msg = f"Command execution failed: {' '.join(cmd)} with error: {e}\n"
+                self.logger.error(log_msg)
+                return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines), stack)
+
+            for t in threads:
+                t.join()
+
+            if self._text_mode:
+                stdout_combined = ''.join(stdout_lines)
+                stderr_combined = ''.join(stderr_lines)
+            else:
+                stdout_combined = b''.join(stdout_lines)
+                stderr_combined = b''.join(stderr_lines)
+
+            if check and process.returncode != 0:
+                self.logger.error(f"Command failed with exit code {process.returncode}")
+                return CommandResult(
+                    process.returncode,
+                    stdout_combined,
+                    stderr_combined,
+                    stack=traceback.format_stack()
+                )
 
-        if check and process.returncode != 0:
-            self.logger.error(f"Command failed with exit code {process.returncode}")
             return CommandResult(
                 process.returncode,
-                stdout_combined,
-                stderr_combined,
-                stack=traceback.format_stack()
-            )
-
-        return CommandResult(
-            process.returncode,
                 stdout_combined,
                 stderr_combined
-        )
-
+            )
+        finally:
+            if termios is not None and saved_tty_attrs is not None and tty_fd is not None:
+                try:
+                    termios.tcsetattr(tty_fd, termios.TCSADRAIN, saved_tty_attrs)
+                except Exception:
+                    self.logger.debug("Failed to restore terminal attributes", exc_info=True)
+            if tty_file is not None:
+                try:
+                    tty_file.close()
+                except Exception:
+                    self.logger.debug("Failed to close /dev/tty handle", exc_info=True)