Come posso elencare tutti i lavori cron per tutti gli utenti?
https://stackoverflow.com/questions/134906
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianDomanda
Esiste un comando o uno script esistente che mi consente di visualizzare contemporaneamente tutti i lavori cron programmati di un sistema * NIX? Vorrei che includesse tutti i crontab dell'utente, nonché / etc / crontab , e qualunque cosa sia in /etc/cron.d . Sarebbe anche bello vedere i comandi specifici eseguiti da run-parts in / etc / crontab .
Idealmente, vorrei l'output in una bella forma di colonna e ordinato in modo significativo.
Potrei quindi unire questi elenchi da più server per visualizzare il programma generale degli eventi. "
Stavo per scrivere una sceneggiatura del genere, ma se qualcuno si è già messo nei guai ...
Soluzione 2
Ho finito per scrivere una sceneggiatura (sto cercando di insegnarmi i punti più fini dello script bash, quindi è per questo che non vedi qualcosa come Perl qui). Non è esattamente un affare semplice, ma fa la maggior parte di ciò di cui ho bisogno. Usa il suggerimento di Kyle per cercare i crontab dei singoli utenti, ma si occupa anche di / etc / crontab (compresi gli script lanciati da run-parts in / etc / cron.hourly , /etc/cron.daily , ecc.) e i lavori nella directory /etc/cron.d . Prende tutti questi e li unisce in un display qualcosa di simile al seguente:
mi h d m w user command
09,39 * * * * root [ -d /var/lib/php5 ] && find /var/lib/php5/ -type f -cmin +$(/usr/lib/php5/maxlifetime) -print0 | xargs -r -0 rm
47 */8 * * * root rsync -axE --delete --ignore-errors / /mirror/ >/dev/null
17 1 * * * root /etc/cron.daily/apt
17 1 * * * root /etc/cron.daily/aptitude
17 1 * * * root /etc/cron.daily/find
17 1 * * * root /etc/cron.daily/logrotate
17 1 * * * root /etc/cron.daily/man-db
17 1 * * * root /etc/cron.daily/ntp
17 1 * * * root /etc/cron.daily/standard
17 1 * * * root /etc/cron.daily/sysklogd
27 2 * * 7 root /etc/cron.weekly/man-db
27 2 * * 7 root /etc/cron.weekly/sysklogd
13 3 * * * archiver /usr/local/bin/offsite-backup 2>&1
32 3 1 * * root /etc/cron.monthly/standard
36 4 * * * yukon /home/yukon/bin/do-daily-stuff
5 5 * * * archiver /usr/local/bin/update-logs >/dev/null
Nota che mostra l'utente e più o meno ordina per ora e minuti in modo che io possa vedere il programma giornaliero.
Finora l'ho provato su Ubuntu, Debian e Red Hat AS.
#!/bin/bash
# System-wide crontab file and cron job directory. Change these for your system.
CRONTAB='/etc/crontab'
CRONDIR='/etc/cron.d'
# Single tab character. Annoyingly necessary.
tab=$(echo -en "\t")
# Given a stream of crontab lines, exclude non-cron job lines, replace
# whitespace characters with a single space, and remove any spaces from the
# beginning of each line.
function clean_cron_lines() {
while read line ; do
echo "${line}" |
egrep --invert-match '^($|\s*#|\s*[[:alnum:]_]+=)' |
sed --regexp-extended "s/\s+/ /g" |
sed --regexp-extended "s/^ //"
done;
}
# Given a stream of cleaned crontab lines, echo any that don't include the
# run-parts command, and for those that do, show each job file in the run-parts
# directory as if it were scheduled explicitly.
function lookup_run_parts() {
while read line ; do
match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+')
if [[ -z "${match}" ]] ; then
echo "${line}"
else
cron_fields=$(echo "${line}" | cut -f1-6 -d' ')
cron_job_dir=$(echo "${match}" | awk '{print $NF}')
if [[ -d "${cron_job_dir}" ]] ; then
for cron_job_file in "${cron_job_dir}"/* ; do # */ <not a comment>
[[ -f "${cron_job_file}" ]] && echo "${cron_fields} ${cron_job_file}"
done
fi
fi
done;
}
# Temporary file for crontab lines.
temp=$(mktemp) || exit 1
# Add all of the jobs from the system-wide crontab file.
cat "${CRONTAB}" | clean_cron_lines | lookup_run_parts >"${temp}"
# Add all of the jobs from the system-wide cron directory.
cat "${CRONDIR}"/* | clean_cron_lines >>"${temp}" # */ <not a comment>
# Add each user's crontab (if it exists). Insert the user's name between the
# five time fields and the command.
while read user ; do
crontab -l -u "${user}" 2>/dev/null |
clean_cron_lines |
sed --regexp-extended "s/^((\S+ +){5})(.+)$/\1${user} \3/" >>"${temp}"
done < <(cut --fields=1 --delimiter=: /etc/passwd)
# Output the collected crontab lines. Replace the single spaces between the
# fields with tab characters, sort the lines by hour and minute, insert the
# header line, and format the results as a table.
cat "${temp}" |
sed --regexp-extended "s/^(\S+) +(\S+) +(\S+) +(\S+) +(\S+) +(\S+) +(.*)$/\1\t\2\t\3\t\4\t\5\t\6\t\7/" |
sort --numeric-sort --field-separator="${tab}" --key=2,1 |
sed "1i\mi\th\td\tm\tw\tuser\tcommand" |
column -s"${tab}" -t
rm --force "${temp}"
Altri suggerimenti
Dovresti eseguirlo come root, ma:
for user in $(cut -f1 -d: /etc/passwd); do crontab -u $user -l; done
passerà in rassegna ogni nome utente elencando il loro crontab. I crontab sono di proprietà dei rispettivi utenti, quindi non sarai in grado di vedere i crontab di un altro utente senza di loro o come root.
Modifica
se vuoi sapere a quale utente appartiene un crontab, usa echo $ user
for user in $(cut -f1 -d: /etc/passwd); do echo $user; crontab -u $user -l; done
Sotto Ubuntu o debian, puoi visualizzare crontab con / var / spool / cron / crontabs / e quindi un file per ogni utente è lì. Questo è ovviamente solo per i crontab specifici dell'utente.
Per Redhat 6/7 e Centos, il crontab è in / var / spool / cron / .
Questo mostrerà tutte le voci crontab di tutti gli utenti.
sed 's/^\([^:]*\):.*$/crontab -u \1 -l 2>\&1/' /etc/passwd | grep -v "no crontab for" | sh
Dipende dalla tua versione di Linux ma io uso:
tail -n 1000 /var/spool/cron/*
come root. Molto semplice e molto corto.
Mi dà un output come:
==> /var/spool/cron/root <==
15 2 * * * /bla
==> /var/spool/cron/my_user <==
*/10 1 * * * /path/to/script
Un piccolo perfezionamento della risposta di Kyle Burton con una migliore formattazione dell'output:
#!/bin/bash
for user in $(cut -f1 -d: /etc/passwd)
do echo $user && crontab -u $user -l
echo " "
done
getent passwd | cut -d: -f1 | perl -e'while(<>){chomp;$l = `crontab -u <*>
Questo evita di fare casini con passwd direttamente, salta gli utenti che non hanno voci cron e per coloro che li hanno stampa il nome utente e il loro crontab.
Abbandono principalmente qui, quindi posso trovarlo più tardi nel caso in cui dovessi cercarlo di nuovo.
-l 2>/dev/null`;print "<*>
Questo evita di fare casini con passwd direttamente, salta gli utenti che non hanno voci cron e per coloro che li hanno stampa il nome utente e il loro crontab.
Abbandono principalmente qui, quindi posso trovarlo più tardi nel caso in cui dovessi cercarlo di nuovo.
\n$l\n" if $l}'
Questo evita di fare casini con passwd direttamente, salta gli utenti che non hanno voci cron e per coloro che li hanno stampa il nome utente e il loro crontab.
Abbandono principalmente qui, quindi posso trovarlo più tardi nel caso in cui dovessi cercarlo di nuovo.
Se controlli un cluster usando NIS, l'unico modo per vedere se un utente ha una voce crontab è secondo la risposta di Matt / var / spool / cron / tabs.
grep -v "#" -R /var/spool/cron/tabs
Questo script ha funzionato per me in CentOS per elencare tutti i croni nell'ambiente:
sudo cat /etc/passwd | sed 's/^\([^:]*\):.*$/sudo crontab -u \1 -l 2>\&1/' | grep -v "no crontab for" | sh
Mi piace la semplice risposta di una riga sopra:
per l'utente in $ (cut -f1 -d: / etc / passwd); crontab -u $ user -l; fatto
Ma Solaris che non ha il flag -u e non stampa l'utente che sta controllando, puoi modificarlo in questo modo:
for user in $(cut -f1 -d: /etc/passwd); do echo User:$user; crontab -l $user 2>&1 | grep -v crontab; done
Otterrai un elenco di utenti senza gli errori generati da crontab quando un account non è autorizzato a utilizzare cron ecc. Tieni presente che in Solaris i ruoli possono essere anche in / etc / passwd (vedi / etc / user_attr).
for user in $(cut -f1 -d: /etc/passwd);
do
echo $user; crontab -u $user -l;
done
Per ottenere l'elenco dagli utenti ROOT.
for user in $(cut -f1 -d: /etc/passwd); do echo $user; sudo crontab -u $user -l; done
Quanto segue rimuove i commenti, le righe vuote e gli errori dagli utenti senza crontab. Tutto ciò che ti rimane è un chiaro elenco di utenti e dei loro lavori.
Nota l'uso di sudo nella seconda riga. Se sei già root, rimuovilo.
for USER in $(cut -f1 -d: /etc/passwd); do \
USERTAB="$(sudo crontab -u "$USER" -l 2>&1)"; \
FILTERED="$(echo "$USERTAB"| grep -vE '^#|^$|no crontab for|cannot use this program')"; \
if ! test -z "$FILTERED"; then \
echo "# ------ $(tput bold)$USER$(tput sgr0) ------"; \
echo "$FILTERED"; \
echo ""; \
fi; \
done
Esempio di output:
# ------ root ------
0 */6 * * * /usr/local/bin/disk-space-notify.sh
45 3 * * * /opt/mysql-backups/mysql-backups.sh
5 7 * * * /usr/local/bin/certbot-auto renew --quiet --no-self-upgrade
# ------ sammy ------
55 * * * * wget -O - -q -t 1 https://www.example.com/cron.php > /dev/null
Lo uso su Ubuntu (dal 12 al 16) e Red Hat (dal 5 al 7).
Dipende dalla tua versione di cron. Usando Vixie cron su FreeBSD, posso fare qualcosa del genere:
(cd /var/cron/tabs && grep -vH ^# *)
se lo voglio più tabulato, potrei fare qualcosa del genere:
(cd /var/cron/tabs && grep -vH ^# * | sed "s/:/ /")
Dove si trova una scheda letterale nella parte di sostituzione sed.
Potrebbe essere più indipendente dal sistema passare in rassegna gli utenti in / etc / passwd ed eseguire crontab -l -u $ user per ciascuno di essi.
Grazie per questo script molto utile. Ho avuto alcuni piccoli problemi eseguendolo su vecchi sistemi (Red Hat Enterprise 3, che gestiscono in modo diverso egrep e tabs nelle stringhe), e altri sistemi con nulla in /etc/cron.d/ (lo script si è quindi concluso con un errore). Quindi ecco una patch per farlo funzionare in questi casi:
2a3,4
> #See: http://stackoverflow.com/questions/134906/how-do-i-list-all-cron-jobs-for-all-users
>
27c29,30
< match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+')
---
> #match=$(echo "${line}" | egrep -o 'run-parts (-{1,2}\S+ )*\S+')
> match=$(echo "${line}" | egrep -o 'run-parts.*')
51c54,57
< cat "${CRONDIR}"/* | clean_cron_lines >>"${temp}" # */ <not a comment>
---
> sys_cron_num=$(ls /etc/cron.d | wc -l | awk '{print $1}')
> if [ "$sys_cron_num" != 0 ]; then
> cat "${CRONDIR}"/* | clean_cron_lines >>"${temp}" # */ <not a comment>
> fi
67c73
< sed "1i\mi\th\td\tm\tw\tuser\tcommand" |
---
> sed "1i\mi${tab}h${tab}d${tab}m${tab}w${tab}user${tab}command" |
Non sono davvero sicuro che i cambiamenti nel primo egrep siano una buona idea, ma bene, questo script è stato testato su RHEL3,4,5 e Debian5 senza alcun problema. Spero che questo aiuti!
Basandosi su @Kyle
for user in $(tail -n +11 /etc/passwd | cut -f1 -d:); do echo $user; crontab -u $user -l; done
per evitare i commenti generalmente nella parte superiore di / etc / passwd,
E su macosx
for user in $(dscl . -list /users | cut -f1 -d:); do echo $user; crontab -u $user -l; done
Penso che una fodera migliore sarebbe sotto. Ad esempio, se hai utenti in NIS o LDAP, non sarebbero in / etc / passwd. Questo ti darà i crontabs di ogni utente che ha effettuato l'accesso.
for I in `lastlog | grep -v Never | cut -f1 -d' '`; do echo $I ; crontab -l -u $I ; done
puoi scrivere per tutto l'elenco utenti:
sudo crontab -u userName -l
,
Puoi anche andare su
cd /etc/cron.daily/
ls -l
cat filename
questo file elencherà le pianificazioni
cd /etc/cron.d/
ls -l
cat filename
Con scuse e grazie a yukondude.
Ho provato a sintetizzare le impostazioni di temporizzazione per una facile lettura, anche se non è un lavoro perfetto, e non tocco "tutti i venerdì" o "solo sulle cose del lunedì".
Questa è la versione 10 - ora:
- funziona molto più velocemente
- ha caratteri di avanzamento opzionali in modo da poter migliorare ulteriormente la velocità.
- utilizza una linea di divisione per separare intestazione e output.
- produce in un formato compatto quando tutti gli intervalli di temporizzazione incontrati possono essere riassunti.
- Accetta i descrittori Jan ... Dec per i mesi dell'anno
- Accetta i descrittori Lun ... Sun per i giorni della settimana
- prova a gestire il dummying-up debian-style di anacron quando manca
- tenta di gestire le linee crontab che eseguono un file dopo aver eseguito il test preliminare dell'esecuzione usando " [-x ...] "
- tenta di gestire le linee crontab che eseguono un file dopo aver eseguito il test preliminare dell'esecuzione usando " command -v "
- consente l'uso di intervalli e liste di intervalli.
- supporta l'utilizzo di parti run in file crontab / var / spool specifici dell'utente.
Ora sto pubblicando lo script per intero qui.
Poiché si tratta di eseguire il ciclo di un file ( / etc / passwd ) e di eseguire un'azione, mi manca l'approccio corretto su Come posso leggere un file (flusso di dati, variabile) riga per riga (e / o campo per campo)? :
while IFS=":" read -r user _
do
echo "crontab for user ${user}:"
crontab -u "$user" -l
done < /etc/passwd
Questo legge / etc / passwd riga per riga usando : come delimitatore di campo. Dicendo read -r user _ , facciamo $ user il primo campo e _ il resto (è solo una variabile junk da ignorare campi).
In questo modo, possiamo quindi chiamare crontab -u usando la variabile $ user , che citiamo per sicurezza (cosa succede se contiene spazi? È improbabile in tali file, ma non puoi mai saperlo).
Su Solaris, per un nome utente noto in particolare:
crontab -l username
Tutti gli altri * Nix avranno bisogno del modificatore -u :
crontab -u username -l
Per ottenere tutti i lavori degli utenti contemporaneamente su Solaris, proprio come gli altri post precedenti:
for user in $(cut -f1 -d: /etc/passwd); do crontab -l $user 2>/dev/null; done
Per me guardare / var / spool / cron / crontabs è il modo migliore
Questo script genera Crontab in un file ed elenca anche tutti gli utenti che confermano quelli che non hanno una voce crontab:
for user in $(cut -f1 -d: /etc/passwd); do
echo $user >> crontab.bak
echo "" >> crontab.bak
crontab -u $user -l >> crontab.bak 2>> > crontab.bak
done
