db-sync-tool-kmi 2.11.6__py3-none-any.whl → 3.0.2__py3-none-any.whl

db_sync_tool/utility/exceptions.py

@@ -0,0 +1,32 @@
+"""Custom exception hierarchy for db-sync-tool."""
+
+
+class DbSyncError(Exception):
+    """Base exception for all db-sync-tool errors."""
+    pass
+
+
+class ConfigError(DbSyncError):
+    """Configuration and file access errors."""
+    pass
+
+
+class NoConfigFoundError(ConfigError):
+    """No configuration found during auto-discovery.
+
+    This is raised when ConfigResolver cannot find any configuration
+    (no project configs, no global hosts, no explicit file).
+    This is distinct from ConfigError which indicates a problem with
+    an existing config file (parse error, invalid format, etc.).
+    """
+    pass
+
+
+class ParsingError(DbSyncError):
+    """Framework configuration parsing errors."""
+    pass
+
+
+class ValidationError(DbSyncError):
+    """Input validation errors."""
+    pass

db_sync_tool/utility/helper.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: future_fstrings -*-
 
 """
 Helper script
@@ -7,26 +6,33 @@ Helper script
 
 import shutil
 import os
-import re
 from db_sync_tool.utility import mode, system, output
+from db_sync_tool.utility.security import quote_shell_arg  # noqa: F401 (re-export)
+from db_sync_tool.utility.pure import (  # noqa: F401 (re-export)
+    parse_version, get_file_from_path, remove_surrounding_quotes,
+    clean_db_config, dict_to_args, remove_multiple_elements_from_string
+)
 from db_sync_tool.remote import utility as remote_utility
 
 
-def clean_up():
+def clean_up() -> None:
     """
-    Clean up
-    :return:
+    Clean up temporary files and resources
     """
-    if not mode.is_import():
+    # Note: MySQL config files are cleaned up in sync.py's finally block
+    # to ensure cleanup even on errors
+    cfg = system.get_typed_config()
+
+    # Skip database cleanup for files-only mode or import mode
+    if not mode.is_import() and not cfg.files_only:
         remote_utility.remove_target_database_dump()
         if mode.get_sync_mode() == mode.SyncMode.PROXY:
             remove_temporary_data_dir()
 
 
-def remove_temporary_data_dir():
+def remove_temporary_data_dir() -> None:
     """
     Remove temporary data directory for storing database dump files
-    :return:
     """
     if os.path.exists(system.default_local_sync_path):
         output.message(
@@ -37,31 +43,31 @@ def remove_temporary_data_dir():
         shutil.rmtree(system.default_local_sync_path)
 
 
-def clean_up_dump_dir(client, path, num=5):
+def clean_up_dump_dir(client: str, path: str, num: int = 5) -> None:
     """
-    Clean up the dump directory from old dump files (only affect .sql and .tar.gz files)
-    :param client:
-    :param path:
-    :param num:
-    :return:
+    Clean up the dump directory from old dump files (only affect .sql and .gz files)
+    :param client: Client identifier
+    :param path: Path to dump directory
+    :param num: Number of files to keep
     """
     # Distinguish stat command on os system (Darwin|Linux)
     if check_os(client).strip() == 'Darwin':
         _command = get_command(client, 'stat') + ' -f "%Sm %N" ' + path + ' | ' + get_command(
             client,
             'sort') + ' -rn | ' + get_command(
-            client, 'grep') + ' -E ".tar.gz|.sql"'
+            client, 'grep') + ' -E "\\.gz$|\\.sql$"'
     else:
         _command = get_command(client, 'stat') + ' -c "%y %n" ' + path + ' | ' + \
                    get_command(client,'sort') + ' -rn | ' + get_command(client, 'grep') + \
-                   ' -E ".tar.gz|.sql"'
+                   ' -E "\\.gz$|\\.sql$"'
 
     # List files in directory sorted by change date
-    _files = mode.run_command(
+    _result = mode.run_command(
         _command,
         client,
         True
-    ).splitlines()
+    )
+    _files = _result.splitlines() if _result else []
 
     for i in range(len(_files)):
         _filename = _files[i].rsplit(' ', 1)[-1]
@@ -74,218 +80,197 @@ def clean_up_dump_dir(client, path, num=5):
             )
 
 
-def check_os(client):
+def check_os(client: str) -> str:
     """
     Check which system is running (Linux|Darwin)
-    :param client:
-    :return:
+    :param client: Client identifier
+    :return: OS name
     """
-    return mode.run_command(
+    result = mode.run_command(
         get_command(client, 'uname') + ' -s',
         client,
         True
     )
+    return result if result else ''
 
 
-def get_command(client, command):
+def get_command(client: str, command: str) -> str:
     """
     Get command helper for overriding default commands on the given client
-    :param client:
-    :param command:
+    :param client: Client identifier
+    :param command: Command name
     :return: String command
     """
-    if 'console' in system.config[client]:
-        if command in system.config[client]['console']:
-            return system.config[client]['console'][command]
+    cfg = system.get_typed_config()
+    client_cfg = cfg.get_client(client)
+    if command in client_cfg.console:
+        return client_cfg.console[command]
     return command
 
 
-def get_dump_dir(client):
+def get_dump_dir(client: str) -> str:
     """
     Get database dump directory by client
-    :param client:
+    :param client: Client identifier
     :return: String path
     """
-    if system.config[f'default_{client}_dump_dir']:
+    cfg = system.get_typed_config()
+    # Check if using default dump dir
+    if client == 'origin':
+        use_default = cfg.default_origin_dump_dir
+    else:
+        use_default = cfg.default_target_dump_dir
+
+    if use_default:
         return '/tmp/'
     else:
-        return system.config[client]['dump_dir']
+        return cfg.get_client(client).dump_dir
 
 
-def check_and_create_dump_dir(client, path):
+def check_and_create_dump_dir(client: str, path: str) -> None:
     """
     Check if a path exists on the client system and creates the given path if necessary
-    :param client:
-    :param path:
-    :return:
+    :param client: Client identifier
+    :param path: Path to check/create
     """
+    _safe_path = quote_shell_arg(path)
     mode.run_command(
-        '[ ! -d "' + path + '" ] && mkdir -p "' + path + '"',
+        '[ ! -d ' + _safe_path + ' ] && mkdir -p ' + _safe_path,
         client
     )
 
 
-def get_ssh_host_name(client, with_user=False, minimal=False):
+def get_ssh_host_name(client: str, with_user: bool = False, minimal: bool = False) -> str:
     """
     Format ssh host name depending on existing client name
-    :param client:
-    :param with_user:
-    :param short:
-    :return:
+    :param client: Client identifier
+    :param with_user: Include username in output
+    :param minimal: Return minimal format
+    :return: Formatted host name
     """
-    if not 'user' in system.config[client] and not 'host' in system.config[client]:
+    cfg = system.get_typed_config()
+    client_cfg = cfg.get_client(client)
+
+    if not client_cfg.user and not client_cfg.host:
         return ''
 
     if with_user:
-        _host = system.config[client]['user'] + '@' + system.config[client]['host']
+        _host = client_cfg.user + '@' + client_cfg.host
     else:
-        _host = system.config[client]['host']
+        _host = client_cfg.host
 
-    if 'name' in system.config[client]:
+    if client_cfg.name:
         if minimal:
-            return system.config[client]['name']
+            return client_cfg.name
         else:
-            return output.CliFormat.BOLD + system.config[client][
-                'name'] + output.CliFormat.ENDC + output.CliFormat.BLACK + ' (' + _host + ')' + \
-               output.CliFormat.ENDC
+            return (output.CliFormat.BOLD + client_cfg.name +
+                    output.CliFormat.ENDC + output.CliFormat.BLACK +
+                    ' (' + _host + ')' + output.CliFormat.ENDC)
     else:
         return _host
 
 
-def create_local_temporary_data_dir():
+def create_local_temporary_data_dir() -> None:
     """
-    Create local temporary data dir
-    :return:
+    Create local temporary data dir with secure permissions
     """
-    # @ToDo: Combine with check_and_create_dump_dir()
-    if not os.path.exists(system.default_local_sync_path):
-        os.makedirs(system.default_local_sync_path)
-
-
-def dict_to_args(dict):
-    """
-    Convert an dictionary to a args list
-    :param dict: Dictionary
-    :return: List
-    """
-    _args = []
-    for key, val in dict.items():
-        if isinstance(val, bool):
-            if val:
-                _args.append(f'--{key}')
-        else:
-            _args.append(f'--{key}')
-            _args.append(str(val))
-    if len(_args) == 0:
-        return None
-    return _args
+    cfg = system.get_typed_config()
+    # Skip secure permissions for user-specified keep_dump directories
+    if cfg.keep_dump:
+        if not os.path.exists(system.default_local_sync_path):
+            os.makedirs(system.default_local_sync_path)
+    else:
+        # Use secure temp dir creation with 0700 permissions
+        system.create_secure_temp_dir(system.default_local_sync_path)
 
 
-def check_file_exists(client, path):
+def check_file_exists(client: str, path: str) -> bool:
     """
     Check if a file exists
-    :param client: String
-    :param path: String file path
+    :param client: Client identifier
+    :param path: File path
     :return: Boolean
     """
-    return mode.run_command(f'[ -f {path} ] && echo "1"', client, True) == '1'
+    _safe_path = quote_shell_arg(path)
+    return mode.run_command(f'[ -f {_safe_path} ] && echo "1"', client, True) == '1'
 
 
-def run_script(client=None, script='before'):
+def run_script(client: str | None = None, script: str = 'before') -> None:
     """
     Executing script command
-    :param client: String
-    :param script: String
-    :return:
+    :param client: Client identifier (or None for global scripts)
+    :param script: Script name ('before', 'after', 'error')
     """
+    cfg = system.get_typed_config()
+
     if client is None:
-        _config = system.config
+        # Global scripts
+        scripts_dict = cfg.scripts
         _subject = output.Subject.LOCAL
         client = mode.Client.LOCAL
     else:
-        _config = system.config[client]
+        # Client-specific scripts
+        client_cfg = cfg.get_client(client)
+        scripts_dict = client_cfg.scripts
         _subject = output.host_to_subject(client)
 
-    if not 'scripts' in _config:
-        return
-
-    if f'{script}' in _config['scripts']:
+    if script in scripts_dict:
         output.message(
             _subject,
             f'Running script {client}',
             True
         )
         mode.run_command(
-            _config['scripts'][script],
+            scripts_dict[script],
             client
         )
 
 
-def check_rsync_version():
-    """
-    Check rsync version
-    :return:
+def _check_tool_version(tool: str, version_flag: str = '--version') -> str | None:
     """
-    _raw_version = mode.run_command(
-        'rsync --version',
-        mode.Client.LOCAL,
-        True
-    )
-    _version = parse_version(_raw_version)
-    output.message(
-        output.Subject.LOCAL,
-        f'rsync version {_version}'
-    )
-
+    Check if a tool is available and return its version.
+    DRY helper for version checks.
 
-def check_sshpass_version():
-    """
-    Check sshpass version
-    :return:
+    :param tool: Tool name
+    :param version_flag: Flag to get version
+    :return: Version string or None
     """
-    _raw_version = mode.run_command(
-        'sshpass -V',
+    raw_version = mode.run_command(
+        f'{tool} {version_flag}',
         mode.Client.LOCAL,
         force_output=True,
         allow_fail=True
     )
-    _version = parse_version(_raw_version)
-
-    if _version:
-        output.message(
-            output.Subject.LOCAL,
-            f'sshpass version {_version}'
-        )
-        system.config['use_sshpass'] = True
-        return True
+    return parse_version(raw_version)
 
 
-def parse_version(output):
+def check_rsync_version() -> bool:
     """
-    Parse version out of console output
-    https://stackoverflow.com/a/60730346
-    :param output: String
-    :return:
+    Check rsync version and availability.
+
+    :return: True if rsync is available, False otherwise
     """
-    _version_pattern = r'\d+(=?\.(\d+(=?\.(\d+)*)*)*)*'
-    _regex_matcher = re.compile(_version_pattern)
-    _version = _regex_matcher.search(output)
-    if _version:
-        return _version.group(0)
-    else:
-        return None
+    version = _check_tool_version('rsync')
+    if version:
+        output.message(output.Subject.LOCAL, f'rsync version {version}')
+        return True
+    return False
 
 
-def get_file_from_path(path):
+def check_sshpass_version() -> bool | None:
     """
-    Trims a path string to retrieve the file
-    :param path:
-    :return: file
+    Check sshpass version
+    :return: True if available, None otherwise
     """
-    return path.split('/')[-1]
+    version = _check_tool_version('sshpass', '-V')
+    if version:
+        output.message(output.Subject.LOCAL, f'sshpass version {version}')
+        system.set_use_sshpass(True)
+        return True
+    return None
 
 
-def confirm(prompt=None, resp=False):
+def confirm(prompt: str | None = None, resp: bool = False) -> bool:
     """
     https://code.activestate.com/recipes/541096-prompt-the-user-for-confirmation/
 
@@ -308,18 +293,40 @@ def confirm(prompt=None, resp=False):
         prompt = 'Confirm'
 
     if resp:
-        prompt = '%s [%s|%s]: ' % (prompt, 'Y', 'n')
+        prompt = f'{prompt} [Y|n]: '
     else:
-        prompt = '%s [%s|%s]: ' % (prompt, 'y', 'N')
+        prompt = f'{prompt} [y|N]: '
 
     while True:
-        ans = input(prompt)
+        ans = input(prompt).lower()
         if not ans:
             return resp
-        if ans not in ['y', 'Y', 'n', 'N']:
-            print('Please enter y or n.')
-            continue
-        if ans == 'y' or ans == 'Y':
-            return True
-        if ans == 'n' or ans == 'N':
-            return False
+        if ans in ('y', 'n'):
+            return ans == 'y'
+        print('Please enter y or n.')
+
+
+def run_sed_command(client: str, command: str) -> str:
+    """
+    Executes a sed command on the specified client, trying -E first and falling back to -r if -E fails.
+
+    :param client: The client on which the sed command should be executed.
+    :param command: The sed command to execute (excluding the sed options).
+    :return: The result of the sed command as a cleaned string (with newlines removed).
+    """
+    # Check if the client supports -E or -r option for sed
+    option = mode.run_command(
+         f"echo | {get_command(client, 'sed')} -E '' >/dev/null 2>&1 && echo -E || (echo | {get_command(client, 'sed')} -r '' >/dev/null 2>&1 && echo -r)",
+         client,
+         True
+    )
+    # If neither option is supported, default to -E
+    if not option:
+        option = '-E'
+
+    result = mode.run_command(
+        f"{get_command(client, 'sed')} -n {option} {command}",
+        client,
+        True
+    )
+    return result.strip().replace('\n', '') if result else ''

db_sync_tool/utility/info.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: future_fstrings -*-
 
 """
 
@@ -11,31 +10,66 @@ from db_sync_tool.utility import mode, system, output
 from db_sync_tool import info
 
 
-def print_header(mute):
+def print_header(mute, verbose=0):
     """
     Printing console header
     :param mute: Boolean
+    :param verbose: int - 0=compact, 1+=full header
     :return:
     """
-    # pylint: max-line-length=240
     if mute is False:
         _colors = get_random_colors()
-        print(
-            output.CliFormat.BLACK + '##############################################' + output.CliFormat.ENDC)
-        print(
-            output.CliFormat.BLACK + '#                                            #' + output.CliFormat.ENDC)
-        print(
-            output.CliFormat.BLACK + '#' + output.CliFormat.ENDC + '              ' + _colors[0] + '⥣ ' + _colors[1] + '⥥ ' + output.CliFormat.ENDC + ' db sync tool             ' + output.CliFormat.BLACK + '#' + output.CliFormat.ENDC)
-        print(
-            output.CliFormat.BLACK + '#                   v' + info.__version__ + '                  #' + output.CliFormat.ENDC)
-        print(output.CliFormat.BLACK + '#  ' + info.__homepage__ + '  #' + output.CliFormat.ENDC)
-        print(
-            output.CliFormat.BLACK + '#                                            #' + output.CliFormat.ENDC)
-        print(
-            output.CliFormat.BLACK + '##############################################' + output.CliFormat.ENDC)
+        if verbose >= 1:
+            # Full header for verbose mode using Rich Panel
+            _print_rich_header(_colors)
+        else:
+            # Compact header for default mode
+            print(
+                output.CliFormat.BLACK + _colors[0] + '⥣ ' + _colors[1] + '⥥ ' + output.CliFormat.ENDC +
+                output.CliFormat.BLACK + 'db-sync-tool v' + info.__version__ + output.CliFormat.ENDC)
         check_updates()
 
 
+def _print_rich_header(_colors):
+    """Print header using Rich if available, fallback to ASCII."""
+    try:
+        from rich.console import Console
+        from rich.text import Text
+
+        console = Console(force_terminal=True)
+
+        # Build simple header line
+        header = Text()
+        header.append("⥣ ", style=_color_to_rich(_colors[0]))
+        header.append("⥥ ", style=_color_to_rich(_colors[1]))
+        header.append("db-sync-tool ", style="bold")
+        header.append(f"v{info.__version__}", style="dim")
+
+        console.print(header)
+        console.print()  # Empty line after header
+    except ImportError:
+        # Fallback to simple ASCII header
+        print(
+            _colors[0] + '⥣ ' + _colors[1] + '⥥ ' + output.CliFormat.ENDC +
+            output.CliFormat.BOLD + 'db-sync-tool ' + output.CliFormat.ENDC +
+            output.CliFormat.BLACK + 'v' + info.__version__ + output.CliFormat.ENDC
+        )
+        print()
+
+
+def _color_to_rich(cli_color):
+    """Convert CliFormat color to Rich style."""
+    color_map = {
+        output.CliFormat.BEIGE: "cyan",
+        output.CliFormat.PURPLE: "magenta",
+        output.CliFormat.BLUE: "blue",
+        output.CliFormat.YELLOW: "yellow",
+        output.CliFormat.GREEN: "green",
+        output.CliFormat.RED: "red",
+    }
+    return color_map.get(cli_color, "white")
+
+
 def check_updates():
     """
     Check for updates of the db_sync_tool
@@ -60,11 +94,10 @@ def print_footer():
     Printing console footer
     :return:
     """
-    if system.config['dry_run']:
+    cfg = system.get_typed_config()
+    if cfg.dry_run:
         _message = 'Successfully executed dry run'
-    elif not system.config['keep_dump'] and \
-            not system.config['is_same_client'] and \
-            not mode.is_import():
+    elif not cfg.keep_dump and not cfg.is_same_client and not mode.is_import():
         _message = 'Successfully synchronized databases'
     elif mode.is_import():
         _message = 'Successfully imported database dump'