Exemplo n.º 1
0
def run_cron_tasks():
    for task in tasks:
        func, params, cron_line = task

        time = CronSchedule(cron_line)
        schedule = ScheduledCall(func, *params)
        schedule.start(time)
Exemplo n.º 2
0
def schedule_tasks():
    cron_tasks = tasks.filter_types('cron')
    for task in cron_tasks.itervalues():
        schedule = CronSchedule(task.cron)
        call = ScheduledCall(task.delay, *task.args,
                             **task.kwargs)
        call.start(schedule)
Exemplo n.º 3
0
def run_cron_tasks():
    for task in tasks:
        func, params, cron_line = task

        time = CronSchedule(cron_line)
        schedule = ScheduledCall(func, *params)
        schedule.start(time)
Exemplo n.º 4
0
    def _load_triggers(self):
        ''' 
        This function loads all the triggers from the database.
        '''
        
        # Stop any outstanding absolute time triggers in case of a reload.
        for schedule in self._absolute_time_schedule_calls:
            schedule.stop()
            
        self._absolute_time_schedule_calls = []
        
        triggers = yield self.db.query_triggers()
        
        for trigger in triggers:   
            t = Trigger(trigger[1], trigger[2], trigger[3])
            
            # get trigger parameters
            trigger_parameters = yield self.db.query_trigger_parameters(trigger[0])
            
            for param in trigger_parameters:
                if param[0] == "cron":
                    t.cron = param[1]
                elif param[0] == "current_value_id":
                    t.current_value_id = param[1]
                elif param[0] == "condition":
                    t.condition = param[1]
                elif param[0] == "condition_value":
                    t.condition_value = param[1]
            
            # Handle absolute time directly, and schedule. No need to keep track of this.
            if trigger[1] == "Absolute time":         

                c = CronSchedule(t.cron)
                print c.getNextEntry()
                s = ScheduledCall(f=self._absolute_time_triggered, eventid=trigger[2], conditions=trigger[3])
                s.start(c)
                
                self._absolute_time_schedule_calls.append(s)
                continue
            
            self._triggers.append(t)
Exemplo n.º 5
0
 def __init__(self, scheduler, name, **kwargs):
     self.scheduler = scheduler
     self.name = name
     self.taskpath = kwargs['task']
     self.args = util.dump(kwargs.get('args', []))
     self.kwargs = util.dump(kwargs.get('kwargs', {}))
     self.targets = [scheduler.nodes[host] for host in kwargs['targets']]
     self.schedule = CronSchedule(kwargs.get('schedule', "* * * * *"))
     self._timer = ScheduledCall(self.execute)
     self.description = kwargs.get(
         'description', "{task} @ {targets}".format(
             task=self.taskpath,
             targets=str(self.targets)))
Exemplo n.º 6
0
class LoomJob(object):
    "represents a scheduled job"
    def __init__(self, scheduler, name, **kwargs):
        self.scheduler = scheduler
        self.name = name
        self.taskpath = kwargs['task']
        self.args = util.dump(kwargs.get('args', []))
        self.kwargs = util.dump(kwargs.get('kwargs', {}))
        self.targets = [scheduler.nodes[host] for host in kwargs['targets']]
        self.schedule = CronSchedule(kwargs.get('schedule', "* * * * *"))
        self._timer = ScheduledCall(self.execute)
        self.description = kwargs.get(
            'description', "{task} @ {targets}".format(
                task=self.taskpath,
                targets=str(self.targets)))

    def start(self):
        "enable schedule for this job"
        if not self._timer.running:
            self._timer.start(self.schedule)

    def stop(self):
        "disable schedule for this job"
        if self._timer.running:
            self._timer.stop()

    def execute(self):
        "execute scheduled task"
        deferreds = []
        for node in self.targets:
            deferreds.append(self.scheduler.pp.doWork(amp.ExecuteTask, **{
                        'nodeinfo': node.__amp__(),
                        'taskpath': self.taskpath,
                        'args': self.args,
                        'kwargs': self.kwargs}))
        return defer.gatherResults(deferreds)