Forza vampate di output in un file mentre bash script è ancora in esecuzione

Question

Ho un piccolo script, che è chiamato ogni giorno da crontab utilizzando il seguente comando:

/homedir/MyScript &> some_log.log 

Il problema di questo metodo è che some_log.log viene creato solo dopo aver terminato MyScript. Vorrei lavare l'output del programma nel file mentre è in esecuzione in modo da poter fare le cose come

tail -f some_log.log 

e tenere traccia dei progressi, ecc

Answer 1

bash non scriverà mai effettivamente alcun output nel file di registro. Invece, i comandi invocati come parte dello script scriveranno e arriveranno individualmente singolarmente ogni volta che ne avranno voglia. Quindi la tua domanda è davvero come forzare i comandi all'interno dello script di bash a svuotare, e questo dipende da cosa sono.

Answer 2

Questa non è una funzione di bash , come tutta la shell fa è aprire il file in questione e quindi passare il descrittore di file come output standard dello script. Quello che devi fare è assicurarti che l'output sia svuotato dal tuo script più frequentemente di quello che sei attualmente.

In Perl, ad esempio, questo potrebbe essere realizzato impostando:

$| = 1; 

Vedi perlvar per ulteriori informazioni su questo.

Answer 3

Non so se funzionerebbe, ma che dire di chiamare sync?

Answer 4

bene o non è così che funziona il reindirizzamento.

Nel tuo caso l'output (cioè lo script è finito) del tuo script reindirizzato a quel file.

Quello che vuoi fare è aggiungere quei reindirizzamenti nel tuo script.

Answer 5

Ho riscontrato questo problema con un processo in background in Mac OS X utilizzando StartupItems. Ecco come lo risolvo:

Se faccio sudo ps aux Vedo che mytool viene lanciato.

Ho trovato che (a causa del buffering) quando Mac OS X si arresta, mytool non trasferisce mai l'output al comando sed. Tuttavia, se eseguo sudo killall mytool, quindi mytool trasferisce l'output al comando sed. Quindi, ho aggiunto un caso stop al StartupItems che viene eseguito quando Mac OS X si spegne:

start) 
    if [ -x /sw/sbin/mytool ]; then 
     # run the daemon 
     ConsoleMessage "Starting mytool" 
     (mytool | sed .... >> myfile.txt) & 
    fi 
    ;; 
stop) 
    ConsoleMessage "Killing mytool" 
    killall mytool 
    ;; 

Answer 6

Sarebbe questo aiuto?

tail -f access.log | stdbuf -oL cut -d ' ' -f1 | uniq 

Ciò immedidately visualizzare voci univoche da access.log
http://www.pixelbeat.org/programming/stdio_buffering/stdbuf-man.html

Answer 7

È possibile utilizzare tee per scrivere sul file senza bisogno di risciacquo.

/homedir/MyScript 2>&1 | tee some_log.log > /dev/null 

Answer 8

script -c <PROGRAM> -f OUTPUT.txt

chiave è -f. Citazione di scrittura dell'uomo:

-f, --flush 
     Flush output after each write. This is nice for telecooperation: one person does `mkfifo foo; script -f foo', and another can supervise real-time what is being done 
     using `cat foo'. 

eseguito in background:

nohup script -c <PROGRAM> -f OUTPUT.txt 

Answer 9

Come appena macchiato here il problema è che bisogna aspettare che i programmi che si esegue dallo script terminare il loro lavori.
Se nello script si esegue il programma in in background è possibile provare qualcosa di più.

In generale una chiamata a sync prima di uscire consente di svuotare i buffer del file system e può aiutare un po '.

Se nello script vengono avviati alcuni programmi in sfondo (&), si può wait che finire prima di uscire dallo script. Per avere un'idea di come può funzionare potete vedere qui sotto

#!/bin/bash 
#... some stuffs ... 
program_1 &   # here you start a program 1 in background 
PID_PROGRAM_1=${!} # here you remember its PID 
#... some other stuffs ... 
program_2 &   # here you start a program 2 in background 
wait ${!}   # You wait it finish not really useful here 
#... some other stuffs ... 
daemon_1 &   # We will not wait it will finish 
program_3 &   # here you start a program 1 in background 
PID_PROGRAM_3=${!} # here you remember its PID 
#... last other stuffs ... 
sync 
wait $PID_PROGRAM_1 
wait $PID_PROGRAM_3 # program 2 is just ended 
# ... 

Dal wait opere con posti di lavoro nonché con PID numeri una soluzione pigra dovrebbe essere quello di mettere alla fine dello script

for job in `jobs -p` 
do 
    wait $job 
done 

Più difficile è la situazione se si esegue qualcosa che esegue qualcos'altro in background perché si deve cercare e attendere (se è il caso) la fine di tutto il processo figlio: ad esempio se si esegue un demone probabilmente non è il caso di aspettare finisce :-).

Nota:

• attesa $ significa "aspettare l'ultimo processo in background viene completato" dove $! è il PID dell'ultimo processo in background {!}. Quindi, per mettere wait ${!} subito dopo program_2 & è equivalente a eseguire direttamente program_2 senza inviarlo in background con &

• Da l'aiuto di wait:

  Syntax  
      wait [n ...] 
  Key 
      n A process ID or a job specification 
  

Answer 10

ho trovato una soluzione a questo here. Usando l'esempio del PO si esegue fondamentalmente

stdbuf -oL /homedir/MyScript &> some_log.log

e quindi il buffer si svuota dopo ogni riga di output. Spesso lo combino con nohup per eseguire lavori lunghi su una macchina remota.

stdbuf -oL nohup /homedir/MyScript &> some_log.log

In questo modo il processo non viene annullata quando si effettua il logout.

Answer 11

Il buffering dell'output dipende dal modo in cui è implementato il programma /homedir/MyScript. Se trovi che l'output viene bufferizzato, devi forzarlo nella tua implementazione. Ad esempio, usa sys.stdout.flush() se è un programma python o usa fflush (stdout) se è un programma C.