def current(): ident = get_ident() with ALL_LOCK: output = ALL.get(ident) if output is None: Log.warning("this thread is not known. Register this thread at earliest known entry point.") return BaseThread(get_ident()) return output
def current(): ident = get_ident() with ALL_LOCK: output = ALL.get(ident) if output is None: Log.warning( "this thread is not known. Register this thread at earliest known entry point." ) return BaseThread(get_ident()) return output
def current(): id = get_ident() with ALL_LOCK: try: return ALL[id] except KeyError: return MAIN_THREAD
def __init__(self): BaseThread.__init__(self, get_ident()) self.name = "Main Thread" self.please_stop = Signal() self.stopped = Signal() self.stop_logging = Log.stop self.timers = None self.shutdown_locker = allocate_lock()
def __init__(self): self.name = "Main Thread" self.id = get_ident() self.please_stop = Signal() self.children = [] self.stop_logging = Log.stop self.timers = None self.cprofiler = Null
def current(): ident = get_ident() with ALL_LOCK: output = ALL.get(ident) if output is None: thread = BaseThread(ident) thread.cprofiler = CProfiler() thread.cprofiler.__enter__() with ALL_LOCK: ALL[ident] = thread Log.warning("this thread is not known. Register this thread at earliest known entry point.") return thread return output
def _run(self): self.id = get_ident() with RegisterThread(self): try: if self.target is not None: a, k, self.args, self.kwargs = self.args, self.kwargs, None, None self.end_of_thread.response = self.target(*a, **k) self.parent.remove_child(self) # IF THREAD ENDS OK, THEN FORGET ABOUT IT except Exception as e: e = Except.wrap(e) with self.synch_lock: self.end_of_thread.exception = e with self.parent.child_lock: emit_problem = self not in self.parent.children if emit_problem: # THREAD FAILURES ARE A PROBLEM ONLY IF NO ONE WILL BE JOINING WITH IT try: Log.fatal("Problem in thread {{name|quote}}", name=self.name, cause=e) except Exception: sys.stderr.write(str("ERROR in thread: " + self.name + " " + text_type(e) + "\n")) finally: try: with self.child_lock: children = copy(self.children) for c in children: try: DEBUG and sys.stdout.write(str("Stopping thread " + c.name + "\n")) c.stop() except Exception as e: Log.warning("Problem stopping thread {{thread}}", thread=c.name, cause=e) for c in children: try: DEBUG and sys.stdout.write(str("Joining on thread " + c.name + "\n")) c.join() except Exception as e: Log.warning("Problem joining thread {{thread}}", thread=c.name, cause=e) finally: DEBUG and sys.stdout.write(str("Joined on thread " + c.name + "\n")) del self.target, self.args, self.kwargs DEBUG and Log.note("thread {{name|quote}} stopping", name=self.name) except Exception as e: DEBUG and Log.warning("problem with thread {{name|quote}}", cause=e, name=self.name) finally: self.stopped.go() DEBUG and Log.note("thread {{name|quote}} is done", name=self.name)
def _run(self): self.id = get_ident() with RegisterThread(self): try: if self.target is not None: a, k, self.args, self.kwargs = self.args, self.kwargs, None, None self.end_of_thread.response = self.target(*a, **k) self.parent.remove_child(self) # IF THREAD ENDS OK, THEN FORGET ABOUT IT except Exception as e: e = Except.wrap(e) with self.synch_lock: self.end_of_thread.exception = e with self.parent.child_lock: emit_problem = self not in self.parent.children if emit_problem: # THREAD FAILURES ARE A PROBLEM ONLY IF NO ONE WILL BE JOINING WITH IT try: Log.fatal("Problem in thread {{name|quote}}", name=self.name, cause=e) except Exception: sys.stderr.write(str("ERROR in thread: " + self.name + " " + text_type(e) + "\n")) finally: try: with self.child_lock: children = copy(self.children) for c in children: try: DEBUG and sys.stdout.write(str("Stopping thread " + c.name + "\n")) c.stop() except Exception as e: Log.warning("Problem stopping thread {{thread}}", thread=c.name, cause=e) for c in children: try: DEBUG and sys.stdout.write(str("Joining on thread " + c.name + "\n")) c.join() except Exception as e: Log.warning("Problem joining thread {{thread}}", thread=c.name, cause=e) finally: DEBUG and sys.stdout.write(str("Joined on thread " + c.name + "\n")) del self.target, self.args, self.kwargs DEBUG and Log.note("thread {{name|quote}} stopping", name=self.name) except Exception as e: DEBUG and Log.warning("problem with thread {{name|quote}}", cause=e, name=self.name) finally: self.stopped.go() DEBUG and Log.note("thread {{name|quote}} is done", name=self.name)
Log.warning("programming error", cause=e) finally: if please_stop: Log.note("please_stop has been requested") Log.note("done waiting for exit") def _wait_for_interrupt(please_stop): DEBUG and Log.note("wait for stop signal") try: # ALTERNATE BETWEEN please_stop CHECK AND SIGINT CHECK while not please_stop: sleep(1) # LOCKS CAN NOT BE INTERRUPTED, ONLY sleep() CAN finally: please_stop.go() MAIN_THREAD = MainThread() def stop_main_thread(signum=0, frame=None): MAIN_THREAD.please_stop.go() _signal.signal(_signal.SIGTERM, stop_main_thread) _signal.signal(_signal.SIGINT, stop_main_thread) ALL_LOCK = allocate_lock() ALL = dict() ALL[get_ident()] = MAIN_THREAD
def __init__(self): BaseThread.__init__(self, get_ident()) self.name = "Main Thread" self.please_stop = Signal() self.stop_logging = Log.stop self.timers = None
def __init__(self): self.name = "Main Thread" self.id = get_ident() self.children = [] self.timers = None
def _run(self): self.id = get_ident() with ALL_LOCK: ALL[self.id] = self try: if self.target is not None: a, k, self.args, self.kwargs = self.args, self.kwargs, None, None self.cprofiler = CProfiler() with self.cprofiler: # PROFILE IN HERE SO THAT __exit__() IS RUN BEFORE THREAD MARKED AS stopped response = self.target(*a, **k) with self.synch_lock: self.end_of_thread = Data(response=response) else: with self.synch_lock: self.end_of_thread = Null except Exception as e: e = Except.wrap(e) with self.synch_lock: self.end_of_thread = Data(exception=e) if self not in self.parent.children: # THREAD FAILURES ARE A PROBLEM ONLY IF NO ONE WILL BE JOINING WITH IT try: Log.fatal("Problem in thread {{name|quote}}", name=self.name, cause=e) except Exception: sys.stderr.write( str("ERROR in thread: " + self.name + " " + text_type(e) + "\n")) finally: try: children = copy(self.children) for c in children: try: if DEBUG: sys.stdout.write( str("Stopping thread " + c.name + "\n")) c.stop() except Exception as e: Log.warning("Problem stopping thread {{thread}}", thread=c.name, cause=e) for c in children: try: if DEBUG: sys.stdout.write( str("Joining on thread " + c.name + "\n")) c.join() except Exception as e: Log.warning("Problem joining thread {{thread}}", thread=c.name, cause=e) finally: if DEBUG: sys.stdout.write( str("Joined on thread " + c.name + "\n")) self.stopped.go() DEBUG and Log.note("thread {{name|quote}} stopping", name=self.name) del self.target, self.args, self.kwargs with ALL_LOCK: del ALL[self.id] except Exception as e: DEBUG and Log.warning("problem with thread {{name|quote}}", cause=e, name=self.name) finally: DEBUG and Log.note("thread {{name|quote}} is done", name=self.name) self.stopped.go()
def __init__(self, thread=None): if thread is None: thread = BaseThread(get_ident()) self.thread = thread
def __init__(self): BaseThread.__init__(self, get_ident()) self.name = "Main Thread" self.please_stop = Signal() self.stop_logging = Log.stop self.timers = None
_wait_for_interrupt(please_stop) break # if DEBUG: # Log.note("read line {{line|quote}}, count={{count}}", line=line, count=cr_count) if line == "": cr_count += 1 else: cr_count = -1000000 # NOT /dev/null if line.strip() == "exit": Log.alert("'exit' Detected! Stopping...") return def _wait_for_interrupt(please_stop): DEBUG and Log.note("inside wait-for-shutdown loop") while not please_stop: try: sleep(1) except Exception: pass MAIN_THREAD = MainThread() ALL_LOCK = allocate_lock() ALL = dict() ALL[get_ident()] = MAIN_THREAD
def _run(self): self.id = get_ident() with RegisterThread(self): try: if self.target is not None: a, k, self.args, self.kwargs = self.args, self.kwargs, None, None self.end_of_thread.response = self.target(*a, **k) except Exception as e: e = Except.wrap(e) self.end_of_thread.exception = e with self.parent.child_locker: emit_problem = self not in self.parent.children if emit_problem: # THREAD FAILURES ARE A PROBLEM ONLY IF NO ONE WILL BE JOINING WITH IT try: Log.error( "Problem in thread {{name|quote}}", name=self.name, cause=e ) except Exception: sys.stderr.write( str("ERROR in thread: " + self.name + " " + text(e) + "\n") ) finally: try: with self.child_locker: children = copy(self.children) for c in children: try: DEBUG and Log.note("Stopping thread " + c.name + "\n") c.stop() except Exception as e: Log.warning( "Problem stopping thread {{thread}}", thread=c.name, cause=e, ) for c in children: try: DEBUG and Log.note("Joining on thread " + c.name + "\n") c.join() except Exception as e: Log.warning( "Problem joining thread {{thread}}", thread=c.name, cause=e, ) finally: DEBUG and Log.note("Joined on thread " + c.name + "\n") del self.target, self.args, self.kwargs DEBUG and Log.note("thread {{name|quote}} stopping", name=self.name) except Exception as e: DEBUG and Log.warning( "problem with thread {{name|quote}}", cause=e, name=self.name ) finally: if not self.ready_to_stop: DEBUG and Log.note("thread {{name|quote}} is done, wait for join", name=self.name) # WHERE DO WE PUT THE THREAD RESULT? # IF NO THREAD JOINS WITH THIS, THEN WHAT DO WE DO WITH THE RESULT? # HOW LONG DO WE WAIT FOR ANOTHER TO ACCEPT THE RESULT? # # WAIT 60seconds, THEN SEND RESULT TO LOGGER (Till(seconds=60) | self.ready_to_stop).wait() self.stopped.go() if not self.ready_to_stop: if self.end_of_thread.exception: # THREAD FAILURES ARE A PROBLEM ONLY IF NO ONE WILL BE JOINING WITH IT try: Log.error( "Problem in thread {{name|quote}}", name=self.name, cause=e ) except Exception: sys.stderr.write( str("ERROR in thread: " + self.name + " " + text(e) + "\n") ) elif self.end_of_thread.response != None: Log.warning( "Thread {{thread}} returned a response, but was not joined with {{parent}} after 10min", thread=self.name, parent=self.parent.name ) else: # IF THREAD ENDS OK, AND NOTHING RETURNED, THEN FORGET ABOUT IT self.parent.remove_child(self)
def __init__(self, thread=None, name=None): if thread is None: thread = BaseThread(get_ident(), name) self.thread = thread
def _run(self): with CProfiler(): self.id = get_ident() with ALL_LOCK: ALL[self.id] = self try: if self.target is not None: a, k, self.args, self.kwargs = self.args, self.kwargs, None, None response = self.target(*a, **k) with self.synch_lock: self.end_of_thread = Data(response=response) else: with self.synch_lock: self.end_of_thread = Null except Exception as e: e = Except.wrap(e) with self.synch_lock: self.end_of_thread = Data(exception=e) if self not in self.parent.children: # THREAD FAILURES ARE A PROBLEM ONLY IF NO ONE WILL BE JOINING WITH IT try: Log.fatal("Problem in thread {{name|quote}}", name=self.name, cause=e) except Exception: sys.stderr.write(b"ERROR in thread: " + str(self.name) + b" " + str(e) + b"\n") finally: try: children = copy(self.children) for c in children: try: if DEBUG: sys.stdout.write(b"Stopping thread " + str(c.name) + b"\n") c.stop() except Exception as e: Log.warning("Problem stopping thread {{thread}}", thread=c.name, cause=e) for c in children: try: if DEBUG: sys.stdout.write(b"Joining on thread " + str(c.name) + b"\n") c.join() except Exception as e: Log.warning("Problem joining thread {{thread}}", thread=c.name, cause=e) finally: if DEBUG: sys.stdout.write(b"Joined on thread " + str(c.name) + b"\n") self.stopped.go() if DEBUG: Log.note("thread {{name|quote}} stopping", name=self.name) del self.target, self.args, self.kwargs with ALL_LOCK: del ALL[self.id] except Exception as e: if DEBUG: Log.warning("problem with thread {{name|quote}}", cause=e, name=self.name) finally: self.stopped.go() if DEBUG: Log.note("thread {{name|quote}} is done", name=self.name)