Beispiel #1
0
    def add_new_job(self, identifier, image_name, callback, tasks):
        """ Add a new job to the job queue

        :param identifier: The identifier for the job
        :param image_name: The name of the image to run each task
        :param callback: The callback URL to report results
        :param tasks: The individual tasks to run
        """
        if not tasks:
            self._logger.error(
                'No tasks provided when submitting job {i}'.format(
                    i=identifier))
            raise ValueError('Tasks must be provided with the job')

        self._logger.info('Adding job {i} to the queue'.format(i=identifier))
        self._job_db.add_job(identifier, image_name, callback)

        self._jobs.add(identifier)

        for t in tasks:
            self._tasks.appendleft(
                TaskEntry(identifier, t['task_name'], t['task_args'],
                          image_name, None, None))

        self._job_db.add_tasks(identifier, tasks)
class TupleTest(TestCase):
	def setUp(self):
		task = Task.objects.create(name='new task')
		self.te = TaskEntry(task=task)

	def test_time(self):
		self.te.start()
		c = self.te.clock_started
		t = self.te.time_record
		
		hour,min,sec = t.hour,t.minute,t.second
		formatted_time = time(hour,min,sec)
		
	def test_date(self):
		self.te.start()
		datetime.combine(self.te.date_field,self.format_time(self.te.time_record))
	
	def format_time(self,t):
		hour,min,sec = t.hour,t.minute,t.second
		return time(hour,min,sec)

	def test_subtract_dates(self):
		self.te.start()
		df = self.te.date_field
		ft = self.format_time(self.te.time_record)
		diff = datetime.now() - datetime.combine(df,ft)
		diff.seconds


	def test_edit_data(self):
		dt = datetime.strptime('2016-01-21T22:50',"%Y-%m-%dT%H:%M")
		time = dt.time()
		date = dt.date()
Beispiel #3
0
    def _scan_for_dead_jobs(self):
        def item_filter(entry: TaskEntry):
            return entry.task_id not in self._overdue_tasks

        while True:
            time.sleep(self.DEAD_SCAN_INTERVAL)
            with self._lock:
                overdue = [
                    t for t in self._running_tasks if datetime.datetime.now() -
                    t.started > self.DEAD_JOB_INTERVAL
                ]
                for task in overdue:
                    self._overdue_tasks.add(task.task_id)
                    self._tasks.appendleft(
                        TaskEntry(task.identifier, task.name, task.args,
                                  task.image, None, None))
                self._running_tasks = list(
                    filter(item_filter, self._running_tasks))
            self._signal_should_run()
Beispiel #4
0
 def set_details(entry: TaskEntry):
     if entry.identifier != identifier or entry.name != name:
         return entry
     return TaskEntry(entry.identifier, entry.name, entry.args,
                      entry.image, task_id, datetime.datetime.now())
def start_experiment(request, save=True):
    '''
    Handles presses of the 'Start Experiment' and 'Test' buttons in the browser 
    interface
    '''
    #make sure we don't have an already-running experiment
    if exp_tracker.status.value != '':
        http_request_queue.append((request, save))
        return _respond(dict(status="running", msg="Already running task, queuelen=%d!" % len(http_request_queue)))

    # Try to start the task, and if there are any errors, send them to the browser interface
    try:
        data = json.loads(request.POST['data'])

        task =  Task.objects.get(pk=data['task'])
        Exp = task.get(feats=data['feats'].keys())

        entry = TaskEntry(subject_id=data['subject'], task=task)
        params = Parameters.from_html(data['params'])
        entry.params = params.to_json()
        kwargs = dict(subj=entry.subject, task_rec=task, feats=Feature.getall(data['feats'].keys()),
                      params=params)

        # Save the target sequence to the database and link to the task entry, if the task type uses target sequences
        if issubclass(Exp, experiment.Sequence):
            print "creating seq"
            print "data['sequence'] POST data"
            print data['sequence']
            seq = Sequence.from_json(data['sequence'])
            seq.task = task
            if save:
                seq.save()
            entry.sequence = seq
            kwargs['seq'] = seq
        else:
            entry.sequence_id = -1
        
        response = dict(status="testing", subj=entry.subject.name, 
                        task=entry.task.name)

        if save:
            # Save the task entry to database
            entry.save()

            # Link the features used to the task entry
            for feat in data['feats'].keys():
                f = Feature.objects.get(pk=feat)
                entry.feats.add(f.pk)

            response['date'] = entry.date.strftime("%h %d, %Y %I:%M %p")
            response['status'] = "running"
            response['idx'] = entry.id

            # Give the entry ID to the runtask as a kwarg so that files can be linked after the task is done
            kwargs['saveid'] = entry.id
        
        # Start the task FSM and exp_tracker
        exp_tracker.runtask(**kwargs)

        # Return the JSON response
        return _respond(response)

    except Exception as e:
        # Generate an HTML response with the traceback of any exceptions thrown
        import cStringIO
        import traceback
        err = cStringIO.StringIO()
        traceback.print_exc(None, err)
        err.seek(0)
        return _respond(dict(status="error", msg=err.read()))
	def setUp(self):
		task = Task.objects.create(name='new task')
		self.te = TaskEntry(task=task)