示例#1
0
    def __str__(self):
        """
        __str__
        """
        if not hasattr(self, "msg"):
            self.msg = ""

        if len(self.message) > 0:
            console_saved_exception("\n".join(self.message), self.verbose)
            self.msg = "\n"
            cnt = 0

            for i in self.args:
                for j in i:
                    if cnt == 0:
                        self.msg += "** " + str(j) + " **\n"
                    elif cnt < 3:
                        if cnt < 2:
                            self.msg += "  " + str(j)
                            self.msg += ":"
                        else:
                            self.msg += " " + str(j)
                    else:
                        if cnt == 3:
                            self.msg += "\n"
                        self.msg += "  " + j + "\n"
                    cnt += 1

        return self.msg
示例#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)