Bash-Skript mit rsync (Anfänger bittet um Hilfe)

## sudoers file.

# Enable logging of a command's output. 
# Use sudoreplay to play back logged sessions.
Defaults syslog=authpriv

# Allow root to execute any command
root ALL=(ALL) ALL

# Allow members of group administrators to execute any command
%administrators ALL=(ALL) ALL

# Configure privilege of wheel group
Cmnd_Alias SHELL = /bin/ash, /bin/sh, /bin/bash
Cmnd_Alias SU = /usr/bin/su
%wheel ALL=(ALL) NOPASSWD: ALL, !SHELL, !SU

...
# Dateien kopieren
if [ "$fullbackup" == "true" ]  
  then
    echo "$(date +%H:%M:%S) - INFO: Vollsicherung: $windowsquelle -> ${lokalesziel}/0 ..."  
    echo "$(date +%H:%M:%S) - INFO: Vollsicherung: $windowsquelle -> ${lokalesziel}/0 ..." >> $scriptlogdatei  
    sudo /opt/bin/rsync -a --no-perms --no-owner --no-group -W --verbose --stats ${lokalequelle}/ ${lokalesziel}/0 > $rsynclogdatei
  else
    echo "$(date +%H:%M:%S) - INFO: Inkrementelle Sicherung: $windowsquelle -> ${lokalesziel}/0 ..."  
    echo "$(date +%H:%M:%S) - INFO: Inkrementelle Sicherung: $windowsquelle -> ${lokalesziel}/0 ..." >> $scriptlogdatei  
    sudo /opt/bin/rsync -a --no-perms --no-owner --no-group -W --verbose --stats --link-dest=${lokalesziel}/1 ${lokalequelle}/ ${lokalesziel}/0 > $rsynclogdatei
fi  
touch ${lokalesziel}/0/
...

#!/bin/bash

### Hauptskript ###
  # zur Ausführung von Backups aufzurufen

# Konfiguration
hauptskriptverzeichnis="/volume1/admin/scripte/backup"  
configdatei="${hauptskriptverzeichnis}/konfiguration.sh"  
functionsdatei="${hauptskriptverzeichnis}/funktionen.sh"  
workerskriptdatei="${hauptskriptverzeichnis}/psync.sh"  
#weitere Konfiguration: configdatei


# Vorprüfung und Konfiguration und Funktionen laden
if [ ! -d "$hauptskriptverzeichnis" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Hauptskriptverzeichnis wurde nicht gefunden."  
		echo "                  $hauptskriptverzeichnis"  
		exit 1
fi
if [ ! -f "$configdatei" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Die Konfig-Datei wurde nicht gefunden."  
		echo "                  $configdatei"  
		exit 1
fi
source "$configdatei" # Konfiguration laden  
if [ ! -f "$functionsdatei" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Hilfskript mit Funktionen wurde nicht gefunden."  
		echo "                  $functionsdatei"  
		exit 1
fi
source "$functionsdatei" # Funktionen laden  
if [ ! -f "$workerskriptdatei" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Hilfskript zur Jobabarbeitung wurde nicht gefunden."  
		echo "                  $workerskriptdatei"  
		exit 1
fi
if [ ! -d "$logverzeichnis" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Log-Hauptverzeichnis wurde nicht gefunden."  
		echo "                  $logverzeichnis"  
		exit 1
fi
if [ ! -d "$lokalequelle" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Das lokale Verzeichnis zum Mounten der Quellen wurde nicht gefunden."  
		echo "                  $lokalequelle"  
		exit 1
fi
if [ ! -d "$jobskriptverzeichnis" ]  
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Verzeichnis der Job-Skripte wurde nicht gefunden."  
		echo "                  $jobskriptverzeichnis"  
		exit 1
fi


# Variablen vorbelegen (hier nichts ändern)
jobanzahl=0
joberfolgreichanzahl=0
jobmitfehleranzahl=0
fehleraufgetreten=0
gesamtbytes=0

# Startzeit merken
zeitformat="+%Y-%m-%d %H:%M:%S" # Format in Variable speichern wegen enthaltenem Leerzeichen  
gesamtstartzeit="$(date "$zeitformat")"  

# Verzeichnis für Logdateien anlegen (-p = kein Fehler wenn Verzeichnis schon vorhanden)
startdatum="$(date +%Y-%m-%d)"  
mkdir -p -m 0755 ${logverzeichnis}/${startdatum}/

# Master-Logdatei anlegen
datum="$(date +%Y-%m-%d_%H-%M-%S)"  
masterlogdatei="${logverzeichnis}/${startdatum}/${datum}__backup.txt"  
sudo echo "$(date +%H:%M:%S) - INFO: Backup wurde gestartet" | sudo tee $masterlogdatei # Nur hier ohne append  
sudo echo "$(date +%H:%M:%S) - INFO: Logstammverzeichnis: $logverzeichnis" | sudo tee --append $masterlogdatei  
sudo echo "$(date +%H:%M:%S) - INFO: Logunterverzeichnis: $startdatum" | sudo tee --append $masterlogdatei  

# Prüfen ob eine andere Instanz des Skripts noch läuft
if [ -f "${hauptskriptverzeichnis}/$isrunningdatei" ]  
	then
		sudo echo "$(date +%H:%M:%S) - ERROR: Eine andere Backup-Instanz läuft noch. Die neue Instanz wird beendet." | sudo tee --append $masterlogdatei  
		fehleraufgetreten=1
		ende 2 # $isrunningdatei nicht löschen daher ende 2
	else
		touch "${hauptskriptverzeichnis}/isrunning.txt"  
fi

# Die "isrunningdatei" erzeugen 
touch "${hauptskriptverzeichnis}/isrunning.txt"  
if [ -f "${hauptskriptverzeichnis}/$isrunningdatei" ]  
	then
		sudo chmod a+rwx "${hauptskriptverzeichnis}/$isrunningdatei"  
		fehlercode=$?
		if [ ! $fehlercode -eq 0 ]
			then
				sudo echo "$(date +%H:%M:%S) - ERROR: Fehler beim Setzen der Rechte für die isrunningdatei" | sudo tee --append $masterlogdatei  
				fehleraufgetreten=1
		fi
	else
		sudo echo "$(date +%H:%M:%S) - ERROR: Die isrunningdatei wurde nicht erzeugt" | sudo tee --append $masterlogdatei  
		fehleraufgetreten=1
fi

# Prüfen ob zumindest 1 Job-Skript existiert
jobgefunden=`find $jobskriptverzeichnis/$jobskriptnamensmuster -type f`
if [ "$jobgefunden" = "" ]  
	then
		sudo echo "$(date +%H:%M:%S) - ERROR: Keinen Job gefunden, Backup wird beendet" | sudo tee --append $masterlogdatei  
		fehleraufgetreten=1
		ende 1
fi

# Job-Skripte suchen und in Array speichern
skripte=()
for datei in "$jobskriptverzeichnis/$jobskriptnamensmuster"  
do 
	skripte+=($datei)
done
jobanzahl=${#skripte[@]}

# Alle gefundenen Job-Skripte auflisten
for s in "${skripte[@]}"  
do
	source "${s}"  
	sudo echo "$(date +%H:%M:%S) - INFO: Job gefunden: ${logtitel} (${logprefix})" | sudo tee --append $masterlogdatei  
done
sudo echo "$(date +%H:%M:%S) - INFO: Jobanzahl: ${jobanzahl}" | sudo tee --append $masterlogdatei  
sudo echo "" | sudo tee --append $masterlogdatei  

# Quelle eventuell unmounten, für den Fall dass es nicht erledigt ist
unmounten $lokalequelle $testdatei # function unmounten() aufrufen

# Alle gefundenen Job-Skripte nacheinander ausführen
for s in "${skripte[@]}"  
do
	jobstartzeit="$(date "$zeitformat")"  
	returnwert=0
	neuedateien=0
	neueverzeichnisse=0
	neuedaten=0
	rsyncoptionen=$rsyncstandardoptionen # rsyncoptionen werden eventuell gleich durch Job-Skript geändert
	versionenanzahl=$versionenstandardanzahl # versionenanzahl wird eventuell gleich durch Job-Skript geändert
	source "${s}"  
	sudo echo "$(date +%H:%M:%S) - INFO: Job wird gestartet: ${logtitel} (${logprefix})" | sudo tee --append $masterlogdatei  
	source "${hauptskriptverzeichnis}/psync.sh"  
	returnwert=$?

	if [ $returnwert -eq 0 ]
		then
			sudo echo "$(date +%H:%M:%S) - INFO: Job wurde beendet : Keine Fehler aufgetreten" | sudo tee --append $masterlogdatei  
			joberfolgreichanzahl=$(($joberfolgreichanzahl + 1))
		else
			if [ -f $scriptlogdatei ]
				then
					sudo echo "$(date +%H:%M:%S) - ERROR: Fehler siehe     : $scriptlogdateiname" | sudo tee --append $masterlogdatei  
				else
					sudo echo "$(date +%H:%M:%S) - ERROR: Fehler siehe     : (kein Skript-Log vorhanden)" | sudo tee --append $masterlogdatei  
			fi
			if [ -f $rsynclogdatei ]
				then
					sudo echo "                                   : $rsynclogdateiname" | sudo tee --append $masterlogdatei  
				else
					sudo echo "                                   : (kein rsync-Log vorhanden)" | sudo tee --append $masterlogdatei  
			fi
			jobmitfehleranzahl=$(($jobmitfehleranzahl + 1))
			fehleraufgetreten=1
	fi
	sudo echo "$(date +%H:%M:%S) - INFO: Dateien/Ver./Daten: $neuedateien / $neueverzeichnisse / $neuedaten" | sudo tee --append $masterlogdatei  

	jobbeginnunix=`date --utc --date "$jobstartzeit" +%s`  
	jobendezeit="$(date "$zeitformat")"  
	jobendeunix=`date --utc --date "$jobendezeit" +%s`  
	jobsekunden=$((jobendeunix-jobbeginnunix))
	jobdauer="$((jobsekunden /3600)) Std. $((jobsekunden % 3600 /60)) Min. $((jobsekunden % 60)) Sek."  
	sudo echo "$(date +%H:%M:%S) - INFO: Job benötigte     : $jobdauer" | sudo tee --append $masterlogdatei  
	sudo echo "" | sudo tee --append $masterlogdatei  
	unmounten $lokalequelle $testdatei # für den Fall dass es nicht erledigt ist
done

ende $fehleraufgetreten # function ende () mit 0 oder 1 aufrufen

#!/bin/bash

# Konfiguration
jobskriptverzeichnis="/volume1/admin/scripte/backup/jobs"  
jobskriptnamensmuster="sichern_*.sh"  
rsyncstandardoptionen="-rtlDW --stats" ## h und hh (human readable) nicht verwenden, da die Auswertung auf bytes basiert  
versionenstandardanzahl=7 # 7 Verzeichnisse (0-6) werden verwendet
logverzeichnis="/volume1/admin/scripte/backup/logs"  
lokalequelle="/volume1/admin/scripte/backup/mount"  
testdatei="${lokalequelle}/lokal.txt" # Die Testdatei muss in diesem Verzeichnis existieren  
isrunningdatei="isrunning.txt"  
windowsbenutzername="Administrator"  
mailepfaenger=ich@example.com
mailsenden=1

#!/bin/bash

function unmounten() # Das Quellverzeichnis unmounten. Aufruf: unmounten $lokalequelle $testdatei
{
	# $1=$lokalequelle, $2=$testdatei
	if [ ! -f $2 ]
		then
		sudo umount $1
	fi
	fehlercode=$?
	if [ ! $fehlercode -eq 0 ]
		then
			sudo echo "$(date +%H:%M:%S) - ERROR: Fehler $fehlercode beim Unmounten der lokalen Quelle" | sudo tee --append $masterlogdatei  
			fehleraufgetreten=1
			ende 1
	fi
}

function leertest() # Prüfen, ob ein Verzeichnis leer ist. Falls das Verzeichnis nicht existiert gilt es auch als leer
{
	# Syntax: if leertest Pfad then echo "leer" else echo "nicht leer" fi 
	if [ $(ls -a "$1" | wc -l) -gt 2 ] # wc = word count (l = lines = zeilen) = 2 (bei . und ..)  
		then
			return 1 # nicht leer
		else
			return 0 # leer
	fi
}

function verzeichnisrotation() # Bei z.B. versionsanzahl=7 die Verzeichnisse 0-6 rotieren: 6 löschen, 0-5 umbenennen in 1-6 und 0 neu anlegen
{
	maxversion=$(($versionenanzahl - 1))
	maxverzeichnis=-1 # Vorbelegenung für höchster Verzeichnisname ohne Lücke (0,1,2,5 => 2)
	fehlertext=""  
	for ((i=0;i<=$maxversion;i++))
	do
		if [ -d "${1}/${i}" ] # existiert das Verzeichnis (0..maxversion)  
			then
				if leertest ${1}/${i}
					then
						fehlertext="$(date +%H:%M:%S) - ERROR: Das alte Verzeichnis $i ist leer."  
						return 1
				fi
				maxverzeichnis=$i # wird jedesmal eins höher
			else
				j=$i
				while [[ $((++j)) -le $maxversion ]] # prüfen ob danach noch Verzeichnisse existieren
				do
					if [ -d "${1}/${j}" ]  
						then
							if [ "$maxverzeichnis" == "-1" ]  
								then
									fehlertext="$(date +%H:%M:%S) - ERROR: Die Verzeichnissequenz weist eine Lücke bei Verzeichnis 0 auf."  
								else
									fehlertext="$(date +%H:%M:%S) - ERROR: Die Verzeichnissequenz weist eine Lücke nach Verzeichnis $maxverzeichnis auf."  
							fi
							return 1
					fi
				done
				break
		fi
	done
	# zuvor keine Lücken in der Verzeichnissequenz 0-aufsteigend gefunden oder 0..maxversion nicht vorhanden
	# Zuvor keine leeren Verzeichnisse in der Verzeichnissequenz gefunden oder 0..n nicht vorhanden

	# Verzeichnis maxversion löschen, falls vorhanden
	if [ -d "${1}/$maxversion" ]  
		then
			sudo /opt/bin/rm -rf ${1}/${maxversion}/
	fi
	fehlercode=$?
	if [ ! $fehlercode -eq 0 ]
		then
			fehlertext="$(date +%H:%M:%S) - ERROR: Fehler $fehlercode beim Löschen von Verzeichnis ${maxversion}"  
			return 1
	fi

	# Verzeichnisnamen 0..(maxversion-1) um 1 erhöhen
	j=$versionenanzahl
	startwert=$(($maxversion - 1))
	for ((i=$startwert;i>=0;i--)) # maxversion..0
	do
		j=$(( $j - 1 ))
		if [ -d "${1}/${i}" ]  
			then
				sudo mv ${1}/${i}/ ${1}/${j}/
		fi
		fehlercode=$?
		if [ ! $fehlercode -eq 0 ]
			then
				fehlertext="$(date +%H:%M:%S) - ERROR: Fehler $fehlercode beim Umbenennen von Verzeichnis $i"  
			return 1
		fi
	done

	# Verzeichnisnamen 0 neu erstellen
	sudo mkdir -m 0755 ${1}/0/
	fehlercode=$?
	if [ ! $fehlercode -eq 0 ]
		then
			fehlertext="$(date +%H:%M:%S) - ERROR: Fehler $fehlercode beim Erstellen von Verzeichnis 0"  
			return 1
	fi

	return 0
}

function rysnclog_auswerten() # rsynclog durchsuchen und ein paar Werte auslesen
{
	#Varianten der relevanten Log-Zeile für kopierte Dateien/Verzeichnisse:
	#2018/01/13 15:28:21 [1403] Number of created files: 0
	#2018/01/13 15:27:32 [1900] Number of created files: 10 (reg: 10)
	#2018/01/13 15:27:54 [1084] Number of created files: 2 (dir: 2)
	#2018/01/13 15:28:15 [1246] Number of created files: 12 (reg: 10, dir: 2)

	#Varianten der relevanten Log-Zeile für kopierte Datenmenge:
	#2018/01/13 15:54:07 [4475] Total transferred file size: 826 bytes
	#2018/01/13 15:54:07 [4475] Total transferred file size: 2.64K bytes
	#2018/01/13 15:54:07 [4475] Total transferred file size: 2.64M bytes
	#2018/01/13 15:54:07 [4475] Total transferred file size: 2.64G bytes
	#2018/01/13 15:54:07 [4475] Total transferred file size: 2.64T bytes
	neueverzeichnisse=0
	neuedateien=0
	neuedaten=0
	if [ ! -f $rsynclogdatei ]
		then return 1
	fi
	
	while read line
	do
		if [[ $line == *"Number of created files:"* ]]  
			then
				ar=($line) # Zeile an Leerzeichen splitten
				if [ "${ar[7]}" != "0" ]  
					then
						if [ "${ar[8]}" == "(reg:" ]  
							then
								neuedateien=${ar[9]:0:-1}
						fi
						if [ "${ar[8]}" == "(dir:" ]  
							then
								neueverzeichnisse=${ar[9]:0:-1}
						fi
						if [ "${ar[10]}" == "dir:" ]  
							then
								neueverzeichnisse=${ar[11]:0:-1}
						fi
				fi
				neuedateien=${neuedateien//,/.} # alle Tausendertrennzeichen austauschen
				neueverzeichnisse=${neueverzeichnisse//,/.} # alle Tausendertrennzeichen austauschen
		fi
		if [[ $line == *"Total transferred file size:"* ]]  
			then
				ar=($line) # Zeile an Leerzeichen splitten
				byteszuhuman ${ar[7]} # function byteszuhuman () aufrufen
				fehlercode=$? # returnwert der Funktion
				if [ ! $fehlercode -eq 0 ]
					then
						echo "$(date +%H:%M:%S) - ERROR: Fehler bei der Umrechung der Bytes" | sudo tee --append $scriptlogdatei  
					else
						neuedaten=$ergebnisumgerechnet
						gesamtbytes=$(( $gesamtbytes + $ergebnisinbytes )) # Aufaddieren für Gesamtergebnis aller Jobs
				fi
		fi
	done < $rsynclogdatei

	return $?
}

function byteszuhuman () # Umrechnung von z.B. 1,024 (bytes) in 1,00 kB (eintausend und 24 in 1 Komma 00), die Variable $ergebnisumgerechnet wird belegt
{
	bytes=$1
	bytes=${bytes//,/} # alle Tausendertrennzeichen entfernen
	ergebnisinbytes=$bytes
	ergebnisumgerechnet=0

	# Prüfung
	if [ ! "${bytes//[0-9]}" = "" ] || [ "$bytes" = "" ] # bleibt was übrig wenn alle Ziffern entfernt sind oder war es leer?  
		then
			ergebnis=0
			return 1
	fi

	# Unterscheidung
	if ((0<=$bytes && $bytes<1024))
		then
			menge=$bytes
			einheit="Byte"  
	elif ((1024<=$bytes && $bytes<1048576))
		then
			menge=`echo $bytes | awk '{ byte = $1 /1024 ; print byte }'`  
			einheit="kB"  
	elif ((1048576<=$bytes && $bytes<1073741824))
		then
			menge=`echo $bytes | awk '{ byte = $1 /1024/1024 ; print byte }'`  
			einheit="MB"  
	elif ((1073741824<=$bytes && $bytes<1099511627776))
		then
			menge=`echo $bytes | awk '{ byte = $1 /1024/1024/1024 ; print byte }'`  
			einheit="GB"  
	else
		menge=`echo $bytes | awk '{ byte = $1 /1024/1024/1024/1024 ; print byte }'`  
		einheit="TB"  
	fi

	# Formatierung
	if [ "$einheit" = "Byte" ]  
		then
			ergebnisumgerechnet=`printf "%'.0f\n" $menge` # Mit Tausendertrennzeichen ohne Nachkommastellen  
		else
			ergebnisumgerechnet=`printf "%'.2f\n" $menge` # Mit Tausendertrennzeichen und zwei Nachkommastellen  
	fi

	# Nachformatierung
	ergebnisumgerechnet=${ergebnisumgerechnet//,/x} # alle Tausendertrennzeichen austauschen
	ergebnisumgerechnet=${ergebnisumgerechnet/./,}  # das  Dezimaltrennzeichen austauschen
	ergebnisumgerechnet=${ergebnisumgerechnet//x/.} # alle Tausendertrennzeichen austauschen
	ergebnisumgerechnet="$ergebnisumgerechnet $einheit"  
	return 0
}

function ende() # Aufräumem, Statistik, E-Mailversand, Beenden
{
	status="$1" # der Status, der an ende() übergeben wurde($1)  

	# isrunningdatei löschen (oder nicht)
	if [ ! $status -eq 2 ]
		then
			# isrunningdatei löschen
			if [ -f ${hauptskriptverzeichnis}/$isrunningdatei ]
				then
					sudo rm -f ${hauptskriptverzeichnis}/$isrunningdatei
			fi
			if [ -f ${hauptskriptverzeichnis}/$isrunningdatei ] # konnte offensichtlich nicht gelöscht werden
				then
					sudo echo "$(date +%H:%M:%S) - ERROR: Datei $isrunningdatei konnte nicht gelöscht werden" | sudo tee --append $masterlogdatei  
					fehleraufgetreten=1
			fi
	fi

	# Ordner für Logdateien an Windowsbenutzer übergeben
	sudo chown -R ${windowsbenutzername}.users ${logverzeichnis}/${startdatum}
	fehlercode=$?
	if [ ! $fehlercode -eq 0 ]
		then
			sudo echo "$(date +%H:%M:%S) - ERROR: Fehler beim Übergeben des Besitzes am Logordner ${startdatum}" | sudo tee --append $masterlogdatei  
			fehleraufgetreten=1
	fi
	# Rechte für Logordner und Logdateien setzen
	sudo chmod a+rwx -R ${logverzeichnis}/${startdatum}
	fehlercode=$?
	if [ ! $fehlercode -eq 0 ]
		then
			sudo echo "$(date +%H:%M:%S) - ERROR: Fehler beim Setzen der Rechte für Logordner/-dateien ${startdatum}" | sudo tee --append $masterlogdatei  
			fehleraufgetreten=1
	fi

	# Gesamtdatenmenge ausgeben
	byteszuhuman $gesamtbytes # function byteszuhuman () aufrufen
	fehlercode=$? # returnwert der Funktion
	if [ ! $fehlercode -eq 0 ]
		then
			echo "$(date +%H:%M:%S) - ERROR: Die Gesamtdatenmenge konnte nicht umgerechnet werden" | sudo tee --append $masterlogdatei  
		else
			echo "$(date +%H:%M:%S) - INFO: Backup kopierte $ergebnisumgerechnet" | sudo tee --append $masterlogdatei  
	fi

	# Gesamtlaufzeit ausgeben
	gesamtbeginnunix=`date --utc --date "$gesamtstartzeit" +%s`  
	gesamtendezeit="$(date "$zeitformat")"  
	gesamtendeunix=`date --utc --date "$gesamtendezeit" +%s`  
	gesamtsekunden=$((gesamtendeunix - gesamtbeginnunix))
	gesamtdauer="$((gesamtsekunden / 3600)) Std. $((gesamtsekunden % 3600 / 60)) Min. $((gesamtsekunden % 60)) Sek."  
	sudo echo "$(date +%H:%M:%S) - INFO: Backup lief $gesamtdauer" | sudo tee --append $masterlogdatei  

	# Transferrate ausgeben
	transfersekunden=$gesamtsekunden
	if [ $transfersekunden -eq 0 ] # geteilt durch 0 vermeiden
		then
			transfersekunden=1
	fi
	transferrate=$(($gesamtbytes / $transfersekunden))
	byteszuhuman $transferrate # function byteszuhuman () aufrufen
	transferrate=$ergebnisumgerechnet
	sudo echo "$(date +%H:%M:%S) - INFO: Gesamtübertragungsrate: ${transferrate}/s" | sudo tee --append $masterlogdatei  

	# Abschlussstatus ausgeben und "mailbetreffteil" belegen 
	if [ $fehleraufgetreten -eq 0 ] && [ $status -eq 0 ]
		then
			sudo echo "$(date +%H:%M:%S) - INFO: Backup erfolgreich beendet" | sudo tee --append $masterlogdatei  
			mailbetreffteil="erfolgreich"  
		else
			sudo echo "$(date +%H:%M:%S) - ERROR: Backup mit Fehler beendet" | sudo tee --append $masterlogdatei  
			if [ $jobmitfehleranzahl -eq 1 ]
				then
					mailbetreffteil="abgeschlossen, 1 Job mit Fehler"  
				else
					mailbetreffteil="abgeschlossen, $jobmitfehleranzahl Jobs mit Fehler"  
			fi
	fi

	# E-Mail senden ?
	if [ $mailsenden -ne 1 ] || [ "$mailepfaenger" == "" ]  
		then
			exit $status
	fi

	# E-Mail senden !
	if [ $jobanzahl -eq 1 ] # Job oder Jobs (Einzahl oder Mehrzahl)
		then
			job_s=""  
		else
			job_s="s"  
	fi
	if [ $jobanzahl -eq 0 ]
		then
			mailbetreff="Nas-Backup: Keinen Job gefunden ($(date +%d.%m.%Y) um $(date +%H:%M:%S))"  
		else
			mailbetreff="Nas-Backup: ${jobanzahl} Job$job_s $mailbetreffteil ($(date +%d.%m.%Y) um $(date +%H:%M:%S))"  
	fi
	if [ $status -eq 2 ]
		then
			mailbetreff="Nas-Backup: Ein laufendes Backup hat die Ausführung verhindert ($(date +%d.%m.%Y) um $(date +%H:%M:%S))"  
	fi

	#echo "Nachrichtentext"  | /opt/bin/nail -s "${mailbetreff}" -a "${masterlogdatei}" $mailepfaenger 
	echo ""  | /opt/bin/nail -s "${mailbetreff}" -a "${masterlogdatei}" $mailepfaenger  

	exit $status
}

#!/bin/bash

### Workerscript zur Jobabarbeitung ###
  # Nicht direkt ausführen, es wird vom Backup-Skript für jeden Job aufgerufen

fullbackup=true

# Logdatei erzeugen
datum="$(date +%Y-%m-%d_%H-%M-%S)"  
scriptlogdateiname="${datum}_${logprefix}_job.txt"  
scriptlogdatei="${logverzeichnis}/${startdatum}/${scriptlogdateiname}"  
rsynclogdateiname="${datum}_${logprefix}_rsync.txt"  
rsynclogdatei="${logverzeichnis}/${startdatum}/${rsynclogdateiname}"  
echo "$(date +%H:%M:%S) - INFO: Starte Backupjob von $logtitel" | sudo tee --append $scriptlogdatei # Nur hier ohne append  

# Prüfen ob der Zielordner existiert
if [ ! -d "${lokalesziel}" ]  
	then
		sudo echo "$(date +%H:%M:%S) - ERROR: Der Zielordner existiert nicht: ${lokalesziel}" | sudo tee --append $scriptlogdatei  
		return 1
fi

# Quelle mounten
echo "$(date +%H:%M:%S) - INFO: Windowsquelle verbinden..." | sudo tee --append $scriptlogdatei  
if [ ! -f $testdatei ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Die Testdatei existiert nicht im lokalen Ordner." | sudo tee --append $scriptlogdatei  
		return 1
fi
sudo mount.cifs -o iocharset=utf8,ro,username=${benutzername},password=${kennwort} "$windowsquelle" $lokalequelle  
if [ -f $testdatei ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Mounten hat nicht funktioniert." | sudo tee --append $scriptlogdatei  
		return 1
fi

# Prüfen ob 0 schon existiert
if [ -d "${lokalesziel}/0" ]  
	then
		fullbackup="false"  
fi

# Verzeichnisrotation ausführen, Verzeichnis 0 wird dabei angelegt
verzeichnisrotation ${lokalesziel} # function verzeichnisrotation () wird aufgerufen
fehlercode=$? # returnwert der function
if [ ! $fehlercode -eq 0 ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Bei der Verzeichnisrotation trag ein Fehler auf..." | sudo tee --append $scriptlogdatei  
		echo "$fehlertext" | sudo tee --append $scriptlogdatei  
		return 1
fi

# Dateien kopieren
if [ "$fullbackup" == "true" ]  
	then
		echo "$(date +%H:%M:%S) - INFO: Vollsicherung: $windowsquelle -> ${lokalesziel}/0 ..." | sudo tee --append $scriptlogdatei  
		echo "/opt/bin/rsync $rsyncoptionen ${lokalequelle}/ ${lokalesziel}/0" | sudo tee $rsynclogdatei # Nur hier ohne append  
		sudo /opt/bin/rsync $rsyncoptionen --log-file="$rsynclogdatei" ${lokalequelle}/ ${lokalesziel}/0  
	else
		echo "$(date +%H:%M:%S) - INFO: Inkrementelle Sicherung: $windowsquelle -> ${lokalesziel}/0 ..." | sudo tee --append $scriptlogdatei  
		echo "/opt/bin/rsync $rsyncoptionen --link-dest=${lokalesziel}/1 ${lokalequelle}/ ${lokalesziel}/0" | sudo tee $rsynclogdatei # Nur hier ohne append  
		sudo /opt/bin/rsync $rsyncoptionen --log-file="$rsynclogdatei" --link-dest=${lokalesziel}/1 ${lokalequelle}/ ${lokalesziel}/0  
fi  
backupfehler=$?
rysnclog_auswerten # function rysnc_auswerten() aufrufen
fehlercode=$? # returnwert der function
if [ ! $fehlercode -eq 0 ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Kopierstatistik nicht verfügbar" | sudo tee --append $scriptlogdatei  
		neueverzeichnisse="?"  
		neuedateien="?"  
		neuedaten="?"  
	else
		if [ ! $neueverzeichnisse  -eq 1 ]
			then
				echo "$(date +%H:%M:%S) - INFO: Kopiert: $neueverzeichnisse Verzeichnisse" | sudo tee --append $scriptlogdatei  
			else
				echo "$(date +%H:%M:%S) - INFO: Kopiert: $neueverzeichnisse Verzeichnis" | sudo tee --append $scriptlogdatei  
		fi
		if [ ! $neuedateien  -eq 1 ]
			then
				echo "                          $neuedateien Dateien" | sudo tee --append $scriptlogdatei  
			else
				echo "                          $neuedateien Datei" | sudo tee --append $scriptlogdatei  
		fi
		echo "                          $neuedaten" | sudo tee --append $scriptlogdatei  
fi
if [ $backupfehler -eq 0 ] || [ $backupfehler -eq 24 ]
	then
		echo "$(date +%H:%M:%S) - INFO: Das Kopieren wurde erfolgreich beendet." | sudo tee --append $scriptlogdatei  
	else
		echo "$(date +%H:%M:%S) - ERROR: Beim Kopieren trat der Fehler $backupfehler auf." | sudo tee --append $scriptlogdatei  
fi

# Zeitstempel nach Backupjob aktualisieren
sudo touch ${lokalesziel}/0/
fehlercode=$?
if [ ! $fehlercode -eq 0 ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Der Zeitstempel von Verz. 0 konnte nicht aktualisiert werden." | sudo tee --append $scriptlogdatei  
fi

# Besitz an "Windows"-Benutzer.users übergeben 
sudo chown -R ${benutzername}.users ${lokalesziel}/0
fehlercode=$?
if [ ! $fehlercode -eq 0 ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Der Besitz für Verz. 0 konnte nicht geändert werden." | sudo tee --append $scriptlogdatei  
fi

# Quelle unmounten
echo "$(date +%H:%M:%S) - INFO: Windowsquelle trennen..." | sudo tee --append $scriptlogdatei  
sudo umount $lokalequelle
fehlercode=$?
if [ ! $fehlercode -eq 0 ]
	then
		echo "$(date +%H:%M:%S) - ERROR: Das Unmounten hat nicht funktioniert. Fehler: $fehlercode" | sudo tee --append $scriptlogdatei  
fi

# Ende
if [ $backupfehler -eq 0 ]
	then
		echo "$(date +%H:%M:%S) - INFO: Backupjob erfolgreich abgeschlossen." | sudo tee --append $scriptlogdatei  
		return 0
	else
		echo "$(date +%H:%M:%S) - INFO: Backupjob mit Fehlercode $backupfehler abgeschlossen." | sudo tee --append $scriptlogdatei  
		return 1
fi

return 0

#!/bin/bash

# Konfiguration

## Windows
benutzername="Administrator"  
kennwort="geheim"  
windowsquelle="//192.168.0.15/Freigabe/Dokumentenordner/" # mit abschließenden Slash  

## Linux
lokalesziel="/volume1/Backups/ServerA/Dokumente" # ohne abschließenden Slash  

## Log
logtitel="Server A - Dokumente" # wahlfrei, wird nur in den Loginhalten verwendet  
logprefix="server-a-dokumente" # wahlfrei, wird als Teil des Dateinamens der jobspezifischen Logdateien verwendet  

## Backup (nur wenn vom konfigurierten Standard abweichend)
#rsyncoptionen=
#versionenanzahl=