web-dev-qa-db-fra.com

Utiliser superviseur comme CRON

Est-il possible de configurer supervisor pour exécuter des commandes toutes les X secondes (comme CRON)?

Je vois des exemples avec eventlistener et TICK_ event

[eventlistener:memmon]
command=memmon -a 200MB -m [email protected]
events=TICK_60

Mais il exécute la commande une seule fois.

cronsupervisord
28
barbushin

Problème

Comme vous le voyez dans l'exemple memmon, supervisord n'exécute pas memmon -a 200MB -m [email protected] à chaque événement. Au lieu de cela, il lance cet écouteur d'événement une fois (ou éventuellement plusieurs fois si vous configurez un pool), puis envoie chaque nouvel événement via l'entrée standard d'un processus existant.

Solution

Par conséquent, vous avez réellement besoin de rechercher ou d'écrire un écouteur d'événement compatible avec le superviseur pour chaque type de fonctionnalité supplémentaire que vous souhaitez déclencher pour les événements.

Exemple de méthode de mise en œuvre

Configurez la configuration et écrivez un écouteur

écrire une section d'événement supervisord.cfg

[eventlistener:passthru]
command=/tmp/simple.py /bin/date -u +"%%s %%S:%%H:%%d:%%m"
events=TICK_60

(note- l'échappement de % pour configParser )

écrire un écouteur d'événement simple.py

Créez ce programme d'écoute simple.py en apportant des modifications à l'exemple de programme d'écoute à partir de la documentation afin d'exécuter son premier argument avec tous les arguments restants:

#! /usr/bin/python
import sys
import subprocess

def write_stdout(s):
    sys.stdout.write(s)
    sys.stdout.flush()

def write_stderr(s):
    sys.stderr.write(s)
    sys.stderr.flush()

def main(args):
    while 1:
        write_stdout('READY\n') # transition from ACKNOWLEDGED to READY
        line = sys.stdin.readline()  # read header line from stdin
        write_stderr(line) # print it out to stderr
        headers = dict([ x.split(':') for x in line.split() ])
        data = sys.stdin.read(int(headers['len'])) # read the event payload
        res = subprocess.call(args, stdout=sys.stderr); # don't mess with real stdout
        write_stderr(data)
        write_stdout('RESULT 2\nOK') # transition from READY to ACKNOWLEDGED

if __== '__main__':
    main(sys.argv[1:])
    import sys

Assurez-vous que la configuration du superviseur fonctionne

$ supervisorctl [-c cfg]
supervisor> status
passthru                         RUNNING   pid 4471, uptime 0:00:32
supervisor> tail passthru
  OKREADY
  RESULT 2
  OKREADY
  ...
supervisor> tail passthru stderr
supervisor> tail passthru stderr
  ver:3.0 server:supervisor serial:0 pool:passthru poolserial:0 eventname:TICK_60 len:15
  1451411161 01:17:29:12 <--- output
  when:1451411160ver:3.0 server:supervisor serial:1 pool:passthru poolserial:1 eventname:TICK_60 len:15
  1451411220 00:17:29:12 <--- output
  when:1451411220

Maintenant, date -u +"%s %S:%H:%d:%m" est exécuté toutes les 60 secondes.

Permutation dans la commande souhaitée

créer un script exécutable

/tmp/hiworld.php:

#! /usr/bin/php
<?= "hiya\n";

(chmod + x ...)

change les arguments de l'auditeur dans supervisord.cfg

[eventlistener:passthru]
command=/tmp/simple.py /tmp/hiworld.php
;stdout_logfile=/tmp/passthru 
events=TICK_60
;autorestart=true
;startsecs=0

reload supervisord and test (la relecture semble ne pas détecter ce changement)

supervisor> reload
   Really restart the remote supervisord process y/N? y
   Restarted supervisord
supervisor> status
   passthru                         RUNNING   pid 6017, uptime 0:00:10
supervisor> tail passthru stderr
supervisor> status
   passthru                         RUNNING   pid 6017, uptime 0:00:21
supervisor> status
   passthru                         RUNNING   pid 6017, uptime 0:01:01
supervisor> tail passthru stderr
   ver:3.0 server:supervisor serial:316 pool:passthru poolserial:0 eventname:TICK_60 len:15
    hiya
   when:1418926740
supervisor>

Fin

Maintenant, la commande souhaitée est exécutée toutes les 60 secondes. Vous êtes maintenant prêt à ajuster les détails des autorisations, des emplacements, des journaux, etc.

18
lossleader

Pourquoi inventer la roue? Vous pouvez utiliser cron et supervisord ensemble.

Dans supervisord, créez une tâche avec autostart=false

Dans cron, utilisez * * * * * supervisorctl start <taskname> pour démarrer la tâche toutes les minutes.

6
AlexM

Le superviseur ne supporte pas cela facilement.

Mais pour atteindre votre objectif, vous pouvez simplement utiliser supervisor pour démarrer cron (pour un conteneur docker par exemple):

https://Gist.github.com/martinrusev/7015e393d46647dbad15

6
wid

Vous pouvez utiliser crobtab pour gérer et planifier vos programmes de superviseur.

Utilisez la commande supervisorctl start <program_name>

Remarque : Ceci ne démarrera qu'une seule instance du programme superviseur. S'il est déjà en cours d'exécution et que crontab tente de le déclencher à nouveau, la commande supervisorctl start ne démarrera pas une nouvelle instance.

1
Raman

Vous pouvez appeler la commande bash sleep:

[program:mycmd]
command=bash -c 'sleep 300 && exec <your command here>'

Cela lancera votre commande toutes les 5 minutes. N'oubliez pas la partie exec pour remplacer le processus bash par votre commande afin que le superviseur obtienne le code de sortie correct.

1
mixel