Removendo arquivos temporários criados em saída inesperada do bash

Estou criando arquivos temporários de um script bash. Estou excluindo-os no final do processamento, mas como o script está em execução há um bom tempo, se eu encerrá-lo ou simplesmente CTRL-C durante a execução, os arquivos temporários não serão excluídos.
Existe uma maneira de capturar esses eventos e limpar os arquivos antes que a execução termine?

Além disso, existe algum tipo de prática recomendada para a nomenclatura e a localização desses arquivos temporários?
No momento, não tenho certeza entre usar:

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

e

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

Ou talvez existam soluções melhores?

Você pode definir uma " armadilha " para executar na saída ou em um control-c para limpar.

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

Como alternativa, um dos meus unix-isms favoritos é abrir um arquivo e excluí-lo enquanto ainda estiver aberto. O arquivo permanece no sistema de arquivos e você pode lê-lo e gravá-lo, mas assim que o programa termina, o arquivo desaparece. Não tenho certeza de como você faria isso no bash, no entanto.

BTW: Um argumento a favor do mktemp em vez de usar sua própria solução: se o usuário antecipar que seu programa criará arquivos temporários enormes, ele pode querer definir TMPDIRpara algum lugar maior, como / var / tmp. mktemp reconhece isso, sua solução enrolada à mão (segunda opção) não. Eu uso freqüentemente TMPDIR=/var/tmp gvim -d foo bar, por exemplo.

Normalmente crio um diretório no qual coloco todos os meus arquivos temporários e, imediatamente depois, crio um manipulador EXIT para limpar esse diretório quando o script for encerrado.

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

Se você colocar todos os seus arquivos temporários em $MYTMPDIR, todos eles serão excluídos quando o script for encerrado na maioria das circunstâncias. Eliminar um processo com SIGKILL (kill -9) elimina o processo imediatamente, portanto, seu manipulador EXIT não será executado nesse caso.

Você deseja usar o comando trap para lidar com a saída do script ou sinais como CTRL-C. Consulte o Wiki de Greg para obter detalhes.

Para seus arquivos temporários, basename $0é uma boa ideia usar , além de fornecer um modelo que forneça espaço para arquivos temporários suficientes:

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

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

trap 'rm -f $TMP1 $TMP2' EXIT

Basta ter em mente que a resposta escolhida é bashism, o que significa solução como

trap "{ rm -f $LOCKFILE }" EXIT

funcionaria apenas no bash (não irá capturar Ctrl + C se o shell for dashou clássico sh), mas se você quiser compatibilidade, então ainda precisa enumerar todos os sinais que deseja capturar.

Também tenha em mente que, quando o script sai, a armadilha do sinal "0" (também conhecida como EXIT) é sempre executada, resultando em dupla execução do trapcomando.

Essa é a razão para não empilhar todos os sinais em uma linha se houver sinal EXIT.

Para melhor entendê-lo, observe o seguinte script que funcionará em diferentes sistemas sem alterações:

#!/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 solução lhe dará mais controle, pois você pode executar parte do seu código na ocorrência do sinal real antes da saída final ( preExitfunção) e, se necessário, pode executar algum código no sinal EXIT real (estágio final de saída)

A alternativa de usar um nome de arquivo previsível com $$ é uma brecha de segurança e você nunca, jamais, deve pensar em usá-lo. Mesmo que seja apenas um simples script pessoal em seu PC de usuário único. É um péssimo hábito que você não deve adquirir. BugTraq está cheio de incidentes de "arquivo temporário inseguro". Consulte aqui , aqui e aqui para obter mais informações sobre o aspecto de segurança de arquivos temporários.

Eu estava inicialmente pensando em citar as atribuições inseguras de TMP1 e TMP2, mas pensando bem, provavelmente não seria uma boa ideia .

Eu prefiro usar o tempfileque cria um arquivo em / tmp de maneira segura e você não precisa se preocupar com sua nomenclatura:

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

Não posso acreditar que tantas pessoas presumam que um nome de arquivo não conterá um espaço. O mundo irá travar se $ TMPDIR for atribuído ao "diretório temporário".

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

Espaços e outros caracteres especiais como aspas simples e retornos de carro em nomes de arquivo devem ser considerados no código como um requisito para um hábito de programação decente.

Você não precisa se preocupar em remover os arquivos tmp criados com mktemp. Eles serão excluídos de qualquer maneira mais tarde.

Use mktemp se puder, pois ele gera mais arquivos exclusivos do que o prefixo '$$'. E parece uma forma mais multiplataforma de criar arquivos temporários e, em seguida, colocá-los explicitamente em / tmp.