Rimozione dei file temporanei creati in un'uscita bash imprevista

Sto creando file temporanei da uno script bash. Li elimino alla fine dell'elaborazione, ma poiché lo script è in esecuzione per un periodo piuttosto lungo, se lo uccido o semplicemente CTRL-C durante l'esecuzione, i file temporanei non vengono eliminati.
C'è un modo per catturare quegli eventi e ripulire i file prima del termine dell'esecuzione?

Inoltre, esiste una sorta di best practice per la denominazione e la posizione di quei file temporanei?
Al momento non sono sicuro se usare:

TMP1=`mktemp -p /tmp`
TMP2=`mktemp -p /tmp`
...

e

TMP1=/tmp/`basename $0`1.$$
TMP2=/tmp/`basename $0`2.$$
...

O forse ci sono soluzioni migliori?

Puoi impostare una " trappola " da eseguire in uscita o su un control-c per ripulire.

trap "{ rm -f $LOCKFILE; }" EXIT

In alternativa, uno dei miei unix-ismi preferiti è aprire un file e quindi eliminarlo mentre lo hai ancora aperto. Il file rimane nel file system e puoi leggerlo e scriverlo, ma non appena il programma esce, il file scompare. Non sono sicuro di come faresti a bash, però.

BTW: Un argomento che darò a favore di mktemp invece di usare la tua soluzione: se l'utente prevede che il tuo programma creerà enormi file temporanei, potrebbe volerlo impostare TMPDIRda qualche parte più grande, come / var / tmp. mktemp lo riconosce, la tua soluzione fatta a mano (seconda opzione) no. Uso spesso TMPDIR=/var/tmp gvim -d foo bar, ad esempio.

Di solito creo una directory in cui posizionare tutti i miei file temporanei e, subito dopo, creo un gestore EXIT per ripulire questa directory quando lo script esce.

MYTMPDIR=$(mktemp -d)
trap "rm -rf $MYTMPDIR" EXIT

Se metti tutti i tuoi file temporanei sotto $MYTMPDIR, nella maggior parte dei casi verranno eliminati tutti quando lo script viene chiuso. Tuttavia, uccidere un processo con SIGKILL (kill -9) interrompe immediatamente il processo, quindi il gestore EXIT non verrà eseguito in quel caso.

Si desidera utilizzare il comando trap per gestire l'uscita dallo script o segnali come CTRL-C. Vedi il Wiki di Greg per i dettagli.

Per i tuoi basename $0file temporanei , l'utilizzo è una buona idea, oltre a fornire un modello che fornisce spazio per un numero sufficiente di file temporanei:

tempfile() {
    tempprefix=$(basename "$0")
    mktemp /tmp/${tempprefix}.XXXXXX
}

TMP1=$(tempfile)
TMP2=$(tempfile)

trap 'rm -f $TMP1 $TMP2' EXIT

Tieni presente che la risposta scelta è bashism, che significa soluzione come

trap "{ rm -f $LOCKFILE }" EXIT

funzionerebbe solo in bash (non catturerà Ctrl + c se la shell è dasho classica sh), ma se vuoi la compatibilità, devi comunque enumerare tutti i segnali che vuoi intercettare.

Inoltre, tieni presente che quando lo script esce dalla trappola per il segnale "0" (noto anche come EXIT) viene sempre eseguita la doppia esecuzione del trapcomando.

Questo è il motivo per non impilare tutti i segnali in una riga se c'è il segnale di USCITA.

Per comprenderlo meglio, guarda il seguente script che funzionerà su diversi sistemi senza modifiche:

#!/bin/sh

on_exit() {
  echo 'Cleaning up...(remove tmp files, etc)'
}

on_preExit() {
  echo
  echo 'Exiting...' # Runs just before actual exit,
                    # shell will execute EXIT(0) after finishing this function
                    # that we hook also in on_exit function
  exit 2
}


trap on_exit EXIT                           # EXIT = 0
trap on_preExit HUP INT QUIT TERM STOP PWR  # 1 2 3 15 30


sleep 3 # some actual code...

exit 

Questa soluzione ti darà un maggiore controllo poiché puoi eseguire parte del tuo codice al verificarsi del segnale effettivo appena prima dell'uscita finale ( preExitfunzione) e, se necessario, puoi eseguire del codice al segnale di USCITA effettivo (fase finale di uscita)

L'alternativa di utilizzare un nome di file prevedibile con $$ è una falla nella sicurezza e non dovresti mai, mai, mai pensare di usarlo. Anche se è solo un semplice script personale sul tuo PC singolo utente. È una pessima abitudine che non dovresti ottenere. BugTraq è pieno di incidenti relativi a "file temporanei non sicuri". Vedi qui , qui e qui per ulteriori informazioni sull'aspetto della sicurezza dei file temporanei.

Inizialmente stavo pensando di citare i compiti insicuri di TMP1 e TMP2, ma ripensandoci probabilmente non sarebbe stata una buona idea .

Preferisco usare tempfileche crea un file in / tmp in modo sicuro e non devi preoccuparti della sua denominazione:

tmp=$(tempfile -s "your_sufix")
trap "rm -f '$tmp'" exit

Non riesco a credere che così tante persone presumono che un nome di file non conterrà uno spazio. Il mondo andrà in crash se $ TMPDIR viene mai assegnato alla "directory temporanea".

zTemp=$(mktemp --tmpdir "$(basename "$0")-XXX.ps")
trap "rm -f ${zTemp@Q}" EXIT

Gli spazi e altri caratteri speciali come virgolette singole e ritorni a capo nei nomi di file dovrebbero essere considerati nel codice come un requisito per un'abitudine di programmazione decente.

Non devi preoccuparti di rimuovere quei file tmp creati con mktemp. Verranno comunque cancellati in seguito.

Usa mktemp se puoi poiché genera più file univoci quindi il prefisso "$$". E sembra più un modo multipiattaforma per creare file temporanei e poi inserirli esplicitamente in / tmp.