dar-backup 1.0.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

dar_backup/command_runner.py

@@ -8,6 +8,10 @@ import os
 import re
 import shlex
 import sys
+try:
+    import termios
+except ImportError:
+    termios = None
 import tempfile
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "../src")))
 from typing import List, Optional, Union
@@ -80,11 +84,13 @@ class CommandRunner:
         self,
         logger: Optional[logging.Logger] = None,
         command_logger: Optional[logging.Logger] = None,
-        default_timeout: int = 30
+        default_timeout: int = 30,
+        default_capture_limit_bytes: Optional[int] = None
     ):
         self.logger = logger or get_logger()
         self.command_logger = command_logger or get_logger(command_output_logger=True)
         self.default_timeout = default_timeout
+        self.default_capture_limit_bytes = default_capture_limit_bytes
 
         if not self.logger or not self.command_logger:
             self.logger_fallback()
@@ -125,124 +131,213 @@ class CommandRunner:
         timeout: Optional[int] = None,
         check: bool = False,
         capture_output: bool = True,
-        text: bool = True
+        capture_output_limit_bytes: Optional[int] = None,
+        log_output: bool = True,
+        text: bool = True,
+        cwd: Optional[str] = None,
+        stdin: Optional[int] = subprocess.DEVNULL
     ) -> CommandResult:
-        self._text_mode = text 
+        self._text_mode = text
         timeout = timeout or self.default_timeout
-
-        cmd_sanitized = None
-
-        try:
-            cmd_sanitized = sanitize_cmd(cmd)
-        except ValueError as e:
-            stack = traceback.format_exc()
-            self.logger.error(f"Command sanitation failed: {e}")
-            return CommandResult(
-                returncode=-1,
-                note=f"Sanitizing failed: command: {' '.join(cmd)}",
-                stdout='',
-                stderr=str(e),
-                stack=stack,
-
-            )
-        finally:
-            cmd = cmd_sanitized
-
-        #command = f"Executing command: {' '.join(cmd)} (timeout={timeout}s)"
-        command = f"Executing command: {' '.join(shlex.quote(arg) for arg in cmd)} (timeout={timeout}s)"
-
-
-        self.command_logger.info(command)
-        self.logger.debug(command)
-
-        stdout_lines = []
-        stderr_lines = []
+        if capture_output_limit_bytes is None:
+            capture_output_limit_bytes = self.default_capture_limit_bytes
+        if capture_output_limit_bytes is not None and capture_output_limit_bytes < 0:
+            capture_output_limit_bytes = None
+
+        tty_fd = None
+        tty_file = None
+        saved_tty_attrs = None
+        if termios is not None:
+            try:
+                if os.path.exists("/dev/tty"):
+                    tty_file = open("/dev/tty")
+                    tty_fd = tty_file.fileno()
+                elif sys.stdin and sys.stdin.isatty():
+                    tty_fd = sys.stdin.fileno()
+                if tty_fd is not None:
+                    saved_tty_attrs = termios.tcgetattr(tty_fd)
+            except Exception:
+                tty_fd = None
+                saved_tty_attrs = None
+                if tty_file:
+                    tty_file.close()
+                    tty_file = None
 
         try:
-            process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE if capture_output else None,
-                stderr=subprocess.PIPE if capture_output else None,
-                text=False,
-                bufsize=-1
-            )
-        except Exception as e:
-            stack = traceback.format_exc()
-            return CommandResult(
-                returncode=-1,
-                stdout='',
-                stderr=str(e),
-                stack=stack
-            )
+            cmd_sanitized = None
 
-        def stream_output(stream, lines, level):
             try:
-                while True:
-                    chunk = stream.read(1024)
-                    if not chunk:
-                        break
-                    if self._text_mode:
-                        decoded = chunk.decode('utf-8', errors='replace')
-                        lines.append(decoded)
-                        self.command_logger.log(level, decoded.strip())
-                    else:
-                        lines.append(chunk)
-                        # Avoid logging raw binary data to prevent garbled logs
-            except Exception as e:
-                self.logger.warning(f"stream_output decode error: {e}")
+                cmd_sanitized = sanitize_cmd(cmd)
+            except ValueError as e:
+                stack = traceback.format_exc()
+                self.logger.error(f"Command sanitation failed: {e}")
+                if isinstance(cmd, list):
+                    cmd_text = " ".join(map(str, cmd))
+                else:
+                    cmd_text = str(cmd)
+                return CommandResult(
+                    returncode=-1,
+                    note=f"Sanitizing failed: command: {cmd_text}",
+                    stdout='',
+                    stderr=str(e),
+                    stack=stack,
+
+                )
             finally:
-                stream.close()
-
+                cmd = cmd_sanitized
 
+            #command = f"Executing command: {' '.join(cmd)} (timeout={timeout}s)"
+            command = f"Executing command: {' '.join(shlex.quote(arg) for arg in cmd)} (timeout={timeout}s)"
 
-        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()
-            log_msg = f"Command timed out after {timeout} seconds: {' '.join(cmd)}:\n"
-            self.logger.error(log_msg)
-            return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines))
-        except Exception as e:
-            stack = traceback.format_exc()
-            log_msg = f"Command execution failed: {' '.join(cmd)} with error: {e}\n"
-            self.logger.error(log_msg)
-            return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines), stack)  
 
-        for t in threads:
-            t.join()
+            self.command_logger.info(command)
+            self.logger.debug(command)
 
+            stdout_lines = []
+            stderr_lines = []
+            truncated_stdout = {"value": False}
+            truncated_stderr = {"value": False}
 
+            try:
+                use_pipes = capture_output or log_output
+                process = subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.PIPE if use_pipes else None,
+                    stderr=subprocess.PIPE if use_pipes else None,
+                    stdin=stdin,
+                    text=False,
+                    bufsize=-1,
+                    cwd=cwd
+                )
+            except Exception as e:
+                stack = traceback.format_exc()
+                return CommandResult(
+                    returncode=-1,
+                    stdout='',
+                    stderr=str(e),
+                    stack=stack
+                )
+
+            def stream_output(stream, lines, level, truncated_flag):
+                captured_bytes = 0
+                try:
+                    while True:
+                        chunk = stream.read(1024)
+                        if not chunk:
+                            break
+                        if self._text_mode:
+                            decoded = chunk.decode('utf-8', errors='replace')
+                            if log_output:
+                                self.command_logger.log(level, decoded.strip())
+                            if capture_output:
+                                if capture_output_limit_bytes is None:
+                                    lines.append(decoded)
+                                else:
+                                    remaining = capture_output_limit_bytes - captured_bytes
+                                    if remaining > 0:
+                                        if len(chunk) <= remaining:
+                                            lines.append(decoded)
+                                            captured_bytes += len(chunk)
+                                        else:
+                                            piece = chunk[:remaining]
+                                            lines.append(piece.decode('utf-8', errors='replace'))
+                                            captured_bytes = capture_output_limit_bytes
+                                            truncated_flag["value"] = True
+                                    else:
+                                        truncated_flag["value"] = True
+                        else:
+                            if capture_output:
+                                if capture_output_limit_bytes is None:
+                                    lines.append(chunk)
+                                else:
+                                    remaining = capture_output_limit_bytes - captured_bytes
+                                    if remaining > 0:
+                                        if len(chunk) <= remaining:
+                                            lines.append(chunk)
+                                            captured_bytes += len(chunk)
+                                        else:
+                                            lines.append(chunk[:remaining])
+                                            captured_bytes = capture_output_limit_bytes
+                                            truncated_flag["value"] = True
+                                    else:
+                                        truncated_flag["value"] = True
+                            # Avoid logging raw binary data to prevent garbled logs
+                except Exception as e:
+                    self.logger.warning(f"stream_output decode error: {e}")
+                finally:
+                    stream.close()
+
+            threads = []
+            if (capture_output or log_output) and process.stdout:
+                t_out = threading.Thread(
+                    target=stream_output,
+                    args=(process.stdout, stdout_lines, logging.INFO, truncated_stdout)
+                )
+                t_out.start()
+                threads.append(t_out)
+            if (capture_output or log_output) and process.stderr:
+                t_err = threading.Thread(
+                    target=stream_output,
+                    args=(process.stderr, stderr_lines, logging.ERROR, truncated_stderr)
+                )
+                t_err.start()
+                threads.append(t_err)
 
-        if self._text_mode:
-            stdout_combined = ''.join(stdout_lines)
-            stderr_combined = ''.join(stderr_lines)
-        else:
-            stdout_combined = b''.join(stdout_lines)
-            stderr_combined = b''.join(stderr_lines)
-
+            try:
+                process.wait(timeout=timeout)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                log_msg = f"Command timed out after {timeout} seconds: {' '.join(cmd)}:\n"
+                self.logger.error(log_msg)
+                return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines))
+            except Exception as e:
+                stack = traceback.format_exc()
+                log_msg = f"Command execution failed: {' '.join(cmd)} with error: {e}\n"
+                self.logger.error(log_msg)
+                return CommandResult(-1, ''.join(stdout_lines), log_msg.join(stderr_lines), stack)
+
+            for t in threads:
+                t.join()
+
+            if self._text_mode:
+                stdout_combined = ''.join(stdout_lines)
+                stderr_combined = ''.join(stderr_lines)
+            else:
+                stdout_combined = b''.join(stdout_lines)
+                stderr_combined = b''.join(stderr_lines)
+
+            note = None
+            if truncated_stdout["value"] or truncated_stderr["value"]:
+                parts = []
+                if truncated_stdout["value"]:
+                    parts.append("stdout truncated")
+                if truncated_stderr["value"]:
+                    parts.append("stderr truncated")
+                note = ", ".join(parts)
+
+            if check and process.returncode != 0:
+                self.logger.error(f"Command failed with exit code {process.returncode}")
+                return CommandResult(
+                    process.returncode,
+                    stdout_combined,
+                    stderr_combined,
+                    stack=traceback.format_stack()
+                )
 
-        if check and process.returncode != 0:
-            self.logger.error(f"Command failed with exit code {process.returncode}")
             return CommandResult(
                 process.returncode,
                 stdout_combined,
                 stderr_combined,
-                stack=traceback.format_stack()
+                note=note
             )
-
-        return CommandResult(
-            process.returncode,
-                stdout_combined,
-                stderr_combined
-        )
-
+        finally:
+            if termios is not None and saved_tty_attrs is not None and tty_fd is not None:
+                try:
+                    termios.tcsetattr(tty_fd, termios.TCSADRAIN, saved_tty_attrs)
+                except Exception:
+                    self.logger.debug("Failed to restore terminal attributes", exc_info=True)
+            if tty_file is not None:
+                try:
+                    tty_file.close()
+                except Exception:
+                    self.logger.debug("Failed to close /dev/tty handle", exc_info=True)

dar_backup/config_settings.py

@@ -1,9 +1,11 @@
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 import configparser
+import re
 from dataclasses import dataclass, field, fields
 from os.path import expandvars, expanduser
 from pathlib import Path
+from typing import Optional, Pattern
 
 from dar_backup.exceptions import ConfigSettingsError
 
@@ -37,6 +39,7 @@ class ConfigSettings:
     min_size_verification_mb: int = field(init=False)
     no_files_verification: int = field(init=False)
     command_timeout_secs: int = field(init=False)
+    command_capture_max_bytes: Optional[int] = field(init=False, default=None)
     backup_dir: str = field(init=False)
     test_restore_dir: str = field(init=False)
     backup_d_dir: str = field(init=False)
@@ -44,8 +47,19 @@ class ConfigSettings:
     incr_age: int = field(init=False)
     error_correction_percent: int = field(init=False)
     par2_enabled: bool = field(init=False)
+    par2_dir: Optional[str] = field(init=False, default=None)
+    par2_ratio_full: Optional[int] = field(init=False, default=None)
+    par2_ratio_diff: Optional[int] = field(init=False, default=None)
+    par2_ratio_incr: Optional[int] = field(init=False, default=None)
+    par2_run_verify: Optional[bool] = field(init=False, default=None)
     logfile_max_bytes: int = field(init=False)
     logfile_no_count: int = field(init=False)    
+    trace_log_max_bytes: int = field(init=False)
+    trace_log_backup_count: int = field(init=False)
+    dar_backup_discord_webhook_url: Optional[str] = field(init=False, default=None)
+    restoretest_exclude_prefixes: list[str] = field(init=False, default_factory=list)
+    restoretest_exclude_suffixes: list[str] = field(init=False, default_factory=list)
+    restoretest_exclude_regex: Optional[Pattern[str]] = field(init=False, default=None)
 
 
     OPTIONAL_CONFIG_FIELDS = [
@@ -70,6 +84,34 @@ class ConfigSettings:
             "type": int,
             "default": 5,
         },
+        {
+            "section": "MISC",
+            "key": "TRACE_LOG_MAX_BYTES",
+            "attr": "trace_log_max_bytes",
+            "type": int,
+            "default": 10485760, # 10 MB
+        },
+        {
+            "section": "MISC",
+            "key": "TRACE_LOG_BACKUP_COUNT",
+            "attr": "trace_log_backup_count",
+            "type": int,
+            "default": 1,
+        },
+        {
+            "section": "MISC",
+            "key": "DAR_BACKUP_DISCORD_WEBHOOK_URL",
+            "attr": "dar_backup_discord_webhook_url",
+            "type": str,
+            "default": None,
+        },
+        {
+            "section": "MISC",
+            "key": "COMMAND_CAPTURE_MAX_BYTES",
+            "attr": "command_capture_max_bytes",
+            "type": int,
+            "default": 102400,
+        },
         # Add more optional fields here
     ]
 
@@ -78,7 +120,7 @@ class ConfigSettings:
             raise ConfigSettingsError("`config_file` must be specified.")
 
         try:
-            self.config = configparser.ConfigParser()
+            self.config = configparser.ConfigParser(inline_comment_prefixes=['#'])
             loaded_files = self.config.read(self.config_file)
             if not loaded_files:
                 raise RuntimeError(f"Configuration file not found or unreadable: '{self.config_file}'")
@@ -103,6 +145,27 @@ class ConfigSettings:
             else:
                 raise ConfigSettingsError(f"Invalid boolean value for 'ENABLED' in [PAR2]: '{val}'")
 
+            self.par2_dir = self._get_optional_str("PAR2", "PAR2_DIR", default=None)
+            self.par2_ratio_full = self._get_optional_int("PAR2", "PAR2_RATIO_FULL", default=None)
+            self.par2_ratio_diff = self._get_optional_int("PAR2", "PAR2_RATIO_DIFF", default=None)
+            self.par2_ratio_incr = self._get_optional_int("PAR2", "PAR2_RATIO_INCR", default=None)
+            self.par2_run_verify = self._get_optional_bool("PAR2", "PAR2_RUN_VERIFY", default=None)
+            self.restoretest_exclude_prefixes = self._get_optional_csv_list(
+                "MISC",
+                "RESTORETEST_EXCLUDE_PREFIXES",
+                default=[]
+            )
+            self.restoretest_exclude_suffixes = self._get_optional_csv_list(
+                "MISC",
+                "RESTORETEST_EXCLUDE_SUFFIXES",
+                default=[]
+            )
+            self.restoretest_exclude_regex = self._get_optional_regex(
+                "MISC",
+                "RESTORETEST_EXCLUDE_REGEX",
+                default=None
+            )
+
             # Load optional fields
             for opt in self.OPTIONAL_CONFIG_FIELDS:
                 if self.config.has_option(opt['section'], opt['key']):
@@ -144,4 +207,98 @@ class ConfigSettings:
         ]
         return f"<ConfigSettings({', '.join(safe_fields)})>"
 
+    def _get_optional_str(self, section: str, key: str, default: Optional[str] = None) -> Optional[str]:
+        if self.config.has_option(section, key):
+            return self.config.get(section, key).strip()
+        return default
+
+    def _get_optional_int(self, section: str, key: str, default: Optional[int] = None) -> Optional[int]:
+        if self.config.has_option(section, key):
+            raw = self.config.get(section, key).strip()
+            return int(raw)
+        return default
+
+    def _get_optional_bool(self, section: str, key: str, default: Optional[bool] = None) -> Optional[bool]:
+        if not self.config.has_option(section, key):
+            return default
+        val = self.config.get(section, key).strip().lower()
+        if val in ('true', '1', 'yes'):
+            return True
+        if val in ('false', '0', 'no'):
+            return False
+        raise ConfigSettingsError(f"Invalid boolean value for '{key}' in [{section}]: '{val}'")
+
+    def _get_optional_csv_list(self, section: str, key: str, default: Optional[list[str]] = None) -> list[str]:
+        if not self.config.has_option(section, key):
+            return default if default is not None else []
+        raw = self.config.get(section, key).strip()
+        if not raw:
+            return default if default is not None else []
+        return [item.strip() for item in raw.split(",") if item.strip()]
+
+    def _get_optional_regex(
+        self,
+        section: str,
+        key: str,
+        default: Optional[Pattern[str]] = None
+    ) -> Optional[Pattern[str]]:
+        if not self.config.has_option(section, key):
+            return default
+        raw = self.config.get(section, key).strip()
+        if not raw:
+            return default
+        try:
+            return re.compile(raw, re.IGNORECASE)
+        except re.error as exc:
+            raise ConfigSettingsError(
+                f"Invalid regex for '{key}' in [{section}]: {exc}"
+            ) from exc
+
+    def get_par2_config(self, backup_definition: Optional[str] = None) -> dict:
+        """
+        Return PAR2 settings, applying per-backup overrides when present.
+        """
+        par2_config = {
+            "par2_dir": self.par2_dir,
+            "par2_ratio_full": self.par2_ratio_full,
+            "par2_ratio_diff": self.par2_ratio_diff,
+            "par2_ratio_incr": self.par2_ratio_incr,
+            "par2_run_verify": self.par2_run_verify,
+            "par2_enabled": self.par2_enabled,
+        }
+
+        if not backup_definition or not self.config.has_section(backup_definition):
+            return par2_config
+
+        section = self.config[backup_definition]
+        for raw_key, raw_value in section.items():
+            key = raw_key.upper()
+            value = raw_value.strip()
+            if not key.startswith("PAR2_"):
+                continue
+            if key == "PAR2_DIR":
+                par2_config["par2_dir"] = value
+            elif key == "PAR2_RATIO_FULL":
+                par2_config["par2_ratio_full"] = int(value)
+            elif key == "PAR2_RATIO_DIFF":
+                par2_config["par2_ratio_diff"] = int(value)
+            elif key == "PAR2_RATIO_INCR":
+                par2_config["par2_ratio_incr"] = int(value)
+            elif key == "PAR2_RUN_VERIFY":
+                val = value.lower()
+                if val in ('true', '1', 'yes'):
+                    par2_config["par2_run_verify"] = True
+                elif val in ('false', '0', 'no'):
+                    par2_config["par2_run_verify"] = False
+                else:
+                    raise ConfigSettingsError(f"Invalid boolean value for 'PAR2_RUN_VERIFY' in [{backup_definition}]: '{value}'")
+            elif key == "PAR2_ENABLED":
+                val = value.lower()
+                if val in ('true', '1', 'yes'):
+                    par2_config["par2_enabled"] = True
+                elif val in ('false', '0', 'no'):
+                    par2_config["par2_enabled"] = False
+                else:
+                    raise ConfigSettingsError(f"Invalid boolean value for 'PAR2_ENABLED' in [{backup_definition}]: '{value}'")
 
+        return par2_config

dar_backup/dar-backup.conf

@@ -9,10 +9,22 @@ LOGFILE_LOCATION = ~/dar-backup/dar-backup.log
 MAX_SIZE_VERIFICATION_MB = 20
 MIN_SIZE_VERIFICATION_MB = 1
 NO_FILES_VERIFICATION = 5
+# Optional restore test filters (case-insensitive)
+# RESTORETEST_EXCLUDE_PREFIXES = .cache/, .local/share/Trash/, .mozilla/
+# RESTORETEST_EXCLUDE_SUFFIXES = .sqlite-wal, .sqlite-shm, .log, .tmp, .lock, .journal
+# RESTORETEST_EXCLUDE_REGEX = (^|/)(Cache|Logs)/   # optional extra noise
 # 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 CommandRunner, a default timeout of 30 secs is used.
 COMMAND_TIMEOUT_SECS = 86400
+# Optional limit on captured command output (in bytes). Output beyond this
+# size is still logged but not kept in memory. Use 0 to avoid buffering entirely.
+# Default is 102400.
+# COMMAND_CAPTURE_MAX_BYTES = 102400
+#DAR_BACKUP_DISCORD_WEBHOOK_URL = https://discord.com/api/webhooks/<id>/<token>
+# Optional Trace log configuration (debug level logs with stack traces)
+# TRACE_LOG_MAX_BYTES = 10485760  # 10 MB default
+# TRACE_LOG_BACKUP_COUNT = 1      # 1 backup file default
 
 [DIRECTORIES]
 BACKUP_DIR = @@BACKUP_DIR@@
@@ -31,6 +43,12 @@ INCR_AGE = 40
 [PAR2]
 ERROR_CORRECTION_PERCENT = 5
 ENABLED = True
+# Optional PAR2 configuration
+# PAR2_DIR = /path/to/par2-store
+# PAR2_RATIO_FULL = 10
+# PAR2_RATIO_DIFF = 5
+# PAR2_RATIO_INCR = 5
+# PAR2_RUN_VERIFY = false
 
 [PREREQ]
 #SCRIPT_1 = <pre-script 1>

dar_backup/dar-backup.conf.j2

@@ -29,10 +29,19 @@ LOGFILE_LOCATION = {{ vars_map.DAR_BACKUP_DIR -}}/dar-backup.log
 # optional parameters
 # LOGFILE_MAX_BYTES = 26214400  # 25 MB default, change as neeeded
 # LOGFILE_BACKUP_COUNT = 5      # default, change as needed
+# DAR_BACKUP_DISCORD_WEBHOOK_URL **should really** be given as an environment variable for security reasons
+# DAR_BACKUP_DISCORD_WEBHOOK_URL = https://discord.com/api/webhooks/<id>/<token>
+# Optional Trace log configuration (debug level logs with stack traces)
+# TRACE_LOG_MAX_BYTES = 10485760  # 10 MB default
+# TRACE_LOG_BACKUP_COUNT = 1      # 1 backup file default
 
 MAX_SIZE_VERIFICATION_MB = 2
 MIN_SIZE_VERIFICATION_MB = 0
 NO_FILES_VERIFICATION = 1
+# Optional restore test filters (case-insensitive)
+# RESTORETEST_EXCLUDE_PREFIXES = .cache/, .local/share/Trash/, .mozilla/
+# RESTORETEST_EXCLUDE_SUFFIXES = .sqlite-wal, .sqlite-shm, .log, .tmp, .lock, .journal
+# RESTORETEST_EXCLUDE_REGEX = (^|/)(Cache|Logs)/
 # 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 CommandRunner, a default timeout of 30 secs is used.
@@ -54,7 +63,15 @@ INCR_AGE = 40
 
 [PAR2]
 ERROR_CORRECTION_PERCENT = 5
+# Enable or disable PAR2 generation globally
 ENABLED = True
+# Optional PAR2 configuration
+# PAR2_DIR = /path/to/par2-store
+# PAR2_RATIOs are meuasured as percentages. Same function as ERROR_CORRECTION_PERCENT
+# PAR2_RATIO_FULL = 10
+# PAR2_RATIO_DIFF = 5
+# PAR2_RATIO_INCR = 5
+# PAR2_RUN_VERIFY = false
 
 [PREREQ]
 #SCRIPT_1 = <pre-script 1>
@@ -62,3 +79,30 @@ ENABLED = True
 [POSTREQ]
 #SCRIPT_1 = <post-script 1>
 
+#######################################################################
+## Per-backup configuration example overrides
+#######################################################################
+#
+## --------------------------------------------------------------------
+## Per-backup overrides (section name must match backup.d filename stem)
+## Example: backup.d/home.conf  ->  [home]
+## --------------------------------------------------------------------
+#
+##[home]
+## Disable PAR2 entirely for this backup definition
+#PAR2_ENABLED = false
+##
+##[media]
+## Store PAR2 files in a separate location for this backup definition
+##PAR2_DIR = /samba/par2/media
+## Raise redundancy only for FULL
+##
+#[documents]
+## Run verify par2 sets after creation
+#PAR2_RUN_VERIFY = true
+##
+##[etc]
+## Keep global PAR2 settings but tweak ratios for this backup definition
+##PAR2_RATIO_FULL = 15
+##PAR2_RATIO_DIFF = 8
+##PAR2_RATIO_INCR = 8