Example #1
0
    def _on_task_done(self, task):
        """Task callback.

        Args:
            task (asyncio.task.Task):
        """
        with Action.continue_task(task_id=self._context['eliot_task']):
            self.logger.debug(f"Task done: {self.name}")
            self._tm.unregister_task(self)
Example #2
0
def with_eliot(action_type, master_id=None, worker_id=None):
    assert master_id or worker_id
    if worker_id:
        # print "WITH {}".format(worker_id)
        master_id = RedisWorker(worker_id).master.master_id
    master = RedisMaster(master_id)
    eliot_task_id = master.eliot_task_id
    del Logger._destinations._destinations[:]
    to_file(open(eliot_log_path + master_id, "ab"))
    with Action.continue_task(task_id=eliot_task_id):
        return start_action(action_type=action_type)
Example #3
0
def with_eliot(action_type, master_id=None, worker_id=None):
    assert master_id or worker_id
    if worker_id:
        # print "WITH {}".format(worker_id)
        master_id = RedisWorker(worker_id).master.master_id
    master = RedisMaster(master_id)
    eliot_task_id = master.eliot_task_id
    del Logger._destinations._destinations[:]
    to_file(open(eliot_log_path + master_id, "ab"))
    with Action.continue_task(task_id=eliot_task_id):
        return start_action(action_type=action_type)
Example #4
0
def elioterize(action_type, master_id=None, worker_id=None):
    """Eliot action continuer that can log to either worker or master."""
    clear_logger_destinations(Logger)
    if worker_id:
        to_file(get_eliot_log_file(worker_id=worker_id))
        client = RedisWorker(worker_id)
    elif master_id:
        to_file(get_eliot_log_file(master_id=master_id))
        client = RedisMaster(master_id)

    with Action.continue_task(task_id=client.eliot_task_id):
        return start_action(action_type=action_type)
Example #5
0
def elioterize(action_type, master_id=None, worker_id=None):
    """Eliot action continuer that can log to either worker or master."""
    clear_logger_destinations(Logger)
    if worker_id:
        to_file(get_eliot_log_file(worker_id=worker_id))
        client = RedisWorker(worker_id)
    elif master_id:
        to_file(get_eliot_log_file(master_id=master_id))
        client = RedisMaster(master_id)

    with Action.continue_task(task_id=client.eliot_task_id):
        return start_action(action_type=action_type)
Example #6
0
    def logger(self, request, **routeArguments):
        serialized_remote_task = request.requestHeaders.getRawHeaders("X-Eliot-Task-Id", [None])[0]
        if serialized_remote_task is None:
            return original(self, request, **routeArguments)

        try:
            action = Action.continue_task(task_id=serialized_remote_task)
        except ValueError:
            return original(self, request, **routeArguments)
        with action.context():
            d = DeferredContext(original(self, request, **routeArguments))
            d.addActionFinish()
            return d.result
Example #7
0
    def logger(self, request, **routeArguments):
        serialized_remote_task = request.requestHeaders.getRawHeaders(
            "X-Eliot-Task-Id", [None])[0]
        if serialized_remote_task is None:
            return original(self, request, **routeArguments)

        try:
            action = Action.continue_task(task_id=serialized_remote_task)
        except ValueError:
            return original(self, request, **routeArguments)
        with action.context():
            d = DeferredContext(original(self, request, **routeArguments))
            d.addActionFinish()
            return d.result
Example #8
0
 def thread_start(task_id):
     # Since loading the image metadata is done separately from
     # booting the node, it's possible the metadata here won't
     # actually match the metadata of the image the node ends up
     # running (someone could replace the image with a different one
     # between this call and the node being started).  Since
     # generating images is currently a manual step, this probably
     # won't happen very often and if it does there's a person there
     # who can deal with it.  Also it will be resolved after the
     # next node restart.  It would be better to extract the image
     # metadata from the booted node, though.
     # FLOC-1905
     with Action.continue_task(task_id=task_id):
         self.image_metadata = self.driver.get_image_metadata()
         return self.driver.create()
Example #9
0
        def wrapper(*args, **kwargs):
            redis_worker = Session.session.config.option.redis_worker
            eliot_task_id = redis_worker.eliot_task_id
            # print "~{} {}".format(eliot_task_id, action_type)

            del Logger._destinations._destinations[:]
            to_file(open(os.path.join(eliot_log_path, redis_worker.master.uuid + '.' + redis_worker.task_id), "ab"))

            eliot_task = Action.continue_task(task_id=eliot_task_id)
            with eliot_task:
                with start_action(action_type=action_type,
                                  worker_id=redis_worker.task_id,
                                  **dec_kwargs):
                    func(*args, **kwargs)
                redis_worker.eliot_task_id = eliot_task.serialize_task_id()
Example #10
0
    def wrapped(*args, **kwargs):
        task_id = kwargs.get("task_id")
        if task_id:
            action = Action.continue_task(task_id=task_id)
        else:
            action = start_action(action_type=name)

        with action.context():
            task_id = action.serialize_task_id()
            kwargs["task_id"] = task_id
            if with_state:
                kwargs["state_manager"] = StateManager(name)

            try:
                return f(*args, **kwargs)
            except Exception as e:
                logging.exception(f"Error during the execution of {f}: <{e}>")

        action.finish()
Example #11
0
        def wrapper(*args, **kwargs):
            redis_worker = Session.session.config.option.redis_worker
            eliot_task_id = redis_worker.eliot_task_id
            # print "~{} {}".format(eliot_task_id, action_type)

            del Logger._destinations._destinations[:]
            to_file(
                open(
                    os.path.join(
                        eliot_log_path,
                        redis_worker.master.uuid + '.' + redis_worker.task_id),
                    "ab"))

            eliot_task = Action.continue_task(task_id=eliot_task_id)
            with eliot_task:
                with start_action(action_type=action_type,
                                  worker_id=redis_worker.task_id,
                                  **dec_kwargs):
                    func(*args, **kwargs)
                redis_worker.eliot_task_id = eliot_task.serialize_task_id()
Example #12
0
    def run(self):
        with Action.continue_task(task_id=self.task_id):
            try:
                with open(self.settings_file, "r") as fd:
                    global_settings = json.load(fd)

                logging_settings = global_settings.get("logging")
                live_settings = global_settings.get("live")

                logging.setup_python_logging(logging_settings)
                logging.setup_live_logging(logging_settings, live_settings)

                agent_processes = processes.start(global_settings)
            except KeyboardInterrupt:
                logging.info("Execution interrupted")
                raise
            except Exception:
                logging.exception("Error processing inputs")
                raise

        for item in agent_processes:
            item.terminate()
            item.join()
Example #13
0
 def fromStringProto(self, inString, proto):
     return Action.continue_task(
         proto.logger,
         Unicode.fromStringProto(self, inString, proto))
Example #14
0
 def fromStringProto(self, inString, proto):
     return Action.continue_task(
         proto.logger, Unicode.fromStringProto(self, inString, proto))
Example #15
0
def main():
    with Action.continue_task(task_id=request.headers["x-eliot-task-id"]):
        x = int(request.args["x"])
        y = int(request.args["y"])
        return str(divide(x, y))
Example #16
0
def main():
    with Action.continue_task(logger, request.headers["x-eliot-task-id"]):
        x = int(request.args["x"])
        y = int(request.args["y"])
        return str(divide(x, y))
Example #17
0
File: tasks.py Project: saml/x
def second_task(action_id):
    Message.log(action_id=action_id)
    with Action.continue_task(task_id=action_id):
        Message.log(action_id=action_id, ty=str(type(action_id)))