Sostituzione di Celerybeat con Chronos

Question

Quanto è maturo Chronos? È un'alternativa valida allo schedulatore come il sedano?

In questo momento la nostra pianificazione implementa un'attività periodica di "heartbeat" che controlla gli eventi "in sospeso" e li licenzia se sono in ritardo. Stiamo usando rrule python-dateutil per la definizione di questo.

Stiamo cercando alternative a questo approccio e Chronos sembra un'alternativa molto attactive: 1) ridurrebbe la necessità di utilizzare un'attività di pianificazione heartbeat, 2) supporta l'invio RESTful di eventi con il formato ISO8601, 3) ha un'interfaccia utile per la gestione e 4) scala.

Il requisito fondamentale è che la pianificazione deve essere configurabile al volo dall'interfaccia Web. Questo è il motivo per cui non è possibile usare la pianificazione integrata di Celerybeat fuori dalla scatola.

---

Abbiamo intenzione di spararci ai piedi passando a Chronos?

Answer 1

This SO ha soluzioni per il tuo problema di attività periodiche dinamiche. Non è la risposta accettata in questo momento:

from djcelery.models import PeriodicTask, IntervalSchedule 
from datetime import datetime 

class TaskScheduler(models.Model): 

    periodic_task = models.ForeignKey(PeriodicTask) 

    @staticmethod 
    def schedule_every(task_name, period, every, args=None, kwargs=None): 
    """ schedules a task by name every "every" "period". So an example call would be: 
      TaskScheduler('mycustomtask', 'seconds', 30, [1,2,3]) 
      that would schedule your custom task to run every 30 seconds with the arguments 1 ,2 and 3 passed to the actual task. 
    """ 
     permissible_periods = ['days', 'hours', 'minutes', 'seconds'] 
     if period not in permissible_periods: 
      raise Exception('Invalid period specified') 
     # create the periodic task and the interval 
     ptask_name = "%s_%s" % (task_name, datetime.datetime.now()) # create some name for the period task 
     interval_schedules = IntervalSchedule.objects.filter(period=period, every=every) 
     if interval_schedules: # just check if interval schedules exist like that already and reuse em 
      interval_schedule = interval_schedules[0] 
     else: # create a brand new interval schedule 
      interval_schedule = IntervalSchedule() 
      interval_schedule.every = every # should check to make sure this is a positive int 
      interval_schedule.period = period 
      interval_schedule.save() 
     ptask = PeriodicTask(name=ptask_name, task=task_name, interval=interval_schedule) 
     if args: 
      ptask.args = args 
     if kwargs: 
      ptask.kwargs = kwargs 
     ptask.save() 
     return TaskScheduler.objects.create(periodic_task=ptask) 

    def stop(self): 
     """pauses the task""" 
     ptask = self.periodic_task 
     ptask.enabled = False 
     ptask.save() 

    def start(self): 
     """starts the task""" 
     ptask = self.periodic_task 
     ptask.enabled = True 
     ptask.save() 

    def terminate(self): 
     self.stop() 
     ptask = self.periodic_task 
     self.delete() 
     ptask.delete() 

non ho ancora usato djcelery, ma ha presumibilmente un'interfaccia di amministrazione per task periodici dinamici.