예제 #1
0
    def start(self, *argc):
        """
        @param argc:
        @type argc:
        """
        if self.verbose:
            console("task_start", self.object_id, color="magenta")

        if not self.m_crypto_user_object_id:
            raise TaskException("start: no crypto_user_object_id set")

        self.save_callable(argc)
        rs = RedisServer("crypto_taskworker", verbose=self.verbose)

        def taskdone(taskid):
            """
            @type taskid: str
            """
            if taskid is None:
                return

            if self.verbose:
                console("taskdone", taskid, source_code_link(), color="magenta")

            if taskid == self.object_id:
                self.load()
        self.tasksubscription = rs.event_subscribe("taskdone:" + str(self.object_id), taskdone)
        rs.list_push("tasks", self.object_id)
        rs.event_emit("runtasks", self.get_serverconfig().get_namespace())
예제 #2
0
    def join(self, max_wait_seconds=None):
        """
        @type max_wait_seconds: float, None
        """
        try:
            if self.tasksubscription is None:
                raise TaskException("task not started")

            rs = RedisServer("crypto_taskworker", verbose=self.verbose)
            try:
                if max_wait_seconds:
                    start = time.time()
                    runtime = time.time() - start

                    while runtime < max_wait_seconds:
                        if self.tasksubscription.is_alive():
                            time.sleep(0.1)
                            rs.event_emit("runtasks", self.get_serverconfig().get_namespace())
                            runtime = time.time() - start
                        else:
                            break

                    if runtime > max_wait_seconds:
                        raise RedisEventWaitTimeout()
                else:
                    while self.tasksubscription.is_alive():
                        time.sleep(0.1)
                        rs.event_emit("runtasks", self.get_serverconfig().get_namespace())

            except RedisEventWaitTimeout:
                object_name = self.human_object_name(self.object_id)
                raise TaskTimeOut(str(object_name) + " timed out")

            if self.m_task_exception is not None:
                if len(self.m_task_exception) > 0:
                    major_info = console_saved_exception(self.m_task_exception, False)
                    excclass = str(major_info[0]).strip().split(".")

                    if len(excclass) > 1:
                        excclass = excclass[1].strip("'>")

                    exc = TaskExecuteException(major_info)
                    major_info[0] = excclass
                    exc.verbose = self.verbose
                    globalvars = globals()

                    if excclass in globalvars:
                        raise globalvars[excclass]("\n\n" + "\n".join(major_info))
                    else:
                        raise exc

            return True
        finally:
            if self.object_id is not None:
                self.delete(delete_from_datastore=False)