707 lines
19 KiB
Bash
Executable File
707 lines
19 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
set -e -u -o pipefail
|
|
|
|
# dumps all the databases in compressed (custom) format
|
|
# EXCLUDE: space seperated list of database names to be skipped
|
|
# KEEP: how many files to keep, eg 3 means, keep 3 days + todays backup
|
|
# the file format includes the database name and owner:
|
|
# <database name>.<owner>.<database type>-<version>_<host>_<port>_<date in YYYYMMDD>_<time in HHMM>_<sequenze in two digits with leading 0>.sql
|
|
|
|
function usage ()
|
|
{
|
|
cat <<- EOT
|
|
Usage: ${0##/*/} [-t] [-s] [-g] [-c] [-r] [-k <number to keep>] [-n] [-b <path>] [-i <postgreSQL version>] [-d <dump database name> [-d ...]] [-e <exclude dump> [-e ...]] [-u <db user>] [-h <db host>] [-p <db port>] [-l <db password>] [-L <log path>]
|
|
|
|
-t: test usage, no real backup is done
|
|
-s: turn ON ssl mode, default mode is off
|
|
-g: turn OFF dumping globals data, default is dumping globals data
|
|
-c: run clean up of old files before data is dumped. Default is run after data dump.
|
|
-k <number>: keep how many backups, default is 3 days/files
|
|
-n: keep files in numbers not in days
|
|
-b <path>: backup target path, if not set, /mnt/backup/db_dumps_fc/ is used
|
|
-i <version>: override automatically set database version
|
|
-d <name>: database name to dump, option can be given multiple times, if not set all databases are dumped
|
|
-e <name>: exclude database from dump, option can be given multiple times, if not set non are excluded
|
|
-u <db user>: default is 'postgres'
|
|
-h <db host>: default is none
|
|
-p <db port>: default port is '5432'
|
|
-l <db password>: default password is empty
|
|
-r: use redhat base paths instead of debian
|
|
-L <log path>: where to put the dump log file, if not set tries to use PostgreSQL log folder
|
|
EOT
|
|
}
|
|
|
|
TEST=0; # if set to 1 will run script without doing anything
|
|
SSLMODE='disable';
|
|
GLOBALS=1; # if set to 0 will not dump globals
|
|
# in days, keeps KEEP+1 files, today + KEEP days before
|
|
# or keep number of files if CLEAN_NUMBER is true, then it can't be 0
|
|
KEEP=3;
|
|
CLEAN_NUMBER=0;
|
|
BACKUPDIR='';
|
|
DB_VERSION='';
|
|
DB_USER='';
|
|
DB_PASSWD='';
|
|
DB_HOST='';
|
|
DB_PORT='';
|
|
EXCLUDE=''; # space separated list of database names
|
|
INCLUDE=''; # space seperated list of database names
|
|
BC='/usr/bin/bc';
|
|
PRE_RUN_CLEAN_UP=0;
|
|
SET_IDENT=0;
|
|
PORT_REGEX="^[0-9]{4,5}$";
|
|
OPTARG_REGEX="^-";
|
|
# log path
|
|
LOG_PATH='';
|
|
# base path for PostgreSQL binary
|
|
# DBPATH_BASE='';
|
|
# defaults
|
|
_BACKUPDIR='';
|
|
_DB_VERSION=$(
|
|
pgv=$(
|
|
pg_dump --version | grep "pg_dump" | cut -d " " -f 3
|
|
);
|
|
if [[ $(echo "${pgv}" | cut -d "." -f 1) -ge 10 ]]; then
|
|
echo "${pgv}" | cut -d "." -f 1;
|
|
else
|
|
echo "${pgv}" | cut -d "." -f 1,2;
|
|
fi
|
|
);
|
|
_DB_USER='postgres';
|
|
_DB_PASSWD='';
|
|
_DB_HOST='';
|
|
_DB_PORT=5432;
|
|
_EXCLUDE=''; # space separated list of database names
|
|
_INCLUDE=''; # space seperated list of database names
|
|
REDHAT=0;
|
|
# CONN_DB_HOST='';
|
|
ERROR=0;
|
|
|
|
# set options
|
|
while getopts ":ctsgnk:b:i:d:e:u:h:p:l:L:rm" opt; do
|
|
# pre test for unfilled
|
|
if [ "${opt}" = ":" ] || [[ "${OPTARG-}" =~ ${OPTARG_REGEX} ]]; then
|
|
if [ "${opt}" = ":" ]; then
|
|
CHECK_OPT=${OPTARG};
|
|
else
|
|
CHECK_OPT=${opt};
|
|
fi;
|
|
case ${CHECK_OPT} in
|
|
k)
|
|
echo "-k needs a number";
|
|
ERROR=1;
|
|
;;
|
|
b)
|
|
echo "-b needs a path";
|
|
ERROR=1;
|
|
;;
|
|
i)
|
|
echo "-i needs an ident";
|
|
ERROR=1;
|
|
;;
|
|
u)
|
|
echo "-u needs a user name";
|
|
ERROR=1;
|
|
;;
|
|
h)
|
|
echo "-h needs a host name";
|
|
ERROR=1;
|
|
;;
|
|
p)
|
|
echo "-p needs a port number";
|
|
ERROR=1;
|
|
;;
|
|
l)
|
|
echo "-l needs a login password";
|
|
ERROR=1;
|
|
;;
|
|
d)
|
|
echo "-d needs a database name";
|
|
ERROR=1;
|
|
;;
|
|
e)
|
|
echo "-e needs a database name";
|
|
ERROR=1;
|
|
;;
|
|
L)
|
|
echo "-L needs a log path";
|
|
ERROR=1;
|
|
;;
|
|
esac
|
|
fi;
|
|
# set options
|
|
case ${opt} in
|
|
# t|test)
|
|
t)
|
|
TEST=1;
|
|
;;
|
|
# g|globals)
|
|
g)
|
|
GLOBALS=0;
|
|
;;
|
|
# c|clean-up-before)
|
|
c)
|
|
PRE_RUN_CLEAN_UP=1;
|
|
;;
|
|
# s|sslmode)
|
|
s)
|
|
SSLMODE=enable;
|
|
;;
|
|
# k|keep)
|
|
k)
|
|
KEEP=${OPTARG};
|
|
;;
|
|
# n|number-keep)
|
|
n)
|
|
CLEAN_NUMBER=1;
|
|
;;
|
|
# b|backuppath)
|
|
b)
|
|
if [ -z "${BACKUPDIR}" ]; then
|
|
BACKUPDIR="${OPTARG}";
|
|
fi;
|
|
;;
|
|
# i|ident)
|
|
i)
|
|
if [ -z "${DB_VERSION}" ]; then
|
|
DB_VERSION=${OPTARG};
|
|
SET_IDENT=1;
|
|
fi;
|
|
;;
|
|
# u|user)
|
|
u)
|
|
if [ -z "${DB_USER}" ]; then
|
|
DB_USER=${OPTARG};
|
|
fi;
|
|
;;
|
|
# h|hostname)
|
|
h)
|
|
if [ -z "${DB_HOST}" ]; then
|
|
DB_HOST=${OPTARG};
|
|
fi;
|
|
;;
|
|
# p|port)
|
|
p)
|
|
if [ -z "${DB_PORT}" ]; then
|
|
DB_PORT=${OPTARG};
|
|
fi;
|
|
;;
|
|
# l|login)
|
|
l)
|
|
if [ -z "${DB_PASSWD}" ]; then
|
|
DB_PASSWD=${OPTARG};
|
|
fi;
|
|
;;
|
|
# d|database)
|
|
d)
|
|
if [ -z "${INCLUDE}" ]; then
|
|
INCLUDE=${INCLUDE}" ";
|
|
fi;
|
|
INCLUDE=${INCLUDE}${OPTARG};
|
|
;;
|
|
# e|exclude)
|
|
e)
|
|
if [ -z "${EXCLUDE}" ]; then
|
|
EXCLUDE=${EXCLUDE}" ";
|
|
fi;
|
|
EXCLUDE=${EXCLUDE}${OPTARG};
|
|
;;
|
|
# r|redhat)
|
|
r)
|
|
REDHAT=1;
|
|
;;
|
|
# L|logpath)
|
|
L)
|
|
if [ -z "${LOG_PATH}" ]; then
|
|
LOG_PATH="${OPTARG}";
|
|
fi;
|
|
;;
|
|
# m|manual)
|
|
m)
|
|
usage;
|
|
exit 0;
|
|
;;
|
|
:)
|
|
echo "Option -$OPTARG requires an argument."
|
|
;;
|
|
\?)
|
|
echo -e "\n Option does not exist: ${OPTARG}\n";
|
|
usage;
|
|
exit 1;
|
|
;;
|
|
esac;
|
|
done;
|
|
|
|
if [ ${ERROR} -eq 1 ]; then
|
|
exit 0;
|
|
fi;
|
|
|
|
# if we have numeric keep and keep number is set to 0 abort
|
|
if [ "${CLEAN_NUMBER}" -eq 1 ] && [ "${KEEP}" -lt 1 ]; then
|
|
echo "If keep in numbers is on, keep must be at least 1 or higher";
|
|
exit 0;
|
|
fi;
|
|
|
|
# set the defaults
|
|
for name in BACKUPDIR DB_VERSION DB_USER DB_PASSWD DB_HOST DB_PORT EXCLUDE INCLUDE; do
|
|
# assign it to the real name if the real name is empty
|
|
if [ -z "${!name}" ]; then
|
|
# add the _ for the default name
|
|
default="_"${name};
|
|
declare $name=${!default}
|
|
fi;
|
|
done;
|
|
|
|
# check base paths depending on installation and set log file
|
|
if [ "${REDHAT}" -eq 1 ]; then
|
|
# Redhat base path (for non official ones would be '/usr/pgsql-'
|
|
# This is also for Amazon NEWER (after 9.6)
|
|
PG_BASE_PATH="/usr/pgsql-";
|
|
# I assume that as default
|
|
if [ -z "${LOG_PATH}" ]; then
|
|
LOG_PATH="/var/lib/pgsql/${DB_VERSION}/data/log";
|
|
fi;
|
|
else
|
|
# Debian base path
|
|
PG_BASE_PATH="/usr/lib/postgresql/";
|
|
if [ -z "${LOG_PATH}" ]; then
|
|
LOG_PATH="/var/log/postgresql";
|
|
fi;
|
|
fi;
|
|
|
|
# setup log before everything else
|
|
LOG="${LOG_PATH}/pg_db_dump_file.log";
|
|
# if we cannot write to the log file abort
|
|
if [[ -f "${LOG}" && ! -w "${LOG}" ]] || [[ ! -f "${LOG}" && ! -w "${LOG_PATH}" ]]; then
|
|
echo "Cannot write to ${LOG} or create a new log file in ${LOG_PATH}";
|
|
exit;
|
|
fi;
|
|
# log to file and also write to stdout
|
|
exec &> >(tee -a "${LOG}");
|
|
|
|
# check DB port is valid number
|
|
if ! [[ "${DB_PORT}" =~ ${PORT_REGEX} ]]; then
|
|
echo "The port needs to be a valid number: ${DB_PORT}";
|
|
exit 0;
|
|
fi;
|
|
|
|
# check if we have the 'bc' command available or not
|
|
if [ -f "${BC}" ]; then
|
|
BC_OK=1;
|
|
else
|
|
BC_OK=0;
|
|
fi;
|
|
|
|
# the default pg params
|
|
PG_PARAMS=("-U" "${DB_USER}" "-p" "${DB_PORT}")
|
|
# if DB_HOST is set, we need to add -h to the command line
|
|
# if nothing is set, DB_HOST is set to local so we know this is a "port" connection for later automatic restore
|
|
if [ -z "${DB_HOST}" ]; then
|
|
DB_HOST='local';
|
|
else
|
|
# CONN_DB_HOST='-h '${DB_HOST};
|
|
PG_PARAMS+=("-h" "${DB_HOST}");
|
|
fi;
|
|
# copy to select
|
|
PG_PARAMS_SELECT=("${PG_PARAMS[@]}");
|
|
PG_PARAMS_SELECT+=("-d" "template1" "-t" "-A" "-F" "," "-X" "-q" "-c");
|
|
|
|
# set the binaries we need
|
|
PG_PATH=${PG_BASE_PATH}${DB_VERSION}'/bin/';
|
|
PG_PSQL=${PG_PATH}'psql';
|
|
PG_DUMP=${PG_PATH}'pg_dump';
|
|
PG_DUMPALL=${PG_PATH}'pg_dumpall';
|
|
DB_TYPE='pgsql';
|
|
db='';
|
|
|
|
# core abort if no core files found
|
|
if [ ! -f "${PG_PSQL}" ] || [ ! -f "${PG_DUMP}" ] || [ ! -f "${PG_DUMPALL}" ]; then
|
|
echo "One of the core binaries (psql, pg_dump, pg_dumpall) could not be found.";
|
|
echo "Search Path: ${PG_PATH}";
|
|
echo "Perhaps manual ident set with -i is necessary";
|
|
echo "Backup aborted";
|
|
exit 0;
|
|
fi;
|
|
|
|
# not directory or length is zero
|
|
if [ ! -d "${BACKUPDIR}" ] || [ -z "${BACKUPDIR}" ]; then
|
|
echo "Backup directory does not exist: ${BACKUPDIR}";
|
|
exit 0;
|
|
fi
|
|
# check if we can write into that folder
|
|
touch "${BACKUPDIR}/tmpfile" || echo "[!] touch failed";
|
|
if [ ! -f "${BACKUPDIR}/tmpfile" ]; then
|
|
echo "Cannot write to ${BACKUPDIR}";
|
|
exit 0;
|
|
else
|
|
rm "${BACKUPDIR}/tmpfile";
|
|
fi;
|
|
# if backupdir is "." rewrite to pwd
|
|
if [ "${BACKUPDIR}" == '.' ]; then
|
|
BACKUPDIR=$(pwd);
|
|
fi;
|
|
# check if we can connect to template1 table, if not we abort here
|
|
_PG_PARAMS_SELECT=("${PG_PARAMS_SELECT[@]}");
|
|
_PG_PARAMS_SELECT+=("SELECT datname FROM pg_catalog.pg_database WHERE datname = 'template1';");
|
|
connect=$(${PG_PSQL} "${_PG_PARAMS_SELECT[@]}") || echo "[!] pgsql connect error";
|
|
if [ "${connect}" != "template1" ]; then
|
|
echo "Failed to connect to template1 with user '${DB_USER}' at host '${DB_HOST}' on port '${DB_PORT}'";
|
|
exit 0;
|
|
fi;
|
|
|
|
# if we have an ident override set, set a different DUMP VERSION here than the automatic one
|
|
if [ "${SET_IDENT}" -eq 1 ]; then
|
|
DUMP_DB_VERSION=$(
|
|
pgv=$(
|
|
"${PG_PATH}/pg_dump" --version | grep "pg_dump" | cut -d " " -f 3
|
|
);
|
|
if [[ $(echo "${pgv}" | cut -d "." -f 1) -ge 10 ]]; then
|
|
echo "${pgv}" | cut -d "." -f 1;
|
|
else
|
|
echo "${pgv}" | cut -d "." -f 1,2;
|
|
fi
|
|
);
|
|
else
|
|
DUMP_DB_VERSION=${DB_VERSION};
|
|
fi;
|
|
|
|
# turn of ssl
|
|
# comment line out, if SSL connection is wanted
|
|
export PGSSLMODE=${SSLMODE};
|
|
|
|
# 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
|
|
if [ ${BC_OK} -eq 1 ]; then
|
|
output[${#output[*]}]=$(echo "${timestamp}/${timeslice}" | bc);
|
|
timestamp=$(echo "${timestamp}%${timeslice}" | bc);
|
|
else
|
|
output[${#output[*]}]=$(awk "BEGIN {printf \"%d\", ${timestamp}/${timeslice}}");
|
|
timestamp=$(awk "BEGIN {printf \"%d\", ${timestamp}%${timeslice}}");
|
|
fi;
|
|
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;
|
|
# milliseconds must be filled, but we also check that they are non "nan" string
|
|
# that can appear in the original value
|
|
if [ -n "${ms}" ] && [ "${ms}" != "nan" ]; then
|
|
if [ "${ms}" -gt 0 ]; then
|
|
time_string="${time_string} ${ms}ms";
|
|
fi;
|
|
fi;
|
|
# just in case the time is 0
|
|
if [ -z "${time_string}" ]; then
|
|
time_string="0s";
|
|
fi;
|
|
echo -n "${time_string}";
|
|
}
|
|
|
|
# METHOD: convert_bytes
|
|
# PARAMS: size in bytes
|
|
# RETURN: human readable byte data in TB/GB/MB/KB/etc
|
|
# CALL : size=$(convert_bytes $bytes);
|
|
# DESC : converts bytes into human readable format with 2 decimals
|
|
function convert_bytes
|
|
{
|
|
bytes=${1};
|
|
# use awk to calc it
|
|
echo -n "$(echo "${bytes}" | awk 'function human(x) {
|
|
s=" B KB MB GB TB EB PB YB ZB"
|
|
while (x>=1024 && length(s)>1)
|
|
{x/=1024; s=substr(s,4)}
|
|
s=substr(s,1,4)
|
|
xf=(s==" B ")?"%d ":"%.2f"
|
|
return sprintf( xf"%s\n", x, s)
|
|
}
|
|
{gsub(/^[0-9]+/, human($1)); print}')";
|
|
}
|
|
|
|
# METHOD: get_dump_file_name
|
|
# PARAMS: none
|
|
# RETURN: dump file name (echo)
|
|
# CALL : var=$(get_dump_file_name);
|
|
# DESC : function for getting the correct dump file
|
|
function get_dump_file_name
|
|
{
|
|
# set base search for the files
|
|
if [ "${db}" ]; then
|
|
db_name="${db}.${owner}.${encoding}.";
|
|
else
|
|
db_name="pg_globals.${DB_USER}.NONE.";
|
|
fi;
|
|
seq='';
|
|
# we need to find the next sequence number
|
|
for i in "${BACKUPDIR}/${db_name}${DB_TYPE}-${DUMP_DB_VERSION}_${DB_HOST}_${DB_PORT}_$(date +%Y%m%d)_$(date +%H%M)"*.c.sql; do
|
|
# get the last sequence and cut any leading 0 so we can run +1 on it
|
|
seq=$(echo "$i" | cut -d "." -f 4 | cut -d "_" -f 6 | sed -e "s/^0//g");
|
|
done;
|
|
if [ -n "${seq}" ]; then
|
|
# add +1 and if < 10 prefix with 0
|
|
seq=$((seq+1));
|
|
if [ ${seq} -lt 10 ]; then
|
|
sequence="0"${seq};
|
|
else
|
|
sequence=${seq};
|
|
fi;
|
|
else
|
|
sequence="01";
|
|
fi;
|
|
# now build correct file name
|
|
filename="${BACKUPDIR}/${db_name}${DB_TYPE}-${DUMP_DB_VERSION}_${DB_HOST}_${DB_PORT}_$(date +%Y%m%d)_$(date +%H%M)_${sequence}.c.sql";
|
|
echo "${filename}";
|
|
}
|
|
|
|
# METHOD: get_dump_databases
|
|
# PARAMS: none
|
|
# RETURN: none
|
|
# CALLS : var=$(get_dump_databases)
|
|
# DESC : this is needd only for clean up run if the clean up is run before
|
|
# the actually database dump
|
|
# fills up the global search names aray
|
|
function get_dump_databases
|
|
{
|
|
search_names=();
|
|
if [ ${GLOBALS} -eq 1 ]; then
|
|
search_names+=("pg_globals.*");
|
|
fi;
|
|
_PG_PARAMS_SELECT=("${PG_PARAMS_SELECT[@]}");
|
|
_PG_PARAMS_SELECT+=("SELECT pg_catalog.pg_get_userbyid(datdba) AS owner, datname, pg_catalog.pg_encoding_to_char(encoding) FROM pg_catalog.pg_database WHERE datname !~ 'template(0|1)';");
|
|
for owner_db in $(${PG_PSQL} "${_PG_PARAMS_SELECT[@]}"); do
|
|
db=$(echo "${owner_db}" | cut -d "," -f 2);
|
|
# check if we exclude this db
|
|
exclude=0;
|
|
include=0;
|
|
for excl_db in ${EXCLUDE}; do
|
|
if [ "${db}" = "${excl_db}" ]; then
|
|
exclude=1;
|
|
break;
|
|
fi;
|
|
done;
|
|
if [ -n "${INCLUDE}" ]; then
|
|
for incl_db in ${INCLUDE}; do
|
|
if [ "${db}" = "${incl_db}" ]; then
|
|
include=1;
|
|
break;
|
|
fi;
|
|
done;
|
|
else
|
|
include=1;
|
|
fi;
|
|
if [ ${exclude} -eq 0 ] && [ ${include} -eq 1 ]; then
|
|
search_names+=("${db}.*");
|
|
fi;
|
|
done;
|
|
}
|
|
|
|
# METHOD: clean_up
|
|
# PARAMS: none
|
|
# RETURN: none
|
|
# CALL : $(clean_up);
|
|
# DESC : checks for older files than given keep time/amount and removes them
|
|
function clean_up
|
|
{
|
|
if [ -d "${BACKUPDIR}" ]; then
|
|
if [ ${CLEAN_NUMBER} -eq 0 ]; then
|
|
echo "Cleanup older than ${KEEP} days backup in ${BACKUPDIR}";
|
|
else
|
|
echo "Cleanup up, keep only ${KEEP} backups in ${BACKUPDIR}";
|
|
# if we run clean before backup, we need to clean up +1
|
|
# so if we keep one, we must remove all data before running new
|
|
if [ ${PRE_RUN_CLEAN_UP} -eq 1 ]; then
|
|
# let KEEP=${KEEP}-1;
|
|
KEEP=$((KEEP-1));
|
|
fi;
|
|
fi;
|
|
# build the find string based on the search names patter
|
|
find_params=("${BACKUPDIR}");
|
|
for name in "${search_names[@]}"; do
|
|
# for not number based, we build the find string here
|
|
# else we do the delete here already
|
|
if [ ${CLEAN_NUMBER} -eq 0 ]; then
|
|
if [ ${#find_params[@]} -gt 1 ]; then
|
|
find_params+=("-o");
|
|
fi;
|
|
find_params+=("-mtime" "+${KEEP}" "-name" "${name}${DB_TYPE}*.sql" "-type" "f" "-delete" "-print");
|
|
echo "- Remove old backups for '${name}'";
|
|
else
|
|
# if we do number based delete of old data, but only if the number of
|
|
# files is bigger than the keep number or equal if we do PRE_RUN_CLEAN_UP
|
|
# this can be error, but we allow it -> script should not abort here
|
|
# note we have a wildcard in the name, so we can't put that into ""
|
|
count=$(find "${BACKUPDIR}" -name "${name}${DB_TYPE}*.sql" -type f -print | wc -l);
|
|
if [ ${PRE_RUN_CLEAN_UP} -eq 1 ]; then
|
|
# let count=${count}+1;
|
|
count=$((count+1));
|
|
fi;
|
|
if [ "${count}" -gt "${KEEP}" ]; then
|
|
# calculate the amount to delete
|
|
# eg if we want to keep 1, and we have 3 files then we need to delete 2
|
|
# keep is always +1 (include the to backup count).
|
|
# count is +1 if we do a pre-run cleanup
|
|
# grouped by db name, db type
|
|
TO_DELETE=$((count-KEEP));
|
|
echo "- Remove old backups for '${name}', found ${count}, will delete ${TO_DELETE}";
|
|
if [ ${TEST} -eq 0 ]; then
|
|
find "${BACKUPDIR}" -name "${name}${DB_TYPE}*.sql" -type f -printf "%Ts\t%p\n" | \
|
|
sort -n | \
|
|
head -n ${TO_DELETE} | \
|
|
xargs rm;
|
|
else
|
|
print "find \"${BACKUPDIR}\" -name \"${name}${DB_TYPE}*.sql\" -type f -printf \"%Ts\\t%p\\n\" | sort -nr | head -n ${TO_DELETE} | xargs rm";
|
|
fi;
|
|
fi;
|
|
fi;
|
|
done;
|
|
# if we do find (day based) delete of old data
|
|
if [ ${CLEAN_NUMBER} -eq 0 ]; then
|
|
if [ ${TEST} -eq 0 ]; then
|
|
find "${find_params[@]}";
|
|
else
|
|
echo "find ${find_params[*]}";
|
|
fi;
|
|
fi;
|
|
fi
|
|
}
|
|
|
|
if [ -n "${DB_PASSWD}" ]; then
|
|
export PGPASSWORD=${DB_PASSWD};
|
|
fi;
|
|
START=$(date "+%s");
|
|
echo "=======================================================================>";
|
|
printf "Starting at %s\n" "$(date '+%Y-%m-%d %H:%M:%S')";
|
|
echo "Target dump directory is: ${BACKUPDIR}";
|
|
echo "Keep ${KEEP} backups";
|
|
# if flag is set, do pre run clean up
|
|
if [ ${PRE_RUN_CLEAN_UP} -eq 1 ]; then
|
|
get_dump_databases;
|
|
clean_up;
|
|
fi;
|
|
echo "Backing up databases:";
|
|
# reset search name list for actual dump
|
|
search_names=();
|
|
# dump globals
|
|
if [ ${GLOBALS} -eq 1 ]; then
|
|
echo -e -n "+ Dumping globals ... "
|
|
# reset any previous set db name from deletes so the correct global file name is set
|
|
db='';
|
|
filename=$(get_dump_file_name);
|
|
# this is used for the find/delete part
|
|
search_names+=("pg_globals.*");
|
|
# build dump parms
|
|
_PG_PARAMS_DUMP=("${PG_PARAMS[@]}");
|
|
_PG_PARAMS_DUMP+=("--globals-only")
|
|
if [ ${TEST} -eq 0 ]; then
|
|
${PG_DUMPALL} "${_PG_PARAMS_DUMP[@]}" > "${filename}";
|
|
else
|
|
echo "${PG_DUMPALL} ${_PG_PARAMS_DUMP[*]} > ${filename}";
|
|
fi;
|
|
echo "done";
|
|
else
|
|
echo "- Skip dumping globals";
|
|
fi;
|
|
|
|
echo -n "(+) Dump databases: ";
|
|
if [ -z "${INCLUDE}" ]; then
|
|
echo "All";
|
|
else
|
|
echo "${INCLUDE}";
|
|
fi;
|
|
echo -n "(-) Exclude databases: ";
|
|
if [ -z "${EXCLUDE}" ]; then
|
|
echo "None";
|
|
else
|
|
echo "${EXCLUDE}";
|
|
fi;
|
|
|
|
filesize_sum=0;
|
|
_PG_PARAMS_SELECT=("${PG_PARAMS_SELECT[@]}");
|
|
_PG_PARAMS_SELECT+=("SELECT pg_catalog.pg_get_userbyid(datdba) AS owner, datname, pg_catalog.pg_encoding_to_char(encoding) AS encoding FROM pg_catalog.pg_database WHERE datname !~ 'template(0|1)' ORDER BY datname;");
|
|
for owner_db in $(${PG_PSQL} "${_PG_PARAMS_SELECT[@]}"); do
|
|
# get the user who owns the DB too
|
|
owner=$(echo "${owner_db}" | cut -d "," -f 1);
|
|
db=$(echo "${owner_db}" | cut -d "," -f 2);
|
|
encoding=$(echo "${owner_db}" | cut -d "," -f 3);
|
|
# check if we exclude this db
|
|
exclude=0;
|
|
include=0;
|
|
for excl_db in ${EXCLUDE}; do
|
|
if [ "${db}" = "${excl_db}" ]; then
|
|
exclude=1;
|
|
break;
|
|
fi;
|
|
done;
|
|
if [ -n "${INCLUDE}" ]; then
|
|
for incl_db in ${INCLUDE}; do
|
|
if [ "${db}" = "${incl_db}" ]; then
|
|
include=1;
|
|
break;
|
|
fi;
|
|
done;
|
|
else
|
|
include=1;
|
|
fi;
|
|
if [ ${exclude} -eq 0 ] && [ ${include} -eq 1 ]; then
|
|
printf "+ Dumping database: %35s ... " "${db}";
|
|
filename=$(get_dump_file_name);
|
|
search_names+=("${db}.*");
|
|
SUBSTART=$(date "+%s");
|
|
# build dump parms
|
|
_PG_PARAMS_DUMP=("${PG_PARAMS[@]}");
|
|
_PG_PARAMS_DUMP+=("-c" "--format=c" "${db}")
|
|
if [ ${TEST} -eq 0 ]; then
|
|
${PG_DUMP} "${_PG_PARAMS_DUMP[@]}" > "${filename}";
|
|
else
|
|
echo "${PG_DUMP} ${_PG_PARAMS_DUMP[*]} > ${filename}";
|
|
fi;
|
|
# get the file size for the dumped file and convert it to a human readable format
|
|
filesize=0;
|
|
if [ -f "${filename}" ]; then
|
|
filesize=$(wc -c "${filename}" | cut -f 1 -d ' ');
|
|
filesize_sum=$((filesize+filesize_sum));
|
|
fi;
|
|
DURATION=$(($(date "+%s")-SUBSTART));
|
|
printf "done (%s and %s)\n" "$(convert_time ${DURATION})" "$(convert_bytes "${filesize}")";
|
|
else
|
|
printf -- "- Exclude database: %35s\n" "${db}";
|
|
fi;
|
|
done
|
|
printf "Backup ended at %s\n" "$(date '+%Y-%m-%d %H:%M:%S')";
|
|
if [ -n "${DB_PASSWD}" ]; then
|
|
unset DB_PASSWD;
|
|
fi;
|
|
|
|
if [ ${PRE_RUN_CLEAN_UP} -eq 0 ]; then
|
|
clean_up;
|
|
fi;
|
|
|
|
DURATION=$(($(date "+%s")-START));
|
|
printf "Cleanup ended at %s\n" "$(date '+%Y-%m-%d %H:%M:%S')";
|
|
printf "Finished backup in %s with %s\n" "$(convert_time ${DURATION})" "$(convert_bytes ${filesize_sum})";
|
|
|
|
## END
|