mirror of
https://github.com/myvesta/vesta.git
synced 2024-11-20 20:40:08 -08:00
813 lines
26 KiB
Bash
Executable File
813 lines
26 KiB
Bash
Executable File
#!/bin/bash
|
|
# info: restore user
|
|
# options: USER BACKUP [WEB] [DNS] [MAIL] [DB] [CRON] [UDIR] [NOTIFY]
|
|
#
|
|
# The function for resotring user from backup.
|
|
|
|
|
|
#----------------------------------------------------------#
|
|
# Variable&Function #
|
|
#----------------------------------------------------------#
|
|
|
|
# Import VESTA variable for cron launch
|
|
source /etc/profile
|
|
|
|
# Argument definition
|
|
user=$1
|
|
backup=$2
|
|
web=$3
|
|
dns=$4
|
|
mail=$5
|
|
db=$6
|
|
cron=$7
|
|
udir=$8
|
|
notify=${9-no}
|
|
|
|
# Define backup dir
|
|
if [ -z "$BACKUP" ]; then
|
|
BACKUP=/backup
|
|
fi
|
|
|
|
# Allow to specify full path to backup file
|
|
if [[ $backup == "/backup/"* ]]; then
|
|
backup="${backup:8}"
|
|
fi
|
|
|
|
# Includes
|
|
source $VESTA/func/main.sh
|
|
source $VESTA/func/domain.sh
|
|
source $VESTA/func/ip.sh
|
|
source $VESTA/func/db.sh
|
|
source $VESTA/func/rebuild.sh
|
|
source $VESTA/conf/vesta.conf
|
|
|
|
if [ ! -z "$OVERRIDE_BACKUP_PATH" ]; then
|
|
BACKUP=$OVERRIDE_BACKUP_PATH
|
|
fi
|
|
|
|
# Check backup ownership function
|
|
is_backup_available() {
|
|
passed=false
|
|
if [[ $2 =~ ^$1.[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]_[0-9][0-9]-[0-9][0-9]-[0-9][0-9].tar$ ]]; then
|
|
passed=true
|
|
elif [[ $2 =~ ^$1.[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9].tar$ ]]; then
|
|
passed=true
|
|
fi
|
|
|
|
if [ $passed = false ]; then
|
|
check_result $E_FORBIDEN "permission denied"
|
|
fi
|
|
}
|
|
|
|
# Defining ftp command function
|
|
ftpc() {
|
|
/usr/bin/ftp -n $HOST $PORT <<EOF
|
|
quote USER $USERNAME
|
|
quote PASS $PASSWORD
|
|
binary
|
|
$1
|
|
$2
|
|
$3
|
|
quit
|
|
EOF
|
|
}
|
|
|
|
# FTP backup download function
|
|
ftp_download() {
|
|
source $VESTA/conf/ftp.backup.conf
|
|
if [ -z "$PORT" ]; then
|
|
PORT='21'
|
|
fi
|
|
if [ -z $BPATH ]; then
|
|
ftpc "get $1"
|
|
else
|
|
ftpc "cd $BPATH" "get $1"
|
|
fi
|
|
}
|
|
|
|
# sftp command function
|
|
sftpc() {
|
|
expect -f "-" <<EOF "$@"
|
|
set timeout 60
|
|
set count 0
|
|
spawn /usr/bin/sftp -o StrictHostKeyChecking=no \
|
|
-o Port=$PORT $USERNAME@$HOST
|
|
expect {
|
|
"password:" {
|
|
send "$PASSWORD\r"
|
|
exp_continue
|
|
}
|
|
|
|
-re "Couldn't|(.*)disconnect|(.*)stalled|(.*)not found" {
|
|
set count \$argc
|
|
set output "Disconnected."
|
|
set rc $E_FTP
|
|
exp_continue
|
|
}
|
|
|
|
-re ".*denied.*(publickey|password)." {
|
|
set output "Permission denied, wrong publickey or password."
|
|
set rc $E_CONNECT
|
|
}
|
|
|
|
-re "\[0-9]*%" {
|
|
exp_continue
|
|
}
|
|
|
|
"sftp>" {
|
|
if {\$count < \$argc} {
|
|
set arg [lindex \$argv \$count]
|
|
send "\$arg\r"
|
|
incr count
|
|
} else {
|
|
send "exit\r"
|
|
set output "Disconnected."
|
|
if {[info exists rc] != 1} {
|
|
set rc $OK
|
|
}
|
|
}
|
|
exp_continue
|
|
}
|
|
timeout {
|
|
set output "Connection timeout."
|
|
set rc $E_CONNECT
|
|
}
|
|
}
|
|
|
|
if {[info exists output] == 1} {
|
|
puts "\$output"
|
|
}
|
|
|
|
exit \$rc
|
|
EOF
|
|
}
|
|
|
|
# SFTP backup download function
|
|
sftp_download() {
|
|
source $VESTA/conf/sftp.backup.conf
|
|
if [ -z "$PORT" ]; then
|
|
PORT='22'
|
|
fi
|
|
cd $BACKUP
|
|
if [ -z $BPATH ]; then
|
|
sftpc "get $1" > /dev/null 2>&1
|
|
else
|
|
sftpc "cd $BPATH" "get $1" > /dev/null 2>&1
|
|
fi
|
|
|
|
}
|
|
|
|
# Google backup download function
|
|
google_download() {
|
|
source $VESTA/conf/google.backup.conf
|
|
gsutil="$VESTA/3rdparty/gsutil/gsutil"
|
|
export BOTO_CONFIG="$VESTA/conf/.google.backup.boto"
|
|
${gsutil} cp gs://$BUCKET/$BPATH/$1 $BACKUP/ > /dev/null 2>&1
|
|
if [ "$?" -ne 0 ]; then
|
|
check_result "$E_CONNECT" "gsutil failed to download $1"
|
|
fi
|
|
}
|
|
|
|
|
|
#----------------------------------------------------------#
|
|
# Verifications #
|
|
#----------------------------------------------------------#
|
|
|
|
args_usage='USER BACKUP [WEB] [DNS] [MAIL] [DB] [CRON] [UDIR] [NOTIFY]'
|
|
check_args '2' "$#" "$args_usage"
|
|
is_format_valid 'user' 'backup'
|
|
is_backup_available "$user" "$backup"
|
|
|
|
|
|
#----------------------------------------------------------#
|
|
# Action #
|
|
#----------------------------------------------------------#
|
|
|
|
# Checking local backup
|
|
if [ ! -e "$BACKUP/$backup" ]; then
|
|
if [[ "$BACKUP_SYSTEM" =~ "google" ]]; then
|
|
google_download $backup
|
|
downloaded='yes'
|
|
fi
|
|
if [[ "$BACKUP_SYSTEM" =~ "sftp" ]] && [ -z "$downloaded" ]; then
|
|
sftp_download $backup
|
|
downloaded='yes'
|
|
fi
|
|
if [[ "$BACKUP_SYSTEM" =~ "ftp" ]] && [ -z "$downloaded" ]; then
|
|
ftp_download $backup
|
|
downloaded='yes'
|
|
fi
|
|
if [ -z "$downloaded" ]; then
|
|
check_result $E_NOTEXIST "backup $backup doesn't exist"
|
|
fi
|
|
fi
|
|
|
|
# Checking user existance on the server
|
|
check_user=$(is_object_valid 'user' 'USER' "$user")
|
|
if [ -z "$check_user" ]; then
|
|
is_object_unsuspended 'user' 'USER' "$user"
|
|
subj="$user → restore failed"
|
|
email=$(get_user_value '$CONTACT')
|
|
else
|
|
create_user="yes"
|
|
email=$(grep CONTACT $VESTA/data/users/admin/user.conf | cut -f2 -d \')
|
|
fi
|
|
|
|
|
|
# Checking avaiable disk space
|
|
disk_usage=$(df $BACKUP |tail -n1 |tr ' ' '\n' |grep % |cut -f 1 -d %)
|
|
if [ "$disk_usage" -ge "$BACKUP_DISK_LIMIT" ]; then
|
|
echo "Error: Not enough disk space" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result $E_DISK "Not enough disk space"
|
|
fi
|
|
|
|
# Checking load average
|
|
la=$(cat /proc/loadavg |cut -f 1 -d ' ' |cut -f 1 -d '.')
|
|
i=0
|
|
while [ "$la" -ge "$BACKUP_LA_LIMIT" ]; do
|
|
echo -e "$(date "+%F %T") Load Average $la"
|
|
sleep 60
|
|
if [ "$i" -ge "15" ]; then
|
|
la_error="LoadAverage $la is above threshold"
|
|
echo "Error: $la_error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result $E_LA "$la_error"
|
|
fi
|
|
la=$(cat /proc/loadavg |cut -f 1 -d ' ' |cut -f 1 -d '.')
|
|
(( ++i))
|
|
done
|
|
|
|
if [ -z "$BACKUP_TEMP" ]; then
|
|
BACKUP_TEMP=$BACKUP
|
|
fi
|
|
|
|
# Creating temporary directory
|
|
tmpdir=$(mktemp -p $BACKUP_TEMP -d)
|
|
if [ "$?" -ne 0 ]; then
|
|
echo "Can't create tmp dir $tmpdir" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_NOTEXIST" "can't create tmp dir"
|
|
fi
|
|
|
|
# Restoring user account
|
|
if [ "$create_user" = 'yes' ]; then
|
|
echo "-- USER --" |tee $tmpdir/restore.log
|
|
echo -e "$(date "+%F %T") $user" |tee -a $tmpdir/restore.log
|
|
|
|
# Unpacking user container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./vesta
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
echo "Can't unpack user contaner" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "can't unpack user contaner"
|
|
fi
|
|
|
|
# Restoring user.conf
|
|
mkdir $USER_DATA
|
|
cp $tmpdir/vesta/user.conf $USER_DATA/
|
|
cp -r $tmpdir/vesta/ssl $USER_DATA/ >/dev/null 2>&1
|
|
cp $tmpdir/vesta/backup-excludes.conf $USER_DATA/ >/dev/null 2>&1
|
|
|
|
# Rebuilding user
|
|
rebuild_user_conf
|
|
fi
|
|
|
|
# Unpacking pam container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./pam
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
echo "Can't unpack PAM contaner" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "can't unpack PAM contaner"
|
|
fi
|
|
old_user=$(cut -f 1 -d : $tmpdir/pam/passwd)
|
|
old_uid=$(cut -f 3 -d : $tmpdir/pam/passwd)
|
|
new_uid=$(grep "^$user:" /etc/passwd |cut -f 3 -d :)
|
|
|
|
|
|
# Restoring web domains
|
|
if [ "$web" != 'no' ] && [ ! -z "$WEB_SYSTEM" ]; then
|
|
echo -e "\n-- WEB --" |tee -a $tmpdir/restore.log
|
|
|
|
# Creating web domain restore list
|
|
backup_domains=$(tar -tf $BACKUP/$backup |grep "^./web")
|
|
backup_domains=$(echo "$backup_domains" |grep domain_data.tar.gz)
|
|
backup_domains=$(echo "$backup_domains" |cut -f 3 -d /)
|
|
if [ -z "$web" ] || [ "$web" = '*' ]; then
|
|
domains="$backup_domains"
|
|
else
|
|
echo "$web" | tr ',' '\n' | sed -e "s/^/^/" > $tmpdir/selected.txt
|
|
domains=$(echo "$backup_domains" |egrep -f $tmpdir/selected.txt)
|
|
fi
|
|
|
|
# Restoring web domain
|
|
for domain in $domains; do
|
|
echo -e "$(date "+%F %T") $domain" |tee -a $tmpdir/restore.log
|
|
|
|
# Checking domain existance
|
|
check_config=$(grep "DOMAIN='$domain'" $USER_DATA/web.conf)
|
|
if [ -z "$check_config" ]; then
|
|
check_new=$(is_domain_new 'web' $domain)
|
|
if [ ! -z "$check_new" ]; then
|
|
rm -rf $tmpdir
|
|
error="$domain belongs to another user"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
fi
|
|
|
|
# Unpacking domain container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./web/$domain
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
error="Can't unpack $domain web container"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
# Restoring web.conf
|
|
if [ -z "$check_config" ]; then
|
|
eval $(cat $tmpdir/web/$domain/vesta/web.conf)
|
|
|
|
# Deleting conflicting aliases
|
|
for dom_alias in ${ALIAS//,/ }; do
|
|
check_new=$(is_domain_new 'web' $dom_alias)
|
|
if [ ! -z "$check_new" ]; then
|
|
ALIAS=$(echo "$ALIAS" |\
|
|
sed "s/,/\n/g"|\
|
|
sed "s/^$dom_alias$//g"|\
|
|
sed "/^$/d"|\
|
|
sed ':a;N;$!ba;s/\n/,/g')
|
|
fi
|
|
done
|
|
|
|
# Checking ip address
|
|
check_ip=$(is_ip_valid $IP $user)
|
|
if [ ! -z "$check_ip" ]; then
|
|
local_ip=''
|
|
get_user_ip $user
|
|
old_ip=$IP
|
|
IP=$ip
|
|
fi
|
|
|
|
# Checking web template
|
|
check_tpl=$(is_web_template_valid $TPL)
|
|
if [ ! -z "$check_tpl" ]; then
|
|
TPL='default'
|
|
fi
|
|
|
|
# Checking proxy template
|
|
check_proxy_tpl=$(is_proxy_template_valid $PROXY)
|
|
if [ ! -z "$check_proxy_tpl" ]; then
|
|
PROXY='default'
|
|
fi
|
|
|
|
# Checking backend template
|
|
check_backend_tpl=$(is_backend_template_valid $BACKEND)
|
|
if [ ! -z "$check_proxy_tpl" ]; then
|
|
BACKEND='default'
|
|
fi
|
|
|
|
# Converting ftp users
|
|
if [ ! -z "$FTP_USER" ]; then
|
|
FTP_USER=$(echo "$FTP_USER" |sed -e "s/${old_user}_//")
|
|
FTP_USER="${user}_${FTP_USER}"
|
|
fi
|
|
|
|
# Converting stats users
|
|
if [ ! -z "$STATS_USER" ]; then
|
|
STATS_USER=$(echo "$STATS_USER" |sed -e "s/${old_user}_//")
|
|
STATS_USER="${user}_${STATS_USER}"
|
|
fi
|
|
|
|
# Copying ssl certificates
|
|
if [ "$SSL" = 'yes' ]; then
|
|
certificates=$(ls $tmpdir/web/$domain/conf| grep ssl)
|
|
certificates=$(echo "$certificates" |grep $domain)
|
|
for crt in $certificates; do
|
|
crt=$(echo $crt|sed -e "s/ssl.//")
|
|
cp -f $tmpdir/web/$domain/conf/ssl.$crt $USER_DATA/ssl/$crt
|
|
done
|
|
fi
|
|
|
|
# Concatenating web.conf keys
|
|
str="DOMAIN='$domain' IP='$IP' IP6='$IP6' ALIAS='$ALIAS'"
|
|
str="$str TPL='$TPL' SSL='$SSL' SSL_HOME='$SSL_HOME'"
|
|
str="$str LETSENCRYPT='$LETSENCRYPT' FTP_USER='$FTP_USER'"
|
|
str="$str FTP_MD5='$FTP_MD5' BACKEND='$BACKEND' PROXY='$PROXY'"
|
|
str="$str PROXY_EXT='$PROXY_EXT' STATS='$STATS'"
|
|
str="$str STATS_USER='$STATS_USER' STATS_CRYPT='$STATS_CRYPT'"
|
|
str="$str U_DISK='$U_DISK' U_BANDWIDTH='0' SUSPENDED='no'"
|
|
str="$str TIME='$(date +%T)' DATE='$(date +%F)'"
|
|
echo $str >> $USER_DATA/web.conf
|
|
|
|
# Rebuilding backend
|
|
if [ ! -z "$WEB_BACKEND" ]; then
|
|
$BIN/v-add-web-domain-backend $user $domain $BACKEND
|
|
fi
|
|
|
|
# Rebuilding vhost
|
|
rebuild_web_domain_conf
|
|
fi
|
|
|
|
# Restoring web domain data
|
|
chown $user $tmpdir
|
|
chmod u+w $HOMEDIR/$user/web/$domain
|
|
sudo -u $user tar -xzpf $tmpdir/web/$domain/domain_data.tar.gz \
|
|
-C $HOMEDIR/$user/web/$domain/ --exclude=./logs/* \
|
|
2> $HOMEDIR/$user/web/$domain/restore_errors.log
|
|
if [ -e "$HOMEDIR/$user/web/$domain/restore_errors.log" ]; then
|
|
chown $user:$user $HOMEDIR/$user/web/$domain/restore_errors.log
|
|
fi
|
|
#if [ "$?" -ne 0 ]; then
|
|
# rm -rf $tmpdir
|
|
# error="can't unpack $domain data tarball"
|
|
# echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
# sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
# check_result "$E_PARSING" "$error"
|
|
#fi
|
|
|
|
# Applying Fix for tar < 1.24
|
|
find $HOMEDIR/$user/web/$domain -type d \
|
|
-exec chown -h $user:$user {} \;
|
|
|
|
# Re-chowning files if uid differs
|
|
if [ "$old_uid" -ne "$new_uid" ]; then
|
|
find $HOMEDIR/$user/web/$domain/ -user $old_uid \
|
|
-exec chown -h $user:$user {} \;
|
|
fi
|
|
|
|
# Restoring php-fpm pool.d conf files
|
|
if [ -d "$tmpdir/web/$domain/php" ]; then
|
|
fpmver=$(ls $tmpdir/web/$domain/php/)
|
|
cp -r $tmpdir/web/$domain/php/$fpmver/ /etc/php/
|
|
systemctl reset-failed php$fpmver-fpm
|
|
systemctl restart php$fpmver-fpm
|
|
fi
|
|
|
|
done
|
|
|
|
# Adding user to traff queue
|
|
sed -i "/ $user /d" $VESTA/data/queue/traffic.pipe
|
|
echo "$BIN/v-update-web-domains-traff $user" >>\
|
|
$VESTA/data/queue/traffic.pipe
|
|
|
|
# Restarting web server
|
|
$BIN/v-restart-web
|
|
check_result $? "Web restart failed"
|
|
if [ ! -z "$PROXY_SYSTEM" ]; then
|
|
$BIN/v-restart-proxy
|
|
check_result $? "Proxy restart failed"
|
|
fi
|
|
fi
|
|
|
|
# Restoring dns domains
|
|
if [ "$dns" != 'no' ] && [ ! -z "$DNS_SYSTEM" ]; then
|
|
echo -e "\n-- DNS --" |tee -a $tmpdir/restore.log
|
|
|
|
# Creating dns domain restore list
|
|
backup_domains=$(tar -tf $BACKUP/$backup |grep "^./dns")
|
|
backup_domains=$(echo "$backup_domains" |grep "dns.conf$")
|
|
backup_domains=$(echo "$backup_domains" |cut -f 3 -d /)
|
|
if [ -z "$dns" ] || [ "$dns" = '*' ]; then
|
|
domains="$backup_domains"
|
|
else
|
|
echo "$dns" | tr ',' '\n' | sed -e "s/^/^/" > $tmpdir/selected.txt
|
|
domains=$(echo "$backup_domains" |egrep -f $tmpdir/selected.txt)
|
|
fi
|
|
|
|
# Restoring dns domain
|
|
for domain in $domains; do
|
|
echo -e "$(date "+%F %T") $domain" |tee -a $tmpdir/restore.log
|
|
|
|
# Checking domain existance
|
|
check_config=$(grep "DOMAIN='$domain'" $USER_DATA/dns.conf)
|
|
if [ -z "$check_config" ]; then
|
|
check_new=$(is_domain_new 'dns' $domain)
|
|
if [ ! -z "$check_new" ]; then
|
|
rm -rf $tmpdir
|
|
error="$domain belongs to another user"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
fi
|
|
|
|
# Unpacking domain container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./dns/$domain
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
error="Can't unpack $domain dns container"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
# Restoring dns.conf
|
|
if [ -z "$check_config" ]; then
|
|
eval $(cat $tmpdir/dns/$domain/vesta/dns.conf)
|
|
|
|
# Checking ip address
|
|
check_ip=$(is_ip_valid $IP $user)
|
|
if [ ! -z "$check_ip" ]; then
|
|
local_ip=''
|
|
get_user_ip $user
|
|
old_ip=$IP
|
|
IP=$ip
|
|
fi
|
|
|
|
# Checking dns template
|
|
check_tpl=$(is_dns_template_valid $TPL)
|
|
if [ ! -z "$check_tpl" ]; then
|
|
TPL='default'
|
|
fi
|
|
|
|
# Concatenating dns.conf keys
|
|
str="DOMAIN='$domain' IP='$IP' TPL='$TPL' TTL='$TTL' EXP='$EXP'"
|
|
str="$str SOA='$SOA' RECORDS='$RECORDS' SUSPENDED='no'"
|
|
str="$str TIME='$(date +%T)' DATE='$(date +%F)'"
|
|
echo $str >> $USER_DATA/dns.conf
|
|
fi
|
|
|
|
# Restoring dns records
|
|
cp -f $tmpdir/dns/$domain/vesta/$domain.conf $USER_DATA/dns/
|
|
|
|
# Rebuilding dns domain
|
|
rebuild_dns_domain_conf
|
|
done
|
|
|
|
# Restarting DNS
|
|
$BIN/v-restart-dns
|
|
check_result $? "DNS restart failed"
|
|
fi
|
|
|
|
# Restoring mail domains
|
|
if [ "$mail" != 'no' ] && [ ! -z "$MAIL_SYSTEM" ]; then
|
|
echo -e "\n-- MAIL --" |tee -a $tmpdir/restore.log
|
|
|
|
# Creating mail domain restore list
|
|
backup_domains=$(tar -tf $BACKUP/$backup |grep "^./mail")
|
|
backup_domains=$(echo "$backup_domains" |grep "mail.conf$")
|
|
backup_domains=$(echo "$backup_domains" |cut -f 3 -d /)
|
|
if [ -z "$mail" ] || [ "$mail" = '*' ]; then
|
|
domains="$backup_domains"
|
|
else
|
|
echo "$mail" | tr ',' '\n' | sed -e "s/^/^/" > $tmpdir/selected.txt
|
|
domains=$(echo "$backup_domains" |egrep -f $tmpdir/selected.txt)
|
|
fi
|
|
|
|
# Checking exim username for later chowning
|
|
exim_user="exim";
|
|
check_exim_username=$(grep -c '^Debian-exim:' /etc/passwd)
|
|
if [ "$check_exim_username" -eq 1 ]; then
|
|
exim_user="Debian-exim"
|
|
fi
|
|
|
|
# Restoring dns domain
|
|
for domain in $domains; do
|
|
echo -e "$(date "+%F %T") $domain" |tee -a $tmpdir/restore.log
|
|
|
|
# Checking domain existance
|
|
check_config=$(grep "DOMAIN='$domain'" $USER_DATA/mail.conf)
|
|
if [ -z "$check_config" ]; then
|
|
check_new=$(is_domain_new 'mail' $domain)
|
|
if [ ! -z "$check_new" ]; then
|
|
rm -rf $tmpdir
|
|
error="$domain belongs to another user"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
fi
|
|
|
|
# Unpacking domain container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./mail/$domain
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
error="Can't unpack $domain mail container"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
# Restoring mail.conf
|
|
if [ -z "$check_config" ]; then
|
|
cat $tmpdir/mail/$domain/vesta/mail.conf >> $USER_DATA/mail.conf
|
|
fi
|
|
|
|
# Restoring DKIM
|
|
if [ -e "$tmpdir/mail/$domain/vesta/$domain.pem" ]; then
|
|
cp -f $tmpdir/mail/$domain/vesta/$domain.pem $USER_DATA/mail/
|
|
cp -f $tmpdir/mail/$domain/vesta/$domain.pub $USER_DATA/mail/
|
|
fi
|
|
|
|
# Restoring email accounts
|
|
cp -f $tmpdir/mail/$domain/vesta/$domain.conf $USER_DATA/mail/
|
|
|
|
# Rebuilding mail config
|
|
rebuild_mail_domain_conf
|
|
|
|
domain_idn=$domain
|
|
format_domain_idn
|
|
|
|
# Restoring emails
|
|
if [ -e "$tmpdir/mail/$domain/accounts.tar.gz" ]; then
|
|
chown $user $tmpdir
|
|
chmod u+w $HOMEDIR/$user/mail/$domain_idn
|
|
sudo -u $user tar -xzpf $tmpdir/mail/$domain/accounts.tar.gz \
|
|
-C $HOMEDIR/$user/mail/$domain_idn/
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
error="Can't unpack $domain mail account container"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
# Re-chowning files if uid differs
|
|
if [ "$old_uid" -ne "$new_uid" ]; then
|
|
find $HOMEDIR/$user/mail/$domain_idn -user $old_uid \
|
|
-exec chown -h $user:mail {} \;
|
|
fi
|
|
fi
|
|
|
|
# Chowning mail conf files to exim user
|
|
find $HOMEDIR/$user/conf/mail/$domain_idn -user root \
|
|
-exec chown $exim_user {} \;
|
|
|
|
done
|
|
fi
|
|
|
|
# Restoring databases
|
|
if [ "$db" != 'no' ] && [ ! -z "$DB_SYSTEM" ]; then
|
|
echo -e "\n-- DB --" |tee -a $tmpdir/restore.log
|
|
|
|
# Creating database restore list
|
|
backup_databases=$(tar -tf $BACKUP/$backup |grep "^./db")
|
|
backup_databases=$(echo "$backup_databases" |grep db.conf)
|
|
backup_databases=$(echo "$backup_databases" |cut -f 3 -d / |sort -u)
|
|
if [ -z "$db" ] || [ "$db" = '*' ]; then
|
|
databases="$backup_databases"
|
|
else
|
|
echo "$db" |tr ',' '\n' | sed -e "s/$/$/" > $tmpdir/selected.txt
|
|
databases=$(echo "$backup_databases" |egrep -f $tmpdir/selected.txt)
|
|
fi
|
|
|
|
# Restoring database
|
|
for database in $databases; do
|
|
echo -e "$(date "+%F %T") $database" |tee -a $tmpdir/restore.log
|
|
|
|
# Checking database existance
|
|
check_config=$(grep "DB='$database'" $USER_DATA/db.conf)
|
|
|
|
# Unpacking database container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./db/$database
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
error="Can't unpack $database database container"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
# Restore database config
|
|
if [ -z "$check_config" ]; then
|
|
eval $(cat $tmpdir/db/$database/vesta/db.conf)
|
|
DB=$(echo "$DB" |sed -e "s/${old_user}_//")
|
|
DB="${user}_${DB}"
|
|
DBUSER=$(echo "$DBUSER" |sed -e "s/${old_user}_//")
|
|
DBUSER="${user}_${DBUSER}"
|
|
str="DB='$DB' DBUSER='$DBUSER' MD5='$MD5' HOST='$HOST'"
|
|
str="$str TYPE='$TYPE' CHARSET='$CHARSET' U_DISK='$U_DISK'"
|
|
str="$str SUSPENDED='no' TIME='$(date +%T)' DATE='$(date +%F)'"
|
|
echo $str >> $USER_DATA/db.conf
|
|
else
|
|
eval $(grep "DB='$database'" $USER_DATA/db.conf)
|
|
fi
|
|
|
|
# Unziping database dump
|
|
gzip -d $tmpdir/db/$database/$database.*.sql.gz
|
|
|
|
# Importing database dump
|
|
database_dump="$tmpdir/db/$database/$database.$TYPE.sql"
|
|
case $TYPE in
|
|
mysql) rebuild_mysql_database;
|
|
import_mysql_database $database_dump ;;
|
|
pgsql) rebuild_pgsql_database;
|
|
import_pgsql_database $database_dump ;;
|
|
esac
|
|
done
|
|
fi
|
|
|
|
# Restoring cron jobs
|
|
if [ "$cron" != 'no' ] && [ ! -z "CRON_SYSTEM" ]; then
|
|
echo -e "\n-- CRON --" |tee -a $tmpdir/restore.log
|
|
|
|
# Unpacking cron container
|
|
tar xf $BACKUP/$backup -C $tmpdir ./cron
|
|
if [ "$?" -ne 0 ]; then
|
|
rm -rf $tmpdir
|
|
error="Can't unpack cron container"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
jobs=$(wc -l $tmpdir/cron/cron.conf |cut -f 1 -d' ')
|
|
if [ "$jobs" -eq 1 ]; then
|
|
echo -e "$(date "+%F %T") $jobs cron job" |tee -a $tmpdir/restore.log
|
|
else
|
|
echo -e "$(date "+%F %T") $jobs cron jobs"|tee -a $tmpdir/restore.log
|
|
fi
|
|
|
|
# Restoring cron jobs
|
|
cp $tmpdir/cron/cron.conf $USER_DATA/cron.conf
|
|
|
|
# Rebuilding cron jobs
|
|
sync_cron_jobs
|
|
|
|
# Restarting cron
|
|
$BIN/v-restart-cron
|
|
check_result $? "CRON restart failed"
|
|
fi
|
|
|
|
# Restoring user files and directories
|
|
if [ "$udir" != 'no' ]; then
|
|
echo -e "\n-- USER FILES --" |tee -a $tmpdir/restore.log
|
|
|
|
# Unpacking user dir container
|
|
if [ ! -z "$(tar -tf $BACKUP/$backup |grep './user_dir')" ]; then
|
|
|
|
# Creating user dir restore list
|
|
backup_dirs=$(tar -tf $BACKUP/$backup |grep "^./user_dir")
|
|
backup_dirs=$(echo "$backup_dirs" |grep tar.gz)
|
|
backup_dirs=$(echo "$backup_dirs" |cut -f 3 -d /)
|
|
backup_dirs=$(echo "$backup_dirs" |sed "s/.tar.gz//")
|
|
if [ -z "$udir" ] || [ "$udir" = '*' ]; then
|
|
user_dirs="$backup_dirs"
|
|
else
|
|
echo "$udir" |tr ',' '\n' > $tmpdir/selected.txt
|
|
user_dirs=$(echo "$backup_dirs" |egrep -f $tmpdir/selected.txt)
|
|
fi
|
|
|
|
for user_dir in $user_dirs; do
|
|
echo -e "$(date "+%F %T") $user_dir" |tee -a $tmpdir/restore.log
|
|
tar xf $BACKUP/$backup -C $tmpdir ./user_dir/$user_dir.tar.gz
|
|
if [ "$?" -ne 0 ]; then
|
|
error="can't unpack $user_dir user dir contaner"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
tar xzf $tmpdir/user_dir/$user_dir.tar.gz -C $HOMEDIR/$user
|
|
if [ "$?" -ne 0 ]; then
|
|
error="can't unpack $user_dir user dir contaner"
|
|
echo "$error" |$SENDMAIL -s "$subj" $email $notify
|
|
sed -i "/ $user /d" $VESTA/data/queue/backup.pipe
|
|
check_result "$E_PARSING" "$error"
|
|
fi
|
|
|
|
# Re-chowning files if uid differs
|
|
if [ "$old_uid" -ne "$new_uid" ]; then
|
|
find $HOMEDIR/$user/$user_dir -user $old_uid \
|
|
-exec chown -h $user:$user {} \;
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
|
|
# Create tmp/
|
|
mkdir -p $HOMEDIR/$user/tmp
|
|
chmod 700 $HOMEDIR/$user/tmp
|
|
chown -R $user:$user $HOMEDIR/$user/tmp
|
|
|
|
# Sending mail notification
|
|
subj="$user → restore has been completed"
|
|
cat $tmpdir/restore.log |$SENDMAIL -s "$subj" $email $notify
|
|
|
|
# Deleting temporary data
|
|
rm -rf $tmpdir
|
|
|
|
# Cleaning restore queue
|
|
sed -i "/v-restore-user $user /d" $VESTA/data/queue/backup.pipe
|
|
|
|
|
|
#----------------------------------------------------------#
|
|
# Vesta #
|
|
#----------------------------------------------------------#
|
|
|
|
# Update user counters
|
|
$BIN/v-update-user-counters $user
|
|
$BIN/v-update-user-counters admin
|
|
$BIN/v-update-sys-ip-counters
|
|
|
|
# Logging
|
|
log_event "$OK" "$ARGUMENTS"
|
|
|
|
exit
|