Ripetere un comando ogni x intervallo di tempo nel terminale?

Come posso ripetere un comando ogni intervallo di tempo, in modo che mi consenta di eseguire comandi per controllare o monitorare le directory?

Non è necessario uno script, ho solo bisogno di un semplice comando da eseguire nel terminale.

È possibile utilizzare il watchcomando, watch viene utilizzato per eseguire qualsiasi comando designato a intervalli regolari.

Apri Terminale e digita:

watch -n x <your command>

cambia x per essere il tempo in secondi che desideri.

Per ulteriori informazioni sull'uso del watchcomando e delle sue opzioni, esegui man watcho visita questo link .

Ad esempio: di seguito verranno elencati, ogni 60s , sullo stesso Terminale, i contenuti della directory Desktop in modo da poter sapere se sono state apportate modifiche:

watch -n 60 ls -l ~/Desktop

Puoi anche usare questo comando nel terminale, a parte la risposta di nux:

while true; do <your_command>; sleep <interval_in_seconds>; done

Esempio

while true; do ls; sleep 2; done

Questo comando stampa l'output lsa un intervallo di 2 sec.

Usa Ctrl+ Cper interrompere il processo.

Ci sono alcuni svantaggi di watch

• Non può utilizzare alcun comando con alias.
• Se l'output di qualsiasi comando è piuttosto lungo, lo scorrimento non funziona correttamente.
• Vi sono alcuni problemi nell'impostare l'intervallo di tempo massimo oltre un determinato valore.
• watchinterpreterà le sequenze di colori ANSI passando i caratteri di escape usando -co l' --coloropzione. Ad esempio, l'output di pygmentizefunzionerà ma non funzionerà ls --color=auto.

Nelle circostanze di cui sopra ciò può apparire come un'opzione migliore.

Volevo solo presentare le risposte di souravc e nux :

1. Mentre watchfunzionerà perfettamente su Ubuntu, potresti voler evitare che se vuoi che il tuo "Unix-fu" sia puro - su FreeBSD per esempio, watch è un comando per "curiosare su un'altra linea tty".
2. while true; do command; sleep SECONDS; doneha anche un avvertimento - il vostro comando potrebbe essere più difficili da uccidere utilizzando CTR + C . Potresti voler preferire while sleep SECONDS; do command; done: non è solo più breve, ma anche più facile da interrompere. L'avvertenza è che prima dormirà, quindi eseguirà il tuo comando, quindi dovrai aspettare alcuni SECONDSprima che accada la prima occorrenza del comando.

Sembra il compito ideale per il crondemone che consente di eseguire comandi periodici. Esegui il crontab -ecomando per iniziare a modificare la configurazione cron dell'utente. Il suo formato è documentato in crontab (5) . Fondamentalmente hai cinque campi relativi al tempo, separati dallo spazio, seguiti da un comando:

The time and date fields are:

       field          allowed values
       -----          --------------
       minute         0-59
       hour           0-23
       day of month   1-31
       month          1-12 (or names, see below)
       day of week    0-7 (0 or 7 is Sunday, or use names)

Ad esempio, se desideri eseguire uno script Python ogni martedì, alle 11.00:

0 11 * * 1 python ~/yourscript.py

Ci sono anche alcuni nomi speciali che sostituiscono il tempo, come @reboot. Molto utile se è necessario creare una directory temporanea. Dal mio crontab (elencato con crontab -l):

# Creates a temporary directory for ~/.distcc at boot
@reboot ln -sfn "$(mktemp -d "/tmp/distcc.XXXXXXXX")" "$HOME/.distcc"

Se stai monitorando il file system, allora inotifywaitè geniale e sicuramente aggiunge meno carico al tuo sistema.

Esempio :

Nel 1 ° terminale digitare questo comando:

$ inotifywait .

Quindi nel 2 ° terminale, qualsiasi comando che influisce sulla directory corrente,

$ touch newfile

Quindi nel terminale originale inotifywait si sveglia e segnala l'evento

./ CREATE newfile2

O in un ciclo

$ while true ; do inotifywait . ; done
Setting up watches.  
Watches established.
./ OPEN newfile2
Setting up watches.  
Watches established.
./ OPEN newfile2
Setting up watches.  
Watches established.
./ DELETE newfile
Setting up watches.  
Watches established.
./ CREATE,ISDIR newdir
Setting up watches.  
Watches established.

È possibile creare il proprio repeatcomando procedendo come segue; crediti qui :

Innanzitutto, apri il tuo .bash_aliasesfile:

$ xdg-open ~/.bash-aliases

In secondo luogo, incolla queste righe nella parte inferiore del file e salva:

repeat() {
n=$1
shift
while [ $(( n -= 1 )) -ge 0 ]
do
    "$@"
done
}

Terzo, chiudi e riapri il tuo terminale o digita:

$ source ~/.bash_aliases

Et voilà ! Ora puoi usarlo in questo modo:

$ repeat 5 echo Hello World !!!

o

$ repeat 5 ./myscript.sh

puoi usare crontab. esegui il comando crontab -ee aprilo con il tuo editor di testo preferito, quindi aggiungi questa riga

*/10 * * * *  /path-to-your-command

Questo eseguirà il tuo comando ogni 10 minuti

* */4 * * *  /path-to-your-command

Questo eseguirà il tuo comando ogni 4 ore

Un'altra possibile soluzione

$ ..some command...; for i in $(seq X); do $cmd; sleep Y; done

X numero di volte da ripetere.

Y tempo di aspettare per ripetere.

Esempio :

$ echo; for i in $(seq 5); do $cmd "This is echo number: $i"; sleep 1;done

Un'altra preoccupazione con l'approccio "watch" proposto sopra è che mostra il risultato solo quando il processo è terminato. "date; sleep 58; date" visualizzerà le 2 date solo dopo 59 secondi ... Se avvii qualcosa in esecuzione per 4 minuti, che visualizzano lentamente più pagine di contenuto, non lo vedrai davvero.

D'altra parte, la preoccupazione con l'approccio "while" è che non prende in considerazione la durata dell'attività.

while true; do script_that_take_between_10s_to_50s.sh; sleep 50; done

Con questo, lo script verrà eseguito ogni minuto, a volte potrebbe richiedere 1m40. Quindi, anche se un cron sarà in grado di eseguirlo ogni minuto, qui non lo farà.

Quindi, per vedere l'output sulla shell mentre viene generato e attendere il tempo esatto della richiesta, è necessario guardare l'ora prima e dopo e fare un ciclo con il while.

Qualcosa di simile a:

while ( true ); do
  echo Date starting `date`
  before=`date +%s`
  sleep `echo $(( ( RANDOM % 30 )  + 1 ))`
  echo Before waiting `date`
  after=`date +%s`
  DELAY=`echo "60-($after-$before)" | bc`
  sleep $DELAY
  echo Done waiting `date`
done

Questo produrrà questo:

Come puoi vedere, il comando viene eseguito ogni minuto:

Date starting Mon Dec 14 15:49:34 EST 2015
Before waiting Mon Dec 14 15:49:52 EST 2015
Done waiting Mon Dec 14 15:50:34 EST 2015

Date starting Mon Dec 14 15:50:34 EST 2015
Before waiting Mon Dec 14 15:50:39 EST 2015
Done waiting Mon Dec 14 15:51:34 EST 2015

Quindi sostituisci semplicemente il echo $(( ( RANDOM % 30 ) + 1 ))comando "sleep " con quello che vuoi e che verrà eseguito, sul terminale / shell, esattamente ogni minuto. Se vuoi un altro programma, cambia i "60" secondi con quello che ti serve.

Versione più breve senza le righe di debug:

while ( true ); do
  before=`date +%s`
  sleep `echo $(( ( RANDOM % 30 )  + 1 ))` # Place you command here
  after=`date +%s`
  DELAY=`echo "60-($after-$before)" | bc`
  sleep $DELAY
done