Exemplo n.º 1
0
    def poll(self):

        if self.result:
            return self.get_result()

        (self.result,
         result_value,
         self.error_reason,
         self.error_exception) = self._redis.hmget(self._task_hash_key,
                                                    (TASK_HKEY_RESULT,
                                                     TASK_HKEY_RESULT_VALUE,
                                                     TASK_HKEY_ERROR_REASON,
                                                     TASK_HKEY_ERROR_EXCEPTION))

        if result_value:
            self.result_value = json.loads(result_value)

        return self.get_result()
Exemplo n.º 2
0
def _exexcute_task(module, queue, task_id, task_hash_key):

    redis = create_redis_connection()
    logger = _create_logger()
    try:
        task = redis.hmget(task_hash_key,
                            (TASK_HKEY_FUNCTION,
                            TASK_HKEY_STATE,
                            TASK_HKEY_ARGS,
                            TASK_HKEY_VIRTUAL_MEMORY_LIMIT))
        print task

        function = task[0]
        state = task[1]
        args = task[2]
        virtual_memory_limit = task[3]

        if function is None or len(function) == 0:
            _set_task_finished(redis, queue, task_id, task_hash_key,
                          RESULT_FAILED,
                          error_reason='for function to execute was not supplied')
            return

        elif state != STATE_PENDING:
            _set_task_finished(redis, queue, task_id, task_hash_key,
                          RESULT_FAILED,
                          error_reason='to execute a task its state must be "{0}" not "{1}"'.format(STATE_PENDING,
                                                                                                    state))
            return

        _set_task_exexcuting(redis, task_hash_key)

        logger.info('executing task_id:{0}\nfunction: {1}\nargs: {2}\n virtual_memory_limit:{3}\n'.format(task_id,
                                                                         function,
                                                                         args,
                                                                         virtual_memory_limit))
        logger.info('--------------------------------------')

        if virtual_memory_limit:
            if isinstance(virtual_memory_limit, basestring):
                virtual_memory_limit = int(virtual_memory_limit)
            if virtual_memory_limit > 0:
                set_virtual_memory_limit(virtual_memory_limit)

        func = getattr(module, function)
        setattr(func, 'task_id', task_id)

        if args:
            result_value = func(**json.loads(args))
        else:
            result_value = func()

        if result_value:
            result_value = json.dumps(result_value, indent=2)

        _set_task_finished(redis,
                           queue,
                           task_id,
                           task_hash_key,
                           RESULT_SUCCESSFUL,
                           result_value,
                           logger=logger)

    except KeyboardInterrupt:
        logger.info('KeyboardInterrupt _exexcute_task')

    except Exception as ex:
        logger.info(traceback.format_exc())
        _set_task_finished(redis, queue, task_id, task_hash_key,
                      RESULT_FAILED,
                      logger=logger,
                      error_reason= '{0}: {1}'.format(type(ex), ex.message),
                      error_exception=traceback.format_exc())