Python threadable.isInIOThread方法代码示例

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def test_ioThreadDoesNotChange(self):
        """
        Using L{IReactorWin32Events.addEvent} does not change which thread is
        reported as the I/O thread.
        """
        results = []
        def check(ignored):
            results.append(isInIOThread())
            reactor.stop()
        reactor = self.buildReactor()
        event = win32event.CreateEvent(None, False, False, None)
        finished = Deferred()
        listener = Listener(finished)
        finished.addCallback(check)
        reactor.addEvent(event, listener, 'occurred')
        reactor.callWhenRunning(win32event.SetEvent, event)
        self.runReactor(reactor)
        self.assertTrue(listener.success)
        self.assertEqual([True], results) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def test_callInThread(self):
        """
        Test callInThread functionality: set a C{threading.Event}, and check
        that it's not in the main thread.
        """
        def cb(ign):
            waiter = threading.Event()
            result = []
            def threadedFunc():
                result.append(threadable.isInIOThread())
                waiter.set()

            reactor.callInThread(threadedFunc)
            waiter.wait(120)
            if not waiter.isSet():
                self.fail("Timed out waiting for event.")
            else:
                self.assertEqual(result, [False])
        return self._waitForThread().addCallback(cb) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def test_callInThread(self):
        """
        Test callInThread functionality: set a C{threading.Event}, and check
        that it's not in the main thread.
        """
        def cb(ign):
            waiter = threading.Event()
            result = []
            def threadedFunc():
                result.append(threadable.isInIOThread())
                waiter.set()

            reactor.callInThread(threadedFunc)
            waiter.wait(120)
            if not waiter.isSet():
                self.fail("Timed out waiting for event.")
            else:
                self.assertEquals(result, [False])
        return self._waitForThread().addCallback(cb) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def setUp(self):
        """
        Reduce the CPython check interval so that thread switches happen much
        more often, hopefully exercising more possible race conditions.  Also,
        delay actual test startup until the reactor has been started.
        """
        if hasattr(sys, 'getcheckinterval'):
            self.addCleanup(sys.setcheckinterval, sys.getcheckinterval())
            sys.setcheckinterval(7)
        # XXX This is a trial hack.  We need to make sure the reactor
        # actually *starts* for isInIOThread() to have a meaningful result.
        # Returning a Deferred here should force that to happen, if it has
        # not happened already.  In the future, this should not be
        # necessary.
        d = defer.Deferred()
        reactor.callLater(0, d.callback, None)
        return d 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def test_isInIOThread(self):
        """
        The reactor registers itself as the I/O thread when it runs so that
        L{twisted.python.threadable.isInIOThread} returns C{True} if it is
        called in the thread the reactor is running in.
        """
        results = []
        reactor = self.buildReactor()
        def check():
            results.append(isInIOThread())
            reactor.stop()
        reactor.callWhenRunning(check)
        self.runReactor(reactor)
        self.assertEqual([True], results) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def test_isNotInIOThread(self):
        """
        The reactor registers itself as the I/O thread when it runs so that
        L{twisted.python.threadable.isInIOThread} returns C{False} if it is
        called in a different thread than the reactor is running in.
        """
        results = []
        reactor = self.buildReactor()
        def check():
            results.append(isInIOThread())
            reactor.callFromThread(reactor.stop)
        reactor.callInThread(check)
        self.runReactor(reactor)
        self.assertEqual([False], results) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def test_isInIOThread(self):
        """
        L{threadable.isInIOThread} returns C{True} if and only if it is called
        in the same thread as L{threadable.registerAsIOThread}.
        """
        threadable.registerAsIOThread()
        foreignResult = []
        t = threading.Thread(
            target=lambda: foreignResult.append(threadable.isInIOThread()))
        t.start()
        t.join()
        self.assertFalse(
            foreignResult[0], "Non-IO thread reported as IO thread")
        self.assertTrue(
            threadable.isInIOThread(), "IO thread reported as not IO thread") 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def __init__(self, crawler, update_vars=None, code=None):
        self.crawler = crawler
        self.update_vars = update_vars or (lambda x: None)
        self.item_class = load_object(crawler.settings['DEFAULT_ITEM_CLASS'])
        self.spider = None
        self.inthread = not threadable.isInIOThread()
        self.code = code
        self.vars = {} 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def testIsInIOThread(self):
        foreignResult = []
        t = threading.Thread(target=lambda: foreignResult.append(threadable.isInIOThread()))
        t.start()
        t.join()
        self.failIf(foreignResult[0], "Non-IO thread reported as IO thread")
        self.failUnless(threadable.isInIOThread(), "IO thread reported as not IO thread") 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def add_pending_connection(self, host, connector=None):
        if debug: print 'adding', host, 'IOthread', threadable.isInIOThread()
        self.halfopen_hosts_lock.acquire()
        self.halfopen_hosts.setdefault(host, []).append(connector)
        self.halfopen_hosts_lock.release()

    # thread footwork, because _remove actually starts new connections 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def remove_pending_connection(self, host, connector=None):
        if not threadable.isInIOThread():
            self.reactor.callFromThread(self._remove_pending_connection,
                                        host, connector)
        else:
            self._remove_pending_connection(host, connector) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def _safestop(self, r=None):
        if not threadable.isInIOThread():
            self.external_add_task(0, self._stop)
        else:
            self._stop() 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def wakeUp(self):
        """Wake up the event loop."""
        if not threadable.isInIOThread():
            if self.waker:
                self.waker.wakeUp()
            # if the waker isn't installed, the reactor isn't running, and
            # therefore doesn't need to be woken up 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def testCallInThread(self):
        waiter = threading.Event()
        result = []
        def threadedFunc():
            result.append(threadable.isInIOThread())
            waiter.set()

        reactor.callInThread(threadedFunc)
        waiter.wait(120)
        if not waiter.isSet():
            self.fail("Timed out waiting for event.")
        else:
            self.assertEquals(result, [False]) 

# 需要导入模块: from twisted.python import threadable [as 别名]
# 或者: from twisted.python.threadable import isInIOThread [as 别名]
def setUp(self):
        # XXX This is a trial hack.  We need to make sure the reactor
        # actually *starts* for isInIOThread() to have a meaningful result.
        # Returning a Deferred here should force that to happen, if it has
        # not happened already.  In the future, this should not be
        # necessary.
        d = defer.Deferred()
        reactor.callLater(0, d.callback, None)
        return d