script/postgres
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Initial import

Browse Source
This commit is contained in:
Christoph 2017-02-21 02:33:47 +01:00
commit 1e2a1066c0
14 changed files with 3539 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
OLD/analyze_reindex_pg-databases_manual.sh Executable file
View File

@ -0,0 +1,49 @@
#!/usr/bin/env bash
LOGGING=true
curdir=`pwd`
cd /tmp
psql=`which psql`
grep=`which grep`
awk=`which awk`
DATABASES=`/bin/su postgres -c "$psql -lt" | $grep -v -e"^$" | $grep -v -e "^\s*[:|]" | $awk '{print$1}'`
for db in $DATABASES ; do
if [ "$db" == "template0" ]; then
continue
fi
if $LOGGING ;then
echo "Database...: $db"
fi
TABLES=`/bin/su postgres -c "$psql -lt -q -c \"\dt \" $db" | awk '{print$3}'`
if $LOGGING ;then
echo
fi
for tbl in $TABLES ; do
if $LOGGING ;then
echo -e "\tvacuum analyze table $tbl .."
fi
/bin/su postgres -c "$psql -q -c \"VACUUM ANALYZE $tbl\" $db"
[[ $? -gt 0 ]] && echo "[ERROR]: vacuun/analyzing table \"${tbl}\" of database \"$db\" failed !!"
if $LOGGING ;then
echo -e "\treindex table $tbl ..\n"
fi
/bin/su postgres -c "$psql -q -c \"REINDEX TABLE $tbl\" $db" > /dev/null 2>&1
[[ $? -gt 0 ]] && echo "[ERROR]: reindexing table \"${tbl}\" of database \"$db\" failed !!"
done
if $LOGGING ;then
echo
fi
done
cd $curdir
exit

354
OLD/dump_all_pg_dbs.sh.00 Executable file
View File

@ -0,0 +1,354 @@
#!/bin/sh
BACKUP_BASE_DIR="/data/pgsql/backup"
mkdir -p $BACKUP_BASE_DIR
PSQL_BIN_DIR=/usr/local/pgsql/bin
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
## - muss als user root ausgeführt werden
## -
if [ "`id -u`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
YEAR=`date +"%Y"`
MONTH=`date +"%m"`
DAY=`date +"%d"`
HOUR=`date +"%H"`
MINUTE=`date +"%M"`
DATE=${YEAR}${MONTH}${DAY}-${HOUR}${MINUTE}
## DATE=`date +"%Y%m%d-%H%M"`
# -- erstelle liste der datenbanken
# --
listfile=${BACKUP_BASE_DIR}/dblist-${DATE}.txt
echo -e "Stand: ${DATE}\n" > $listfile
su postgres -c"${PSQL_BIN_DIR}/psql -l" >> $listfile
# - Erstelle Liste der Datenbanken (zur Weiterverarbeitung)
# -
# database_list=`su postgres -c"${PSQL_BIN_DIR}/psql -Alt -F ' '" | awk '{print$1}'`
# - Erstelle Liste der User (Roles) (zur Weiterverarbeitung)
# -
role_list=`su postgres -c"${PSQL_BIN_DIR}/psql -At -F ' ' -c \"\\du\"" | awk '{print$1}'`
for role in $role_list ; do
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -g -c " | grep ${role} > ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
#!/bin/sh
role=$role
restore_file=${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
logfile=${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.log
PSQL_BIN_DIR=$PSQL_BIN_DIR
PSQL_USER=postgres
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
echo -e "\n\trestoring role \$role..\n"
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
EOF
chmod 755 ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
done
dbusers_databases_file=${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
# -- Erstelle dump (Teil 1) zum Wiederherstellen der
# -- User und Datenbanken:
# -- Header
# --
cat <<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su postgres -c"${PSQL_BIN_DIR}/psql -f $dbusers_databases_file template1"
--
--
-- Drop dumped databases
--
\\connect postgres
EOF
# -- Erstelle dump Dateien sowie Wiederherstellungsscripte
# -- fuer die einzelnen Datenbanken
# --
databases=`su postgres -c"${PSQL_BIN_DIR}/psql -l -t" | grep -v -e"^$" | awk '{print$1}'`
dbs_dumped=""
for db in $databases ; do
BACKUP_DIR=${BACKUP_BASE_DIR}/$db
mkdir -p $BACKUP_DIR
# -- Erstelle dump Datei
# --
su postgres -c"${PSQL_BIN_DIR}/pg_dump -c $db" > ${BACKUP_DIR}/dump_${db}-${DATE}.sql 2> /dev/null
if [ $? -eq 0 ]; then
echo -e "\n\t$db: successfully dumped\n"
dbs_dumped="$dbs_dumped $db"
# -- Erstelle Wiederherstellungsscript
# --
cat<<EOF > ${BACKUP_DIR}/restore_${db}-${DATE}.sh
#!/bin/sh
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
## --
## -- restore data for databas $db:
## -- su postgres -c"${PSQL_BIN_DIR}/psql -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
## --
echo -e "\n\trestore data for databas $db from backup at ${DAY}.${MONTH}.${YEAR} ${HOUR}:${MINUTE}h\n"
su postgres -c"${PSQL_BIN_DIR}/psql -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
EOF
chmod 755 ${BACKUP_DIR}/restore_${db}-${DATE}.sh
# -- Erstelle dump (Teil 2) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP DATABASE statements
# --
echo "DROP DATABASE \"$db\";" >> $dbusers_databases_file
else
echo -e "\n\t$db: [WARNING] cannot dump database $db\n"
rm -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql
fi
done
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP ROLE ..
# -- CREATE ROLE..
# --
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -g -c " >> $dbusers_databases_file
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- CREATE DATABASE
# --
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -s" | grep -e "^CREATE DATABASE" >> $dbusers_databases_file
# -- Bemerkung:
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su postgres -c"psql -f $dbusers_databases_file template1"
# -- Erstelle script zum Wiederherstellen der Geasmaten Datenbank,
# -- User, Datenbanken ( Definitionen und Datensätze
# --
cat<<EOF > ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$BACKUP_BASE_DIR ] ; then
echo
echo " Backup directory not found"
echo
exit 1
fi
PSQL_USER=postgres
PSQL_BIN_DIR="$PSQL_BIN_DIR"
logfile=restore_dump-${DATE}.log
# -- Wiedrherstellung der Datanbank User und Datenbank Definitionen
# --
## restore_file=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases\`
_list=\`ls -t \${BACKUP_BASE_DIR}/db_users_databases*\`
restore_file=\`echo \$_list | awk '{print\$1}'\`
restore_file=$dbusers_databases_file
echo -e "\n\tWiedrherstellung der Datanbank User und Datenbank Definitionen"
echo -e "\t==============================================================\n"
## echo -e "\tsu $PSQL_USER -c\"${PSQL_BIN_DIR}/psql -f \$restore_file template1\"\n"
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
echo
echo -n "Sollen die Datenbanksätze reorganisiert werden? [ja/nein]: "
read OK
while [ "X\$OK" != "Xyes" -a "X\$OK" != "XYes" -a "X\$OK" != "Xja" -a "X\$OK" != "XJa" \
-a "X\$OK" != "XNo" -a "X\$OK" != "Xno" -a "X\$OK" != "Xn" -a "X\$OK" != "Xnein" -a "X\$OK" != "XNein" ]
do
echo -n "falsche Angabe! [ja/nein]: "
read OK
done
[ \$OK = "Yes" -o \$OK = "yes" -o "\$OK" = "ja" -o "\$OK" = "Ja" ] || exit 0
# -- Wiedrherstellung der Datanbankdaten
# --
## databases=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type d -printf "%f "\`
databases="$dbs_dumped"
echo -e "\n\tWiedrherstellung der Datanbankdaten"
echo -e "\t===================================\n"
for db in \$databases ; do
## _list=\`ls -d -t \${BACKUP_BASE_DIR}/\$db/*${DATE}.sql\`
## file=\`echo \$_list | awk '{print\$1}'\`
file=\${BACKUP_BASE_DIR}/\$db/dump_${db}-${DATE}.sql
## echo -e "\\t\$file"
if [ -f \$file ]; then
## echo -e "\\t\${db}: su \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$file \$db\" restoring..\n"
echo -e "\\t\${db}: restoring..\n"
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$file \$db" >> \$logfile 2>&1
else
echo -e "\\t\${db}: [WARNING] konnte keine Sicherung vom ${DAY}.${MONTH}.${YEAR} (${HOUR}:${MINUTE}h) finden\n"
fi
done
echo
exit 0
EOF
chmod 755 ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
for db in $dbs_dumped ; do
cat $dbusers_databases_file | grep "DATABASE $db " > ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$BACKUP_BASE_DIR ] ; then
echo
echo " Backup directory not found"
echo
exit 1
fi
PSQL_USER=postgres
PSQL_BIN_DIR="$PSQL_BIN_DIR"
file=${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
logfile=${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$file" | tee ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
## - get user
## -
_owner=`cat ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql | grep OWNER | sed -e "s/.*OWNER[\ ]\{1,\}=[\ ]\{1,\}\([^\ ]*\).*/\1/"`
owner=`echo $_owner | cut -d' ' -f1`
## echo -e "\tOWNER = X${owner}X"
if [ -n "$owner" ]; then
cp ${BACKUP_BASE_DIR}/createrole_${owner}-${DATE}.sql ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$BACKUP_BASE_DIR ] ; then
echo
echo " Backup directory not found"
echo
exit 1
fi
PSQL_USER=postgres
PSQL_BIN_DIR="$PSQL_BIN_DIR"
file=${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
logfile=${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.log
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$file" | tee ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
fi
done
# -- Create archive from the whole backup
# --
_curdir=`pwd`
cd ${BACKUP_BASE_DIR}
tar -czf db_dump-${DATE}.tar.gz `find . -name "*${DATE}*"`
cd $_curdir
# delete all older than $days days
#
/usr/bin/find $BACKUP_DIR -type f -mtime +${days} -exec /bin/rm {} \;
exit 0

488
OLD/dump_all_pg_dbs.sh.01 Executable file
View File

@ -0,0 +1,488 @@
#!/bin/sh
#BACKUP_BASE_DIR="/data/pgsql/backup"
BACKUP_BASE_DIR="/data/backup/pgsql"
mkdir -p $BACKUP_BASE_DIR
PSQL_BIN_DIR=/usr/local/pgsql/bin
if [ ! -d $PSQL_BIN_DIR ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
## - muss als user root ausgeführt werden
## -
if [ "`id -u`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
YEAR=`date +"%Y"`
MONTH=`date +"%m"`
DAY=`date +"%d"`
HOUR=`date +"%H"`
MINUTE=`date +"%M"`
DATE=${YEAR}${MONTH}${DAY}-${HOUR}${MINUTE}
## DATE=`date +"%Y%m%d-%H%M"`
# -- erstelle liste der datenbanken
# --
listfile=${BACKUP_BASE_DIR}/dblist-${DATE}.txt
echo -e "Stand: ${DATE}\n" > $listfile
su postgres -c"${PSQL_BIN_DIR}/psql -l" >> $listfile
# - Erstelle Liste der Datenbanken (zur Weiterverarbeitung)
# -
# database_list=`su postgres -c"${PSQL_BIN_DIR}/psql -Alt -F ' '" | awk '{print$1}'`
# - Erstelle Liste der User (Roles) (zur Weiterverarbeitung)
# -
role_list=`su postgres -c"${PSQL_BIN_DIR}/psql -At -F ' ' -c \"\\du\" postgres" | awk '{print$1}'`
for role in $role_list ; do
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -g -c " | grep ${role} > ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
#!/bin/sh
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
role=$role
restore_file=\${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.log
PSQL_USER=postgres
PSQL_BIN_DIR=$PSQL_BIN_DIR
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
echo -e "\n\trestoring role \$role..\n"
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
EOF
chmod 755 ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
done
dbusers_databases_file=${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
# -- Erstelle dump (Teil 1) zum Wiederherstellen der
# -- User und Datenbanken:
# -- Header
# --
cat <<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su postgres -c"${PSQL_BIN_DIR}/psql -f $dbusers_databases_file template1"
--
--
-- Drop dumped databases
--
\\connect postgres
EOF
# -- Erstelle dump Dateien sowie Wiederherstellungsscripte
# -- fuer die einzelnen Datenbanken
# --
databases=`su postgres -c"${PSQL_BIN_DIR}/psql -l -t" | grep -v -e"^$" | awk '{print$1}'`
dbs_dumped=""
for db in $databases ; do
BACKUP_DIR=${BACKUP_BASE_DIR}/$db
mkdir -p $BACKUP_DIR
[ "$db" == "template0" ] && continue
# -- Erstelle dump Datei
# --
su postgres -c"${PSQL_BIN_DIR}/pg_dump -c $db" > ${BACKUP_DIR}/dump_${db}-${DATE}.sql 2> /dev/null
if [ $? -eq 0 ]; then
#echo -e "\n\t$db: successfully dumped\n"
dbs_dumped="$dbs_dumped $db"
# -- Erstelle Wiederherstellungsscript
# --
cat<<EOF > ${BACKUP_DIR}/restore_${db}-${DATE}.sh
#!/bin/sh
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
BACKUP_DIR=\${BACKUP_BASE_DIR}/$db
PSQL_USER=postgres
PSQL_BIN_DIR=$PSQL_BIN_DIR
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
## --
## -- restore data for databas $db:
## -- su postgres -c"\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
## --
echo -e "\n\trestore data for databas $db from backup at ${DAY}.${MONTH}.${YEAR} ${HOUR}:${MINUTE}h\n"
su postgres -c"\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
EOF
chmod 755 ${BACKUP_DIR}/restore_${db}-${DATE}.sh
# -- Erstelle dump (Teil 2) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP DATABASE statements
# --
echo "DROP DATABASE \"$db\";" >> $dbusers_databases_file
else
echo -e "\n\t$db: [WARNING] cannot dump database $db\n"
rm -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql
fi
done
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP ROLE ..
# -- CREATE ROLE..
# --
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -g -c " >> $dbusers_databases_file
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- CREATE DATABASE
# --
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -s" | grep -e "^CREATE DATABASE" >> $dbusers_databases_file
# -- Bemerkung:
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su postgres -c"psql -f $dbusers_databases_file template1"
# -- Erstelle script zum Wiederherstellen der Geasmaten Datenbank,
# -- User, Datenbanken ( Definitionen und Datensätze
# --
cat<<EOF > ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
PSQL_USER=postgres
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
logfile=\${BACKUP_BASE_DIR}/restore_dump-${DATE}.log
# -- Wiedrherstellung der Datanbank User und Datenbank Definitionen
# --
## restore_file=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases\`
## _list=\`ls -t \${BACKUP_BASE_DIR}/db_users_databases*\`
## restore_file=\`echo \$_list | awk '{print\$1}'\`
## restore_file=$dbusers_databases_file
restore_file=\${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
echo -e "\n\tWiedrherstellung der Datanbank User und Datenbank Definitionen"
echo -e "\t==============================================================\n"
## echo -e "\tsu \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$restore_file template1\"\n"
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
echo
echo -n "Sollen die Datenbanksätze reorganisiert werden? [ja/nein]: "
read OK
while [ "X\$OK" != "Xyes" -a "X\$OK" != "XYes" -a "X\$OK" != "Xja" -a "X\$OK" != "XJa" \
-a "X\$OK" != "XNo" -a "X\$OK" != "Xno" -a "X\$OK" != "Xn" -a "X\$OK" != "Xnein" -a "X\$OK" != "XNein" ]
do
echo -n "falsche Angabe! [ja/nein]: "
read OK
done
[ \$OK = "Yes" -o \$OK = "yes" -o "\$OK" = "ja" -o "\$OK" = "Ja" ] || exit 0
# -- Wiedrherstellung der Datanbankdaten
# --
## databases=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type d -printf "%f "\`
databases="$dbs_dumped"
echo -e "\n\tWiedrherstellung der Datanbankdaten"
echo -e "\t===================================\n"
for db in \$databases ; do
## _list=\`ls -d -t \${BACKUP_BASE_DIR}/\$db/*${DATE}.sql\`
## file=\`echo \$_list | awk '{print\$1}'\`
file=\${BACKUP_BASE_DIR}/\$db/dump_\${db}-${DATE}.sql
## echo -e "\\t\$file"
if [ -f \$file ]; then
## echo -e "\\t\${db}: su \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$file \$db\" restoring..\n"
echo -e "\\t\${db}: restoring..\n"
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$file \$db" >> \$logfile 2>&1
else
echo -e "\\t\${db}: [WARNING] konnte keine Sicherung vom ${DAY}.${MONTH}.${YEAR} (${HOUR}:${MINUTE}h) finden\n"
fi
done
echo
exit 0
EOF
chmod 755 ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
for db in $dbs_dumped ; do
cat $dbusers_databases_file | grep "DATABASE $db " > ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
PSQL_USER=postgres
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$file" | tee \${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
## - get user
## -
_owner=`cat ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql | grep OWNER | sed -e "s/.*OWNER[\ ]\{1,\}=[\ ]\{1,\}\([^\ ]*\).*/\1/"`
owner=`echo $_owner | cut -d' ' -f1`
## echo -e "\tOWNER = X${owner}X"
if [ -n "$owner" ]; then
cp ${BACKUP_BASE_DIR}/createrole_${owner}-${DATE}.sql ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
## - muss als user root ausgeführt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
PSQL_USER=postgres
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.log
su \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \$file" | tee \${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
fi
done
# -- Create archive from the whole backup
# --
_curdir=`pwd`
cd ${BACKUP_BASE_DIR}
cd .. > /dev/null 2>&1
tar -czf db_dump-${DATE}.tar.gz `find . -name "*${DATE}*"`
cd $_curdir
# delete all older than $days days
#
/usr/bin/find $BACKUP_BASE_DIR/.. -type f -mtime +${days} -exec /bin/rm {} \;
exit 0

540
OLD/dump_all_pg_dbs.sh.02 Executable file
View File

@ -0,0 +1,540 @@
#!/usr/bin/env bash
## - postgres user source system
## -
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER_SRC=postgres
else
PSQL_USER_SRC=pgsql
fi
## - postgres user destination system
PSQL_USER_DST=postgres
#BACKUP_BASE_DIR="/data/pgsql/backup"
BACKUP_BASE_DIR="/data/backup/pgsql"
mkdir -p $BACKUP_BASE_DIR
PSQL_BIN_DIR_SRC=/usr/local/pgsql/bin
if [ ! -d $PSQL_BIN_DIR_SRC ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/bin
elif [ -x /usr/local/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/local/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
PSQL_BIN_DIR_DST=$PSQL_BIN_DIR_SRC
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "`id -u`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
YEAR=`date +"%Y"`
MONTH=`date +"%m"`
DAY=`date +"%d"`
HOUR=`date +"%H"`
MINUTE=`date +"%M"`
DATE=${YEAR}${MONTH}${DAY}-${HOUR}${MINUTE}
## DATE=`date +"%Y%m%d-%H%M"`
# -- erstelle liste der datenbanken
# --
listfile=${BACKUP_BASE_DIR}/dblist-${DATE}.txt
echo -e "Stand: ${DATE}\n" > $listfile
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l" >> $listfile
# - Erstelle Liste der Datenbanken (zur Weiterverarbeitung)
# -
# database_list=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -Alt -F ' '" | awk '{print$1}'`
# - Erstelle Liste der User (Roles) (zur Weiterverarbeitung)
# -
role_list=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -At -F ' ' -c \"\\du\" postgres" | awk '{print$1}'`
for role in $role_list ; do
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " | grep ${role} > ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
role=$role
restore_file=\${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.log
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
echo -e "\n\trestoring role \$role..\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
EOF
chmod 755 ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
done
dbusers_databases_file=${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
# -- Erstelle dump (Teil 1) zum Wiederherstellen der
# -- User und Datenbanken:
# -- Header
# --
cat <<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su - <postgres-user> -c "<postgres-bin-dir>/psql -f $dbusers_databases_file template1"
--
--
-- Drop dumped databases
--
\\connect postgres
EOF
# -- Erstelle dump Dateien sowie Wiederherstellungsscripte
# -- fuer die einzelnen Datenbanken
# --
databases=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l -t" | grep -v -e"^$" | awk '{print$1}'`
dbs_dumped=""
for db in $databases ; do
BACKUP_DIR=${BACKUP_BASE_DIR}/$db
mkdir -p $BACKUP_DIR
[ "$db" == "template0" ] && continue
# -- Erstelle dump Datei
# --
su - $PSQL_USER_SRC -c " ${PSQL_BIN_DIR_SRC}/pg_dump -c $db" > ${BACKUP_DIR}/dump_${db}-${DATE}.sql 2> /dev/null
if [ $? -eq 0 ]; then
#echo -e "\n\t$db: successfully dumped\n"
dbs_dumped="$dbs_dumped $db"
# -- Erstelle Wiederherstellungsscript
# --
cat<<EOF > ${BACKUP_DIR}/restore_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
BACKUP_DIR=\${BACKUP_BASE_DIR}/$db
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
## --
## -- restore data for databas $db:
## -- su - \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
## --
echo -e "\n\trestore data for databas $db from backup at ${DAY}.${MONTH}.${YEAR} ${HOUR}:${MINUTE}h\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
EOF
chmod 755 ${BACKUP_DIR}/restore_${db}-${DATE}.sh
# -- Erstelle dump (Teil 2) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP DATABASE statements
# --
echo "DROP DATABASE \"$db\";" >> $dbusers_databases_file
else
echo -e "\n\t$db: [WARNING] cannot dump database $db\n"
rm -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql
fi
done
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP ROLE ..
# -- CREATE ROLE..
# --
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " >> $dbusers_databases_file
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- CREATE DATABASE
# --
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -s" | grep -e "^CREATE DATABASE" >> $dbusers_databases_file
# -- Bemerkung:
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su - postgres -c "psql -f $dbusers_databases_file template1"
# -- Erstelle script zum Wiederherstellen der Geasmaten Datenbank,
# -- User, Datenbanken ( Definitionen und Datensätze
# --
cat<<EOF > ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
logfile=\${BACKUP_BASE_DIR}/restore_dump-${DATE}.log
# -- Wiedrherstellung der Datanbank User und Datenbank Definitionen
# --
## restore_file=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases\`
## _list=\`ls -t \${BACKUP_BASE_DIR}/db_users_databases*\`
## restore_file=\`echo \$_list | awk '{print\$1}'\`
## restore_file=$dbusers_databases_file
restore_file=\${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
echo -e "\n\tWiedrherstellung der Datanbank User und Datenbank Definitionen"
echo -e "\t==============================================================\n"
## echo -e "\tsu - \$PSQL_USER -c \"\${PSQL_BIN_DIR}/psql -f \$restore_file template1\"\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
echo
echo -n "Sollen die Datenbanksaetze reorganisiert werden? [ja/nein]: "
read OK
while [ "X\$OK" != "Xyes" -a "X\$OK" != "XYes" -a "X\$OK" != "Xja" -a "X\$OK" != "XJa" \
-a "X\$OK" != "XNo" -a "X\$OK" != "Xno" -a "X\$OK" != "Xn" -a "X\$OK" != "Xnein" -a "X\$OK" != "XNein" ]
do
echo -n "falsche Angabe! [ja/nein]: "
read OK
done
[ \$OK = "Yes" -o \$OK = "yes" -o "\$OK" = "ja" -o "\$OK" = "Ja" ] || exit 0
# -- Wiedrherstellung der Datanbankdaten
# --
## databases=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type d -printf "%f "\`
databases="$dbs_dumped"
echo -e "\n\tWiedrherstellung der Datanbankdaten"
echo -e "\t===================================\n"
for db in \$databases ; do
## _list=\`ls -d -t \${BACKUP_BASE_DIR}/\$db/*${DATE}.sql\`
## file=\`echo \$_list | awk '{print\$1}'\`
file=\${BACKUP_BASE_DIR}/\$db/dump_\${db}-${DATE}.sql
## echo -e "\\t\$file"
if [ -f \$file ]; then
## echo -e "\\t\${db}: su - \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$file \$db\" restoring..\n"
echo -e "\\t\${db}: restoring..\n"
su - \$PSQL_USER -c" \${PSQL_BIN_DIR}/psql -f \$file \$db" >> \$logfile 2>&1
else
echo -e "\\t\${db}: [WARNING] konnte keine Sicherung vom ${DAY}.${MONTH}.${YEAR} (${HOUR}:${MINUTE}h) finden\n"
fi
done
echo
exit 0
EOF
chmod 755 ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
for db in $dbs_dumped ; do
cat $dbusers_databases_file | grep "DATABASE $db " > ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
## - get user
## -
_owner=`cat ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql | grep OWNER | sed -e "s/.*OWNER[\ ]\{1,\}=[\ ]\{1,\}\([^\ ]*\).*/\1/"`
owner=`echo $_owner | cut -d' ' -f1`
## echo -e "\tOWNER = X${owner}X"
if [ -n "$owner" ]; then
cp ${BACKUP_BASE_DIR}/createrole_${owner}-${DATE}.sql ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
fi
done
# -- Create archive from the whole backup
# --
_curdir=`pwd`
cd ${BACKUP_BASE_DIR}
cd .. > /dev/null 2>&1
tar -czf db_dump-${DATE}.tar.gz `find . -name "*${DATE}*"`
cd $_curdir
# delete all older than $days days
#
/usr/bin/find $BACKUP_BASE_DIR/.. -type f -mtime +${days} -exec /bin/rm {} \;
exit 0

547
OLD/dump_all_pg_dbs.sh.03 Executable file
View File

@ -0,0 +1,547 @@
#!/usr/bin/env bash
## - postgres user source system
## -
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER_SRC=postgres
else
PSQL_USER_SRC=pgsql
fi
## - postgres user destination system
PSQL_USER_DST=postgres
#BACKUP_BASE_DIR="/data/pgsql/backup"
BACKUP_BASE_DIR="/data/backup/pgsql"
mkdir -p $BACKUP_BASE_DIR
PSQL_BIN_DIR_SRC=/usr/local/pgsql/bin
if [ ! -d $PSQL_BIN_DIR_SRC ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/bin
elif [ -x /usr/local/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/local/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
PSQL_BIN_DIR_DST=$PSQL_BIN_DIR_SRC
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "`id -u`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
YEAR=`date +"%Y"`
MONTH=`date +"%m"`
DAY=`date +"%d"`
HOUR=`date +"%H"`
MINUTE=`date +"%M"`
DATE=${YEAR}${MONTH}${DAY}-${HOUR}${MINUTE}
## DATE=`date +"%Y%m%d-%H%M"`
# -- erstelle liste der datenbanken
# --
listfile=${BACKUP_BASE_DIR}/dblist-${DATE}.txt
echo -e "Stand: ${DATE}\n" > $listfile
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l" >> $listfile
# - Erstelle Liste der Datenbanken (zur Weiterverarbeitung)
# -
# database_list=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -Alt -F ' '" | awk '{print$1}'`
# - Erstelle Liste der User (Roles) (zur Weiterverarbeitung)
# -
role_list=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -At -F ' ' -c \"\\du\" postgres" | grep -v -e"^Create\ " | awk '{print$1}'`
echo ""
for role in $role_list ; do
echo -e "\tdumping role $role.."
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " | grep ${role} > ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
role=$role
restore_file=\${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.log
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
echo -e "\n\trestoring role \$role..\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
EOF
chmod 755 ${BACKUP_BASE_DIR}/createrole_${role}-${DATE}.sh
done
dbusers_databases_file=${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
# -- Erstelle dump (Teil 1) zum Wiederherstellen der
# -- User und Datenbanken:
# -- Header
# --
cat <<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su - <postgres-user> -c "<postgres-bin-dir>/psql -f $dbusers_databases_file template1"
--
--
-- Drop dumped databases
--
\\connect postgres
EOF
# -- Erstelle dump Dateien sowie Wiederherstellungsscripte
# -- fuer die einzelnen Datenbanken
# --
databases=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l -t" | grep -v -e"^$" | grep -v -e"[[:space:]]:" | awk '{print$1}'`
echo ""
dbs_dumped=""
for db in $databases ; do
BACKUP_DIR=${BACKUP_BASE_DIR}/$db
mkdir -p $BACKUP_DIR
[ "$db" == "template0" ] && continue
# -- Erstelle dump Datei
# --
echo -e "\tdumping database $db.."
su - $PSQL_USER_SRC -c " ${PSQL_BIN_DIR_SRC}/pg_dump -c $db" > ${BACKUP_DIR}/dump_${db}-${DATE}.sql 2> /dev/null
if [ $? -eq 0 ]; then
#echo -e "\n\t$db: successfully dumped\n"
dbs_dumped="$dbs_dumped $db"
# -- Erstelle Wiederherstellungsscript
# --
cat<<EOF > ${BACKUP_DIR}/restore_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
BACKUP_DIR=\${BACKUP_BASE_DIR}/$db
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
## --
## -- restore data for databas $db:
## -- su - \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
## --
echo -e "\n\trestore data for databas $db from backup at ${DAY}.${MONTH}.${YEAR} ${HOUR}:${MINUTE}h\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
EOF
chmod 755 ${BACKUP_DIR}/restore_${db}-${DATE}.sh
# -- Erstelle dump (Teil 2) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP DATABASE statements
# --
echo "DROP DATABASE \"$db\";" >> $dbusers_databases_file
else
echo -e "\n\t$db: [WARNING] cannot dump database $db\n"
rm -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql
fi
done
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP ROLE ..
# -- CREATE ROLE..
# --
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " >> $dbusers_databases_file
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- CREATE DATABASE
# --
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -s" | grep -e "^CREATE DATABASE" >> $dbusers_databases_file
# -- Bemerkung:
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su - postgres -c "psql -f $dbusers_databases_file template1"
# -- Erstelle script zum Wiederherstellen der Geasmaten Datenbank,
# -- User, Datenbanken ( Definitionen und Datensätze
# --
cat<<EOF > ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
logfile=\${BACKUP_BASE_DIR}/restore_dump-${DATE}.log
# -- Wiedrherstellung der Datanbank User und Datenbank Definitionen
# --
## restore_file=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases\`
## _list=\`ls -t \${BACKUP_BASE_DIR}/db_users_databases*\`
## restore_file=\`echo \$_list | awk '{print\$1}'\`
## restore_file=$dbusers_databases_file
restore_file=\${BACKUP_BASE_DIR}/db_users_databases-${DATE}.sql
echo -e "\n\tWiedrherstellung der Datanbank User und Datenbank Definitionen"
echo -e "\t==============================================================\n"
## echo -e "\tsu - \$PSQL_USER -c \"\${PSQL_BIN_DIR}/psql -f \$restore_file template1\"\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
echo
echo -n "Sollen die Datenbanksaetze reorganisiert werden? [ja/nein]: "
read OK
while [ "X\$OK" != "Xyes" -a "X\$OK" != "XYes" -a "X\$OK" != "Xja" -a "X\$OK" != "XJa" \
-a "X\$OK" != "XNo" -a "X\$OK" != "Xno" -a "X\$OK" != "Xn" -a "X\$OK" != "Xnein" -a "X\$OK" != "XNein" ]
do
echo -n "falsche Angabe! [ja/nein]: "
read OK
done
[ \$OK = "Yes" -o \$OK = "yes" -o "\$OK" = "ja" -o "\$OK" = "Ja" ] || exit 0
# -- Wiedrherstellung der Datanbankdaten
# --
## databases=\`find \$BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type d -printf "%f "\`
databases="$dbs_dumped"
echo -e "\n\tWiedrherstellung der Datanbankdaten"
echo -e "\t===================================\n"
for db in \$databases ; do
## _list=\`ls -d -t \${BACKUP_BASE_DIR}/\$db/*${DATE}.sql\`
## file=\`echo \$_list | awk '{print\$1}'\`
file=\${BACKUP_BASE_DIR}/\$db/dump_\${db}-${DATE}.sql
## echo -e "\\t\$file"
if [ -f \$file ]; then
## echo -e "\\t\${db}: su - \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$file \$db\" restoring..\n"
echo -e "\\t\${db}: restoring..\n"
su - \$PSQL_USER -c" \${PSQL_BIN_DIR}/psql -f \$file \$db" >> \$logfile 2>&1
else
echo -e "\\t\${db}: [WARNING] konnte keine Sicherung vom ${DAY}.${MONTH}.${YEAR} (${HOUR}:${MINUTE}h) finden\n"
fi
done
echo
exit 0
EOF
chmod 755 ${BACKUP_BASE_DIR}/restore_dump-${DATE}.sh
for db in $dbs_dumped ; do
cat $dbusers_databases_file | grep "DATABASE $db " > ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sh
## - get user
## -
_owner=`cat ${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.sql | grep OWNER | sed -e "s/.*OWNER[\ ]\{1,\}=[\ ]\{1,\}\([^\ ]*\).*/\1/"`
owner=`echo $_owner | cut -d' ' -f1`
owner=`echo $owner | cut -d';' -f1`
## echo -e "\tOWNER = X${owner}X"
if [ -n "$owner" ]; then
cp ${BACKUP_BASE_DIR}/createrole_${owner}-${DATE}.sql ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
cat <<EOF >${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
BACKUP_BASE_DIR="$BACKUP_BASE_DIR"
if [ ! -d \$BACKUP_BASE_DIR ] ; then
if [ -n "\$1" -a -d "\$1" ];then
BACKUP_BASE_DIR="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sql
logfile=\${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${BACKUP_BASE_DIR}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${BACKUP_BASE_DIR}/${db}/createuser_${owner}-${DATE}.sh
fi
done
echo ""
# -- Create archive from the whole backup
# --
_curdir=`pwd`
cd ${BACKUP_BASE_DIR}
cd .. > /dev/null 2>&1
tar -czf pgsql_dump-${DATE}.tar.gz `find . -name "*${DATE}*"`
cd $_curdir
# delete all older than $days days
#
/usr/bin/find $BACKUP_BASE_DIR/.. -type f -mtime +${days} -exec /bin/rm {} \;
exit 0

77
OLD/dump_all_pg_dbs.sh.BAK Executable file
View File

@ -0,0 +1,77 @@
#!/bin/bash
BACKUP_BASE_DIR="/backup/psql"
mkdir -p $BACKUP_BASE_DIR
PSQL_BIN_DIR=/usr/local/pgsql/bin
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
# -- erstelle liste der datenbanken
# --
listfile=${BACKUP_BASE_DIR}/dblist-`date +"%Y%m%d-%H%M"`.txt
echo -e "Stand: `date +\"%d.%m.%Y %H:%Mh\"`\n" > $listfile
su postgres -c"${PSQL_BIN_DIR}/psql -l" >> $listfile
# -- erstelle dump zum wiederherstellen der
# -- user und datenbanken.
# --
dbusers_databases_file=${BACKUP_BASE_DIR}/db_users_databases-`date +"%Y%m%d-%H%M"`.sql
cat<<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su postgres -c"psql -f $dbusers_databases_file template1"
--
EOF
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -g" >> $dbusers_databases_file
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su postgres -c"${PSQL_BIN_DIR}/pg_dumpall -s" | grep "CREATE DATABASE" >> $dbusers_databases_file
# --
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su postgres -c"psql -f $dbusers_databases_file template1"
databases=`su postgres -c"${PSQL_BIN_DIR}/psql -l -t" | grep -v -e"^$" | awk '{print$1}'`
# -- erstelle dump dateien fer jede einzelne datenbank
# --
for db in $databases ; do
BACKUP_DIR=${BACKUP_BASE_DIR}/$db
mkdir -p $BACKUP_DIR
cat<<EOF > ${BACKUP_DIR}/dump_${db}-${DATE}.sql
--
-- restore data for databas $db:
-- su postgres -c"psql -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
--
EOF
DATE=`date +"%Y%m%d-%H%M"`
su postgres -c"${PSQL_BIN_DIR}/pg_dump -c $db" >> ${BACKUP_DIR}/dump_${db}-${DATE}.sql
done
# delete all older than $days days
#
/usr/bin/find $BACKUP_DIR -type f -mtime +${days} -exec /bin/rm {} \;
exit 0

587
OLD/dump_all_pg_dbs_manual.sh Executable file
View File

@ -0,0 +1,587 @@
#!/usr/bin/env bash
_logging=true
## - postgres user source system
## -
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER_SRC=postgres
else
PSQL_USER_SRC=pgsql
fi
## - postgres user destination system
PSQL_USER_DST=postgres
BACKUP_BASE_DIR=$1
BACKUP_BASE_DIR=${BACKUP_BASE_DIR:="/data/backup"}
backup_dir=$BACKUP_BASE_DIR/pgsql
mkdir -p $backup_dir
_local=$2
_local=${_local:=true}
PSQL_BIN_DIR_SRC=/usr/local/pgsql/bin
if [ ! -d $PSQL_BIN_DIR_SRC ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/bin
elif [ -x /usr/local/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/local/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
PSQL_BIN_DIR_DST=$PSQL_BIN_DIR_SRC
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "`id -u`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
YEAR=`date +"%Y"`
MONTH=`date +"%m"`
DAY=`date +"%d"`
HOUR=`date +"%H"`
MINUTE=`date +"%M"`
DATE=${YEAR}${MONTH}${DAY}-${HOUR}${MINUTE}
## DATE=`date +"%Y%m%d-%H%M"`
# -- Erstelle liste der Datenbanken
# --
listfile=${backup_dir}/dblist-${DATE}.txt
echo -e "Stand: ${DATE}\n" > $listfile
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l" >> $listfile
# - Erstelle Liste der Datenbanken (zur Weiterverarbeitung)
# -
databases=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l -t" | grep -v -e"^$" | grep -v -e"^\s*[:|]" | awk '{print$1}'`
# - Erstelle Liste der User (Roles) (zur Weiterverarbeitung)
# -
role_list=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -t -F ' ' -c \"\\du\" postgres" |grep -v -e"^$" | grep -v -e"^\s*[:|]" | awk '{print$1}'`
## --------------------------
## - Sichern der User (Roles)
## -
if $_logging ; then
echo ""
fi
for role in $role_list ; do
if $_logging ; then
echo -e "\tdumping role $role.."
fi
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " | grep ${role} > ${backup_dir}/createrole_${role}-${DATE}.sql
cat <<EOF >${backup_dir}/createrole_${role}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
role=$role
restore_file=\${backup_dir}/createrole_${role}-${DATE}.sql
logfile=\${backup_dir}/createrole_${role}-${DATE}.log
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
echo -e "\n\trestoring role \$role..\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
EOF
chmod 755 ${backup_dir}/createrole_${role}-${DATE}.sh
done
dbusers_databases_file=${backup_dir}/db_users_databases-${DATE}.sql
# -- Erstelle dump (Teil 1) zum Wiederherstellen der
# -- User und Datenbanken:
# -- Header
# --
cat <<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su - <postgres-user> -c "<postgres-bin-dir>/psql -f $dbusers_databases_file template1"
--
--
-- Drop dumped databases
--
\\connect postgres
EOF
# -- Erstelle dump Dateien sowie Wiederherstellungsscripte
# -- fuer die einzelnen Datenbanken
# --
if $_logging ; then
echo ""
fi
dbs_dumped=""
for db in $databases ; do
BACKUP_DIR=${backup_dir}/$db
mkdir -p $BACKUP_DIR
[ "$db" == "template0" ] && continue
# -- Erstelle dump Datei
# --
if $_logging ; then
echo -e "\tdumping database $db.."
fi
su - $PSQL_USER_SRC -c " ${PSQL_BIN_DIR_SRC}/pg_dump -c $db" > ${BACKUP_DIR}/dump_${db}-${DATE}.sql 2> /dev/null
if [ $? -eq 0 ]; then
#echo -e "\n\t$db: successfully dumped\n"
dbs_dumped="$dbs_dumped $db"
# -- Erstelle Wiederherstellungsscript
# --
cat<<EOF > ${BACKUP_DIR}/restore_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
BACKUP_DIR=\${backup_dir}/$db
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
## --
## -- restore data for databas $db:
## -- su - \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
## --
echo -e "\n\trestore data for databas $db from backup at ${DAY}.${MONTH}.${YEAR} ${HOUR}:${MINUTE}h\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
EOF
chmod 755 ${BACKUP_DIR}/restore_${db}-${DATE}.sh
# -- Erstelle dump (Teil 2) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP DATABASE statements
# --
echo "DROP DATABASE \"$db\";" >> $dbusers_databases_file
else
echo -e "\n\t$db: [WARNING] cannot dump database $db\n"
rm -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql
fi
done
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP ROLE ..
# -- CREATE ROLE..
# --
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " >> $dbusers_databases_file
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- CREATE DATABASE
# --
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -s" | grep -e "^CREATE DATABASE" >> $dbusers_databases_file
# -- Bemerkung:
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su - postgres -c "psql -f $dbusers_databases_file template1"
# -- Erstelle script zum Wiederherstellen der Geasmaten Datenbank,
# -- User, Datenbanken ( Definitionen und Datensätze
# --
cat<<EOF > ${backup_dir}/restore_dump-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
backup_dir="$backup_dir"
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
logfile=\${backup_dir}/restore_dump-${DATE}.log
# -- Wiedrherstellung der Datanbank User und Datenbank Definitionen
# --
## restore_file=\`find \$backup_dir -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases\`
## _list=\`ls -t \${backup_dir}/db_users_databases*\`
## restore_file=\`echo \$_list | awk '{print\$1}'\`
## restore_file=$dbusers_databases_file
restore_file=\${backup_dir}/db_users_databases-${DATE}.sql
echo -e "\n\tWiedrherstellung der Datanbank User und Datenbank Definitionen"
echo -e "\t==============================================================\n"
## echo -e "\tsu - \$PSQL_USER -c \"\${PSQL_BIN_DIR}/psql -f \$restore_file template1\"\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
echo
echo -n "Sollen die Datenbanksaetze reorganisiert werden? [ja/nein]: "
read OK
while [ "X\$OK" != "Xyes" -a "X\$OK" != "XYes" -a "X\$OK" != "Xja" -a "X\$OK" != "XJa" \
-a "X\$OK" != "XNo" -a "X\$OK" != "Xno" -a "X\$OK" != "Xn" -a "X\$OK" != "Xnein" -a "X\$OK" != "XNein" ]
do
echo -n "falsche Angabe! [ja/nein]: "
read OK
done
[ \$OK = "Yes" -o \$OK = "yes" -o "\$OK" = "ja" -o "\$OK" = "Ja" ] || exit 0
# -- Wiedrherstellung der Datanbankdaten
# --
## databases=\`find \$backup_dir -maxdepth 1 -mindepth 1 -type d -printf "%f "\`
databases="$dbs_dumped"
echo -e "\n\tWiedrherstellung der Datanbankdaten"
echo -e "\t===================================\n"
for db in \$databases ; do
## _list=\`ls -d -t \${backup_dir}/\$db/*${DATE}.sql\`
## file=\`echo \$_list | awk '{print\$1}'\`
file=\${backup_dir}/\$db/dump_\${db}-${DATE}.sql
## echo -e "\\t\$file"
if [ -f \$file ]; then
## echo -e "\\t\${db}: su - \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$file \$db\" restoring..\n"
echo -e "\\t\${db}: restoring..\n"
su - \$PSQL_USER -c" \${PSQL_BIN_DIR}/psql -f \$file \$db" >> \$logfile 2>&1
else
echo -e "\\t\${db}: [WARNING] konnte keine Sicherung vom ${DAY}.${MONTH}.${YEAR} (${HOUR}:${MINUTE}h) finden\n"
fi
done
echo
exit 0
EOF
chmod 755 ${backup_dir}/restore_dump-${DATE}.sh
for db in $dbs_dumped ; do
cat $dbusers_databases_file | grep -e "CREATE DATABASE\ *$db" > ${backup_dir}/${db}/createdb_${db}-${DATE}.sql
cat <<EOF >${backup_dir}/${db}/createdb_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${backup_dir}/${db}/createdb_${db}-${DATE}.sql
logfile=\${backup_dir}/${db}/createdb_${db}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${backup_dir}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${backup_dir}/${db}/createdb_${db}-${DATE}.sh
## - get user
## -
_owner=`cat ${backup_dir}/${db}/createdb_${db}-${DATE}.sql | grep OWNER | sed -e "s/.*OWNER[\ ]\{1,\}=[\ ]\{1,\}\([^\ ]*\).*/\1/"`
owner=`echo $_owner | cut -d' ' -f1`
owner=`echo $owner | cut -d';' -f1`
## echo -e "\tOWNER = X${owner}X"
if [ -n "$owner" ]; then
cp ${backup_dir}/createrole_${owner}-${DATE}.sql ${backup_dir}/${db}/createuser_${owner}-${DATE}.sql
cat <<EOF >${backup_dir}/${db}/createuser_${owner}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${backup_dir}/${db}/createuser_${owner}-${DATE}.sql
logfile=\${backup_dir}/${db}/createuser_${owner}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${backup_dir}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${backup_dir}/${db}/createuser_${owner}-${DATE}.sh
fi
done
if $_logging ; then
echo ""
fi
# -- Create archive from the whole backup
# --
if $_local ; then
_curdir=`pwd`
cd ${backup_dir}
cd .. > /dev/null 2>&1
if $_logging ; then
echo -e "\tCreate archiv pgsql_dump-${DATE}.tar.gz.."
fi
tar -czf pgsql_dump-${DATE}.tar.gz `find . -name "*${DATE}*"`
cd $_curdir
fi
if $_logging ; then
echo ""
fi
# delete all older than $days days
#
if $_logging ; then
echo -e "\tDelete all archives in $BACKUP_BASE_DIR older than ${days} days.."
fi
/usr/bin/find $BACKUP_BASE_DIR -type f -name "*.tar.gz" -mtime +${days} -exec /bin/rm {} \;
if $_logging ; then
echo ""
fi
exit 0

25
OLD/init_db.sh Executable file
View File

@ -0,0 +1,25 @@
#!/bin/sh
# postgressql
#
DBDATA_BASE=/data/pgsql
DBDATA=$DBDATA_BASE/data
PSQL_USER=postgres
PSQL_GROUP=postgres
if [ -d $DBDATA ];then
_date=`date +"%Y-%m-%d-%H-%M"`
mv $DBDATA $DBDATA_BASE/data-${_date}.back
fi
mkdir -p $DBDATA
chown ${PSQL_USER}.$PSQL_GROUP $DBDATA
echo "Create a database installation with the.. "
su - $PSQL_USER -c "/usr/local/pgsql/bin/initdb -D $DBDATA" || exit 1
exit
mkdir -p /var/log/pgsql
chown ${PSQL_USER}.$PSQL_GROUP /var/log/pgsql

46
OLD/restore_all_pg_dbs.sh.00 Executable file
View File

@ -0,0 +1,46 @@
#!/bin/bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/usr/bin/X11
BACKUP_BASE_DIR="/backup/psql"
if [ ! -d $BACKUP_BASE_DIR ] ; then
echo
echo " Backup directory not found"
echo
exit 1
fi
PSQL_USER=postgres
PSQL_BIN_DIR=/usr/local/pgsql/bin
logfile=restore_db.log
# -- Wiedrherstellung der datanbakuser und datenbankdefinitionen
# --
## restore_file=`find $BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases`
_list=`ls -t ${BACKUP_BASE_DIR}/db_users_databases*`
restore_file=`echo $_list | awk '{print$1}'`
echo -e "\nWiedrherstellung der datanbakuser und datenbankdefinitionen"
echo -e "\tsu $PSQL_USER -c\"${PSQL_BIN_DIR}/psql -f $restore_file template1\"\n"
su $PSQL_USER -c"${PSQL_BIN_DIR}/psql -f $restore_file template1" > $logfile 2>&1
# -- Wiedrherstellung der datanbakdaten
# --
databases=`find $BACKUP_BASE_DIR -maxdepth 1 -mindepth 1 -type d -printf "%f "`
echo "Wiedrherstellung der datanbakdaten"
for db in $databases ; do
_list=`ls -d -t ${BACKUP_BASE_DIR}/$db/*`
file=`echo $_list | awk '{print$1}'`
echo " ${db}: su $PSQL_USER -c\"${PSQL_BIN_DIR}/psql -f $file $db\""
su $PSQL_USER -c"${PSQL_BIN_DIR}/psql -f $file $db" >> $logfile 2>&1
done
echo
exit 0

69
analyze_reindex_pg-databases.sh Executable file
View File

@ -0,0 +1,69 @@
#!/usr/bin/env bash
# - Is this script running on terminal ?
# -
if [[ -t 1 ]] ; then
terminal=true
LOGGING=true
else
terminal=false
LOGGING=false
fi
curdir=`pwd`
cd /tmp
psql=`which psql`
grep=`which grep`
awk=`which awk`
DATABASES=`/bin/su postgres -c "$psql -lt" | $grep -v -e"^$" | $grep -v -e "^\s*[:|]" | $awk '{print$1}'`
if $terminal ; then
echo ""
echo "PostgeSQL: analyze and reindex databases at host $(hostname -f)."
echo ""
fi
for db in $DATABASES ; do
if [ "$db" == "template0" ]; then
continue
fi
if $LOGGING ;then
echo "Database...: $db"
fi
#TABLES=`/bin/su postgres -c "$psql -lt -q -c \"\dt \" $db" | awk '{print$3}'`
TABLES=`/bin/su postgres -c "$psql -t -q -c \"\dt \" $db" | awk '{print$3}'`
if $LOGGING ;then
echo
fi
for tbl in $TABLES ; do
if $LOGGING ;then
echo -e "\tvacuum analyze table $tbl .."
fi
/bin/su postgres -c "$psql -q -c \"VACUUM ANALYZE $tbl\" $db"
[[ $? -gt 0 ]] && echo "[ERROR]: vacuun/analyzing table \"${tbl}\" of database \"$db\" failed !!"
if $LOGGING ;then
echo -e "\treindex table $tbl ..\n"
fi
/bin/su postgres -c "$psql -q -c \"REINDEX TABLE $tbl\" $db" > /dev/null 2>&1
[[ $? -gt 0 ]] && echo "[ERROR]: reindexing table \"${tbl}\" of database \"$db\" failed !!"
done
if $LOGGING ;then
echo
fi
done
cd $curdir
if $terminal ; then
echo "Finished analyzing and reindexing databases at host $(hostname -f)."
echo ""
fi
exit

587
dump_all_pg_dbs.sh Executable file
View File

@ -0,0 +1,587 @@
#!/usr/bin/env bash
_logging=false
## - postgres user source system
## -
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER_SRC=postgres
else
PSQL_USER_SRC=pgsql
fi
## - postgres user destination system
PSQL_USER_DST=postgres
BACKUP_BASE_DIR=$1
BACKUP_BASE_DIR=${BACKUP_BASE_DIR:="/data/backup"}
backup_dir=$BACKUP_BASE_DIR/pgsql
mkdir -p $backup_dir
_local=$2
_local=${_local:=true}
PSQL_BIN_DIR_SRC=/usr/local/pgsql/bin
if [ ! -d $PSQL_BIN_DIR_SRC ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/bin
elif [ -x /usr/local/bin/psql ]; then
PSQL_BIN_DIR_SRC=/usr/local/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
PSQL_BIN_DIR_DST=$PSQL_BIN_DIR_SRC
days=30
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "`id -u`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
YEAR=`date +"%Y"`
MONTH=`date +"%m"`
DAY=`date +"%d"`
HOUR=`date +"%H"`
MINUTE=`date +"%M"`
DATE=${YEAR}${MONTH}${DAY}-${HOUR}${MINUTE}
## DATE=`date +"%Y%m%d-%H%M"`
# -- Erstelle liste der Datenbanken
# --
listfile=${backup_dir}/dblist-${DATE}.txt
echo -e "Stand: ${DATE}\n" > $listfile
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l" >> $listfile
# - Erstelle Liste der Datenbanken (zur Weiterverarbeitung)
# -
databases=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -l -t" | grep -v -e"^$" | grep -v -e"^\s*[:|]" | awk '{print$1}'`
# - Erstelle Liste der User (Roles) (zur Weiterverarbeitung)
# -
role_list=`su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/psql -t -F ' ' -c \"\\du\" postgres" |grep -v -e"^$" | grep -v -e"^\s*[:|]" | awk '{print$1}'`
## --------------------------
## - Sichern der User (Roles)
## -
if $_logging ; then
echo ""
fi
for role in $role_list ; do
if $_logging ; then
echo -e "\tdumping role $role.."
fi
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " | grep ${role} > ${backup_dir}/createrole_${role}-${DATE}.sql
cat <<EOF >${backup_dir}/createrole_${role}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
role=$role
restore_file=\${backup_dir}/createrole_${role}-${DATE}.sql
logfile=\${backup_dir}/createrole_${role}-${DATE}.log
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
echo -e "\n\trestoring role \$role..\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
EOF
chmod 755 ${backup_dir}/createrole_${role}-${DATE}.sh
done
dbusers_databases_file=${backup_dir}/db_users_databases-${DATE}.sql
# -- Erstelle dump (Teil 1) zum Wiederherstellen der
# -- User und Datenbanken:
# -- Header
# --
cat <<EOF > $dbusers_databases_file
--
-- restore user and databasedefinitions (no data) for db-cluster
-- su - <postgres-user> -c "<postgres-bin-dir>/psql -f $dbusers_databases_file template1"
--
--
-- Drop dumped databases
--
\\connect postgres
EOF
# -- Erstelle dump Dateien sowie Wiederherstellungsscripte
# -- fuer die einzelnen Datenbanken
# --
if $_logging ; then
echo ""
fi
dbs_dumped=""
for db in $databases ; do
BACKUP_DIR=${backup_dir}/$db
mkdir -p $BACKUP_DIR
[ "$db" == "template0" ] && continue
# -- Erstelle dump Datei
# --
if $_logging ; then
echo -e "\tdumping database $db.."
fi
su - $PSQL_USER_SRC -c " ${PSQL_BIN_DIR_SRC}/pg_dump -c $db" > ${BACKUP_DIR}/dump_${db}-${DATE}.sql 2> /dev/null
if [ $? -eq 0 ]; then
#echo -e "\n\t$db: successfully dumped\n"
dbs_dumped="$dbs_dumped $db"
# -- Erstelle Wiederherstellungsscript
# --
cat<<EOF > ${BACKUP_DIR}/restore_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
BACKUP_DIR=\${backup_dir}/$db
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=$PSQL_BIN_DIR_DST
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
## --
## -- restore data for databas $db:
## -- su - \$PSQL_USER -c"\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
## --
echo -e "\n\trestore data for databas $db from backup at ${DAY}.${MONTH}.${YEAR} ${HOUR}:${MINUTE}h\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \${BACKUP_DIR}/dump_${db}-${DATE}.sql ${db}"
EOF
chmod 755 ${BACKUP_DIR}/restore_${db}-${DATE}.sh
# -- Erstelle dump (Teil 2) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP DATABASE statements
# --
echo "DROP DATABASE \"$db\";" >> $dbusers_databases_file
else
echo -e "\n\t$db: [WARNING] cannot dump database $db\n"
rm -f ${BACKUP_DIR}/dump_${db}-${DATE}.sql
fi
done
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- DROP ROLE ..
# -- CREATE ROLE..
# --
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -g -c " >> $dbusers_databases_file
# -- Erstelle dump (Teil 3) zum Wiederherstellen der
# -- User und Datenbanken:
# -- CREATE DATABASE
# --
cat<<EOF >> $dbusers_databases_file
--
-- Database creation
--
EOF
su - $PSQL_USER_SRC -c "${PSQL_BIN_DIR_SRC}/pg_dumpall -s" | grep -e "^CREATE DATABASE" >> $dbusers_databases_file
# -- Bemerkung:
# -- Wiederherstellung der user und datenbanken (nur definitionen - keine daten )
# -- su - postgres -c "psql -f $dbusers_databases_file template1"
# -- Erstelle script zum Wiederherstellen der Geasmaten Datenbank,
# -- User, Datenbanken ( Definitionen und Datensätze
# --
cat<<EOF > ${backup_dir}/restore_dump-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
backup_dir="$backup_dir"
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
logfile=\${backup_dir}/restore_dump-${DATE}.log
# -- Wiedrherstellung der Datanbank User und Datenbank Definitionen
# --
## restore_file=\`find \$backup_dir -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases\`
## _list=\`ls -t \${backup_dir}/db_users_databases*\`
## restore_file=\`echo \$_list | awk '{print\$1}'\`
## restore_file=$dbusers_databases_file
restore_file=\${backup_dir}/db_users_databases-${DATE}.sql
echo -e "\n\tWiedrherstellung der Datanbank User und Datenbank Definitionen"
echo -e "\t==============================================================\n"
## echo -e "\tsu - \$PSQL_USER -c \"\${PSQL_BIN_DIR}/psql -f \$restore_file template1\"\n"
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$restore_file template1" > \$logfile 2>&1
echo
echo -n "Sollen die Datenbanksaetze reorganisiert werden? [ja/nein]: "
read OK
while [ "X\$OK" != "Xyes" -a "X\$OK" != "XYes" -a "X\$OK" != "Xja" -a "X\$OK" != "XJa" \
-a "X\$OK" != "XNo" -a "X\$OK" != "Xno" -a "X\$OK" != "Xn" -a "X\$OK" != "Xnein" -a "X\$OK" != "XNein" ]
do
echo -n "falsche Angabe! [ja/nein]: "
read OK
done
[ \$OK = "Yes" -o \$OK = "yes" -o "\$OK" = "ja" -o "\$OK" = "Ja" ] || exit 0
# -- Wiedrherstellung der Datanbankdaten
# --
## databases=\`find \$backup_dir -maxdepth 1 -mindepth 1 -type d -printf "%f "\`
databases="$dbs_dumped"
echo -e "\n\tWiedrherstellung der Datanbankdaten"
echo -e "\t===================================\n"
for db in \$databases ; do
## _list=\`ls -d -t \${backup_dir}/\$db/*${DATE}.sql\`
## file=\`echo \$_list | awk '{print\$1}'\`
file=\${backup_dir}/\$db/dump_\${db}-${DATE}.sql
## echo -e "\\t\$file"
if [ -f \$file ]; then
## echo -e "\\t\${db}: su - \$PSQL_USER -c\"\${PSQL_BIN_DIR}/psql -f \$file \$db\" restoring..\n"
echo -e "\\t\${db}: restoring..\n"
su - \$PSQL_USER -c" \${PSQL_BIN_DIR}/psql -f \$file \$db" >> \$logfile 2>&1
else
echo -e "\\t\${db}: [WARNING] konnte keine Sicherung vom ${DAY}.${MONTH}.${YEAR} (${HOUR}:${MINUTE}h) finden\n"
fi
done
echo
exit 0
EOF
chmod 755 ${backup_dir}/restore_dump-${DATE}.sh
for db in $dbs_dumped ; do
cat $dbusers_databases_file | grep -e "CREATE DATABASE\ *$db" > ${backup_dir}/${db}/createdb_${db}-${DATE}.sql
cat <<EOF >${backup_dir}/${db}/createdb_${db}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${backup_dir}/${db}/createdb_${db}-${DATE}.sql
logfile=\${backup_dir}/${db}/createdb_${db}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${backup_dir}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${backup_dir}/${db}/createdb_${db}-${DATE}.sh
## - get user
## -
_owner=`cat ${backup_dir}/${db}/createdb_${db}-${DATE}.sql | grep OWNER | sed -e "s/.*OWNER[\ ]\{1,\}=[\ ]\{1,\}\([^\ ]*\).*/\1/"`
owner=`echo $_owner | cut -d' ' -f1`
owner=`echo $owner | cut -d';' -f1`
## echo -e "\tOWNER = X${owner}X"
if [ -n "$owner" ]; then
cp ${backup_dir}/createrole_${owner}-${DATE}.sql ${backup_dir}/${db}/createuser_${owner}-${DATE}.sql
cat <<EOF >${backup_dir}/${db}/createuser_${owner}-${DATE}.sh
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
## - muss als user root ausgefuehrt werden
## -
if [ "\`id -u\`" -ne 0 ]; then
echo -e "\n\tgeht nur als user \"root\"\n"
exit 1
fi
backup_dir="$backup_dir"
if [ ! -d \$backup_dir ] ; then
if [ -n "\$1" -a -d "\$1" ];then
backup_dir="\$1"
else
echo
echo " Backup directory not found"
echo " try: \`basename \$0\` <path-to-backup-basedir>"
echo
exit 1
fi
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR="$PSQL_BIN_DIR"
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
file=\${backup_dir}/${db}/createuser_${owner}-${DATE}.sql
logfile=\${backup_dir}/${db}/createuser_${owner}-${DATE}.log
su - \$PSQL_USER -c "\${PSQL_BIN_DIR}/psql -f \$file" | tee \${backup_dir}/${db}/createdb_${db}-${DATE}.log
EOF
chmod 755 ${backup_dir}/${db}/createuser_${owner}-${DATE}.sh
fi
done
if $_logging ; then
echo ""
fi
# -- Create archive from the whole backup
# --
if $_local ; then
_curdir=`pwd`
cd ${backup_dir}
cd .. > /dev/null 2>&1
if $_logging ; then
echo -e "\tCreate archiv pgsql_dump-${DATE}.tar.gz.."
fi
tar -czf pgsql_dump-${DATE}.tar.gz `find . -name "*${DATE}*"`
cd $_curdir
fi
if $_logging ; then
echo ""
fi
# delete all older than $days days
#
if $_logging ; then
echo -e "\tDelete all archives in $BACKUP_BASE_DIR older than ${days} days.."
fi
/usr/bin/find $BACKUP_BASE_DIR -type f -name "*.tar.gz" -mtime +${days} -exec /bin/rm {} \;
if $_logging ; then
echo ""
fi
exit 0

36
postgres.forwarders_in.sql Normal file
View File

@ -0,0 +1,36 @@
CREATE LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS udf_forwarders_in();
DROP FUNCTION IF EXISTS udf_forwarders_in(TEXT,TEXT,TEXT,CHAR,BOOLEAN);
CREATE FUNCTION udf_forwarders_in(forewarders_str TEXT,
email_str TEXT,
vacation_domain TEXT ,
list_seperator CHAR ,
vacation_enable BOOLEAN)
RETURNS TEXT AS $$
DECLARE
return_str text;
local_email_part TEXT;
domain_email_part TEXT;
BEGIN
return_str = email_str;
IF vacation_enable THEN
local_email_part = substring(email_str, 1, position('@' in email_str) - 1);
domain_email_part = substring(email_str, position('@' in email_str) + 1 );
return_str = return_str || list_seperator || local_email_part || '#' || domain_email_part || '@' || vacation_domain;
END IF;
IF char_length(forewarders_str) > 7 THEN
return_str = return_str || list_seperator || forewarders_str;
END IF;
RETURN return_str;
END;
$$ LANGUAGE plpgsql;
SELECT udf_forwarders_in('ckubu@oopen.de', 'admin@initiativenserver.de','autoreply.initiativenserver.de',',',TRUE);

59
postgres.forwarders_out.sql Normal file
View File

@ -0,0 +1,59 @@
CREATE LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS udf_forwarders_out(TEXT,TEXT,CHAR);
CREATE FUNCTION udf_forwarders_out( email_str TEXT,
vacation_domain TEXT ,
list_seperator CHAR
)
RETURNS TEXT AS $$
DECLARE
forward_str text;
local_email_part TEXT;
domain_email_part TEXT;
BEGIN
-- get list of forwarders
--
SELECT goto INTO forward_str FROM alias WHERE address=email_str;
-- entferne mailbox emailadresse
--
forward_str = replace(forward_str, email_str, '' );
-- entferne vacation adresse
--
local_email_part = substring(email_str, 1, position('@' in email_str) - 1);
domain_email_part = substring(email_str, position('@' in email_str) + 1 );
forward_str = replace(forward_str, local_email_part || '#' || domain_email_part || '@' || vacation_domain, '');
-- enferne doppelte seperatorzeichen
--
WHILE position( list_seperator || list_seperator in forward_str ) > 0 LOOP
forward_str = replace(forward_str, list_seperator || list_seperator , '');
END LOOP;
-- entferne erstes zeichen wenn es das seperatorzeichen ist
--
IF substring(forward_str,1,1) = list_seperator THEN
forward_str = substring(forward_str from 2);
END IF;
-- entferne letztes zeichen wenn es das seperatorzeichen ist
--
IF substring(forward_str from char_length(forward_str)) = list_seperator THEN
forward_str = substring(forward_str, 1, char_length(forward_str) - 1);
END IF;
-- forward_str = substring(forward_str from char_length(forward_str));
RETURN forward_str;
END;
$$ LANGUAGE plpgsql;
SELECT udf_forwarders_out('ckubu@oopen.de','autoreply.oopen.de',',');

75
restore_all_pg_dbs.sh Executable file
View File

@ -0,0 +1,75 @@
#!/usr/bin/env bash
PATH=/usr/local/sbin:/usr/sbin:/sbin:/usr/local/bin:/usr/bin:/bin:/root/bin
BACKUP_BASE_DIR=$1
BACKUP_BASE_DIR=${BACKUP_BASE_DIR:="/data/backup"}
backup_dir=$BACKUP_BASE_DIR/pgsql
if [ ! -d $backup_dir ] ; then
echo
echo " Backup directory not found"
echo
exit 1
fi
if cat /etc/passwd 2> /dev/null | grep postgres > /dev/null ; then
PSQL_USER=postgres
else
PSQL_USER=pgsql
fi
PSQL_BIN_DIR=/usr/local/pgsql/bin
if [ ! -x \$PSQL_BIN_DIR/psql ]; then
if [ -x /usr/bin/psql ]; then
PSQL_BIN_DIR=/usr/bin
elif [ -x /usr/local/bin/psql ];then
PSQL_BIN_DIR=/usr/local/bin
elif [ -x /usr/local/pgsql/bin/psql ];then
PSQL_BIN_DIR=/usr/local/pgsql/bin
else
echo
echo " pgsql bindir not found"
echo
exit 1
fi
fi
logfile=restore_db.log
# -- Wiedrherstellung der datanbakuser und datenbankdefinitionen
# --
## restore_file=`find $backup_dir -maxdepth 1 -mindepth 1 -type f -printf "%f\n" | grep db_users_databases`
_list=`ls -t ${backup_dir}/db_users_databases*`
restore_file=`echo $_list | awk '{print$1}'`
echo -e "\n\tWiedrherstellung der Datanbakuser und Datenbankdefinitionen"
#echo -e "\tsu $PSQL_USER -c\"${PSQL_BIN_DIR}/psql -f $restore_file template1\"\n"
echo ""
su $PSQL_USER -c "${PSQL_BIN_DIR}/psql -f $restore_file template1" > $logfile 2>&1
# -- Wiedrherstellung der datanbakdaten
# --
#databases=`find $backup_dir -maxdepth 1 -mindepth 1 -type d -printf "%f "`
databases=`find $backup_dir -maxdepth 1 -mindepth 1 -type d -exec basename {} \;`
echo -e "\n\tWiedrherstellung der Datanbakdaten"
for db in $databases ; do
[ "$db" = "template0" ] && continue
_list=`ls -d -t ${backup_dir}/$db/dump*`
file=`echo $_list | awk '{print$1}'`
#echo " ${db}: su $PSQL_USER -c\"${PSQL_BIN_DIR}/psql -f $file $db\""
echo ""
echo -e "\t\t${db}.."
su $PSQL_USER -c "${PSQL_BIN_DIR}/psql -f $file $db" >> $logfile 2>&1
done
echo
exit 0