Come creare un cron job usando Bash automaticamente senza l’editor interattivo?

Crontab ha un argomento per creare job cron senza usare l’editor (crontab -e). In tal caso, quale sarebbe il codice creare un cronjob da uno script Bash?

È ansible aggiungere a crontab come segue:

#write out current crontab crontab -l > mycron #echo new cron into cron file echo "00 09 * * 1-5 echo hello" >> mycron #install new cron file crontab mycron rm mycron 

Spiegazione della linea cron

 * * * * * "command to be executed" - - - - - | | | | | | | | | ----- Day of week (0 - 7) (Sunday=0 or 7) | | | ------- Month (1 - 12) | | --------- Day of month (1 - 31) | ----------- Hour (0 - 23) ------------- Minute (0 - 59) 

Fonte nixCraft .

Potresti riuscire a farlo al volo

 crontab -l | { cat; echo "0 0 0 0 0 some entry"; } | crontab - 

crontab -l elenca i lavori correnti di crontab, cat stampa, echo stampa il nuovo comando e crontab - aggiunge tutti gli elementi stampati nel file crontab. Puoi vedere l’effetto facendo un nuovo crontab -l .

Questo più breve non richiede file temporanei, è immune a più inserimenti e consente di modificare la pianificazione di una voce esistente.

Di ‘che hai questi:

 croncmd="/home/me/myfunction myargs > /home/me/myfunction.log 2>&1" cronjob="0 */15 * * * $croncmd" 

Per aggiungerlo a crontab, senza duplicazioni:

 ( crontab -l | grep -v -F "$croncmd" ; echo "$cronjob" ) | crontab - 

Per rimuoverlo dal crontab qualunque sia il suo programma attuale:

 ( crontab -l | grep -v -F "$croncmd" ) | crontab - 

Gli appunti:

  • grep -F corrisponde letteralmente alla stringa, in quanto non vogliamo interpretarla come un’espressione regolare
  • Ignoriamo anche la pianificazione temporale e cerchiamo solo il comando. Per di qua; il programma può essere modificato senza il rischio di aggiungere una nuova riga al crontab

Grazie a tutti per il vostro aiuto. Mettendo insieme quello che ho trovato qui e altrove ho trovato questo:

Il codice

 command="php $INSTALL/indefero/scripts/gitcron.php" job="0 0 * * 0 $command" cat <(fgrep -i -v "$command" <(crontab -l)) <(echo "$job") | crontab - 

Non riuscivo a capire come eliminare la necessità delle due variabili senza ripetermi.

command è ovviamente il comando che voglio programmare. job prende $command e aggiunge i dati di programmazione. Avevo bisogno di entrambe le variabili separatamente nella riga di codice che fa il lavoro.

Dettagli

  1. Ringraziamo duckyflip, io uso questo piccolo reindirizzamento ( <(*command*) ) per trasformare l'output di crontab -l in input per il comando fgrep .
  2. fgrep quindi esclude qualsiasi corrispondenza di $command (opzione -v ), case-insensitive (opzione -i ).
  3. Di nuovo, il piccolo reindirizzamento ( <(*command*) ) viene usato per trasformare il risultato in input per il comando cat .
  4. Il comando cat riceve anche echo "$job" (auto esplicativo), ancora, attraverso l'uso del reindirizzamento thingy ( <(*command*) ).
  5. Quindi l'output filtrato da crontab -l e il semplice echo "$job" , combinato, vengono reindirizzati ('|') a crontab - per essere infine scritti.
  6. E vissero tutti felici e contenti!

In poche parole:

Questa riga di codice filtra tutti i processi cron che corrispondono al comando, quindi scrive i restanti lavori cron con il nuovo, agendo efficacemente come una funzione "aggiungi" o "aggiorna". Per usare questo, tutto ciò che devi fare è scambiare i valori per il command e job variabili del job .

EDIT (sovrascrittura fissa):

 cat <(crontab -l) <(echo "1 2 3 4 5 scripty.sh") | crontab - 

Ci sono state molte buone risposte sull’uso di crontab, ma nessuna menzione di un metodo più semplice, come l’uso di cron .

L’utilizzo di cron si avvantaggerà dei file di sistema e delle directory che si trovano in /etc/crontab , /etc/cron.daily,weekly,hourly , /etc/cron.daily,weekly,hourly , /etc/cron.daily,weekly,hourly o /etc/cron.d/ :

 cat > /etc/cron.d/ << EOF SHELL=/bin/bash PATH=/sbin:/bin:/usr/sbin:/usr/bin MAILTO=root HOME=/ 01 * * * *   EOF 

In questo esempio sopra, abbiamo creato un file in /etc/cron.d/ , fornito le variabili d’ambiente per il comando da eseguire con successo e fornito user il comando e il command stesso. Questo file non dovrebbe essere eseguibile e il nome dovrebbe contenere solo caratteri alfanumerici e trattini (maggiori dettagli sotto).

Per dare una risposta approfondita, diamo un’occhiata alle differenze tra crontab vs cron/crond :

 crontab -- maintain tables for driving cron for individual users 

Per coloro che vogliono eseguire il lavoro nel contesto del proprio utente sul sistema, l’utilizzo di crontab può avere perfettamente senso.

 cron -- daemon to execute scheduled commands 

Per coloro che usano la gestione della configurazione o vogliono gestire lavori per altri utenti, nel qual caso dovremmo usare cron .

Un rapido estratto dalla manpage ti offre alcuni esempi su cosa fare e cosa non fare:

/ etc / crontab ei file in /etc/cron.d devono essere di proprietà di root e non devono essere di gruppo o di altro tipo. In contrasto con l’area di spool, i file in /etc/cron.d oi file in /etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly e /etc/cron.monthly possono anche essere collegamenti simbolici, a condizione che sia il link simbolico che il file a cui punta siano di proprietà di root. I file in /etc/cron.d non devono essere eseguibili, mentre i file in /etc/cron.hourly, /etc/cron.daily, /etc/cron.weekly e /etc/cron.monthly fanno, come sono gestiti da parti di corsa (si veda run-parts (8) per maggiori informazioni).

Fonte: http://manpages.ubuntu.com/manpages/trusty/man8/cron.8.html

Gestire i crons in questo modo è più facile e più scalabile dal punto di vista del sistema, ma non sarà sempre la soluzione migliore.

È probabile che tu lo stia automatizzando e non vuoi che un singolo lavoro venga aggiunto due volte. In tal caso utilizzare:

 CRON="1 2 3 4 5 /root/bin/backup.sh" cat < (crontab -l) |grep -v "${CRON}" < (echo "${CRON}") 

Funziona solo se stai usando BASH. Non sono a conoscenza della syntax DASH ( sh ) corretta.

Una variante che modifica solo crontab se non viene trovata la stringa desiderata:

 CMD="/sbin/modprobe fcpci" JOB="@reboot $CMD" TMPC="mycron" grep "$CMD" -q <(crontab -l) || (crontab -l>"$TMPC"; echo "$JOB">>"$TMPC"; crontab "$TMPC") 

Per una bella creazione / sostituzione di un crontab veloce e sporca con uno script BASH, ho usato questa notazione:

 crontab < 

Se stai usando Vixie Cron, ad esempio sulla maggior parte delle distribuzioni Linux, puoi semplicemente mettere un file in /etc/cron.d con il cronjob individuale.

Questo funziona solo per root, naturalmente. Se il tuo sistema lo supporta, dovresti vedere diversi esempi. (Nota il nome utente incluso nella riga, nella stessa syntax del vecchio / etc / crontab)

È una triste disfunzione in cron che non ci sia modo di gestirlo come un utente normale e che così tante implementazioni di cron non hanno assolutamente alcun modo per gestirlo.

Ecco una funzione di bash per aggiungere un comando a crontab senza duplicazione

 function addtocrontab () { local frequency=$1 local command=$2 local job="$frequency $command" cat <(fgrep -i -v "$command" <(crontab -l)) <(echo "$job") | crontab - } addtocrontab "0 0 1 * *" "echo hello" 
 CRON="1 2 3 4 5 /root/bin/backup.sh" cat < (crontab -l) |grep -v "${CRON}" < (echo "${CRON}") 

aggiungi il parametro -w al comando grep exact, senza il parametro -w aggiungendo il "test" del cronjob causa la cancellazione del job cron "testing123"

funzione di script per aggiungere / rimuovere cronjobs. nessuna voce di duplicazione:

 cronjob_editor () { # usage: cronjob_editor '' ''  if [[ -z "$1" ]] ;then printf " no interval specified\n" ;fi if [[ -z "$2" ]] ;then printf " no command specified\n" ;fi if [[ -z "$3" ]] ;then printf " no action specified\n" ;fi if [[ "$3" == add ]] ;then # add cronjob, no duplication: ( crontab -l | grep -v -F -w "$2" ; echo "$1 $2" ) | crontab - elif [[ "$3" == remove ]] ;then # remove cronjob: ( crontab -l | grep -v -F -w "$2" ) | crontab - fi } cronjob_editor "$1" "$2" "$3" 

testato:

 $ ./cronjob_editor.sh '*/10 * * * *' 'echo "this is a test" > export_file' add $ crontab -l $ */10 * * * * echo "this is a test" > export_file 

No, non c’è alcuna opzione in crontab per modificare i file di cron.

Devi: prendere il file cron corrente (crontab -l> newfile), cambiarlo e mettere il nuovo file sul posto (crontab newfile).

Se hai familiarità con perl, puoi usare questo modulo Config :: Crontab .

LLP, Andrea

funzione di script per aggiungere cronjobs. controlla le voci duplicate, espressioni utilizzabili *> ”

 cronjob_creator () { # usage: cronjob_creator '' '' if [[ -z $1 ]] ;then printf " no interval specified\n" elif [[ -z $2 ]] ;then printf " no command specified\n" else CRONIN="/tmp/cti_tmp" crontab -l | grep -vw "$1 $2" > "$CRONIN" echo "$1 $2" >> $CRONIN crontab "$CRONIN" rm $CRONIN fi } 

testato:

 $ ./cronjob_creator.sh '*/10 * * * *' 'echo "this is a test" > export_file' $ crontab -l $ */10 * * * * echo "this is a test" > export_file 

fonte: il mio cervello;)

Probabilmente puoi modificare l’editor predefinito in ed ed usare un heredoc da modificare.

 EDITOR=ed export EDITOR crontab -e << EOF > a > * * * * * Myscript > * * * * * AnotherScript > * * * * * MoreScript > . > w > q > EOF 

Notare il comando > in quel codice significa che il tasto di invio / invio viene premuto per creare una nuova riga.

Il a significa APPEND in modo che non sovrascriva nulla.

Il . significa che hai finito di modificare.

Il w significa SCRIVI i cambiamenti.

Q significa QUIT o exit ed.

puoi verificarlo

 crontab -l 

Puoi anche cancellare una voce.

 EDITOR=ed export EDITOR crontab -e << EOF > /Myscript/ > d > . > w > q > EOF 

Questo cancellerà la voce crontab con Myscript al suo interno.

La d significa eliminare il pattern all’interno di / / .

No, controlla di nuovo

 crontab -l 

Ovviamente questa soluzione funziona anche all’interno di uno script 🙂 🙂