Borgbacup compacter Free2Usb

Borgbacup compacter Free2Usb

Notes › _DIFFUSION

Cette conversation a été générée avec Duck.ai (https://duck.ai) à l’aide du modèle GPT-5.6 Luna d’OpenAI. Les chats IA peuvent afficher des informations inexactes ou offensantes (voir https://duckduckgo.com/duckai/privacy-terms pour en savoir plus).

====================

Message 1 sur 6 de l’utilisateur - 31/08/2026 18:28:54: Borgbackup: Procédure de compactage des dépôts dans un dossier /mnt/FreeUSB2To/sauvegardes/borgbackup/ cwwk e6230 iceyan.xyz ouestline.xyz pc1 sharenfs xoyaz.xyz yannig.net yannir.xyz

GPT-5.6 Luna: Voici une procédure sûre pour compacter tous les dépôts Borg situés dans :

1

/mnt/FreeUSB2To/sauvegardes/borgbackup/

Le compactage récupère l’espace inutilisé après des suppressions d’archives (borg prune ou borg delete). Il ne supprime aucune archive à lui seul.

1. Vérifier les dépôts

1
2
3

BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"

ls -ld "$BASE"/*

Tester l’accès à chaque dépôt :

1
2
3
4
5

for repo in "$BASE"/*; do
    [ -d "$repo" ] || continue
    echo "===== $repo ====="
    borg info "$repo" >/dev/null && echo "OK" || echo "ERREUR"
done

Si les dépôts sont chiffrés, Borg demandera éventuellement la phrase secrète.

2. Compacter tous les dépôts

Commande simple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"

for repo in "$BASE"/*; do
    [ -d "$repo" ] || continue

    echo
    echo "===== Compactage de $repo ====="

    borg compact "$repo"

    if [ $? -eq 0 ]; then
        echo "Compactage terminé : $repo"
    else
        echo "ERREUR sur : $repo"
    fi
done

Les dépôts concernés seront :

1
2
3
4
5
6
7
8
9

cwwk
e6230
iceyan.xyz
ouestline.xyz
pc1
sharenfs
xoyaz.xyz
yannig.net
yannir.xyz

3. Version avec journal

Pour conserver la sortie dans un fichier :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"
LOG="/var/log/borg-compact-$(date +%F-%H%M%S).log"

{
    echo "Début : $(date)"

    for repo in "$BASE"/*; do
        [ -d "$repo" ] || continue

        echo
        echo "===== Compactage de $repo ====="
        borg compact "$repo"
        echo "Code retour : $?"
    done

    echo
    echo "Fin : $(date)"
} 2>&1 | tee "$LOG"

4. Contrôler l’espace récupéré

Avant et après :

1
2

df -h /mnt/FreeUSB2To
du -sh /mnt/FreeUSB2To/sauvegardes/borgbackup/*

Pour examiner un dépôt particulier :

1

borg info "/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1"

Procédure recommandée complète

Si l’objectif est de supprimer les anciennes sauvegardes puis de récupérer l’espace, l’ordre est généralement :

1
2

borg prune
borg compact

Exemple pour un seul dépôt :

1
2
3
4
5
6
7
8
9

REPO="/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1"

borg prune "$REPO" \
    --list \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=6

borg compact "$REPO"

Ne lancez pas le compactage en même temps qu’une sauvegarde Borg utilisant le même dépôt. Assurez-vous également que le disque n’est pas monté en lecture seule et que le support USB reste connecté pendant toute l’opération.

Message 2 sur 6 de l’utilisateur - 31/08/2026 18:30:18: j’ai la procédure pour les dépôts distants

GPT-5.6 Luna: <!– Explaining remote repositories

I need to clarify how to interpret the wants for the remote repositories procedure. The SSH syntax user@host:path should be explained, especially regarding remotely running commands. I’m considering if the base path might be a remote mount, as they mentioned a local folder. It sounds like the user is interested in procedures for remote repositories, possibly wanting a loop for mapping. I should include examples and mention that the “borg compact” command operates server-side while controlling traffic. –> Pour des dépôts Borg distants, borg compact s’exécute depuis la machine cliente, mais le compactage est effectué sur le serveur distant via SSH.

La syntaxe est généralement :

1

borg compact utilisateur@serveur:/chemin/du/depot

Par exemple, si les dépôts sont sur backup.example.net dans /mnt/FreeUSB2To/sauvegardes/borgbackup/ :

1
2

borg compact \
    user@backup.example.net:/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1

Compacter tous les dépôts distants

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

REMOTE="user@backup.example.net"
BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"

for repo in \
    cwwk \
    e6230 \
    iceyan.xyz \
    ouestline.xyz \
    pc1 \
    sharenfs \
    xoyaz.xyz \
    yannig.net \
    yannir.xyz
do
    echo
    echo "===== Compactage de $repo ====="

    borg compact "$REMOTE:$BASE/$repo"

    if [ $? -eq 0 ]; then
        echo "OK : $repo"
    else
        echo "ERREUR : $repo"
    fi
done

Remplacez :

1

user@backup.example.net

par votre utilisateur et votre serveur SSH.

Avec la syntaxe ssh://

Si le chemin distant est absolu, vous pouvez aussi utiliser :

1
2

borg compact \
    ssh://user@backup.example.net/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1

Pour plusieurs dépôts :

1
2
3
4
5
6
7
8

REMOTE="ssh://user@backup.example.net"
BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"

for repo in cwwk e6230 iceyan.xyz ouestline.xyz pc1 sharenfs xoyaz.xyz yannig.net yannir.xyz
do
    echo "===== $repo ====="
    borg compact "$REMOTE$BASE/$repo"
done

Si chaque dépôt est sur un serveur différent

Créez une liste contenant le serveur et le dépôt :

1
2
3
4
5
6
7
8
9
10

while IFS= read -r repo; do
    echo "===== Compactage de $repo ====="
    borg compact "$repo"
done <<'EOF'
user@serveur1:/mnt/FreeUSB2To/sauvegardes/borgbackup/cwwk
user@serveur1:/mnt/FreeUSB2To/sauvegardes/borgbackup/e6230
user@serveur2:/mnt/FreeUSB2To/sauvegardes/borgbackup/iceyan.xyz
user@serveur2:/mnt/FreeUSB2To/sauvegardes/borgbackup/ouestline.xyz
user@serveur3:/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1
EOF

Vérifier d’abord l’accès

Avant de compacter, testez un dépôt :

1
2

borg info \
    user@backup.example.net:/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1

Puis lancez le compactage :

1
2

borg compact \
    user@backup.example.net:/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1

La phrase secrète du dépôt peut être demandée. Pour une exécution automatisée, utilisez de préférence une variable d’environnement ou un fichier de mot de passe protégé, par exemple :

1
2

export BORG_PASSCOMMAND='cat /etc/borg/passphrase'
chmod 600 /etc/borg/passphrase

Ne lancez pas simultanément une sauvegarde, un prune et un compact sur le même dépôt. Si vous devez supprimer les anciennes archives puis récupérer l’espace disque, l’ordre est :

1
2

borg prune ...
borg compact ...

Message 3 sur 6 de l’utilisateur - 31/08/2026 18:30:29: #!/bin/bash

. “/sharenfs/scripts/env/ntfy.env”

Fichier temporaire pour mémoriser toutes les sorties

tmpfile=”$(mktemp)”

Optionnel: affiche même si le script plante

trap ‘cat “$tmpfile”; rm -f “$tmpfile”’ EXIT

compactage des dépôts borg distants

servers=$(cat /sharenfs/pc1/.borg/servers.list) #servers=”pc1 media iceyan.xyz e6230 cwwk asus-xh51 xoyize.xyz” hote_array=(${servers// / }) for hote in “${hote_array[@]}” do export BORG_RSH=’ssh -i /sharenfs/pc1/.borg/’$hote’.borgssh’ export BORG_PASSPHRASE=$(cat /sharenfs/pc1/.borg/$hote.passphrase) export BORG_DEPOT=$(cat /sharenfs/pc1/.borg/$hote.repository) echo $BORG_DEPOT

{ echo “= Dépôt $BORG_DEPOT : $(date -Is) =” echo “borg compact –progress "$BORG_DEPOT"”

err=$(borg compact –progress “$BORG_DEPOT” 2>&1 >/dev/null) ret=$?

if [ $ret -ne 0 ]; then echo “ERREUR ($ret) :” echo “$err” else echo “OK” fi

} »“$tmpfile” done

Message

#

curl –ipv4
-H “X-Email: $NTFY_EMAIL”
-H “Title: 💾​ Compactage dépôts BorgBackup”
-H “Authorization: Bearer $NTFY_TOKEN”
-H “prio:low”
-d “CWWK $0 cat $tmpfile ✔️ Fin compactage dépôts borgbackup”
“$NTFY_URL”

GPT-5.6 Luna: Votre script est globalement adapté aux dépôts distants. Le point principal à corriger est cette redirection :

1

2>&1 >/dev/null

Elle envoie la sortie standard vers /dev/null et ne conserve que la sortie d’erreur. Pour mémoriser toute la sortie de Borg, utilisez simplement :

1

2>&1

Voici une version corrigée et un peu renforcée :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#!/bin/bash

. "/sharenfs/scripts/env/ntfy.env"

tmpfile="$(mktemp)"

cleanup() {
    rm -f "$tmpfile"
}
trap cleanup EXIT

# Lecture des hôtes depuis le fichier
read -r -a hote_array < /sharenfs/pc1/.borg/servers.list

for hote in "${hote_array[@]}"; do
    key="/sharenfs/pc1/.borg/${hote}.borgssh"
    passphrase_file="/sharenfs/pc1/.borg/${hote}.passphrase"
    repository_file="/sharenfs/pc1/.borg/${hote}.repository"

    {
        echo
        echo "===== Hôte : $hote ====="

        if [ ! -r "$key" ]; then
            echo "ERREUR : clé SSH absente ou illisible : $key"
            continue
        fi

        if [ ! -r "$passphrase_file" ]; then
            echo "ERREUR : fichier de phrase secrète absent : $passphrase_file"
            continue
        fi

        if [ ! -r "$repository_file" ]; then
            echo "ERREUR : fichier de dépôt absent : $repository_file"
            continue
        fi

        export BORG_RSH="ssh -i $key"
        export BORG_PASSPHRASE="$(< "$passphrase_file")"
        export BORG_REPO="$(< "$repository_file")"

        echo "Dépôt : $BORG_REPO"
        echo "Début : $(date -Is)"
        echo "Commande : borg compact --progress"

        # Capture la sortie standard et la sortie d'erreur
        sortie="$(borg compact --progress "$BORG_REPO" 2>&1)"
        ret=$?

        printf '%s\n' "$sortie"

        if [ "$ret" -ne 0 ]; then
            echo "ERREUR Borg : code retour $ret"
        else
            echo "OK : compactage terminé"
        fi

        echo "Fin : $(date -Is)"

    } >> "$tmpfile" 2>&1
done

message="$(
    printf 'Fin du compactage des dépôts BorgBackup\n\n'
    cat "$tmpfile"
)"

curl --ipv4 \
    -H "X-Email: $NTFY_EMAIL" \
    -H "Title: 💾 Compactage dépôts BorgBackup" \
    -H "Authorization: Bearer $NTFY_TOKEN" \
    -H "prio: low" \
    --data-binary "$message" \
    "$NTFY_URL"

Votre fichier servers.list peut rester sous forme d’une ligne :

1

pc1 media iceyan.xyz e6230 cwwk asus-xh51 xoyize.xyz

ou contenir plusieurs lignes. En revanche, cette version ne traite pas les lignes contenant des commentaires avec #.

Pour tester un seul dépôt avant de lancer toute la boucle :

1
2
3
4
5
6
7
8

hote="pc1"

export BORG_RSH="ssh -i /sharenfs/pc1/.borg/${hote}.borgssh"
export BORG_PASSPHRASE="$(< "/sharenfs/pc1/.borg/${hote}.passphrase")"
export BORG_REPO="$(< "/sharenfs/pc1/.borg/${hote}.repository")"

borg info "$BORG_REPO"
borg compact --progress "$BORG_REPO"

Deux remarques importantes :

  • BORG_REPO n’est pas indispensable dans votre script puisque le dépôt est passé en argument à borg compact, mais son utilisation rend la configuration plus claire.
  • Le compactage ne supprimera pas d’anciennes sauvegardes. Pour cela, il faut exécuter auparavant un borg prune, puis borg compact pour récupérer l’espace libéré.

Message 4 sur 6 de l’utilisateur - 31/08/2026 18:33:06: Pour les dépôts locaux /mnt/FreeUSB2To/sauvegardes/borgbackup/ cwwk e6230 iceyan.xyz ouestline.xyz pc1 sharenfs xoyaz.xyz yannig.net yannir.xyz

GPT-5.6 Luna: Pour les dépôts locaux, il ne faut pas utiliser BORG_RSH. Le dépôt est directement accessible par son chemin local.

Voici une version adaptée à votre script, avec notification ntfy et une phrase secrète par dépôt :

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

#!/bin/bash

. "/sharenfs/scripts/env/ntfy.env"

BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"
BORG_CONFIG="/sharenfs/pc1/.borg"

tmpfile="$(mktemp)"

cleanup() {
    rm -f "$tmpfile"
}
trap cleanup EXIT

depots=(
    cwwk
    e6230
    iceyan.xyz
    ouestline.xyz
    pc1
    sharenfs
    xoyaz.xyz
    yannig.net
    yannir.xyz
)

for depot in "${depots[@]}"; do
    repo="$BASE/$depot"
    passphrase_file="$BORG_CONFIG/$depot.passphrase"

    {
        echo
        echo "===== Dépôt : $repo ====="
        echo "Début : $(date -Is)"

        if [ ! -d "$repo" ]; then
            echo "ERREUR : dépôt absent : $repo"
            continue
        fi

        if [ ! -r "$passphrase_file" ]; then
            echo "ERREUR : phrase secrète absente : $passphrase_file"
            continue
        fi

        # Aucun BORG_RSH pour les dépôts locaux
        unset BORG_RSH

        export BORG_REPO="$repo"
        export BORG_PASSPHRASE="$(< "$passphrase_file")"

        echo "Commande : borg compact --progress $repo"

        sortie="$(borg compact --progress "$repo" 2>&1)"
        ret=$?

        printf '%s\n' "$sortie"

        if [ "$ret" -ne 0 ]; then
            echo "ERREUR Borg : code retour $ret"
        else
            echo "OK : compactage terminé"
        fi

        echo "Fin : $(date -Is)"

    } >> "$tmpfile" 2>&1
done

message="$(
    printf 'Fin du compactage des dépôts Borg locaux\n\n'
    cat "$tmpfile"
)"

curl --ipv4 \
    -H "X-Email: $NTFY_EMAIL" \
    -H "Title: 💾 Compactage dépôts Borg locaux" \
    -H "Authorization: Bearer $NTFY_TOKEN" \
    -H "prio: low" \
    --data-binary "$message" \
    "$NTFY_URL"

Les fichiers de phrases secrètes attendus sont donc :

1
2
3
4
5
6
7
8
9

/sharenfs/pc1/.borg/cwwk.passphrase
/sharenfs/pc1/.borg/e6230.passphrase
/sharenfs/pc1/.borg/iceyan.xyz.passphrase
/sharenfs/pc1/.borg/ouestline.xyz.passphrase
/sharenfs/pc1/.borg/pc1.passphrase
/sharenfs/pc1/.borg/sharenfs.passphrase
/sharenfs/pc1/.borg/xoyaz.xyz.passphrase
/sharenfs/pc1/.borg/yannig.net.passphrase
/sharenfs/pc1/.borg/yannir.xyz.passphrase

Si tous les dépôts utilisent la même phrase secrète, remplacez :

1

export BORG_PASSPHRASE="$(< "$passphrase_file")"

par, par exemple :

1

export BORG_PASSPHRASE="$(< /sharenfs/pc1/.borg/borg.passphrase)"

Pour tester uniquement le dépôt pc1 :

1
2
3
4

export BORG_PASSPHRASE="$(< /sharenfs/pc1/.borg/pc1.passphrase)"

borg info "/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1"
borg compact --progress "/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1"

Le borg compact ne supprime pas les anciennes archives : il doit être exécuté après un éventuel borg prune ou borg delete.

Message 5 sur 6 de l’utilisateur - 31/08/2026 18:34:56: le contenu de /mnt/FreeUSB2To/sauvegardes/borgbackup peut varier. Il faut lire le contenu du dossier

GPT-5.6 Luna: Oui. Il faut parcourir automatiquement les sous-répertoires de BASE, au lieu de définir la liste manuellement.

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

#!/bin/bash

. "/sharenfs/scripts/env/ntfy.env"

BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"
BORG_CONFIG="/sharenfs/pc1/.borg"

tmpfile="$(mktemp)"

cleanup() {
    rm -f "$tmpfile"
}
trap cleanup EXIT

# Vérification du dossier principal
if [ ! -d "$BASE" ]; then
    echo "ERREUR : dossier absent : $BASE" >&2
    exit 1
fi

# Les dépôts sont les sous-répertoires directs de BASE
shopt -s nullglob

depots=("$BASE"/*)

if [ "${#depots[@]}" -eq 0 ]; then
    echo "Aucun dépôt trouvé dans $BASE" >&2
    exit 1
fi

for repo in "${depots[@]}"; do
    # Ignorer les fichiers et ne traiter que les répertoires
    [ -d "$repo" ] || continue

    depot="$(basename "$repo")"
    passphrase_file="$BORG_CONFIG/$depot.passphrase"

    {
        echo
        echo "===== Dépôt : $repo ====="
        echo "Début : $(date -Is)"

        if [ ! -r "$passphrase_file" ]; then
            echo "ERREUR : phrase secrète absente ou illisible : $passphrase_file"
            continue
        fi

        # Aucun SSH pour les dépôts locaux
        unset BORG_RSH

        export BORG_REPO="$repo"
        export BORG_PASSPHRASE="$(< "$passphrase_file")"

        echo "Commande : borg compact --progress $repo"

        sortie="$(borg compact --progress "$repo" 2>&1)"
        ret=$?

        printf '%s\n' "$sortie"

        if [ "$ret" -ne 0 ]; then
            echo "ERREUR Borg : code retour $ret"
        else
            echo "OK : compactage terminé"
        fi

        echo "Fin : $(date -Is)"

    } >> "$tmpfile" 2>&1
done

message="$(
    printf 'Fin du compactage des dépôts Borg locaux\n\n'
    cat "$tmpfile"
)"

curl --ipv4 \
    -H "X-Email: $NTFY_EMAIL" \
    -H "Title: 💾 Compactage dépôts Borg locaux" \
    -H "Authorization: Bearer $NTFY_TOKEN" \
    -H "prio: low" \
    --data-binary "$message" \
    "$NTFY_URL"

Le script traitera automatiquement, par exemple :

1
2
3

/mnt/FreeUSB2To/sauvegardes/borgbackup/cwwk
/mnt/FreeUSB2To/sauvegardes/borgbackup/e6230
/mnt/FreeUSB2To/sauvegardes/borgbackup/pc1

et tout nouveau sous-répertoire ajouté ultérieurement.

Il cherchera pour chaque dépôt la phrase secrète correspondante :

1
2
3

/sharenfs/pc1/.borg/cwwk.passphrase
/sharenfs/pc1/.borg/e6230.passphrase
/sharenfs/pc1/.borg/pc1.passphrase

Les guillemets autour des variables permettent également de gérer correctement les noms contenant des espaces.

Message 6 sur 6 de l’utilisateur - 31/08/2026 18:40:37: avec “echo” car lancé manuellement

GPT-5.6 Luna: <!– Addressing echo commands

I need to figure out what the user means by wanting to understand echo commands. It seems likely they’re working with a script using echo for progress visibility when manually launched, instead of just notifications. Currently, the output redirects to a temporary file without live feedback. I should suggest using tee to send output to both the terminal and the temporary file. I want to correct the block to keep echo while ensuring the trap doesn’t duplicate at exit. –> Pour un lancement manuel, utilisez tee afin d’afficher chaque message à l’écran tout en le conservant dans le fichier temporaire pour ntfy.

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
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#!/bin/bash

. "/sharenfs/scripts/env/ntfy.env"

BASE="/mnt/FreeUSB2To/sauvegardes/borgbackup"
BORG_CONFIG="/sharenfs/pc1/.borg"

tmpfile="$(mktemp)"
trap 'rm -f "$tmpfile"' EXIT

if [ ! -d "$BASE" ]; then
    echo "ERREUR : dossier absent : $BASE"
    exit 1
fi

shopt -s nullglob
depots=("$BASE"/*)

if [ "${#depots[@]}" -eq 0 ]; then
    echo "Aucun dépôt trouvé dans $BASE"
    exit 1
fi

for repo in "${depots[@]}"; do
    [ -d "$repo" ] || continue

    depot="$(basename "$repo")"
    passphrase_file="$BORG_CONFIG/$depot.passphrase"

    {
        echo
        echo "=========================================="
        echo "Dépôt : $repo"
        echo "Début : $(date -Is)"
        echo "=========================================="

        if [ ! -r "$passphrase_file" ]; then
            echo "ERREUR : phrase secrète absente : $passphrase_file"
            continue
        fi

        unset BORG_RSH

        export BORG_REPO="$repo"
        export BORG_PASSPHRASE="$(< "$passphrase_file")"

        echo "Lancement du compactage..."
        echo "borg compact --progress \"$repo\""

        sortie="$(borg compact --progress "$repo" 2>&1)"
        ret=$?

        echo "$sortie"

        if [ "$ret" -ne 0 ]; then
            echo "ERREUR Borg : code retour $ret"
        else
            echo "OK : compactage terminé"
        fi

        echo "Fin : $(date -Is)"

    } 2>&1 | tee -a "$tmpfile"
done

message="$(
    printf 'Fin du compactage des dépôts Borg locaux\n\n'
    cat "$tmpfile"
)"

curl --ipv4 \
    -H "X-Email: $NTFY_EMAIL" \
    -H "Title: 💾 Compactage dépôts Borg locaux" \
    -H "Authorization: Bearer $NTFY_TOKEN" \
    -H "prio: low" \
    --data-binary "$message" \
    "$NTFY_URL"

echo
echo "Notification envoyée."

La ligne importante est :

1

} 2>&1 | tee -a "$tmpfile"

Elle affiche les sorties dans le terminal et les ajoute simultanément à tmpfile.

Si vous voulez voir la progression Borg en temps réel, évitez de la stocker dans une variable. Remplacez :

1
2
3
4

sortie="$(borg compact --progress "$repo" 2>&1)"
ret=$?

echo "$sortie"

par :

1
2

borg compact --progress "$repo"
ret=$?

Ainsi, la progression s’affichera immédiatement à l’écran. Le bloc complet étant envoyé vers tee, elle sera également enregistrée dans le fichier temporaire.