Início / unix / Perguntas / 414892
Accepted
PhilBot
Asked: 2018-01-05 16:31:27 +0800 CST

Como encerrar o comando tee do Linux sem matar o aplicativo do qual ele está recebendo

  • 772

Eu tenho um script bash que é executado enquanto a máquina Linux estiver ligada. Eu começo como mostrado abaixo:

( /mnt/apps/start.sh 2>&1 | tee /tmp/nginx/debug_log.log ) &

Após o lançamento, posso ver o comando tee na saída do meu ps , conforme mostrado abaixo:

$ ps | grep tee
  418 root       0:02 tee /tmp/nginx/debug_log.log
3557 root       0:00 grep tee

Eu tenho uma função que monitora o tamanho do log que o tee produz e mata o comando tee quando o log atinge um determinado tamanho:

monitor_debug_log_size() {
                ## Monitor the file size of the debug log to make sure it does not get too big
                while true; do
                                cecho r "CHECKING DEBUG LOG SIZE... "
                                debugLogSizeBytes=$(stat -c%s "/tmp/nginx/debug_log.log")
                                cecho r "DEBUG LOG SIZE: $debugLogSizeBytes"
                                if [ $((debugLogSizeBytes)) -gt 100000 ]; then
                                                cecho r "DEBUG LOG HAS GROWN TO LARGE... "
                                                sleep 3
                                                #rm -rf /tmp/nginx/debug_log.log 1>/dev/null 2>/dev/null
                                                kill -9 `pgrep -f tee`
                                fi
                                sleep 30
                done
}

Para minha surpresa, matar o comando tee também mata por instância start.sh. Por que é isso? Como posso encerrar o comando tee , mas fazer com que meu start.sh continue em execução? Obrigado.

linux scripting

2 respostas

  1. Best Answer

    Quando teeterminar, o comando que o alimenta continuará em execução, até tentar gravar mais saída. Em seguida, obterá um SIGPIPE (13 na maioria dos sistemas) por tentar gravar em um pipe sem leitores.

    Se você modificar seu script para interceptar o SIGPIPE e tomar alguma ação apropriada (como parar de gravar a saída), você poderá fazer com que ele continue depois que o tee for encerrado.

    Melhor ainda, em vez de matar tee , use logrotatecom a copytruncateopção de simplicidade.

    Para citar logrotate(8):

    copytruncate

    Trunque o arquivo de log original no local depois de criar uma cópia, em vez de mover o arquivo de log antigo e, opcionalmente, criar um novo. Ele pode ser usado quando algum programa não pode ser instruído a fechar seu arquivo de log e, portanto, pode continuar gravando (anexando) no arquivo de log anterior para sempre. Observe que há uma fatia de tempo muito pequena entre copiar o arquivo e truncá-lo, portanto, alguns dados de registro podem ser perdidos. Quando esta opção é usada, a opção de criação não terá efeito, pois o arquivo de log antigo permanece no lugar.

    • 36

  2. Explicando o "porquê"

    Resumindo: se as falhas de gravação não causassem a saída de um programa (por padrão), teríamos uma bagunça. Considere find . | head -n 10- você não quer findcontinuar rodando, escaneando o resto do seu disco rígido, depois headde pegar as 10 linhas necessárias e prosseguir.

    Fazendo melhor: gire dentro do seu registrador

    Considere o seguinte, que não usa teenada, como um exemplo demonstrativo:

    #!/usr/bin/env bash

file=${1:-debug.log}                     # filename as 1st argument
max_size=${2:-100000}                    # max size as 2nd argument
size=$(stat --format=%s -- "$file") || exit  # Use GNU stat to retrieve size
exec >>"$file"                           # Open file for append

while IFS= read -r line; do              # read a line from stdin
  size=$(( size + ${#line} + 1 ))        # add line's length + 1 to our counter
  if (( size > max_size )); then         # and if it exceeds our maximum...
    mv -- "$file" "$file.old"            # ...rename the file away...
    exec >"$file"                        # ...and reopen a new file as stdout
    size=0                               # ...resetting our size counter
  fi
  printf '%s\n' "$line"                  # regardless, append to our current stdout
done

    Se executado como:

    /mnt/apps/start.sh 2>&1 | above-script /tmp/nginx/debug_log

    ...isso começará anexando a /tmp/nginx/debug_log, renomeando o arquivo para /tmp/nginx/debug_log.oldquando houver mais de 100 KB de conteúdo. Como o próprio registrador está fazendo a rotação, não há tubo quebrado, nenhum erro e nenhuma janela de perda de dados quando a rotação ocorre - cada linha será gravada em um arquivo ou outro.

    Obviamente, implementar isso no bash nativo é ineficiente, mas o exemplo acima é ilustrativo. Existem vários programas disponíveis que implementarão a lógica acima para você. Considerar:

    • svlogd, o registrador de serviços do pacote Runit.
    • s6-log, uma alternativa mantida ativamente da suíte skanet.
    • multilogda DJB Daemontools, o avô desta família de ferramentas de supervisão e monitoramento de processos.
    • 3

relate perguntas