Estou usando o tail -f para monitorar um arquivo de log que está sendo gravado ativamente. Quando uma determinada sequência de caracteres é gravada no arquivo de log, desejo encerrar o monitoramento e continuar com o restante do meu script.

Atualmente estou usando:

tail -f logfile.log | grep -m 1 "Server Started"

Quando a string é encontrada, o grep é encerrado conforme o esperado, mas preciso encontrar uma maneira de fazer com que o comando tail seja fechado também para que o script possa continuar.

Um simples liner POSIX

Aqui está uma linha simples. Ele não precisa de truques específicos para o bash ou não POSIX, nem mesmo um pipe nomeado. Tudo o que você realmente precisa é desacoplar o término de tailfrom grep. Dessa forma, assim que grepterminar, o script poderá continuar mesmo se tailainda não tiver terminado. Portanto, esse método simples o levará até lá:

( tail -f -n0 logfile.log & ) | grep -q "Server Started"

grepirá bloquear até encontrar a string e, em seguida, sairá. Ao tailexecutar a partir de seu próprio sub-shell, podemos colocá-lo em segundo plano para que seja executado de forma independente. Enquanto isso, o shell principal está livre para continuar a execução do script assim que grepsair. tailpermanecerá em seu sub-shell até que a próxima linha seja gravada no arquivo de log e saia (possivelmente mesmo depois que o script principal for finalizado). O ponto principal é que o pipeline não espera mais tailterminar, portanto o pipeline sai assim que grepsai.

Alguns pequenos ajustes:

• A opção -n0 para tailiniciar a leitura da última linha atual do arquivo de log, caso a sequência exista anteriormente no arquivo de log.
• Você pode querer dar tail-F ao invés de -f. Não é POSIX, mas permite tailtrabalhar mesmo se o log for girado enquanto aguarda.
• A opção -q em vez de -m1 grepsai após a primeira ocorrência, mas sem imprimir a linha de acionamento. Também é POSIX, o que -m1 não é.

A resposta aceita não está funcionando para mim, além de ser confusa e alterar o arquivo de log.

Estou usando algo parecido com isto:

tail -f logfile.log | while read LOGLINE
do
   [[ "${LOGLINE}" == *"Server Started"* ]] && pkill -P $$ tail
done

Se a linha de log corresponder ao padrão, mate o tailiniciado por este script.

Nota: se você também quiser visualizar a saída na tela, faça | tee /dev/ttyeco na linha antes de testar no loop while.

Se você estiver usando o Bash (pelo menos, mas parece que não está definido pelo POSIX, pode estar ausente em alguns shells), você pode usar a sintaxe

grep -m 1 "Server Started" <(tail -f logfile.log)

Funciona praticamente como as soluções FIFO já mencionadas, mas muito mais simples de escrever.

Existem algumas maneiras tailde sair:

Má abordagem: forçar taila escrever outra linha

Você pode forçar taila escrever outra linha de saída imediatamente após grepencontrar uma correspondência e sair. Isso fará com tailque obtenha um SIGPIPE, fazendo com que ele saia. Uma maneira de fazer isso é modificar o arquivo que está sendo monitorado tailapós as grepsaídas.

Aqui está um exemplo de código:

tail -f logfile.log | grep -m 1 "Server Started" | { cat; echo >>logfile.log; }

Neste exemplo, catnão sairá até grepque o stdout seja fechado, portanto, tailé provável que você não consiga gravar no pipe antes de grepter a chance de fechar o stdin. caté usado para propagar a saída padrão de grepnão modificado.

Essa abordagem é relativamente simples, mas existem várias desvantagens:

• Se grepfechar stdout antes de fechar stdin, sempre haverá uma condição de corrida: grepfecha stdout, acionando catpara sair, acionando echo, acionando tailpara emitir uma linha. Se essa linha é enviada para grepantes grepde fechar o stdin, tailnão será exibida SIGPIPEaté que ela escreva outra linha.
• Requer acesso de gravação ao arquivo de log.
• Você deve aceitar a modificação do arquivo de log.
• Você pode corromper o arquivo de log se gravar ao mesmo tempo que outro processo (as gravações podem ser intercaladas, fazendo com que uma nova linha apareça no meio de uma mensagem de log).
• Essa abordagem é específica para tail- não funcionará com outros programas.
• O terceiro estágio do pipeline dificulta o acesso ao código de retorno do segundo estágio do pipeline (a menos que você esteja usando uma extensão POSIX, como basha PIPESTATUSmatriz de). Isso não é muito importante nesse caso, porque grepsempre retornará 0, mas, em geral, o estágio intermediário pode ser substituído por um comando diferente cujo código de retorno você se preocupa (por exemplo, algo que retorne 0 quando o "servidor iniciado" for detectado, 1 quando "servidor falhou ao iniciar" for detectado).

As próximas abordagens evitam essas limitações.

Uma abordagem melhor: evitar tubulações

Você pode usar um FIFO para evitar completamente o pipeline, permitindo que a execução continue assim que o grepretorno for retornado. Por exemplo:

fifo=/tmp/tmpfifo.$$
mkfifo "${fifo}" || exit 1
tail -f logfile.log >${fifo} &
tailpid=$! # optional
grep -m 1 "Server Started" "${fifo}"
kill "${tailpid}" # optional
rm "${fifo}"

As linhas marcadas com o comentário # optionalpodem ser removidas e o programa ainda funcionará; tailpermanecerá apenas até que leia outra linha de entrada ou seja morto por algum outro processo.

As vantagens dessa abordagem são:

• você não precisa modificar o arquivo de log
• a abordagem funciona para outros utilitários além tail
• não sofre de uma condição de corrida
• você pode facilmente obter o valor de retorno grep(ou qualquer comando alternativo que esteja usando)

A desvantagem dessa abordagem é a complexidade, especialmente o gerenciamento do FIFO: você precisará gerar com segurança um nome de arquivo temporário e garantir que o FIFO temporário seja excluído, mesmo que o usuário pressione Ctrl-C no meio de o script. Isso pode ser feito usando uma armadilha.

Abordagem alternativa: envie uma mensagem para matar tail

Você pode obter o tailestágio do pipeline para sair enviando um sinal como SIGTERM. O desafio é saber com segurança duas coisas no mesmo local no código: tailo PID e se grepfoi encerrado.

Com um pipeline como tail -f ... | grep ...esse, é fácil modificar o primeiro estágio do pipeline para salvar tailo PID de uma variável em segundo plano taile lendo $!. Também é fácil modificar o segundo estágio do pipeline para executar killquando grepsair. O problema é que os dois estágios do pipeline são executados em "ambientes de execução" separados (na terminologia do padrão POSIX), portanto, o segundo estágio do pipeline não pode ler nenhuma variável definida pelo primeiro estágio do pipeline. Sem o uso de variáveis ​​de shell, o segundo estágio deve, de alguma forma, descobrir o tailPID para que ele possa matar tailquando grepretorna, ou o primeiro estágio deve ser notificado de alguma forma quando grepretorna.

O segundo estágio pode ser usado pgreppara obter tailo PID, mas isso não é confiável (você pode corresponder ao processo errado) e não pgrepé portátil ( não é especificado pelo padrão POSIX).

O primeiro estágio pode enviar o PID para o segundo estágio através do pipe, usando echoo PID, mas essa string será misturada com taila saída. A desmultiplexação dos dois pode exigir um esquema de escape complexo, dependendo da saída de tail.

Você pode usar um FIFO para que o segundo estágio do pipeline notifique o primeiro estágio do pipeline quando grepsair. Então o primeiro estágio pode matar tail. Aqui está um exemplo de código:

fifo=/tmp/notifyfifo.$$
mkfifo "${fifo}" || exit 1
{
    # run tail in the background so that the shell can
    # kill tail when notified that grep has exited
    tail -f logfile.log &
    # remember tail's PID
    tailpid=$!
    # wait for notification that grep has exited
    read foo <${fifo}
    # grep has exited, time to go
    kill "${tailpid}"
} | {
    grep -m 1 "Server Started"
    # notify the first pipeline stage that grep is done
    echo >${fifo}
}
# clean up
rm "${fifo}"

Essa abordagem tem todos os prós e contras da abordagem anterior, exceto que é mais complicada.

Um aviso sobre buffer

O POSIX permite que os fluxos stdin e stdout sejam totalmente armazenados em buffer, o que significa que taila saída pode não ser processada por grepum tempo arbitrariamente longo. Não deve haver nenhum problema nos sistemas GNU: o GNU grepusa read(), o que evita todos os buffers, e o GNU tail -ffaz chamadas regulares ao fflush()gravar no stdout. Os sistemas não-GNU podem precisar fazer algo especial para desativar ou liberar regularmente os buffers.

Deixe-me expandir na resposta do 00prometheus (qual é a melhor).

Talvez você deva usar um tempo limite em vez de esperar indefinidamente.

A função bash abaixo será bloqueada até que o termo de pesquisa especificado apareça ou que um tempo limite seja atingido.

O status de saída será 0 se a sequência for encontrada dentro do tempo limite.

wait_str() {
  local file="$1"; shift
  local search_term="$1"; shift
  local wait_time="${1:-5m}"; shift # 5 minutes as default timeout

  (timeout $wait_time tail -F -n0 "$file" &) | grep -q "$search_term" && return 0

  echo "Timeout of $wait_time reached. Unable to find '$search_term' in '$file'"
  return 1
}

Talvez o arquivo de log ainda não exista logo após o lançamento do servidor. Nesse caso, você deve esperar que ele apareça antes de procurar a string:

wait_server() {
  echo "Waiting for server..."
  local server_log="$1"; shift
  local wait_time="$1"; shift

  wait_file "$server_log" 10 || { echo "Server log file missing: '$server_log'"; return 1; }

  wait_str "$server_log" "Server Started" "$wait_time"
}

wait_file() {
  local file="$1"; shift
  local wait_seconds="${1:-10}"; shift # 10 seconds as default timeout

  until test $((wait_seconds--)) -eq 0 -o -f "$file" ; do sleep 1; done

  ((++wait_seconds))
}

Veja como você pode usá-lo:

wait_server "/var/log/server.log" 5m && \
echo -e "\n-------------------------- Server READY --------------------------\n"

Então, depois de fazer alguns testes, encontrei uma maneira rápida de 1 linha para fazer isso funcionar. Parece que tail -f será encerrado quando o grep for encerrado, mas há um problema. Parece ser acionado apenas se o arquivo for aberto e fechado. Eu consegui isso anexando a string vazia ao arquivo quando grep encontra a correspondência.

tail -f logfile |grep -m 1 "Server Started" | xargs echo "" >> logfile \;

Não sei por que o abrir / fechar o arquivo aciona a cauda para perceber que o canal está fechado, portanto, não confio nesse comportamento. mas parece funcionar por enquanto.

Razão pelo qual fecha, observe o sinalizador -F versus o sinalizador -f.

Atualmente, como indicado, todas as tail -fsoluções aqui correm o risco de selecionar uma linha "Iniciada pelo servidor" registrada anteriormente (o que pode ou não ser um problema no seu caso específico, dependendo do número de linhas registradas e da rotação do arquivo de log / truncamento).

Em vez de complicar demais as coisas, use apenas uma inteligência tail, como bmike mostrou com um snippit perl. A solução mais simples é a retailque possui suporte a regex integrado com padrões de condição de início e parada :

retail -f -u "Server Started" server.log > /dev/null

Isso seguirá o arquivo normalmente tail -faté que a primeira nova instância dessa sequência seja exibida e saia. (A -uopção não dispara nas linhas existentes nas últimas 10 linhas do arquivo quando no modo "seguir" normal).

Se você usa o GNU tail(do coreutils ), a próxima opção mais simples é usar --pide um FIFO (pipe nomeado):

mkfifo ${FIFO:=serverlog.fifo.$$}
grep -q -m 1 "Server Started" ${FIFO}  &
tail -n 0 -f server.log  --pid $! >> ${FIFO}
rm ${FIFO}

Um FIFO é usado porque os processos devem ser iniciados separadamente para obter e passar um PID. A FIFO ainda sofre com o mesmo problema de pendurar em torno de uma gravação oportuna a causa tailpara receber um SIGPIPE , use a --pidopção para que tailas saídas quando se percebe que grepfoi terminado (convencionalmente usado para monitorar o escritor processo em vez do leitor , mas taildoesn' realmente não me importo). A opção -n 0é usada com tailpara que as linhas antigas não disparem uma correspondência.

Por fim, você pode usar uma cauda com estado , isso armazenará o deslocamento do arquivo atual para que as chamadas subsequentes mostrem apenas novas linhas (ele também lida com a rotação do arquivo). Este exemplo usa o antigo FWTK retail*:

retail "${LOGFILE:=server.log}" > /dev/null   # skip over current content
while true; do
    [ "${LOGFILE}" -nt ".${LOGFILE}.off" ] && 
       retail "${LOGFILE}" | grep -q "Server Started" && break
    sleep 2
done

_{* Observe, mesmo nome, programa diferente da opção anterior.}

Em vez de ter um loop de sobrecarga da CPU, compare o registro de data e hora do arquivo com o arquivo de estado ( .${LOGFILE}.off) e durma. Use " -T" para especificar o local do arquivo de estado, se necessário, o que precede assume o diretório atual. Sinta-se à vontade para ignorar essa condição ou, no Linux, você pode usar o mais eficiente inotifywait:

retail "${LOGFILE:=server.log}" > /dev/null
while true; do
    inotifywait -qq "${LOGFILE}" && 
       retail "${LOGFILE}" | grep -q "Server Started" && break
done

Isso será um pouco complicado, pois você terá que entrar no controle e sinalização do processo. Mais kludgey seria uma solução de dois scripts usando o rastreamento PID. Melhor seria usar pipes nomeados como este.

Qual script de shell você está usando?

Para uma solução rápida e suja, um script - eu faria um script perl usando File: Tail

use File::Tail;
$file=File::Tail->new(name=>$name, maxinterval=>300, adjustafter=>7);
while (defined($line=$file->read)) {
    last if $line =~ /Server started/;
}

Portanto, em vez de imprimir dentro do loop while, você pode filtrar a correspondência de sequência e interromper o loop while para permitir que o script continue.

Qualquer um destes deve envolver apenas um pouco de aprendizado para implementar o controle de fluxo de observação que você está procurando.

aguarde o arquivo aparecer

while [ ! -f /path/to/the.file ] 
do sleep 2; done

aguarde a seqüência de caracteres apper no arquivo

while ! grep "the line you're searching for" /path/to/the.file  
do sleep 10; done

https://superuser.com/a/743693/129669

Não consigo imaginar uma solução mais limpa que esta:

#!/usr/bin/env bash
# file : untail.sh
# usage: untail.sh logfile.log "Server Started"
(echo $BASHPID; tail -f $1) | while read LINE ; do
    if [ -z $TPID ]; then
        TPID=$LINE # the first line is used to store the previous subshell PID
    else
        echo "$LINE"; [[ "$LINE" == *"${*:2}"* ]] && kill -3 $TPID && break
    fi
done

ok, talvez o nome possa estar sujeito a melhorias ...

Vantagens:

• ele não usa nenhum utilitário especial
• não escreve no disco
• graciosamente sai da cauda e fecha o cano
• é bem curto e fácil de entender

Você não precisa de cauda para fazer isso. Eu acho que o comando watch é o que você está procurando. O comando watch monitora a saída de um arquivo e pode ser finalizado com a opção -g quando a saída foi alterada.

watch -g grep -m 1 "Server Started" logfile.log && Yournextaction

Alex, acho que este irá ajudá-lo muito.

tail -f logfile |grep -m 1 "Server Started" | xargs echo "" >> /dev/null ;

este comando nunca fornecerá uma entrada no arquivo de log, mas cumprimentará silenciosamente ...

Aqui está uma solução muito melhor que não exige que você escreva no arquivo de log, o que é muito perigoso ou mesmo impossível em alguns casos.

sh -c 'tail -n +0 -f /tmp/foo | { sed "/EOF/ q" && kill $$ ;}'

Atualmente, ele tem apenas um efeito colateral, o tailprocesso permanecerá em segundo plano até que a próxima linha seja gravada no log.

As outras soluções aqui têm vários problemas:

• se o processo de registro já estiver inativo ou inativo durante o loop, eles serão executados indefinidamente
• editar um log que deve ser exibido apenas
• escrever desnecessariamente um arquivo adicional
• não permitindo lógica adicional

Aqui está o que eu descobri usando o tomcat como exemplo (remova os hashes se você quiser ver o log enquanto ele é iniciado):

function startTomcat {
    loggingProcessStartCommand="${CATALINA_HOME}/bin/startup.sh"
    loggingProcessOwner="root"
    loggingProcessCommandLinePattern="${JAVA_HOME}"
    logSearchString="org.apache.catalina.startup.Catalina.start Server startup"
    logFile="${CATALINA_BASE}/log/catalina.out"

    lineNumber="$(( $(wc -l "${logFile}" | awk '{print $1}') + 1 ))"
    ${loggingProcessStartCommand}
    while [[ -z "$(sed -n "${lineNumber}p" "${logFile}" | grep "${logSearchString}")" ]]; do
        [[ -z "$(ps -ef | grep "^${loggingProcessOwner} .* ${loggingProcessCommandLinePattern}" | grep -v grep)" ]] && { echo "[ERROR] Tomcat failed to start"; return 1; }
        [[ $(wc -l "${logFile}" | awk '{print $1}') -lt ${lineNumber} ]] && continue
        #sed -n "${lineNumber}p" "${logFile}"
        let lineNumber++
    done
    #sed -n "${lineNumber}p" "${logFile}"
    echo "[INFO] Tomcat has started"
}

O tailcomando pode ser em segundo plano e seu pid ecoou no grepsubshell. No grepsubshell, um manipulador de trap no EXIT pode matar o tailcomando.

( (sleep 1; exec tail -f logfile.log) & echo $! ; wait ) | 
     (trap 'kill "$pid"' EXIT; pid="$(head -1)"; grep -m 1 "Server Started")

Leia todos eles. tldr: desacopla a terminação da cauda do grep.

As duas formas mais convenientes são

( tail -f logfile.log & ) | grep -q "Server Started"

e se você tiver festança

grep -m 1 "Server Started" <(tail -f logfile.log)

Mas se a cauda em segundo plano o incomoda, há uma maneira mais agradável do que uma resposta quino ou qualquer outra aqui. Requer festança.

coproc grep -m 1 "Server Started"
tail -F /tmp/x --pid $COPROC_PID >&${COPROC[1]}

Ou se não é a cauda que está produzindo coisas,

coproc command that outputs
grep -m 1 "Sever Started" ${COPROC[0]}
kill $COPROC_PID

Tente usar inotify (inotifywait)

Você configura o inotifywait para qualquer alteração no arquivo e, em seguida, verifique o arquivo com grep, se não encontrado, execute novamente o inotifywait, se encontrado sair do loop ...

Você deseja sair assim que a linha for gravada, mas também deseja sair após um tempo limite:

if (timeout 15s tail -F -n0 "stdout.log" &) | grep -q "The string that says the startup is successful" ; then
    echo "Application started with success."
else
    echo "Startup failed."
    tail stderr.log stdout.log
    exit 1
fi

que tal agora:

enquanto verdadeiro; Faça se [ ! -z $ (grep "myRegEx" myLog.log)]; então quebre; fi; feito