HEX

File: //usr/lib/python3/dist-packages/twisted/python/__pycache__/threadpool.cpython-38.pyc
U

�b�'�@sxdZddlmZmZddlmZddlmZddl	m
Z
mZddlm
Z
ddlmZddlmZe�ZGd	d
�d
�ZdS)z�
twisted.python.threadpool: a pool of threads to which we dispatch tasks.

In most cases you can just use C{reactor.callInThread} and friends
instead of creating a thread pool directly.
�)�Thread�current_thread)�List)�pool)�context�log)�
deprecated)�Failure)�Versionc@s�eZdZdZdZdZdZdZdZe	Z
eee
dddd	�d
d�e��Zee�Zd,dd
�Zedd��Zedd��Zedd��Zedd��ZeZdd�Zdd�Zdd�Zdd�Zdd�Zd d!�Zd"d#�Zd$d%�Zd&d'�Z d-d(d)�Z!d*d+�Z"dS).�
ThreadPoola�
    This class (hopefully) generalizes the functionality of a pool of threads
    to which work can be dispatched.

    L{callInThread} and L{stop} should only be called from a single thread.

    @ivar started: Whether or not the thread pool is currently running.
    @type started: L{bool}

    @ivar threads: List of workers currently running in this thread pool.
    @type threads: L{list}

    @ivar _pool: A hook for testing.
    @type _pool: callable compatible with L{_pool}
    ��FN�Twisted��rzthreading.current_thread)�version�replacementcsb|dkstd��||ks td��|�_|�_|�_g�_�fdd�}�fdd�}��||��_dS)	ac
        Create a new threadpool.

        @param minthreads: minimum number of threads in the pool
        @type minthreads: L{int}

        @param maxthreads: maximum number of threads in the pool
        @type maxthreads: L{int}

        @param name: The name to give this threadpool; visible in log messages.
        @type name: native L{str}
        r�minimum is negative�minimum is greater than maximumcs(�j|d���i|��}�j�|�|S)N�name)�
threadFactory�
_generateName�threads�append)�a�kw�thread��self��;/usr/lib/python3/dist-packages/twisted/python/threadpool.py�trackingThreadFactoryLs���z2ThreadPool.__init__.<locals>.trackingThreadFactorycs�js
dS�jS)Nr)�started�maxrrrr �currentLimitSsz)ThreadPool.__init__.<locals>.currentLimitN)�AssertionError�minr#rr�_pool�_team)r�
minthreads�
maxthreadsrr!r$rrr �__init__8s
zThreadPool.__init__cCs|j��}|j|jS)a
        For legacy compatibility purposes, return a total number of workers.

        @return: the current number of workers, both idle and busy (but not
            those that have been quit by L{ThreadPool.adjustPoolsize})
        @rtype: L{int}
        )r(�
statistics�idleWorkerCount�busyWorkerCount)r�statsrrr �workersZs	
zThreadPool.workerscCsdg|j��jS)z�
        For legacy compatibility purposes, return the number of busy workers as
        expressed by a list the length of that number.

        @return: the number of workers currently processing a work item.
        @rtype: L{list} of L{None}
        N)r(r,r.rrrr �workingfs	zThreadPool.workingcCsdg|j��jS)a,
        For legacy compatibility purposes, return the number of idle workers as
        expressed by a list the length of that number.

        @return: the number of workers currently alive (with an allocated
            thread) but waiting for new work.
        @rtype: L{list} of L{None}
        N)r(r,r-rrrr �waitersqs
zThreadPool.waiterscsG�fdd�d�}|�S)z�
        For legacy compatibility purposes, return an object with a C{qsize}
        method that indicates the amount of work not yet allocated to a worker.

        @return: an object with a C{qsize} method.
        cseZdZ�fdd�ZdS)z$ThreadPool._queue.<locals>.NotAQueuecs�j��jS)a
                Pretend to be a Python threading Queue and return the
                number of as-yet-unconsumed tasks.

                @return: the amount of backlogged work not yet dispatched to a
                    worker.
                @rtype: L{int}
                )r(r,�backloggedWorkCount)�qrrr �qsize�s	z*ThreadPool._queue.<locals>.NotAQueue.qsizeN)�__name__�
__module__�__qualname__r5rrrr �	NotAQueue�sr9r)rr9rrr �_queue}s	zThreadPool._queuecCs4d|_d|_|��|j��j}|r0|j�|�dS)z'
        Start the threadpool.
        FTN)�joinedr"�adjustPoolsizer(r,r3�grow)r�backlogrrr �start�szThreadPool.startcCs|j�d�dS)z�
        Increase the number of available workers for the thread pool by 1, up
        to the maximum allowed by L{ThreadPool.max}.
        rN)r(r=rrrr �startAWorker�szThreadPool.startAWorkercCsd|jpt|��d|j��S)z�
        Generate a name for a new pool thread.

        @return: A distinctive name for the thread.
        @rtype: native L{str}
        zPoolThread-�-)r�idr0rrrr r�szThreadPool._generateNamecCs|j�d�dS)zn
        Decrease the number of available workers by 1, by quitting one as soon
        as it's idle.
        rN)r(�shrinkrrrr �stopAWorker�szThreadPool.stopAWorkercCs"t|d|�t�||j|j�dS)N�__dict__)�setattrrr+r&r#�r�staterrr �__setstate__�szThreadPool.__setstate__cCsi}|j|d<|j|d<|S)Nr&r#)r&r#rGrrr �__getstate__�s

zThreadPool.__getstate__cOs|jd|f|�|�dS)a
        Call a callable object in a separate thread.

        @param func: callable object to be called in separate thread

        @param args: positional arguments to be passed to C{func}

        @param kw: keyword args to be passed to C{func}
        N)�callInThreadWithCallback)r�func�argsrrrr �callInThread�s
zThreadPool.callInThreadcsP|jr
dStj��jd��fdd������fdd��_|�_|j���dS)a$
        Call a callable object in a separate thread and call C{onResult} with
        the return value, or a L{twisted.python.failure.Failure} if the
        callable raises an exception.

        The callable is allowed to block, but the C{onResult} function must not
        block and should perform as little work as possible.

        A typical action for C{onResult} for a threadpool used with a Twisted
        reactor would be to schedule a L{twisted.internet.defer.Deferred} to
        fire in the main reactor thread using C{.callFromThread}.  Note that
        C{onResult} is called inside the separate thread, not inside the
        reactor thread.

        @param onResult: a callable with the signature C{(success, result)}.
            If the callable returns normally, C{onResult} is called with
            C{(True, result)} where C{result} is the return value of the
            callable.  If the callable throws an exception, C{onResult} is
            called with C{(False, failure)}.

            Optionally, C{onResult} may be L{None}, in which case it is not
            called at all.

        @param func: callable object to be called in separate thread

        @param args: positional arguments to be passed to C{func}

        @param kw: keyword arguments to be passed to C{func}
        N���csfz���}d}Wntk
r.t�}d}YnXd�_�jdk	rT��||�d�_n|sbt�|�dS)NTF)�theWork�
BaseExceptionr	�onResultr�err)�result�ok)�	inContextrr rV�s

z6ThreadPool.callInThreadWithCallback.<locals>.inContextcstj��f����S)N)r�callr)rM�ctxrLrrr �<lambda>s���z5ThreadPool.callInThreadWithCallback.<locals>.<lambda>)	r;r�theContextTracker�currentContext�contextsrPrRr(Zdo)rrRrLrMrr)rMrXrLrVrr rK�sz#ThreadPool.callInThreadWithCallbackcCs.d|_d|_|j��|jD]}|��qdS)z9
        Shutdown the threads in the threadpool.
        TFN)r;r"r(�quitr�join)rrrrr �stops


zThreadPool.stopcCs�|dkr|j}|dkr|j}|dks,td��||ks<td��||_||_|jsRdS|j|jkrr|j�|j|j�|j|jkr�|j�|j|j�dS)z�
        Adjust the number of available threads by setting C{min} and C{max} to
        new values.

        @param minthreads: The new value for L{ThreadPool.min}.

        @param maxthreads: The new value for L{ThreadPool.max}.
        Nrrr)r&r#r%r"r0r(rCr=)rr)r*rrr r<s	zThreadPool.adjustPoolsizecCs:t�d|j���t�d|j���t�d|j���dS)zw
        Dump some plain-text informational messages to the log about the state
        of this L{ThreadPool}.
        z	waiters: z	workers: ztotal: N)r�msgr2r1rrrrr �	dumpStats2szThreadPool.dumpStats)rr
N)NN)#r6r7r8�__doc__r&r#r;r"rrr�staticmethodrr
r�
currentThreadr'r+�propertyr0r1r2r:r4r?r@rrDrIrJrNrKr_r<rarrrr rsJ���
"




	;

rN)rb�	threadingrr�typingrZtwisted._threadsrr'�twisted.pythonrrZtwisted.python.deprecater�twisted.python.failurer	Ztwisted.python.versionsr
�objectZ
WorkerStoprrrrr �<module>s