Testen Sie einen wöchentlichen Cron-Job [geschlossen]

Ich habe eine #!/bin/bashDatei im Verzeichnis cron.week.

Gibt es eine Möglichkeit zu testen, ob es funktioniert? Ich kann nicht 1 Woche warten

Ich bin auf Debian 6 mit root

Tun Sie einfach, was cron tut, und führen Sie Folgendes aus root:

run-parts -v /etc/cron.weekly

... oder der nächste, wenn Sie den Fehler "Kein Verzeichnis: -v" erhalten:

run-parts /etc/cron.weekly -v

Option -vdruckt die Skriptnamen, bevor sie ausgeführt werden.

Ein bisschen jenseits des Rahmens Ihrer Frage ... aber hier ist, was ich tue.

Das "Wie teste ich einen Cron-Job?" Die Frage ist eng verbunden mit "Wie teste ich Skripte, die in nicht interaktiven Kontexten ausgeführt werden, die von anderen Programmen gestartet wurden?" In cron ist der Auslöser eine zeitliche Bedingung, aber viele andere * nix-Funktionen starten Skripte oder Skriptfragmente auf nicht interaktive Weise, und häufig enthalten die Bedingungen, unter denen diese Skripte ausgeführt werden, etwas Unerwartetes und verursachen einen Bruch, bis die Fehler behoben sind. (Siehe auch: https://stackoverflow.com/a/17805088/237059 )

Ein allgemeiner Ansatz für dieses Problem ist hilfreich.

Eine meiner Lieblingstechniken ist die Verwendung eines von mir geschriebenen Skripts namens " Crontest ". Es startet den Zielbefehl innerhalb einer GNU-Bildschirmsitzung von cron aus, sodass Sie mit einem separaten Terminal anhängen können, um zu sehen, was los ist, mit dem Skript interagieren und sogar einen Debugger verwenden können.

Um dies einzurichten, würden Sie "alle Sterne" in Ihrem crontab-Eintrag verwenden und crontest als ersten Befehl in der Befehlszeile angeben, z.

* * * * * crontest /command/to/be/tested --param1 --param2

Jetzt führt cron Ihren Befehl jede Minute aus, aber crontest stellt sicher, dass jeweils nur eine Instanz ausgeführt wird. Wenn die Ausführung des Befehls einige Zeit in Anspruch nimmt, können Sie einen "Bildschirm -x" ausführen, um ihn anzuhängen und die Ausführung zu beobachten. Wenn es sich bei dem Befehl um ein Skript handelt, können Sie oben einen "Lese" -Befehl einfügen, um ihn anzuhalten und auf den Abschluss des Bildschirmanhangs zu warten (drücken Sie nach dem Anhängen die Eingabetaste).

Wenn Ihr Befehl ein Bash-Skript ist, können Sie stattdessen Folgendes tun:

* * * * * crontest --bashdb /command/to/be/tested --param1 --param2

Wenn Sie jetzt mit "screen -x" anhängen, sehen Sie sich einer interaktiven Bashdb-Sitzung gegenüber, und Sie können den Code schrittweise durchlaufen, Variablen untersuchen usw.

#!/bin/bash

# crontest
# See https://github.com/Stabledog/crontest for canonical source.

# Test wrapper for cron tasks.  The suggested use is:
#
#  1. When adding your cron job, use all 5 stars to make it run every minute
#  2. Wrap the command in crontest
#        
#
#  Example:
#
#  $ crontab -e
#     * * * * * /usr/local/bin/crontest $HOME/bin/my-new-script --myparams
#
#  Now, cron will run your job every minute, but crontest will only allow one
#  instance to run at a time.  
#
#  crontest always wraps the command in "screen -d -m" if possible, so you can
#  use "screen -x" to attach and interact with the job.   
#
#  If --bashdb is used, the command line will be passed to bashdb.  Thus you
#  can attach with "screen -x" and debug the remaining command in context.
#
#  NOTES:
#   - crontest can be used in other contexts, it doesn't have to be a cron job.
#       Any place where commands are invoked without an interactive terminal and
#       may need to be debugged.
#
#   - crontest writes its own stuff to /tmp/crontest.log
#
#   - If GNU screen isn't available, neither is --bashdb
#

crontestLog=/tmp/crontest.log
lockfile=$(if [[ -d /var/lock ]]; then echo /var/lock/crontest.lock; else echo /tmp/crontest.lock; fi )
useBashdb=false
useScreen=$( if which screen &>/dev/null; then echo true; else echo false; fi )
innerArgs="$@"
screenBin=$(which screen 2>/dev/null)

function errExit {
    echo "[-err-] $@" | tee -a $crontestLog >&2
}

function log {
    echo "[-stat-] $@" >> $crontestLog
}

function parseArgs {
    while [[ ! -z $1 ]]; do
        case $1 in
            --bashdb)
                if ! $useScreen; then
                    errExit "--bashdb invalid in crontest because GNU screen not installed"
                fi
                if ! which bashdb &>/dev/null; then
                    errExit "--bashdb invalid in crontest: no bashdb on the PATH"
                fi

                useBashdb=true
                ;;
            --)
                shift
                innerArgs="$@"
                return 0
                ;;
            *)
                innerArgs="$@"
                return 0
                ;;
        esac
        shift
    done
}

if [[ -z  $sourceMe ]]; then
    # Lock the lockfile (no, we do not wish to follow the standard
    # advice of wrapping this in a subshell!)
    exec 9>$lockfile
    flock -n 9 || exit 1

    # Zap any old log data:
    [[ -f $crontestLog ]] && rm -f $crontestLog

    parseArgs "$@"

    log "crontest starting at $(date)"
    log "Raw command line: $@"
    log "Inner args: $@"
    log "screenBin: $screenBin"
    log "useBashdb: $( if $useBashdb; then echo YES; else echo no; fi )"
    log "useScreen: $( if $useScreen; then echo YES; else echo no; fi )"

    # Were building a command line.
    cmdline=""

    # If screen is available, put the task inside a pseudo-terminal
    # owned by screen.  That allows the developer to do a "screen -x" to
    # interact with the running command:
    if $useScreen; then
        cmdline="$screenBin -D -m "
    fi

    # If bashdb is installed and --bashdb is specified on the command line,
    # pass the command to bashdb.  This allows the developer to do a "screen -x" to
    # interactively debug a bash shell script:
    if $useBashdb; then
        cmdline="$cmdline $(which bashdb) "
    fi

    # Finally, append the target command and params:
    cmdline="$cmdline $innerArgs"

    log "cmdline: $cmdline"


    # And run the whole schlock:
    $cmdline 

    res=$?

    log "Command result: $res"


    echo "[-result-] $(if [[ $res -eq 0 ]]; then echo ok; else echo fail; fi)" >> $crontestLog

    # Release the lock:
    9<&-
fi

Nachdem ich mit einigen Dingen in Cron herumgespielt hatte, die nicht sofort kompatibel waren, stellte ich fest, dass der folgende Ansatz zum Debuggen gut war:

crontab -e

* * * * * /path/to/prog var1 var2 &>>/tmp/cron_debug_log.log

Dadurch wird die Aufgabe einmal pro Minute ausgeführt, und Sie können einfach in die /tmp/cron_debug_log.logDatei schauen, um herauszufinden, was gerade passiert.

Es ist nicht genau der "Feuerjob", nach dem Sie vielleicht suchen, aber das hat mir sehr geholfen, als ich ein Skript debuggte, das anfangs nicht in cron funktionierte.

Ich würde eine Sperrdatei verwenden und dann den Cron-Job so einstellen, dass er jede Minute ausgeführt wird. (Verwenden Sie crontab -e und * * * * * / path / to / job.) Auf diese Weise können Sie die Dateien einfach weiter bearbeiten und jede Minute werden sie getestet. Außerdem können Sie den Cronjob stoppen, indem Sie einfach die Sperrdatei berühren.

    #!/bin/sh
    if [ -e /tmp/cronlock ]
    then
        echo "cronjob locked"
        exit 1
    fi

    touch /tmp/cronlock
    <...do your regular cron here ....>
    rm -f /tmp/cronlock

Wie wäre es cron.hourly, wenn Sie es einlegen , bis zum nächsten Durchlauf von Cron-Jobs warten und es dann entfernen? Das würde es einmal innerhalb einer Stunde und in der Cron-Umgebung ausführen. Sie können auch ausführen ./your_script, aber das hat nicht die gleiche Umgebung wie unter cron.

Keine dieser Antworten passte zu meiner spezifischen Situation, nämlich dass ich einen bestimmten Cron-Job nur einmal ausführen und sofort ausführen wollte.

Ich bin auf einem Ubuntu-Server und verwende cPanel, um meine Cron-Jobs einzurichten.

Ich habe einfach meine aktuellen Einstellungen aufgeschrieben und sie dann in einer Minute bearbeitet. Als ich einen anderen Fehler behoben habe, habe ich ihn in einer Minute erneut bearbeitet. Und als ich fertig war, habe ich die Einstellungen einfach wieder auf den vorherigen Stand zurückgesetzt.

Beispiel: Es ist jetzt 16:34 Uhr, also habe ich 35 16 * * * gesetzt, damit es um 16:35 Uhr läuft.

Es funktionierte wie ein Zauber, und das meiste, auf das ich jemals warten musste, war etwas weniger als eine Minute.

Ich dachte, dies sei eine bessere Option als einige der anderen Antworten, weil ich nicht alle meine wöchentlichen Crones ausführen wollte und nicht wollte, dass der Job jede Minute ausgeführt wird. Ich brauche ein paar Minuten, um die Probleme zu beheben, bevor ich bereit bin, sie erneut zu testen. Hoffentlich hilft das jemandem.

Abgesehen davon können Sie auch verwenden:

http://pypi.python.org/pypi/cronwrap

um Ihren Cron einzupacken und Ihnen bei Erfolg oder Misserfolg eine E-Mail zu senden.

Die Lösung, die ich verwende, lautet wie folgt:

1. Bearbeiten Sie crontab (verwenden Sie den Befehl: crontab -e), um den Job so oft wie nötig auszuführen (alle 1 Minute oder 5 Minuten).
2. Ändern Sie das Shell-Skript, das mit cron ausgeführt werden soll, um die Ausgabe in eine Datei zu
   drucken (z. B.: Echo "Working fine" >> output.txt)
3. Überprüfen Sie die Datei output.txt mit dem Befehl: tail -f output.txt, der die neuesten Ergänzungen in diese Datei druckt, und verfolgen Sie so die Ausführung des Skripts

Normalerweise teste ich, indem ich den von mir erstellten Job wie folgt ausführe:

Es ist einfacher, zwei Terminals zu verwenden, um dies zu tun.

Job ausführen:

#./jobname.sh

gehe zu:

#/var/log and run 

Führen Sie Folgendes aus:

#tailf /var/log/cron

Auf diese Weise kann ich sehen, wie die Cron-Protokolle in Echtzeit aktualisiert werden. Sie können das Protokoll auch überprüfen, nachdem Sie es ausgeführt haben. Ich bevorzuge es, es in Echtzeit anzusehen.

Hier ist ein Beispiel für einen einfachen Cron-Job. Ein leckeres Update ausführen ...

#!/bin/bash
YUM=/usr/bin/yum
$YUM -y -R 120 -d 0 -e 0 update yum
$YUM -y -R 10 -e 0 -d 0 update

Hier ist die Aufschlüsselung:

Der erste Befehl aktualisiert yum selbst und der nächste wendet Systemaktualisierungen an.

-R 120: Legt die maximale Wartezeit fest, bevor ein Befehl ausgeführt wird

-e 0: Setzt die Fehlerstufe auf 0 (Bereich 0 - 10). 0 bedeutet, dass nur kritische Fehler gedruckt werden, über die Sie informiert werden müssen.

-d 0: Setzt die Debugging-Stufe auf 0 - Erhöht oder verringert die Anzahl der gedruckten Elemente. (Bereich: 0 - 10).

-y: Angenommen, ja; Angenommen, die Antwort auf jede gestellte Frage lautet Ja

Nachdem ich den Cron-Job erstellt hatte, führte ich den folgenden Befehl aus, um meinen Job ausführbar zu machen.

#chmod +x /etc/cron.daily/jobname.sh 

Hoffe das hilft, Dorlack

sudo run-parts --test /var/spool/cron/crontabs/

Dateien in diesem crontabs/Verzeichnis müssen vom Eigentümer - oktal ausführbar sein700

Quelle: man cronund NNRooth's

Ich verwende Webmin, weil es ein Produktivitätsjuwel für jemanden ist, der die Befehlszeilenverwaltung als etwas entmutigend und undurchdringlich empfindet.

In der Weboberfläche "System> Geplante Cron-Jobs> Cron-Job bearbeiten" befindet sich die Schaltfläche "Jetzt speichern und ausführen".

Es zeigt die Ausgabe des Befehls an und ist genau das, was ich brauchte.