notes.txt

### problema di zfs send da server a backup: 
Sending snapshot
zfs send -i zfspool/Foto@2024.06.06-02.50.10 zfspool/Foto@2024.06.16-16.33.39 | pv -ptebar | ssh finzic@r4spi.local sudo zfs recv backuppool/Foto
ERRORE: 
?? cannot receive incremental stream: destination backuppool/Foto has been modified since most recent snapshot

To solve this, 
1) set property readonly = on on the dataset : 
    sudo zfs set readonly=on backuppool/Foto

2) find the last or only snapshot and rollback to it: 
    sudo zfs rollback backuppool/Foto@2024.06.06-02.50.10 

---------

finzic@morla ~/src/zfs-backup  (main) $ sudo zfs diff zfspool/Test@2024.06.03-22.42.54  zfspool/Test@2024.06.03-22.44.28  
M       /mnt/raid/Test/
+       /mnt/raid/Test/file-fourth-snapshot.txt
-       /mnt/raid/Test/file-second-snap.txt
M       /mnt/raid/Test/file-third-snap.txt
finzic@morla ~/src/zfs-backup  (main) $ sudo zfs diff zfspool/Test@2024.06.03-22.40.32  zfspool/Test@2024.06.03-22.44.28  
M       /mnt/raid/Test/
+       /mnt/raid/Test/file-fourth-snapshot.txt
-       /mnt/raid/Test/file-second-snap.txt
+       /mnt/raid/Test/file-third-snap.txt
finzic@morla ~/src/zfs-backup  (main) $ sudo zfs diff zfspool/Test@2024.06.03-22.40.32  zfspool/Test@2024.06.03-22.42.54 
M       /mnt/raid/Test/
M       /mnt/raid/Test/file-second-snap.txt
+       /mnt/raid/Test/file-third-snap.txt

snap base : 
    file0.txt # file that is never changed 
second-snap
    file-2.txt
third-snap
    file-3.txt
    modify file-2.txt    
fourth-snap
    file-4.txt
    modify file-3.txt
    delete file-2.txt

------------------------------
DELETING FIRST snapshot
finzic@r4spi:~/src $ zfs list -t snapshot testpool/Test
NAME                                USED  AVAIL  REFER  MOUNTPOINT
testpool/Test@2024.06.20-15.24.40   107K      -  5.32G  -
testpool/Test@2024.06.24-01.37.17   108K      -  5.32G  -
testpool/Test@2024.06.24-01.55.00   109K      -  5.41G  -
testpool/Test@2024.06.24-02.10.26     0B      -  5.41G  -

da qui cancello il primo snapshot a mano: 
$ sudo zfs destroy testpool/Test@2024.06.20-15.24.40
cannot destroy snapshot testpool/Test@2024.06.20-15.24.40: dataset is busy

finzic@r4spi:~/src $ sudo systemctl stop nmbd.service
finzic@r4spi:~/src $ sudo systemctl stop smbd.service
finzic@r4spi:~/src $ sudo zfs destroy testpool/Test@2024.06.20-15.24.40
<OK>
Risultato: 
cancellato il primo snapshot, riesco comunque a vedere file-0.txt che e' stato creato all'inizio e mai modificato. 
---------
Ora da capire cosa succede se voglio fare subito un nuovo snapshot modificando dati nel server: 
IT WORKS . No need to rollback to the last snapshot. 
This means we can reclaim space when needed by removing snapshots if this is of any worth. 
-----------------------------------------------------------------------------------------------------
Calcolo taglia invio incrementale: 
sudo zfs diff -F -H -h zfspool/Music@2024.06.06-02.50.15  zfspool/Music@2024.06.24-02.50.28  | grep -v /$'\t' | grep -v "^-" | sort | awk '{for (i=3; i <= NF-1; i++) printf("%s ", $i); printf ("%s",$NF); print ""}'  | tr '\n' '\0' | du -ch --files0-from=- | tail -1 | awk '{print $1}'

Questa gestisce anche i file con spazi nel filename, comunissimi negli MP3;
Il -h in zfs diff serve per non stampare "\0040" al posto di <spazio>
Il programma AWK serve per stampare tutti i 'campi' meno i primi 2.
Il sort non serve ma fa l'output piu' grazioso se lo vedi a schermo 
grep -v "^-" -> toglie le righe dei file che sono presenti nel primo snapshot e cancellati nel secondo. 
grep -v /$'\t' -> toglie le righe che rappresentano directory
forse vale comunque la pena di non usare solo pipe per non dover aspettare senza output
Il tr '\n' '\0' serve perche' il du successivo si aspetta una lista di path zero-terminated... 

zfspool/Foto@2024.06.16-16.33.39  zfspool/Foto@2024.06.24-02.40.59 
---------------------------------
old method with rsync
############################################################################################################################################################################### 
	### rsync -nia --out-format="%i \"%f\"" ${SOURCE_DATASET}/ ${DEST_USERNAME}@${DEST_ADDR}:${DEST_BASE}/${DEST_DATASET} | egrep '<' | cut -d' ' -f2- > /tmp/changed-files.txt ###
    ############################################################################################################################################################################### 

# remove quotes from file so that parallel can run and pass paths to md5sum correctly 
		sed -i 's/\"//g' /tmp/changed-files.txt
# rsync -avzpH --partial --delete -P --progress $SOURCE_PATH bu@$DEST_ADDR:/home/bu/$DEST_DATASET

	# 
	#TODO - weak - need to compute the differences with last snapshot to actually know if any file has been changed. 
    # 
	### OLD METHOD - using RSYNC. 
	## >> rsync prepares the list of differences between server and backup machine;  
	# rsync -nia --out-format="%i \"%f\"" $SRC_DATASET bu@$DST_ADDR:/home/bu/$DST_DATASET | egrep '<' | cut -d' ' -f2- > /tmp/changed-files.txt
	# NOTE: the trailing '/' after ${SRC_DATASET} is FUNDAMENTAL to compare the right folders.
	# if ${DEBUG}; then
	#	echo "==== rsync -nia --out-format="%i \"%f\"" ${SRC_DATASET}/ ${DST_USERNAME}@${DST_ADDR}:${DST_BASE}/${DST_DATASET} ..." 
	# fi 
	############################################################################################################################################################################### 
	### rsync -nia --out-format="%i \"%f\"" ${SRC_DATASET}/ ${DST_USERNAME}@${DST_ADDR}:${DST_BASE}/${DST_DATASET} | egrep '<' | cut -d' ' -f2- > /tmp/changed-files.txt ###
    ############################################################################################################################################################################### 


-------------------------------------
ZFS information resource: 
https://www.illumos.org/books/zfs-admin/snapshots.html
--------------------------------------
NOTA sul caso in cui nel backup NON ci sia il dataset: 
non e' cosi' ovvio che nel mio serve NON ci sia alcuno snapshot : e' solo un caso iniziale, un corner case. 
La cosa giusta e': 
SE non c'e' alcun dataset nel backup server, allora
- prendo la lista di snapshot nel local server, cioe' attuale
- se non ce n'e' nessuno, allora faccio come adesso: 
	-- faccio il primo snapshot
	-- lo trasmetto dall'altra parte al backup server; 
- Se invece ce n'e' gia' almeno uno, allora 
	- faccio un nuovo snapshot ora su local server ; 
	- trasmetto il primo snapshot come faccio adesso; 
	- per tutti gli snapshot successivi al primo 
		Trasmetto lo snapshot come faccio sotto, come incrementale rispetto al precedente.

Qusta cosa si puo' semplificare perche' lo step di trasmissione del primo snapshot e' duplicata, dunque diventa: 

Se non c'e' alcun dataset nel backup server, allora
	- prendo la lista di snapshot nel server attuale
	- se non c'e' alcuno snapshot, ne creo uno adesso; 
	- se c'e' almeno uno snapshot, ne creo uno adesso; 
	- comincio la trasmissione degli snapshot dall'altra parte come segue: 
		- Trasmetto il primo snapshot (piu' vecchio) da solo, come faccio ora nel primo caso; 
		- Per tutti i successivi, trasmetto lo snapshot come faccio sotto, come incrementale rispetto al precedente. 

Poiche' ho ancora 2 step ripetuti sempre, li sintetizzo in uno solo: 
che ci sia uno snapshot o che non ci sia, comunque ne devo creare uno nuovo, dunque lo creo e basta. 
Ottengo questo: 

Se non c'e' alcun dataset nel backup server, allora
	- creo un nuovo snapshot (puo' essere il primo come l'ultimo se ce n'erano altri, non cambia)
	- Trasmetto il primo snapshot in modo completo (prima fase fatta adesso); 
	- Per tutti gli snapshot successivi: 
		Trasmetto ogni snapshot come differenza dal precedente come faccio adesso nel secondo caso.

Questa cosa serve per, ad esempio, replicare il mio dataset su un nuovo dataset o su un nuovo server! Cosi' copio tutti gli snapshot anche e cio' e' bene
Magari c'e' una feature di ZFS che fa tutto questo senza fare passetto per volta... 
---------------
semplicemente c'e' l'opzione giusta gia' fatta! L'opzione "-R" ! 

sudo zfs send -R zfspool/Test@2024.06.27-10.43.07 | pv | ssh finzic@r4spi.local sudo zfs receive testpool/Test-2
Lo snapshot indicato e' il piu' recente! 
e' la "-R" 

Le fornisco l'ultimo snapshot a disposizione e dunqwue basta fare uno snapshot comunque, cosi' si copre anche il primo caso; usare questo snapshot nel comando e via. 

Per il 'pv' resta da capire come valorizzare la 'taglia'; si puo' fare per far facile di prendere l'output di zfs list -t snapshot | valore "REFER" e via andare! 
Da fare e cosi' si finisce. 

Nota: per l'uso 'normale', si puo' fare ch esi faccia COMUNQUE subito un nuovo snapshot tanto non costa nulla, e i comandi successivi si basino sull'outpud di questo (zfs diff...) 

Gestyione errori: 
si dovrebbe fare in modo che, se fallisce una qualche parte della vicenda, tipo fallisce la spedizione dello snapshot, allora si distrugga (DESTROY) l'ultimo appena fatto, 
cosi' che la prossima volta si possa fare un nuovo snapshot che abbia una diff significativa. 

[x] fare uno snapshot come prima cosa
[x] usare il latest snapshot come punto per fare i diff successivi

=======================================================================
Prossime feature
[] caso primo invio: fare tutte le checksum e il controllo relativo 
[x] caso incrementale: comuque servirebbe fare un invio di tutti gli snapshot dall'ultimo sul backup sino all'ultimo sul 'server'. Forse si puo' fare con -R? 
	sudo zfs send -I zfspool/Test@2024.06.25-02.04.47 zfspool/Test@2024.07.03-14.10.05 | pv -ptebar -s 3G | ssh finzic@r4spi.local sudo zfs receive testpool/Test
	La soluzione e' il "-I" : manda tutti gli snap dal primo all'ultimo indicati. Pero' per farlo bene bisogna trovare l'ultimo presente sul backup e vedere se c'e' anche qui. 
	zfs list -H -t snapshot zfspool/Test | awk '{print $1}' | sed "s/^\(.*\)\/\(.*\)@\(.*\)$/\3/"
	-> lista delle date degli snapshot!

	Trovo l'ultima snapshot lato backup: 
	ssh finzic@r4spi.local zfs list -H  -t snapshot testpool/Test-2 | awk '{print $1}' |  sort | sed "s/^\(.*\)\/\(.*\)@\(.*\)$/\3/" | tail -n 1 

	Verifico che ci sia lato server dati: 
	zfs list -H -t snapshot zfspool/Test | awk '{print $1}' | sed "s/^\(.*\)\/\(.*\)@\(.*\)$/\3/" | grep 2024.06.24-02.25.31

	Questo deve dare proprio 
	2024.06.24-02.25.31
[] Si deve fare il backup se : 
	() Ho delle differenze locali -> faccio il backup dall'ultimo snap remoto all'ultmio che faccio ora localmente; 
	() NON ho differenze locali MA il backup e' indietro con gli snap allora posso buttare via lo snap appena fatto e fare con l'ultimo significativo. 

=============
finzic@morla ~/src/zfs-backup  (main) $ L=$(zfs list -t snapshot zfspool/Test | tail -n 1 | awk '{print $1}')
finzic@morla ~/src/zfs-backup  (main) $ echo $L
zfspool/Test@2024.07.04-01.36.12
finzic@morla ~/src/zfs-backup  (main) $ sudo zfs diff $L
finzic@morla ~/src/zfs-backup  (main) $ D=$(sudo zfs diff $L)
finzic@morla ~/src/zfs-backup  (main) $ N=$(echo $D | wc -l)
finzic@morla ~/src/zfs-backup  (main) $ echo $N

finzic@morla ~/src/zfs-backup  (main) $ if [ x$D == x ]; then echo "It is empty" ; else echo "it is not empty"; fi
It is empty

Se e' empty allora prendo $L come ULTIMO SNAPSHOT altrimenti ne faccio uno ora. 
E cosi' risolvo la questione se fare o no uno snapshot. 
SE NON ne devo fare, allora devo controllare se dall'altra parte ci sono tutti gli snapshot oppure no; 
se ci sono tutti allora non faccio veramente nulla; 
altrimenti mando via la differenza.
=====
calcolare la differenza di file. 
- inizialmente faccio diff da ultimo snapshot locale. Cosi' vedo se devo fare un nuovo snapshot. 
- poi vedo qual e' l'ultimo snapshot remoto e vedo se e' contenuto nei locali come data
- poi la vera differenza e' tra l'ultimo snapshot 'remoto' in locale e l'ultimo snapshot appena fatto, se devo farlo, e di questo faccio la diff vera.