rear-backup_v0.1.2.sh

#!/bin/bash
# name          : rear-backup
# desciption    : create temporary connects and paths for rear backup
# autor         : speefak ( itoss@gmx.de )
# licence       : (CC) BY-NC-SA
# version       : 0.1.2
# notice        :
# infosource    :
#
#------------------------------------------------------------------------------------------------------------
############################################################################################################
#######################################   define global variables   ########################################
############################################################################################################
#------------------------------------------------------------------------------------------------------------

 Version=0.1.2
 ScriptName=$(basename $0)

 SSHFSUser=speefak					# TODO userinput / configfile
 SSHFSHost=192.168.1.x					# TODO userinput / configfile
 BackupFileSuffix="OS"					# TODO userinput / configfile
 BackupTargetDirRemoteHost="ReaR_Backups"		# TODO userinput / configfile
 BackupExcludeDir=" /mnt /media /home "			# TODO userinput / configfile
 RearOutputMode=ISO 					# TODO rear output for bootable USB drive incl backup tar only available for connected USB hardware

 RequiredPackets="rear syslinux syslinux-utils pigz locate"
 RearOutputImageName="$(hostname)_$(date +%F-%H%M%S)_${BackupFileSuffix}"
 SSHFSMountpoint="/mnt/${SSHFSUser}@$(echo ${SSHFSHost} | tr -d "/")_ReaR"
 RearOutputDir="${SSHFSMountpoint}/${BackupTargetDirRemoteHost}"

 CheckMark="\033[0;32m\xE2\x9C\x94\033[0m"

#------------------------------------------------------------------------------------------------------------
############################################################################################################
###############################################   parser  ##################################################
############################################################################################################
#------------------------------------------------------------------------------------------------------------

 BackupExcludeDirParsed=$(for i in $BackupExcludeDir ; do echo -n "'$i/*' " ; done)

#------------------------------------------------------------------------------------------------------------
############################################################################################################
########################################   set vars from options  ##########################################
############################################################################################################
#------------------------------------------------------------------------------------------------------------

	OptionVarList="

		HelpDialog;-h
		CreateUSBDrive;-cUSB
		ExternalISOFile;-eISO
		SSHConnectionCheck;-sshcc
		CheckForRequiredPackages;-cfrp
		Monochrome;-m
	"

	# set entered vars from optionvarlist
	OptionAllocator=" "										# for option seperator "=" use cut -d "="
	SAVEIFS=$IFS
	IFS=$(echo -en "\n\b")
 	for InputOption in $(echo " $@" | sed 's/ -/\n-/g') ; do
		for VarNameVarValue in $OptionVarList ; do
			VarName=$(echo "$VarNameVarValue" | cut -d ";" -f1)
			VarValue=$(echo "$VarNameVarValue" | cut -d ";" -f2)
			if [[ $InputOption == "$VarValue" ]]; then
				eval $(echo "$VarName"='$InputOption')					# if [[ -n Option1 ]]; then echo "Option1 set";fi
				#eval $(echo "$VarName"="true")
			elif [[ $(echo $InputOption | cut -d "$OptionAllocator" -f1) == "$VarValue" ]]; then
				eval $(echo "$VarName"='$(echo $InputOption | cut -d "$OptionAllocator" -f 2-5000)')
			fi
		done
	done
	IFS=$SAVEIFS

#------------------------------------------------------------------------------------------------------------
############################################################################################################
###########################################   define functions   ###########################################
############################################################################################################
#------------------------------------------------------------------------------------------------------------

script_information () {
        printf " Scriptname: $ScriptName\n"
        printf " Version:    $Version \n"
        printf " Location:   $(pwd)/$ScriptName\n"
        printf " Filesize:   $(ls -lh $0 | cut -d " " -f5)\n"
}

#------------------------------------------------------------------------------------------------------------

usage() {
	printf "\n"
	printf " Usage: $(basename $0) <options> "
	printf "\n"
	printf " -h		=> help dialog \n"
	printf " -cUSB		=> create bootable USB drive\n"
	printf " -eISO		=> external ISO file for -cUSB option (-eISO <file.iso|iso>)\n"
	ürintf " -sshcc		=> SSH connection check\n"
	printf " -cfrp		=> check for required packages\n"
	printf " -m		=> monochrome output\n"
	printf  "\e[0;31m\n $1\e[0m\n"
	printf "\n"
	exit
}

#------------------------------------------------------------------------------------------------------------------------------------------------

load_color_codes () {
	Black='\033[0;30m'	&&	DGray='\033[1;30m'
	LRed='\033[0;31m'	&&	Red='\033[1;31m'
	LGreen='\033[0;32m'	&&	Green='\033[1;32m'
	LYellowe='\033[0;33m'	&&	Yellow='\033[1;33m'
	LBlue='\033[0;34m'	&&	Blue='\033[1;34m'
	LPurple='\033[0;35m'	&&	Purple='\033[1;35m'
	LCyan='\033[0;36m'	&&	Cyan='\033[1;36m'
	LLGrey='\033[0;37m'	&&	White='\033[1;37m'
	Reset='\033[0m'
	# Use them to print in your required colours:
	# printf "%s\n" "Text in ${Red}red${Reset}, white and ${Blue}blue${Reset}."
}

#------------------------------------------------------------------------------------------------------------------------------------------------

check_for_required_packages () {

	InstalledPacketList=$(dpkg -l | grep ii)

	for Packet in $RequiredPackets ; do
		if [[ -z $(grep -w $Packet <<< $InstalledPacketList) ]]; then
			MissingPackets=$(echo $MissingPackets $Packet)
		fi
	done
 
	# print status message / install dialog
	if [[ -n $MissingPackets ]]; then
		printf  "missing packets: \e[0;31m $MissingPackets\e[0m\n"$(tput sgr0)
		read -e -p "install required packets ? (Y/N) " -i "Y" InstallMissingPackets
		if   [[ $InstallMissingPackets == [Yy] ]]; then

			# install software packets
			sudo apt update
			sudo apt install $MissingPackets
			if [[ ! $? == 0 ]]; then 
				exit
			fi
		else 
			printf  "programm error: \e[0;31m missing packets : $MissingPackets\e[0m\n\n"$(tput sgr0)
			exit 1
		fi
	else
		printf " all required packets detected\n"
	fi
	exit
}

#------------------------------------------------------------------------------------------------------------

SSH_connection_check () {

	ssh ${SSHFSUser}@${SSHFSHost} -t exit
	if [[ ! $? == 0 ]]; then
		usage " SSH connection failed"
	else
		printf " SSH connection ${SSHFSUser}@${SSHFSHost} established $CheckMark\n" 
		
		# check sshfs mount process
		sshfs -o allow_other,follow_symlinks,nonempty ${SSHFSUser}@${SSHFSHost}: ${SSHFSMountpoint}
		if [[ ! $? == 0 ]]; then
			printf " SSH connection ${SSHFSUser}@${SSHFSHost} established $CheckMark\n"
		fi

		umount ${SSHFSMountpoint}
		
	fi
	exit 1
}

#------------------------------------------------------------------------------------------------------------

WriteRearConfigISO () {

        echo '
		OUTPUT=ISO
		ISO_DIR='${RearOutputDir}'
		ISO_PREFIX="'$RearOutputImageName'"
		OUTPUT_URL=null
		BACKUP=NETFS
		BACKUP_URL="iso:///backup"

        ' > /etc/rear/local.conf
}

#------------------------------------------------------------------------------------------------------------

WriteRearConfigUSB () {

	# TODO create a bootable usb stick directly from Rear
	# issue : Raw output, used to create an image file does not support including backup tar archiv
	# you have to create an loop device, and use this loop device for OUTPUT=USB://path''/to/loopdevice to include backup tar archiv
	# 
	# https://github.com/rear/rear/issues/2581

        echo '
                OUTPUT=RAW
		RAW_DIR='${RearOutputDir}'
		OUTPUT_URL=null

		RAWDISK_IMAGE_NAME="'$RearOutputImageName'"
		RAWDISK_IMAGE_COMPRESSION_COMMAND='\''gzip'\''
		RAWDISK_FAT_VOLUME_LABEL='\''RESCUE SYS'\''
		RAWDISK_GPT_PARTITION_NAME='\'''$RearOutputImageName' Rescue System'\''

        ' > /etc/rear/local.conf
}

#------------------------------------------------------------------------------------------------------------

WriteRearConfigAdditional () {

        echo '
		BACKUP_PROG_COMPRESS_OPTIONS=( --use-compress-program=pigz )
		REQUIRED_PROGS+=( pigz )

		USER_INPUT_TIMEOUT=3

		AUTORESIZE_PARTITIONS=true

		BACKUP_PROG_EXCLUDE=( '$BackupExcludeDirParsed' )

        ' >> /etc/rear/local.conf
}

#------------------------------------------------------------------------------------------------------------------------------------------------

check_ISO_file () {									# usage: check_ISO_file <isofile.iso>

	# check ISO file - updatedb for quick image locaion and | otherwise input must include absolute path cause file cmd causes error
	ISOFile=$(locate -b "$1" | grep "\.iso$")
	if [[ -z $ISOFile ]]; then
		updatedb
	fi
	ISOFile=$(locate -b "$1" | grep "\.iso$")

	# check for more than one matched ISO file, print selection for various
	ISOFileAbsolutePath=$ISOFile
	if [[ $(grep -c . <<< $ISOFile) -gt 1 ]]; then
		ISOImageList=$(echo "$ISOFile" | nl | sed 's/^ */ /g')
		ISOImageListCount=$(echo "$ISOFile" | grep -c .)
		request_loop5 () {
			printf " Varios ISO Images detected, select one image: \n"
			printf "$ISOImageList\n\n"
			read -s -n 1 ISOImageSelection
			if [[ -z $( grep [[:digit:]] <<< $ISOImageSelection) ]] || [[ $ISOImageSelection -gt $ISOImageListCount ]]; then
				printf " invalid number: $ISOImageSelection \n"
				request_loop5
			fi
		}
		request_loop5
		ISOFileAbsolutePath=$(echo "$ISOImageList" | grep "^ $ISOImageSelection" | awk -F " " '{printf $2}') 
	fi

	# check for existing file
	if [[ -f $ISOFileAbsolutePath ]]; then
		printf " image exists $CheckMark ($ISOFileAbsolutePath)\n"
	else
		usage " file not found: $ISOFileAbsolutePath"
	fi

	FileProperties=$(file $(locate "$ISOFileAbsolutePath"))

	# check ISO filesystem
	if   [[ -n $(grep "ISO 9660" <<< $FileProperties)  ]]; then
		printf " ISO filesystem $CheckMark\n"
		ISOHybrid=false
	elif [[ -n $(grep " DOS/MBR boot sector" <<< $FileProperties)  ]]; then
		printf " Hybrid filesystem $CheckMark\n"
		ISOHybrid=true		
	else
		usage "invalid ISO file: $(printf "$(echo -e " $FileProperties" | sed 's/iso:/iso \\n type:\\t\\t   '/)")"
	fi

	# check for bootable ISO 
	if [[ -z $(grep "bootable" <<< $FileProperties)  ]]; then
		request_loop4 () {
			Request=
			printf " non bootable ISO file $ISOFileAbsolutePath"
			read -n1 -e -p " Are you sure to use this image (y/N)? " Request
			if   [[ "$Request" == [yY] ]]; then
				printf " non bootable ISO image accepted $CheckMark\n"
			elif [[ "$Request" == [nN]  ]]; then
				printf " USB drive creation process canceled\n"
				exit 1
			else
				request_loop4
			fi
			printf ""
		}
		request_loop4
	else
		printf " bootable ISO image $CheckMark\n"
	fi
}

#------------------------------------------------------------------------------------------------------------------------------------------------

detect_and_select_usb_drives () {

	DetectUSBDrivesResultFile=/tmp/.usbdrives
	DeviceListRAW=$(ls /dev/sd{a..z} 2> /dev/null)
	DeviceListInfoRAW=$(lshw -class disk)
	DeviceListOS=$(df -h | grep -v "/media/")

	# detect usb devices and safe output to $DetectUSBDrivesResultFile
	SAVEIFS=$IFS
	IFS=$(echo -en "\n\b")
	for i in $DeviceListRAW ; do
		if [[ -n $( grep $i <<< "$DeviceListOS")  ]]; then
			printf "Systemdevice detected: $i \n\n" 
		else
			# get USB drive vars
			DeviceInfo=$( grep -m1 -A5 -B5 "$i" <<< "$DeviceListInfoRAW")

			DeviceSize=$(awk -F "size:" '{printf $2 $3 }' <<< "$DeviceInfo")
			DeviceProduct=$(awk -F "product:" '{printf $2 $3 }' <<< "$DeviceInfo")
			DeviceVendor=$(awk -F "vendor:" '{printf $2 $3 }' <<< "$DeviceInfo")
			DeviceCapability=$(awk -F "capabilities:" '{printf $2 $3 }' <<< "$DeviceInfo")

			# set unknown var for unset vars
			DeviceSize=${DeviceSize:- unknown size}
			DeviceProduct=${DeviceProduct:-unknown product}
			DeviceVendor=${DeviceVendor:-unknown Vendor}
			DeviceCapability=${DeviceCapability:-unknown capability}

			printf "%-20s %-8s %-10s %-18s %-10s\n" "USB drive detected:" "$i" "$DeviceProduct" "$DeviceSize" "$DeviceCapability"
		fi
	done | grep USB | nl | sed 's/^ */ /g' > $DetectUSBDrivesResultFile
	IFS=$SAVEIFS	

	# select USB drive if more than one usb drive is detected
	USBDriveChoise=1
	DetectedUSBDeviceCount=$( grep -c . $DetectUSBDrivesResultFile)
	if   [[ $DetectedUSBDeviceCount == 0 ]]; then
		usage " no usb drive found"
	elif [[ $DetectedUSBDeviceCount -gt 1 ]]; then
		request_loop () {
			printf "\n select USB drive: \n" 
			cat $DetectUSBDrivesResultFile
			read -s -n 1 USBDriveChoise
			if [[ -z $( grep [[:digit:]] <<< $USBDriveChoise) ]] || [[ $USBDriveChoise -gt $DetectedUSBDeviceCount ]]; then
				printf " invalid number: $USBDriveChoise \n"
				request_loop
			fi
		}
		request_loop
	fi

	# get selected USB device path
	SelectedUSBDrive=$(grep "^ $USBDriveChoise" $DetectUSBDrivesResultFile) 
	USBTargetDevicePath=$( awk -F " " '{printf $5}' <<< "$SelectedUSBDrive")

	printf "\n$(sed 's/detected/selected/' <<< $SelectedUSBDrive)\n"

	# final check for correct device path
	request_loop2 () {
		Request=
		read -n1 -e -p " ALL DATA ON THIS DEVICE WILL BE LOST ! Use this drive (y/N)? " Request
		if   [[ "$Request" == [yY] ]]; then
			printf ""
		elif [[ "$Request" == [nN]  ]]; then
			printf " USB drive creation process canceled\n"
			exit 1
		else
			request_loop2
		fi
		printf ""
 	}
 	request_loop2
}

#------------------------------------------------------------------------------------------------------------------------------------------------

create_USB_drive_from_ISO () {

	# unmount USB drive if mounted
	umount -f ${USBTargetDevicePath}* 2> /dev/null

	# format USB drive with vFAT filesystem 
	printf "\n format USB drive (${USBTargetDevicePath}) with vFAT filesystem\n"
	mkfs -t vfat -I ${USBTargetDevicePath}
	
	# create iso hybrid filesystem for iso 9660
	if   [[ $ISOHybrid == false ]]; then
		
		# copy source ISO
		printf "\n copy ISO file for header update"
		cp ${ISOFileAbsolutePath} ${ISOFileAbsolutePath}-isohybrid

		# prepeare image header for blockdevice copy
		printf "\n change ISO header"
		isohybrid ${ISOFileAbsolutePath}-isohybrid --entry 4 --type 0x1c

		# write ISO to USB drive
		ISO2USBSourcefile="${ISOFileAbsolutePath}-isohybrid"
		write_ISO_to_USB

		# delete Isohybrid image
		rm ${ISOFileAbsolutePath}-isohybrid

	elif [[ $ISOHybrid == true ]]; then
		# write ISO to USB drive
		ISO2USBSourcefile=${ISOFileAbsolutePath}
		write_ISO_to_USB
	fi
}

#------------------------------------------------------------------------------------------------------------
write_ISO_to_USB () {

	# write ISO file to USB drive
	printf "\n write ISO file to USB drive\n"
	dd if=${ISO2USBSourcefile} | pv ${ISO2USBSourcefile} | dd of=${USBTargetDevicePath} status=none conv=fdatasync oflag=sync bs=2M 
}

#------------------------------------------------------------------------------------------------------------
############################################################################################################
#############################################   start script   #############################################
############################################################################################################
#------------------------------------------------------------------------------------------------------------

        # check for script information
        if [[ $1 == "-i" ]]; then
                printf "\n"
                script_information
                printf "\n"
        fi

#------------------------------------------------------------------------------------------------------------

	# check help dialog
	if [[ -n $HelpDialog ]] || [[ -z $1 ]]; then usage "help dialog" ; fi

#------------------------------------------------------------------------------------------------------------
	# check for root permission
        if [ ! "$(whoami)" = "root" ]; then printf "\nAre You Root ?\n\n";exit 1;fi

#------------------------------------------------------------------------------------------------------------

	# check for monochrome output
	if [[ -n $Monochrome ]]; then
		load_color_codes
	fi

#------------------------------------------------------------------------------------------------------------

	if [[ -n $CheckForRequiredPackages ]]; then
		check_for_required_packages
	fi

#------------------------------------------------------------------------------------------------------------

	if [[ -n $SSHConnectionCheck ]]; then
		SSH_connection_check
	fi

#------------------------------------------------------------------------------------------------------------

	# create ReaR backup using ISO file ouput including systembackup if no external ISO file specified
	if [[ -z $ExternalISOFile ]]; then

	        # create local mountpoint, mount ssh remote host and create iso backup target dir
		SSHFSMount=true
		mkdir -p "${SSHFSMountpoint}"
		sshfs -o allow_other,follow_symlinks,nonempty ${SSHFSUser}@${SSHFSHost}: ${SSHFSMountpoint}

		# check for correct sshfs mount
		if [[ ! $? == 0 ]]; then
			SSH_connection_check
		fi

		# create backup directory on ssh host 
		mkdir -p "${RearOutputDir}"

		#-------------------------------------------------------------------------------------------------------------

		# backup existing ReaR configuration and setup temporary ReaR configuration
		cp /etc/rear/local.conf /etc/rear/local.conf_bak

		# create rear configfile in /etc/rear/local.conf
		if   [[ $RearOutputMode == "ISO" ]]; then
			WriteRearConfigISO
		elif [[ $RearOutputMode == "RAW" ]]; then
			WriteRearConfigIRAW
		fi

		WriteRearConfigAdditional

		#------------------------------------------------------------------------------------------------------------

		# start ReaR backup
		rear -v mkbackup

		#------------------------------------------------------------------------------------------------------------

		# restore ReaR configuration
		mv /etc/rear/local.conf_bak /etc/rear/local.conf

		#------------------------------------------------------------------------------------------------------------
	fi

#------------------------------------------------------------------------------------------------------------

	# check for USB creation or external ISO file
	if [[ -n $CreateUSBDrive ]] || [[ -n $ExternalISOFile ]]; then

		SourceISO="'${RearOutputDir}'/'$RearOutputImageName'"
		# check for external ISO file
		if [[ -n $ExternalISOFile ]]; then
			SourceISO="$ExternalISOFile"
		fi

		# check ISO file
		check_ISO_file "$SourceISO"

		# detect and select usb drives
		detect_and_select_usb_drives

		#TODO check if USB drive size is larger than ISO image file size

		# create bootable usb drive from ISO file
		create_USB_drive_from_ISO
	fi

#------------------------------------------------------------------------------------------------------------

        # unmount and delete directories
	if [[ $SSHFSMount == true ]]; then
	        umount ${SSHFSMountpoint}
	        rmdir ${SSHFSMountpoint}
	fi

#------------------------------------------------------------------------------------------------------------

exit 0

#TODO export tmporary tar archiv
#backup.tar.gz
#root@speenux:/tmp/rear.kdR0eQobzObpXSK/tmp/isofs/backup/backup.tar.gz




#TODO	https://github.com/jsamr/bootiso	
# use bootiso insted of "detect_and_select_usb_drives" "create_USB_drive_from_ISO"
# request for using non main repo software

## Infosoure ISO
# https://askubuntu.com/questions/372607/how-to-create-a-bootable-ubuntu-usb-flash-drive-from-terminal/667224#667224