paulfp / three-factor-security-door Goto Github PK

    try:
        self._set_ident()
        self.__started.set()
        with _active_limbo_lock:
            _active[self.__ident] = self
            del _limbo[self]
        if __debug__:
            self._note("%s.__bootstrap(): thread started", self)

        if _trace_hook:
            self._note("%s.__bootstrap(): registering trace hook", self)
            _sys.settrace(_trace_hook)
        if _profile_hook:
            self._note("%s.__bootstrap(): registering profile hook", self)
            _sys.setprofile(_profile_hook)

        except SystemExit:
            if __debug__:
                self._note("%s.__bootstrap(): raised SystemExit", self)
        except:
            if __debug__:
                self._note("%s.__bootstrap(): unhandled exception", self)
            # If sys.stderr is no more (most likely from interpreter
            # shutdown) use self.__stderr.  Otherwise still use sys (as in
            # _sys) in case sys.stderr was redefined since the creation of
            # self.
            if _sys and _sys.stderr is not None:
                print>>_sys.stderr, ("Exception in thread %s:\n%s" %
                                     (self.name, _format_exc()))
            elif self.__stderr is not None:
                # Do the best job possible w/o a huge amt. of code to
                # approximate a traceback (code ideas from
                # Lib/traceback.py)
                exc_type, exc_value, exc_tb = self.__exc_info()
                try:
                    print>>self.__stderr, (
                        "Exception in thread " + self.name +
                        " (most likely raised during interpreter shutdown):")
                    print>>self.__stderr, (
                        "Traceback (most recent call last):")
                    while exc_tb:
                        print>>self.__stderr, (
                            '  File "%s", line %s, in %s' %
                            (exc_tb.tb_frame.f_code.co_filename,
                                exc_tb.tb_lineno,
                                exc_tb.tb_frame.f_code.co_name))
                        exc_tb = exc_tb.tb_next
                    print>>self.__stderr, ("%s: %s" % (exc_type, exc_value))
                # Make sure that exc_tb gets deleted since it is a memory
                # hog; deleting everything else is just for thoroughness
                finally:
                    del exc_type, exc_value, exc_tb
        else:
            if __debug__:
                self._note("%s.__bootstrap(): normal return", self)
        finally:
            # Prevent a race in
            # test_threading.test_no_refcycle_through_target when
            # the exception keeps the target alive past when we
            # assert that it's dead.
            self.__exc_clear()
    finally:
        with _active_limbo_lock:
            self.__stop()
            try:
                # We don't call self.__delete() because it also
                # grabs _active_limbo_lock.
                del _active[_get_ident()]
            except:
                pass

    """Method representing the thread's activity.

    You may override this method in a subclass. The standard run() method
    invokes the callable object passed to the object's constructor as the
    target argument, if any, with sequential and keyword arguments taken
    from the args and kwargs arguments, respectively.

    """
    try:
        if self.__target:

    finally:
        # Avoid a refcycle if the thread is running a function with
        # an argument that has a member that points to the thread.
        del self.__target, self.__args, self.__kwargs