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

dar_backup/util.py

@@ -19,13 +19,13 @@ import sys
 import threading
 import traceback
 from datetime import datetime
+from dar_backup.config_settings import ConfigSettings
 
 from typing import NamedTuple, List
 
 logger=None
 secondary_logger=None   
 
-
 def setup_logging(log_file: str, command_output_log_file: str, log_level: str = "info", log_to_stdout: bool = False) -> logging.Logger:
     """
     Sets up logging for the main program and a separate secondary logfile for command outputs.
@@ -98,106 +98,44 @@ def get_logger(command_output_logger: bool = False) -> logging.Logger:
 
 
 
-def _stream_reader(pipe, log_funcs, output_accumulator: List[str]):
-    """
-    Reads lines from the subprocess pipe and logs them to multiple destinations.
+def requirements(type: str, config_setting: ConfigSettings):
     """
-    with pipe:
-        for line in iter(pipe.readline, ''):
-            stripped_line = line.strip()
-            output_accumulator.append(stripped_line)
-            for log_func in log_funcs:
-                log_func(stripped_line)  # Log the output in real-time
+    Perform PREREQ or POSTREQ requirements.
 
+    Args:
+        type (str): The type of prereq (PREREQ, POSTREQ).
+        config_settings (ConfigSettings): An instance of the ConfigSettings class.
 
+    Raises:
+        RuntimeError: If a subprocess returns anything but zero.
 
-def run_command(command: List[str], timeout: int = 30, no_output_log: bool = False):
+        subprocess.CalledProcessError: if CalledProcessError is raised in subprocess.run(), let it bobble up.
     """
-    Executes a command and streams output only to the secondary log unless no_log is set to True.
+    
+    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}")
 
-    Returns:
-        A CommandResult NamedTuple with the following properties:
-        - process: subprocess.CompletedProcess
-        - stdout: str: The full standard output of the command.
-        - stderr: str: The full standard error of the command.
-        - returncode: int: The return code of the command.
-        - timeout: int: The timeout value in seconds used to run the command.
-        - command: list[str]: The command executed.
-
-    Logs:
-        - Logs standard output (`stdout`) and standard error in real-time to the
-          logger.secondary_log (that contains the command output).  
-    
-    Raises:
-        subprocess.TimeoutExpired: If the command execution times out (see `timeout` parameter).
-        Exception: If other exceptions occur during command execution.
-        FileNotFoundError: If the command is not found.
-    """
-    stdout_lines, stderr_lines = [], []
-    process = None
-    stdout_thread, stderr_thread = None, None
 
-    try:
-        logger =         get_logger(command_output_logger=False)
-        command_logger = get_logger(command_output_logger=True)
-
-        if not shutil.which(command[0]):
-            raise FileNotFoundError(f"Command not found: {command[0]}")
-   
-        logger.debug(f"Running command: {command}")
-        command_logger.info(f"Running command: {command}")
-
-        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
-
-        log_funcs = [command_logger.info] if not no_output_log else []
-        err_log_funcs = [command_logger.error] if not no_output_log else []
-
-        stdout_thread = threading.Thread(target=_stream_reader, args=(process.stdout, log_funcs,     stdout_lines))
-        stderr_thread = threading.Thread(target=_stream_reader, args=(process.stderr, err_log_funcs, stderr_lines))
-        
-        stdout_thread.start()
-        stderr_thread.start()
-
-        process.wait(timeout=timeout)
-
-    except FileNotFoundError as e:
-        logger.error(f"Command not found: {command[0]}")
-        return CommandResult(
-            process=None,
-            stdout="",
-            stderr=str(e),
-            returncode=127,
-            timeout=timeout,
-            command=command
-        )
-    except subprocess.TimeoutExpired:
-        if process:
-            process.terminate()
-        logger.error(f"Command: '{command}' timed out and was terminated.")
-        raise
-    except Exception as e:
-        logger.error(f"Error running command: {command}", exc_info=True)
-        raise
-    finally:
-        if stdout_thread and stdout_thread.is_alive():
-            stdout_thread.join()
-        if stderr_thread and stderr_thread.is_alive():
-            stderr_thread.join()
-        if process:
-            if process.stdout:
-                process.stdout.close()
-            if process.stderr:
-                process.stderr.close()
+    logger.debug(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
 
-    
-    # Combine captured stdout and stderr lines into single strings
-    stdout = "\n".join(stdout_lines)
-    stderr = "\n".join(stderr_lines)
 
-    #Build the result object
-    result = CommandResult(process=process, stdout=stdout, stderr=stderr, returncode=process.returncode, timeout=timeout, command=command)
-    return result
 
 
 class BackupError(Exception):
@@ -234,49 +172,6 @@ class CommandResult(NamedTuple):
         return f"CommandResult: [Return Code: '{self.returncode}', \nCommand: '{' '.join(map(shlex.quote, self.command))}']"
 
 
-
-
-def extract_error_lines(log_file_path: str, start_time: str, end_time: str):
-    """
-    Extracts error lines from a log file within a specific time range.
-
-    Args:
-        log_file_path (str): The path to the log file.
-        start_time (str): The start time of the desired time range (unixtime).
-        end_time (str): The end time of the desired time range (unixtime).
-
-    Returns:
-        list: A list of error lines within the specified time range.
-
-    Raises:
-        ValueError: If the start or end markers are not found in the log file.
-    """
-    with open(log_file_path, 'r') as log_file:
-        lines = log_file.readlines()
-
-    start_index = None
-    end_index = None
-
-    start_marker = f"START TIME: {start_time}"
-    end_marker = f"END TIME: {end_time}"
-    error_pattern = re.compile(r'ERROR')
-
-    # Find the start and end index for the specific run
-    for i, line in enumerate(lines):
-        if start_marker in line:
-            start_index = i
-        elif end_marker in line and start_index is not None:
-            end_index = i
-            break
-
-    if start_index is None or end_index is None:
-        raise ValueError("Could not find start or end markers in the log file")
-
-    error_lines = [line.rstrip("\n") for line in lines[start_index:end_index + 1] if error_pattern.search(line)]
-
-    return error_lines
-
-
 def list_backups(backup_dir, backup_definition=None):
     """
     List the available backups in the specified directory and their sizes in megabytes, with aligned sizes.