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

db_sync_tool/utility/mode.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
-# -*- coding: future_fstrings -*-
 
 """
 Mode script
 """
 
 import subprocess
-import sys
 
 from db_sync_tool.utility import system, output, helper
+from db_sync_tool.utility.exceptions import DbSyncError
+from db_sync_tool.utility.security import sanitize_command_for_logging  # noqa: F401 (re-export)
 from db_sync_tool.remote import system as remote_system
 
 
@@ -38,140 +38,72 @@ class SyncMode:
     SYNC_LOCAL = 'SYNC_LOCAL'
 
     @staticmethod
-    def is_dump_local():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_full_local() and SyncMode.is_same_host() and not SyncMode.is_sync_local()
-
-    @staticmethod
-    def is_dump_remote():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_full_remote() and SyncMode.is_same_host() and \
-               not SyncMode.is_sync_remote()
-
-    @staticmethod
-    def is_receiver():
-        """
-
-        :return: boolean
-        """
-        return 'host' in system.config[Client.ORIGIN] and not SyncMode.is_proxy() and \
-               not SyncMode.is_sync_remote()
-
-    @staticmethod
-    def is_sender():
-        """
-
-        :return: boolean
-        """
-        return 'host' in system.config[Client.TARGET] and not SyncMode.is_proxy() and \
-               not SyncMode.is_sync_remote()
+    def is_dump_local() -> bool:
+        cfg = system.get_typed_config()
+        both_local = not cfg.origin.is_remote and not cfg.target.is_remote
+        return both_local and SyncMode.is_same_host() and not SyncMode.is_sync_local()
 
     @staticmethod
-    def is_proxy():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_full_remote()
+    def is_dump_remote() -> bool:
+        cfg = system.get_typed_config()
+        both_remote = cfg.origin.is_remote and cfg.target.is_remote
+        return both_remote and SyncMode.is_same_host() and not SyncMode.is_sync_remote()
 
     @staticmethod
-    def is_import_local():
-        """
-
-        :return: boolean
-        """
-        return system.config['import'] != '' and 'host' not in system.config[Client.TARGET]
+    def is_receiver() -> bool:
+        cfg = system.get_typed_config()
+        return cfg.origin.is_remote and not SyncMode.is_proxy() and not SyncMode.is_sync_remote()
 
     @staticmethod
-    def is_import_remote():
-        """
-
-        :return: boolean
-        """
-        return system.config['import'] != '' and 'host' in system.config[Client.TARGET]
+    def is_sender() -> bool:
+        cfg = system.get_typed_config()
+        return cfg.target.is_remote and not SyncMode.is_proxy() and not SyncMode.is_sync_remote()
 
     @staticmethod
-    def is_sync_local():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_full_local() and SyncMode.is_same_host() and SyncMode.is_same_sync()
+    def is_proxy() -> bool:
+        cfg = system.get_typed_config()
+        return cfg.origin.is_remote and cfg.target.is_remote
 
     @staticmethod
-    def is_sync_remote():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_full_remote() and SyncMode.is_same_host() and SyncMode.is_same_sync()
+    def is_import_local() -> bool:
+        cfg = system.get_typed_config()
+        return cfg.import_file != '' and not cfg.target.is_remote
 
     @staticmethod
-    def is_same_sync():
-        """
-
-        :return: boolean
-        """
-        return ((SyncMode.is_available_configuration('path') and
-                 not SyncMode.is_same_configuration('path')) or
-               (SyncMode.is_available_configuration('db') and
-                not SyncMode.is_same_configuration('db')))
+    def is_import_remote() -> bool:
+        cfg = system.get_typed_config()
+        return cfg.import_file != '' and cfg.target.is_remote
 
     @staticmethod
-    def is_full_remote():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_available_configuration('host')
+    def is_sync_local() -> bool:
+        cfg = system.get_typed_config()
+        return (not cfg.origin.is_remote and not cfg.target.is_remote and
+                SyncMode.is_same_host() and SyncMode.is_same_sync())
 
     @staticmethod
-    def is_full_local():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_unavailable_configuration('host')
+    def is_sync_remote() -> bool:
+        cfg = system.get_typed_config()
+        return (cfg.origin.is_remote and cfg.target.is_remote and
+                SyncMode.is_same_host() and SyncMode.is_same_sync())
 
     @staticmethod
-    def is_same_host():
-        """
-
-        :return: boolean
-        """
-        return SyncMode.is_same_configuration('host') and SyncMode.is_same_configuration('port')
-
-    @staticmethod
-    def is_available_configuration(key):
-        """
-
-        :return: boolean
-        """
-        return key in system.config[Client.ORIGIN] and key in system.config[Client.TARGET]
-
-    @staticmethod
-    def is_unavailable_configuration(key):
-        """
-
-        :return: boolean
-        """
-        return key not in system.config[Client.ORIGIN] and key not in system.config[Client.TARGET]
+    def is_same_sync() -> bool:
+        cfg = system.get_typed_config()
+        # Different paths on same host
+        if cfg.origin.path and cfg.target.path and cfg.origin.path != cfg.target.path:
+            return True
+        # Different databases on same host
+        if cfg.origin.db.name and cfg.target.db.name:
+            if (cfg.origin.db.name, cfg.origin.db.host) != (cfg.target.db.name, cfg.target.db.host):
+                return True
+        return False
 
     @staticmethod
-    def is_same_configuration(key):
-        """
-
-        :return: boolean
-        """
-        return (SyncMode.is_available_configuration(key) and
-               system.config[Client.ORIGIN][key] == system.config[Client.TARGET][key]) or \
-               SyncMode.is_unavailable_configuration(key)
+    def is_same_host() -> bool:
+        cfg = system.get_typed_config()
+        return (cfg.origin.host == cfg.target.host and
+                cfg.origin.port == cfg.target.port and
+                cfg.origin.user == cfg.target.user)
 
 
 # Default sync mode
@@ -181,7 +113,7 @@ sync_mode = SyncMode.RECEIVER
 #
 # FUNCTIONS
 #
-def get_sync_mode():
+def get_sync_mode() -> str:
     """
     Returning the sync mode
     :return: String sync_mode
@@ -189,10 +121,9 @@ def get_sync_mode():
     return sync_mode
 
 
-def check_sync_mode():
+def check_sync_mode() -> None:
     """
     Checking the sync_mode based on the given configuration
-    :return: String subject
     """
     global sync_mode
     _description = ''
@@ -214,14 +145,15 @@ def check_sync_mode():
             sync_mode = _mode
             _description = _desc
 
+    cfg = system.get_typed_config()
     if is_import():
         output.message(
             output.Subject.INFO,
-            f'Import file {output.CliFormat.BLACK}{system.config["import"]}{output.CliFormat.ENDC}',
+            f'Import file {output.CliFormat.BLACK}{cfg.import_file}{output.CliFormat.ENDC}',
             True
         )
 
-    system.config['is_same_client'] = SyncMode.is_same_host()
+    system.set_is_same_client(SyncMode.is_same_host())
 
     output.message(
         output.Subject.INFO,
@@ -232,23 +164,19 @@ def check_sync_mode():
     check_for_protection()
 
 
-def is_remote(client):
+def is_remote(client: str) -> bool:
     """
     Check if given client is remote client
-    :param client: String
+    :param client: Client identifier
     :return: Boolean
     """
-    if client == Client.ORIGIN:
-        return is_origin_remote()
-    elif client == Client.TARGET:
-        return is_target_remote()
-    elif client == Client.LOCAL:
-        return False
-    else:
-        return False
+    return {
+        Client.ORIGIN: is_origin_remote,
+        Client.TARGET: is_target_remote,
+    }.get(client, lambda: False)()
 
 
-def is_target_remote():
+def is_target_remote() -> bool:
     """
     Check if target is remote client
     :return: Boolean
@@ -257,7 +185,7 @@ def is_target_remote():
                          SyncMode.IMPORT_REMOTE, SyncMode.SYNC_REMOTE)
 
 
-def is_origin_remote():
+def is_origin_remote() -> bool:
     """
     Check if origin is remote client
     :return: Boolean
@@ -266,7 +194,7 @@ def is_origin_remote():
                          SyncMode.IMPORT_REMOTE, SyncMode.SYNC_REMOTE)
 
 
-def is_import():
+def is_import() -> bool:
     """
     Check if sync mode is import
     :return: Boolean
@@ -274,15 +202,16 @@ def is_import():
     return sync_mode in (SyncMode.IMPORT_LOCAL, SyncMode.IMPORT_REMOTE)
 
 
-def is_dump():
+def is_dump() -> bool:
     """
-    Check if sync mode is import
+    Check if sync mode is dump
     :return: Boolean
     """
     return sync_mode in (SyncMode.DUMP_LOCAL, SyncMode.DUMP_REMOTE)
 
 
-def run_command(command, client, force_output=False, allow_fail=False, skip_dry_run=False):
+def run_command(command: str, client: str, force_output: bool = False,
+                allow_fail: bool = False, skip_dry_run: bool = False) -> str | None:
     """
     Run command depending on the given client
     :param command: String
@@ -290,17 +219,20 @@ def run_command(command, client, force_output=False, allow_fail=False, skip_dry_
     :param force_output: Boolean
     :param allow_fail: Boolean
     :param skip_dry_run: Boolean
-    :return:
+    :return: Command output or None
     """
-    if system.config['verbose']:
+    cfg = system.get_typed_config()
+    if cfg.verbose:
+        # Sanitize command to prevent credentials from appearing in logs
+        _safe_command = sanitize_command_for_logging(command)
         output.message(
             output.host_to_subject(client),
-            output.CliFormat.BLACK + command + output.CliFormat.ENDC,
+            output.CliFormat.BLACK + _safe_command + output.CliFormat.ENDC,
             debug=True
         )
 
-    if system.config['dry_run'] and skip_dry_run:
-        return
+    if cfg.dry_run and skip_dry_run:
+        return None
 
     if is_remote(client):
         if force_output:
@@ -314,22 +246,25 @@ def run_command(command, client, force_output=False, allow_fail=False, skip_dry_
 
         if res.wait() != 0 and err.decode() != '' and not allow_fail:
             helper.run_script(script='error')
-            sys.exit(output.message(output.Subject.ERROR, err.decode(), False))
+            raise DbSyncError(err.decode())
 
         if force_output:
             return out.decode().strip()
 
+        return None
+
 
-def check_for_protection():
+def check_for_protection() -> None:
     """
-    Check if the target system is protected
-    :return: Boolean
+    Check if the target system is protected and exit if so.
     """
+    cfg = system.get_typed_config()
     if sync_mode in (SyncMode.RECEIVER, SyncMode.SENDER, SyncMode.PROXY, SyncMode.SYNC_LOCAL,
                      SyncMode.SYNC_REMOTE, SyncMode.IMPORT_LOCAL, SyncMode.IMPORT_REMOTE) and \
-            'protect' in system.config[Client.TARGET]:
+            cfg.target.protect:
         _host = helper.get_ssh_host_name(Client.TARGET)
-        sys.exit(output.message(output.Subject.ERROR,
-                                f'The host {_host} is protected against the import of a database dump. Please '
-                                'check synchronisation target or adjust the host configuration.', False))
+        raise DbSyncError(
+            f'The host {_host} is protected against the import of a database dump. '
+            'Please check synchronisation target or adjust the host configuration.'
+        )
 

db_sync_tool/utility/output.py

@@ -1,15 +1,25 @@
 #!/usr/bin/env python3
-# -*- coding: future_fstrings -*-
 
 """
 Output script
+
+This module provides the legacy output interface using Rich and structured logging.
+For new code, prefer using the logging_config module directly:
+
+    from db_sync_tool.utility.logging_config import get_sync_logger
+
+    logger = get_sync_logger("origin", remote=True)
+    logger.info("Creating database dump")
 """
-import time
-from yaspin import yaspin
-from db_sync_tool.utility import log, mode, system
+from __future__ import annotations
+
+from db_sync_tool.utility import mode, system
+from db_sync_tool.utility.console import get_output_manager
+from db_sync_tool.utility.logging_config import get_sync_logger
 
 
 class CliFormat:
+    """ANSI color codes for CLI formatting (legacy compatibility)."""
     BEIGE = '\033[96m'
     PURPLE = '\033[95m'
     BLUE = '\033[94m'
@@ -23,6 +33,7 @@ class CliFormat:
 
 
 class Subject:
+    """Subject prefixes for messages (legacy compatibility)."""
     INFO = CliFormat.GREEN + '[INFO]' + CliFormat.ENDC
     LOCAL = CliFormat.BEIGE + '[LOCAL]' + CliFormat.ENDC
     TARGET = CliFormat.BLUE + '[TARGET]' + CliFormat.ENDC
@@ -32,57 +43,113 @@ class Subject:
     DEBUG = CliFormat.BLACK + '[DEBUG]' + CliFormat.ENDC
 
 
-def message(header, message, do_print=True, do_log=False, debug=False, verbose_only=False):
+# Mapping from Subject constants to subject strings for structured logging
+_SUBJECT_MAP = {
+    Subject.INFO: "INFO",
+    Subject.LOCAL: "LOCAL",
+    Subject.TARGET: "TARGET",
+    Subject.ORIGIN: "ORIGIN",
+    Subject.ERROR: "INFO",  # Error level handled separately
+    Subject.WARNING: "INFO",  # Warning level handled separately
+    Subject.DEBUG: "INFO",  # Debug level handled separately
+}
+
+
+def message(
+    header: str,
+    message: str,
+    do_print: bool = True,
+    do_log: bool = False,
+    debug: bool = False,
+    verbose_only: bool = False,
+) -> str | None:
     """
-    Formatting a message for print or log
-    :param header: String
-    :param message: String
-    :param do_print: Boolean
-    :param do_log: Boolean
-    :param debug: Boolean
-    :param verbose_only: Boolean
-    :return: String message
+    Formatting a message for print or log.
+
+    This function maintains backward compatibility while using structured logging
+    and delegating console output to the Rich-based OutputManager.
+
+    Args:
+        header: Subject prefix (e.g., Subject.ORIGIN)
+        message: Message text
+        do_print: Whether to print to console
+        do_log: Whether to log the message
+        debug: Whether this is a debug message
+        verbose_only: Only show in verbose mode
+
+    Returns:
+        String message if do_print is False, None otherwise
     """
-    # Logging if explicitly forced or verbose option is active
-    if do_log or system.config['verbose']:
-        _message = remove_multiple_elements_from_string([CliFormat.BEIGE,
-                                                         CliFormat.PURPLE,
-                                                         CliFormat.BLUE,
-                                                         CliFormat.YELLOW,
-                                                         CliFormat.GREEN,
-                                                         CliFormat.RED,
-                                                         CliFormat.BLACK,
-                                                         CliFormat.ENDC,
-                                                         CliFormat.BOLD,
-                                                         CliFormat.UNDERLINE], message)
-        # @ToDo: Can this be done better? Dynamic functions?
+    cfg = system.get_typed_config()
+    output_manager = get_output_manager()
+
+    # Clean ANSI codes from message for logging and structured output
+    clean_message = remove_multiple_elements_from_string([
+        CliFormat.BEIGE, CliFormat.PURPLE, CliFormat.BLUE,
+        CliFormat.YELLOW, CliFormat.GREEN, CliFormat.RED,
+        CliFormat.BLACK, CliFormat.ENDC, CliFormat.BOLD,
+        CliFormat.UNDERLINE
+    ], message)
+
+    # Get subject and remote status for structured logging
+    subject_str = _SUBJECT_MAP.get(header, "INFO")
+    is_remote = _is_remote_for_header(header)
+
+    # Structured logging if explicitly forced or verbose option is active
+    if do_log or cfg.verbose:
+        logger = get_sync_logger(subject=subject_str, remote=is_remote)
+
         if debug:
-            log.get_logger().debug(_message)
+            logger.debug(clean_message)
         elif header == Subject.WARNING:
-            log.get_logger().warning(_message)
+            logger.warning(clean_message)
         elif header == Subject.ERROR:
-            log.get_logger().error(_message)
+            logger.error(clean_message)
         else:
-            log.get_logger().info(_message)
+            logger.info(clean_message)
 
-    # Formatting message if mute option is inactive
-    if (system.config['mute'] and header == Subject.ERROR) or (not system.config['mute']):
+    # Console output if mute option is inactive
+    if (cfg.mute and header == Subject.ERROR) or (not cfg.mute):
         if do_print:
-            if not verbose_only or (verbose_only and system.config['verbose']):
-                _message = header + extend_output_by_sync_mode(header, debug) + ' ' + message
-                with yaspin(text=_message, color="yellow", side="right") as spinner:
-                    spinner.ok("\b\b")
+            if not verbose_only or (verbose_only and cfg.verbose):
+                # Use new OutputManager for console display
+                if header == Subject.ERROR:
+                    output_manager.error(clean_message)
+                elif header == Subject.WARNING:
+                    output_manager.warning(clean_message)
+                elif debug:
+                    output_manager.debug(clean_message)
+                else:
+                    # Legacy API: messages are logged after completion
+                    # Set up step context for success() to use, then show completed
+                    output_manager._setup_step(clean_message, subject=subject_str, remote=is_remote)
+                    output_manager.success()
+            return None
         else:
             return header + extend_output_by_sync_mode(header, debug) + ' ' + message
+    return None
+
+
+def _is_remote_for_header(header) -> bool:
+    """Determine if the operation is remote based on header."""
+    if header in (Subject.INFO, Subject.LOCAL, Subject.WARNING, Subject.ERROR):
+        return False
+
+    host = subject_to_host(header)
+    if host is None:
+        return False
+
+    return mode.is_remote(host)
 
 
 def extend_output_by_sync_mode(header, debug=False):
     """
-    Extending the output by a client information (LOCAL|REMOTE)
-    :param header: String
-    :return: String message
+    Extending the output by a client information (LOCAL|REMOTE).
+
+    :param header: Subject prefix
+    :param debug: Whether to include debug tag
+    :return: String extension
     """
-    _sync_mode = mode.get_sync_mode()
     _debug = ''
 
     if debug:
@@ -103,9 +170,10 @@ def extend_output_by_sync_mode(header, debug=False):
 
 def host_to_subject(host):
     """
-    Converting the client to the according subject
-    :param host: String
-    :return: String subject
+    Converting the client to the according subject.
+
+    :param host: Client constant
+    :return: Subject prefix
     """
     if host == mode.Client.ORIGIN:
         return Subject.ORIGIN
@@ -113,13 +181,15 @@ def host_to_subject(host):
         return Subject.TARGET
     elif host == mode.Client.LOCAL:
         return Subject.LOCAL
+    return None
 
 
 def subject_to_host(subject):
     """
-    Converting the subject to the according host
-    :param subject: String
-    :return: String host
+    Converting the subject to the according host.
+
+    :param subject: Subject prefix
+    :return: Client constant
     """
     if subject == Subject.ORIGIN:
         return mode.Client.ORIGIN
@@ -127,17 +197,18 @@ def subject_to_host(subject):
         return mode.Client.TARGET
     elif subject == Subject.LOCAL:
         return mode.Client.LOCAL
+    return None
 
 
 def remove_multiple_elements_from_string(elements, string):
     """
-    Removing multiple elements from a string
-    :param elements: List
-    :param string: String
-    :return: String string
+    Removing multiple elements from a string.
+
+    :param elements: List of strings to remove
+    :param string: Input string
+    :return: Cleaned string
     """
     for element in elements:
         if element in string:
             string = string.replace(element, '')
     return string
-