Port Home Assistant backup script to Go (v3.1.1)

Rewrite home_assistant_backup.sh as a single Go binary that reads the
existing home_assistant_backup.conf unchanged.

- Create a backup over SSH, scp it locally, and prune old backups both
  on the HA host (when free space is low) and locally
- Send ntfy and Discord notifications at the same points as the script
- Drop the jq and yq dependencies: parse `ha backups --raw-json` and
  `ha backup new --raw-json` in Go, falling back to `slug:` line parsing
- Add timestamped progress output, a heartbeat while HA builds the
  backup, and live size/percent/speed reporting during the copy
- Build the Discord payload with json.Marshal and validate backup slugs
  before using them in remote commands
- Abort with a notification if the remote disk-space check fails
- Add -config and -version flags
- Build with CGO_ENABLED=0 for a static binary that runs on older glibc

README.md

@@ -1,3 +1,80 @@
-# Home-Assistant-Backup-Script
+# Home Assistant Backup Automation Scripts
+
+These scripts automate the backup process for **Home Assistant** servers, enabling you to create, transfer, and manage backups. The backups are securely transferred from the Home Assistant server to your local machine, with options for cleaning up old backups based on configurable retention periods.
+
+## Overview
+
+### Features:
+
+- **Backup Creation**: Automates the process of creating backups on your Home Assistant server.
+- **Backup Transfer**: Transfers the generated backups to a local machine for safekeeping.
+- **Old Backup Cleanup**: Automatically cleans up old backups on both the Home Assistant server and local machine after a specified retention period.
+- **Notification Support** (Optional): Configure **ntfy** or **Discord** notifications to alert you about the backup status (available in the first script version).
+  
+### Two Versions of the Script:
+
+1. **Version 1: Simple Backup with Cleanup**  
+   A simpler version that creates a backup, copies it to your local machine, and performs a basic cleanup of old backups locally. No notification system is included in this version.
+
+2. **Version 2: Full Backup and Cleanup with Notifications**  
+   This version includes backup creation, local and remote cleanup of old backups, and optional notifications via **ntfy** and **Discord**. It also checks for available disk space before cleaning up old backups.
+   
+## Requirements
+
+Both scripts require the following to function correctly:
+
+- **Bash shell** (on your local machine and Home Assistant server)
+- **SSH** access to the Home Assistant server
+- **`scp`** and **`ssh`** tools
+- **Home Assistant** installed on the server with the `ha` CLI tool
+- **Optional**: Access to a notification service (for Version 2)
+
+## Configuration
+
+Before running either script, you need to set up a few configuration parameters. These include SSH credentials, backup destination paths, and notification settings.
+
+- **HA_SSH_KEY**: Path to your private SSH key for accessing the Home Assistant server.
+- **HA_SSH_USER**: The SSH username (default is `root`).
+- **HA_SSH_HOST**: The IP address or hostname of your Home Assistant server.
+- **BACKUP_DEST**: Path to the directory where backups will be saved locally.
+- **Retention Settings**: You can configure how long old backups are kept before they are deleted (default is 30 days for local and remote backups).
+- **Optional**: Set up **ntfy** or **Discord** notifications to receive alerts when backups are created or when errors occur.
+
+## How to Use
+
+### Step 1: Configure the Script
+Open the script file in a text editor and set the following variables:
+- **SSH credentials** (`HA_SSH_KEY`, `HA_SSH_USER`, `HA_SSH_HOST`)
+- **Backup destination path** (`BACKUP_DEST`)
+- **Notification settings** (optional)
+
+### Step 2: Make the Script Executable
+
+After configuring the script, make it executable by running:
+```
+chmod +x home_assistant_backup.sh
+```
+
+## Disclaimer
+
+**The software is provided "as-is" without any warranties or guarantees of any kind.**
+
+By using this script, you acknowledge and agree that:
+
+- **No Warranty**: The script is provided without any warranty of any kind, either express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement. The entire risk arising out of the use or performance of the script remains with you.
+
+- **Data Loss**: The author cannot be held responsible for any data loss, damage to your system, or any other kind of loss resulting from the use of this script. You are solely responsible for backing up your data and ensuring the integrity of your systems before using the script.
+
+- **Use at Your Own Risk**: You are using this script at your own risk. The author shall not be liable for any damages, including but not limited to direct, indirect, incidental, special, consequential, or punitive damages, arising out of the use of or inability to use the script.
+
+- **No Support**: The script is provided "as-is" with no formal support or maintenance. The author does not provide any guarantees of continued functionality, updates, or support.
+
+- **Modifications and Redistribution**: If you modify or redistribute the script, you do so at your own risk. You are solely responsible for ensuring that any modifications or redistributed versions do not cause harm or violate any laws.
+
+By using or modifying this script, you agree to indemnify and hold harmless the author from any and all claims, damages, liabilities, and expenses arising from your use or modification of the script.
+
+---
+
+Use of this script is subject to the terms above. If you do not agree with this disclaimer, you should not use the script.
+
 
-A script that when ran, creates a backup of Home Assistant using the "ha backup new" command over SSH, then pulls the .tar file from the HA system on to the system that the script is running on

V1/README.md

@@ -0,0 +1,70 @@
+# Home Assistant Backup Script
+
+This script automates the process of creating and copying backups from a Home Assistant server to a local machine. It includes functionality for:
+
+- Creating a new backup on the Home Assistant server.
+- Copying the backup file to a specified local destination.
+- Cleaning up old backups based on a specified retention period.
+
+## Requirements
+
+- Bash shell
+- SSH access to your Home Assistant server
+- `scp` and `ssh` tools
+- Access to a Home Assistant server with the `ha` command line tool installed
+
+## Configuration
+
+Before using the script, you need to configure the following variables:
+
+### Global Settings
+
+- **HA_SSH_KEY**: Path to your SSH private key for accessing the Home Assistant server.
+- **HA_SSH_USER**: The SSH username to use for connecting to the Home Assistant server (usually `root`).
+- **HA_SSH_HOST**: The IP address or hostname of your Home Assistant server.
+- **BACKUP_DEST**: The destination directory on your local machine where the backup file will be stored.
+
+### Backup Retention
+
+- The script will automatically clean up backup files on the local machine that are older than 30 days. You can adjust this retention period by modifying the `-mtime +30` argument in the `find` command to a different number of days.
+
+## Script Flow
+
+1. **Backup Creation**: The script connects to the Home Assistant server via SSH and creates a new backup using the `ha backup new` command. It generates a timestamped name for the backup.
+2. **Backup Transfer**: The backup file is copied from the Home Assistant server to your local machine using `scp`.
+3. **Local Backup Cleanup**: The script will automatically remove local backups that are older than the configured retention period (default is 30 days).
+4. **Completion Message**: A success message is displayed after the backup process is complete.
+
+## Usage
+
+1. **Clone or Download the Script**:
+   - Clone the repository or download the script file.
+
+2. **Make the Script Executable**:
+```
+   chmod +x home_assistant_backup.sh
+```
+
+## Disclaimer
+
+
+**The software is provided "as-is" without any warranties or guarantees of any kind.**
+
+By using this script, you acknowledge and agree that:
+
+- **No Warranty**: The script is provided without any warranty of any kind, either express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement. The entire risk arising out of the use or performance of the script remains with you.
+
+- **Data Loss**: The author cannot be held responsible for any data loss, damage to your system, or any other kind of loss resulting from the use of this script. You are solely responsible for backing up your data and ensuring the integrity of your systems before using the script.
+
+- **Use at Your Own Risk**: You are using this script at your own risk. The author shall not be liable for any damages, including but not limited to direct, indirect, incidental, special, consequential, or punitive damages, arising out of the use of or inability to use the script.
+
+- **No Support**: The script is provided "as-is" with no formal support or maintenance. The author does not provide any guarantees of continued functionality, updates, or support.
+
+- **Modifications and Redistribution**: If you modify or redistribute the script, you do so at your own risk. You are solely responsible for ensuring that any modifications or redistributed versions do not cause harm or violate any laws.
+
+By using or modifying this script, you agree to indemnify and hold harmless the author from any and all claims, damages, liabilities, and expenses arising from your use or modification of the script.
+
+---
+
+Use of this script is subject to the terms above. If you do not agree with this disclaimer, you should not use the script.
+

V2/README.md

@@ -0,0 +1,90 @@
+# Home Assistant Backup Script
+
+This script automates the process of creating, copying, and cleaning up backups for a Home Assistant server. It supports the ability to:
+
+- Create a backup on the Home Assistant server.
+- Copy the backup file to a local machine.
+- Clean up old backups on both the local machine and Home Assistant server.
+- Send notifications to `ntfy` and Discord.
+
+## Requirements
+
+- Bash shell
+- SSH access to your Home Assistant server
+- `scp` and `ssh`
+- `yq` for parsing YAML (https://github.com/mikefarah/yq)
+- `jq` for parsing JSON (https://github.com/jqlang/jq)
+- `curl` for sending notifications
+- Access to a Discord webhook URL (if using Discord notifications) (https://support.discord.com/hc/en-us/articles/228383668-Intro-to-Webhooks)
+- ntfy.sh server (if using ntfy.sh notifications) (https://ntfy.sh/)
+## Configuration
+
+Before using the script, you need to set up the following environment variables in the script:
+
+### Global Settings
+
+- **HA_SSH_KEY**: Path to your SSH private key for Home Assistant.
+- **HA_SSH_USER**: Username for SSH login (usually `root`).
+- **HA_SSH_HOST**: IP address or hostname of your Home Assistant server.
+- **HA_SSH_PORT**: SSH port (default is 22).
+- **BACKUP_DEST**: Destination directory for storing local backups.
+- **BACKUP_FILE_LOCATION**: Location of the backups on the Home Assistant server (default is `/backup`).
+- **LOCAL_BACKUP_CLEANUP**: Number of days to keep local backups (default is 90 days).
+- **REMOTE_BACKUP_CLEANUP**: Number of days to keep backups on the Home Assistant server (default is 30 days).
+- **NTFY_ENABLED**: Set to `true` to enable `ntfy` notifications.
+- **NTFY_SERVER**: The FQDN of your `ntfy` server.
+- **NTFY_TOPIC**: The topic for your `ntfy` notifications.
+- **DISCORD_ENABLED**: Set to `true` to enable Discord notifications.
+- **DISCORD_WEBHOOK_URL**: Your Discord webhook URL.
+- **STORAGE_THRESHOLD_KB**: The disk space threshold in KB for triggering cleanup (default is 2GB).
+
+### Notifications
+
+- **ntfy**: Notifications are sent via HTTP POST to your `ntfy` server.
+- **Discord**: Notifications are sent via a Discord webhook.
+
+Set `NTFY_ENABLED` and `DISCORD_ENABLED` to `true` to enable notifications for respective services. Replace the relevant URLs and topics.
+
+## Script Flow
+
+1. **Backup Creation**: The script first creates a backup on the Home Assistant server.
+2. **Disk Space Check**: It checks available disk space on the Home Assistant server. If it is less than the specified threshold, it will clean up old backups on the Home Assistant server.
+3. **Backup Transfer**: The backup file is then copied from the Home Assistant server to the local backup destination.
+4. **Local Cleanup**: Old backups are removed from the local machine if they exceed the specified retention period.
+5. **Notification**: Notifications are sent at each major step (e.g., start of backup, successful backup, cleanup actions) via `ntfy` and Discord if enabled.
+6. **Backup File Size and Script Runtime**: The script reports the backup file size and runtime after completing the backup process.
+
+## Usage
+
+1. **Clone or Download the Script**:
+   - Clone the repository or download the script file.
+
+2. **Make the Script Executable**:
+   ```bash
+   chmod +x home_assistant_backup.sh
+
+
+## Disclaimer
+
+
+**The software is provided "as-is" without any warranties or guarantees of any kind.**
+
+By using this script, you acknowledge and agree that:
+
+- **No Warranty**: The script is provided without any warranty of any kind, either express or implied, including but not limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement. The entire risk arising out of the use or performance of the script remains with you.
+
+- **Data Loss**: The author cannot be held responsible for any data loss, damage to your system, or any other kind of loss resulting from the use of this script. You are solely responsible for backing up your data and ensuring the integrity of your systems before using the script.
+
+- **Use at Your Own Risk**: You are using this script at your own risk. The author shall not be liable for any damages, including but not limited to direct, indirect, incidental, special, consequential, or punitive damages, arising out of the use of or inability to use the script.
+
+- **No Support**: The script is provided "as-is" with no formal support or maintenance. The author does not provide any guarantees of continued functionality, updates, or support.
+
+- **Modifications and Redistribution**: If you modify or redistribute the script, you do so at your own risk. You are solely responsible for ensuring that any modifications or redistributed versions do not cause harm or violate any laws.
+
+By using or modifying this script, you agree to indemnify and hold harmless the author from any and all claims, damages, liabilities, and expenses arising from your use or modification of the script.
+
+---
+
+Use of this script is subject to the terms above. If you do not agree with this disclaimer, you should not use the script.
+
+

V2/home_assistant_backup.conf

@@ -0,0 +1,32 @@
+### Global Settings ###
+# Set your Home Assistant SSH credentials
+HA_SSH_KEY="SSH_PRIVATE_KEY"  # Replace with your SSH Private key for HomeAssistant
+HA_SSH_USER="SSH_USER"        # Replace with your HomeAssistant server username (Default is root)
+HA_SSH_HOST="SSH_HOST_IP_OR_HOSTNAME"  # Replace with your HomeAssistant server IP address
+HA_SSH_PORT="SSH_PORT"        # Replace with your HomeAssistant server port
+
+## Storage
+# Set the backup destination path
+BACKUP_DEST="BACKUP_FILE_DESTINATION" # Replace with the location for the backup files
+
+# Set the location of the Home Assistant backups (Set to default location /backup)
+# If you have a custom install, using the likes of Supervised
+# this location should normally be /usr/share/hassio/backup
+BACKUP_FILE_LOCATION="/backup"
+
+# Storage threshold (in KB) for triggering cleanup
+STORAGE_THRESHOLD_KB=2097152  # 2GB = 2 * 1024 * 1024 KB
+# Set clean up old backups (adjust the number of days to keep)
+LOCAL_BACKUP_CLEANUP="90"  # Set the number of days that local backup files will be kept for (Default 90 days)
+REMOTE_BACKUP_CLEANUP="30" # Set the number of days that backups on the Home Assistant server will be kept for (Default 30 days)
+
+## Notification Settings
+# ntfy settings
+NTFY_ENABLED=false  # Set to 'true' to enable ntfy notifications
+NTFY_SERVER="NTFY_SERVER_FQDN_ADDRESS"  # Replace with your ntfy server address
+NTFY_TOPIC="NTFY_TOPIC"  # Replace with your ntfy topic
+
+# Discord webhook settings
+DISCORD_ENABLED=false  # Set to 'true' to enable Discord notifications
+DISCORD_WEBHOOK_URL="DISCORD_WEBHOOK_URL"  # Replace with your Discord webhook URL
+

V2/home_assistant_backup.sh

@@ -0,0 +1,222 @@
+#!/bin/bash
+#set -x 
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+CONFIG_FILE="$SCRIPT_DIR/home_assistant_backup.conf"
+
+if [ ! -f "$CONFIG_FILE" ]; then
+    echo "Error: Config file not found: $CONFIG_FILE"
+    exit 1
+fi
+
+# Load variables
+# shellcheck disable=SC1090
+source "$CONFIG_FILE"
+
+### Script ###
+## Sanity Check##
+# Function to check if the necessary variables are set and if jq and yq are installed
+sanity_check() {
+    # Check if jq and yq are installed
+    if ! command -v jq &> /dev/null; then
+        echo "Error: jq is not installed. Please install jq before running this script."
+        exit 1
+    fi
+    
+    if ! command -v yq &> /dev/null; then
+        echo "Error: yq is not installed. Please install yq before running this script."
+        exit 1
+    fi
+    
+    # Check for each variable
+    if [ -z "$HA_SSH_KEY" ] || [ "$HA_SSH_KEY" == "SSH_PRIVATE_KEY" ]; then
+        echo "Error: SSH_PRIVATE_KEY is not set."
+        exit 1
+    fi
+
+    if [ -z "$HA_SSH_USER" ] || [ "$HA_SSH_USER" == "SSH_USER" ]; then
+        echo "Error: SSH_USER is not set."
+        exit 1
+    fi
+
+    if [ -z "$HA_SSH_HOST" ] || [ "$HA_SSH_HOST" == "SSH_HOST_IP_OR_HOSTNAME" ]; then
+        echo "Error: SSH_HOST_IP_OR_HOSTNAME is not set."
+        exit 1
+    fi
+
+    if [ -z "$HA_SSH_PORT" ] || [ "$HA_SSH_PORT" == "SSH_PORT" ]; then
+        echo "Error: SSH_PORT is not set."
+        exit 1
+    fi
+
+    if [ -z "$BACKUP_DEST" ] || [ "$BACKUP_DEST" == "BACKUP_FILE_DESTINATION" ]; then
+        echo "Error: BACKUP_FILE_DESTINATION is not set."
+        exit 1
+    fi
+
+    if [ "$NTFY_ENABLED" == "true" ]; then
+        if [ -z "$NTFY_SERVER" ] || [ "$NTFY_SERVER" == "NTFY_SERVER_FQDN_ADDRESS" ]; then
+            echo "Error: NTFY_SERVER_FQDN_ADDRESS is not set."
+            exit 1
+        fi
+        if [ -z "$NTFY_TOPIC" ] || [ "$NTFY_TOPIC" == "NTFY_TOPIC" ]; then
+            echo "Error: NTFY_TOPIC is not set."
+            exit 1
+        fi
+    fi
+
+    if [ "$DISCORD_ENABLED" == "true" ]; then
+        if [ -z "$DISCORD_WEBHOOK_URL" ] || [ "$DISCORD_WEBHOOK_URL" == "DISCORD_WEBHOOK_URL" ]; then
+            echo "Error: DISCORD_WEBHOOK_URL is not set."
+            exit 1
+        fi
+    fi
+}
+
+# Call the function to check requirements and variables
+sanity_check
+
+# Function to remove old backups from Home Assistant server (older than $REMOTE_BACKUP_CLEANUP days)
+remove_old_backups_ssh() {
+    echo "Removing backups older than $REMOTE_BACKUP_CLEANUP days on Home Assistant server..."
+
+    # Fetch the list of backups and parse the YAML output using yq
+    BACKUPS_OUTPUT=$(ssh -i "$HA_SSH_KEY" -p "$HA_SSH_PORT" "$HA_SSH_USER@$HA_SSH_HOST" "ha backups")
+    if ! echo "$BACKUPS_OUTPUT" | yq eval >/dev/null 2>&1; then
+        echo "Error: The output of 'ha backups' is not valid YAML."
+        return 1
+    fi
+
+    # Convert the YAML to JSON and extract old backups using jq
+    OLD_BACKUPS=$(echo "$BACKUPS_OUTPUT" | yq eval -o=json | jq --argjson days "$REMOTE_BACKUP_CLEANUP" -r '.backups[] | select((.date | sub("\\.[0-9]+\\+00:00$"; "Z") | fromdateiso8601) < (now - ($days * 86400))) | .slug')
+
+    # Remove each old backup by its slug
+    if [ -n "$OLD_BACKUPS" ]; then
+        for slug in $OLD_BACKUPS; do
+            echo "Removing backup with slug: $slug"
+            ssh -i "$HA_SSH_KEY" -p "$HA_SSH_PORT" "$HA_SSH_USER@$HA_SSH_HOST" "ha backups remove $slug"
+            if [ $? -eq 0 ]; then
+                echo "Successfully removed backup with slug: $slug"
+                send_ntfy_notification "Old backup removed: $slug"
+                send_discord_notification "Old backup removed: $slug"
+            else
+                echo "Failed to remove backup with slug: $slug"
+            fi
+        done
+    else
+        echo "No old backups found to remove."
+    fi
+}
+
+
+### Function for sending notifications ###
+send_ntfy_notification() {
+    local message=$1
+    if [ "$NTFY_ENABLED" = true ]; then
+        curl -X POST -d "$message" $NTFY_URL
+    fi
+}
+
+send_discord_notification() {
+    local message=$1
+    if [ "$DISCORD_ENABLED" = true ]; then
+        curl -X POST -H "Content-Type: application/json" -d '{"content": "'"$message"'"}' $DISCORD_WEBHOOK_URL
+    fi
+}
+
+# ntfy URL setup
+NTFY_URL="$NTFY_SERVER/$NTFY_TOPIC"
+
+# Timestamp variable for consistent naming
+TIMESTAMP=$(date '+%Y-%m-%d_%H-%M-%S')
+
+# Start the timer
+START_TIME=$(date +%s)
+
+# Send notification that backup has started
+send_ntfy_notification "Backup process started at $TIMESTAMP"
+send_discord_notification "Backup process started at $TIMESTAMP"
+
+# Check available disk space on Home Assistant server
+AVAILABLE_SPACE=$(ssh -i "$HA_SSH_KEY" -p "$HA_SSH_PORT" "$HA_SSH_USER@$HA_SSH_HOST" "df -k / | tail -n 1 | tr -s ' ' | cut -d ' ' -f 4")
+if [ "$AVAILABLE_SPACE" -lt "$STORAGE_THRESHOLD_KB" ]; then
+    echo "Disk space is less than 2GB on Home Assistant server. Proceeding with remote backup cleanup..."
+    # Remove old backups on Home Assistant server if less than 2GB available
+    remove_old_backups_ssh
+else
+    echo "Sufficient disk space available on Home Assistant server. Skipping remote backup cleanup."
+fi
+
+# Create a backup on the Home Assistant server and extract the slug
+BACKUP_OUTPUT=$(ssh -i "$HA_SSH_KEY" -p "$HA_SSH_PORT" "$HA_SSH_USER@$HA_SSH_HOST" "ha backup new --name=auto_backup_$TIMESTAMP")
+if [ $? -ne 0 ]; then
+    # Send notification if backup creation fails
+    send_ntfy_notification "Error: Failed to create backup on Home Assistant server."
+    send_discord_notification "Error: Failed to create backup on Home Assistant server."
+    echo "Error: Failed to create backup on Home Assistant server."
+    exit 1
+fi
+
+# Extract the backup slug and strip any carriage return characters
+BACKUP_SLUG=$(echo "$BACKUP_OUTPUT" | awk '/slug:/ {print $2}' | tr -d '\r')
+if [ -z "$BACKUP_SLUG" ]; then
+    # Send notification if backup slug extraction fails
+    send_ntfy_notification "Error: Failed to extract backup slug."
+    send_discord_notification "Error: Failed to extract backup slug."
+    echo "Error: Failed to extract backup slug."
+    exit 1
+fi
+
+# Send notification that backup was created
+send_ntfy_notification "Backup created successfully with slug: $BACKUP_SLUG"
+send_discord_notification "Backup created successfully with slug: $BACKUP_SLUG"
+
+# Create a filename for the backup
+BACKUP_FILE="$BACKUP_DEST/${TIMESTAMP}_${BACKUP_SLUG}.tar"
+
+# Copy the backup file from Home Assistant to your local machine
+scp -i "$HA_SSH_KEY" -P "$HA_SSH_PORT" "$HA_SSH_USER@$HA_SSH_HOST:$BACKUP_FILE_LOCATION/${BACKUP_SLUG}.tar" "$BACKUP_FILE"
+if [ $? -ne 0 ]; then
+    # Send notification if backup copy fails
+    send_ntfy_notification "Error: Failed to copy backup to local machine."
+    send_discord_notification "Error: Failed to copy backup to local machine."
+    echo "Error: Failed to copy backup to local machine."
+    exit 1
+fi
+
+# Get the size of the backup file
+BACKUP_FILE_SIZE=$(stat -c %s "$BACKUP_FILE")
+if [ $? -ne 0 ]; then
+    send_ntfy_notification "Error: Failed to get backup file size."
+    send_discord_notification "Error: Failed to get backup file size."
+    echo "Error: Failed to get backup file size."
+    exit 1
+fi
+
+# Clean up old backups locally (older than $LOCAL_BACKUP_CLEANUP days)
+find "$BACKUP_DEST" -name '*.tar' -mtime +$LOCAL_BACKUP_CLEANUP -exec rm {} \;
+if [ $? -ne 0 ]; then
+    # Send notification if cleanup fails
+    send_ntfy_notification "Error: Failed to clean up old backups locally."
+    send_discord_notification "Error: Failed to clean up old backups locally."
+    echo "Error: Failed to clean up old backups locally."
+    exit 1
+fi
+
+# Send notification that the cleanup was successful
+send_ntfy_notification "Old backups cleaned up successfully."
+send_discord_notification "Old backups cleaned up successfully."
+
+# Success message
+echo "Backup completed successfully: $BACKUP_FILE"
+send_ntfy_notification "Backup completed successfully: $BACKUP_FILE"
+send_discord_notification "Backup completed successfully: $BACKUP_FILE"
+
+# Get the total time taken by the script
+END_TIME=$(date +%s)
+RUNTIME=$((END_TIME - START_TIME))
+
+# Send notification with backup file size and script runtime
+send_ntfy_notification "Backup file size: $BACKUP_FILE_SIZE bytes. Script runtime: $RUNTIME seconds."
+send_discord_notification "Backup file size: $BACKUP_FILE_SIZE bytes. Script runtime: $RUNTIME seconds."
+

V3/README.md

@@ -0,0 +1,22 @@
+# ha-backup v3.1.1
+
+Go port of `home_assistant_backup.sh`. Uses the same `home_assistant_backup.conf`.
+
+## Build
+    CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o ha-backup .
+
+Override the version at build time if needed:
+    CGO_ENABLED=0 go build -trimpath -ldflags="-s -w -X main.version=3.1.2" -o ha-backup .
+
+Check the version:
+    ./ha-backup -version
+
+Cross-compile examples:
+    GOOS=linux GOARCH=amd64 go build -o ha-backup-linux-amd64 .
+    GOOS=linux GOARCH=arm64 go build -o ha-backup-linux-arm64 .   # Raspberry Pi / ARM NAS
+
+## Run
+    ./ha-backup                       # looks for home_assistant_backup.conf next to the binary, then in cwd
+    ./ha-backup -config /path/to.conf
+
+Requires `ssh` and `scp` on the machine running it. `jq` and `yq` are no longer needed.

V3/go.mod

@@ -0,0 +1,3 @@
+module ha-backup
+
+go 1.21

V3/home_assistant_backup.conf

@@ -0,0 +1,32 @@
+### Global Settings ###
+# Set your Home Assistant SSH credentials
+HA_SSH_KEY="SSH_PRIVATE_KEY"  # Replace with your SSH Private key for HomeAssistant
+HA_SSH_USER="SSH_USER"        # Replace with your HomeAssistant server username (Default is root)
+HA_SSH_HOST="SSH_HOST_IP_OR_HOSTNAME"  # Replace with your HomeAssistant server IP address
+HA_SSH_PORT="SSH_PORT"        # Replace with your HomeAssistant server port
+
+## Storage
+# Set the backup destination path
+BACKUP_DEST="BACKUP_FILE_DESTINATION" # Replace with the location for the backup files
+
+# Set the location of the Home Assistant backups (Set to default location /backup)
+# If you have a custom install, using the likes of Supervised
+# this location should normally be /usr/share/hassio/backup
+BACKUP_FILE_LOCATION="/backup"
+
+# Storage threshold (in KB) for triggering cleanup
+STORAGE_THRESHOLD_KB=2097152  # 2GB = 2 * 1024 * 1024 KB
+# Set clean up old backups (adjust the number of days to keep)
+LOCAL_BACKUP_CLEANUP="90"  # Set the number of days that local backup files will be kept for (Default 90 days)
+REMOTE_BACKUP_CLEANUP="30" # Set the number of days that backups on the Home Assistant server will be kept for (Default 30 days)
+
+## Notification Settings
+# ntfy settings
+NTFY_ENABLED=false  # Set to 'true' to enable ntfy notifications
+NTFY_SERVER="NTFY_SERVER_FQDN_ADDRESS"  # Replace with your ntfy server address
+NTFY_TOPIC="NTFY_TOPIC"  # Replace with your ntfy topic
+
+# Discord webhook settings
+DISCORD_ENABLED=false  # Set to 'true' to enable Discord notifications
+DISCORD_WEBHOOK_URL="DISCORD_WEBHOOK_URL"  # Replace with your Discord webhook URL
+

V3/main.go

@@ -0,0 +1,615 @@
+// ha-backup v3.1.1: creates a Home Assistant backup over SSH, copies it locally,
+// prunes old backups (remote and local) and sends optional ntfy/Discord
+// notifications. Go port of home_assistant_backup.sh.
+//
+// Only the standard library is used. The system `ssh` and `scp` binaries are
+// still required (same as the original script), but `jq` and `yq` are not.
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io/fs"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// ---------------------------------------------------------------------------
+// Configuration (reads the same KEY="value" # comment format as the .sh script)
+// ---------------------------------------------------------------------------
+
+const defaultConfigName = "home_assistant_backup.conf"
+
+// version is the release version. It can be overridden at build time with:
+//
+//	go build -ldflags "-X main.version=3.1.2"
+var version = "3.1.1"
+
+type Config struct {
+	SSHKey  string
+	SSHUser string
+	SSHHost string
+	SSHPort string
+
+	BackupDest         string
+	BackupFileLocation string
+	StorageThresholdKB int64
+	LocalCleanupDays   int
+	RemoteCleanupDays  int
+
+	NtfyEnabled bool
+	NtfyServer  string
+	NtfyTopic   string
+
+	DiscordEnabled    bool
+	DiscordWebhookURL string
+}
+
+func parseValue(raw string) string {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return ""
+	}
+	if raw[0] == '"' || raw[0] == '\'' {
+		q := raw[0]
+		if end := strings.IndexByte(raw[1:], q); end >= 0 {
+			return raw[1 : 1+end]
+		}
+		return raw[1:]
+	}
+	// Unquoted: strip trailing comment (a '#' preceded by whitespace).
+	for i := 1; i < len(raw); i++ {
+		if raw[i] == '#' && (raw[i-1] == ' ' || raw[i-1] == '\t') {
+			raw = raw[:i]
+			break
+		}
+	}
+	return strings.TrimSpace(raw)
+}
+
+func readConfFile(path string) (map[string]string, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	vals := map[string]string{}
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		line := strings.TrimSpace(sc.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		line = strings.TrimPrefix(line, "export ")
+		k, v, ok := strings.Cut(line, "=")
+		if !ok {
+			continue
+		}
+		vals[strings.TrimSpace(k)] = parseValue(v)
+	}
+	return vals, sc.Err()
+}
+
+func loadConfig(path string) (*Config, error) {
+	m, err := readConfFile(path)
+	if err != nil {
+		return nil, err
+	}
+
+	get := func(key, def string) string {
+		if v, ok := m[key]; ok && v != "" {
+			return v
+		}
+		return def
+	}
+
+	cfg := &Config{
+		SSHKey:             get("HA_SSH_KEY", ""),
+		SSHUser:            get("HA_SSH_USER", ""),
+		SSHHost:            get("HA_SSH_HOST", ""),
+		SSHPort:            get("HA_SSH_PORT", ""),
+		BackupDest:         get("BACKUP_DEST", ""),
+		BackupFileLocation: strings.TrimRight(get("BACKUP_FILE_LOCATION", "/backup"), "/"),
+		NtfyEnabled:        get("NTFY_ENABLED", "false") == "true",
+		NtfyServer:         get("NTFY_SERVER", ""),
+		NtfyTopic:          get("NTFY_TOPIC", ""),
+		DiscordEnabled:     get("DISCORD_ENABLED", "false") == "true",
+		DiscordWebhookURL:  get("DISCORD_WEBHOOK_URL", ""),
+	}
+
+	if cfg.StorageThresholdKB, err = strconv.ParseInt(get("STORAGE_THRESHOLD_KB", "2097152"), 10, 64); err != nil {
+		return nil, fmt.Errorf("invalid STORAGE_THRESHOLD_KB: %w", err)
+	}
+	if cfg.LocalCleanupDays, err = strconv.Atoi(get("LOCAL_BACKUP_CLEANUP", "90")); err != nil {
+		return nil, fmt.Errorf("invalid LOCAL_BACKUP_CLEANUP: %w", err)
+	}
+	if cfg.RemoteCleanupDays, err = strconv.Atoi(get("REMOTE_BACKUP_CLEANUP", "30")); err != nil {
+		return nil, fmt.Errorf("invalid REMOTE_BACKUP_CLEANUP: %w", err)
+	}
+	return cfg, nil
+}
+
+// validate mirrors sanity_check() from the shell script.
+func (c *Config) validate() error {
+	type req struct{ val, placeholder, name string }
+	checks := []req{
+		{c.SSHKey, "SSH_PRIVATE_KEY", "HA_SSH_KEY"},
+		{c.SSHUser, "SSH_USER", "HA_SSH_USER"},
+		{c.SSHHost, "SSH_HOST_IP_OR_HOSTNAME", "HA_SSH_HOST"},
+		{c.SSHPort, "SSH_PORT", "HA_SSH_PORT"},
+		{c.BackupDest, "BACKUP_FILE_DESTINATION", "BACKUP_DEST"},
+	}
+	if c.NtfyEnabled {
+		checks = append(checks,
+			req{c.NtfyServer, "NTFY_SERVER_FQDN_ADDRESS", "NTFY_SERVER"},
+			req{c.NtfyTopic, "NTFY_TOPIC", "NTFY_TOPIC"})
+	}
+	if c.DiscordEnabled {
+		checks = append(checks, req{c.DiscordWebhookURL, "DISCORD_WEBHOOK_URL", "DISCORD_WEBHOOK_URL"})
+	}
+	for _, r := range checks {
+		if r.val == "" || r.val == r.placeholder {
+			return fmt.Errorf("%s is not set", r.name)
+		}
+	}
+	for _, bin := range []string{"ssh", "scp"} {
+		if _, err := exec.LookPath(bin); err != nil {
+			return fmt.Errorf("%s is not installed or not in PATH", bin)
+		}
+	}
+	return nil
+}
+
+// ---------------------------------------------------------------------------
+// Notifications
+// ---------------------------------------------------------------------------
+
+type Notifier struct {
+	cfg    *Config
+	client *http.Client
+}
+
+func NewNotifier(cfg *Config) *Notifier {
+	return &Notifier{cfg: cfg, client: &http.Client{Timeout: 15 * time.Second}}
+}
+
+func (n *Notifier) post(url, contentType string, body []byte) {
+	resp, err := n.client.Post(url, contentType, bytes.NewReader(body))
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "notification failed (%s): %v\n", url, err)
+		return
+	}
+	resp.Body.Close()
+	if resp.StatusCode >= 300 {
+		fmt.Fprintf(os.Stderr, "notification failed (%s): HTTP %d\n", url, resp.StatusCode)
+	}
+}
+
+// Send delivers msg to every enabled notification channel.
+func (n *Notifier) Send(msg string) {
+	if n.cfg.NtfyEnabled {
+		url := strings.TrimRight(n.cfg.NtfyServer, "/") + "/" + n.cfg.NtfyTopic
+		n.post(url, "text/plain", []byte(msg))
+	}
+	if n.cfg.DiscordEnabled {
+		body, _ := json.Marshal(map[string]string{"content": msg})
+		n.post(n.cfg.DiscordWebhookURL, "application/json", body)
+	}
+}
+
+// ---------------------------------------------------------------------------
+// SSH / SCP helpers (shell out to the system OpenSSH client)
+// ---------------------------------------------------------------------------
+
+type Remote struct{ cfg *Config }
+
+func (r Remote) target() string { return r.cfg.SSHUser + "@" + r.cfg.SSHHost }
+
+// run executes a command on the Home Assistant host and returns its stdout.
+// stderr is passed through to the terminal.
+func (r Remote) run(remoteCmd string) (string, error) {
+	cmd := exec.Command("ssh", "-i", r.cfg.SSHKey, "-p", r.cfg.SSHPort, r.target(), remoteCmd)
+	var out bytes.Buffer
+	cmd.Stdout = &out
+	cmd.Stderr = os.Stderr
+	err := cmd.Run()
+	return out.String(), err
+}
+
+func (r Remote) copyFrom(remotePath, localPath string) error {
+	cmd := exec.Command("scp", "-i", r.cfg.SSHKey, "-P", r.cfg.SSHPort,
+		r.target()+":"+remotePath, localPath)
+	cmd.Stdout = os.Stdout
+	cmd.Stderr = os.Stderr
+	return cmd.Run()
+}
+
+// availableKB returns free space (in KB) on the remote root filesystem.
+func (r Remote) availableKB() (int64, error) {
+	out, err := r.run("df -k / | tail -n 1")
+	if err != nil {
+		return 0, err
+	}
+	fields := strings.Fields(out)
+	if len(fields) < 4 {
+		return 0, fmt.Errorf("unexpected df output: %q", out)
+	}
+	return strconv.ParseInt(fields[3], 10, 64)
+}
+
+// ---------------------------------------------------------------------------
+// Home Assistant operations
+// ---------------------------------------------------------------------------
+
+var slugRe = regexp.MustCompile(`^[A-Za-z0-9_-]+$`)
+
+type backupEntry struct {
+	Slug string `json:"slug"`
+	Date string `json:"date"`
+}
+
+type backupListResp struct {
+	Backups []backupEntry `json:"backups"`
+	Data    struct {
+		Backups []backupEntry `json:"backups"`
+	} `json:"data"`
+}
+
+func (r Remote) listBackups() ([]backupEntry, error) {
+	out, err := r.run("ha backups --raw-json")
+	if err != nil {
+		return nil, err
+	}
+	var resp backupListResp
+	if err := json.Unmarshal([]byte(out), &resp); err != nil {
+		return nil, fmt.Errorf("could not parse 'ha backups' output as JSON: %w", err)
+	}
+	if len(resp.Data.Backups) > 0 {
+		return resp.Data.Backups, nil
+	}
+	return resp.Backups, nil
+}
+
+func removeOldRemoteBackups(r Remote, n *Notifier, days int) {
+	fmt.Printf("Removing backups older than %d days on Home Assistant server...\n", days)
+
+	backups, err := r.listBackups()
+	if err != nil {
+		fmt.Printf("Error: %v\n", err)
+		return
+	}
+
+	cutoff := time.Now().Add(-time.Duration(days) * 24 * time.Hour)
+	removed := 0
+	for _, b := range backups {
+		t, err := time.Parse(time.RFC3339Nano, b.Date)
+		if err != nil {
+			fmt.Printf("Skipping backup %s: cannot parse date %q\n", b.Slug, b.Date)
+			continue
+		}
+		if !t.Before(cutoff) {
+			continue
+		}
+		if !slugRe.MatchString(b.Slug) {
+			fmt.Printf("Skipping backup with unexpected slug %q\n", b.Slug)
+			continue
+		}
+		fmt.Printf("Removing backup with slug: %s\n", b.Slug)
+		if _, err := r.run("ha backups remove " + b.Slug); err != nil {
+			fmt.Printf("Failed to remove backup with slug: %s\n", b.Slug)
+			continue
+		}
+		removed++
+		fmt.Printf("Successfully removed backup with slug: %s\n", b.Slug)
+		n.Send("Old backup removed: " + b.Slug)
+	}
+	if removed == 0 {
+		fmt.Println("No old backups found to remove.")
+	}
+}
+
+type newBackupResp struct {
+	Data struct {
+		Slug string `json:"slug"`
+	} `json:"data"`
+	Slug string `json:"slug"`
+}
+
+// createBackup creates a backup and returns its slug.
+func (r Remote) createBackup(name string) (string, error) {
+	out, err := r.run("ha backup new --name=" + name + " --raw-json")
+	if err != nil {
+		return "", fmt.Errorf("failed to create backup on Home Assistant server: %w", err)
+	}
+
+	var resp newBackupResp
+	if json.Unmarshal([]byte(out), &resp) == nil {
+		if resp.Data.Slug != "" {
+			return strings.TrimSpace(resp.Data.Slug), nil
+		}
+		if resp.Slug != "" {
+			return strings.TrimSpace(resp.Slug), nil
+		}
+	}
+
+	// Fallback: plain-text "slug: xxxx" line (what the original script parsed).
+	for _, line := range strings.Split(out, "\n") {
+		line = strings.TrimSpace(strings.TrimRight(line, "\r"))
+		if strings.HasPrefix(line, "slug:") {
+			if s := strings.TrimSpace(strings.TrimPrefix(line, "slug:")); s != "" {
+				return s, nil
+			}
+		}
+	}
+	return "", fmt.Errorf("failed to extract backup slug")
+}
+
+// removeOldLocalBackups deletes *.tar files under dir that `find -mtime +days`
+// would match (age of at least days+1 full 24h periods).
+func removeOldLocalBackups(dir string, days int) error {
+	minAge := time.Duration(days+1) * 24 * time.Hour
+	now := time.Now()
+	return filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
+		if !d.Type().IsRegular() || !strings.HasSuffix(d.Name(), ".tar") {
+			return nil
+		}
+		info, err := d.Info()
+		if err != nil {
+			return err
+		}
+		if now.Sub(info.ModTime()) >= minAge {
+			return os.Remove(path)
+		}
+		return nil
+	})
+}
+
+// ---------------------------------------------------------------------------
+// main
+// ---------------------------------------------------------------------------
+
+// ---------------------------------------------------------------------------
+// Progress reporting
+// ---------------------------------------------------------------------------
+
+func logf(format string, a ...any) {
+	fmt.Printf("[%s] %s\n", time.Now().Format("15:04:05"), fmt.Sprintf(format, a...))
+}
+
+func humanBytes(n int64) string {
+	const unit = 1024
+	if n < unit {
+		return fmt.Sprintf("%d B", n)
+	}
+	div, exp := int64(unit), 0
+	for m := n / unit; m >= unit; m /= unit {
+		div *= unit
+		exp++
+	}
+	return fmt.Sprintf("%.1f %cB", float64(n)/float64(div), "KMGTPE"[exp])
+}
+
+func stdoutIsTerminal() bool {
+	fi, err := os.Stdout.Stat()
+	return err == nil && fi.Mode()&os.ModeCharDevice != 0
+}
+
+// withHeartbeat runs fn and prints a "still running" line every interval so
+// long operations don't look hung.
+func withHeartbeat(label string, interval time.Duration, fn func() error) error {
+	start := time.Now()
+	done := make(chan struct{})
+	go func() {
+		t := time.NewTicker(interval)
+		defer t.Stop()
+		for {
+			select {
+			case <-done:
+				return
+			case <-t.C:
+				logf("%s... still running (%s elapsed)", label, time.Since(start).Round(time.Second))
+			}
+		}
+	}()
+	err := fn()
+	close(done)
+	return err
+}
+
+// remoteSize returns the size in bytes of a file on the HA host (0 if unknown).
+func (r Remote) remoteSize(path string) int64 {
+	out, err := r.run("wc -c < '" + path + "'")
+	if err != nil {
+		return 0
+	}
+	f := strings.Fields(out)
+	if len(f) == 0 {
+		return 0
+	}
+	n, _ := strconv.ParseInt(f[0], 10, 64)
+	return n
+}
+
+// copyWithProgress runs scp while reporting how much has arrived locally.
+// On a terminal it updates a single line; otherwise (cron, logs) it prints a
+// line every 10 seconds.
+func (r Remote) copyWithProgress(remotePath, localPath string) error {
+	total := r.remoteSize(remotePath)
+	if total > 0 {
+		logf("Backup size on Home Assistant: %s", humanBytes(total))
+	}
+
+	tty := stdoutIsTerminal()
+	interval := 10 * time.Second
+	if tty {
+		interval = time.Second
+	}
+
+	stop := make(chan struct{})
+	stopped := make(chan struct{})
+	start := time.Now()
+	go func() {
+		defer close(stopped)
+		t := time.NewTicker(interval)
+		defer t.Stop()
+		for {
+			select {
+			case <-stop:
+				if tty {
+					fmt.Print("\r\033[K")
+				}
+				return
+			case <-t.C:
+				info, err := os.Stat(localPath)
+				if err != nil {
+					continue
+				}
+				cur := info.Size()
+				secs := time.Since(start).Seconds()
+				speed := int64(0)
+				if secs > 0 {
+					speed = int64(float64(cur) / secs)
+				}
+				var msg string
+				if total > 0 {
+					msg = fmt.Sprintf("Copying: %s / %s (%d%%) at %s/s",
+						humanBytes(cur), humanBytes(total), cur*100/total, humanBytes(speed))
+				} else {
+					msg = fmt.Sprintf("Copying: %s at %s/s", humanBytes(cur), humanBytes(speed))
+				}
+				if tty {
+					fmt.Printf("\r\033[K[%s] %s", time.Now().Format("15:04:05"), msg)
+				} else {
+					logf("%s", msg)
+				}
+			}
+		}
+	}()
+
+	err := r.copyFrom(remotePath, localPath)
+	close(stop)
+	<-stopped
+	return err
+}
+
+func findConfig(flagPath string) string {
+	if flagPath != "" {
+		return flagPath
+	}
+	if exe, err := os.Executable(); err == nil {
+		p := filepath.Join(filepath.Dir(exe), defaultConfigName)
+		if _, err := os.Stat(p); err == nil {
+			return p
+		}
+	}
+	return defaultConfigName // current working directory
+}
+
+func main() {
+	confFlag := flag.String("config", "", "path to config file (default: "+defaultConfigName+" next to the binary, then current directory)")
+	versionFlag := flag.Bool("version", false, "print version and exit")
+	flag.Parse()
+
+	if *versionFlag {
+		fmt.Printf("ha-backup v%s\n", version)
+		return
+	}
+
+	confPath := findConfig(*confFlag)
+	cfg, err := loadConfig(confPath)
+	if err != nil {
+		fmt.Printf("Error: cannot load config file %s: %v\n", confPath, err)
+		os.Exit(1)
+	}
+	if err := cfg.validate(); err != nil {
+		fmt.Printf("Error: %v\n", err)
+		os.Exit(1)
+	}
+
+	notify := NewNotifier(cfg)
+	remote := Remote{cfg: cfg}
+
+	fail := func(msg string) {
+		full := "Error: " + msg
+		notify.Send(full)
+		logf("%s", full)
+		os.Exit(1)
+	}
+
+	timestamp := time.Now().Format("2006-01-02_15-04-05")
+	start := time.Now()
+
+	logf("ha-backup v%s - backup process started (%s)", version, timestamp)
+	notify.Send("Backup process started at " + timestamp)
+
+	// Free-space check on the Home Assistant host.
+	logf("Checking free disk space on %s...", cfg.SSHHost)
+	avail, err := remote.availableKB()
+	if err != nil {
+		fail("failed to check disk space on Home Assistant server: " + err.Error())
+	}
+	logf("Free space: %s (threshold: %s)", humanBytes(avail*1024), humanBytes(cfg.StorageThresholdKB*1024))
+	if avail < cfg.StorageThresholdKB {
+		logf("Disk space is below the threshold. Running remote backup cleanup...")
+		removeOldRemoteBackups(remote, notify, cfg.RemoteCleanupDays)
+	} else {
+		logf("Sufficient disk space available. Skipping remote backup cleanup.")
+	}
+
+	// Create the backup.
+	logf("Creating backup on Home Assistant (this can take a few minutes)...")
+	var slug string
+	err = withHeartbeat("Creating backup", 10*time.Second, func() (e error) {
+		slug, e = remote.createBackup("auto_backup_" + timestamp)
+		return e
+	})
+	if err != nil {
+		fail(err.Error() + ".")
+	}
+	if !slugRe.MatchString(slug) {
+		fail(fmt.Sprintf("unexpected backup slug %q.", slug))
+	}
+	logf("Backup created with slug: %s", slug)
+	notify.Send("Backup created successfully with slug: " + slug)
+
+	// Copy it locally.
+	backupFile := filepath.Join(cfg.BackupDest, fmt.Sprintf("%s_%s.tar", timestamp, slug))
+	logf("Copying backup to %s ...", backupFile)
+	copyStart := time.Now()
+	if err := remote.copyWithProgress(cfg.BackupFileLocation+"/"+slug+".tar", backupFile); err != nil {
+		fail("Failed to copy backup to local machine.")
+	}
+
+	info, err := os.Stat(backupFile)
+	if err != nil {
+		fail("Failed to get backup file size.")
+	}
+	logf("Copy complete: %s in %s", humanBytes(info.Size()), time.Since(copyStart).Round(time.Second))
+
+	// Local retention.
+	logf("Cleaning up local backups older than %d days...", cfg.LocalCleanupDays)
+	if err := removeOldLocalBackups(cfg.BackupDest, cfg.LocalCleanupDays); err != nil {
+		fail("Failed to clean up old backups locally: " + err.Error())
+	}
+	notify.Send("Old backups cleaned up successfully.")
+
+	logf("Backup completed successfully: %s", backupFile)
+	notify.Send("Backup completed successfully: " + backupFile)
+
+	runtime := int(time.Since(start).Seconds())
+	logf("Total runtime: %d seconds", runtime)
+	notify.Send(fmt.Sprintf("Backup file size: %d bytes. Script runtime: %d seconds.", info.Size(), runtime))
+}