Eliminar archivos temporales creados en una salida de bash inesperada

Estoy creando archivos temporales a partir de un script bash. Los estoy eliminando al final del procesamiento, pero dado que el script se está ejecutando durante bastante tiempo, si lo mato o simplemente CTRL-C durante la ejecución, los archivos temporales no se eliminan.
¿Hay alguna forma de detectar esos eventos y limpiar los archivos antes de que finalice la ejecución?

Además, ¿existe algún tipo de práctica recomendada para el nombre y la ubicación de esos archivos temporales?
Actualmente no estoy seguro entre usar:

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

y

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

¿O tal vez hay mejores soluciones?

Puede establecer una " trampa " para ejecutar al salir o en un control-c para limpiar.

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

Alternativamente, uno de mis unix-isms favoritos es abrir un archivo y luego eliminarlo mientras aún lo tienes abierto. El archivo permanece en el sistema de archivos y puede leerlo y escribirlo, pero tan pronto como se cierre el programa, el archivo desaparecerá. Sin embargo, no estoy seguro de cómo harías eso en bash.

Por cierto: un argumento que daré a favor de mktemp en lugar de usar su propia solución: si el usuario anticipa que su programa va a crear archivos temporales enormes, es posible que desee configurarlo TMPDIRen un lugar más grande, como / var / tmp. mktemp reconoce eso, su solución hecha a mano (segunda opción) no lo hace. Yo uso con frecuencia TMPDIR=/var/tmp gvim -d foo bar, por ejemplo.

Por lo general, creo un directorio en el que colocar todos mis archivos temporales, e inmediatamente después, creo un controlador EXIT para limpiar este directorio cuando sale el script.

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

Si coloca todos sus archivos temporales debajo $MYTMPDIR, todos se eliminarán cuando su secuencia de comandos salga en la mayoría de las circunstancias. Sin embargo, matar un proceso con SIGKILL (kill -9) mata el proceso de inmediato, por lo que su controlador EXIT no se ejecutará en ese caso.

Desea utilizar el comando trap para manejar la salida del script o señales como CTRL-C. Consulte la Wiki de Greg para obtener más detalles.

Para sus archivos temporales, usar basename $0es una buena idea, además de proporcionar una plantilla que proporcione espacio para suficientes archivos temporales:

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

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

trap 'rm -f $TMP1 $TMP2' EXIT

Solo tenga en cuenta que la respuesta elegida es bashism, lo que significa solución como

trap "{ rm -f $LOCKFILE }" EXIT

funcionaría solo en bash (no detectará Ctrl + c si shell es dasho clásico sh), pero si desea compatibilidad, aún debe enumerar todas las señales que desea atrapar.

También tenga en cuenta que cuando el script sale de la trampa para la señal "0" (también conocido como EXIT) siempre se realiza, lo que resulta en una doble ejecución del trapcomando.

Esa es la razón para no apilar todas las señales en una línea si hay una señal de SALIDA.

Para comprenderlo mejor, consulte el siguiente script que funcionará en diferentes sistemas sin cambios:

#!/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 

Esta solución le dará más control, ya que puede ejecutar parte de su código en la aparición de la señal real justo antes de la salida final ( preExitfunción) y, si es necesario, puede ejecutar algún código en la señal de SALIDA real (etapa final de salida)

La alternativa de usar un nombre de archivo predecible con $$ es un enorme agujero de seguridad y nunca, nunca, nunca debería pensar en usarlo. Incluso si es solo un simple script personal en su PC de un solo usuario. Es un hábito muy malo que no debes adquirir. BugTraq está lleno de incidentes de "archivos temporales inseguros". Consulte aquí , aquí y aquí para obtener más información sobre el aspecto de seguridad de los archivos temporales.

Inicialmente estaba pensando en citar las asignaciones inseguras de TMP1 y TMP2, pero pensándolo bien, probablemente no sería una buena idea .

Prefiero usar tempfileque crea un archivo en / tmp de manera segura y no tiene que preocuparse por su nombre:

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

No puedo creer que tanta gente asuma que un nombre de archivo no contendrá un espacio. El mundo se colapsará si $ TMPDIR se asigna alguna vez al "directorio temporal".

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

Los espacios y otros caracteres especiales como comillas simples y retornos de carro en los nombres de archivos deben considerarse en el código como un requisito de un hábito de programación decente.

No tiene que molestarse en eliminar esos archivos tmp creados con mktemp. De todos modos, se eliminarán más tarde.

Use mktemp si puede, ya que genera más archivos únicos que el prefijo '$$'. Y parece una forma más multiplataforma de crear archivos temporales y luego ponerlos explícitamente en / tmp.