Exemplo n.º 1
0
 def _is_owner(self):
     is_owner = self._owner == _current_thread().name
     #         if is_owner:
     #             self._debug("{0} is the owner", _current_thread().name)
     #         else:
     #             self._debug("{1} is NOT the owner", _current_thread().name)
     return is_owner
Exemplo n.º 2
0
 def _do_lock(self, timeout=None):
     if self._has_owner():
         raise RuntimeError("Try to lock when not yet released")
     self._owner = _current_thread().name
     self._when = _datetime.now()
     self.expiration_time = timeout
     self._info("{0} has take the lock (expiration time {1})", self.owner,
                self.expiration_time)
Exemplo n.º 3
0
def _process_async_queue():
    t = _current_thread()
    t.alive = True
    while t.alive:
        function, args, kwargs = _task_queue.get()
        if function:
            function(*args, **kwargs)
    if _log.isEnabledFor(_DEBUG):
        _log.debug("stopped")
Exemplo n.º 4
0
 def access(self):
     """
         Request if the give thread is allowed to access the resource.
     """
     # self._debug("%s access()" % _current_thread().name)
     if not self.isLock():
         self._debug("There is no owner of the lock, {0} can pass",
                     _current_thread().name)
         return True
     elif self._isOwner():
         self._when = _datetime.now()
         self._debug(
             "The owner is who is asking ({0}), "
             "renew its booking",
             _current_thread().name)
         return True
     else:
         return False
Exemplo n.º 5
0
 def __popRequester(self):
     found, pos = self.__searchRequester()
     if found or pos is not None:
         self.__pauseRequesterStack.pop(pos)
         processName = _current_process().name
         threadName = _current_thread().name
         self.debug("Removed '%d'th requester" % (pos))
         return True
     self.debug("pop unsatisfied")
     return False
Exemplo n.º 6
0
 def __procedure(self):
     """Function of the fork process"""
     _current_process().name = "Process%d" % (self.__id)
     _current_thread().name = "Worker%d" % (self.__id)
     self.debug("Fork build")
     while not self.__events.waitStart(self.checkPeriod):
         self.debug("Waiting start...")
     try:
         self.info("Fork starts %s after the event trigger"
                   % (_datetime.now()-self.__events.whenStarted()))
     except Exception as e:
         self.warning("Start event received but not propagated when "
                      "it was triggered")
     while not self._endProcedure():
         try:
             if self.__events.isPaused():
                 self.info("paused")
                 if self._procedureHas2End():
                     break
                 while not self.__events.waitResume(self.checkPeriod):
                     pass
                 self.info("resume")
             else:
                 self.__currentArgin = self.__input.get()
                 self.debug("argin: %s" % (self.__currentArgin))
                 if self.__preHook is not None:
                     self.debug("call preHook")
                     self.__preHook(self.__currentArgin,
                                    **self.__preExtraArgs)
                 if self._procedureHas2End():
                     break
                 t_0 = _datetime.now()
                 self.__currentArgout = self.__target(self.__currentArgin)
                 t_diff = _datetime.now()-t_0
                 t_diff = t_diff.total_seconds()
                 self.__computationTime.value += t_diff
                 self.debug("argout: %s (%f seconds)"
                            % (self.__currentArgout, t_diff))
                 self.__ctr.value += 1
                 self.__output.put([self.__currentArgin,
                                    self.__currentArgout])
                 if self.__postHook is not None:
                     self.debug("call postHook")
                     self.__postHook(self.__currentArgin,
                                     self.__currentArgout,
                                     **self.__postExtraArgs)
                 self.__events.step()
         except Exception as e:
             self.error("exception: %s" % (e))
             _print_exc()
     # process has finish, lets wake up the monitor
     self.__internalEvent.set()
     self.debug("Internal event emitted to report end of the procedure")
Exemplo n.º 7
0
 def release(self):
     """
         Only the owner can release the lock.
     """
     # self._debug("%s release()" % _current_thread().name)
     if self._isOwner():
         self._debug("{0} releases the lock", self._owner)
         self._doRelease()
         return True
     else:
         self._error("{0} is NOT allowed to release {1}'s lock",
                     _current_thread().name, self._owner)
         return False
Exemplo n.º 8
0
 def request(self, timeout=None):
     """
         Request to book the access. If its free (or has expired a previous
         one) do it, else reject (even if the owner recalls it).
     """
     # self._debug("%s request()" % _current_thread().name)
     if not self._has_owner() or self._has_expired():
         self._doLock(timeout)
         return True
     else:
         self._warning("{0} request the lock when already is",
                       _current_thread().name)
         return False
Exemplo n.º 9
0
 def __thread(self):
     """Monitor thread function."""
     _current_thread().name = "Monitor%d" % (self.__id)
     self.__prepared.set()
     self.info("Creating the fork")
     self.__worker = _Process(target=self.__procedure)
     while not self.__events.waitStart(self.__checkPeriod):
         self.debug("Waiting to start")
         # FIXME: msg to be removed, together with the timeout
     self.info("Starting the fork")
     self.__worker.start()
     self.__processMonitoring()
     self.info("Monitor has finished its task")
Exemplo n.º 10
0
    def __new__(cls, callback=None):
        """Create a weak reference to the current thread.

        Arguments:
            callback (optional): Function (or other callable)
                to call once the current thread stops running.
        """
        try:
            anchor = _threadlocal.anchor
        except AttributeError:
            anchor = _threadlocal.anchor = _Object()
            anchor._thread = _current_thread()
        return super().__new__(cls, anchor, callback)
Exemplo n.º 11
0
def print_info(msg, level=0, lock=None, top=False, bottom=False):
    if lock is None:
        print("{}{}".format("\t" * level, msg))
    else:
        with lock:
            tab = "\t" * level
            msg = "Thread {}: {}".format(_current_thread().name, msg)
            if top or bottom:
                if top:
                    msg = "{}{}\n{}{}".format(tab, "-" * len(msg), tab, msg)
                elif bottom:
                    msg = "{}{}}\n{}{}\n".format(tab, msg, tab, "-" * len(msg))
            else:
                msg = "{}{}".format(tab, msg)
            print(msg)
Exemplo n.º 12
0
 def __searchRequester(self):
     nonBookRequest = None
     processName = _current_process().name
     threadName = _current_thread().name
     for i, request in enumerate(self.__pauseRequesterStack):
         if request[0] == processName and request[1] == threadName:
             self.debug("Found (%s, %s) as requester in position %d"
                        % (processName, threadName, i))
             return (True, i)
         elif nonBookRequest is None and request[2] is False:
             nonBookRequest = i
     self.debug("NOT found (%s, %s) as requester"
                % (processName, threadName))
     if nonBookRequest is not None:
         self.debug("But a nonBook request found from (%s, %s)"
                    % (self.__pauseRequesterStack[nonBookRequest][0],
                       self.__pauseRequesterStack[nonBookRequest][1]))
     return (False, nonBookRequest)
    def __init__(*args, **kwargs):
        """Initialize the finalizer.

        Arguments:
            function: Function (or other callable) to call
                once the current thread stops running.
            *args: Positional arguments for the function.
            **kwargs: Keyword arguments for the function.
        """
        def __init__(self, function, *args):
            return self, function, args
        self, function, args = __init__(*args)
        try:
            anchor = _threadlocal.anchor
        except AttributeError:
            anchor = _threadlocal.anchor = _Object()
            anchor._thread = _current_thread()
        super(finalize, self).__init__(anchor, function, *args, **kwargs)
Exemplo n.º 14
0
 def __poolMonitorThread(self):
     _current_thread().name = "PoolMonitor"
     while not self.__events.waitStart(self.checkPeriod):
         self.debug("Collector prepared, but processing not started")
         # FIXME: msg to be removed, together with the timeout
     while not self.__events.isStopped():
         if self.__events.waitStep(self.checkPeriod):
             self.__events.stepClean()
             self.debug("STEP event received")
             self.__collectOutputs()
         else:
             self.debug("Periodic check")
         self.__reviewWorkers()
         self.__loadAverage.review()
         self.__memoryPercent.review()
     while self.activeWorkers > 0:
         self.debug("Waiting workers to finish")
         self.__reviewWorkers()
         if self.activeWorkers > 0:
             _sleep(self.checkPeriod)
     self.debug("Pool complete, exiting")
Exemplo n.º 15
0
class finalize(_finalize):
    """Finalizer for the current thread.

    Unlike normal finalizers, this detects when the current thread
    stops running, not when a given object is stops being alive.
    """

    __slots__ = ()

    def __init__(self, function, /, *args, **kwargs):
        """Initialize the finalizer.

        Arguments:
            function: Function (or other callable) to call
                once the current thread stops running.
            *args: Positional arguments for the function.
            **kwargs: Keyword arguments for the function.
        """
        try:
            anchor = _threadlocal.anchor
        except AttributeError:
            anchor = _threadlocal.anchor = _Object()
            anchor._thread = _current_thread()
        super().__init__(anchor, function, *args, **kwargs)
Exemplo n.º 16
0
 def __storeRequester(self, book):
     processName = _current_process().name
     threadName = _current_thread().name
     self.__pauseRequesterStack.append([processName, threadName, book])
     self.debug("Stored (%s, %s) as a requester (book=%s)"
                % (processName, threadName, book))
Exemplo n.º 17
0
    def interrupt(self):
        self._stream.close()

        # Wait only a second for thread to terminate.
        if self.isAlive() and self != _current_thread():
            self.join(1.0)
Exemplo n.º 18
0
 def _threadId(self):
     return _current_thread().getName()