Usare "while true" per mantenere viva una sceneggiatura è una buona idea?

Sto solo saltando in Unix da un mondo diverso e volevo sapere se

while true
do
  /someperlscript.pl
done

Lo script perl stesso ha internamente un watcher di cartelle / file che viene eseguito quando i file vengono modificati nella posizione di destinazione.

Questa ( while true) è una buona idea? In caso contrario, qual è un approccio robusto preferito?

TIA

EDIT: poiché questo sembra aver suscitato un discreto interesse, ecco lo scenario completo. Lo script perl stesso guarda una directory usando un watcher di file. Alla ricezione di nuovi file (arrivano tramite rsync), raccoglie il nuovo e lo elabora. Ora i file in arrivo potrebbero essere danneggiati (non chiedere .. provenienti da un raspberry pi), e talvolta il processo potrebbe non essere in grado di gestirlo. Non so esattamente perché, perché non siamo ancora a conoscenza di tutti gli scenari.

MA - se il processo fallisce per qualche motivo, vogliamo che sia attivo e funzionante e gestisca il file successivo, perché il file successivo non è completamente correlato al precedente che potrebbe aver causato l'errore.

Di solito avrei usato una sorta di catch all e racchiuso l'intero codice in modo che non si blocchi MAI. Ma non ero sicuro del perl.

Da quello che ho capito, usare qualcosa come supervisord è un buon approccio per questo.

Dipende da quanto velocemente ritorna lo script perl. Se ritorna rapidamente, potresti voler inserire una piccola pausa tra le esecuzioni per evitare il carico della CPU, ad esempio:

while true
do
  /someperlscript.pl
  sleep 1
done

Ciò impedirà anche un errore della CPU se lo script non viene trovato o si blocca immediatamente.

Il ciclo potrebbe anche essere meglio implementato nello script perl stesso per evitare questi problemi.

Modificare:

Come hai scritto, il solo scopo del loop è riavviare lo script perl in caso di crash, un approccio migliore sarebbe implementarlo come un servizio monitorato, ma il modo preciso per farlo dipende dal sistema operativo. Ad esempio: Solaris smf, Linux systemd o un riavvio basato su cron.

Le altre risposte sull'utilizzo inotifysono corrette, ma non una risposta a questa domanda.

Un supervisore di processo, come supervisord, upstarto runit, è progettato esattamente per il problema di guardare e riavviare un servizio in caso di arresto anomalo.

La tua distribuzione probabilmente include un supervisore di processo integrato.

while trueva bene come una costruzione "loop forever" per tutti gli usi. Come dicono altre risposte, il corpo del loop non dovrebbe essere vuoto o diventare vuoto in virtù del comando all'interno del loop non funzionante.

Se stai usando Linux, potresti voler usare un comando simile inotifywait, che rende il whileciclo molto più semplice:

while inotifywait -qqe modify "$DIRECTORY"
do
    process_the_directory "$DIRECTORY"
done

Qui, il inotifywaitcomando resterà in attesa del verificarsi di un evento del filesystem (in questo esempio, quando vengono scritti i file nella directory). A quel punto, esce correttamente e il corpo del loop viene eseguito. Torna quindi ad aspettare di nuovo. Poiché il inotifywaitcomando attende che accada qualcosa nella directory, è molto più efficiente del polling continuo della directory.

Sposta il tempo 1 nello script perl (seguendo il suggerimento di @roaima)

#!/usr/bin/perl

 use Linux::Inotify2;

 my $inotify = new Linux::Inotify2 or die "unable to inotify: $!";

 $inotify->watch ("Dir", IN_MODIFY, ## or in_{acess,create,open, etc...}
   sub { my $e = shift;
     my $name = $e->fullname;
     ## whatever 
     print "$name was modified\n" if $e->IN_MODIFY;
  });

 1 while $inotify->poll;

Quando il tuo script perl è destinato a funzionare continuamente, perché usare la costruzione while? Quando il perl fallisce in vista di qualche grave problema, il nuovo script perl avviato nel frattempo potrebbe bloccarsi altrettanto duramente. Nuovo-e-ancora-e-così via.
se vuoi davvero ricominciare il tuo perl, considera crontab e uno script che controlla prima le istanze in esecuzione. In questo modo lo script verrà avviato anche dopo un riavvio.

In generale, non vi è alcun problema nell'utilizzo while truepoiché si tratta di un test minuscolo che viene eseguito solo dopo la chiusura dello script perl. Tieni presente che, a seconda della variante Linux / Unix che stai utilizzando, lo script potrebbe terminare alla disconnessione. In tal caso, considera l'utilizzo del loop in uno script e chiamalo nohupe mettilo in background, ad esnohup myscript &

Se lo script perl termina troppo spesso e causa un carico della CPU, questo carico è responsabile dello script perl e non di while true.

Vedi anche man nohupper i dettagli.

Se si desidera gestire un processo, è possibile esaminare un gestore processi per farlo.

Con molti sistemi recenti, è possibile utilizzare systemd per monitorare i processi (che è uno dei vantaggi di systemd rispetto agli script di script classici). Se la vostra distro di scelta non utilizza systemd, si potrebbe usare daemontools o Monit .

Il whileciclo non è davvero una buona idea. Non c'è scampo lì - corre solo per sempre - staticamente . Qualsiasi numero di cose potrebbe cambiare nell'ambiente e non ne risentirebbe - e questo potrebbe essere negativo.

Ad esempio, se il file eseguibile della shell responsabile di quel whileciclo viene aggiornato, il kernel non sarà in grado di liberare lo spazio su disco per la versione precedente fino a quando lo script non si chiude perché deve mantenere il descrittore per tutto il tempo in cui viene eseguito. E questo è vero per tutti i file che la shell potrebbe avere aperto per qualsiasi motivo per eseguire il ciclo - saranno tutti tenuti aperti da questo whileciclo per tutto il tempo in cui viene eseguito - per sempre.

E se, il cielo lo proibisce, c'è una perdita di memoria in qualsiasi punto della shell che esegue quel loop - anche il più minuto - continuerà semplicemente a perdere - staticamente . Costruirà senza controllo e l'unica risorsa è ucciderlo con forza, quindi ricominciare da capo solo per fare lo stesso in seguito.

Questo non è davvero il modo in cui dovresti impostare un processo in background - almeno, non secondo me. Invece, come penso, dovrebbe esserci un punto di ripristino: un aggiornamento dello script e del suo stato. Il modo più semplice per farlo è con exec. È possibile sostituire il processo corrente con uno nuovo, mantenendo lo stesso PID, ma eseguendo comunque un nuovo processo.

Ad esempio, se lo perlscript deve restituire true dopo aver gestito correttamente una modifica del file in alcune directory monitorate:

#!/bin/sh
trap 'rm -rf -- "${ldir%%*.}"' 0 INT
_exec() case    $#      in
        (0)     exec env -  "PID=$$" "ldir=${TMPDIR:-/tmp}/." \
                            "$0" "$@";;
        (*)     export "$@" "boff=0" "lmt=30"
                exec        "$0" "$@";;
        esac
[ "$PID" = "$$" ] || _exec
[ -w "$ldir" ]  &&
case    $ldir   in
(*.)    until   mkdir -- "$ldir"
        do      :& ldir=$ldir$$$!
        done    2>/dev/null
;;
(*)     until   /someperlscript.pl ||
                [ "$((boff+=1))"  -ge "$lmt" ]
        do      [ -d "$ldir" ]     &&
                sleep "$boff"      || ! break
        done
;;esac  &&      _exec ldir PID

...o qualcosa di simile. Qualcosa che consente ai macchinari di base dietro il circuito di aggiornarsi di tanto in tanto.

Ho valutato alcune di queste risposte, ma istintivamente provo i sentimenti più calorosi per la risposta di @ WalterA. Bene, l'ho fatto fino a quando non ho creato la mia risposta ...

Personalmente, tenderei ad aggiornare lo script Perl in modo che scriva una voce di registro descrittiva sull'errore e invii un avviso a un amministratore.

Se si prevede che lo script Perl continui l'esecuzione, in attesa di eventi di modifica dal file system, perché non funziona?

Se non fallisce, perché ti preoccupi di racchiuderlo in uno script per riavviarlo all'infinito?

Se c'è un problema di configurazione o una dipendenza interrotta che causa l'interruzione dello script Perl, è semplice riavviarlo ripetutamente per far sì che improvvisamente inizi a funzionare.

Conosci la definizione di follia, vero? (facendo sempre la stessa cosa, aspettandosi un risultato diverso). Sto solo dicendo. ;-)