dar-backup 0.6.2__py3-none-any.whl → 0.6.3__py3-none-any.whl

dar_backup/__about__.py

@@ -1 +1 @@
-__version__ = "0.6.2"
+__version__ = "0.6.3"

dar_backup/manager.py

@@ -21,8 +21,9 @@
 """
 
 
-import os
 import argparse
+import os
+import re
 import sys
 
 
@@ -30,7 +31,9 @@ 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 datetime import datetime
 from time import time
+from typing import Dict, List, NamedTuple
 
 # Constants
 SCRIPTNAME = os.path.basename(__file__)
@@ -70,9 +73,20 @@ def create_db(backup_def: str, config_settings: ConfigSettings):
             logger.error(f"stderr: {stderr}")
             logger.error(f"stdout: {stdout}")
 
+    return process.returncode
 
 
-def list_db(backup_def: str, config_settings: ConfigSettings):
+def list_catalogs(backup_def: str, config_settings: ConfigSettings) -> NamedTuple:
+    """
+    Returns:
+       a typing.NamedTuple of class dar-backup.util.CommandResult with the following properties:
+        - process: of type subprocess.CompletedProcess: The result of the command execution.
+        - stdout: of type str: The standard output of the command.
+        - stderr: of type str: The standard error of the command.
+        - returncode: of type int: The return code of the command.
+        - timeout: of type int: The timeout value in seconds used to run the command.
+        - command: of type list[str): The command executed.
+    """
     database = f"{backup_def}{DB_SUFFIX}"
     database_path = os.path.join(config_settings.backup_dir, database)
     if not os.path.exists(database_path):
@@ -87,27 +101,101 @@ def list_db(backup_def: str, config_settings: ConfigSettings):
         logger.error(f"stdout: {stdout}")
     else:
         print(stdout)
-    sys.exit(process.returncode)
+    return process
+
+
+def cat_no_for_name(archive: str, config_settings: ConfigSettings) -> int:
+    """
+    Find the catalog number for the given archive name
+
+    Returns:
+      - the found number, if the archive catalog is present in the database
+      - "-1" if the archive is not found
+    """
+    backup_def = backup_def_from_archive(archive)
+    process = list_catalogs(backup_def, config_settings)
+    if process.returncode != 0:
+        logger.error(f"Error listing catalogs for backup def: '{backup_def}'")
+        return -1
+    line_no = 1
+    for line in process.stdout.splitlines():
+        #print(f"{line_no}: {line}")
+        line_no += 1
+        search = re.search(f"\s+(\d+)\s+.*?({archive}).*", line)
+        if search:
+            #print("FOUND")
+            logger.info(f"Found archive: '{archive}', catalog #: '{search.group(1)}'")
+            return int(search.group(1))
+    return -1
+
+
+
+
+
+def list_catalog_contents(catalog_number: int, backup_def: str, config_settings: ConfigSettings):
+    """
+    List the contents of catalog # in catalog database for given backup definition
+    """
+    database = f"{backup_def}{DB_SUFFIX}"
+    database_path = os.path.join(config_settings.backup_dir, database)
+    if not os.path.exists(database_path):
+        logger.error(f'Database not found: "{database_path}"')
+        return 1
+    command = ['dar_manager', '--base', database_path, '-u', f"{catalog_number}"]
+    process = run_command(command)
+    stdout, stderr = process.stdout, process.stderr 
+    if process.returncode != 0:
+        logger.error(f'Error listing catalogs for: "{database_path}"')
+        logger.error(f"stderr: {stderr}")  
+        logger.error(f"stdout: {stdout}")
+    else:
+        print(stdout)
+    return process.returncode
+
+
+def find_file(file, backup_def, config_settings):
+    """
+    Find a specific file
+    """
+    database = f"{backup_def}{DB_SUFFIX}"
+    database_path = os.path.join(config_settings.backup_dir, database)
+    if not os.path.exists(database_path):
+        logger.error(f'Database not found: "{database_path}"')
+        return 1
+    command = ['dar_manager', '--base', database_path, '-f', f"{file}"]
+    process = run_command(command)
+    stdout, stderr = process.stdout, process.stderr 
+    if process.returncode != 0:
+        logger.error(f'Error finding file: {file} in: "{database_path}"')
+        logger.error(f"stderr: {stderr}")  
+        logger.error(f"stdout: {stdout}")
+    else:
+        print(stdout)
+    return process.returncode
 
 
-def add_specific_archive(archive: str, config_settings: ConfigSettings):    
+def add_specific_archive(archive: str, config_settings: ConfigSettings, directory: str =None) -> int:    
     # sanity check - does dar backup exist?
+    if not directory:
+        directory = config_settings.backup_dir
     archive = os.path.basename(archive)  # remove path if it was given
-    archive_path = os.path.join(config_settings.backup_dir, f'{archive}.1.dar')
-    if not os.path.exists(archive_path):
-        logger.error(f'dar backup: "{archive_path}" not found, exiting')
-        sys.exit(1)
+    archive_path = os.path.join(directory, f'{archive}')
+
+    archive_test_path =  os.path.join(directory, f'{archive}.1.dar')
+    if not os.path.exists(archive_test_path):
+        logger.error(f'dar backup: "{archive_test_path}" not found, exiting')
+        return 1
         
     # sanity check - does backup definition exist?
     backup_definition = archive.split('_')[0]
     backup_def_path = os.path.join(config_settings.backup_d_dir, backup_definition)
     if not os.path.exists(backup_def_path):
         logger.error(f'backup definition "{backup_definition}" not found (--add-specific-archive option probably not correct), exiting')
-        sys.exit(1)
+        return 1
     
     database = f"{backup_definition}{DB_SUFFIX}"
     database_path = os.path.realpath(os.path.join(config_settings.backup_dir, database))
-    logger.info(f'Add "{archive_path}" to catalog "{database}"')
+    logger.info(f'Add "{archive_path}" to catalog: "{database}"')
     
     command = ['dar_manager', '--base', database_path, "--add", archive_path, "-ai", "-Q"]
     process = run_command(command)
@@ -122,7 +210,99 @@ def add_specific_archive(archive: str, config_settings: ConfigSettings):
         logger.error(f"stderr: {stderr}")
         logger.error(f"stdout: {stdout}")
      
-    sys.exit(process.returncode)
+    return process.returncode
+
+
+
+def add_directory(args: argparse.ArgumentParser, config_settings: ConfigSettings) -> None:
+    """
+    Loop over the DAR archives in the given directory args.add_dir in increasing order by date and add them to their catalog database.
+
+    Args:
+        args (argparse.ArgumentParser): The command-line arguments object containing the add_dir attribute.
+        config_settings (ConfigSettings): The configuration settings object.
+
+    This function performs the following steps:
+    1. Checks if the specified directory exists. If not, raises a RuntimeError.
+    2. Uses a regular expression to match DAR archive files with base names in the format <string>_{FULL, DIFF, INCR}_YYYY-MM-DD.
+    3. Lists the DAR archives in the specified directory and extracts their base names and dates.
+    4. Sorts the DAR archives by date.
+    5. Loops over the sorted DAR archives and adds each archive to its catalog database using the add_specific_archive function.
+
+    Example:
+        args = argparse.ArgumentParser()
+        args.add_dir = '/path/to/dar/archives'
+        config_settings = ConfigSettings()
+        add_directory(args, config_settings)
+    """
+    if not os.path.exists(args.add_dir):
+        raise RuntimeError(f"Directory {args.add_dir} does not exist")
+
+    # Regular expression to match DAR archive files with base name and date in the format <string>_{FULL, DIFF, INCR}_YYYY-MM-DD
+    #dar_pattern = re.compile(r'^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.\d+\.dar$')
+    dar_pattern = re.compile(r'^(.*?_(FULL|DIFF|INCR)_(\d{4}-\d{2}-\d{2}))\.1.dar$') # just read slice #1 of an archive
+    # List of DAR archives with their dates and base names
+    dar_archives = []
+
+    for filename in os.listdir(args.add_dir):
+        logger.debug(f"check if '{filename}' is a dar archive slice #1?")
+        match = dar_pattern.match(filename)
+        if match:
+            base_name = match.group(1)
+            date_str = match.group(3)
+            date_obj = datetime.strptime(date_str, '%Y-%m-%d')
+            dar_archives.append((date_obj, base_name))
+            logger.debug(f" -> yes: base name: {base_name}, date: {date_str}")
+
+    if not dar_archives or len(dar_archives) == 0:
+        logger.info(f"No 'dar' archives found in directory {args.add_dir}")
+        return
+
+    # Sort the DAR archives by date
+    dar_archives.sort()
+
+    # Loop over the sorted DAR archives and process them
+    result: List[Dict] = []
+    for date_obj, base_name in dar_archives:
+        logger.info(f"Adding dar archive: '{base_name}' to it's catalog database")
+        result_archive = add_specific_archive(base_name, config_settings, args.add_dir)
+        result.append({ f"{base_name}" : result_archive})
+        if result_archive != 0:
+            logger.error(f"Something went wrong added {base_name} to it's catalog")
+    
+    logger.debug(f"Results adding archives found in: '{args.add_dir}': result")
+
+
+def backup_def_from_archive(archive: str) -> str:
+    """
+    return the backup definition from archive name
+    """
+    search = re.search("(.*?)_", archive)
+    backup_def = search.group(1)
+    logger.debug(f"backup definition: '{backup_def}' from given archive '{archive}'")
+    return backup_def
+
+
+
+def remove_specific_archive(archive: str, config_settings: ConfigSettings) -> int:
+    backup_def = backup_def_from_archive(archive)
+    database_path = os.path.join(config_settings.backup_dir, f"{backup_def}{DB_SUFFIX}")
+    cat_no = cat_no_for_name(archive, config_settings)
+    if cat_no > 0:
+        command = ['dar_manager', '--base', database_path, "--delete", str(cat_no)]
+        process = run_command(command)
+    else:
+        logger.error(f"archive: '{archive}' not found in in't catalog database: {database_path}")
+        return cat_no
+
+    if process.returncode == 0:
+        logger.info(f"'{archive}' removed from it's catalog")
+    else:
+        logger.error(process.stdout)
+        logger.error(process.sterr)
+
+    return process.returncode
+
 
 
 
@@ -142,7 +322,9 @@ def main():
     parser.add_argument('-d', '--backup-def', type=str, help='Restrict to work only on this backup definition')
     parser.add_argument('--add-specific-archive', type=str, help='Add this archive to catalog database')
     parser.add_argument('--remove-specific-archive', type=str, help='Remove this archive from catalog database')
-    parser.add_argument('--list-db', action='store_true', help='List catalogs in databases')
+    parser.add_argument('--list-catalog', action='store_true', help='List catalogs in databases for all backup definitions')
+    parser.add_argument('--list-catalog-contents', type=int, help="List contents of a catalog. Argument is the 'archive #', '-d <definition>' argument is also required")
+    parser.add_argument('--find-file', type=str, help="List catalogs containing <path>/file. '-d <definition>' argument is also required")
     parser.add_argument('--verbose', action='store_true', help='Be more verbose')
     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')
@@ -196,6 +378,13 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
         logger.error("you can't add and remove archives in the same operation, exiting")
         sys.exit(1)
 
+    if args.add_dir and args.add_specific_archive:
+        logger.error("you cannot add both a directory and an archive")
+        sys.exit(1)
+
+    if args.backup_def and not args.backup_def.strip():
+        logger.error(f"No backup definition given to --backup-def")
+
     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):
@@ -203,6 +392,16 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
             sys.exit(1)
 
 
+    if args.list_catalog_contents and not args.backup_def:
+        logger.error(f"--list-catalog-contents requires the --backup-def, exiting")
+        sys.exit(1)
+
+    if args.find_file and not args.backup_def:
+        logger.error(f"--find-file requires the --backup-def, exiting")
+        sys.exit(1)
+    
+
+
     # Modify config settings based on the arguments
     if args.alternate_archive_dir:
         if not os.path.exists(args.alternate_archive_dir):
@@ -213,35 +412,49 @@ See section 15 and section 16 in the supplied "LICENSE" file.''')
 
     if args.create_db:
         if args.backup_def:
-            create_db(args.backup_def, config_settings)
+            sys.exit(create_db(args.backup_def, config_settings))
         else:
             for root, dirs, files in os.walk(config_settings.backup_d_dir):
                 for file in files:
                     current_backupdef = os.path.basename(file)
-                    create_db(current_backupdef, config_settings)
-        sys.exit(0)
+                    logger.debug(f"Create catalog db for backup definition: '{current_backupdef}'")
+                    result = create_db(current_backupdef, config_settings)
+                    if result != 0:
+                        sys.exit(result)
 
     if args.add_specific_archive:
-        add_specific_archive(args.add_specific_archive, config_settings)
+        sys.exit(add_specific_archive(args.add_specific_archive, config_settings))
 
     if args.add_dir:
-        # Implement add directory logic
-        pass
+        sys.exit(add_directory(args, config_settings))
+
 
     if args.remove_specific_archive:
-        # Implement remove specific archive logic
-        pass
+        sys.exit(remove_specific_archive(args.remove_specific_archive, config_settings))
+
 
 
-    if args.list_db:
+    if args.list_catalog:
         if args.backup_def:
-            list_db(args.backup_def, config_settings)
+            process = list_catalogs(args.backup_def, config_settings)
+            result = process.returncode
         else:
+            result = 0
             for root, dirs, files in os.walk(config_settings.backup_d_dir):
                 for file in files:
                     current_backupdef = os.path.basename(file)
-                    list_db(current_backupdef, config_settings)
-        sys.exit(0)
+                    if list_catalogs(current_backupdef, config_settings).returncode != 0:
+                        result = 1
+        sys.exit(result)
+
+    if args.list_catalog_contents:
+        result = list_catalog_contents(args.list_catalog_contents, args.backup_def, config_settings)
+        sys.exit(result)
+
+    if args.find_file:
+        result = find_file(args.find_file, args.backup_def, config_settings)
+        sys.exit(result)
+
 
 if __name__ == "__main__":
     main()

{dar_backup-0.6.2.dist-info → dar_backup-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dar-backup
-Version: 0.6.2
+Version: 0.6.3
 Summary: A script to do full, differential and incremental backups using dar.     Some files are restored from the backups during verification, after which par2 redundancy files are created.     The script also has a cleanup feature to remove old backups and par2 files.
 Project-URL: Homepage, https://github.com/per2jensen/dar-backup
 Project-URL: Issues, https://github.com/per2jensen/dar-backup/issues

{dar_backup-0.6.2.dist-info → dar_backup-0.6.3.dist-info}/RECORD

@@ -1,13 +1,13 @@
 dar_backup/.darrc,sha256=ggex9N6eETOS6u003_QRRJMeWbveQfkT1lDBt0XpU-I,2112
-dar_backup/__about__.py,sha256=d7NGuoje3vHyudKIFR_PmfKozIOKDFvAhGx0QXiyuMw,21
+dar_backup/__about__.py,sha256=_SsQ0ZcyZbUqlFFT370nQxs8UER9D0oW_EmCr4Q-hx4,21
 dar_backup/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dar_backup/cleanup.py,sha256=DgmxSUwKrLLIQuYSIY_yTRhIuOMgI6ivjlQuH4u3wX4,9057
 dar_backup/config_settings.py,sha256=CBMUhLOOZ-x7CRdS3vBDk4TYaGqC4N1Ot8IMH-qPaI0,3617
 dar_backup/dar_backup.py,sha256=YZoVu9NJX3_WIkQIG8EMLSK3-VWdslI0c2XKrM2Un38,32214
-dar_backup/manager.py,sha256=lkw1ZAIdxY7WedLPKZMnHpuq_QbjkUdcG61ooiwUYpo,10197
+dar_backup/manager.py,sha256=Y1dQ7CRGQx5sGoGrjAO62QfJcuW_0Vod-ZGaQmHInFU,19062
 dar_backup/util.py,sha256=6lPCFHr3MDdaLWAW9EDMZ4jdL7pt8rki-5dOXcesmP8,8955
-dar_backup-0.6.2.dist-info/METADATA,sha256=PMfP8NhPwzhHRbjJt6_7Unqxbqqj13PW19QdYac6pcc,22496
-dar_backup-0.6.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dar_backup-0.6.2.dist-info/entry_points.txt,sha256=x9vnW-JEl8mpDJC69f_XBcn0mBSkV1U0cyvFV-NAP1g,126
-dar_backup-0.6.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-dar_backup-0.6.2.dist-info/RECORD,,
+dar_backup-0.6.3.dist-info/METADATA,sha256=6120hSt2mUxhn3u8PfbJweoPY4ToWFlAPHAgLozaK7Q,22496
+dar_backup-0.6.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dar_backup-0.6.3.dist-info/entry_points.txt,sha256=x9vnW-JEl8mpDJC69f_XBcn0mBSkV1U0cyvFV-NAP1g,126
+dar_backup-0.6.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+dar_backup-0.6.3.dist-info/RECORD,,