Wie stelle ich alle Cron-Jobs für alle Benutzer?

Question

Gibt es einen Befehl oder ein vorhandenes Skript, das mir alle eines * NIX Systems geplant Cron-Jobs auf einmal sehen lassen? Ich möchte es alle Benutzer crontabs enthalten, sowie /etc/crontab, und was auch immer das in /etc/cron.d. Es wäre auch schön, die Befehle, von run-parts in /etc/crontab laufen zu sehen.

Idealerweise würde ich die Ausgabe in einer schönen Säulenform mag und auf sinnvolle Art und Weise geordnet.

Ich kann dann diese Anzeigen von mehreren Servern fusioniert die Gesamt, um „Liste der Veranstaltungen.“

Ich war über ein solches Skript selbst zu schreiben, aber wenn jemand schon die Mühe gemacht ...

Answer 1

beenden ich ein Skript zu schreiben (ich bin versucht, mir die Feinheiten der Bash Scripting zu lehren, ist also, warum Sie so etwas wie Perl nicht hier sehen). Es ist nicht gerade eine einfache Angelegenheit, aber es hat fast alles, was ich brauche. Es nutzt Kyle Vorschlag für einzelne Benutzer crontabs aufzublicken, sondern befasst sich auch mit /etc/crontab (einschließlich der Skripte von run-parts in /etc/cron.hourly ins Leben gerufen, /etc/cron.daily, etc.) und die Arbeitsplätze im /etc/cron.d Verzeichnis. Es nimmt alle diejenigen und verschmilzt sie in einem Display in etwa wie folgt:

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

Beachten Sie, dass es den Benutzer zeigt, und mehr oder weniger Arten von Stunde und Minute, so dass ich den Tagesplan sehen kann.

Bisher habe ich es auf Ubuntu, Debian getestet und 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}"

Answer 2

Sie würden dies als root laufen müssen, aber:

for user in $(cut -f1 -d: /etc/passwd); do crontab -u $user -l; done

wird Schleife über jeden Benutzernamen ihre crontab Auflistung aus. Die crontabs werden von den jeweiligen Benutzern gehört, so dass Sie nicht in der Lage sein werden, ein anderer Benutzer crontab w / o sie oder Wurzel zu sein.

zu sehen

---

Bearbeiten Wenn Sie wissen möchten, welcher Benutzer eine crontab gehört, Verwendung echo $user

for user in $(cut -f1 -d: /etc/passwd); do echo $user; crontab -u $user -l; done

Answer 3

Unter Ubuntu oder Debian, können Sie crontab von /var/spool/cron/crontabs/ ansehen und dann eine Datei für jeden Benutzer ist da drin. Das ist nur für anwenderspezifische crontab der natürlich.

Für Redhat 6/7 und Centos, die crontab ist unter /var/spool/cron/.

Answer 4

Damit werden alle crontab Einträge von allen Benutzern zeigen.

sed 's/^\([^:]*\):.*$/crontab -u \1 -l 2>\&1/' /etc/passwd | grep -v "no crontab for" | sh

Answer 5

Abhängig von Ihrer Linux-Version, aber ich benutze:

tail -n 1000 /var/spool/cron/*

als root. Sehr einfach und sehr kurz.

Gibt mir eine Ausgabe wie:

==> /var/spool/cron/root <==
15 2 * * * /bla

==> /var/spool/cron/my_user <==
*/10 1 * * * /path/to/script

Answer 6

Eine kleine Verfeinerung von Kyle Burton Antwort mit einem verbesserten Ausgabeformatierung:

#!/bin/bash
for user in $(cut -f1 -d: /etc/passwd)
do echo $user && crontab -u $user -l
echo " "
done

Answer 7

getent passwd | cut -d: -f1 | perl -e'while(<>){chomp;$l = `crontab -u $_ -l 2>/dev/null`;print "$_\n$l\n" if $l}'

Dies vermeidet mit passwd direkt durcheinander, überspringt Benutzer, die keine cron-Einträge und für diejenigen, die sie es haben auch den Benutzernamen druckt als crontab.

dropping Meistens dies hier aber so kann ich es später im Fall finde ich immer danach suchen muß wieder.

Answer 8

Wenn Sie einen Cluster mit NIS überprüfen, der einzige Weg, um zu sehen, wenn ein Benutzer einen crontab-Eintrag hat ist nach Matts Antwort / var / spool / cron / tabs.

grep -v "#" -R  /var/spool/cron/tabs

Answer 9

Dieses Skript arbeitete für mich in CentOS alle crons in der Umgebung zur Liste:

sudo cat /etc/passwd | sed 's/^\([^:]*\):.*$/sudo crontab -u \1 -l 2>\&1/' | grep -v "no crontab for" | sh

Answer 10

Ich mag die einfache Einzeiler Antwort oben:

  

für Benutzer in $ (cut -f1 -d: / etc / passwd); tun crontab -u $ user -l; getan

Aber Solaris, die nicht die -u-Flag hat und druckt nicht den Benutzer es überprüfen, können Sie es wie so ändern:

for user in $(cut -f1 -d: /etc/passwd); do echo User:$user; crontab -l $user 2>&1 | grep -v crontab; done

Sie erhalten eine Liste der Benutzer, ohne dass die Fehler, die durch crontab geworfen bekommen, wenn ein Konto nicht Cron darf usw. verwenden Beachten Sie, dass in Solaris, Rollen in sein / etc / passwd zu (siehe / etc / user_attr).

Answer 11

for user in $(cut -f1 -d: /etc/passwd); 
do 
    echo $user; crontab -u $user -l; 
done

Answer 12

Zur kompletten Liste von Root-Benutzer erhalten.

for user in $(cut -f1 -d: /etc/passwd); do echo $user; sudo crontab -u $user -l; done

Answer 13

Die folgenden Streifen entfernt Kommentare, Leerzeilen und Fehler von Benutzern ohne crontab. Alles, was Sie links mit einem klaren Liste der Benutzer und ihre Arbeitsplätze.

Beachten Sie die Verwendung von sudo in der 2. Zeile. Wenn Sie bereits Root sind, entfernen das.

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

Beispiel Ausgabe:

# ------ 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

Ich benutze dies auf Ubuntu (12 bis 16) und Red Hat (5 bis 7).

Answer 14

Abhängig von Ihrer Version von cron. Mit Vixie cron auf FreeBSD, ich kann etwas tun:

(cd /var/cron/tabs && grep -vH ^# *) 

, wenn ich es mehr Tabs deliminated will, könnte ich so etwas tun:

(cd /var/cron/tabs && grep -vH ^# * | sed "s/:/      /")

Wo das ist eine wörtliche Registerkarte im sed Ersatzteil.

Es kann mehr System unabhängig sein, um eine Schleife durch die Benutzer in /etc/passwd und tut crontab -l -u $user für jeden von ihnen.

Answer 15

Vielen Dank für diese sehr nützliche Skript. Ich hatte ein paar kleine Probleme, die sie auf alten Systemen laufen (Red Hat Enterprise 3, die unterschiedlich egrep und Tabs in Strings verarbeiten) und andere Systeme mit nichts in /etc/cron.d/ (das Skript dann mit einem Fehler beendet). Also hier ist ein Patch, um es in solchen Fällen funktioniert:

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" |

Ich bin nicht wirklich sicher, dass die Änderungen in der ersten egrep eine gute Idee, aber gut, hat dieses Skript auf RHEL3,4,5 und Debian5 ohne Probleme getestet. Hoffe, das hilft!

Answer 16

Aufbauend auf dem Gipfel von @ Kyle

for user in $(tail -n +11 /etc/passwd | cut -f1 -d:); do echo $user; crontab -u $user -l; done

, um die Kommentare zu vermeiden, in der Regel an der Spitze der / etc / passwd,

Und auf macosx

for user in $(dscl . -list /users | cut -f1 -d:); do echo $user; crontab -u $user -l; done    

Answer 17

Ich denke, ein besserer Liner unten sei. Zum Beispiel, wenn Sie Benutzer in NIS oder LDAP würden sie nicht sein in / etc / passwd. Dies gibt Ihnen die crontabs jeder Benutzer, der sich angemeldet hat.

for I in `lastlog | grep -v Never | cut -f1 -d' '`; do echo $I ; crontab -l -u $I ; done

Answer 18

Sie können für alle Benutzerliste schreiben:

sudo crontab -u userName -l

,

Sie können auch gehen zu

cd /etc/cron.daily/
ls -l
cat filename

Diese Datei wird die Zeitpläne Liste

cd /etc/cron.d/
ls -l
cat filename

Answer 19

Mit Entschuldigungen und dank yukondude.

Ich habe versucht, die Timing-Einstellungen für eine einfache Lesung zusammenzufassen, obwohl es kein perfekter Job, und ich nicht berühren ‚jeden Freitag‘ oder ‚nur montags‘ Zeug.

Dies ist die Version 10 - nun:

• läuft viel schneller
• hat optional Fortschritt Zeichen, so dass Sie die Geschwindigkeit weiter verbessern könnten.
• verwendet eine Trennlinie zu separaten Header und ausgegeben.
• Ausgänge in einem kompakten Format, wenn alle Zeitintervalle uencountered zusammengefasst werden können.
• Akzeptiert Jan ... Dec-Deskriptoren für Monate-of-the-Jahres-
• Akzeptiert Mo ... So Deskriptoren für Tage-of-the-Woche
• versucht debian-Stil dummying-up von anacron zu handhaben, wenn es fehlt
• versucht mit crontab Linien zu behandeln, die eine Datei nach dem Vortest Ausführbarkeit läuft mit „[-x ...]“
• versucht mit crontab Linien zu behandeln, die eine Datei nach dem Vortest Ausführbarkeit mit „Befehl -v“
laufen
• ermöglicht die Verwendung von Intervall Spannweiten und Listen.
• unterstützt run-parts Verwendung in benutzerspezifischen Verzeichnis / var / spool crontab-Dateien.

veröffentliche ich jetzt das Skript vollständig hier.

https://gist.github.com/myshkin-uk/d667116d3e2d689f23f18f6cd3c71107

Answer 20

Da es eine Frage der Schleife durch eine Datei ist (/etc/passwd) und die Durchführung einer Aktion, ich bin der richtigen Ansatz fehle auf Wie können wir lesen, eine Datei (Datenstrom, variable) Zeile-für-Zeile (und / oder Feld-by-Feld) :

while IFS=":" read -r user _
do
   echo "crontab for user ${user}:"
   crontab -u "$user" -l
done < /etc/passwd

Dieses liest /etc/passwd Zeile für Zeile als Feldtrennzeichen verwendet :. Indem man sagt, read -r user _, machen $user wir das erste Feld zu halten und _ den Rest (es ist nur ein Junk-Variable Felder zu ignorieren).

Auf diese Weise können wir dann crontab -u rufen Sie die Variable $user verwenden, die wir für die Sicherheit zitieren (was, wenn es Leerzeichen enthält? Es ist unwahrscheinlich in einer solchen Datei ist, aber man kann nie wissen,).

Answer 21

Unter Solaris für einen bestimmten bekannten Benutzernamen:

crontab -l username

Alle anderen * Nix müssen -u Modifikator:

crontab -u username -l

Für alle Aufträge des Benutzers erhalten sofort auf Solaris, ähnlich wie andere Beiträge über:

for user in $(cut -f1 -d: /etc/passwd); do crontab -l $user 2>/dev/null; done

Answer 22

Für mich schauen / var / spool / cron / crontabs ist der beste Weg,

Answer 23

Dieses Skript gibt das Crontab in eine Datei und listet auch alle Benutzer jene bestätigt, die keinen crontab-Eintrag haben:

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