Dateibasierte RSync-Datensicherung auf externen Datenträger oder RSync kompatiblen Server: Unterschied zwischen den Versionen

Aus
Keine Bearbeitungszusammenfassung
Keine Bearbeitungszusammenfassung
(30 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
{| border="0" cellpadding="10" cellspacing="0" width="100%" style="text-align:center"
|-
|style="color:#ff0000; background-color:#ddd;"| Resultierend aus diesem Wiki ist [http://www.synology-forum.de/showthread.html?78115-Ultimate-Backup Ultimate Backup] als eigenständiges SPK entstanden !!!
|}
=Einleitung=
=Einleitung=
Mit dem Start der DSM 6 Beta und Hyper Backup wurde die dateibasierte Datensicherung bis auf weiteres auf Eis gelegt. Stattdessen werden die gesicherten Daten in einer Datenbank abgelegt, auf die man erstmal keinen direkten Zugriff hat. Zum wiederherstellen dieser Daten ist entweder ein NAS-System von Synology oder eine von Synology bereitgestellte Zusatzsoftware, dem "Hyper Backup Explorer" erforderlich, welchen es aktuell jedoch nur für Windows und Ubuntu gibt. Da in meinen Augen eine dateibasierte Datensicherung jedoch eine elementare Funktion darstellt, suchte ich nach einer Möglichkeit auch weiterhin nach diesem Prinzip meine persönlichen Daten zu sichern. Dabei lag mein Fokus auf eine einfache und handliche Funktionsweise sowie eine unkomplizierte Einrichtung über den DSM.  
 
'''Diese Anleitung zur dateibasierten RSync-Datensicherung bietet folgende Möglichkeiten...'''
 
* Quelle(n) und/oder Ziel können unverschlüsselt sein
* Quelle(n) und/oder Ziel können verschlüsselt sein
* Quelle(n) und/oder Ziel können Leerzeichen im Ordernamen enthalten
* Sicherung innerhalb eines /volume
* Sicherung zwischen internen /volumes
* Sicherung AUF lokal angeschlossene USB-/SATA-Datenträger sowie eingebundene Remote-Shares (nur unverschlüsselt)
* Sicherung VON lokal angeschlossene USB-/SATA-Datenträger AUF internes /volume oder RSync-kompatiblen Server (auch verschlüsselt möglich)
* Sicherung von einer entfernten DS oder RSync-kompatilben Server
* Sicherung auf eine entfernte DS oder RSync-kompatilben Server
* (weitere Konstellationen sind möglich, wurden jedoch nicht getestet)
 
'''Hinweis:''' Die Verschlüsselung beruht hierbei auf der von Synology verwendeten Ordnerverschlüsselung (eCryptfs). Um verschlüsselte gemeinsame Ordner einbinden zu können, wird das Key-File also der Exportschlüssel benötigt. Diesen erhält man über die DSM-Systemsteuerung/Gemeinsame Ordner.


=Anmerkung=
=Anmerkung=
Bevor ihr anfangt, nehmt bitte noch den Artikel "[[Wichtige Informationen zum Modden der Synology Stations]]" zur Kenntnis.   
Bevor ihr anfangt, nehmt bitte noch den Artikel "[[Wichtige Informationen zum Modden der Synology Stations]]" zur Kenntnis.   


'''Auch wenn dieses Script intensiv auf einwandfreie Funktion hin getestet wurde, so kann eine Fehlfunktion und demzufolge ein möglicher Datenverlust nicht ausgeschlossen werden. Daher verwendet ihr dieses Script auf eigene Gefahr. Aus diesem Grunde solltet ihr das System erstmal mit unwichtigen Testdaten auf Herz und Nieren prüfen, bevor ihr das ganze "produktiv" einsetzt. Auch ist es immer ratsam, bereits ein Backup seiner Daten in Reichweite zu haben.'''
Auch wenn dieses Script intensiv auf einwandfreie Funktion hin getestet wurde, so kann eine Fehlfunktion und demzufolge ein möglicher Datenverlust nicht ausgeschlossen werden. Aus diesem Grund solltet ihr das System erstmal mit unwichtigen Testdaten auf Herz und Nieren prüfen und sich mit der Arbeitsweise des Scripts und dessen Funktionen vertraut machen bevor ihr das ganze "produktiv" einsetzt. '''Ihr verwendet dieses Script auf eigene Gefahr.'''


=Voraussetzungen=
=Voraussetzungen=
Zeile 14: Zeile 34:
* Zum versenden einer E-Mail muss im DSM unter Hauptmenü/Systemsteuerung/Benachrichtigung eine E-Mail Adresse hinterlegt sein.
* Zum versenden einer E-Mail muss im DSM unter Hauptmenü/Systemsteuerung/Benachrichtigung eine E-Mail Adresse hinterlegt sein.
* Ein externer USB- oder SATA-Datenträger, eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk.
* Ein externer USB- oder SATA-Datenträger, eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk.
* Optional: autorun für externe Datenträger (Version 1.7)


=Erläuterungen zur Funktion und Arbeitsweise=
=Erläuterungen zur Funktion und Arbeitsweise=
Mit dem hier vorgestellten System ist sowohl eine Datensicherung von und auf einen lokal angeschlossenen USB- oder SATA-Datenträger, als auch eine Netzwerksicherung auf eine weitere Synology Diskstation bzw. einem rsync-kompatiblen Server im Netzwerk möglich (SSH-Zugang vorausgesetzt). Die gewünschte Ausgangssituation bestimmt die Art und Weise der Scriptausführung, die im folgenden schematisch dargestellt wird:


<pre>
<pre>
Diskstation
    |  |
    |  '--> Aufgabenplaner ------------------------------
    |            |                                      |
    |            '--> Such-Script -----> USB/SATA-Share ---> Ausführungs-
    |                                                    |      Script
    '----------------> USB/SATA-Share --> autorun --------    (Key-Files)
                                                                  |
                                      .---------------------------'
                                      |
                                      V
            .---------- Quelle <--- definiere ---> Ziel----------.
            |            |                          |            |
            V            '-- lokale/intern/extern --'            V
lokalisiere Quelle(n)                                    lokalisiere Ziel
  |                                                                    | 
  |                          Protokoll/E-Mail                          |
  |-->  Verschlüsselte              |              Verschlüsseltes  <--|
  |  Quelle(n) anhand der          |              Ziel anhand der    |
  |  Key-Files einhängen  <--- aushängen --->  Key-Files einhängen  |
  |          |                      |                  |              |
  |          V                      |                  V              |
  '--------------------->> !! DATENSICHERUNG !! >>---------------------'
                      |                          |
                      '--  lokale/intern/extern -'


  Aufgabenplaner (manuell/auto)
    |
    |                      .--> USB/SATA-Datenträger  --> start-rsync.sh
    |-> *search-rsync.sh ->|
    |                      '--> Diskstation SSH-Server --> start-rsync.sh
    |
    |                      .--> USB/SATA-Datenträger  --> *start-rsync.sh
    '--------------------->|
                            '--> Diskstation SSH-Server --> *start-rsync.sh
   
</pre>
</pre>


'''Der DSM-Aufgabenplaner'''


Der DSM-Aufgabenplaner ist die eigentliche Schaltzentrale dieses Systems, worüber sowohl das Such-Script (search-rsync.sh) als auch das Ausführungs-Script (start-rsync.sh) aufgerufen werden kann. Versierte Anwender können die Scripte bei Bedarf natürlich z.B. auch direkt über die Konsole aufrufen und ausführen.
'''Scriptausführung über den DSM-Aufgabenplaner'''


'''Das Such-Script (search-rsync.sh)'''
Das manuelle oder automatisierte Aufrufen von Such- oder Ausführungs-Script wird komfortabel über den DSM - Aufgabenplaner gesteuert. Das Such-Script hat dabei die Aufgabe, das Ausführungs-Script zu lokalisieren und starten. Es wird jedoch nur bei der Verwendung einer lokalen Datensicherung auf einem angeschlossenen USB-/SATA-Datenträger eingesetzt, da sich hier die Datenträgerbezeichnungen durchaus mal ändern können. Für alle andern Aufgaben wird das Such-Script nicht benötigt weshalb man das Ausführungs-Script auch direkt über den DSM-Aufgabenplaner ansprechen kann, um es manuell oder automatisiert auszuführen. Dabei befindet sich das Ausführungs-Script innerhalb eines "gemeinsamen Ordners" auf der DS, also z.B. dort, wo die interne oder externe Datensicherung später gespeichert werden soll.


Die Verwendung des Such-Scripts ist nicht zwingend erforderlich, hat aber den entscheidenen Vorteil, dass das Ausführungs-Script entweder anhand des vollständigen Script-Dateinamens, oder aber anhand einer bestimmten Zeichenkette innerhalb des Script-Dateinamens lokalisiert, ausgeführt oder bei Bedarf von der Ausführung ausgeschlossen werden kann. Der Name sowie der Speicherort des Such-Scripts ist auch erstmal nicht relevant. Es macht jedoch Sinn dem Script einen aussagekräftigen Namen zu geben und es an einem Ort auf der Synology Diskstation abzulegen, wo man es bei Bedarf z.B. mit dem DSM eigenen Text-Editor bearbeiten kann. Einzig muss darauf geachtet werden, dass das Script die Dateiendung .sh trägt und ausführbar ist.


'''Das Ausführungs-Script (start-rsync.sh)'''
'''Scriptausführung mittels "autorun"'''


Das Ausführungs-Script befindet sich entweder im Wurzel- oder auch Hauptverzeichnis eines an der DS angeschlossenen, externen USB- oder SATA-Datenträgers, oder aber innerhalb eines "gemeinsamen Ordners" auf der Synology Diskstation, dort wo die gesicherten Daten später abgelegt werden sollen. Der Standort des Scripts bestimmt also das Ziel der Datensicherung, welcher jedoch auch über die Variable $DESTINATION im Script genauer definiert werden kann.
Eine weitere Möglichkeit der Scriptausführung bietet die Verwendung von "autorun", welches angeschlossene USB-/SATA-Datenträger automatisch erkennt und ein darauf liegendes Script Namens "autorun" ausführt, sollte es im Wurzel- bzw. Hauptverzeichnis des externen Datenträgers lokalisiert werden. Dieses Verhalten machen wir uns zunutze, indem wir entweder den Inhalt unseres Ausführungs-Scriptes per Copy & Paste mit dem des "autorun" Scripts überschreiben, oder wir legen uns eine neue Datei namens "autorun" an bzw. benennen unser Script einfach nach "autorun" um und legen es auf dem externen Datenträger ab. Somit erhält man die Möglichkeit durch einfaches anstecken des USB-Sticks eine lokale, interne oder externe Datensicherung auszuführen. Ein weiterer Vorteil von "autorun" ist der Tatsache geschuldet, das sich evtl. benötigte Key-Files (also der Exportschlüssel) für das Einhängen verschlüsselter gemeinsamer Ordner am Speicherort des Ausführungs-Scripts befinden müssen. Wird der USB-Stick demnach nur für die Zeit der Datensicherung verwendet und ansonsten an einem sicheren Ort aufbewahrt, sind auch die Key-Files für diesen Zeitraum erstmal sicher.  
Auch hier ist der Name des Ausführungs-Scripts erstmal nicht relevant, es macht jedoch auch hier Sinn einen aussagekräftigen Namen zu vergeben, da unter umständen mehrere Scripte hintereinander ausgeführt werden. Einzig muss darauf geachtet werden, dass das Script die Dateiendung .sh trägt und ausführbar ist, sollte es nicht über das Such-Script ausgeführt werden.


Das Ausführungs-Script selber synchronisiert sämtliche konfigurierte Quellen mit dem Backupziel. Dabei werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) angelegt. Gelöschte Dateien in der Quelle werden im Ziel in den Ordner /@Recycle verschoben um einen möglichen Datenverlust vorzubeugen. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen.
Des Weiteren wird ein Protokoll in den Ordner /@Logfiles geschrieben welches man sich bei Bedarf auch per E-Mail zusenden lassen kann. Protokolle und zum Löschen vorgemerkte Dateien, sowie die Sicherung der DSM-Konfiguration können nach Ablauf einer einstellbaren Zeitvorgabe (in Tagen) automatisch über das System gelöscht werden. Außerdem erhält die DSM-Administratorengruppe über das Benachrichtigungssystems des DSM eine Meldung über Erfolg oder Misserfolg des Vorganges inkl. Fehler-Code. Der Fehlercode entstammt hierbei den exit-codes von rsync und kann unter dem Punkt „Externe Links“ entnommen werden. Optional kein eine optische und akustische Signalausgabe ausgewählt werden.


'''Datensicherungsvarianten'''
'''Arbeitsweise des Ausführungs-Script (start-rsync.sh)'''


Dieses System ist mittlerweile so flexibel Aufgebaut, das Quelle und Ziel einer Datensicherung individuell definiert werden kann. So kann bei einer lokalen Datensicherung zwischen Synology Diskstation und einem angeschlossenen, externen USB- oder SATA-Datenträger sowohl der Datenträger als auch die Synology Diskstation die Quelle als auch das Ziel sein. Auch eine Datensicherung innerhalb einer Synology Diskstation ist möglich z.B. um regelmäßig Daten von /volume1 nach /volume2 zu sichern. Gleiches gilt für die Datensicherung auf eine weitere Synology Diskstation oder einem rsync-kompatiblen Server über eine SSH-Verbindung. Das Ziel der Datensicherung bestimmt immer der Speicherort des Ausführungs-Script, wobei selbst hier noch das Ziel individuell angepasst werden kann.  
Das Ausführungs-Script führt neben einigen anderen Dingen die eigentliche Datensicherung aus, wobei mittels RSync sämtliche konfigurierte Quellen mit dem Ziel synchronisiert werden. Befindet sich unter den Quellen oder dem Ziel ein oder mehrere verschlüsselte gemeinsame Ordner, so können diese über das sogenanntes Key-File (der Exportschlüssel) automatisch ein- und nach dem Beenden der Datensicherung wieder automatisch ausgehangen werden. Dazu ist es jedoch erforderlich, das sich das Key-File am Speicherort des Ausführungs-Scripts befindet. Das Key-File selber wird einem beim erstellen eines verschlüsselten gemeinsamen Ordners im DSM unter Systemsteuerung/Gemeinsame Ordner zum Download angeboten, man kann sich dieses aber auch nachträglich erstellen lassen. Weiterhin muss der Benutzer im Vorfeld noch einige Parameter innerhalb des Ausführungs-Scripts definieren, dessen Funktionen durch zusätzliche Kommentare näher beschrieben werden.


Um dem Benutzer ein Feedback über Erfolg und Misserfolg der Datensicherung geben zu können wird ein Systemprotokoll erstellt, welches in einem Ordner Namens /@Logfiles abgelegt wird. Dieser Ordner liegt hierbei immer im Speicherort des Ausführungs-Scriptes. Weiterhin werden gelöschte Daten einer Quelle, im Ziel bei Bedarf in den Ordner /@Recycle verschoben, welcher sich auch im Speicherort der Datensicherung befindet. Ebenso wird hier bei Bedarf ein weiterer Ordner mit dem Namen @/DSMConfig angelegt, worin die Sicherungen der DSM-Systemkonfiguration des Systems aufbewahrt werden, von dem auch die Quellen stammen. Die Inhalte der Ordner /@Logfiles, /@Recycle sowie /@DSMConfig können nach der Angabe einer Individuellen Zeitvorgabe (in Tagen) vom System automatisch gelöscht werden um einen Speicherüberlauf zu verhindern und um die Übersicht zu bewahren.
Bei der eigentlichen Datensicherung über RSync werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) in das entsprechende Unterverzeichnis gespeichert. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen. Alle ausgeführten Schritte sowie Fehlermeldungen als auch Abbrüche werden protokolliert und teilweise über sogenannte Exit-Codes als Zahlenwert ausgegeben. Diese Exit-Codes geben weitere Auskunft über mögliche Fehlerquellen. Im Anhang unten findet man ein entsprechender Link zur Auswertung. Das Protokoll wird im oben beschriebenen Ordner /@Logfiles abgelegt und kann bei Bedarf auch als E-Mail zugestellt werden.
Weitere Einstellmöglichkeiten werden innerhalb des Scripts beschrieben und hier nicht weiter ausgeführt.


=Hinweise zum Erstellen und ausführen der Scripte=
=Hinweise zum Erstellen und ausführen der Scripte=
Zeile 57: Zeile 92:
Für die Erstellung der Scripte wurde im DSM unter dem Benutzer "admin" der DSM eigene Text-Editor, der evtl. noch über das Paketzentrum installiert werden muss, verwendet. Wichtig ist das im Editor unter "Voreinstellungen" im Reiter "Bearbeiten" als Standardcodierung "Unicode (UTF-8)" ausgewählt wird.
Für die Erstellung der Scripte wurde im DSM unter dem Benutzer "admin" der DSM eigene Text-Editor, der evtl. noch über das Paketzentrum installiert werden muss, verwendet. Wichtig ist das im Editor unter "Voreinstellungen" im Reiter "Bearbeiten" als Standardcodierung "Unicode (UTF-8)" ausgewählt wird.


Nachdem das jeweilige Script aus dem Wiki in die Zwischenablage kopiert und im Text-Editor eingefügt wurde, kann die entsprechende Datei über "Speichern unter..." am gewünschten Ort abgespeichert werden. Scripte die später über den Aufgabenplaner ausgeführt werden, müssen noch die entsprechenden Berechtigungen erhalten um das jeweilige Script "ausführbar" zu machen (In der schematischen Darstellung mit einem * gekennzeichnet). Dazu muss man in der FileStation mit einem rechtsklick auf die betreffenden Datei gehen und im Kontextmenü den Menüpunkt "Eigenschaften" auswählen. Dort angekommen wechselt man zum Reiter "Genehmigung" und weiter auf die Schaltfläche "Erweiterte Optionen" um darauffolgend den Punkt "Übernommene Genehmigungen einschließen" auszuwählen. Zum Schluss bestätigt man das Ganze mit der Schaltfläche "OK" (Die Datei sollte jetzt die Berechtigung rwxrw-rw, bzw. 766 haben)
Nachdem das jeweilige Script aus dem Wiki in die Zwischenablage kopiert und im Text-Editor eingefügt wurde, kann die entsprechende Datei über "Speichern unter..." am gewünschten Ort abgespeichert werden. Scripte die später über den Aufgabenplaner ausgeführt werden, müssen noch die entsprechenden Berechtigungen erhalten um das jeweilige Script "ausführbar" zu machen. Dazu muss man in der FileStation mit einem rechtsklick auf die betreffenden Datei gehen und im Kontextmenü den Menüpunkt "Eigenschaften" auswählen. Dort angekommen wechselt man zum Reiter "Genehmigung" und weiter auf die Schaltfläche "Erweiterte Optionen" um darauffolgend den Punkt "Übernommene Genehmigungen einschließen" auszuwählen. Zum Schluss bestätigt man das Ganze mit der Schaltfläche "OK" (Die Datei sollte jetzt die Berechtigung rwxrw-rw, bzw. 766 haben)


Nachdem die Privilegien richtig gesetzt wurden, kann das Script unter Hauptmenü/Systemsteuerung in den Aufgabenplaner aufgenommen werden, ohne die Aufgabe jedoch vorerst auszuführen. Dazu wählt man unter DSM 6 "Erstellen" --> "Geplante Aufgabe" --> "Benutzerdefiniertes Script". Im Reiter "Allgemein" kann man unter "Vorgang" einen individuellen Namen für die Aufgabe vergeben und als Benutzer sollte "root" ausgewählt werden. Bei einer Netzwerksicherung über eine SSH-Verbindung muss hier der Benutzer angegeben werden, auf dem der RSA-Key ausgestellt wurde, in unserem Fall (siehe Anleitung unten) ist das der Benutzer "root". (Nur unter dem Benutzer "root" funktioniert die Signaausgabe sowie die Sicherung der DSM-Konfiguration) Die Checkbox "Aktiviert" wird nur benötigt, sollte das Script automatisiert, also Zeitgesteuert gestartet werden. Dazu wäre dann im nächsten Schritt unter dem Reiter der "Zeitplan" zu definieren. Im Reiter "Aufgabeneinstellungen" muss jetzt noch unter dem Punkt "Befehl ausführen" der Pfad zum "Benutzerdefinierten Script" angegeben werden, also z.B. /volume1/ScriptStuff/search-rsync.sh. Nach dem Bestätigen mit "OK" wird die Aufgabe dem Aufgabenplaner hinzugefügt und kann später, falls gewünscht, nach dem Markieren der Aufgabe, über die Schaltfläche "Ausführen" manuell ausgeführt werden.
Nachdem die Privilegien richtig gesetzt wurden, kann das Script unter Hauptmenü/Systemsteuerung in den Aufgabenplaner aufgenommen werden, ohne die Aufgabe jedoch vorerst auszuführen. Dazu wählt man unter DSM 6 "Erstellen" --> "Geplante Aufgabe" --> "Benutzerdefiniertes Script". Im Reiter "Allgemein" kann man unter "Vorgang" einen individuellen Namen für die Aufgabe vergeben und als Benutzer sollte "root" ausgewählt werden. Bei einer Netzwerksicherung über eine SSH-Verbindung muss hier der Benutzer angegeben werden, auf dem der RSA-Key ausgestellt wurde, in unserem Fall (siehe Anleitung unten) ist das der Benutzer "root". (Nur unter dem Benutzer "root" funktioniert die Signaausgabe sowie die Sicherung der DSM-Konfiguration) Die Checkbox "Aktiviert" wird nur benötigt, sollte das Script automatisiert, also Zeitgesteuert gestartet werden. Dazu wäre dann im nächsten Schritt unter dem Reiter der "Zeitplan" zu definieren. Im Reiter "Aufgabeneinstellungen" muss jetzt noch unter dem Punkt "Befehl ausführen" der Pfad zum "Benutzerdefinierten Script" angegeben werden, also z.B. /volume1/ScriptStuff/search-rsync.sh. Nach dem Bestätigen mit "OK" wird die Aufgabe dem Aufgabenplaner hinzugefügt und kann später, falls gewünscht, nach dem Markieren der Aufgabe, über die Schaltfläche "Ausführen" manuell ausgeführt werden.
Zeile 91: Zeile 126:
</pre>
</pre>


=Script 2: Das ausführungs-Script "start-rsync.sh"=
=Script 2: Das Ausführungs-Script "start-rsync.sh"=
Das nächste Script mit dem beispielhaften Script-Dateinamen "start-rsync.sh", wird entweder auf den entsprechenden externen USB- oder SATA-Datenträger in dessen Wurzelverzeichnis oder aber in einen "gemeinsamen Ordner" auf der Diskstation abgelegt, auf dem die Datensicherung abgelegt werden soll.
Das Script mit dem beispielhaften Script-Dateinamen "start-rsync.sh", wird entweder auf den entsprechenden externen USB- oder SATA-Datenträger in dessen Wurzelverzeichnis oder aber in einen "gemeinsamen Ordner" auf der Diskstation abgelegt, auf dem die Datensicherung abgelegt werden soll.  
Vor der ersten Ausführung des Scriptes müssen im Vorfeld noch die Backup-Quellen (SOURCES), der Backup-Zielordner (DESTINATION) sowie ggfls. eine E-Mailadresse (EMAIL) und bei Bedarf die SSH-Verbindungsdaten eingegeben werden. Ebenso kann eine Zeitvorgabe für das Löschen alter Logdateien und zum Löschen vorgemerkter Dateien bestimmt werden, sowie eine Signalsteuerung miteinbezogen werden.
 
Es ist hierbei durchaus möglich, unterschiedliche Scripte mit unterschiedlichen Backup-Aufgaben auszuführen, die dabei auch auf unterschiedlichen Datenträgern  oder auf der DS (bei SSH-Verbindungen) abgelegt wurden. Es ist nicht zwingend erforderlich, das alle Scripte permanent Verfügbar sind. Alle gefundenen Scripte werden ausgeführt, nicht auffindbare Scripte werden übersprungen. Hierzu bitte auch die weiteren Hinweise in den Scripten beachten. Nachdem alle Parameter bestimmt wurden, kann man den Vorgang über den Aufgabenplaner ausführen lassen.  


'''start-rsync.sh'''
'''start-rsync.sh'''
Zeile 101: Zeile 133:
#!/bin/sh
#!/bin/sh


# E-Mail Adresse, SSH-Benutzer sowie Netzwerkquelle
# E-Mail Adresse
# ------------------------------------------------------------------------  
# -------------------------------------------------------------------------
# Bei Angabe einer E-Mail-Adresse, die identisch mit der bereits im DSM |
# Die E-Mail Adresse muss mit der bereits im DSM unter "Benachrichtigung" |
# unter Hauptmenue/Systemsteuerung/Benachrichtigung hinterlegten         |
# hinterlegten E-Mail-Adresse identisch sein.                            |
# E-Mail-Adresse sein muß, wird einem das Sicherungsprotokoll zugestellt |
# -------------------------------------------------------------------------
# Möchte man dies nicht, kann das Feld mit # auskommentiert werden. Es  |
EMAIL=""              # E-Mail für Zustellung des Sicherungsprotokolls
# wird dann nur ein Sicherungsprotokoll unter @Logfiles im Ziel abgelegt.|
EMAILFAIL="0"        # "0" = Sicherungsprotokoll immer senden
# Weiterhin wird hier der SSH-Benutzer, sowie die Netzwerkquelle in Form |
                      # "1" = Sicherungsprotokoll nur bei Problemen senden
# der IP eingegeben. Soll keine Datensicherung über SSH stattdinden sind |
# SSH - Verbindungsdaten
# die Felder SSHUSER und FROMSSH mit # auszukommentieren                |
# -------------------------------------------------------------------------
# Werden keine Verbindungsdaten angegeben, wird eine lokale Datensicherung|
# durchgeführt.                                                          |
# -------------------------------------------------------------------------
SSH_USER=""          # Benutzername
SSH_FROM=""          # IP-, Host- oder Domain VON entfernter Quelle AUF lokales Ziel
SSH_TO=""            # IP-, Host- oder Domain VON lokaler Quelle AUF entferntes Ziel
SSH_PORT=""          # Leer = Port 22 ansonsten gewünschten Port angeben
RSYNC_PORT=""        # Alternativer Rsync Port kann hier eingetragen werden
MAC=""                # Leer = WOL wird nicht genutzt
SLEEP="300"          # Wartezeit in Sekunden bis Remoteserver gebootet ist
                      # MAC Adresse eintragen = Server wird hochgefahren, wenn dieser ausgeschaltet ist
SHUTDOWN="0"          # "0" = Entfernter Server wird nicht heruntergefahren
                      # "1" = Entfernter Server wird heruntergefahren wenn das Backup erfolgreich war
 
# Umgang mit verschlüsselten Ordnern
# ------------------------------------------------------------------------
# Angeben, ob eingehangene verschlüsselte Ordner nach der Datensicherung |
# wieder ausgehangen werden sollen.                                     |
# ------------------------------------------------------------------------
UNMOUNT="0"          # "0" = Eingehangene Ordner werden nicht ausgehängt
                      # "1" = Quelle und Ziel werden ausgehängt
                      # "2" = Quelle wird ausgehängt
                      # "3" = Ziel wird ausgehängt
 
# Backup - Quellen
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
EMAIL="you@mail.de"
# Hier können beliebige, unverschlüsselte sowie verschlüsselte          |
#SSHUSER="root"
# Backup-Quellen einer lokalen oder entfernten DS eingetragen werden.   |
#FROMSSH="192.168.178.10"
# Zu beachten ist, das immer der vollständige Pfad ohne Angabe des      |
# entsprechenden Volume anzugeben ist. Weiterhin ist auf die            |
# Schreibweise im Beispiel zu achten, pro Zeile je eine Backupquelle.   |
# Backup - Quellen 
# ------------------------------------------------------------------------                                               
# Hier können beliebige sowie unterschiedliche Backupquellen von der DS  |
# eingetragen werden. Zu beachten ist, das immer der vollständige Pfad   |
# ohne Angabe des entsprechenden Volume anzugeben ist. Weiterhin ist auf |
# die Schreibweise im Beispiel zu achten, pro Zeile je eine Backupquelle.|                                                        |
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
SOURCES="/Musik/Alben
SOURCES="/homes/admin
        /Fotos
/ordner mit leerzeichen
/Videos/Serien
/verschlüsselter ordner"
/homes/admin"


# Backup - Ziel
# Backup - Ziel  
# ------------------------------------------------------------------------  
# Als Backupziel bedarf es nur der Angabe des Ordners, worin das Backup  |
# abgelegt werden soll. Das Script erkennt automatisch an welchen USB-  |
# oder SATA-Port sich der externe Datenträger befindet (volumeUSB1,      |
# volumeUSB2, volumeUSB3 oder volumeSATA) und fügt die Ordnerstruktur    |
# dementsprechnend dem Backupziel hinzu.                                |
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
DESTINATION="/Backup_DS"
# Wenn NOTTOSCRIPT="0"                                                  |
#  - dann entspricht TARGET einem "Unterverzeichnis" am Speicherort des  |
#    Scripts. Beisp.: volume[x]/share/[TARGET] oder bei einem            |
#    angeschlossenen USB-Datenträger: volumeUSB[x]/usbshare/[TARGET]    |
#  - Ist zusätzlich HOSTNAME="1" gesetzt, wird der Netzwerkname dem      |
#    Speicherort hinzugefügt. Beisp.: volume[x]/Share/[TARGET]/[HOSTNAME]|
#                                                                        |
# Wenn NOTTOSCRIPT="1" und Ziel ist eine Diskstation                    |
#  - dann entspricht TARGET einem "gemeinsamen Ordner" (Share) am        |
#    Speicherort des Ziel's. Beisp.: volume[x]/[TARGET]                  |
#  - Ist zusätzlich HOSTNAME="1" gesetzt, wird der Netzwerkname dem      |
#    Speicherort hinzugefügt. Beisp.: volume[x]/[TARGET]/[HOSTNAME]      |
#                                                                        |
# Wenn NOTTOSCRIPT="1" und Ziel ist ein RSync-kompatibler Server        |
#  - dann entspricht TARGET einem Ordner (Share) am Speicherort des      |
#    Ziel's. Beisp.: /[TARGET]                                          |
#  - Ist zusätzlich HOSTNAME="1" gesetzt, wird der Netzwerkname dem      |
#    Speicherort hinzugefügt. Beisp.: /[TARGET]/[HOSTNAME]              |
#-------------------------------------------------------------------------
TARGET="/RSync Backup"


FROMTHISDEVICE="0"    # "0" = Quelle ist ein gemeinsamer Ordner
                      # "1" = Quelle liegt auf externen USB/SATA-Speicher neben Script
NOTTOSCRIPT="0"        # "0" = Sicherungsziel liegt beim Script
                      # "1" = Sicherungsziel liegt im geinsamen Ordner
HOSTNAME="0"          # "0" = Sicherungsziel entspricht TARGET
                      # "1" = Sicherungsziel entspricht TARGET/HOSTNAME
AUTORUN="0"            # "0" = autorun wirft USB-Stick nicht aus
                      # "1" = autorun wirft USB-Stick aus


# Optische- sowie akustische Signalausgabe
# Optische- sowie akustische Signalausgabe
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
# 0 = Optische- sowie akustische Signalausgabe aus                      |
# Start : Status-LED wechselt von grün nach orange. Ein Signalton ertönt|
# 1 = Optische- sowie akustische Signalausgabe an                        |
# Ende  : Status-LED wechselt von orange nach grün. Ein Signalton ertönt|
#    Start     : Status-LED wechselt von grün nach orange             |
# Fehler : Status-LED wechselt von orange nach grün. 3x Signalton ertönt |
#                  und es erklinkt ein Signalton                       |
#     Erfolgreich: Status-LED wechselt von orange nach grün             |
#                  und es erklinkt ein weiterer Signalton               |
#     Fehler     : Status-LED wechselt von orange nach grün             |
#                  und es erklinkt ein 3-Facher Fehler-Signalton       |
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
SIGNAL="1"
SIGNAL="0"            # "0" = Optische- sowie akustische Signalausgabe aus
 
                      # "1" = Optische- sowie akustische Signalausgabe an


# Exportieren der DSM-Systemkonfiguration (.dss)
# Exportieren der DSM-Systemkonfiguration (.dss)
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
# Durch Eingabe einer "1" wird die DSM-Systemkonfigurartion (.dss) in den|
# Die DSM-Systemkonfigurartion (.dss) wird in den Systemordner          |
# Systemordner /@DSMConfig exportiert. Ist der Export nicht gewünscht,  |
# /@DSMConfig exportiert.                                               |
# ist hier eine "0" einzutragen.                                        |
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
DSSEXPORT="1"
DSM_EXPORT="0"        # "0" = DSM-Systemkonfiguration wird NICHT exportiert
                      # "1" = DSM-Systemkonfiguration wird exportiert


# Rotationszyklus für das Löschen von @Recycle und @Logfiles  
# Rotationszyklus für das Löschen von @Recycle und @Logfiles
#-------------------------------------------------------------------------
#-------------------------------------------------------------------------
# Zeitangabe, wann Ordner bzw. Dateien in den System-Ordnern             |
# Zeitangabe, wann Ordner bzw. Dateien in den System-Ordnern endgültig  |
# @Recycle (RECYCLE_ROTATE), @Logfiles (LOGFILES_ROTATE) sowie          |
# gelöscht werden sollen, die älter als x Tage sind.                     |
# @DSMConfig (DSMCONFIG_ROTATE) endgültig gelöscht werden sollen, die   |
# älter als x Tage sind. Bei der Angabe "0" werden keinen Ordner/Dateien |
# in dem jeweiligen Ordner @Recycle, @Logfiles oder @DSMConfig gelöscht. |
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
RECYCLE_ROTATE="90"
RECYCLE_ROTATE="90"   # @Recycle-Daten die älter als "x" Tage sind, löschen
LOGFILES_ROTATE="90"
LOGFILES_ROTATE="60"  # @Logfiles-Daten die älter als "x" Tage sind, löschen
DSMCONFIG_ROTATE="90"
DSMCONFIG_ROTATE="30" # @DSMConfig-Daten die älter als "x" Tage sind, löschen


# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
# Ab hier bitte nichts mehr ändern, wenn man nicht weiß was man tut !!!  |
# Ab hier bitte nichts mehr ändern, wenn man nicht weiß was man tut !!!  |
# ------------------------------------------------------------------------
# ------------------------------------------------------------------------
# Umgebungsvariablen definieren
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/syno/bin:/usr/syno/sbin
SCRIPTFILE="${0##*/}"
SCRIPTFILE="${0##*/}"
SCRIPTNAME="${SCRIPTFILE%.*}"
SCRIPTNAME="${SCRIPTFILE%.*}"
DATEOPT="+%Y-%m-%d_%Hh%M"
DATE=`date +%Y-%m-%d_%Hh%M`
TIMESTAMPOPT="+%d.%m.%Y%t%H:%M:%S"
 
# RSync Optionen konfigurieren
# RSync Optionen konfigurieren
#-------------------------------------------------------------------------
SYNCOPT="-ahR"
SYNCOPT="-ahR"
SSHOPT="-e ssh"
LOGSTAT="--stats"
LOGSTAT="--stats"
EXCLUDE="--exclude=/@eaDir/*** --exclude=/#recycle/*** --exclude=/#snapshot/*** --exclude=/.DS_Store/***"
EXCLUDE="--exclude=@eaDir/*** --exclude=@Logfiles/*** --exclude=#recycle/*** --exclude=#snapshot/*** --exclude=.DS_Store/***"
RECYCLE="--delete --backup --backup-dir=@Recycle/`date $DATEOPT`_$SCRIPTNAME"
RECYCLE="--delete --backup --backup-dir=@Recycle/"$DATE"_$SCRIPTNAME"


# Volume lokalisieren und Sicherungsziel definieren
# Umgebungsvariablen definieren
if find $0; then
#-------------------------------------------------------------------------
   mkdir -p "`dirname $0`$DESTINATION"
BACKIFS="$IFS"
   TARGET="`dirname $0`$DESTINATION"
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/syno/bin:/usr/syno/sbin
   # Signalausgabe - Beginn der Datensicherung
TARGET_EMPTY="/Backup_DS"
   if [ $SIGNAL -eq 1 ]; then
if [[ ${TARGET:0:1} != \/ ]] && [ -n "$TARGET" ]; then
  echo 3 >/dev/ttyS1; echo : >/dev/ttyS1
  TARGET="/$TARGET"
     sleep 2
fi
DEST="${TARGET#*/}"
TARGET_CUT="${TARGET#*/}"
TARGET_DECRYPT="${TARGET_CUT%%/*}"
TIMESTAMP=`date +%d.%m.%Y%t%H:%M:%S`
LOKALHOST="$(hostname)"
HR="------------------------------------------------------------------------------------------------"
 
# Variablen je nach Verbindung festlegen
#-------------------------------------------------------------------------
# Wenn Verbindung AUF entfernten Server... (TOSSH)
if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  if [ -n "$SSH_PORT" ]; then
    FROMSSH="ssh -p $SSH_PORT $SSH_USER@$SSH_FROM"
    SCP="scp -P $SSH_PORT"
  else
    FROMSSH="ssh $SSH_USER@$SSH_FROM"
    SCP="scp"
  fi
   if [ -n "$RSYNC_PORT" ]; then
    FROMRSYNC="ssh -p $RSYNC_PORT -l $SSH_USER"
  else
    FROMRSYNC="ssh -l $SSH_USER"
  fi
  REMOTEIP="$SSH_FROM"
# Wenn Verbindung VON entfernten Server... (FROMSSH)
elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  if [ -n "$SSH_PORT" ]; then
    TOSSH="ssh -p $SSH_PORT $SSH_USER@$SSH_TO"
    SCP="scp -P $SSH_PORT"
  else
    TOSSH="ssh $SSH_USER@$SSH_TO"
    SCP="scp"
   fi
  if [ -n "$RSYNC_PORT" ]; then
    TORSYNC="ssh -p $RSYNC_PORT -l $SSH_USER"
  else
    TORSYNC="ssh -l $SSH_USER"
   fi
  REMOTEIP="$SSH_TO"
# Wenn Verbindung lokal...
elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  FIND="find"
  SOURCE_TEST="test"
  TARGET_TEST="test"
   if [ $HOSTNAME -eq 1 ]; then
     NAME="$LOKALHOST"
   fi
   fi
 
fi
fi  


# Ordner und Datei für das Protokoll anlegen und bei Bedarf die E-Mail-Kopfdaten generieren
# DSM-Benachrichtigung: Script wird ausgeführt...
mkdir -p $TARGET/@Logfiles
#-------------------------------------------------------------------------
LOG="$TARGET/@Logfiles/`date $DATEOPT`_$SCRIPTNAME.log"
synodsmnotify @administrators "Script: $SCRIPTNAME" "Wird ausgeführt.."
 
# Speicherort des Logfiles festlegen
#-------------------------------------------------------------------------
mkdir -p `dirname $0`/@Logfiles
LOG="`dirname $0`/@Logfiles/"$DATE"_$SCRIPTNAME.log"
if test ! -d `dirname $0`/@Logfiles; then
  DSMNOTIFY="Es konnte kein @Logfiles Ordner erstellt werden!"
fi
if [ $SIGNAL -eq 1 ]; then
  echo 3 >/dev/ttyS1; echo : >/dev/ttyS1
  sleep 2
fi


if [ "$EMAIL" ]; then
# Ordner/Datei für das Protokoll anlegen und Kopfdaten generieren
#-------------------------------------------------------------------------
# E-Mail-Kopf aufbauen...
if [ -n "$EMAIL" ]; then
   echo "To: $EMAIL" > $LOG
   echo "To: $EMAIL" > $LOG
   echo "From: $EMAIL" >> $LOG
   echo "From: $EMAIL" >> $LOG
   echo "Subject: Sicherungsprotokoll vom `date $TIMESTAMPOPT` Uhr" >> $LOG
   echo "Subject: Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
   echo "" >> $LOG
   echo "" >> $LOG
   echo "Ausgefuehrtes rsync-Script: $SCRIPTFILE" >> $LOG
   echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
   echo ""
   echo "" >> $LOG; echo "$HR" >> $LOG
else
# Protokoll-Kopf aufbauen...
   echo "Sicherungsprotokoll vom `date $TIMESTAMPOPT` Uhr" > $LOG
else
   echo "Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
   echo "" >> $LOG
   echo "" >> $LOG
   echo "Ausgefuehrtes rsync-Script: $SCRIPTFILE" >> $LOG
   echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
  echo "" >> $LOG; echo "$HR" >> $LOG
fi
 
# Fehlererkennung
#-------------------------------------------------------------------------
if [ -z "$TARGET" ] && [ "$NOTTOSCRIPT" -eq 1 ]; then
  STOP="Bitte TARGET setzen oder NOTTOSCRIPT nicht setzen..." >> $LOG
fi
if [ -z "$STOP" ] && [ -n "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  STOP="Bitte nur SSH_FROM oder SSH_TO setzen!" >> $LOG
fi
if [ -z "$STOP" ] && [ -n "$SSH_TO" ] && [ -z "$TARGET" ]; then
  STOP="Bei SSH_TO muss TARGET angegeben werden!"
fi
if [ -z "$STOP" ] && [ "$NOTTOSCRIPT" -eq 1 ] && [ -z "$TARGET" ]; then
  STOP="Bei NOTTOSCRIPT=1 muss TARGET angegeben werden!"
fi
if [ -z "$STOP" ] && [ $FROMTHISDEVICE -eq 1 ] && [ -n "$SSH_FROM" ]; then
  STOP="Nur FROMTHISDEVICE setzen oder SSH_FROM !"
fi
# Ping Test
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  if [ -n "$SSH_FROM" ] || [ -n "$SSH_TO" ]; then
    ping $REMOTEIP -c 2
    ONLINE="$?"
    if [ $ONLINE -eq 0 ]; then
      echo "Remoteserver $REMOTEIP ist online." >> $LOG
    else
      if [ -z "$MAC" ]; then
        STOP="Remoteserver $REMOTEIP ist offline!" >> $LOG
      else
        echo "Remoteserver $REMOTEIP ist offline!" >> $LOG
      fi
    fi
    if [ -z "$SSH_USER" ]; then
      STOP="Bei der Netzwerksicherung bitte SSH_USER angeben." >> $LOG
    fi
  fi
fi
 
# WOL
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -n "$MAC" ] && [ $ONLINE -eq 1 ]; then
  echo "Remoteserver $REMOTEIP wird geweckt." >> $LOG
  if test -f /usr/bin/ether-wake; then
    /usr/bin/ether-wake $MAC
  elif test -f /usr/syno/sbin/synonet; then
    /usr/syno/sbin/synonet --wake $MAC eth0
  fi
  sleep $SLEEP
  ping $REMOTEIP -c 2
  ONLINE="$?"
  if [ $ONLINE -eq 0 ]; then
    echo "Remoteserver $REMOTEIP wurde hochgefahren." >> $LOG
  else
    if [ -z "$STOP" ]; then
      STOP="Remoteserver $REMOTEIP konnte nicht hochgefahren werden." >> $LOG
    fi
  fi
fi
 
# Verbindungstest (SSH_FROM)
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  if [ ! "$FROMSSH" ]; then
    STOP="Es konnte keine SSH-Verbindung zu $SSH_FROM aufgebaut werden." >> $LOG
  elif [ "$FROMSSH" ]; then
    REMOTEHOST=$($FROMSSH "echo \`hostname\`")
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
    SYNOSHARE_SOURCE="$FROMSSH"
    FIND="$FROMSSH find"
    SOURCE_TEST="$FROMSSH test"
    TARGET_TEST="test"
    if [ $HOSTNAME -eq 1 ]; then
      NAME="$REMOTEHOST"
    fi
  fi
fi
 
# Verbindungstest (SSH_TO)
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  if [ ! "$TOSSH" ]; then
    STOP="Es konnte keine SSH-Verbindung zu $SSH_TO aufgebaut werden." >> $LOG
  elif [ "$TOSSH" ]; then
    REMOTEHOST=$($TOSSH "echo \`hostname\`")
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
    SYNOSHARE_TARGET="$TOSSH"
    FIND="$TOSSH find"
    SOURCE_TEST="test"
    TARGET_TEST="$TOSSH test"
    if [ $HOSTNAME -eq 1 ]; then
      NAME="$LOKALHOST"
    fi
  fi
fi
 
# Verbindungstest ob Quelle bzw. Ziel eine Diskstation ist oder nicht
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -n "$SSH_FROM" ] || [ -n "$SSH_TO" ]; then
  if $SOURCE_TEST -d /usr/syno/synoman; then
    SOURCE_PATH="/volume*"
    SOURCEDS="1"
    echo "Quellserver ist eine DS" >> $LOG
  elif $SOURCE_TEST ! -d /usr/syno/synoman; then
    SOURCEDS="0"
    echo "Quellserver ist keine DS" >> $LOG
  fi
 
  if $TARGET_TEST -d /usr/syno/synoman; then
    TARGET_PATH="/volume*"
    TARGETDS="1"
    echo "Zielserver ist eine DS" >> $LOG
  elif $TARGET_TEST ! -d /usr/syno/synoman; then
    TARGETDS="0"
    echo "Zielserver ist keine DS" >> $LOG
  fi
 
elif [ -z "$STOP" ]; then
  SOURCE_PATH="/volume*"
  TARGET_PATH="/volume*"
  SOURCEDS="1"
  TARGETDS="1"
fi
 
if [ $FROMTHISDEVICE -eq 1 ]; then
  SOURCE_PATH="/volume*/*share"
fi
 
# Zielordner checken
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
IFS="
"
  TARGET_ESCAPE=$(echo $TARGET | sed -e 's/ /\\ /g')
  TARGET_DECRYPT_ESCAPE=$(echo $TARGET_DECRYPT | sed -e 's/ /\\ /g')
  IFS="$BACKIFS"
  if [ -n "$SSH_TO" ]; then
    DEST_DECRYPT="$TARGET_DECRYPT_ESCAPE"
  else
    DEST_DECRYPT="$TARGET_DECRYPT"
  fi
  if [ "$NOTTOSCRIPT" -eq 1 ] || [ -n "$SSH_TO" ]; then
    if $TARGET_TEST ! -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST -d $TARGET_PATH/"$DEST_DECRYPT"; then
      echo "Zielordner $TARGET_DECRYPT wurde lokalisiert..." >> $LOG
    elif $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST -d $TARGET_PATH/"$DEST_DECRYPT"; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT bereits eingehangen..." >> $LOG
    elif $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST ! -d $TARGET_PATH/"$DEST_DECRYPT"; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Zielordner einbinden
      if test -f `dirname $0`/"$TARGET_DECRYPT".key; then
        echo "$TARGET_DECRYPT.key gefunden" >> $LOG
        echo "Verschluesselter Zielordner $TARGET_DECRYPT wird eingehangen..."  >> $LOG
        KEYFILEDEST=$(ecryptfs-unwrap-passphrase `dirname $0`/"$TARGET_DECRYPT".key "\$1\$5YN01o9y")
        $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_mount "$DEST_DECRYPT" "$KEYFILEDEST" >> $LOG
        sleep 20
        if $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST -d $TARGET_PATH/"$DEST_DECRYPT"; then
          echo "Verschluesselter Zielordner $TARGET_DECRYPT wurde eingehangen..."  >> $LOG
        elif $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST ! -d $TARGET_PATH/"$DEST_DECRYPT"; then
          echo "Verschluesselter Zielordner $TARGET_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
        fi
      else
        echo "Kein Keyfile fuer $TARGET_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden!"
      fi
    fi
    if $TARGET_TEST ! -d $TARGET_PATH/"$DEST_DECRYPT"; then
      if [ -z "$STOP" ]; then
        STOP="Zielordner /$TARGET_DECRYPT nicht gefunden!"
      fi
    fi
  fi
fi
 
# Quellordner checken
#-------------------------------------------------------------------------
IFS="
"
for SHARE in $SOURCES; do
  if [[ ${SHARE:0:1} != \/ ]] ; then
    SHARE="/$SHARE"
  fi
  SHARE_ESCAPE=$(echo $SHARE | sed -e 's/ /\\ /g')
  SHARE_CUT="${SHARE#*/}"
  SHARE_DECRYPT="${SHARE_CUT%%/*}"
  SHARE_DECRYPT_ESCAPE=$(echo $SHARE_DECRYPT | sed -e 's/ /\\ /g')
  IFS="$BACKIFS"
  if [ -n "$SSH_FROM" ]; then
    SOURCE_DECRYPT="$SHARE_DECRYPT_ESCAPE"
  else
    SOURCE_DECRYPT="$SHARE_DECRYPT"
  fi
  if $SOURCE_TEST ! -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
    echo "Quellordner $SHARE_DECRYPT wurde lokalisiert..." >> $LOG
  elif $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
    echo "Verschluesselter Quellordner $SHARE_DECRYPT bereits eingehangen..." >> $LOG
  elif $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST ! -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
    echo "Verschluesselter Quellordner $SHARE_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Quellordner einbinden
    if test -f `dirname $0`/"$SHARE_DECRYPT".key; then
      echo "$SHARE_DECRYPT.key gefunden" >> $LOG
      echo "Verschluesselter Quellordner $SHARE_DECRYPT wird eingehangen..."  >> $LOG
      KEYFILESHARE=$(ecryptfs-unwrap-passphrase `dirname $0`/"$SHARE_DECRYPT".key "\$1\$5YN01o9y")
      $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_mount "$SHARE_DECRYPT" "$KEYFILESHARE" >> $LOG
      sleep 20
      if $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
        echo "Verschluesselter Quellordner $SHARE_DECRYPT wurde eingehangen..."  >> $LOG
      elif $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST ! -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
        echo "Verschluesselter Quellordner $SHARE_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
      fi
    else
      STOP="Kein Keyfile fuer $SHARE_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden! Datensicherung ABGEBROCHEN..."
    fi
  fi
done
 
# Ziel definieren
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  if [ -n "$SSH_TO" ] && [ -n "$TARGET" ]; then
    DEST_FULL=$($TOSSH "echo $TARGET_PATH/$TARGET_DECRYPT_ESCAPE")
    DEST_CUT="${DEST_FULL#*/}"
    DEST_VOL="${DEST_CUT%%/*}"
    if [ $TARGETDS -eq 1 ]; then
      DESTTARGET="/$DEST_VOL$TARGET_ESCAPE"
    else
      DESTTARGET="$TARGET_ESCAPE"
    fi
    if [ $HOSTNAME -eq 1 ]; then
      DESTINATION="$DESTTARGET/$NAME"
    else
      DESTINATION="$DESTTARGET"
    fi
  elif [ -z "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 0 ] && [ -z "$TARGET" ]; then
    if [ $HOSTNAME -eq 1 ]; then
      DESTINATION="`dirname $0`$TARGET_EMPTY/$NAME"
    else
      DESTINATION="`dirname $0`$TARGET_EMPTY"
    fi
  elif [ -z "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 1 ] && [ -n "$TARGET" ]; then
    DEST_FULL=$(echo $TARGET_PATH/"$TARGET_DECRYPT")
    DEST_CUT="${DEST_FULL#*/}"
    DEST_VOL="${DEST_CUT%%/*}"
    if [ -n "$TARGETDS" ]; then
      DESTTARGET="/$DEST_VOL$TARGET"
  else
      DESTTARGET="$TARGET"
  fi
  if [ $HOSTNAME -eq 1 ]; then
    DESTINATION="$DESTTARGET/$NAME"
  else
    DESTINATION="$DESTTARGET"
  fi
  elif [ -z "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 0 ]; then
    if [ $HOSTNAME -eq 1 ]; then
      DESTINATION="`dirname $0`$TARGET/$NAME"
    else
      DESTINATION="`dirname $0`$TARGET"
    fi
  fi
  mkdir -p "$DESTINATION"
  if [ -n "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 0 ]; then
    STOP="Bei SSH_TO muss NOTTOSCRIPT gesetzt werden!" >> $LOG
  elif [ -n "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 1 ] && [ -n "$TARGET" ]; then
    if $TARGET_TEST -d $TARGET_PATH/$TARGET_DECRYPT_ESCAPE; then
      $TOSSH mkdir -p "$DESTINATION"
    fi
  fi
fi
fi


# rsync - Befehl ausführen sowie protokollieren
# Check ob Zielordner erstellt wurde bzw. vorhanden war.
for SHARE in $SOURCES; do   
if $TARGET_TEST ! -d "$DESTINATION"; then
  if [ -z "$STOP" ]; then
    STOP="Zielordner $TARGET konnte nicht erstellt werden bzw. ist nicht vorhanden !"
  fi
fi


  # SSH-Verbindung prüfen. Falls erfolgreich --> Netzwerksicherung
echo "" >> $LOG
   if [ "$SSHUSER" ] && [ "$FROMSSH" ] && ssh $SSHUSER@$FROMSSH; then  
echo "$HR" >> $LOG
echo "" >> $LOG
# Beginn der RSync-Datensicherung
#--------------------------------------------------------------------------
IFS="
"
for SHARE in $SOURCES; do
   if [ -z "$STOP" ]; then
     echo "" >> $LOG
     echo "" >> $LOG
     echo "--> Zusammenfassung: $SHARE nach $TARGET" >> $LOG
     if [[ ${SHARE:0:1} != \/ ]] ; then
               
      SHARE="/$SHARE"
     if ssh $SSHUSER@$FROMSSH test -d /volume*$SHARE; then
    fi
      echo "   SSH-Verbindungsaufbau erfolgreich. Quellordner $SHARE wurde lokalisiert. Start..." >> $LOG
     SHARE_ESCAPE=$(echo $SHARE | sed -e 's/ /\\ /g')
      rsync $SYNCOPT $SSHOPT $SSHUSER@$FROMSSH:/volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$TARGET" >> $LOG 2>&1 
    SHARE_CUT="${SHARE#*/}"
    SHARE_DECRYPT="${SHARE_CUT%%/*}"
    IFS="$BACKIFS"
    unset FORERROR
    if [ -n "$SSH_FROM" ]; then
      SOURCE="$SHARE_ESCAPE"
     else
     else
       echo "   SSH-Verbindungsaufbau erfolgreich. Der Quellordner $SHARE konnte jedoch NICHT lokalisiert werden!" >> $LOG
    SOURCE="$SHARE"
       echo "   Bitte kontrollieren Sie ihre Einstellungen. Verschluesselte Ordner muessen eingehangen sein." >> $LOG
    fi
     fi    
 
 
  if $SOURCE_TEST ! -d $SOURCE_PATH"$SOURCE"; then
    ERROR="Quellordner $SHARE nicht erreichbar..." >> $LOG
    FORERROR="1"
  elif $SOURCE_TEST -d $SOURCE_PATH"$SOURCE"; then
    echo "Quellordner $SHARE erreichbar." >> $LOG
  fi
  if [ $FROMTHISDEVICE -eq 1 ] && [ -z "$SSH_FROM" ]; then
    SOURCE="`dirname $0`$SHARE"
  elif [ $FROMTHISDEVICE -eq 0 ] && [ -z "$SSH_FROM" ]; then
    SOURCE="$SHARE"
  fi
 
  if [ -z "$STOP" ] && [ -z "$FORERROR" ]; then
# SSH-SSH_FROM RSync-Datensicherung VON einer entfernten DS oder komp. Server
#--------------------------------------------------------------------------
    if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ] && [ -n "$DESTINATION" ]; then
       echo "$HR" >> $LOG
      echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
      echo "$HR" >> $LOG
      if [ $SOURCEDS -eq 1 ]; then
        rsync -e "$FROMRSYNC" $SYNCOPT $SSH_FROM:/volume*"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
        RSYNC_EXIT="$?"
        elif [ $SOURCEDS -ne 1 ]; then
          rsync -e "$FROMRSYNC" $SYNCOPT $SSH_FROM:"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
          RSYNC_EXIT="$?"
        fi
# SSH-SSH_TO RSync-Datensicherung AUF eine entfernte DS oder komp. Server
#--------------------------------------------------------------------------
      elif [ -n "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -n "$DESTINATION" ]; then
        echo "$HR" >> $LOG
        echo "Starte Datensicherung: $LOKALHOST$SHARE nach $DESTINATION" >> $LOG
        echo "$HR" >> $LOG
        if [ $SOURCEDS -eq 1 ] && [ $FROMTHISDEVICE -ne 1 ]; then
          rsync -e "$TORSYNC" $SYNCOPT /volume*"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE $SSH_TO:"$DESTINATION" >> $LOG
          RSYNC_EXIT="$?"
          elif [ $SOURCEDS -ne 1 ] || [ $FROMTHISDEVICE -eq 1 ]; then
            rsync -e "$TORSYNC" $SYNCOPT "$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE $SSH_TO:"$DESTINATION" >> $LOG
            RSYNC_EXIT="$?"
          fi
# RSync- Lokale Datensicherung auf Volume, USB- oder SATA-Datentr�ger
#-------------------------------------------------------------------------
       elif [ -z "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -n "$DESTINATION" ]; then
        echo "$HR" >> $LOG
        echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
        echo "$HR" >> $LOG
        if [ $SOURCEDS -eq 1 ] && [ $FROMTHISDEVICE -ne 1 ]; then
          rsync $SYNCOPT /volume*"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
          RSYNC_EXIT="$?"
          elif [ $SOURCEDS -ne 1 ] || [ $FROMTHISDEVICE -eq 1 ]; then
            rsync $SYNCOPT "$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
            RSYNC_EXIT="$?"
          fi
        fi
        echo "" >> $LOG
        if [ $RSYNC_EXIT -ne 0 ]; then
          RSYNC_CODE="$RSYNC_EXIT"
        fi
     fi
   fi
   fi
   
  # SSH-Verbindung prüfen. Falls NICHT erfolgreich --> lokale Sicherung...
  if [ ! "$SSHUSER" ] && [ ! "$FROMSSH" ]; then
    echo "" >> $LOG
    echo "--> Zusammenfassung: $SHARE nach $TARGET" >> $LOG
   
    if [ -d /volume*"$SHARE" ]; then
      echo "    Der lokale Quellordner $SHARE wurde lokalisiert. Start..." >> $LOG
      rsync $SYNCOPT /volume*$SHARE $LOGSTAT $EXCLUDE $RECYCLE "$TARGET" >> $LOG 2>&1
    else 
      echo "    Der lokale Quellordner $SHARE konnte NICHT lokalisiert werden!" >> $LOG
      echo "    Bitte kontrollieren Sie ihre Einstellungen. Verschluesselte Ordner muessen eingehangen sein." >> $LOG
    fi 
   
  fi 
done
done


# SSH-Verbindung prüfen. Falls Fehlerhaft --> Abbruch
# RSync Exit-Code = Fehlermeldung
if [ "$SSHUSER" ] || [ "$FROMSSH" ] && ! ssh $SSHUSER@$FROMSSH; then
#-------------------------------------------------------------------------
  echo "" >> $LOG
if [ -n "$RSYNC_CODE" ]; then
   echo "   Es konnte keine SSH-Verbindung hergestellt werden. Bitte kontrollieren sie Ihre Einstellungen" >> $LOG
# Exit-Code: Entfernter Server ausgeschaltet?
fi 
  if [ $RSYNC_CODE -eq 43 ]; then
 
    echo "RSync-Code $RSYNC_CODE: Entfernte DS oder RSync komp. Server nicht Online? Bitte RSYNC Port kontrollieren!" >> $LOG
# DSM-Systemkonfiguration exportieren
# Exit-Code: DSL-Verbindung getrennt?
if [ $DSSEXPORT -eq 1 ]; then
   elif [ $RSYNC_CODE -eq 255 ]; then
  mkdir -p $TARGET/@DSMConfig
    echo "RSync-Code $RSYNC_CODE: Bitte Internetverbindung oder RSYNC Port kontrollieren!" >> $LOG
   synoconfbkp export --filepath $TARGET/@DSMConfig/DSMConfig_`date $DATEOPT`.dss
# Exit-Code ausgeben...
  elif [ $RSYNC_CODE -ne 0 ]; then
    echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
   fi
fi
fi


# rsync - Ausführung auswerten und Ergebnis anhand der "exit codes" ausgeben
# RSync Exit-Code = Erfolgreich bzw. Unvollständig
if [ $? -eq 0 ]; then
#-------------------------------------------------------------------------
   echo "" >> $LOG
if [ -z "$RSYNC_CODE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
   echo "rsync-Datensicherung erfolgreich abgeschlossen. Sicherungsziel: $TARGET" >> $LOG
   echo "$HR" >> $LOG
   DSMNOTIFY="rsync-Datensicherung erfolgreich abgeschlossen. Sicherungsziel: $TARGET"
   echo "RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION" >> $LOG
   # Signalausgabe - Ende der Datensicherung
   if [ -z "$DSMNOTIFY" ]; then
    DSMNOTIFY="RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION"
   fi
# Signalausgabe - Datensicherung erfolgreich
   if [ $SIGNAL -eq 1 ]; then
   if [ $SIGNAL -eq 1 ]; then
     echo 3 >/dev/ttyS1; echo 8 >/dev/ttyS1
     echo 3 >/dev/ttyS1; echo 8 >/dev/ttyS1
     sleep 2    
     sleep 2
   fi
   fi
 
# RSync Exit-Code = Fehlermeldung
elif [ $? -ne 0 ]; then
elif [ $RSYNC_CODE -ne 0 ] || [ -n "$STOP" ] || [ -n "$ERROR" ]; then
   echo "" >> $LOG
   echo "$HR" >> $LOG
   echo "rsync-Datensicherung nach $TARGET fehlgeschlagen - Fehler $?" >> $LOG
   echo "RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Sicherungsziel: $DESTINATION" >> $LOG
   DSMNOTIFY="rsync-Datensicherung nach $TARGET fehlgeschlagen - Fehler $?"
   if [ -z "$DSMNOTIFY" ]; then
   # Signalausgabe - Fehlermeldung
    DSMNOTIFY="RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Bitte Protokoll prüfen!"
   fi
# Signalausgabe - Datensicherung fehlgeschlagen
   if [ $SIGNAL -eq 1 ]; then
   if [ $SIGNAL -eq 1 ]; then
     echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 8 >/dev/ttyS1
     echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 8 >/dev/ttyS1
   fi
   fi
fi
echo "$HR" >> $LOG; echo "" >> $LOG
if [ -n "$STOP" ]; then
  echo "FEHLER: $STOP" >> $LOG
fi
if [ -n "$ERROR" ]; then
  echo "FEHLER: $ERROR" >> $LOG
fi
fi


# DSM-Systemkonfiguration exportieren
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ "$DSM_EXPORT" -eq 1 ] && [ -z "$RSYNC_CODE" ]; then
  if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ] && [ -n "$SOURCEDS" ]; then
    $FROMSSH /usr/syno/bin/synoconfbkp export --filepath DSMConfig_TEMP.dss
    mkdir -p "$DESTINATION"/@DSMConfig
    $SCP -r $SSH_USER@$SSH_FROM:DSMConfig_TEMP.dss "$DESTINATION"/@DSMConfig/DSMConfig_"$DATE"_$REMOTEHOST.dss
    $FROMSSH rm -rf DSMConfig_TEMP.dss
    echo  "Sicherung der DSM-Systemkonfiguration von $REMOTEHOST erfolgreich zu $LOKALHOST kopiert.." >> $LOG
    echo "" >> $LOG
  elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
    synoconfbkp export --filepath `dirname $0`/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    $TOSSH mkdir -p "$DESTINATION"/@DSMConfig
    $SCP -r `dirname $0`/@DSMConfig/*.dss $SSH_USER@$SSH_TO:"$DESTINATION"/@DSMConfig/
    rm -rf `dirname $0`/@DSMConfig
    echo  "Sicherung der DSM-Systemkonfiguration von $LOKALHOST erfolgreich zu $REMOTEHOST kopiert.." >> $LOG
    echo "" >> $LOG
  elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
    mkdir -p "$DESTINATION"/@DSMConfig
    synoconfbkp export --filepath "$DESTINATION"/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    echo  "Lokale Sicherung der DSM-Systemkonfiguration erfolgreich." >> $LOG
    echo "" >> $LOG
  fi
fi
# Rotationszyklus für das Löschen von @Recycle, @Logfiles und @DSMConfig
#-------------------------------------------------------------------------
# Dateien im Ordner @Recycle die älter als x Tage sind, löschen.
# Dateien im Ordner @Recycle die älter als x Tage sind, löschen.
if [ -d $TARGET/@Recycle/ ]; then  
if [ -z "$STOP" ] && [ -z "$RSYNC_CODE" ]; then
 
  if $TARGET_TEST -d "$DESTINATION"/@Recycle/; then
  if [ $RECYCLE_ROTATE -ne 0 ]; then
    if [ -z "$STOP" ] && [ -n "$RECYCLE_ROTATE" ] && [ -z "$ERROR" ]; then
    find $TARGET/@Recycle -type d -mtime +$RECYCLE_ROTATE -exec rm -rd {} \;
      $FIND "$DESTINATION"/@Recycle/* -type d -mtime +$RECYCLE_ROTATE -exec rm -rf {} \;
      echo  "HINWEIS: Daten aus dem Ordner /@Recycle, die mehr als $RECYCLE_ROTATE Tage alt waren, wurden geloescht." >> $LOG
      echo "" >> $LOG
   fi
   fi
  fi
# Dateien im Ordner @Logfiles die älter als x Tage sind, löschen.
  if $TARGET_TEST -d `dirname $0`/@Logfiles/; then
    if [ -z "$STOP" ] && [ -n "$LOGFILES_ROTATE" ] && [ -z "$ERROR" ]; then
      find `dirname $0`/@Logfiles -name "*.log" -type f -mtime +$LOGFILES_ROTATE -exec rm {} \;
      echo  "HINWEIS: Daten aus dem Ordner /@Logfiles, die mehr als $LOGFILES_ROTATE Tage alt waren, wurden geloescht." >> $LOG
      echo "" >> $LOG
    fi
  fi
# Dateien im Ordner @DSMConfig die älter als x Tage sind, löschen.
  if  $TARGET_TEST -d "$DESTINATION"/@DSMConfig/; then
    if [ -z "$STOP" ] && [ -n "$DSMCONFIG_ROTATE" ] && [ -z "$ERROR" ]; then
      $FIND "$DESTINATION"/@DSMConfig -name "*.dss" -type f -mtime +$DSMCONFIG_ROTATE -exec rm {} \;
      echo  "HINWEIS: Daten aus dem Ordner /@DSMConfig, die mehr als $DSMCONFIG_ROTATE Tage alt waren, wurden geloescht." >> $LOG
      echo "" >> $LOG
    fi
  fi
fi


# Verschlüsselte Shares wieder aushängen..
#-------------------------------------------------------------------------
if [ $UNMOUNT -ne 0 ] && [ -n "$TARGETDS" ]; then
  if [ $UNMOUNT -ne 2 ]; then
IFS="
"
    TARGET_ESCAPE=$(echo $TARGET | sed -e 's/ /\\ /g')
    TARGET_DECRYPT_ESCAPE=$(echo $TARGET_DECRYPT | sed -e 's/ /\\ /g')
    IFS="$BACKIFS"
    if [ -n "$SSH_TO" ]; then
      DEST_DECRYPT="$TARGET_DECRYPT_ESCAPE"
    else
      DEST_DECRYPT="$TARGET_DECRYPT"
    fi
    if $TARGET_TEST -d /volume*/@"$DEST_DECRYPT"@ && $TARGET_TEST -d /volume*/"$DEST_DECRYPT"; then
      echo "Ziel: $TARGET_DECRYPT wurde ausgehangen" >> $LOG
      $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_unmount "$DEST_DECRYPT" >> $LOG
      sleep 10
    fi
  fi
fi
fi
if [ $UNMOUNT -ne 0 ] && [ -n "$SOURCEDS" ]; then
  if [ $UNMOUNT -ne 3 ]; then
IFS="
"
  for SHARE in $SOURCES; do
    SHARE_ESCAPE=$(echo $SHARE | sed -e 's/ /\\ /g')
    SHARE_CUT="${SHARE#*/}"
    SHARE_DECRYPT="${SHARE_CUT%%/*}"
    SHARE_DECRYPT_ESCAPE=$(echo $SHARE_DECRYPT | sed -e 's/ /\\ /g')
    IFS="$BACKIFS"
    if [ -n "$SSH_FROM" ]; then
      SOURCE_DECRYPT="$SHARE_DECRYPT_ESCAPE"
    else
      SOURCE_DECRYPT="$SHARE_DECRYPT"
    fi
    if $SOURCE_TEST -d /volume*/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d /volume*/"$SOURCE_DECRYPT"; then
      echo "Quelle: $SHARE_DECRYPT wurde ausgehangen" >> $LOG
      $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_unmount "$SHARE_DECRYPT" >> $LOG
      sleep 10
    fi
  done
  fi
fi
unset KEYFILEPW


# Dateien im Ordner @RLogfiles die älter als x Tage sind, löschen.
# Entfernten Server herunterfahren
if [ -d $TARGET/@Logfiles/ ]; then
#-------------------------------------------------------------------------
 
if [ $SHUTDOWN -ne 0 ] && [ -z "$RSYNC_CODE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
   if [ $LOGFILES_ROTATE -ne 0 ]; then
   if [ -n "$SSH_FROM" ]; then
     find $TARGET/@Logfiles -name "*.log" -type f -mtime +$LOGFILES_ROTATE -exec rm {} \;
     $FROMSSH poweroff
    echo "Remoteserver $SSH_FROM wird heruntergefahren." >> $LOG
  elif [ -n "$SSH_TO" ]; then
    $TOSSH poweroff
    echo "Remoteserver $SSH_TO wird heruntergefahren." >> $LOG
   fi
   fi
 
fi
fi


# Dateien im Ordner @DSMConfig die älter als x Tage sind, löschen.
# Benachrichtigung an die DSM-Administratorengruppe sowie E-Mail senden
if [ -d $TARGET/@DSMConfig/ ]; then
#-------------------------------------------------------------------------
 
if [ -n "$DSMNOTIFY" ]; then
  if [ $DSMCONFIG_ROTATE -ne 0 ]; then
  synodsmnotify @administrators "Script: $SCRIPTNAME" "$DSMNOTIFY"
    find $TARGET/@DSMConfig -name "*.log" -type f -mtime +$DSMCONFIG_ROTATE -exec rm {} \;
fi
if [ -n "$EMAIL" ]; then
  if [ "$EMAILFAIL" -eq 1 ] && [ -z "$RSYNC_CODE" ] || [ -n "$STOP" ] || [ -n "$ERROR" ]; then
    ssmtp $EMAIL < $LOG
  elif [ "$EMAILFAIL" -eq 0 ]; then
    ssmtp $EMAIL < $LOG
   fi
   fi
fi


# Script beenden...
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -z "$RSYNC_CODE" ] && [ -z "$ERROR" ] && [ "$AUTORUN" -eq 1 ]; then
  exit 100
else
  exit $?
fi
fi


# Benachrichtigung an die DSM-Administratorengruppe senden
synodsmnotify @administrators "Script: $SCRIPTNAME" "$DSMNOTIFY"
# Sicherungsprotokoll als E-Mail versenden (oder als Datei im Backupziel einsehen)
if [ "$EMAIL" ]; then
  ssmtp $EMAIL < $LOG
fi
</pre>
</pre>


=Erstellen eines RSA-Keys für den Aufbau einer SSH-Verbindung=
=Erstellen eines RSA-Keys für den Aufbau einer SSH-Verbindung=
Es soll eine dateibasierte Datensicherung mittels rsync von Diskstation "A" (Produktivsystem) auf Diskstation "B" (Backupsystem) angelegt werden. Dabei übernimmt das Backupsystem die Aufgabe des Servers, worüber der Verbindungsaufbau und der eigentliche Sicherungsvorgang initiiert wird. Das Produktivsystem übernimmt somit die Aufgabe des Client und muß dem ganzen Vorgang nur zustimmen. Um dies zu ermöglichen muß im Vorfeld ein RSA-Schlüssel auf dem Backupsystem erzeugt und dem Produktivsystem der öffentliche Schlüssel mitgeteilt werden, um so den automatischen Verbindungsaufbau per SSH zu ermöglichen. Nachdem die SSH-Verbindung erfolgreich aufgebaut wurde, wird der eigentliche rsync-Befehl abgesetzt und somit die Datensicherung ausgelöst.
Es soll eine dateibasierte Datensicherung mittels RSync von Diskstation "A" (Produktivsystem) auf Diskstation "B" (Backupsystem) angelegt werden. Dabei übernimmt das Backupsystem die Aufgabe des Servers, worüber der Verbindungsaufbau und der eigentliche Sicherungsvorgang initiiert wird. Das Produktivsystem übernimmt somit die Aufgabe des Client und muß dem ganzen Vorgang nur zustimmen. Um dies zu ermöglichen muß im Vorfeld ein RSA-Schlüssel auf dem Backupsystem erzeugt und dem Produktivsystem der öffentliche Schlüssel mitgeteilt werden, um so den automatischen Verbindungsaufbau per SSH zu ermöglichen. Nachdem die SSH-Verbindung erfolgreich aufgebaut wurde, wird der eigentliche rsync-Befehl abgesetzt und somit die Datensicherung ausgelöst. Um auch in die Gegenrichtung sichern zu können, muss die RSA-Key Einrichtung dementsprechend gedreht werden, so das am Ende sowohl Diskstation "A" als auch Diskstation "B" Quelle als auch Ziel der Datensicherung darstellen können.


Im folgenden werden alle Einstellungen für den Benutzer '''root''' getroffen, da nur unter diesem Benutzer die Signalausgabe als auch das Sichern der DSM-Konfiguration funktioniert. Wer hier lieber als "admin" oder vielleicht sogar als eingeschränkter Benutzer "rsync" arbeiten möchte, muss nachfolgend an den entsprechenden Stellen den gewünschten Benutzernamen einsetzen. Das hier verwendete Homeverzeichnis des Benutzer "root" wird im folgenden nur in dessen Kurzform mit ~/ angesprochen, wobei hier immer auf /root verwiesen wird. Alle anderen Benutzerkonten befinden sich im Homeverzeichnis /home/[BENUTZERNAME] bzw. richtigerweise unter /var/services/homes/[BENUTZERNAME].
Im folgenden werden alle Einstellungen für den Benutzer '''root''' getroffen, da nur unter diesem Benutzer die Signalausgabe als auch das Sichern der DSM-Konfiguration funktioniert. Wer hier lieber als "admin" oder vielleicht sogar als eingeschränkter Benutzer "rsync" arbeiten möchte, muss nachfolgend an den entsprechenden Stellen den gewünschten Benutzernamen einsetzen. Das hier verwendete Homeverzeichnis des Benutzer "root" wird im folgenden nur in dessen Kurzform mit ~/ angesprochen, wobei hier immer auf /root verwiesen wird. Alle anderen Benutzerkonten befinden sich im Homeverzeichnis /home/[BENUTZERNAME] bzw. richtigerweise unter /var/services/homes/[BENUTZERNAME].
Zeile 423: Zeile 980:
<pre>$ exit</pre>
<pre>$ exit</pre>


=Realese-Notes (Stand: 28.03.2016)=
=Release Notes=
*Mit diesem Update wurde die Möglichkeit geschaffen, auf eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk per SSH-Verbindung  zu sichern.
*Dafür wurde dieses Wiki vollständig Überarbeitet, umgeschrieben und ergänzt um die neuen Funktionen zu beschreiben.
*Eine Anleitung zur Erstellung eines RSA-Keys um den Zugriff per SSH zu ermöglichen wurde hinzugefügt.
 
 
'''Realese-Notes (Stand: 19.03.2016)'''
*Ab sofort kann man die DSM-Systemkonfiguration exportieren. Diese wird auf Wunsch in den Systemordner @DSMConfig nach dem Muster DSMConfig_2016-03-19_22h00.dss abgelegt. Weiterhin kann auch hier über eine Zeitvorgabe (in Tagen) eingestellt werden, wie lange die exportieren Systemkonfigurationen erhalten bleiben sollen.
*Eine weitere Variante des Such-Scriptes wurde veröffentlicht um die Suchbedingungen individueller anpassen zu können.
 
 
'''Release-Notes (Stand: 18.03.2016)'''
*Die chronologische Speicherung innerhalb der Systemordner @Recycle und @Logfiles kann jetzt unabhängig von einander über eine individuell einstellbare Zeitvorgabe in Tagen begrenzt werden. Daten, die älter sind als die eingestellten Zeitvorgaben, werden "unwiderruflich" gelöscht.
*Die eigentliche Befehlszeile des rsync-Aufrufes im Script wurde neu strukturiert, indem die Ausführungsoptionen in Variablen ausgelagert, gruppiert und optimiert wurden. Das erleichtert eine Anpassung des rsync-Aufruf an die gewünschten Bedürfnisse.
*Verbesserung der Anzeige und Ausgabe von Datum und Uhrzeit sowie des Script-Dateinamens
*@Logfile Protokolle werden jetzt nach dem Muster 2016-03-18_21h37_[SCRIPT-NAME].log abgelegt
*@Recycle Ordner werden jetzt nach dem Muster 2016-03-18_21h37_[SCRIPT-NAME] abgelegt
*In den Benachrichtigungen und Protokollen wird stets der ausgeführte Script-Dateiname angegeben. 
*Viele kleinere Script-Verbesserungen- und Anpassungen


'''Release Notes vom 10.05.2016'''
(Knapp 150 Zeilen Script-Code wurden seit dem letzen Update hinzugefügt.)
* Es wurde eine neue Variable (MAC) geschaffen um entfernte Server per WOL zu starten.
* Es wurde eine neue Variable (SLEEP) geschaffen um dem entfernten Server ein Zeitfenster zum starten zu geben.
* Es wurde eine neue Variable (SHUTDOWN) geschaffen um entfernte Server auszuschalten.
* Anhand der drei grade genannten Variablen können demnach entfernte Server per WOL geweckt, die eigentliche Datensicherung ausgeführt werden um im Anschluss den entfernten Server bei Bedarf wieder auszuschalten.
* Es wurde eine neue Variable (FROMTHISDEVICE) geschaffen um Inhalte eines USB/SATA-Datenräger auf eine Diskstation oder einem entfernten, RSync-kompatiblen Server zu sichern.
* Quellen und Ziel können ab sofort auch Leerzeichen enthalten.


'''Release-Notes (Stand: 11.03.2016)'''
'''Release Notes vom 01.05.2016'''
* Anstatt wie bisher nur eine Backup-Aufgabe ausführen zu können, kann jetzt eine beliebige Anzahl von Backup-Aufgaben auf unterschiedlichen Datenträgern ausgeführt werden.
* Es wurde eine neue Variable (SSH_PORT) geschaffen um einen abweichenden SSH-Port angeben zu können.
* Die Script-Dateinamen („search-rsync.sh“ sowie „rsync.sh“) können ab sofort individuell vergeben werden, einzig die Endung .sh muss erhalten bleiben.
* Es wurde eine neue Variable (RSYNC_PORT) geschaffen um einen abweichenden RSync-Port angeben zu können.
* Beim Definieren der Backup-Quellen (SOURCES), müssen keine Volume-Bezeichnungen mehr mitgeführt werden. Es reicht demnach der Pfad eines gemeinsamen Ordners, also z.B. /music/Alben/International
* Es wurde eine neue Variable (EMAILFAIL) geschaffen um nur bei einer Störung per E-Mail benachrichtigt zu werden.
* Über das Benachrichtigungssystems des DSM wird jetzt auch der ausgeführte Script-Dateiname angezeigt.
* Alle "schaltbaren" Benutzer-Variablen wurden nach dem Schema "0" = aus / "1" = an umstrukturiert. Ursprünglich wurde der Wert bei Zustand "aus" einfach leer gelassen, also "".  
* Es wurde eine optische- sowie akustische Signalausgabe eingebaut, die optional ausgewählt werden kann.  
* Kommentare im Benutzer-Eingabebereich des Scripts wurden optimiert.
* Kleinere Script-Verbesserungen und Beseitigung von Schönheitsfehlern.
* Neben der bereits funktionierenden Sicherung von und auf eine weitere Diskstation funktioniert jetzt auch das Sichern von und auf einen RSync-kompatible Server. Das Script erkennt hierbei automatisch ob es sich um eine Diskstation oder einen RSync-kompatiblen Server handelt und passt die Sicherungs-Pfade dementsprechend an. Diskstation arbeiten i.d.R. mit einem /volume[x], RSync-kompatible Server tun das in der Regel nicht.
* Viele weitere Detailverbesserungen, die hier nicht alle aufgeführt werden können. Nur so viel... das Script ist um weitere 100 Zeilen Scipt-Code gewachsen.


=Externe Links=
=Externe Links=

Version vom 24. Juli 2016, 14:05 Uhr

Resultierend aus diesem Wiki ist Ultimate Backup als eigenständiges SPK entstanden !!!


Einleitung

Diese Anleitung zur dateibasierten RSync-Datensicherung bietet folgende Möglichkeiten...

  • Quelle(n) und/oder Ziel können unverschlüsselt sein
  • Quelle(n) und/oder Ziel können verschlüsselt sein
  • Quelle(n) und/oder Ziel können Leerzeichen im Ordernamen enthalten
  • Sicherung innerhalb eines /volume
  • Sicherung zwischen internen /volumes
  • Sicherung AUF lokal angeschlossene USB-/SATA-Datenträger sowie eingebundene Remote-Shares (nur unverschlüsselt)
  • Sicherung VON lokal angeschlossene USB-/SATA-Datenträger AUF internes /volume oder RSync-kompatiblen Server (auch verschlüsselt möglich)
  • Sicherung von einer entfernten DS oder RSync-kompatilben Server
  • Sicherung auf eine entfernte DS oder RSync-kompatilben Server
  • (weitere Konstellationen sind möglich, wurden jedoch nicht getestet)

Hinweis: Die Verschlüsselung beruht hierbei auf der von Synology verwendeten Ordnerverschlüsselung (eCryptfs). Um verschlüsselte gemeinsame Ordner einbinden zu können, wird das Key-File also der Exportschlüssel benötigt. Diesen erhält man über die DSM-Systemsteuerung/Gemeinsame Ordner.

Anmerkung

Bevor ihr anfangt, nehmt bitte noch den Artikel "Wichtige Informationen zum Modden der Synology Stations" zur Kenntnis.

Auch wenn dieses Script intensiv auf einwandfreie Funktion hin getestet wurde, so kann eine Fehlfunktion und demzufolge ein möglicher Datenverlust nicht ausgeschlossen werden. Aus diesem Grund solltet ihr das System erstmal mit unwichtigen Testdaten auf Herz und Nieren prüfen und sich mit der Arbeitsweise des Scripts und dessen Funktionen vertraut machen bevor ihr das ganze "produktiv" einsetzt. Ihr verwendet dieses Script auf eigene Gefahr.

Voraussetzungen

  • Umgang mit dem DSM Aufgabenplaner
  • Umgang mit einem Editor seiner Wahl (z.B. Notepad++ oder dem DSM Text-Editor)
  • Grundkenntnisse im Umgang mit Shell-Scripten
  • Umgang mit der Konsole (bei Verwendung des SSH-Zuganges)
  • Zum versenden einer E-Mail muss im DSM unter Hauptmenü/Systemsteuerung/Benachrichtigung eine E-Mail Adresse hinterlegt sein.
  • Ein externer USB- oder SATA-Datenträger, eine weitere Synology Diskstation oder einen rsync-kompatiblen Server im Netzwerk.
  • Optional: autorun für externe Datenträger (Version 1.7)

Erläuterungen zur Funktion und Arbeitsweise

 Diskstation
    |   |
    |   '--> Aufgabenplaner ------------------------------
    |             |                                      |
    |             '--> Such-Script -----> USB/SATA-Share ---> Ausführungs-
    |                                                    |       Script
    '----------------> USB/SATA-Share --> autorun --------    (Key-Files)
                                                                   |
                                       .---------------------------'
                                       |
                                       V
            .---------- Quelle <--- definiere ---> Ziel----------.
            |            |                          |            |
            V            '-- lokale/intern/extern --'            V
lokalisiere Quelle(n)                                     lokalisiere Ziel
  |                                                                    |  
  |                          Protokoll/E-Mail                          |
  |-->  Verschlüsselte              |              Verschlüsseltes  <--|
  |  Quelle(n) anhand der           |              Ziel anhand der     |
  |  Key-Files einhängen   <--- aushängen --->   Key-Files einhängen   |
  |          |                      |                   |              |
  |          V                      |                   V              |
  '--------------------->> !! DATENSICHERUNG !! >>---------------------'
                       |                          |
                       '--  lokale/intern/extern -'


Scriptausführung über den DSM-Aufgabenplaner

Das manuelle oder automatisierte Aufrufen von Such- oder Ausführungs-Script wird komfortabel über den DSM - Aufgabenplaner gesteuert. Das Such-Script hat dabei die Aufgabe, das Ausführungs-Script zu lokalisieren und starten. Es wird jedoch nur bei der Verwendung einer lokalen Datensicherung auf einem angeschlossenen USB-/SATA-Datenträger eingesetzt, da sich hier die Datenträgerbezeichnungen durchaus mal ändern können. Für alle andern Aufgaben wird das Such-Script nicht benötigt weshalb man das Ausführungs-Script auch direkt über den DSM-Aufgabenplaner ansprechen kann, um es manuell oder automatisiert auszuführen. Dabei befindet sich das Ausführungs-Script innerhalb eines "gemeinsamen Ordners" auf der DS, also z.B. dort, wo die interne oder externe Datensicherung später gespeichert werden soll.


Scriptausführung mittels "autorun"

Eine weitere Möglichkeit der Scriptausführung bietet die Verwendung von "autorun", welches angeschlossene USB-/SATA-Datenträger automatisch erkennt und ein darauf liegendes Script Namens "autorun" ausführt, sollte es im Wurzel- bzw. Hauptverzeichnis des externen Datenträgers lokalisiert werden. Dieses Verhalten machen wir uns zunutze, indem wir entweder den Inhalt unseres Ausführungs-Scriptes per Copy & Paste mit dem des "autorun" Scripts überschreiben, oder wir legen uns eine neue Datei namens "autorun" an bzw. benennen unser Script einfach nach "autorun" um und legen es auf dem externen Datenträger ab. Somit erhält man die Möglichkeit durch einfaches anstecken des USB-Sticks eine lokale, interne oder externe Datensicherung auszuführen. Ein weiterer Vorteil von "autorun" ist der Tatsache geschuldet, das sich evtl. benötigte Key-Files (also der Exportschlüssel) für das Einhängen verschlüsselter gemeinsamer Ordner am Speicherort des Ausführungs-Scripts befinden müssen. Wird der USB-Stick demnach nur für die Zeit der Datensicherung verwendet und ansonsten an einem sicheren Ort aufbewahrt, sind auch die Key-Files für diesen Zeitraum erstmal sicher.


Arbeitsweise des Ausführungs-Script (start-rsync.sh)

Das Ausführungs-Script führt neben einigen anderen Dingen die eigentliche Datensicherung aus, wobei mittels RSync sämtliche konfigurierte Quellen mit dem Ziel synchronisiert werden. Befindet sich unter den Quellen oder dem Ziel ein oder mehrere verschlüsselte gemeinsame Ordner, so können diese über das sogenanntes Key-File (der Exportschlüssel) automatisch ein- und nach dem Beenden der Datensicherung wieder automatisch ausgehangen werden. Dazu ist es jedoch erforderlich, das sich das Key-File am Speicherort des Ausführungs-Scripts befindet. Das Key-File selber wird einem beim erstellen eines verschlüsselten gemeinsamen Ordners im DSM unter Systemsteuerung/Gemeinsame Ordner zum Download angeboten, man kann sich dieses aber auch nachträglich erstellen lassen. Weiterhin muss der Benutzer im Vorfeld noch einige Parameter innerhalb des Ausführungs-Scripts definieren, dessen Funktionen durch zusätzliche Kommentare näher beschrieben werden.

Um dem Benutzer ein Feedback über Erfolg und Misserfolg der Datensicherung geben zu können wird ein Systemprotokoll erstellt, welches in einem Ordner Namens /@Logfiles abgelegt wird. Dieser Ordner liegt hierbei immer im Speicherort des Ausführungs-Scriptes. Weiterhin werden gelöschte Daten einer Quelle, im Ziel bei Bedarf in den Ordner /@Recycle verschoben, welcher sich auch im Speicherort der Datensicherung befindet. Ebenso wird hier bei Bedarf ein weiterer Ordner mit dem Namen @/DSMConfig angelegt, worin die Sicherungen der DSM-Systemkonfiguration des Systems aufbewahrt werden, von dem auch die Quellen stammen. Die Inhalte der Ordner /@Logfiles, /@Recycle sowie /@DSMConfig können nach der Angabe einer Individuellen Zeitvorgabe (in Tagen) vom System automatisch gelöscht werden um einen Speicherüberlauf zu verhindern und um die Übersicht zu bewahren.

Bei der eigentlichen Datensicherung über RSync werden die Ordnerpfade relativ, nach dem jeweiligen Volume (1,2,3,4….) in das entsprechende Unterverzeichnis gespeichert. Systemorder wie z.B. /@eaDIR, /#recycle, /#snapshot und /.DS_Store werden von der Synchronisation ausgeschlossen. Alle ausgeführten Schritte sowie Fehlermeldungen als auch Abbrüche werden protokolliert und teilweise über sogenannte Exit-Codes als Zahlenwert ausgegeben. Diese Exit-Codes geben weitere Auskunft über mögliche Fehlerquellen. Im Anhang unten findet man ein entsprechender Link zur Auswertung. Das Protokoll wird im oben beschriebenen Ordner /@Logfiles abgelegt und kann bei Bedarf auch als E-Mail zugestellt werden.

Weitere Einstellmöglichkeiten werden innerhalb des Scripts beschrieben und hier nicht weiter ausgeführt.

Hinweise zum Erstellen und ausführen der Scripte

Die hier verwendeten Script-Dateinamen dienen nur der Veranschaulichung und können, unter Beachtung einiger Rahmenbedingungen nach Belieben verändert werden. Für die Erstellung der Scripte wurde im DSM unter dem Benutzer "admin" der DSM eigene Text-Editor, der evtl. noch über das Paketzentrum installiert werden muss, verwendet. Wichtig ist das im Editor unter "Voreinstellungen" im Reiter "Bearbeiten" als Standardcodierung "Unicode (UTF-8)" ausgewählt wird.

Nachdem das jeweilige Script aus dem Wiki in die Zwischenablage kopiert und im Text-Editor eingefügt wurde, kann die entsprechende Datei über "Speichern unter..." am gewünschten Ort abgespeichert werden. Scripte die später über den Aufgabenplaner ausgeführt werden, müssen noch die entsprechenden Berechtigungen erhalten um das jeweilige Script "ausführbar" zu machen. Dazu muss man in der FileStation mit einem rechtsklick auf die betreffenden Datei gehen und im Kontextmenü den Menüpunkt "Eigenschaften" auswählen. Dort angekommen wechselt man zum Reiter "Genehmigung" und weiter auf die Schaltfläche "Erweiterte Optionen" um darauffolgend den Punkt "Übernommene Genehmigungen einschließen" auszuwählen. Zum Schluss bestätigt man das Ganze mit der Schaltfläche "OK" (Die Datei sollte jetzt die Berechtigung rwxrw-rw, bzw. 766 haben)

Nachdem die Privilegien richtig gesetzt wurden, kann das Script unter Hauptmenü/Systemsteuerung in den Aufgabenplaner aufgenommen werden, ohne die Aufgabe jedoch vorerst auszuführen. Dazu wählt man unter DSM 6 "Erstellen" --> "Geplante Aufgabe" --> "Benutzerdefiniertes Script". Im Reiter "Allgemein" kann man unter "Vorgang" einen individuellen Namen für die Aufgabe vergeben und als Benutzer sollte "root" ausgewählt werden. Bei einer Netzwerksicherung über eine SSH-Verbindung muss hier der Benutzer angegeben werden, auf dem der RSA-Key ausgestellt wurde, in unserem Fall (siehe Anleitung unten) ist das der Benutzer "root". (Nur unter dem Benutzer "root" funktioniert die Signaausgabe sowie die Sicherung der DSM-Konfiguration) Die Checkbox "Aktiviert" wird nur benötigt, sollte das Script automatisiert, also Zeitgesteuert gestartet werden. Dazu wäre dann im nächsten Schritt unter dem Reiter der "Zeitplan" zu definieren. Im Reiter "Aufgabeneinstellungen" muss jetzt noch unter dem Punkt "Befehl ausführen" der Pfad zum "Benutzerdefinierten Script" angegeben werden, also z.B. /volume1/ScriptStuff/search-rsync.sh. Nach dem Bestätigen mit "OK" wird die Aufgabe dem Aufgabenplaner hinzugefügt und kann später, falls gewünscht, nach dem Markieren der Aufgabe, über die Schaltfläche "Ausführen" manuell ausgeführt werden.

Script 1: Das Such-Script "search-rsync.sh"

Da es mehrere Ansätze für die Suche gibt, kann man sich hier Weitere Suchscriptvarianten anschauen und sich die für sich passenden Möglichkeit auswählen.

search-rsync.sh

#!/bin/sh

# Zeichenkette für Script-Dateinamen definieren
# ------------------------------------------------------------------------
# Es ist nicht erforderlich, den kompletten Script-Dateinamen anzugeben. |
# Es reicht die Eingabe einer Zeichenkette, die in jedem auszuführenden  |
# Script-Dateinamen enthalten sein muss.                                 |
# Beispiele für die Zeichenkette: "local" = local_Backup_Filme.sh        |
# local_Filme.sh oder auch Filme_local_sichern.sh                        |
#-------------------------------------------------------------------------
SCRIPT_STRING="start"

# ------------------------------------------------------------------------
# Ab hier bitte nichts mehr ändern                                       |
# ------------------------------------------------------------------------

for SCRIPT in /volume*/*share/*$SCRIPT_STRING*.sh
  do
    if [ -f $SCRIPT ]; then
    sh $SCRIPT
    fi
  done

Script 2: Das Ausführungs-Script "start-rsync.sh"

Das Script mit dem beispielhaften Script-Dateinamen "start-rsync.sh", wird entweder auf den entsprechenden externen USB- oder SATA-Datenträger in dessen Wurzelverzeichnis oder aber in einen "gemeinsamen Ordner" auf der Diskstation abgelegt, auf dem die Datensicherung abgelegt werden soll.

start-rsync.sh

#!/bin/sh

# E-Mail Adresse
# -------------------------------------------------------------------------
# Die E-Mail Adresse muss mit der bereits im DSM unter "Benachrichtigung" |
# hinterlegten E-Mail-Adresse identisch sein.                             |
# -------------------------------------------------------------------------
EMAIL=""              # E-Mail für Zustellung des Sicherungsprotokolls
EMAILFAIL="0"         # "0" = Sicherungsprotokoll immer senden
                      # "1" = Sicherungsprotokoll nur bei Problemen senden
# SSH - Verbindungsdaten
# -------------------------------------------------------------------------
# Werden keine Verbindungsdaten angegeben, wird eine lokale Datensicherung|
# durchgeführt.                                                           |
# -------------------------------------------------------------------------
SSH_USER=""           # Benutzername
SSH_FROM=""           # IP-, Host- oder Domain VON entfernter Quelle AUF lokales Ziel
SSH_TO=""             # IP-, Host- oder Domain VON lokaler Quelle AUF entferntes Ziel
SSH_PORT=""           # Leer = Port 22 ansonsten gewünschten Port angeben
RSYNC_PORT=""         # Alternativer Rsync Port kann hier eingetragen werden
MAC=""                # Leer = WOL wird nicht genutzt
SLEEP="300"           # Wartezeit in Sekunden bis Remoteserver gebootet ist
                      # MAC Adresse eintragen = Server wird hochgefahren, wenn dieser ausgeschaltet ist
SHUTDOWN="0"          # "0" = Entfernter Server wird nicht heruntergefahren
                      # "1" = Entfernter Server wird heruntergefahren wenn das Backup erfolgreich war

# Umgang mit verschlüsselten Ordnern
# ------------------------------------------------------------------------
# Angeben, ob eingehangene verschlüsselte Ordner nach der Datensicherung |
# wieder ausgehangen werden sollen.                                      |
# ------------------------------------------------------------------------
UNMOUNT="0"           # "0" = Eingehangene Ordner werden nicht ausgehängt
                      # "1" = Quelle und Ziel werden ausgehängt
                      # "2" = Quelle wird ausgehängt
                      # "3" = Ziel wird ausgehängt

# Backup - Quellen
# ------------------------------------------------------------------------
# Hier können beliebige, unverschlüsselte sowie verschlüsselte           |
# Backup-Quellen einer lokalen oder entfernten DS eingetragen werden.    |
# Zu beachten ist, das immer der vollständige Pfad ohne Angabe des       |
# entsprechenden Volume anzugeben ist. Weiterhin ist auf  die            |
# Schreibweise im Beispiel zu achten, pro Zeile je eine Backupquelle.    |
# ------------------------------------------------------------------------
SOURCES="/homes/admin
/ordner mit leerzeichen
/verschlüsselter ordner"

# Backup - Ziel
# ------------------------------------------------------------------------
# Wenn NOTTOSCRIPT="0"                                                   |
#  - dann entspricht TARGET einem "Unterverzeichnis" am Speicherort des  |
#    Scripts. Beisp.: volume[x]/share/[TARGET] oder bei einem            |
#    angeschlossenen USB-Datenträger: volumeUSB[x]/usbshare/[TARGET]     |
#  - Ist zusätzlich HOSTNAME="1" gesetzt, wird der Netzwerkname dem      |
#    Speicherort hinzugefügt. Beisp.: volume[x]/Share/[TARGET]/[HOSTNAME]|
#                                                                        |
# Wenn NOTTOSCRIPT="1" und Ziel ist eine Diskstation                     |
#  - dann entspricht TARGET einem "gemeinsamen Ordner" (Share) am        |
#    Speicherort des Ziel's. Beisp.: volume[x]/[TARGET]                  |
#  - Ist zusätzlich HOSTNAME="1" gesetzt, wird der Netzwerkname dem      |
#    Speicherort hinzugefügt. Beisp.: volume[x]/[TARGET]/[HOSTNAME]      |
#                                                                        |
# Wenn NOTTOSCRIPT="1" und Ziel ist ein RSync-kompatibler Server         |
#  - dann entspricht TARGET einem Ordner (Share) am Speicherort des      |
#    Ziel's. Beisp.: /[TARGET]                                           |
#  - Ist zusätzlich HOSTNAME="1" gesetzt, wird der Netzwerkname dem      |
#    Speicherort hinzugefügt. Beisp.: /[TARGET]/[HOSTNAME]               |
#-------------------------------------------------------------------------
TARGET="/RSync Backup"

FROMTHISDEVICE="0"     # "0" = Quelle ist ein gemeinsamer Ordner
                       # "1" = Quelle liegt auf externen USB/SATA-Speicher neben Script
NOTTOSCRIPT="0"        # "0" = Sicherungsziel liegt beim Script
                       # "1" = Sicherungsziel liegt im geinsamen Ordner
HOSTNAME="0"           # "0" = Sicherungsziel entspricht TARGET
                       # "1" = Sicherungsziel entspricht TARGET/HOSTNAME
AUTORUN="0"            # "0" = autorun wirft USB-Stick nicht aus
                       # "1" = autorun wirft USB-Stick aus

# Optische- sowie akustische Signalausgabe
#-------------------------------------------------------------------------
# Start  : Status-LED wechselt von grün nach orange. Ein Signalton ertönt|
# Ende   : Status-LED wechselt von orange nach grün. Ein Signalton ertönt|
# Fehler : Status-LED wechselt von orange nach grün. 3x Signalton ertönt |
#-------------------------------------------------------------------------
SIGNAL="0"             # "0" = Optische- sowie akustische Signalausgabe aus
                       # "1" = Optische- sowie akustische Signalausgabe an

# Exportieren der DSM-Systemkonfiguration (.dss)
#-------------------------------------------------------------------------
# Die DSM-Systemkonfigurartion (.dss) wird in den Systemordner           |
# /@DSMConfig exportiert.                                                |
#-------------------------------------------------------------------------
DSM_EXPORT="0"         # "0" = DSM-Systemkonfiguration wird NICHT exportiert
                       # "1" = DSM-Systemkonfiguration wird exportiert

# Rotationszyklus für das Löschen von @Recycle und @Logfiles
#-------------------------------------------------------------------------
# Zeitangabe, wann Ordner bzw. Dateien in den System-Ordnern endgültig   |
# gelöscht werden sollen, die älter als x Tage sind.                     |
# ------------------------------------------------------------------------
RECYCLE_ROTATE="90"   # @Recycle-Daten die älter als "x" Tage sind, löschen
LOGFILES_ROTATE="60"  # @Logfiles-Daten die älter als "x" Tage sind, löschen
DSMCONFIG_ROTATE="30" # @DSMConfig-Daten die älter als "x" Tage sind, löschen

# ------------------------------------------------------------------------
# Ab hier bitte nichts mehr ändern, wenn man nicht weiß was man tut !!!  |
# ------------------------------------------------------------------------
SCRIPTFILE="${0##*/}"
SCRIPTNAME="${SCRIPTFILE%.*}"
DATE=`date +%Y-%m-%d_%Hh%M`
# RSync Optionen konfigurieren
#-------------------------------------------------------------------------
SYNCOPT="-ahR"
LOGSTAT="--stats"
EXCLUDE="--exclude=@eaDir/*** --exclude=@Logfiles/*** --exclude=#recycle/*** --exclude=#snapshot/*** --exclude=.DS_Store/***"
RECYCLE="--delete --backup --backup-dir=@Recycle/"$DATE"_$SCRIPTNAME"

# Umgebungsvariablen definieren
#-------------------------------------------------------------------------
BACKIFS="$IFS"
PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/syno/bin:/usr/syno/sbin
TARGET_EMPTY="/Backup_DS"
if [[ ${TARGET:0:1} != \/ ]] && [ -n "$TARGET" ]; then
  TARGET="/$TARGET"
fi
DEST="${TARGET#*/}"
TARGET_CUT="${TARGET#*/}"
TARGET_DECRYPT="${TARGET_CUT%%/*}"
TIMESTAMP=`date +%d.%m.%Y%t%H:%M:%S`
LOKALHOST="$(hostname)"
HR="------------------------------------------------------------------------------------------------"

# Variablen je nach Verbindung festlegen
#-------------------------------------------------------------------------
# Wenn Verbindung AUF entfernten Server... (TOSSH)
if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  if [ -n "$SSH_PORT" ]; then
    FROMSSH="ssh -p $SSH_PORT $SSH_USER@$SSH_FROM"
    SCP="scp -P $SSH_PORT"
  else
    FROMSSH="ssh $SSH_USER@$SSH_FROM"
    SCP="scp"
  fi
  if [ -n "$RSYNC_PORT" ]; then
    FROMRSYNC="ssh -p $RSYNC_PORT -l $SSH_USER"
  else
    FROMRSYNC="ssh -l $SSH_USER"
  fi
  REMOTEIP="$SSH_FROM"
# Wenn Verbindung VON entfernten Server... (FROMSSH)
elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  if [ -n "$SSH_PORT" ]; then
    TOSSH="ssh -p $SSH_PORT $SSH_USER@$SSH_TO"
    SCP="scp -P $SSH_PORT"
  else
    TOSSH="ssh $SSH_USER@$SSH_TO"
    SCP="scp"
  fi
  if [ -n "$RSYNC_PORT" ]; then
    TORSYNC="ssh -p $RSYNC_PORT -l $SSH_USER"
  else
    TORSYNC="ssh -l $SSH_USER"
  fi
  REMOTEIP="$SSH_TO"
# Wenn Verbindung lokal...
elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  FIND="find"
  SOURCE_TEST="test"
  TARGET_TEST="test"
  if [ $HOSTNAME -eq 1 ]; then
    NAME="$LOKALHOST"
  fi
fi

# DSM-Benachrichtigung: Script wird ausgeführt...
#-------------------------------------------------------------------------
synodsmnotify @administrators "Script: $SCRIPTNAME" "Wird ausgeführt.."

# Speicherort des Logfiles festlegen
#-------------------------------------------------------------------------
mkdir -p `dirname $0`/@Logfiles
LOG="`dirname $0`/@Logfiles/"$DATE"_$SCRIPTNAME.log"
if test ! -d `dirname $0`/@Logfiles; then
  DSMNOTIFY="Es konnte kein @Logfiles Ordner erstellt werden!"
fi
if [ $SIGNAL -eq 1 ]; then
  echo 3 >/dev/ttyS1; echo : >/dev/ttyS1
  sleep 2
fi

# Ordner/Datei für das Protokoll anlegen und Kopfdaten generieren
#-------------------------------------------------------------------------
# E-Mail-Kopf aufbauen...
if [ -n "$EMAIL" ]; then
  echo "To: $EMAIL" > $LOG
  echo "From: $EMAIL" >> $LOG
  echo "Subject: Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
  echo "" >> $LOG
  echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
  echo "" >> $LOG; echo "$HR" >> $LOG
# Protokoll-Kopf aufbauen...
else
  echo "Sicherungsprotokoll vom $TIMESTAMP Uhr" >> $LOG
  echo "" >> $LOG
  echo "Ausgefuehrtes RSync-Script: $SCRIPTFILE" >> $LOG
  echo "" >> $LOG; echo "$HR" >> $LOG
fi

# Fehlererkennung
#-------------------------------------------------------------------------
if [ -z "$TARGET" ] && [ "$NOTTOSCRIPT" -eq 1 ]; then
  STOP="Bitte TARGET setzen oder NOTTOSCRIPT nicht setzen..." >> $LOG
fi
if [ -z "$STOP" ] && [ -n "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  STOP="Bitte nur SSH_FROM oder SSH_TO setzen!" >> $LOG
fi
if [ -z "$STOP" ] && [ -n "$SSH_TO" ] && [ -z "$TARGET" ]; then
  STOP="Bei SSH_TO muss TARGET angegeben werden!"
fi
if [ -z "$STOP" ] && [ "$NOTTOSCRIPT" -eq 1 ] && [ -z "$TARGET" ]; then
  STOP="Bei NOTTOSCRIPT=1 muss TARGET angegeben werden!"
fi
if [ -z "$STOP" ] && [ $FROMTHISDEVICE -eq 1 ] && [ -n "$SSH_FROM" ]; then
  STOP="Nur FROMTHISDEVICE setzen oder SSH_FROM !"
fi
# Ping Test
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  if [ -n "$SSH_FROM" ] || [ -n "$SSH_TO" ]; then
    ping $REMOTEIP -c 2
    ONLINE="$?"
    if [ $ONLINE -eq 0 ]; then
      echo "Remoteserver $REMOTEIP ist online." >> $LOG
    else
      if [ -z "$MAC" ]; then
        STOP="Remoteserver $REMOTEIP ist offline!" >> $LOG
      else
        echo "Remoteserver $REMOTEIP ist offline!" >> $LOG
      fi
    fi
    if [ -z "$SSH_USER" ]; then
      STOP="Bei der Netzwerksicherung bitte SSH_USER angeben." >> $LOG
    fi
  fi
fi

# WOL
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -n "$MAC" ] && [ $ONLINE -eq 1 ]; then
  echo "Remoteserver $REMOTEIP wird geweckt." >> $LOG
  if test -f /usr/bin/ether-wake; then
    /usr/bin/ether-wake $MAC
  elif test -f /usr/syno/sbin/synonet; then
    /usr/syno/sbin/synonet --wake $MAC eth0
  fi
  sleep $SLEEP
  ping $REMOTEIP -c 2
  ONLINE="$?"
  if [ $ONLINE -eq 0 ]; then
    echo "Remoteserver $REMOTEIP wurde hochgefahren." >> $LOG
  else
    if [ -z "$STOP" ]; then
      STOP="Remoteserver $REMOTEIP konnte nicht hochgefahren werden." >> $LOG
    fi
  fi
fi

# Verbindungstest (SSH_FROM)
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
  if [ ! "$FROMSSH" ]; then
    STOP="Es konnte keine SSH-Verbindung zu $SSH_FROM aufgebaut werden." >> $LOG
  elif [ "$FROMSSH" ]; then
    REMOTEHOST=$($FROMSSH "echo \`hostname\`")
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
    SYNOSHARE_SOURCE="$FROMSSH"
    FIND="$FROMSSH find"
    SOURCE_TEST="$FROMSSH test"
    TARGET_TEST="test"
    if [ $HOSTNAME -eq 1 ]; then
      NAME="$REMOTEHOST"
    fi
  fi
fi

# Verbindungstest (SSH_TO)
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
  if [ ! "$TOSSH" ]; then
    STOP="Es konnte keine SSH-Verbindung zu $SSH_TO aufgebaut werden." >> $LOG
  elif [ "$TOSSH" ]; then
    REMOTEHOST=$($TOSSH "echo \`hostname\`")
    echo "SSH-Verbindung zu $REMOTEHOST aufgebaut." >> $LOG
    SYNOSHARE_TARGET="$TOSSH"
    FIND="$TOSSH find"
    SOURCE_TEST="test"
    TARGET_TEST="$TOSSH test"
    if [ $HOSTNAME -eq 1 ]; then
      NAME="$LOKALHOST"
    fi
  fi
fi

# Verbindungstest ob Quelle bzw. Ziel eine Diskstation ist oder nicht
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -n "$SSH_FROM" ] || [ -n "$SSH_TO" ]; then
  if $SOURCE_TEST -d /usr/syno/synoman; then
    SOURCE_PATH="/volume*"
    SOURCEDS="1"
    echo "Quellserver ist eine DS" >> $LOG
  elif $SOURCE_TEST ! -d /usr/syno/synoman; then
    SOURCEDS="0"
    echo "Quellserver ist keine DS" >> $LOG
  fi

  if $TARGET_TEST -d /usr/syno/synoman; then
    TARGET_PATH="/volume*"
    TARGETDS="1"
    echo "Zielserver ist eine DS" >> $LOG
  elif $TARGET_TEST ! -d /usr/syno/synoman; then
    TARGETDS="0"
    echo "Zielserver ist keine DS" >> $LOG
  fi

elif [ -z "$STOP" ]; then
  SOURCE_PATH="/volume*"
  TARGET_PATH="/volume*"
  SOURCEDS="1"
  TARGETDS="1"
fi

if [ $FROMTHISDEVICE -eq 1 ]; then
  SOURCE_PATH="/volume*/*share"
fi

# Zielordner checken
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
IFS="
"
  TARGET_ESCAPE=$(echo $TARGET | sed -e 's/ /\\ /g')
  TARGET_DECRYPT_ESCAPE=$(echo $TARGET_DECRYPT | sed -e 's/ /\\ /g')
  IFS="$BACKIFS"
  if [ -n "$SSH_TO" ]; then
    DEST_DECRYPT="$TARGET_DECRYPT_ESCAPE"
  else
    DEST_DECRYPT="$TARGET_DECRYPT"
  fi
  if [ "$NOTTOSCRIPT" -eq 1 ] || [ -n "$SSH_TO" ]; then
    if $TARGET_TEST ! -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST -d $TARGET_PATH/"$DEST_DECRYPT"; then
      echo "Zielordner $TARGET_DECRYPT wurde lokalisiert..." >> $LOG
    elif $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST -d $TARGET_PATH/"$DEST_DECRYPT"; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT bereits eingehangen..." >> $LOG
    elif $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST ! -d $TARGET_PATH/"$DEST_DECRYPT"; then
      echo "Verschluesselter Zielordner $TARGET_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Zielordner einbinden
      if test -f `dirname $0`/"$TARGET_DECRYPT".key; then
        echo "$TARGET_DECRYPT.key gefunden" >> $LOG
        echo "Verschluesselter Zielordner $TARGET_DECRYPT wird eingehangen..."  >> $LOG
        KEYFILEDEST=$(ecryptfs-unwrap-passphrase `dirname $0`/"$TARGET_DECRYPT".key "\$1\$5YN01o9y")
        $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_mount "$DEST_DECRYPT" "$KEYFILEDEST" >> $LOG
        sleep 20
        if $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST -d $TARGET_PATH/"$DEST_DECRYPT"; then
          echo "Verschluesselter Zielordner $TARGET_DECRYPT wurde eingehangen..."  >> $LOG
        elif $TARGET_TEST -d $TARGET_PATH/@"$DEST_DECRYPT"@ && $TARGET_TEST ! -d $TARGET_PATH/"$DEST_DECRYPT"; then
          echo "Verschluesselter Zielordner $TARGET_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
        fi
      else
        echo "Kein Keyfile fuer $TARGET_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden!"
      fi
    fi
    if $TARGET_TEST ! -d $TARGET_PATH/"$DEST_DECRYPT"; then
      if [ -z "$STOP" ]; then
        STOP="Zielordner /$TARGET_DECRYPT nicht gefunden!"
      fi
    fi
  fi
fi

# Quellordner checken
#-------------------------------------------------------------------------
IFS="
"
for SHARE in $SOURCES; do
  if [[ ${SHARE:0:1} != \/ ]] ; then
    SHARE="/$SHARE"
  fi
  SHARE_ESCAPE=$(echo $SHARE | sed -e 's/ /\\ /g')
  SHARE_CUT="${SHARE#*/}"
  SHARE_DECRYPT="${SHARE_CUT%%/*}"
  SHARE_DECRYPT_ESCAPE=$(echo $SHARE_DECRYPT | sed -e 's/ /\\ /g')
  IFS="$BACKIFS"
  if [ -n "$SSH_FROM" ]; then
    SOURCE_DECRYPT="$SHARE_DECRYPT_ESCAPE"
  else
    SOURCE_DECRYPT="$SHARE_DECRYPT"
  fi
  if $SOURCE_TEST ! -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
    echo "Quellordner $SHARE_DECRYPT wurde lokalisiert..." >> $LOG
  elif $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
    echo "Verschluesselter Quellordner $SHARE_DECRYPT bereits eingehangen..." >> $LOG
  elif $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST ! -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
    echo "Verschluesselter Quellordner $SHARE_DECRYPT nicht eingehangen..." >> $LOG
# Anhand des Key-Files versuchen einen verschluesselten Quellordner einbinden
    if test -f `dirname $0`/"$SHARE_DECRYPT".key; then
      echo "$SHARE_DECRYPT.key gefunden" >> $LOG
      echo "Verschluesselter Quellordner $SHARE_DECRYPT wird eingehangen..."  >> $LOG
      KEYFILESHARE=$(ecryptfs-unwrap-passphrase `dirname $0`/"$SHARE_DECRYPT".key "\$1\$5YN01o9y")
      $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_mount "$SHARE_DECRYPT" "$KEYFILESHARE" >> $LOG
      sleep 20
      if $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
        echo "Verschluesselter Quellordner $SHARE_DECRYPT wurde eingehangen..."  >> $LOG
      elif $SOURCE_TEST -d $SOURCE_PATH/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST ! -d $SOURCE_PATH/"$SOURCE_DECRYPT"; then
        echo "Verschluesselter Quellordner $SHARE_DECRYPT konnte nicht eingehangen werden..."  >> $LOG
      fi
    else
      STOP="Kein Keyfile fuer $SHARE_DECRYPT gefunden! Verschluesselte Ordner muessen eingehangen werden! Datensicherung ABGEBROCHEN..."
    fi
  fi
done

# Ziel definieren
#-------------------------------------------------------------------------
if [ -z "$STOP" ]; then
  if [ -n "$SSH_TO" ] && [ -n "$TARGET" ]; then
    DEST_FULL=$($TOSSH "echo $TARGET_PATH/$TARGET_DECRYPT_ESCAPE")
    DEST_CUT="${DEST_FULL#*/}"
    DEST_VOL="${DEST_CUT%%/*}"
    if [ $TARGETDS -eq 1 ]; then
      DESTTARGET="/$DEST_VOL$TARGET_ESCAPE"
    else
      DESTTARGET="$TARGET_ESCAPE"
    fi
    if [ $HOSTNAME -eq 1 ]; then
      DESTINATION="$DESTTARGET/$NAME"
    else
      DESTINATION="$DESTTARGET"
    fi
  elif [ -z "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 0 ] && [ -z "$TARGET" ]; then
    if [ $HOSTNAME -eq 1 ]; then
      DESTINATION="`dirname $0`$TARGET_EMPTY/$NAME"
    else
      DESTINATION="`dirname $0`$TARGET_EMPTY"
    fi
  elif [ -z "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 1 ] && [ -n "$TARGET" ]; then
    DEST_FULL=$(echo $TARGET_PATH/"$TARGET_DECRYPT")
    DEST_CUT="${DEST_FULL#*/}"
    DEST_VOL="${DEST_CUT%%/*}"
    if [ -n "$TARGETDS" ]; then
      DESTTARGET="/$DEST_VOL$TARGET"
   else
       DESTTARGET="$TARGET"
   fi
   if [ $HOSTNAME -eq 1 ]; then
     DESTINATION="$DESTTARGET/$NAME"
   else
     DESTINATION="$DESTTARGET"
   fi
  elif [ -z "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 0 ]; then
    if [ $HOSTNAME -eq 1 ]; then
      DESTINATION="`dirname $0`$TARGET/$NAME"
    else
      DESTINATION="`dirname $0`$TARGET"
    fi
  fi
  mkdir -p "$DESTINATION"
  if [ -n "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 0 ]; then
    STOP="Bei SSH_TO muss NOTTOSCRIPT gesetzt werden!" >> $LOG
  elif [ -n "$SSH_TO" ] && [ "$NOTTOSCRIPT" -eq 1 ] && [ -n "$TARGET" ]; then
    if $TARGET_TEST -d $TARGET_PATH/$TARGET_DECRYPT_ESCAPE; then
      $TOSSH mkdir -p "$DESTINATION"
    fi
  fi
fi

# Check ob Zielordner erstellt wurde bzw. vorhanden war.
if $TARGET_TEST ! -d "$DESTINATION"; then
  if [ -z "$STOP" ]; then
    STOP="Zielordner $TARGET konnte nicht erstellt werden bzw. ist nicht vorhanden !"
  fi
fi

echo "" >> $LOG
echo "$HR" >> $LOG
echo "" >> $LOG
# Beginn der RSync-Datensicherung
#--------------------------------------------------------------------------
IFS="
"
for SHARE in $SOURCES; do
  if [ -z "$STOP" ]; then
    echo "" >> $LOG
    if [[ ${SHARE:0:1} != \/ ]] ; then
      SHARE="/$SHARE"
    fi
    SHARE_ESCAPE=$(echo $SHARE | sed -e 's/ /\\ /g')
    SHARE_CUT="${SHARE#*/}"
    SHARE_DECRYPT="${SHARE_CUT%%/*}"
    IFS="$BACKIFS"
    unset FORERROR
    if [ -n "$SSH_FROM" ]; then
      SOURCE="$SHARE_ESCAPE"
    else
     SOURCE="$SHARE"
    fi

  if $SOURCE_TEST ! -d $SOURCE_PATH"$SOURCE"; then
    ERROR="Quellordner $SHARE nicht erreichbar..." >> $LOG
    FORERROR="1"
  elif $SOURCE_TEST -d $SOURCE_PATH"$SOURCE"; then
    echo "Quellordner $SHARE erreichbar." >> $LOG
  fi
  if [ $FROMTHISDEVICE -eq 1 ] && [ -z "$SSH_FROM" ]; then
    SOURCE="`dirname $0`$SHARE"
  elif [ $FROMTHISDEVICE -eq 0 ] && [ -z "$SSH_FROM" ]; then
    SOURCE="$SHARE"
  fi

  if [ -z "$STOP" ] && [ -z "$FORERROR" ]; then
# SSH-SSH_FROM RSync-Datensicherung VON einer entfernten DS oder komp. Server
#--------------------------------------------------------------------------
    if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ] && [ -n "$DESTINATION" ]; then
      echo "$HR" >> $LOG
      echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
      echo "$HR" >> $LOG
      if [ $SOURCEDS -eq 1 ]; then
        rsync -e "$FROMRSYNC" $SYNCOPT $SSH_FROM:/volume*"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
        RSYNC_EXIT="$?"
        elif [ $SOURCEDS -ne 1 ]; then
          rsync -e "$FROMRSYNC" $SYNCOPT $SSH_FROM:"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
          RSYNC_EXIT="$?"
        fi
# SSH-SSH_TO RSync-Datensicherung AUF eine entfernte DS oder komp. Server
#--------------------------------------------------------------------------
      elif [ -n "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -n "$DESTINATION" ]; then
        echo "$HR" >> $LOG
        echo "Starte Datensicherung: $LOKALHOST$SHARE nach $DESTINATION" >> $LOG
        echo "$HR" >> $LOG
        if [ $SOURCEDS -eq 1 ] && [ $FROMTHISDEVICE -ne 1 ]; then
          rsync -e "$TORSYNC" $SYNCOPT /volume*"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE $SSH_TO:"$DESTINATION" >> $LOG
          RSYNC_EXIT="$?"
          elif [ $SOURCEDS -ne 1 ] || [ $FROMTHISDEVICE -eq 1 ]; then
            rsync -e "$TORSYNC" $SYNCOPT "$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE $SSH_TO:"$DESTINATION" >> $LOG
            RSYNC_EXIT="$?"
          fi
# RSync- Lokale Datensicherung auf Volume, USB- oder SATA-Datentr�ger
#-------------------------------------------------------------------------
      elif [ -z "$SSH_TO" ] && [ -z "$SSH_FROM" ] && [ -n "$DESTINATION" ]; then
        echo "$HR" >> $LOG
        echo "Starte Datensicherung: $REMOTEHOST$SHARE nach $DESTINATION" >> $LOG
        echo "$HR" >> $LOG
        if [ $SOURCEDS -eq 1 ] && [ $FROMTHISDEVICE -ne 1 ]; then
          rsync $SYNCOPT /volume*"$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
          RSYNC_EXIT="$?"
          elif [ $SOURCEDS -ne 1 ] || [ $FROMTHISDEVICE -eq 1 ]; then
            rsync $SYNCOPT "$SOURCE" $LOGSTAT $EXCLUDE $RECYCLE "$DESTINATION" >> $LOG
            RSYNC_EXIT="$?"
          fi
        fi
        echo "" >> $LOG
        if [ $RSYNC_EXIT -ne 0 ]; then
          RSYNC_CODE="$RSYNC_EXIT"
        fi
    fi
  fi
done

# RSync Exit-Code = Fehlermeldung
#-------------------------------------------------------------------------
if [ -n "$RSYNC_CODE" ]; then
# Exit-Code: Entfernter Server ausgeschaltet?
  if [ $RSYNC_CODE -eq 43 ]; then
    echo "RSync-Code $RSYNC_CODE: Entfernte DS oder RSync komp. Server nicht Online? Bitte RSYNC Port kontrollieren!" >> $LOG
# Exit-Code: DSL-Verbindung getrennt?
  elif [ $RSYNC_CODE -eq 255 ]; then
    echo "RSync-Code $RSYNC_CODE: Bitte Internetverbindung oder RSYNC Port kontrollieren!" >> $LOG
# Exit-Code ausgeben...
  elif [ $RSYNC_CODE -ne 0 ]; then
    echo "RSync Fehlermeldung (Exit Code): $RSYNC_CODE" >> $LOG
  fi
fi

# RSync Exit-Code = Erfolgreich bzw. Unvollständig
#-------------------------------------------------------------------------
if [ -z "$RSYNC_CODE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
  echo "$HR" >> $LOG
  echo "RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION" >> $LOG
  if [ -z "$DSMNOTIFY" ]; then
    DSMNOTIFY="RSync-Datensicherung erfolgreich. Sicherungsziel: $DESTINATION"
  fi
# Signalausgabe - Datensicherung erfolgreich
  if [ $SIGNAL -eq 1 ]; then
    echo 3 >/dev/ttyS1; echo 8 >/dev/ttyS1
    sleep 2
  fi
# RSync Exit-Code = Fehlermeldung
elif [ $RSYNC_CODE -ne 0 ] || [ -n "$STOP" ] || [ -n "$ERROR" ]; then
  echo "$HR" >> $LOG
  echo "RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Sicherungsziel: $DESTINATION" >> $LOG
  if [ -z "$DSMNOTIFY" ]; then
    DSMNOTIFY="RSync-Datensicherung unvollstaendig oder fehlgeschlagen - Bitte Protokoll prüfen!"
  fi
# Signalausgabe - Datensicherung fehlgeschlagen
  if [ $SIGNAL -eq 1 ]; then
    echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 2 >/dev/ttyS1; sleep 1; echo 8 >/dev/ttyS1
  fi
fi
echo "$HR" >> $LOG; echo "" >> $LOG
if [ -n "$STOP" ]; then
  echo "FEHLER: $STOP" >> $LOG
fi
if [ -n "$ERROR" ]; then
  echo "FEHLER: $ERROR" >> $LOG
fi

# DSM-Systemkonfiguration exportieren
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ "$DSM_EXPORT" -eq 1 ] && [ -z "$RSYNC_CODE" ]; then
  if [ -n "$SSH_FROM" ] && [ -z "$SSH_TO" ] && [ -n "$SOURCEDS" ]; then
    $FROMSSH /usr/syno/bin/synoconfbkp export --filepath DSMConfig_TEMP.dss
    mkdir -p "$DESTINATION"/@DSMConfig
    $SCP -r $SSH_USER@$SSH_FROM:DSMConfig_TEMP.dss "$DESTINATION"/@DSMConfig/DSMConfig_"$DATE"_$REMOTEHOST.dss
    $FROMSSH rm -rf DSMConfig_TEMP.dss
    echo  "Sicherung der DSM-Systemkonfiguration von $REMOTEHOST erfolgreich zu $LOKALHOST kopiert.." >> $LOG
    echo "" >> $LOG
  elif [ -z "$SSH_FROM" ] && [ -n "$SSH_TO" ]; then
    synoconfbkp export --filepath `dirname $0`/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    $TOSSH mkdir -p "$DESTINATION"/@DSMConfig
    $SCP -r `dirname $0`/@DSMConfig/*.dss $SSH_USER@$SSH_TO:"$DESTINATION"/@DSMConfig/
    rm -rf `dirname $0`/@DSMConfig
    echo  "Sicherung der DSM-Systemkonfiguration von $LOKALHOST erfolgreich zu $REMOTEHOST kopiert.." >> $LOG
    echo "" >> $LOG
  elif [ -z "$SSH_FROM" ] && [ -z "$SSH_TO" ]; then
    mkdir -p "$DESTINATION"/@DSMConfig
    synoconfbkp export --filepath "$DESTINATION"/@DSMConfig/DSMConfig_"$DATE"_$LOKALHOST.dss
    echo  "Lokale Sicherung der DSM-Systemkonfiguration erfolgreich." >> $LOG
    echo "" >> $LOG
  fi
fi

# Rotationszyklus für das Löschen von @Recycle, @Logfiles und @DSMConfig
#-------------------------------------------------------------------------
# Dateien im Ordner @Recycle die älter als x Tage sind, löschen.
if [ -z "$STOP" ] && [ -z "$RSYNC_CODE" ]; then
  if $TARGET_TEST -d "$DESTINATION"/@Recycle/; then
    if [ -z "$STOP" ] && [ -n "$RECYCLE_ROTATE" ] && [ -z "$ERROR" ]; then
      $FIND "$DESTINATION"/@Recycle/* -type d -mtime +$RECYCLE_ROTATE -exec rm -rf {} \;
      echo  "HINWEIS: Daten aus dem Ordner /@Recycle, die mehr als $RECYCLE_ROTATE Tage alt waren, wurden geloescht." >> $LOG
      echo "" >> $LOG
  fi
  fi
# Dateien im Ordner @Logfiles die älter als x Tage sind, löschen.
  if $TARGET_TEST -d `dirname $0`/@Logfiles/; then
    if [ -z "$STOP" ] && [ -n "$LOGFILES_ROTATE" ] && [ -z "$ERROR" ]; then
      find `dirname $0`/@Logfiles -name "*.log" -type f -mtime +$LOGFILES_ROTATE -exec rm {} \;
      echo  "HINWEIS: Daten aus dem Ordner /@Logfiles, die mehr als $LOGFILES_ROTATE Tage alt waren, wurden geloescht." >> $LOG
      echo "" >> $LOG
    fi
  fi
# Dateien im Ordner @DSMConfig die älter als x Tage sind, löschen.
  if  $TARGET_TEST -d "$DESTINATION"/@DSMConfig/; then
    if [ -z "$STOP" ] && [ -n "$DSMCONFIG_ROTATE" ] && [ -z "$ERROR" ]; then
      $FIND "$DESTINATION"/@DSMConfig -name "*.dss" -type f -mtime +$DSMCONFIG_ROTATE -exec rm {} \;
      echo  "HINWEIS: Daten aus dem Ordner /@DSMConfig, die mehr als $DSMCONFIG_ROTATE Tage alt waren, wurden geloescht." >> $LOG
      echo "" >> $LOG
    fi
  fi
fi

# Verschlüsselte Shares wieder aushängen..
#-------------------------------------------------------------------------
if [ $UNMOUNT -ne 0 ] && [ -n "$TARGETDS" ]; then
  if [ $UNMOUNT -ne 2 ]; then
IFS="
"
    TARGET_ESCAPE=$(echo $TARGET | sed -e 's/ /\\ /g')
    TARGET_DECRYPT_ESCAPE=$(echo $TARGET_DECRYPT | sed -e 's/ /\\ /g')
    IFS="$BACKIFS"
    if [ -n "$SSH_TO" ]; then
      DEST_DECRYPT="$TARGET_DECRYPT_ESCAPE"
    else
      DEST_DECRYPT="$TARGET_DECRYPT"
    fi
    if $TARGET_TEST -d /volume*/@"$DEST_DECRYPT"@ && $TARGET_TEST -d /volume*/"$DEST_DECRYPT"; then
      echo "Ziel: $TARGET_DECRYPT wurde ausgehangen" >> $LOG
      $SYNOSHARE_TARGET /usr/syno/sbin/synoshare --enc_unmount "$DEST_DECRYPT" >> $LOG
      sleep 10
    fi
  fi
fi
if [ $UNMOUNT -ne 0 ] && [ -n "$SOURCEDS" ]; then
  if [ $UNMOUNT -ne 3 ]; then
IFS="
"
  for SHARE in $SOURCES; do
    SHARE_ESCAPE=$(echo $SHARE | sed -e 's/ /\\ /g')
    SHARE_CUT="${SHARE#*/}"
    SHARE_DECRYPT="${SHARE_CUT%%/*}"
    SHARE_DECRYPT_ESCAPE=$(echo $SHARE_DECRYPT | sed -e 's/ /\\ /g')
    IFS="$BACKIFS"
    if [ -n "$SSH_FROM" ]; then
      SOURCE_DECRYPT="$SHARE_DECRYPT_ESCAPE"
    else
      SOURCE_DECRYPT="$SHARE_DECRYPT"
    fi
    if $SOURCE_TEST -d /volume*/@"$SOURCE_DECRYPT"@ && $SOURCE_TEST -d /volume*/"$SOURCE_DECRYPT"; then
      echo "Quelle: $SHARE_DECRYPT wurde ausgehangen" >> $LOG
      $SYNOSHARE_SOURCE /usr/syno/sbin/synoshare --enc_unmount "$SHARE_DECRYPT" >> $LOG
      sleep 10
    fi
  done
  fi
fi
unset KEYFILEPW

# Entfernten Server herunterfahren
#-------------------------------------------------------------------------
if [ $SHUTDOWN -ne 0 ] && [ -z "$RSYNC_CODE" ] && [ -z "$STOP" ] && [ -z "$ERROR" ]; then
  if [ -n "$SSH_FROM" ]; then
    $FROMSSH poweroff
    echo "Remoteserver $SSH_FROM wird heruntergefahren." >> $LOG
  elif [ -n "$SSH_TO" ]; then
    $TOSSH poweroff
    echo "Remoteserver $SSH_TO wird heruntergefahren." >> $LOG
  fi
fi

# Benachrichtigung an die DSM-Administratorengruppe sowie E-Mail senden
#-------------------------------------------------------------------------
if [ -n "$DSMNOTIFY" ]; then
  synodsmnotify @administrators "Script: $SCRIPTNAME" "$DSMNOTIFY"
fi
if [ -n "$EMAIL" ]; then
  if [ "$EMAILFAIL" -eq 1 ] && [ -z "$RSYNC_CODE" ] || [ -n "$STOP" ] || [ -n "$ERROR" ]; then
    ssmtp $EMAIL < $LOG
  elif [ "$EMAILFAIL" -eq 0 ]; then
    ssmtp $EMAIL < $LOG
  fi
fi

# Script beenden...
#-------------------------------------------------------------------------
if [ -z "$STOP" ] && [ -z "$RSYNC_CODE" ] && [ -z "$ERROR" ] && [ "$AUTORUN" -eq 1 ]; then
  exit 100
else
  exit $?
fi

Erstellen eines RSA-Keys für den Aufbau einer SSH-Verbindung

Es soll eine dateibasierte Datensicherung mittels RSync von Diskstation "A" (Produktivsystem) auf Diskstation "B" (Backupsystem) angelegt werden. Dabei übernimmt das Backupsystem die Aufgabe des Servers, worüber der Verbindungsaufbau und der eigentliche Sicherungsvorgang initiiert wird. Das Produktivsystem übernimmt somit die Aufgabe des Client und muß dem ganzen Vorgang nur zustimmen. Um dies zu ermöglichen muß im Vorfeld ein RSA-Schlüssel auf dem Backupsystem erzeugt und dem Produktivsystem der öffentliche Schlüssel mitgeteilt werden, um so den automatischen Verbindungsaufbau per SSH zu ermöglichen. Nachdem die SSH-Verbindung erfolgreich aufgebaut wurde, wird der eigentliche rsync-Befehl abgesetzt und somit die Datensicherung ausgelöst. Um auch in die Gegenrichtung sichern zu können, muss die RSA-Key Einrichtung dementsprechend gedreht werden, so das am Ende sowohl Diskstation "A" als auch Diskstation "B" Quelle als auch Ziel der Datensicherung darstellen können.

Im folgenden werden alle Einstellungen für den Benutzer root getroffen, da nur unter diesem Benutzer die Signalausgabe als auch das Sichern der DSM-Konfiguration funktioniert. Wer hier lieber als "admin" oder vielleicht sogar als eingeschränkter Benutzer "rsync" arbeiten möchte, muss nachfolgend an den entsprechenden Stellen den gewünschten Benutzernamen einsetzen. Das hier verwendete Homeverzeichnis des Benutzer "root" wird im folgenden nur in dessen Kurzform mit ~/ angesprochen, wobei hier immer auf /root verwiesen wird. Alle anderen Benutzerkonten befinden sich im Homeverzeichnis /home/[BENUTZERNAME] bzw. richtigerweise unter /var/services/homes/[BENUTZERNAME].

(Nachfolgend symbolisiert das Zeichen "$" nur den Zeilenanfang und wird nicht mit geschrieben)


Hinweis zum Loginvorgang bis DSM 5.2 für den Benutzer "root"

Login als Benutzer "root" mit dem Passwort des DSM-Benutzer "admin"

Hinweis zum Loginvorgang ab DSM 6 für den Benutzer "root"

Login als Benutzer "admin" mit dem Passwort des DSM-Benutzer "admin"
 
"root"-Zugriff erhält man dann über die Eingabe von...

  $ sudo -i
 
  ...und gibt abermals das Password des DSM-Benutzer "admin" ein.


Beginnen wir auf dem Server der "Diskstation B" oder besser gesagt, dem Backupsystem

Auf der Konsole der DS als Benutzer "root" einloggen. Erstellen des RSA-Schlüssels mit...

$ ssh-keygen -t rsa

Bei der Erstellung wird man nach Speicherort und Passphrase gefragt...

Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no oassphrase):
Enter same passphrase again:

... hier bitte nichts eintragen, sondern einfach nur mit der "Return-Taste" bestätigen. Nach der Ausführung werden im Homeverzeichnis des Benutzer "root" folgende Ordner und Dateien erstellt:

~/.ssh
~/.ssh/id_rsa
~/.ssh/id_rsa.pub

An dieser Stelle sollte man gleich noch die Ordner- und Dateirechte anpassen.

$ chmod 0700 ~/.ssh
$ chmod 0600 ~/.ssh/id_rsa*

Den Inhalt der Datei ~/.ssh/id_rsa.pub z.B. mit vi, nano oder dem AdminTool editieren und den Inhalt in die Zwischenablage kopieren.

$ nano ~/.ssh/id_rsa.pub

Wichtig, wie hier im Beispiel gezeigt (RSA-Schlüssel wurde hier gekürzt) ist, das alles in einer Zeile steht...

ssh-rsa AAAAB3NzaC1yc2..*gekürzt*...EAAAADAQABA3e root@Backupstation

Weiter gehts auf dem Client der "Diskstation A", also dem Produktivsystem.

Auf der Konsole der DS als Benutzer "root" einloggen. Erstellen eines neuen Ornders

$ mkdir ~/.ssh

Daraufhin wird unter ~/.ssh/ eine neue Datei namens "authorized_keys" erstellt...

$ nano ~/.ssh/authorized_keys

...und der Inhalt aus der Zwischenablage, also der Inhalt aus der ~/.ssh/id_rsa.pub, die auf dem Backupsystem erstellt wurde, in die geöffnete Datei eingefügt. Nach dem Speichern und verlassen des Editors müssen auch hier noch die Ordner- und Dateirechte richtig gesetzt werden.

$ chmod 0700 ~/.ssh
$ chmod 0600 ~/.ssh/authorized_keys

Zurück auf der Konsole der Backupstation.

Als Benutzer "root" auf der DS einloggen und als Erstes die SSH-Verbindung prüfen mit...

$ ssh root@IP-DER-DISKSTATION_A -p 22

Der Verbindungsaufbau möchte vom System nochmal mit "yes" bestätigt werden um anschließend auf der Konsole des Produktivsystemes zu landen. Diese Verbindung kann man durch die Eingabe eines...

$ exit

... wieder beenden. Durch den Verbindungsaufbau wurde nun in der Datei ~/.ssh/known_hosts ein neuer Eintrag hinzugefügt, der die Zugangsdaten zur Diskstation beinhaltet. Kontrollieren kann man das mit...

$ nano ~/.ssh/known_hosts

Nachdem alles gut verlaufen ist, wird die Konsole wieder geschlossen mit...

$ exit

Release Notes

Release Notes vom 10.05.2016 (Knapp 150 Zeilen Script-Code wurden seit dem letzen Update hinzugefügt.)

  • Es wurde eine neue Variable (MAC) geschaffen um entfernte Server per WOL zu starten.
  • Es wurde eine neue Variable (SLEEP) geschaffen um dem entfernten Server ein Zeitfenster zum starten zu geben.
  • Es wurde eine neue Variable (SHUTDOWN) geschaffen um entfernte Server auszuschalten.
  • Anhand der drei grade genannten Variablen können demnach entfernte Server per WOL geweckt, die eigentliche Datensicherung ausgeführt werden um im Anschluss den entfernten Server bei Bedarf wieder auszuschalten.
  • Es wurde eine neue Variable (FROMTHISDEVICE) geschaffen um Inhalte eines USB/SATA-Datenräger auf eine Diskstation oder einem entfernten, RSync-kompatiblen Server zu sichern.
  • Quellen und Ziel können ab sofort auch Leerzeichen enthalten.

Release Notes vom 01.05.2016

  • Es wurde eine neue Variable (SSH_PORT) geschaffen um einen abweichenden SSH-Port angeben zu können.
  • Es wurde eine neue Variable (RSYNC_PORT) geschaffen um einen abweichenden RSync-Port angeben zu können.
  • Es wurde eine neue Variable (EMAILFAIL) geschaffen um nur bei einer Störung per E-Mail benachrichtigt zu werden.
  • Alle "schaltbaren" Benutzer-Variablen wurden nach dem Schema "0" = aus / "1" = an umstrukturiert. Ursprünglich wurde der Wert bei Zustand "aus" einfach leer gelassen, also "".
  • Kommentare im Benutzer-Eingabebereich des Scripts wurden optimiert.
  • Neben der bereits funktionierenden Sicherung von und auf eine weitere Diskstation funktioniert jetzt auch das Sichern von und auf einen RSync-kompatible Server. Das Script erkennt hierbei automatisch ob es sich um eine Diskstation oder einen RSync-kompatiblen Server handelt und passt die Sicherungs-Pfade dementsprechend an. Diskstation arbeiten i.d.R. mit einem /volume[x], RSync-kompatible Server tun das in der Regel nicht.
  • Viele weitere Detailverbesserungen, die hier nicht alle aufgeführt werden können. Nur so viel... das Script ist um weitere 100 Zeilen Scipt-Code gewachsen.

Externe Links