Saya menggunakan tail -f untuk memonitor file log yang sedang ditulis secara aktif. Ketika string tertentu ditulis ke file log, saya ingin keluar dari pemantauan, dan melanjutkan dengan sisa skrip saya.

Saat ini saya menggunakan:

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

Ketika string ditemukan, grep berhenti seperti yang diharapkan, tetapi saya perlu menemukan cara untuk membuat perintah tail juga berhenti sehingga skrip dapat melanjutkan.

Satu-baris POSIX sederhana

Berikut ini adalah one-liner sederhana. Tidak perlu trik bash-spesifik atau non-POSIX, atau bahkan pipa bernama. Semua Anda benar-benar butuhkan adalah untuk memisahkan penghentian taildari grep. Dengan begitu, sekali grepberakhir, skrip dapat berlanjut meskipun tailbelum berakhir. Jadi metode sederhana ini akan membantu Anda:

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

grepakan memblokir sampai telah menemukan string, di mana ia akan keluar. Dengan tailmenjalankan dari sub-shell sendiri, kita dapat menempatkannya di latar belakang sehingga berjalan secara independen. Sementara itu, shell utama bebas untuk melanjutkan eksekusi skrip segera setelah grepkeluar. tailakan berlama-lama di sub-shellnya sampai baris berikutnya telah ditulis ke logfile, dan kemudian keluar (mungkin bahkan setelah skrip utama dihentikan). Poin utama adalah bahwa pipa tidak lagi menunggu untuk tailberakhir, sehingga pipa keluar segera setelah grepkeluar.

Beberapa perubahan kecil:

• Opsi -n0 untuk tailmembuatnya mulai membaca dari baris terakhir logfile saat ini, seandainya string ada sebelumnya di logfile.
• Anda mungkin ingin memberikan tail-F daripada -f. Ini bukan POSIX, tetapi memungkinkan tailuntuk bekerja bahkan jika log diputar sambil menunggu.
• Opsi -q daripada -m1 membuat grepberhenti setelah kejadian pertama, tetapi tanpa mencetak garis pemicu. Juga POSIX, yang -m1 tidak.

Jawaban yang diterima tidak berfungsi untuk saya, ditambah lagi membingungkan dan mengubah file log.

Saya menggunakan sesuatu seperti ini:

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

Jika baris log cocok dengan pola, bunuh tailmulai dengan skrip ini.

Catatan: jika Anda ingin juga melihat output di layar, pilih salah satu | tee /dev/ttyatau gema garis sebelum menguji di loop sementara.

Jika Anda menggunakan Bash (setidaknya, tetapi tampaknya itu tidak didefinisikan oleh POSIX, jadi mungkin ada beberapa shell yang hilang), Anda dapat menggunakan sintaksisnya

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

Ini berfungsi sangat mirip dengan solusi FIFO yang telah disebutkan, tetapi jauh lebih mudah untuk ditulis.

Ada beberapa cara tailuntuk keluar:

Pendekatan yang Buruk: Memaksa tailuntuk menulis baris lain

Anda dapat memaksa tailuntuk menulis baris output lain segera setelah grepmenemukan kecocokan dan keluar. Ini akan menyebabkan tailuntuk mendapatkan SIGPIPE, menyebabkannya keluar. Salah satu cara untuk melakukan ini adalah memodifikasi file yang dipantau tailsetelah grepkeluar.

Berikut ini beberapa contoh kode:

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

Dalam contoh ini, cattidak akan keluar sampai grepstdout ditutup, jadi tailtidak mungkin untuk dapat menulis ke pipa sebelum grepmemiliki kesempatan untuk menutup stdinnya. catdigunakan untuk menyebarkan output standar yang greptidak dimodifikasi.

Pendekatan ini relatif sederhana, tetapi ada beberapa kelemahan:

• Jika grepmenutup stdout sebelum menutup stdin, akan selalu ada kondisi balapan: grepmenutup stdout, memicu catuntuk keluar, memicu echo, memicu tailuntuk menghasilkan garis. Jika baris ini dikirim ke grepsebelum grepmemiliki kesempatan untuk menutup stdin, tailtidak akan mendapatkan SIGPIPEsampai menulis baris lain.
• Ini membutuhkan akses tulis ke file log.
• Anda harus OK dengan memodifikasi file log.
• Anda dapat merusak file log jika Anda kebetulan menulis pada saat yang sama dengan proses lain (penulisan mungkin disisipkan, menyebabkan baris baru muncul di tengah pesan log).
• Pendekatan ini khusus untuk tail— itu tidak akan bekerja dengan program lain.
• Tahap pipa ketiga menyulitkan untuk mendapatkan akses ke kode pengembalian tahap pipa kedua (kecuali jika Anda menggunakan ekstensi POSIX seperti array bash's PIPESTATUS). Ini bukan masalah besar dalam kasus ini karena grepakan selalu mengembalikan 0, tetapi secara umum tahap tengah mungkin diganti dengan perintah berbeda yang kode pengembaliannya Anda pedulikan (misalnya, sesuatu yang mengembalikan 0 ketika "server mulai" terdeteksi, 1 ketika "server gagal memulai" terdeteksi).

Pendekatan selanjutnya menghindari keterbatasan ini.

Pendekatan yang Lebih Baik: Hindari Saluran Pipa

Anda dapat menggunakan FIFO untuk menghindari pipa sama sekali, yang memungkinkan eksekusi berlanjut setelah grepkembali. Sebagai contoh:

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}"

Garis yang ditandai dengan komentar # optionaldapat dihapus dan program akan tetap bekerja; tailhanya akan berlama-lama sampai membaca baris input lain atau terbunuh oleh proses lain.

Keuntungan dari pendekatan ini adalah:

• Anda tidak perlu memodifikasi file log
• selain itu pendekatan ini berfungsi untuk utilitas lain tail
• itu tidak menderita dari kondisi balapan
• Anda dapat dengan mudah mendapatkan nilai kembali grep(atau perintah alternatif apa pun yang Anda gunakan)

Kelemahan dari pendekatan ini adalah kompleksitas, terutama mengelola FIFO: Anda harus secara aman menghasilkan nama file sementara, dan Anda harus memastikan bahwa FIFO sementara dihapus bahkan jika pengguna menekan Ctrl-C di tengah-tengah naskah. Ini bisa dilakukan menggunakan perangkap.

Pendekatan Alternatif: Kirim Pesan ke Kill tail

Anda bisa mendapatkan tailtahap pipa untuk keluar dengan mengirimkannya seperti sinyal SIGTERM. Tantangannya adalah mengetahui dua hal di tempat yang sama dalam kode: tailPID dan apakah greptelah keluar.

Dengan pipeline like tail -f ... | grep ..., mudah untuk memodifikasi tahap pipeline pertama untuk menyimpan tailPID dalam sebuah variabel dengan latar belakang taildan membaca $!. Juga mudah untuk memodifikasi tahap pipa kedua untuk dijalankan killketika grepkeluar. Masalahnya adalah bahwa dua tahap pipa berjalan dalam "lingkungan eksekusi" yang terpisah (dalam terminologi standar POSIX) sehingga tahap pipa kedua tidak dapat membaca variabel yang ditetapkan oleh tahap pipa pertama. Tanpa menggunakan variabel shell, entah itu tahap kedua harus entah bagaimana mencari tahu tailPID sehingga bisa membunuh tailketika grepkembali, atau tahap pertama harus entah bagaimana diberitahu ketika grepkembali.

Tahap kedua bisa digunakan pgrepuntuk mendapatkan tailPID, tetapi itu tidak bisa diandalkan (Anda mungkin cocok dengan proses yang salah) dan non-portabel ( pgreptidak ditentukan oleh standar POSIX).

Tahap pertama bisa mengirim PID ke tahap kedua melalui pipa dengan echomemasukkan PID, tetapi string ini akan dicampur dengan tailoutput. Demultiplexing keduanya mungkin memerlukan skema pelarian yang kompleks, tergantung pada output dari tail.

Anda dapat menggunakan FIFO agar tahap pipa kedua memberi tahu tahap pipa pertama saat grepkeluar. Maka tahap pertama bisa membunuh tail. Berikut ini beberapa contoh kode:

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}"

Pendekatan ini memiliki semua pro dan kontra dari pendekatan sebelumnya, kecuali itu lebih rumit.

Peringatan Tentang Buffering

POSIX memungkinkan stdin dan stdout stream sepenuhnya buffered, yang berarti bahwa tailoutput mungkin tidak diproses oleh grepuntuk waktu yang lama secara sewenang-wenang. Seharusnya tidak ada masalah pada sistem GNU: grepPenggunaan GNU read(), yang menghindari semua buffering, dan GNU tail -fmelakukan panggilan rutin fflush()ketika menulis ke stdout. Sistem non-GNU mungkin harus melakukan sesuatu yang khusus untuk menonaktifkan atau membersihkan buffer secara berkala.

Biarkan saya memperluas jawaban di @ 00prometheus (yang terbaik).

Mungkin Anda harus menggunakan batas waktu alih-alih menunggu tanpa batas waktu.

Fungsi bash di bawah ini akan memblokir hingga istilah pencarian yang diberikan muncul atau batas waktu yang diberikan tercapai.

Status keluar akan menjadi 0 jika string ditemukan dalam batas waktu.

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
}

Mungkin file log belum ada setelah meluncurkan server Anda. Dalam hal ini, Anda harus menunggu sampai muncul sebelum mencari 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))
}

Inilah cara Anda dapat menggunakannya:

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

Jadi setelah melakukan beberapa pengujian, saya menemukan cara 1-baris cepat untuk membuat pekerjaan ini. Tampaknya tail -f akan berhenti ketika grep berhenti, tetapi ada tangkapan. Tampaknya hanya dipicu jika file dibuka dan ditutup. Saya telah menyelesaikan ini dengan menambahkan string kosong ke file ketika grep menemukan kecocokan.

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

Saya tidak yakin mengapa buka / tutup file memicu ekor untuk menyadari bahwa pipa ditutup, jadi saya tidak akan bergantung pada perilaku ini. tetapi tampaknya berfungsi untuk saat ini.

Alasannya ditutup, lihat bendera -F, versus bendera -f.

Saat ini, seperti yang diberikan, semua tail -fsolusi di sini berisiko mengambil jalur "Server Dimulai" yang sebelumnya dicatat (yang mungkin atau mungkin tidak menjadi masalah dalam kasus spesifik Anda, tergantung pada jumlah baris yang dicatat dan rotasi file log / pemotongan).

Daripada hal-hal yang terlalu rumit, gunakan saja yang lebih pintar tail, seperti yang ditunjukkan bmike dengan potongan perl. Solusi paling sederhana adalah ini retailyang memiliki dukungan regex terintegrasi dengan pola kondisi mulai dan berhenti :

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

Ini akan mengikuti file seperti biasa tail -fsampai instance baru pertama dari string itu muncul, kemudian keluar. ( -uOpsi tidak memicu pada baris yang ada di 10 baris terakhir file ketika dalam mode "follow" normal.)

Jika Anda menggunakan GNU tail(dari coreutils ), opsi paling sederhana berikutnya adalah menggunakan --piddan FIFO (pipa bernama):

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

FIFO digunakan karena proses harus dimulai secara terpisah untuk mendapatkan dan melewati PID. Sebuah FIFO masih mengalami masalah yang sama yaitu berkeliaran untuk penulisan yang tepat waktu menyebabkan tailmenerima SIGPIPE , gunakan --pidopsi sehingga tailkeluar ketika pemberitahuan itu greptelah berakhir (biasanya digunakan untuk memantau proses penulis daripada pembaca , tetapi tailtidak t benar-benar peduli). Opsi -n 0digunakan dengan tailsehingga garis lama tidak memicu kecocokan.

Akhirnya, Anda bisa menggunakan ekor stateful , ini akan menyimpan offset file saat ini sehingga permintaan berikutnya hanya menampilkan baris baru (juga menangani rotasi file). Contoh ini menggunakan FWTK retail* lama :

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

_{* Catatan, nama yang sama, program yang berbeda dengan opsi sebelumnya.}

Daripada memiliki loop CPU-hogging, bandingkan timestamp file dengan file state ( .${LOGFILE}.off), dan sleep. Gunakan " -T" untuk menentukan lokasi file status jika diperlukan, yang di atas mengasumsikan direktori saat ini. Jangan ragu untuk melewati kondisi itu, atau di Linux Anda bisa menggunakan yang lebih efisien inotifywaitsebagai gantinya:

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

Ini akan sedikit rumit karena Anda harus masuk ke kontrol proses dan pensinyalan. Lebih banyak kludgey akan menjadi solusi dua skrip menggunakan pelacakan PID. Lebih baik menggunakan pipa bernama seperti ini.

Script shell apa yang Anda gunakan?

Untuk solusi skrip cepat dan kotor, saya akan membuat skrip perl menggunakan 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/;
}

Jadi daripada mencetak di dalam loop sementara, Anda bisa memfilter untuk kecocokan string dan keluar dari loop sementara untuk membiarkan skrip Anda berlanjut.

Salah satu dari ini harus melibatkan hanya sedikit pembelajaran untuk menerapkan kontrol aliran menonton yang Anda cari.

tunggu file muncul

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

tunggu string untuk muncul dalam file

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

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

Saya tidak bisa membayangkan solusi yang lebih bersih dari ini:

#!/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, mungkin namanya bisa diperbaiki ...

Keuntungan:

• itu tidak menggunakan utilitas khusus
• itu tidak menulis ke disk
• itu dengan anggun berhenti ekor dan menutup pipa
• itu sangat singkat dan mudah dimengerti

Anda tidak perlu perlu melakukan itu. Saya pikir perintah arloji adalah apa yang Anda cari. Perintah arloji memonitor output dari file dan dapat diakhiri dengan opsi -g ketika output berubah.

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

Alex saya pikir ini akan banyak membantu Anda.

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

perintah ini tidak akan pernah memberikan entri pada logfile tetapi akan diam-diam ...

Berikut ini adalah solusi yang jauh lebih baik yang tidak mengharuskan Anda menulis ke file log, yang sangat berbahaya atau bahkan tidak mungkin dalam beberapa kasus.

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

Saat ini hanya memiliki satu efek samping, tailproses akan tetap di latar belakang sampai baris berikutnya ditulis ke log.

Solusi lain di sini memiliki beberapa masalah:

• jika proses logging sudah turun atau turun selama loop mereka akan berjalan tanpa batas
• mengedit log yang seharusnya hanya dilihat
• tidak perlu menulis file tambahan
• tidak memungkinkan untuk logika tambahan

Inilah yang saya buat dengan menggunakan kucing jantan sebagai contoh (hapus hash jika Anda ingin melihat log saat permulaannya):

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"
}

The tailperintah dapat dilatarbelakangi dan pid yang menggema ke grepsubkulit. Dalam grepsubkulit penangan perangkap pada EXIT dapat membunuh tailperintah.

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

Baca semuanya. tldr: memisahkan pemutusan ekor dari grep.

Dua bentuk yang paling nyaman adalah

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

dan jika Anda memiliki bash

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

Tetapi jika ekor yang duduk di latar belakang mengganggu Anda, ada cara yang lebih baik daripada fifo atau jawaban lain di sini. Membutuhkan bash.

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

Atau jika itu bukan ekor yang menghasilkan sesuatu,

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

Coba gunakan inotify (inotifywait)

Anda mengatur inotifywait untuk setiap perubahan file, kemudian periksa file dengan grep, jika tidak ditemukan jalankan kembali inotifywait, jika ditemukan keluar dari loop ... Aduh seperti itu

Anda ingin pergi segera setelah garis ditulis, tetapi Anda juga ingin pergi setelah batas waktu:

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

bagaimana dengan ini:

sementara benar; lakukan jika [! -z $ (grep "myRegEx" myLog.log)]; lalu hancurkan; fi; selesai