staging.inyokaproject.org

Hallo,

ich synce als Backup 3 lokale Ordner mit Unterordner in ein virtuelles Laufwerk von pCloud. Der pCloud Dienst ladet diese dann selber in die Cloud hoch. Er speichert die Dateien in einem Cache zwischen.

Nun zum "Problem": Mit rsync kopiere ich die Inhalte der 3 Ordner in das virtuelle. Ich drossle das kopieren mit der Bandbreite, welches mein Upload in etwa hat. Damit der pCloud Dienst Zeit hat die Dateien hoch zu laden und der lokale Cache nicht zu groß wird.

Aber: wenn die Internetverbindung wegbricht oder sehr langsam wäre, würde der Cache extrem groß werden und könnte passieren das die Platte voll wird.

Drum prüfe ich zyklisch jede Stunde den Cache und stoppe rsync bis dieser wieder unter die Schwelle fällt.

Aber so ganz rund ist das noch nicht.

Frage: Kann ich rsnc pausieren und dann wieder fortsetzen? Die besonderheit, wenn ich den Pause sende, soll er aber noch das aktuelle File ferig kopieren

mit -partiel möchte ich nicht arbeiten, da ein "halbes" File wohl vom Dienst hochgeladen wird und wenn er das File fertig stellt, würde der pCloud Dienst wohl nochmal das ganze File hochladen.

Mein Script das jede Stunde über den Cron gestartet wird bis dato:

syncpCloud.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#!/bin/bash
pid=$(pgrep rsync)
cacheSize=$(du -sb ~/.pcloud/Cache | cut -f1)
cacheSizeH=$(du -sh ~/.pcloud/Cache | cut -f1)

echo "Sync lokal folder to pCloud startet. Current cache size from pCloud is $cacheSizeH"
logger "Sync lokal folder to pCloud startet. Current cache size from pCloud is $cacheSizeH"

# 7GB = 7516192768 bytes
if [ $cacheSize -gt 7516192768 ]; then
    echo "Cache from pCloud drive is over 7GB and kill rsync if its running"
    logger "Cache from pCloud drive is over 7GB and kill rsync if its running"
    killall syncpCloud.sh
    killall rsync
    exit 1
fi

if [ -z "$pid" ]
then
      echo "rsync ist not running and sync to pCloud drive start now"
      logger "rsync ist not running and sync to pCloud drive start now"
      rsync -ahP --bwlimit=5300 --stats /media/Daten// /media/pCloud/Daten/
      rsync -ahP --bwlimit=5300 --stats /media/Multimedia/ /media/pCloud/Multimedia
      rsync -ahP --bwlimit=5300 --stats /media/Files/ /media/pCloud/Files

else
      echo "rsync is already running with the pids \n$pid\nand skip the sync to the pCloud drive"
      logger "rsync is already running with the pids $pid and skip the sync to the pCloud drive"
      exit 1
fi

Übrigens: der rsync ist mit ps aux 3x enthalten ... sollte der nicht einmal drinnen sein? Er kopiert ja nach ein ander

Er soll also, wenn der Cache 7GB erreicht das aktuelle File fertig stellen und dann warten bis der Cache wieder unter die 7GB fällt und fortsetzen wo er pausiert hat.

Ist das so möglich?

Und es wäre schön den aktuellen Status (also welches File wird gerade kopiert) zu sehen. Ausgabe von rsync in ein log File umleiten oder kann man mit einem befehl sehen was er grad macht?

Danke

update:

Hab nun gesehen das die einzelnen rsync Befehle mit ps aux nach einiger Zeit 3fach vorkommen. Also das er ein Verzeichniss 3x syncronisiert. Mein Script klappt also mit dem beenden und neu starten noch nicht so recht ☺

rsync kann schon mal mehrere Prozesse haben (Sender, Empfänger, ...). Evtl. zeigt pstree was los ist.

$ rsync --bwlimit=22 foobar barfoo
$ pstree -p | grep rsync
├─urxvt(11396)───bash(11397)───rsync(11420)───rsync(11421)───rsync(11422)
$ ls -l /proc/1142[012]/fd
/proc/11420/fd:
total 0
lrwx------ 1 andreas andreas 64 May 30 14:23 0 -> /dev/pts/1
lrwx------ 1 andreas andreas 64 May 30 14:23 1 -> /dev/pts/1
lrwx------ 1 andreas andreas 64 May 30 14:23 2 -> /dev/pts/1
lr-x------ 1 andreas andreas 64 May 30 14:23 3 -> /dev/shm/foobar
lrwx------ 1 andreas andreas 64 May 30 14:23 4 -> socket:[601058]
lrwx------ 1 andreas andreas 64 May 30 14:23 5 -> socket:[601059]

/proc/11421/fd:
total 0
lrwx------ 1 andreas andreas 64 May 30 14:23 1 -> socket:[601060]
lrwx------ 1 andreas andreas 64 May 30 14:23 2 -> /dev/pts/1
lrwx------ 1 andreas andreas 64 May 30 14:23 3 -> socket:[602809]

/proc/11422/fd:
total 0
lrwx------ 1 andreas andreas 64 May 30 14:23 0 -> socket:[601057]
lrwx------ 1 andreas andreas 64 May 30 14:23 1 -> /dev/shm/.barfoo.nRuFwk
lrwx------ 1 andreas andreas 64 May 30 14:23 2 -> /dev/pts/1
lrwx------ 1 andreas andreas 64 May 30 14:23 4 -> socket:[602810]

Der Prozess 11422 schreibt, der Prozess 11420 liest, und 11421 ist ... äh ... mysteriös! Lustige Sachen mit Sockets und so Krams.

Frage: Kann ich rsnc pausieren und dann wieder fortsetzen?

Vielleicht. Versuchs mit kill -SIGSTOP / -SIGCONT um rsync zu unterbrechen / weitermachen zu lassen. Kann funktionieren (gleich wie Strg+Z auf der Konsole), wenn du Pech hast gibts irgendwo ein Timeout.

Dein killall ist gemeingefährlich. Mach dir die Mühe und merke dir die Prozess-IDs um die es wirklich geht.

Hallo,

danke für die Infos. Ich hab das Script mal überarbeitet und scheint soweit alles zu laufen:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#!/bin/bash
pid=$(pgrep rsync)

cacheSize=$(du -sb ~/.pcloud/Cache | cut -f1)
cacheSizeH=$(($cacheSize / 1024 / 1024 / 1024))

#value in GB
cacheLimitH=10
cacheLimit=$(($cacheLimitH * 1024 * 1024 * 1024))


echo "Sync lokal folder to pCloud drive startet. Current cache size from pCloud is $cacheSizeH GB"
logger "Sync lokal folder to pCloud drive startet. Current cache size from pCloud is $cacheSizeH GB"


# Check if Cash is over limit and pause rsync if running
if [ $cacheSize -gt $cacheLimit ]; then

    if [ -z "$pid" ]; then
      echo "Cache size ($cacheSizeH GB) is over limit ($cacheLimitH GB) and rsync not running. Doing nothing!"
      logger "Cache size ($cacheSizeH GB) is over limit ($cacheLimitH GB) and rsync not running. Doing nothing!"
      exit 1
    else
      echo "Cache size ($cacheSizeH GB) is over limit ($cacheLimitH GB) and pause now rsync"
      logger "Cache size ($cacheSizeH GB) is over limit ($cacheLimitH GB) and pause now rsync"
      for i in "${pid[@]}"
        do
         echo "Pause rsync with PID: $i"
         logger "Pause rsync with PID: $i"
         kill -SIGSTOP $i
        done
       exit 1
      fi
fi

if [ -z "$pid" ]; then
      echo "rsync ist not running and sync to pCloud drive start now"
      logger "rsync ist not running and sync to pCloud drive start now"
      rsync -ahP --bwlimit=5300 --stats /media/Daten/ /media/pCloud/Daten
      rsync -ahP --bwlimit=5300 --stats /media/Multimedia/ /media/pCloud/Multimedia
      rsync -ahP --bwlimit=5300 --stats /media/Files/ /media/pCloud/Files

else
      echo "rsync is already running with the pids \n$pid\n"
      logger "rsync is already running with the pids $pid"
     for i in "${pid[@]}"
        do
         echo "Resume rsync with PID: $i"
         logger "Resum rsync with PID: $i"
         kill -SIGCONT $i
        done
      fi

      exit 1
fi

Einzig wenn ich das Script erneut state, sendet es beim laufenden rsync ein -SIGCONT ... aber das scheint wohl kein Problem zu sein.

Wenn ich rsync mit -SIGSTOP pausiere, hält er mitten in der Datei an ... das er die eine Datei noch fertig kopiert werd ich wohl nicht hinbekommen

Und "pgrep rsync" gibt wohl doch kein Array zurück sondern einen String mit Zeilenumbruch. Aber ich kann das wohl so mit kill verwenden und er wendet es an alle laufenden Instanzen von rsync an. Den array loop lass ich mal so wie ich es momentan hab

Du kannst alternativ auch die Optionen --stop-at=y-m-dTh:m oder --time-limit=MINS verwenden. Zusammen mit -bwlimit=RATE kannst Du dann sauber das Volumen beschränken. Dann terminiert der rsync einfach und Du startest ihn dann später wieder.

Hallo,

danke für die Info ... aber er soll stoppen wenn die Gesamtgröße des Cache Speicher mein Limit übersteigt, aber das aktuelle File soll noch fertig gestellt werden.

Das stoppen nach einer festen Zeit würde da mir nicht unbedingt weiter helfen, oder?

Fohnbit schrieb:

danke für die Info ... aber er soll stoppen wenn die Gesamtgröße des Cache Speicher mein Limit übersteigt, aber das aktuelle File soll noch fertig gestellt werden.

Das stoppen nach einer festen Zeit würde da mir nicht unbedingt weiter helfen, oder?

Würde ich mal ausprobieren. Ich weiß nicht, wie sich rsync genau verhält. Es würde relativ wenig Sinn machen mitten in einer Datei abzubrechen.

-SIGSTOP pausiert rsync ... bleibt mitten drinnen stehen ... mit -SIGCONT macht er an der Stelle weiter

Fohnbit schrieb:

-SIGSTOP pausiert rsync ... bleibt mitten drinnen stehen ... mit -SIGCONT macht er an der Stelle weiter

... wenn die Netzwerkverbindung stabil bleibt. Aber was ist der Punkt?

Der Punkt dabei ist:

Wenn er grad ein 1.5Gb File kopieren würde und der Cache an die Grenze geht, pausiert er: soweit ok.

Aber pCloud synct wohl die bis dato kopierten Bytes in die Cloud. Zum Beispiel 1GB von 1.5GB

danach bereinigt er den Cache ... dann macht rsync weiter und könnte sein das die bis dahin kopierten partielle Datei aus dem Cache schon entfernt wurde. Oder er kopiert weiter und ladet dann das ganze File hoch. Also total 2.5Gb Upload bei einem File von 1.5GB

Drum sollte er die Files immer fertig stellen ... egal wie groß der Cache ist und nach dem kompletten File pausieren.

Idee mit einem anderen Ansatz:

Ich schreibe mit rsync ja in ein log file: Inhalt als Beispiel:

2019/05/31 15:37:31 [49374] >f+++++++++ Bilder/USA 2016/Videos/00029_mts.HDP
2019/05/31 15:37:46 [49374] >f+++++++++ Bilder/USA 2016/Videos/00030.MTS
2019/05/31 15:37:55 [49374] >f+++++++++ Bilder/USA 2016/Videos/00031.MTS
2019/05/31 15:38:01 [49374] >f+++++++++ Bilder/USA 2016/Videos/00032.MTS
2019/05/31 15:38:01 [49374] >f+++++++++ Bilder/USA 2016/Videos/00032_mts.HDP

Wenn der Cache zu groß wird, soll er noch eine Änderung des logfiles abwarten und dann rsync pausieren ... denn der nächste Eintrag in das Logfile ist ja die aktuell kopierende Datei.

Wie könnte ich also ein script schreiben, das auf Befehl das logfile auf Änderung überwacht und dann einen Befehl absetzen?

Oder ich schreibe die aktuelle Größe des Logfiles oder die letzte Zeile in ein temporäre Datei und wenn diese beim nächsten Sync Check exiustiert prüfen ob sich diese geändert hat. Falls ja: rsync pausieren.

Danke!

Fohnbit schrieb:

Drum sollte er die Files immer fertig stellen ... egal wie groß der Cache ist und nach dem kompletten File pausieren.

Natürlich. Aber ich gehe davon aus, dass er das mit SIGSTOP / SIGCNT nicht macht. Oder beobachtest Du ein verzögertes Stoppen des Prozesses? Deshalb habe ich ja vorgeschlagen, dass Du mal meinen Ansatz testest.

Hallo,

ich lass es in einem screen laufen und mit -p sehe ich wieviel er grad kopiert hat .. in Echtzeit. Sende ich SIGSTOP bleibt der Kopierfortschritt stehen ... mit SIGCONT macht er wieder weiter .. also ein "richtiges" PAUSE

Deinen Ansatz habe ich nicht ganz verstanden. Ich kann beim Aufruf von rsync ja keine Stoppzeit mit übergeben. Das ergibt sich ja irgendwann einmal. Und zwar wenn der Cash zu groß wird.

Die ganze Geschichte kommt mir sowieso umständlich vor. pCloud kann doch lokale Dateien in die Cloud synchronisieren. Warum dann überhaupt noch der Zwischenschritt? Das kostet doch nur unnötig Zeit, Bandbreite und CPU.

Fohnbit schrieb:

danach bereinigt er den Cache ... dann macht rsync weiter und könnte sein das die bis dahin kopierten partielle Datei aus dem Cache schon entfernt wurde.

Ich kenne pCloud nicht. Wenn das die Dateien wegputzt die rsync gerade kopiert (woher weiß rsync denn dann überhaupt, was neu zu übertragen ist? Oder kopierst du mit rsync einfach "alles"?) und noch dazu auch Dateien die noch in Benutzung sind, dann wirds irgendwann halt ein bißchen kritisch.

Wie rklm auch vorschlägt... vielleicht noch mal ganz neu drüber nachdenken dann.