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

dar_backup/__about__.py

@@ -1 +1 @@
-__version__ = "0.6.16"
+__version__ = "0.6.18"

dar_backup/cleanup.py

@@ -27,16 +27,16 @@ from typing import Dict, List, NamedTuple
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
-from dar_backup.util import extract_error_lines
 from dar_backup.util import list_backups
-from dar_backup.util import run_command
 from dar_backup.util import setup_logging
+from dar_backup.util import get_logger
+from dar_backup.util import requirements
 
-from dar_backup.util import CommandResult   
-
-
+from dar_backup.command_runner import CommandRunner   
+from dar_backup.command_runner import CommandResult
 
 logger = None 
+runner = None
 
 def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=None):
     """
@@ -134,7 +134,7 @@ def delete_catalog(catalog_name: str, args: NamedTuple) -> bool:
     command = [f"manager", "--remove-specific-archive", catalog_name, "--config-file", args.config_file, '--log-level', 'debug', '--log-stdout']
     logger.info(f"Deleting catalog '{catalog_name}' using config file: '{args.config_file}'")
     try:
-        result:CommandResult = run_command(command)
+        result:CommandResult = runner.run(command)
         if result.returncode == 0:
             logger.info(f"Deleted catalog '{catalog_name}', using config file: '{args.config_file}'")
             logger.debug(f"Stdout: manager.py --remove-specific-archive output:\n{result.stdout}")
@@ -158,8 +158,32 @@ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW,
 See section 15 and section 16 in the supplied "LICENSE" file.''')
 
 
+def confirm_full_archive_deletion(archive_name: str, test_mode=False) -> bool:
+    try:
+        if test_mode:
+            confirmation = os.environ.get("CLEANUP_TEST_DELETE_FULL")
+            if confirmation is None:
+                raise RuntimeError("envvar 'CLEANUP_TEST_DELETE_FULL' not set")
+            print(f"Simulated confirmation for FULL archive: {confirmation}")
+        else:
+            confirmation = inputimeout(
+                prompt=f"Are you sure you want to delete the FULL archive '{archive_name}'? (yes/no): ",
+                timeout=30)
+        if confirmation is None:
+            logger.info(f"No confirmation received for FULL archive: {archive_name}. Skipping deletion.")
+            return False
+        return confirmation.strip().lower() == "yes"
+    except TimeoutOccurred:
+        logger.info(f"Timeout waiting for confirmation for FULL archive: {archive_name}. Skipping deletion.")
+        return False
+    except KeyboardInterrupt:
+        logger.info(f"User interrupted confirmation for FULL archive: {archive_name}. Skipping deletion.")
+        return False
+    
+
+
 def main():
-    global logger
+    global logger, runner
 
     parser = argparse.ArgumentParser(description="Cleanup old archives according to AGE configuration.")
     parser.add_argument('-d', '--backup-definition', help="Specific backup definition to cleanup.")
@@ -188,7 +212,8 @@ def main():
 #    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)
 
     logger.info(f"=====================================")
     logger.info(f"cleanup.py started, version: {about.__version__}")
@@ -205,21 +230,9 @@ def main():
     args.verbose and (print(f"--alternate-archive-dir:    {args.alternate_archive_dir}"))
     args.verbose and (print(f"--cleanup-specific-archives:{args.cleanup_specific_archives}")) 
 
-    # run PREREQ scripts
-    if 'PREREQ' in config_settings.config:
-        for key in sorted(config_settings.config['PREREQ'].keys()):
-            script = config_settings.config['PREREQ'][key]
-            try:
-                result = subprocess.run(script, shell=True, check=True)
-                logger.info(f"PREREQ {key}: '{script}' run, return code: {result.returncode}")
-                logger.info(f"PREREQ stdout:\n{result.stdout}")
-            except subprocess.CalledProcessError as e:
-                logger.error(f"Error executing {key}: '{script}': {e}")
-                if result:
-                    logger.error(f"PREREQ stderr:\n{result.stderr}")
-                print(f"Error executing {script}: {e}") 
-                sys.exit(1)
 
+    # run PREREQ scripts
+    requirements('PREREQ', config_settings)
 
     if args.alternate_archive_dir:
         if not os.path.exists(args.alternate_archive_dir):
@@ -230,37 +243,15 @@ def main():
             sys.exit(1) 
         config_settings.backup_dir = args.alternate_archive_dir
 
+    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(',')
         for archive_name in archive_names:
             if "_FULL_" in archive_name:
-                try:
-                    try:
-                        # used for pytest cases
-                        if args.test_mode:
-                            confirmation = os.environ.get("CLEANUP_TEST_DELETE_FULL")
-                            if confirmation == None:
-                                raise RuntimeError("envvar 'CLEANUP_TEST_DELETE_FULL' not set")
-                            
-                        else:
-                            confirmation = inputimeout(
-                                prompt=f"Are you sure you want to delete the FULL archive '{archive_name}'? (yes/no): ",
-                                timeout=30)
-                        if confirmation == None:
-                            continue
-                        else:
-                            confirmation = confirmation.strip().lower()
-                    except TimeoutOccurred:
-                        logger.info(f"Timeout waiting for confirmation for FULL archive: {archive_name}. Skipping deletion.")
-                        continue
-                except KeyboardInterrupt:
-                    logger.info(f"User interrupted confirmation for FULL archive: {archive_name}. Skipping deletion.")
-                    continue
-
-                if confirmation != 'yes':
-                    logger.info(f"User did not answer 'yes' to confirm deletion of FULL archive: {archive_name}. Skipping deletion.")
+                if not confirm_full_archive_deletion(archive_name, args.test_mode):
                     continue
             logger.info(f"Deleting archive: {archive_name}")
             delete_archive(config_settings.backup_dir, archive_name.strip(), args)
@@ -279,19 +270,13 @@ def main():
             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)
 
+    # run POST scripts
+    requirements('POSTREQ', config_settings)
+
 
     end_time=int(time())
     logger.info(f"END TIME: {end_time}")
-
-#    error_lines = extract_error_lines(config_settings.logfile_location, start_time, end_time)
-#    if len(error_lines) > 0:
-#        args.verbose and print("\033[1m\033[31mErrors\033[0m encountered")
-#        for line in error_lines:
-#            args.verbose and print(line)
-#        sys.exit(1)
-#    else:
-#        args.verbose and print("\033[1m\033[32mSUCCESS\033[0m No errors encountered")
-#        sys.exit(0)
+    sys.exit(0)
 
 if __name__ == "__main__":
     main()

dar_backup/command_runner.py

@@ -0,0 +1,81 @@
+import subprocess
+import logging
+import threading
+import os
+import sys
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
+from typing import List, Optional
+
+class CommandResult:
+    def __init__(self, returncode: int, stdout: str, stderr: str):
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+    def __repr__(self):
+        return f"<CommandResult returncode={self.returncode}>"
+
+class CommandRunner:
+    def __init__(
+        self,
+        logger: Optional[logging.Logger] = None,
+        command_logger: Optional[logging.Logger] = None,
+        default_timeout: int = 30
+    ):
+        self.logger = logger or logging.getLogger(__name__)
+        self.command_logger = command_logger or self.logger
+        self.default_timeout = default_timeout
+
+    def run(
+        self,
+        cmd: List[str],
+        *,
+        timeout: Optional[int] = None,
+        check: bool = False,
+        capture_output: bool = True,
+        text: bool = True
+    ) -> CommandResult:
+        timeout = timeout or self.default_timeout
+        self.logger.debug(f"Executing command: {' '.join(cmd)} (timeout={timeout}s)")
+
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE if capture_output else None,
+            stderr=subprocess.PIPE if capture_output else None,
+            text=text,
+            bufsize=1
+        )
+
+        stdout_lines = []
+        stderr_lines = []
+
+        def stream_output(stream, lines, level):
+            for line in iter(stream.readline, ''):
+                lines.append(line)
+                self.command_logger.log(level, line.strip())
+            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()
+            self.logger.error(f"Command timed out: {' '.join(cmd)}")
+            return CommandResult(-1, ''.join(stdout_lines), ''.join(stderr_lines))
+
+        for t in threads:
+            t.join()
+
+        if check and process.returncode != 0:
+            self.logger.error(f"Command failed with exit code {process.returncode}")
+
+        return CommandResult(process.returncode, ''.join(stdout_lines), ''.join(stderr_lines))

dar_backup/config_settings.py

@@ -63,7 +63,13 @@ class ConfigSettings:
             self.diff_age = int(self.config['AGE']['DIFF_AGE'])
             self.incr_age = int(self.config['AGE']['INCR_AGE'])
             self.error_correction_percent = int(self.config['PAR2']['ERROR_CORRECTION_PERCENT'])
-            self.par2_enabled = self.config['PAR2']['ENABLED'].lower() in ('true', '1', 'yes')
+            val = self.config['PAR2']['ENABLED'].strip().lower()
+            if val in ('true', '1', 'yes'):
+                self.par2_enabled = True
+            elif val in ('false', '0', 'no'):
+                self.par2_enabled = False
+            else:
+                raise ValueError(f"Invalid boolean value for 'ENABLED' in [PAR2]: '{val}'")
             
             # Ensure the directories exist
             Path(self.backup_dir).mkdir(parents=True, exist_ok=True)

dar_backup/dar-backup.conf

@@ -9,7 +9,7 @@ MIN_SIZE_VERIFICATION_MB = 1
 NO_FILES_VERIFICATION = 5
 # timeout in seconds for backup, test, restore and par2 operations
 # The author has such `dar` tasks running for 10-15 hours on the yearly backups, so a value of 24 hours is used.
-# If a timeout is not specified when using the util.run_command(), a default timeout of 30 secs is used.
+# If a timeout is not specified when using the CommandRunner, a default timeout of 30 secs is used.
 COMMAND_TIMEOUT_SECS = 86400
 
 [DIRECTORIES]

dar_backup/dar_backup.py

@@ -1,5 +1,19 @@
 #!/usr/bin/env python3
 
+"""
+installer.py source code is here: https://github.com/per2jensen/dar-backup/tree/main/v2/src/dar_backup/installer.py
+This script is part of dar-backup, a backup solution for Linux using dar and systemd.
+
+Licensed under GNU GENERAL PUBLIC LICENSE v3, see the supplied file "LICENSE" for details.
+
+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
+
+This script can be used to control `dar` to backup parts of or the whole system.
+"""
+
+
 import argparse
 import filecmp
 
@@ -11,6 +25,7 @@ import shutil
 import subprocess
 import xml.etree.ElementTree as ET
 import tempfile
+import threading
 
 from argparse import ArgumentParser
 from datetime import datetime
@@ -20,19 +35,26 @@ from sys import stderr
 from sys import argv
 from sys import version_info
 from time import time
+from threading import Event
 from typing import List
 
 from . import __about__ as about
 from dar_backup.config_settings import ConfigSettings
 from dar_backup.util import list_backups
-from dar_backup.util import run_command
 from dar_backup.util import setup_logging
 from dar_backup.util import get_logger
 from dar_backup.util import BackupError
 from dar_backup.util import RestoreError
+from dar_backup.util import requirements
+
+from dar_backup.command_runner import CommandRunner   
+from dar_backup.command_runner import CommandResult
+
+from dar_backup.rich_progress import show_log_driven_bar
 
 
 logger = None
+runner = None
 
 def generic_backup(type: str, command: List[str], backup_file: str, backup_definition: str, darrc: str,  config_settings: ConfigSettings, args: argparse.Namespace) -> List[str]:
     """
@@ -63,9 +85,32 @@ def generic_backup(type: str, command: List[str], backup_file: str, backup_defin
     result: List[tuple] = []
 
     logger.info(f"===> Starting {type} backup for {backup_definition}")
-    logger.info(f"Running command: {' '.join(map(shlex.quote, command))}")
     try:
-        process = run_command(command, config_settings.command_timeout_secs)
+        log_basename = os.path. dirname(config_settings.logfile_location)
+        logfile = os.path.basename(config_settings.logfile_location)[:-4] + "-commands.log"
+        log_path = os.path.join( log_basename, logfile)
+        logger.debug(f"Commands log file: {log_path}")
+
+        # wrap a progress bar around the dar command
+        stop_event = Event()
+        session_marker = f"=== START BACKUP SESSION: {int(time())} ==="
+        get_logger(command_output_logger=True).info(session_marker)
+
+        progress_thread = threading.Thread(
+            target=show_log_driven_bar,
+            args=(log_path, stop_event, session_marker),
+            daemon=True
+        )
+        progress_thread.start()
+        try:
+            process = runner.run(command, timeout = config_settings.command_timeout_secs)
+        except Exception as e:
+            print(f"[!] Backup failed: {e}")
+            raise
+        finally:
+            stop_event.set()
+            progress_thread.join()
+
         if process.returncode == 0:
             logger.info(f"{type} backup completed successfully.")
         elif process.returncode == 5:
@@ -75,7 +120,7 @@ def generic_backup(type: str, command: List[str], backup_file: str, backup_defin
 
         if process.returncode == 0 or process.returncode == 5:
             add_catalog_command = ['manager', '--add-specific-archive' ,backup_file, '--config-file', args.config_file]
-            command_result = run_command(add_catalog_command, config_settings.command_timeout_secs)
+            command_result = runner.run(add_catalog_command, timeout = config_settings.command_timeout_secs)
             if command_result.returncode == 0:
                 logger.info(f"Catalog for archive '{backup_file}' added successfully to its manager.")
             else:
@@ -192,8 +237,33 @@ def verify(args: argparse.Namespace, backup_file: str, backup_definition: str, c
     """
     result = True
     command = ['dar', '-t', backup_file, '-Q']
-    logger.debug(f"Running command: {' '.join(map(shlex.quote, command))}")
-    process = run_command(command, config_settings.command_timeout_secs)
+ 
+ 
+    log_basename = os.path. dirname(config_settings.logfile_location)
+    logfile = os.path.basename(config_settings.logfile_location)[:-4] + "-commands.log"
+    log_path = os.path.join( log_basename, logfile)
+
+    # wrap a progress bar around the dar command
+    stop_event = Event()
+    session_marker = f"=== START BACKUP SESSION: {int(time())} ==="
+    get_logger(command_output_logger=True).info(session_marker)
+
+    progress_thread = threading.Thread(
+        target=show_log_driven_bar,
+        args=(log_path, stop_event, session_marker),
+        daemon=True
+    )
+    progress_thread.start()
+    try:
+        process = runner.run(command, timeout = config_settings.command_timeout_secs)
+    except Exception as e:
+        print(f"[!] Backup failed: {e}")
+        raise
+    finally:
+        stop_event.set()
+        progress_thread.join()
+
+
     if process.returncode == 0:
         logger.info("Archive integrity test passed.")
     else:
@@ -235,7 +305,7 @@ def verify(args: argparse.Namespace, backup_file: str, backup_definition: str, c
             args.verbose and logger.info(f"Restoring file: '{restored_file_path}' from backup to: '{config_settings.test_restore_dir}' for file comparing")
             command = ['dar', '-x', backup_file, '-g', restored_file_path.lstrip("/"), '-R', config_settings.test_restore_dir, '-Q', '-B', args.darrc, 'restore-options']
             args.verbose and logger.info(f"Running command: {' '.join(map(shlex.quote, command))}")
-            process = run_command(command, config_settings.command_timeout_secs)    
+            process = runner.run(command, timeout = config_settings.command_timeout_secs)    
             if process.returncode != 0:
                 raise Exception(str(process))
 
@@ -276,7 +346,7 @@ def restore_backup(backup_name: str, config_settings: ConfigSettings, restore_di
             command.extend(selection_criteria)
         command.extend(['-B', darrc,  'restore-options'])  # the .darrc `restore-options` section
         logger.info(f"Running restore command: {' '.join(map(shlex.quote, command))}")
-        process = run_command(command, config_settings.command_timeout_secs)
+        process = runner.run(command, timeout = config_settings.command_timeout_secs)
         if process.returncode == 0:
             logger.info(f"Restore completed successfully to: '{restore_dir}'")
         else:
@@ -309,7 +379,7 @@ def get_backed_up_files(backup_name: str, backup_dir: str):
     try:
         command = ['dar', '-l', backup_path, '-am', '-as', "-Txml" , '-Q']
         logger.debug(f"Running command: {' '.join(map(shlex.quote, command))}")
-        command_result = run_command(command)
+        command_result = runner.run(command)
         # Parse the XML data
         file_paths = find_files_with_paths(command_result.stdout)
         return file_paths
@@ -339,8 +409,7 @@ def list_contents(backup_name, backup_dir, selection=None):
         if selection:
             selection_criteria = shlex.split(selection)
             command.extend(selection_criteria)
-        logger.info(f"Running command: {' '.join(map(shlex.quote, command))}")
-        process = run_command(command)
+        process = runner.run(command)
         stdout,stderr = process.stdout, process.stderr
         if process.returncode != 0:
             logger.error(f"Error listing contents of backup: '{backup_name}'")
@@ -402,7 +471,8 @@ def perform_backup(args: argparse.Namespace, config_settings: ConfigSettings, ba
         if '_' in args.backup_definition:
             msg = f"Skipping backup definition: '{args.backup_definition}' due to '_' in name"
             logger.error(msg)
-            return results.append((msg, 1))
+            results.append((msg, 1))
+            return results
         backup_definitions.append((os.path.basename(args.backup_definition).split('.')[0], os.path.join(config_settings.backup_d_dir, args.backup_definition)))
     else:
         for root, _, files in os.walk(config_settings.backup_d_dir):
@@ -512,7 +582,7 @@ def generate_par2_files(backup_file: str, config_settings: ConfigSettings, args)
 
         # Run the par2 command to generate redundancy files with error correction
         command = ['par2', 'create', f'-r{config_settings.error_correction_percent}', '-q', '-q', file_path]
-        process = run_command(command, config_settings.command_timeout_secs)
+        process = runner.run(command, timeout = config_settings.command_timeout_secs)
 
         if process.returncode == 0:
             logger.info(f"{counter}/{number_of_slices}: Done")
@@ -620,45 +690,57 @@ INCR back of a single backup definition in backup.d
 
 
 
-def requirements(type: str, config_setting: ConfigSettings):
+def print_markdown(source: str, from_string: bool = False, pretty: bool = True):
     """
-    Perform PREREQ or POSTREQ requirements.
-
+    Print Markdown content either from a file or directly from a string.
+    
     Args:
-        type (str): The type of prereq (PREREQ, POSTREQ).
-        config_settings (ConfigSettings): An instance of the ConfigSettings class.
+        source: Path to the file or Markdown string itself.
+        from_string: If True, treat `source` as Markdown string instead of file path.
+        pretty: If True, render with rich formatting if available.
+    """
+    import os
+    import sys
 
-    Raises:
-        RuntimeError: If a subprocess  returns anything but zero.
+    content = ""
+    if from_string:
+        content = source
+    else:
+        if not os.path.exists(source):
+            print(f"❌ File not found: {source}")
+            sys.exit(1)
+        with open(source, "r", encoding="utf-8") as f:
+            content = f.read()
+
+    if pretty:
+        try:
+            from rich.console import Console
+            from rich.markdown import Markdown
+            console = Console()
+            console.print(Markdown(content))
+        except ImportError:
+            print("⚠️ 'rich' not installed. Falling back to plain text.\n")
+            print(content)
+    else:
+        print(content)
+
+
+
+def print_changelog(path: str = None, pretty: bool = True):
+    if path is None:
+        path = Path(__file__).parent / "Changelog.md"
+    print_markdown(str(path), pretty=pretty)
+
+
+def print_readme(path: str = None, pretty: bool = True):
+    if path is None:
+        path = Path(__file__).parent / "README.md"
+    print_markdown(str(path), pretty=pretty)
 
-        subprocess.CalledProcessError: if CalledProcessError is raised in subprocess.run(), let it bobble up.
-    """
-    if type is None or config_setting is None:
-        raise RuntimeError(f"requirements: 'type' or config_setting is None")
-
-    allowed_types = ['PREREQ', 'POSTREQ'] 
-    if type not in allowed_types:
-        raise RuntimeError(f"requirements: {type} not in: {allowed_types}")
-
-
-    logger.info(f"Performing  {type}")
-    if type in config_setting.config:
-        for key in sorted(config_setting.config[type].keys()):
-            script = config_setting.config[type][key]
-            try:
-                result = subprocess.run(script, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, shell=True, check=True)
-                logger.debug(f"{type} {key}: '{script}' run, return code: {result.returncode}")
-                logger.debug(f"{type} stdout:\n{result.stdout}")
-                if result.returncode != 0:
-                    logger.error(f"{type} stderr:\n{result.stderr}")
-                    raise RuntimeError(f"{type} {key}: '{script}' failed, return code: {result.returncode}")    
-            except subprocess.CalledProcessError as e:
-                logger.error(f"Error executing {key}: '{script}': {e}")
-                raise e
 
 
 def main():
-    global logger
+    global logger, runner
     results: List[(str,int)] = []  # a list op tuples (<msg>, <exit code>)
 
     MIN_PYTHON_VERSION = (3, 9)
@@ -674,7 +756,6 @@ def main():
     parser.add_argument('--alternate-reference-archive', help="DIFF or INCR compared to specified archive.")
     parser.add_argument('-c', '--config-file', type=str, help="Path to 'dar-backup.conf'", default='~/.config/dar-backup/dar-backup.conf')
     parser.add_argument('--darrc', type=str, help='Optional path to .darrc')
-    parser.add_argument('--examples', action="store_true", help="Examples of using dar-backup.py.")
     parser.add_argument('-l', '--list', action='store_true', help="List available archives.")
     parser.add_argument('--list-contents', help="List the contents of the specified archive.")
     parser.add_argument('--selection', help="dar file selection for listing/restoring specific files/directories.")
@@ -686,6 +767,11 @@ def main():
     parser.add_argument('--log-level', type=str, help="`debug` or `trace`", default="info")
     parser.add_argument('--log-stdout', action='store_true', help='also print log messages to stdout')
     parser.add_argument('--do-not-compare', action='store_true', help="do not compare restores to file system")
+    parser.add_argument('--examples', action="store_true", help="Examples of using dar-backup.py.")
+    parser.add_argument("--readme", action="store_true", help="Print README.md to stdout and exit.")
+    parser.add_argument("--readme-pretty", action="store_true", help="Print README.md to stdout with Markdown styling and exit.")
+    parser.add_argument("--changelog", action="store_true", help="Print Changelog.md to stdout and exit.")
+    parser.add_argument("--changelog-pretty", action="store_true", help="Print Changelog.md to stdout with Markdown styling and exit.")
     parser.add_argument('-v', '--version', action='store_true', help="Show version and license information.")
     args = parser.parse_args()
 
@@ -695,6 +781,20 @@ def main():
     elif args.examples:
         show_examples()
         exit(0)
+    elif args.readme:
+        print_readme(None, pretty=False)
+        exit(0)
+    elif args.readme_pretty:
+        print_readme(None, pretty=True)
+        exit(0)
+    elif args.changelog:
+        print_changelog(None, pretty=False)
+        exit(0)
+    elif args.changelog_pretty:
+        print_changelog(None, pretty=True)
+        exit(0)
+
+
 
     if not args.config_file:
         print(f"Config file not specified, exiting", file=stderr)
@@ -713,6 +813,9 @@ def main():
         print(f"Error: logfile_location in {args.config_file} does not end at 'dar-backup.log', exiting", file=stderr)
 
     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)
+
 
     try:
         if not args.darrc:
@@ -741,9 +844,9 @@ def main():
         file_dir =  os.path.normpath(os.path.dirname(__file__))
         args.verbose and (print(f"Script directory:  {file_dir}"))
         args.verbose and (print(f"Config file:       {args.config_file}"))
-        args.verbose and args.full_backup         and (print(f"Type of backup: FULL"))
-        args.verbose and args.differential_backup and (print(f"Type of backup: DIFF"))
-        args.verbose and args.incremental_backup  and (print(f"Type of backup: INCR"))
+        args.verbose and args.full_backup         and (print(f"Type of backup:    FULL"))
+        args.verbose and args.differential_backup and (print(f"Type of backup:    DIFF"))
+        args.verbose and args.incremental_backup  and (print(f"Type of backup:    INCR"))
         args.verbose and args.backup_definition   and (print(f"Backup definition: '{args.backup_definition}'"))
         if args.alternate_reference_archive:
             args.verbose and (print(f"Alternate ref archive: {args.alternate_reference_archive}"))