7e4dc8d500
- check for invalid encryption setting - switch from none to keyfile type (without password) - error for no password for repokey or authentication type encryption - update init and print out the key file data
669 lines
20 KiB
Bash
669 lines
20 KiB
Bash
#!/usr/bin/env bash
|
|
|
|
if [ -z "${MODULE}" ]; then
|
|
echo "Script cannot be run on its own";
|
|
exit 1;
|
|
fi;
|
|
|
|
set -ETu #-e -o pipefail
|
|
trap cleanup SIGINT SIGTERM ERR
|
|
|
|
cleanup() {
|
|
# script cleanup here
|
|
echo "Some part of the script failed with an error: $? @LINE: $(caller)";
|
|
# unset exported vars
|
|
unset BORG_BASE_DIR BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK BORG_RELOCATED_REPO_ACCESS_IS_OK;
|
|
# end trap
|
|
trap - SIGINT SIGTERM ERR
|
|
}
|
|
# on exit unset any exported var
|
|
trap "unset BORG_BASE_DIR BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK BORG_RELOCATED_REPO_ACCESS_IS_OK" EXIT;
|
|
# for version compare
|
|
function version {
|
|
echo "$@" | awk -F. '{ printf("%d%03d%03d%03d\n", $1,$2,$3,$4); }';
|
|
}
|
|
|
|
# version for all general files
|
|
VERSION="4.5.4";
|
|
|
|
# borg version and borg comamnd
|
|
BORG_VERSION="";
|
|
BORG_COMMAND="borg";
|
|
# default log folder if none are set in config or option
|
|
_LOG_FOLDER="/var/log/borg.backup/";
|
|
# log file name is set based on BACKUP_FILE, .log is added
|
|
LOG_FOLDER="";
|
|
# should be there on everything
|
|
TEMPDIR="/tmp/";
|
|
# HOSTNAME (as set on server)
|
|
HOSTNAME=$(hostname);
|
|
# creates borg backup based on the include/exclude files
|
|
# if base borg folder (backup files) does not exist, it will automatically init it
|
|
# base folder
|
|
BASE_FOLDER="/usr/local/scripts/borg/";
|
|
# base settings and init flag
|
|
SETTINGS_FILE="borg.backup.settings";
|
|
# include files
|
|
INCLUDE_FILE="";
|
|
EXCLUDE_FILE="";
|
|
# backup folder initialzed verify
|
|
BACKUP_INIT_FILE="";
|
|
BACKUP_INIT_DATE="";
|
|
# file with last compact date
|
|
BACKUP_COMPACT_FILE="";
|
|
# file with last check timestamp
|
|
BACKUP_CHECK_FILE="";
|
|
# one time backup prefix tag, if set will use <tag>.<prefix>-Y-M-DTh:m:s type backup prefix
|
|
ONE_TIME_TAG="";
|
|
DELETE_ONE_TIME_TAG="";
|
|
# check command prefix/glob
|
|
CHECK_PREFIX="";
|
|
# debug/verbose/other flags
|
|
VERBOSE=0;
|
|
LIST=0;
|
|
DEBUG=0;
|
|
DRYRUN=0;
|
|
INFO=0;
|
|
VERIFY=0;
|
|
CHECK=0;
|
|
CHECK_VERIFY_DATA=0;
|
|
COMPACT=0;
|
|
INIT=0;
|
|
EXIT=0;
|
|
PRINT=0;
|
|
# flags, set to no to disable
|
|
_BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK="yes";
|
|
_BORG_RELOCATED_REPO_ACCESS_IS_OK="yes";
|
|
# compatible settings
|
|
# NOTE: to keep the old .borg repository name for file module set this to true
|
|
# if set to false (future) it will add -file to the repository name like for other
|
|
# modules
|
|
FILE_REPOSITORY_COMPATIBLE="false";
|
|
# other variables
|
|
TARGET_SERVER="";
|
|
REGEX="";
|
|
REGEX_COMMENT="^[\ \t]*#";
|
|
REGEX_GLOB='\*';
|
|
REGEX_NUMERIC="^[0-9]{1,2}$";
|
|
REGEX_ERROR="^Some part of the script failed with an error:";
|
|
PRUNE_DEBUG="";
|
|
INIT_REPOSITORY=0;
|
|
FOLDER_OK=0;
|
|
TMP_EXCLUDE_FILE="";
|
|
# printf strings
|
|
PRINTF_INFO_STRING="%-23s: %s\n";
|
|
PRINTF_MASTER_BLOCK="=== [%-8s: %19s] ==[%s]====================================>\n";
|
|
PRINTF_SUB_BLOCK="|-- [%-8s: %19s] --[%s]------------------------------------>\n";
|
|
PRINTF_SUBEXT_BLOCK="|-- [%-8s: %s: %19s] --[%s]------------------------------------>\n";
|
|
PRINTF_DB_SUB_BLOCK="|>- [%-8s: %s] ==[%s]=======================>\n";
|
|
PRINTF_DB_RUN_TIME_SUB_BLOCK=">>- [%-8s: %s] ==[%s]==[Run time: %s]=======================>\n";
|
|
# opt flags
|
|
OPT_VERBOSE="";
|
|
OPT_PROGRESS="";
|
|
OPT_LIST="";
|
|
OPT_REMOTE="";
|
|
OPT_LOG_FOLDER="";
|
|
OPT_EXCLUDE="";
|
|
OPT_CHECK_VERIFY_DATA="";
|
|
# config variables (will be overwritten from .settings file)
|
|
TARGET_USER="";
|
|
TARGET_HOST="";
|
|
TARGET_PORT="";
|
|
TARGET_BORG_PATH="";
|
|
TARGET_FOLDER="";
|
|
BACKUP_FILE="";
|
|
SUB_BACKUP_FILE="";
|
|
# OPT is for options set
|
|
OPT_BORG_EXECUTEABLE="";
|
|
# which overrides BORG_EXECUTABLE that can be set in the settings file
|
|
BORG_EXECUTEABLE="";
|
|
# lz4, zstd 1-22 (3), zlib 0-9 (6), lzma 0-9 (6)
|
|
DEFAULT_COMPRESSION="zstd";
|
|
DEFAULT_COMPRESSION_LEVEL=3;
|
|
COMPRESSION="";
|
|
COMPRESSION_LEVEL="";
|
|
SUB_COMPRESSION="";
|
|
SUB_COMPRESSION_LEVEL="";
|
|
# encryption settings
|
|
DEFAULT_ENCRYPTION="keyfile";
|
|
ENCRYPTION="";
|
|
# force verify always
|
|
DEFAULT_FORCE_VERIFY="false";
|
|
FORCE_VERIFY="";
|
|
FORCE_CHECK=""; # Deprecated name, use FORCE_VERIFY
|
|
# compact
|
|
DEFAULT_COMPACT_INTERVAL="1";
|
|
LAST_COMPACT_DATE="";
|
|
COMPACT_INTERVAL="";
|
|
SUB_COMPACT_INTERVAL="";
|
|
# check
|
|
# default interval is none
|
|
DEFAULT_CHECK_INTERVAL="";
|
|
LAST_CHECK_DATE="";
|
|
CHECK_INTERVAL="";
|
|
SUB_CHECK_INTERVAL="";
|
|
# backup set names
|
|
BACKUP_SET="";
|
|
SUB_BACKUP_SET="";
|
|
# for database backup only
|
|
DATABASE_FULL_DUMP="";
|
|
DATABASE_USER="";
|
|
# only for mysql old config file
|
|
MYSQL_DB_CONFIG="";
|
|
MYSQL_DB_CONFIG_PARAM="";
|
|
# gitea module
|
|
GIT_USER="";
|
|
GITEA_WORKING_DIR="";
|
|
GITEA_TEMP_DIR="";
|
|
GITEA_BIN="";
|
|
GITEA_CONFIG="";
|
|
GITEA_EXPORT_TYPE="";
|
|
# zabbix module
|
|
ZABBIX_DUMP_BIN="";
|
|
ZABBIX_CONFIG="";
|
|
ZABBIX_DATABASE="";
|
|
ZABBIX_UNKNOWN_TABLES="";
|
|
ZABBIX_DB_PORT="";
|
|
OPT_ZABBIX_DUMP="";
|
|
OPT_ZABBIX_CONFIG="";
|
|
OPT_ZABBIX_UNKNOWN_TABLES="";
|
|
OPT_ZABBIX_DB_PORT="";
|
|
# default keep 7 days, 4 weeks, 6 months, 1 year
|
|
# if set 0, ignore/off
|
|
# note that for last/hourly it is needed to create a different
|
|
# BACKUP SET that includes hour and minute information
|
|
# IF BACKUP_SET is empty, this is automatically added
|
|
# general keep last, if only this is set only last n will be kept
|
|
DEFAULT_KEEP_LAST=0;
|
|
DEFAULT_KEEP_HOURS=0;
|
|
DEFAULT_KEEP_DAYS=7;
|
|
DEFAULT_KEEP_WEEKS=4;
|
|
DEFAULT_KEEP_MONTHS=6;
|
|
DEFAULT_KEEP_YEARS=1;
|
|
KEEP_LAST="";
|
|
KEEP_HOURS="";
|
|
KEEP_DAYS="";
|
|
KEEP_WEEKS="";
|
|
KEEP_MONTHS="";
|
|
KEEP_YEARS="";
|
|
# in the format of nY|M|d|h|m|s
|
|
KEEP_WITHIN="";
|
|
# sub override init to empty
|
|
SUB_KEEP_LAST="";
|
|
SUB_KEEP_HOURS="";
|
|
SUB_KEEP_DAYS="";
|
|
SUB_KEEP_WEEKS="";
|
|
SUB_KEEP_MONTHS="";
|
|
SUB_KEEP_YEARS="";
|
|
SUB_KEEP_WITHIN="";
|
|
|
|
function usage()
|
|
{
|
|
cat <<- EOT
|
|
Usage: ${0##/*/} [-c <config folder>] [-v] [-d]
|
|
|
|
-c <config folder>: if this is not given, ${BASE_FOLDER} is used
|
|
-L <log folder>: override config set and default log folder
|
|
-T <tag>: create one time stand alone backup prefixed with tag name
|
|
-D <tag backup set>: remove a tagged backup set, full name must be given
|
|
-b <borg executable>: override default path
|
|
-Z: run compress after prune/backup. Only for borg 1.2 or newer
|
|
-C: run borg check if repository is ok
|
|
-y: in combination with -C: add --verify-data
|
|
-p <archive prefix|glob>: in combinatio with -C: only check archives with prefix or glob
|
|
-P: print list of archives created
|
|
-V: verify if repository exists, if not abort
|
|
-e: exit after verify
|
|
-I: init repository (must be run first)
|
|
-i: print out only info
|
|
-l: list files during backup
|
|
-v: be verbose
|
|
-d: debug output all commands
|
|
-n: only do dry run
|
|
-h: this help page
|
|
|
|
Version : ${VERSION}
|
|
Module Version: ${MODULE_VERSION}
|
|
Module : ${MODULE}
|
|
EOT
|
|
}
|
|
|
|
# set options
|
|
while getopts ":c:L:T:D:b:p:vldniCVeIPyZh" opt; do
|
|
case "${opt}" in
|
|
c|config)
|
|
BASE_FOLDER=${OPTARG};
|
|
;;
|
|
L|Log)
|
|
OPT_LOG_FOLDER=${OPTARG};
|
|
;;
|
|
T|Tag)
|
|
ONE_TIME_TAG=${OPTARG};
|
|
;;
|
|
D|Delete)
|
|
DELETE_ONE_TIME_TAG=${OPTARG};
|
|
;;
|
|
b|borg)
|
|
OPT_BORG_EXECUTEABLE=${OPTARG};
|
|
;;
|
|
Z|Compact)
|
|
# will run compact alone
|
|
COMPACT=1;
|
|
;;
|
|
C|Check)
|
|
# will run borg check
|
|
# alt modes --repository-only, --archives-only,
|
|
# add mode --verify-data
|
|
# note that --repair has to be called manually is it might damange backups
|
|
CHECK=1;
|
|
;;
|
|
y|Verify-Data)
|
|
CHECK_VERIFY_DATA=1;
|
|
;;
|
|
p|prefix-glob)
|
|
CHECK_PREFIX=${OPTARG};
|
|
;;
|
|
V|Verify)
|
|
# will verify if repo is there and abort if not
|
|
VERIFY=1;
|
|
;;
|
|
e|exit)
|
|
# exit after verify or init (default off)
|
|
EXIT=1;
|
|
;;
|
|
I|Init)
|
|
# will check if there is a repo and init it
|
|
# previoous this was default
|
|
VERIFY=1;
|
|
INIT=1;
|
|
;;
|
|
P|Print)
|
|
# use borg list to print list of archves
|
|
PRINT=1;
|
|
;;
|
|
v|verbose)
|
|
VERBOSE=1;
|
|
;;
|
|
l|list)
|
|
LIST=1;
|
|
;;
|
|
i|info)
|
|
INFO=1;
|
|
;;
|
|
d|debug)
|
|
DEBUG=1;
|
|
;;
|
|
n|dryrun)
|
|
DRYRUN=1;
|
|
;;
|
|
h|help)
|
|
usage;
|
|
exit;
|
|
;;
|
|
:)
|
|
echo "Option -$OPTARG requires an argument."
|
|
;;
|
|
\?)
|
|
echo -e "\n Option does not exist: ${OPTARG}\n";
|
|
usage;
|
|
exit 1;
|
|
;;
|
|
esac;
|
|
done;
|
|
|
|
# add trailing slasd for base folder
|
|
[[ "${BASE_FOLDER}" != */ ]] && BASE_FOLDER=${BASE_FOLDER}"/";
|
|
# must have settings file there, if not, abort early
|
|
if [ ! -f "${BASE_FOLDER}${SETTINGS_FILE}" ]; then
|
|
echo "No settings file could be found: ${BASE_FOLDER}${SETTINGS_FILE}";
|
|
exit 1;
|
|
fi;
|
|
if [ ! -w "${BASE_FOLDER}" ]; then
|
|
echo "Cannot write to BASE_FOLDER ${BASE_FOLDER}";
|
|
echo "Is the group set to 'backup' and is this group allowed to write?"
|
|
echo "If run as sudo, is this user in the 'backup' group?"
|
|
echo "chgrp -R backup ${BASE_FOLDER}";
|
|
echo "chmod -R g+rwX ${BASE_FOLDER}";
|
|
echo "chmod g+s ${BASE_FOLDER}";
|
|
exit 1;
|
|
fi;
|
|
|
|
# info -i && -C/-I cannot be run together
|
|
if [ ${VERIFY} -eq 1 ] || [ ${INIT} -eq 1 ] && [ ${INFO} -eq 1 ]; then
|
|
echo "Cannot have -i info option and -V verify or -I initialize option at the same time";
|
|
exit 1;
|
|
fi;
|
|
# print -P cannot be run with -i/-C/-I together
|
|
if [ ${PRINT} -eq 1 ] && { [ ${INIT} -eq 1 ] || [ ${VERIFY} -eq 1 ] || [ ${INFO} -eq 1 ]; }; then
|
|
echo "Cannot have -P print option and -i info, -V verify or -I initizalize option at the same time";
|
|
exit 1;
|
|
fi;
|
|
# if tag is set, you can't have init, verify, info, etc
|
|
if [ -n "${ONE_TIME_TAG}" ] && { [ ${PRINT} -eq 1 ] || [ ${INIT} -eq 1 ] || [ ${VERIFY} -eq 1 ] || [ ${INFO} -eq 1 ]; }; then
|
|
echo "Cannot have -T '${ONE_TIME_TAG}' option with -i info, -V verify, -I initialize or -P print option at the same time";
|
|
exit 1;
|
|
fi;
|
|
# verify only alphanumeric, no spaces, only underscore and dash
|
|
if [ -n "${ONE_TIME_TAG}" ] && ! [[ "${ONE_TIME_TAG}" =~ ^[A-Za-z0-9_-]+$ ]]; then
|
|
echo "One time tag '${ONE_TIME_TAG}' must be alphanumeric with dashes and underscore only.";
|
|
exit 1;
|
|
elif [ -n "${ONE_TIME_TAG}" ]; then
|
|
# all ok, attach . at the end
|
|
ONE_TIME_TAG=${ONE_TIME_TAG}".";
|
|
fi;
|
|
# if -D, cannot be with -T, -i, -C, -I, -P
|
|
if [ -n "${DELETE_ONE_TIME_TAG}" ] && { [ -n "${ONE_TIME_TAG}" ] || [ ${PRINT} -eq 1 ] || [ ${INIT} -eq 1 ] || [ ${VERIFY} -eq 1 ] || [ ${INFO} -eq 1 ]; }; then
|
|
echo "Cannot have -D delete tag option with -T one time tag, -i info, -V verify, -I initialize or -P print option at the same time";
|
|
exit 1;
|
|
fi;
|
|
# -D also must be in valid backup set format
|
|
# ! [[ "${DELETE_ONE_TIME_TAG}" =~ ^[A-Za-z0-9_-]+\.${MODULE},(\*-)?[0-9]{4}-[0-9]{2}-[0-9]{2}T\*$ ]]
|
|
if [ -n "${DELETE_ONE_TIME_TAG}" ] && ! [[ "${DELETE_ONE_TIME_TAG}" =~ ^[A-Za-z0-9_-]+\.${MODULE},([A-Za-z0-9_-]+-)?[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}$ ]] && ! [[ "${DELETE_ONE_TIME_TAG}" =~ ^[A-Za-z0-9_-]+\.${MODULE},(\*-)?[0-9]{4}-[0-9]{2}-[0-9]{2}T\*$ ]]; then
|
|
echo "Delete one time tag '${DELETE_ONE_TIME_TAG}' is in an invalid format. "
|
|
echo "Please verify existing tags with -P option."
|
|
echo "For a globing be sure it is in the format of: TAG.MODULE,*-YYYY-MM-DDT*";
|
|
echo "Note the dash (-) after the first *, also time (T) is a globa (*) must."
|
|
exit 1;
|
|
fi;
|
|
# -y can't be set without -C
|
|
if [ ${CHECK_VERIFY_DATA} -eq 1 ] && [ ${CHECK} -eq 0 ]; then
|
|
echo "-y (verify-data) cannot be run without -C (Check) option";
|
|
exit 1;
|
|
fi;
|
|
# -p can't be set without -C
|
|
if [ -n "${CHECK_PREFIX}" ] && [ ${CHECK} -eq 0 ]; then
|
|
echo "-p (pattern|glob) for check cannot be run without -C (Check) options";
|
|
exit 1;
|
|
fi;
|
|
# can't have -e if VERIFY or INIT is not set
|
|
if [ ${EXIT} -eq 1 ] && [ ${VERIFY} -eq 0 ] && [ ${INIT} -eq 0 ]; then
|
|
echo "-e (exit) can only be used with -V (Verify) and -I (Init)";
|
|
exit 1;
|
|
fi;
|
|
|
|
# verbose & progress
|
|
if [ ${VERBOSE} -eq 1 ]; then
|
|
OPT_VERBOSE="-v";
|
|
OPT_PROGRESS="-p";
|
|
fi;
|
|
# list files
|
|
if [ ${LIST} -eq 1 ]; then
|
|
OPT_LIST="--list";
|
|
fi;
|
|
# If dry run, the stats (-s) option cannot be used
|
|
if [ ${DRYRUN} -eq 1 ]; then
|
|
DRY_RUN_STATS="-n";
|
|
else
|
|
DRY_RUN_STATS="-s";
|
|
fi;
|
|
if [ ${CHECK_VERIFY_DATA} -eq 1 ] && [ ${CHECK} -eq 1 ]; then
|
|
OPT_CHECK_VERIFY_DATA="--verify-data";
|
|
fi;
|
|
|
|
# read config file
|
|
. "${BASE_FOLDER}${SETTINGS_FILE}";
|
|
|
|
# if OPTION SET overrides ALL others
|
|
if [ -n "${OPT_BORG_EXECUTEABLE}" ]; then
|
|
BORG_COMMAND="${OPT_BORG_EXECUTEABLE}";
|
|
if [ ! -f "${BORG_COMMAND}" ]; then
|
|
echo "borg command not found with option -b: ${BORG_COMMAND}";
|
|
exit;
|
|
fi;
|
|
# if in setting file, use this
|
|
elif [ -n "${BORG_EXECUTEABLE}" ]; then
|
|
BORG_COMMAND="${BORG_EXECUTEABLE}";
|
|
if [ ! -f "${BORG_COMMAND}" ]; then
|
|
echo "borg command not found with setting: ${BORG_COMMAND}";
|
|
exit;
|
|
fi;
|
|
elif ! command -v borg &> /dev/null; then
|
|
# elif [ -z ($command -v borg) ]; then
|
|
echo "borg backup seems not to be installed, please verify paths";
|
|
exit;
|
|
fi;
|
|
# verify that this is a borg executable, no detail check
|
|
_BORG_COMMAND_VERIFY=$(${BORG_COMMAND} -V | grep "borg");
|
|
if [[ "${_BORG_COMMAND_VERIFY}" =~ ${REGEX_ERROR} ]]; then
|
|
echo "Cannot extract borg info from command, is this a valid borg executable?: ${BORG_COMMAND}";
|
|
exit;
|
|
fi;
|
|
# extract actually borg version from here
|
|
# alt sed to get only numbes: sed -e 's/.* \([0-9]*\.[0-9]*\.[0-9]*\)$/\1/g'
|
|
# or use cut -d " " -f 2 and assume NO space in the first part
|
|
BORG_VERSION=$(${BORG_COMMAND} -V | sed -e 's/borg.* //') 2>&1 || echo "[!] Borg version not estable";
|
|
|
|
# load default settings for fileds not set
|
|
if [ -z "${COMPRESSION}" ]; then
|
|
COMPRESSION="${DEFAULT_COMPRESSION}";
|
|
fi;
|
|
if [ -z "${COMPRESSION_LEVEL}" ]; then
|
|
COMPRESSION_LEVEL="${DEFAULT_COMPRESSION_LEVEL}";
|
|
fi;
|
|
if [ -z "${ENCRYPTION}" ]; then
|
|
ENCRYPTION="${DEFAULT_ENCRYPTION}";
|
|
fi;
|
|
# check interval override
|
|
if [ -z "${COMPACT_INTERVAL}" ]; then
|
|
COMPACT_INTERVAL="${DEFAULT_COMPACT_INTERVAL}";
|
|
fi;
|
|
if [ -z "${CHECK_INTERVAL}" ]; then
|
|
CHECK_INTERVAL="${DEFAULT_CHECK_INTERVAL}";
|
|
fi;
|
|
# deprecated name FORCE_CHECK, use FORCE_VERIFY instead
|
|
if [ -n "${FORCE_CHECK}" ]; then
|
|
FORCE_VERIFY="${FORCE_CHECK}";
|
|
fi;
|
|
if [ -z "${FORCE_VERIFY}" ]; then
|
|
FORCE_VERIFY="${DEFAULT_FORCE_VERIFY}";
|
|
fi;
|
|
if [ -z "${KEEP_LAST}" ]; then
|
|
KEEP_LAST="${DEFAULT_KEEP_LAST}";
|
|
fi;
|
|
if [ -z "${KEEP_HOURS}" ]; then
|
|
KEEP_HOURS="${DEFAULT_KEEP_HOURS}";
|
|
fi;
|
|
if [ -z "${KEEP_DAYS}" ]; then
|
|
KEEP_DAYS="${DEFAULT_KEEP_DAYS}";
|
|
fi;
|
|
if [ -z "${KEEP_WEEKS}" ]; then
|
|
KEEP_WEEKS="${DEFAULT_KEEP_WEEKS}";
|
|
fi;
|
|
if [ -z "${KEEP_MONTHS}" ]; then
|
|
KEEP_MONTHS="${DEFAULT_KEEP_MONTHS}";
|
|
fi;
|
|
if [ -z "${KEEP_YEARS}" ]; then
|
|
KEEP_YEARS="${DEFAULT_KEEP_YEARS}";
|
|
fi;
|
|
# ** SUB LOAD
|
|
# a settings file always end in .settings, replace that with lower case MODULE.settings
|
|
SETTINGS_FILE_SUB=$(echo "${SETTINGS_FILE}" | sed -e "s/\.settings/\.${MODULE,,}\.settings/");
|
|
# if mysql/pgsql run, load sub settings
|
|
if [ -f "${BASE_FOLDER}${SETTINGS_FILE_SUB}" ]; then
|
|
. "${BASE_FOLDER}${SETTINGS_FILE_SUB}";
|
|
# if SUB_ set override master
|
|
if [ -n "${SUB_BACKUP_FILE}" ]; then
|
|
BACKUP_FILE=${SUB_BACKUP_FILE}
|
|
fi;
|
|
# if sub backup set it set, override current
|
|
if [ -n "${SUB_BACKUP_SET}" ]; then
|
|
BACKUP_SET=${SUB_BACKUP_SET};
|
|
fi;
|
|
# ovrride compression
|
|
if [ -n "${SUB_COMPRESSION}" ]; then
|
|
COMPRESSION=${SUB_COMPRESSION};
|
|
fi;
|
|
if [ -n "${SUB_COMPRESSION_LEVEL}" ]; then
|
|
COMPRESSION_LEVEL=${SUB_COMPRESSION_LEVEL};
|
|
fi;
|
|
# compact interval override
|
|
if [ -n "${SUB_COMPACT_INTERVAL}" ]; then
|
|
COMPACT_INTERVAL="${SUB_COMPACT_INTERVAL}";
|
|
fi;
|
|
# override check interval
|
|
if [ -n "${SUB_CHECK_INTERVAL}" ]; then
|
|
CHECK_INTERVAL="${SUB_CHECK_INTERVAL}";
|
|
fi;
|
|
# check override for keep time
|
|
if [ -n "${SUB_KEEP_LAST}" ]; then
|
|
KEEP_LAST=${SUB_KEEP_LAST};
|
|
fi;
|
|
if [ -n "${SUB_KEEP_HOURS}" ]; then
|
|
KEEP_HOURS=${SUB_KEEP_HOURS};
|
|
fi;
|
|
if [ -n "${SUB_KEEP_DAYS}" ]; then
|
|
KEEP_DAYS=${SUB_KEEP_DAYS};
|
|
fi;
|
|
if [ -n "${SUB_KEEP_WEEKS}" ]; then
|
|
KEEP_WEEKS=${SUB_KEEP_WEEKS};
|
|
fi;
|
|
if [ -n "${SUB_KEEP_MONTHS}" ]; then
|
|
KEEP_MONTHS=${SUB_KEEP_MONTHS};
|
|
fi;
|
|
if [ -n "${SUB_KEEP_YEARS}" ]; then
|
|
KEEP_YEARS=${SUB_KEEP_YEARS};
|
|
fi;
|
|
if [ -n "${SUB_KEEP_WITHIN}" ]; then
|
|
KEEP_WITHIN=${SUB_KEEP_WITHIN};
|
|
fi;
|
|
fi;
|
|
# add module name to backup file, always
|
|
# except if FILE module and FILE_REPOSITORY_COMPATIBLE="true"
|
|
if [ "${FILE_REPOSITORY_COMPATIBLE}" != "true" ] || [ "${MODULE,,}" != "file" ]; then
|
|
BACKUP_FILE=${BACKUP_FILE/.borg/-${MODULE,,}.borg};
|
|
fi;
|
|
# backup file must be set
|
|
if [ -z "${BACKUP_FILE}" ]; then
|
|
echo "No BACKUP_FILE set";
|
|
exit;
|
|
fi;
|
|
# backup file (folder) must end as .borg
|
|
# BACKUP FILE also cannot start with / or have / inside or start with ~
|
|
# valid file name check, alphanumeric, -,._ ...
|
|
if ! [[ "${BACKUP_FILE}" =~ ^[A-Za-z0-9,._-]+\.borg$ ]]; then
|
|
echo "BACKUP_FILE ${BACKUP_FILE} can only contain A-Z a-z 0-9 , . _ - chracters and must end with .borg";
|
|
exit 1;
|
|
fi;
|
|
# error if the repository file still has the default name
|
|
# This is just for old sets
|
|
REGEX="^some\-prefix\-";
|
|
if [[ "${BACKUP_FILE}" =~ ${REGEX} ]]; then
|
|
echo "[DEPRECATED] The repository name still has the default prefix: ${BACKUP_FILE}";
|
|
exit 1;
|
|
fi;
|
|
|
|
# check LOG_FOLDER, TARGET_BORG_PATH, TARGET_FOLDER must have no ~/ as start position
|
|
if [[ ${LOG_FOLDER} =~ ^~\/ ]]; then
|
|
echo "LOG_FOLDER path cannot start with ~/. Path must be absolute: ${LOG_FOLDER}";
|
|
exit 1;
|
|
fi;
|
|
if [[ ${TARGET_BORG_PATH} =~ ^~\/ ]]; then
|
|
echo "TARGET_BORG_PATH path cannot start with ~/. Path must be absolute: ${TARGET_BORG_PATH}";
|
|
exit 1;
|
|
fi;
|
|
if [[ ${TARGET_FOLDER} =~ ^~\/ ]]; then
|
|
echo "TARGET_FOLDER path cannot start with ~/. Path must be absolute: ${TARGET_FOLDER}";
|
|
exit 1;
|
|
fi
|
|
|
|
# COMPACT_INTERVAL must be a number from -1 to 365
|
|
# CHECK_INTERVAL must be a number from -1 to 365
|
|
|
|
# log file set and check
|
|
# option folder overrides all other folders
|
|
if [ -n "${OPT_LOG_FOLDER}" ]; then
|
|
LOG_FOLDER="${OPT_LOG_FOLDER}";
|
|
fi;
|
|
# if empty folder set to default folder
|
|
if [ -z "${LOG_FOLDER}" ]; then
|
|
LOG_FOLDER="${_LOG_FOLDER}";
|
|
fi;
|
|
# if folder does not exists create it
|
|
if [ ! -d "${LOG_FOLDER}" ]; then
|
|
mkdir "${LOG_FOLDER}";
|
|
fi;
|
|
# set the output log folder
|
|
# LOG=$(printf "%q" "${LOG_FOLDER}/${BACKUP_FILE}.log");
|
|
LOG="${LOG_FOLDER}/${BACKUP_FILE}.log";
|
|
# fail if not writeable to folder or file
|
|
if [[ -f "${LOG}" && ! -w "${LOG}" ]] || [[ ! -f "${LOG}" && ! -w "${LOG_FOLDER}" ]]; then
|
|
echo "Log folder or log file is not writeable: ${LOG}";
|
|
echo "Is the group set to 'backup' and is this group allowed to write?"
|
|
echo "If run as sudo, is this user in the 'backup' group?"
|
|
echo "chgrp -R backup ${LOG}";
|
|
echo "chmod -R g+rwX ${LOG}";
|
|
echo "chmod g+s ${LOG}";
|
|
exit 1;
|
|
fi;
|
|
|
|
# if ENCRYPTION is empty or not in the valid list fall back to none
|
|
# NOTE This is currently set in default and doesn't need to be set on empty
|
|
# only ivalid should be checked
|
|
if
|
|
[ "${ENCRYPTION}" = "authenticated" ] ||
|
|
[ "${ENCRYPTION}" = "repokey" ] ||
|
|
[ "${ENCRYPTION}" = "authenticated-blake2" ] ||
|
|
[ "${ENCRYPTION}" = "repokey-blake2" ] ;
|
|
then
|
|
# if "authenticated" or "repokey" a password must be set
|
|
if [[ ! -v BORG_PASSPHRASE ]] && [[ ! -v BORG_PASSCOMMAND ]] && [[ ! -v BORG_PASSPHRASE_FD ]]; then
|
|
echo "Encryption method '${ENCRYPTION}' requires a BORG_PASSPHRASE, BORG_PASSCOMMAND or BORG_PASSPHRASE_FD to be set.";
|
|
exit 1;
|
|
fi;
|
|
elif [ "${ENCRYPTION}" = "keyfile" ] || [ "${ENCRYPTION}" = "keyfile-blake2" ]; then
|
|
# if no password, set empty password
|
|
if [[ ! -v BORG_PASSPHRASE ]] && [[ ! -v BORG_PASSCOMMAND ]] && [[ ! -v BORG_PASSPHRASE_FD ]]; then
|
|
export BORG_PASSPHRASE="";
|
|
fi;
|
|
elif [ "${ENCRYPTION}" != "none" ]; then
|
|
echo "Encryption method '${ENCRYPTION}' is not valid.";
|
|
exit 1;
|
|
fi;
|
|
|
|
## FUNCTIONS
|
|
|
|
# METHOD: convert_time
|
|
# PARAMS: timestamp in seconds or with milliseconds (nnnn.nnnn)
|
|
# RETURN: formated string with human readable time (d/h/m/s)
|
|
# CALL : var=$(convert_time $timestamp);
|
|
# DESC : converts a timestamp or a timestamp with float milliseconds
|
|
# to a human readable format
|
|
# output is in days/hours/minutes/seconds
|
|
function convert_time
|
|
{
|
|
timestamp=${1};
|
|
# round to four digits for ms
|
|
timestamp=$(printf "%1.4f" "$timestamp");
|
|
# get the ms part and remove any leading 0
|
|
ms=$(echo "${timestamp}" | cut -d "." -f 2 | sed -e 's/^0*//');
|
|
timestamp=$(echo "${timestamp}" | cut -d "." -f 1);
|
|
timegroups=(86400 3600 60 1); # day, hour, min, sec
|
|
timenames=("d" "h" "m" "s"); # day, hour, min, sec
|
|
output=( );
|
|
time_string=;
|
|
for timeslice in "${timegroups[@]}"; do
|
|
# floor for the division, push to output
|
|
output[${#output[*]}]=$(awk "BEGIN {printf \"%d\", ${timestamp}/${timeslice}}");
|
|
timestamp=$(awk "BEGIN {printf \"%d\", ${timestamp}%${timeslice}}");
|
|
done;
|
|
|
|
for ((i=0; i<${#output[@]}; i++)); do
|
|
if [ "${output[$i]}" -gt 0 ] || [ -n "$time_string" ]; then
|
|
if [ -n "${time_string}" ]; then
|
|
time_string=${time_string}" ";
|
|
fi;
|
|
time_string=${time_string}${output[$i]}${timenames[$i]};
|
|
fi;
|
|
done;
|
|
if [ -n "${ms}" ] && [ "${ms}" != "nan" ] && [ "${ms}" -gt 0 ]; then
|
|
time_string="${time_string} ${ms}ms";
|
|
fi;
|
|
# just in case the time is 0
|
|
if [ -z "${time_string}" ]; then
|
|
time_string="0s";
|
|
fi;
|
|
echo -n "${time_string}";
|
|
}
|
|
|
|
# __END__
|