Uruchamianie zadania cron ręcznie i natychmiast

(Przeczytałem już Jak mogę przetestować nowy skrypt cron? )

Mam konkretny problem (zadanie CRON nie wydaje się działać lub działa poprawnie), ale problem jest ogólny: chciałbym debugować skrypty, które są kontrolowane. Wiem, że mogę skonfigurować linię crontab * * * * *, ale nie jest to w pełni zadowalające rozwiązanie. Chciałbym móc uruchomić zadanie cron z wiersza poleceń, tak jakby uruchomiło je cron (ten sam użytkownik, te same zmienne środowiskowe itp.). Czy jest na to sposób? Nie trzeba czekać 60 sekund na przetestowanie zmian skryptu.

Oto co zrobiłem i wydaje się, że działa w tej sytuacji. Przynajmniej pokazuje mi błąd, podczas gdy uruchamiany z wiersza poleceń, ponieważ użytkownik nie pokazuje błędu.

Krok 1 : Tymczasowo umieszczam ten wiersz w crontab użytkownika:

* * * * *   /usr/bin/env > /home/username/tmp/cron-env

następnie wyjął go po zapisaniu pliku.

Krok 2 : Zrobiłem sobie mały skrypt bash typu run-as-cron zawierający:

#!/bin/bash
/usr/bin/env -i $(cat /home/username/tmp/cron-env) "$@"

Tak więc, jako dany użytkownik, byłem w stanie

run-as-cron /the/problematic/script --with arguments --and parameters

To rozwiązanie można oczywiście rozszerzyć, aby korzystać z sudo lub podobnego rozwiązania dla większej elastyczności.

Mam nadzieję, że to pomaga innym.

Przedstawiam rozwiązanie oparte na odpowiedzi Pistos, ale bez wad.

• Dodaj następujący wiersz do crontab, np. Używając crontab -e

  * * * * *  /usr/bin/env > /home/username/cron-env
  

• Utwórz skrypt powłoki, który wykonuje polecenie w tym samym środowisku, w którym uruchamiane są zadania cron:

  #!/bin/sh
  
  . "$1"
  exec /usr/bin/env -i "$SHELL" -c ". $1; $2"
  

Posługiwać się:

run-as-cron <cron-environment> <command>

na przykład

run-as-cron /home/username/cron-env 'echo $PATH'

Zauważ, że drugi argument musi zostać zacytowany, jeśli wymaga argumentu. Pierwszy wiersz skryptu ładuje powłokę POSIX jako interpreter. Drugi wiersz pobiera plik środowiska cron. Jest to wymagane do załadowania poprawnej powłoki, która jest przechowywana w zmiennej środowiskowej SHELL. Następnie ładuje puste środowisko (aby zapobiec wyciekaniu zmiennych środowiskowych do nowej powłoki), uruchamia tę samą powłokę, która jest używana dla cronjobs i ładuje zmienne środowiskowe cron. Na koniec polecenie jest wykonywane.

Ponieważ crontab nie wykonuje zadania, będziesz manipulować jego zawartością:

crontab -l | grep -v '^#' | cut -f 6- -d ' ' | while read CMD; do eval $CMD; done

Co to robi :

• wyświetla listę zadań crontab
• usuń wiersze komentarza
• usuń konfigurację crontab
• następnie uruchom je jeden po drugim

Domyślnie w przypadku większości domyślnych demonów cron, które widziałem, po prostu nie ma sposobu, aby powiedzieć cronowi, aby teraz działał tutaj. Jeśli używasz anakronu, być może możliwe jest uruchomienie osobnej instancji na pierwszym planie.

Jeśli twoje skrypty nie działają poprawnie, nie bierzesz tego pod uwagę

• skrypt działa jako określony użytkownik
• cron ma ograniczone środowisko (najbardziej oczywistym tego przejawem jest inna ścieżka).

Z crontab (5):

Kilka zmiennych środowiskowych jest konfigurowanych automatycznie przez demona cron (8). SHELL jest ustawiony na / bin / sh, a LOGNAME i HOME są ustawiane z wiersza / etc / passwd właściciela crontab. PATH jest ustawione na „/ usr / bin: / bin”. HOME, SHELL i PATH mogą zostać zastąpione przez ustawienia w crontab; LOGNAME to użytkownik, od którego uruchomione jest zadanie, i nie można go zmienić.

Ogólnie ŚCIEŻKA jest największym problemem, dlatego musisz:

• Jawnie ustaw PATH w skrypcie podczas testowania na / usr / bin: / bin. Możesz to zrobić w bashie za pomocą PATH eksportu = "/ usr / bin: / bin"
• Wyraźnie ustaw odpowiednią ŚCIEŻKĘ na górze tabeli crontab. np. PATH = "/ usr / bin: / bin: / usr / local / bin: / usr / sbin: / sbin"

Jeśli chcesz uruchomić skrypt jako inny użytkownik bez powłoki (np. Www-data), użyj sudo:

sudo -u www-data /path/to/crontab-script.sh

Pierwszą rzeczą do przetestowania przed tym wszystkim jest oczywiście to, że skrypt faktycznie robi to, co powinien, z wiersza poleceń. Jeśli nie możesz uruchomić go z wiersza poleceń, to oczywiście nie będzie działał z cronem.

Z jakiegoś powodu skrypt Marco nie działał dla mnie. Nie miałem czasu na debugowanie, więc napisałem skrypt w języku Python, który robi to samo. Jest dłuższy, ale: po pierwsze, działa dla mnie, a po drugie, łatwiej mi zrozumieć. Zmień „/ tmp / cron-env” na miejsce, w którym zapisałeś swoje środowisko. Oto on:

#!/usr/bin/env python
from __future__ import division, print_function

import sys
import os

def main():
    if len(sys.argv) != 2 or sys.argv[1] in ('-h', '--help'):
        print("Usage: {} CMD\n"
              "Run a command as cron would. Note that CMD must be quoted to be only one argument."
              .format(sys.argv[0]))
        sys.exit(1)
    _me, cmd = sys.argv
    env = dict(line.strip().split('=', 1) for line in open('/tmp/cron-env'))
    sh = env['SHELL']
    os.execvpe(sh, [sh, '-c', cmd], env)

if __name__ == '__main__':
    main()

Cóż, użytkownik jest taki sam jak ten, który umieściłeś we wpisie crontab (lub na którego crontab wkładasz go naprzemiennie), więc nie ma wątpliwości. crontab(5) powinien dać ci listę ustawionych zmiennych środowiskowych, jest tylko kilka.

W większości crontabów, takich jak np. Vixie-cron, możesz umieścić zmienne w samym crontabie w ten sposób, a następnie użyć / usr / bin / env, aby sprawdzić, czy zadziałało. W ten sposób możesz sprawić, by skrypt działał w crontab, gdy dowiesz się, co jest nie tak ze skryptem run-as-cron.

SHELL=/bin/bash
LANG=en
FASEL=BLA

* * * * *   /usr/bin/env > /home/username/cron-env

Rozwiązanie Marco nie działało dla mnie, ale skrypt Pythona Noama działał. Oto niewielka modyfikacja skryptu Marco, która sprawiła, że ​​zadziałał dla mnie:

#!/bin/sh
. "$1"
exec /usr/bin/env -i "$SHELL" -c "set -a;. $1; $2"

Dodano set -azmienne eksportu zdefiniowane w skrypcie $ 1 i udostępniono je do polecenia $ 2

ps Pyton Noama działał, ponieważ „eksportował” środowisko do procesu potomnego.

Jeśli jest to skrypt powłoki, powinno to zapewnić ci większość możliwości:

sudo su  # (assuming it's run as root, if not switch to the user you want it to run as)
cd  # Switch to home folder
sh <full-path/my-shell-script>

Na pewno uwypukli niektóre problemy, jeśli nie wszystko.

Nigdy nie znalazłem sposobu na ręczne uruchamianie zadań crona, ale ten zapis sugeruje ustawienie tego samego środowiska, które miałoby cronjob i ręczne uruchomienie skryptu.

możesz zaprogramować pracę, aby rozpocząć następną minutę :)

Zastanawiałem się nad odpowiedzią Marco. Kod pokazano poniżej, ale utrzymam ten skrypt tutaj .

Biorąc pod uwagę ten crontab:

# m h  dom mon dow   command

X=Y
1 2 3 4 5 6 echo "Hello, world"
1 2 3 4 5 6 echo "Goodby, cruel world"
1 2 3 4 5 6 echo "Please spare me the drama"

Przykładowa sesja użytkowania:

$ cronTest
This is the crontab for  without comment lines or blank lines:
     1  X=Y
     2  echo "Hello, world"
     3  echo "Goodby, cruel world"
     4  echo "Please spare me the drama"
Which line would you like to run as  now?
55
55 is not valid, please enter an integer from 1 to 4
2

Evaluating 1: X=Y

Evaluating 2: echo "Hello, world"
Hello, world

To cronTest2, co musi być prawidłowo wywołany skonfigurować zmienne środowiskowe w taki sam sposób, jak robi cron:

#!/bin/bash

# Prompt user for a user crontab entry to execute

function deleteTempFile {
  rm -f $TEMP_FILE
}

function debug {
  if [ "$DEBUG" ]; then >&2 printf "$1\n"; fi
}

function isValidLineNumber {
  # $1 - number of lines
  # $2 - requested line number
  if [[ -n "${2//[0-9]+/}" ]] && (( $2 <= $1 )); then echo true; else echo false; fi
}

function isVariableAssignment {
  [[ "$( echo "$1" | grep "=" )" ]]
}

function makeTempCrontab {
  local -r ASTERISK=\\*
  local -r NUMBER='[[:digit:]]{1,2}'
  local -r NUMBERS="$NUMBER(,$NUMBER)+"
  local -r CRON="^(($ASTERISK|$NUMBER|$NUMBERS)[[:space:]]+)"
  local -r CRON5_REGEX="$CRON{5}"
  local -r CRON6_REGEX="$CRON{6}"

  rm -f "$TEMP_FILE"

  local -r ALL_LINES="$( crontab -l )"

  # Ignore empty lines and lines starting with # (comment lines)
  local -r LINES="$( 
    echo "$ALL_LINES" | \
    grep -v '^[[:space:]]*#' | \
    grep -v '^[[:space:]]*$'
  )"

  if [[ -z "$LINES" ]]; then
    echo "Your crontab is empty, nothing to do"
    exit 1
  fi

  IFS=$'\n' 
  for LINE in $LINES; do
    LINE="$( echo "$LINE" | sed 's/\s\+$//e' )" # remove trailing space
    if [ "$( echo "$LINE" | grep "^$" )" ]; then  
      debug ""  # ignore empty line
    elif [ "$( echo "$LINE" | egrep "$CRON6_REGEX" )" ]; then
      debug "6 field date/time specifier: $LINE"
      # strip out when to run debug, leaving just the command to execute
      echo "$LINE" | cut -f 7- -d ' ' >> "$TEMP_FILE"
    elif [ "$( echo "$LINE" | egrep "$CRON5_REGEX" )" ]; then
      debug "5 field date/time specifier: $LINE"
      # strip out when to run debug, leaving just the command to execute
      echo "$LINE" | cut -f 6- -d ' ' >> "$TEMP_FILE"
    elif [ "$( echo "$LINE" | grep '^@' )" ]; then
      debug "@declaration: $LINE"
      # strip out @declaration, leaving just the command to execute
      echo "$LINE" | cut -f 2- -d ' ' >> "$TEMP_FILE"
    elif [ "$( echo "$LINE" | grep '=' )" ]; then
      debug "Variable assignment: $LINE"
      echo "$LINE"  >> "$TEMP_FILE"
    else
      debug "Ignored: $LINE"
    fi
  done
  unset IFS
}

function runUpToLine {
  # Scans up to given line number in $TEMP_FILE
  # Evaluates variable assignment
  # Executes specified line
  # Ignores remainder of file
  # Function definitions are not supported
  #
  # $1 - line number to run

  readarray CONTENTS < "$TEMP_FILE"
  for (( i=0; i<=$1; i++ )); do
    # >&2 echo "\$i=$i, \$1=$1, isVariableAssignment: $( isVariableAssignment $CONTENTS[$i] ), CONTENTS[$i]=${CONTENTS[$i]}"
    if isVariableAssignment ${CONTENTS[$i]} || (( $i == $1 )); then
      printf "\nEvaluating $(( i+1 )): ${CONTENTS[$i]}"
      eval "${CONTENTS[$i]}"
    fi
  done
}

function selectLine {
  >&2 echo "This is the crontab for $USER without comment lines or blank lines:"
  cat -n "$TEMP_FILE" >&2
  >&2 echo "Which line would you like to run as $USER now?"

  local -r NUM_LINES=$( cat "$TEMP_FILE" | wc -l )
  read LINE_NUMBER
  # >&2 echo "NUM_LINES=$NUM_LINES, LINE_NUMBER=$LINE_NUMBER;  valid: $( isValidLineNumber $NUM_LINES $LINE_NUMBER )"
  while [[ $( isValidLineNumber $NUM_LINES $LINE_NUMBER ) == false ]]; do
    >&2 echo "$LINE_NUMBER is not valid, please enter an integer from 1 to $NUM_LINES"
    read LINE_NUMBER
    # >&2 echo "NUM_LINES=$NUM_LINES, LINE_NUMBER=$LINE_NUMBER;  valid: $( isValidLineNumber $NUM_LINES $LINE_NUMBER )"
  done
  (( LINE_NUMBER-- ))
  echo ${LINE_NUMBER}
}

function doIt {
  export USER=$1
  local -r TEMP_FILE="$( mktemp crontabTest.XXX )"
  trap deleteTempFile EXIT

  makeTempCrontab
  local -r LINE_NUMBER="$( selectLine )"
  runUpToLine $LINE_NUMBER
}

doIt "$1" 

cronTestdziała cronTest2z ustawionymi odpowiednimi zmiennymi środowiskowymi:

#!/bin/bash

# Execute a user crontab entry with the proper environment

DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"

env -i bash --noprofile --norc -c "$DIR/cronTest2 $USER"