def install():
"""Install the context tracking reactor."""
# Install logging patches.
originalFormatter = log.textFromEventDict
def newFormatter(*args, **kw):
"""Augmented log formatter that includes context information."""
originalResult = originalFormatter(*args, **kw)
values = AsyncFrame.currentFrame.getLocals()
if values:
originalResult += ' %r' % values
return originalResult
log.textFromEventDict = newFormatter
# Patch threads.deferToThread(Pool)
originalDeferToThreadPool = threads.deferToThreadPool
def deferToThreadPool(*args, **kw):
"""Patches defer to thread pool to install the context when running the callback."""
deferred = originalDeferToThreadPool(*args, **kw)
# pylint: disable=W0212
deferred._startRunCallbacks = wrapped(deferred._startRunCallbacks, 'Thread')
return deferred
threads.deferToThreadPool = deferToThreadPool
# Overwrite the reactor.
del sys.modules['twisted.internet.reactor']
r = FrameTrackingReactor()
from twisted.internet.main import installReactor
installReactor(r)
def install(runLoop=None, runner=None):
"""
Configure the twisted mainloop to be run inside CFRunLoop.
@param runLoop: the run loop to use.
@param runner: the function to call in order to actually invoke the main
loop. This will default to L{CFRunLoopRun} if not specified. However,
this is not an appropriate choice for GUI applications, as you need to
run NSApplicationMain (or something like it). For example, to run the
Twisted mainloop in a PyObjC application, your C{main.py} should look
something like this::
from PyObjCTools import AppHelper
from twisted.internet.cfreactor import install
install(runner=AppHelper.runEventLoop)
# initialize your application
reactor.run()
@return: The installed reactor.
@rtype: L{CFReactor}
"""
reactor = CFReactor(runLoop=runLoop, runner=runner)
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install():
"""Configure the twisted mainloop to be run using the select() reactor.
"""
reactor = ThreadedSelectReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install():
"""
Configure the twisted mainloop to be run inside the qt mainloop.
"""
from twisted.internet import main
reactor = QTReactor()
main.installReactor(reactor)
def install():
"""
Install the kqueue() reactor.
"""
p = KQueueReactor()
from twisted.internet.main import installReactor
installReactor(p)
def install():
"""
Install the Qt reactor.
"""
p = QtReactor()
from twisted.internet.main import installReactor
installReactor(p)
def install():
"""
Install the epoll() reactor.
"""
p = EPollReactor()
from twisted.internet.main import installReactor
installReactor(p)
def install(app=None): """ Configure the twisted mainloop to be run inside the e2 mainloop. """ from twisted.internet import main reactor = e2reactor() main.installReactor(reactor)
def __init__(self, evManager): self.state = ReactorSpinController.STATE_STOPPED self.evManager = evManager self.evManager.RegisterListener( self ) self.reactor = SelectReactor() installReactor(self.reactor) self.loopingCall = LoopingCall(self.FireTick)
def install():
"""Configure the twisted mainloop to be run inside the wxPython mainloop.
"""
reactor = WxReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def portableInstall():
"""Configure the twisted mainloop to be run inside the gtk mainloop.
"""
reactor = PortableGtkReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def win32install():
"""
Install the Qt reactor.
"""
p = QtEventReactor()
from twisted.internet.main import installReactor
installReactor(p)
return p
def install(io_loop=None):
"""Install this package as the default Twisted reactor."""
if not io_loop:
io_loop = IOLoop.instance()
reactor = TornadoReactor(io_loop)
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def win32install():
"""
Install the Qt reactor.
"""
p = pyqt4eventreactor()
from twisted.internet.main import installReactor
installReactor(p)
def install():
"""
Setup Twisted+Pyglet integration based on the Pyglet event loop.
"""
reactor = PygletReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def posixinstall():
"""
Install the Qt reactor.
"""
p = pyqt4reactor()
from twisted.internet.main import installReactor
installReactor(p)
def posixinstall():
"""
Install the Qt reactor.
"""
from twisted.internet.main import installReactor
p = QtReactor()
installReactor(p)
def install(io_loop=None):
"""Install this package as the default Twisted reactor."""
if not io_loop:
io_loop = webalchemy.tornado.ioloop.IOLoop.current()
reactor = TornadoReactor(io_loop)
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install():
"""
Configure the twisted mainloop to be run inside the npyscreen mainloop.
"""
reactor = NpyscreenReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install(runLoop=None):
"""Configure the twisted mainloop to be run inside CFRunLoop.
"""
reactor = CFReactor(runLoop=runLoop)
reactor.addSystemEventTrigger('after', 'shutdown', reactor.cleanup)
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def __init__(self):
self.keepGoing = True
self.reactor = SelectReactor()
installReactor(self.reactor)
connection = self.reactor.connectTCP('localhost', 8000, factory)
self.reactor.startRunning()
self.futureCall = None
self.futureCallTimeout = None
pygame_test.prepare()
def install(app=None):
"""Configure the twisted mainloop to be run inside the qt mainloop.
"""
reactor = QTReactor(app=app)
reactor.addSystemEventTrigger('after', 'shutdown', reactor.cleanup )
reactor.simulate()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def test_installReactor(self):
"""
L{installReactor} installs a new reactor if none is present.
"""
with NoReactor():
newReactor = object()
installReactor(newReactor)
from twisted.internet import reactor
self.assertIdentical(newReactor, reactor)
def test_alreadyInstalled(self):
"""
If a reactor is already installed, L{installReactor} raises
L{ReactorAlreadyInstalledError}.
"""
with NoReactor():
installReactor(object())
self.assertRaises(ReactorAlreadyInstalledError, installReactor,
object())
def install(eventloop=None):
"""
Install a tulip-based reactor.
"""
if eventloop is None:
eventloop = get_event_loop()
reactor = AsyncioSelectorReactor(eventloop)
from twisted.internet.main import installReactor
installReactor(reactor)
def install(useGtk=True):
"""Configure the twisted mainloop to be run inside the gtk mainloop.
@param useGtk: should glib rather than GTK+ event loop be
used (this will be slightly faster but does not support GUI).
"""
reactor = Gtk2Reactor(useGtk)
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install():
"""
Configure the twisted mainloop to be run using the kaa reactor.
"""
reactor = KaaReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
reactor.connect()
return reactor
def install(eventloop=None):
"""
Install an asyncio-based reactor.
@param eventloop: The asyncio eventloop to wrap. If default, the global one
is selected.
"""
reactor = AsyncioSelectorReactor(eventloop)
from twisted.internet.main import installReactor
installReactor(reactor)
def install(io_loop=None):
"""
Install the Tornado reactor.
"""
if not io_loop:
io_loop = tornado.ioloop.IOLoop.instance()
reactor = TornadoReactor(io_loop)
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install():
k = KQueueReactor()
main.installReactor(k)
def removeAll(self):
return get_event_loop().remove_all()
#######################################################################
# Functions not needed by pulsar
_registerAsIOThread = False
def installWaker(self):
pass
def mainLoop(self):
pass
def doIteration(self, delay):
pass
def spawnProcess(self, *args, **kwargs):
raise NotImplementedError('Cannot spawn process from Pulsar reactor')
def _initThreads(self):
pass
def _handleSignals(self):
pass
if installReactor: # pragma nocover
_reactor = PulsarReactor()
installReactor(_reactor)
_reactor.run()
def install(klass):
""" Install custom reactor """
if sys.modules.has_key('twisted.internet.reactor'):
del sys.modules['twisted.internet.reactor']
Hellanzb.reactor = HellaReactor()
installReactor(Hellanzb.reactor)
import scrapy
from scrapy.crawler import CrawlerProcess
from twisted.internet.main import installReactor
from twisted.internet.selectreactor import SelectReactor
class SelectReactorSubclass(SelectReactor):
pass
reactor = SelectReactorSubclass()
installReactor(reactor)
class NoRequestsSpider(scrapy.Spider):
name = 'no_request'
def start_requests(self):
return []
process = CrawlerProcess(
settings={
"TWISTED_REACTOR": "twisted.internet.selectreactor.SelectReactor",
})
process.crawl(NoRequestsSpider)
process.start()
def setup_reactor(self):
self.reactor = pollreactor.PollReactor()
installReactor(self.reactor)
def install():
"""Configure the twisted mainloop to be run using geventreactor."""
reactor = GeventReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
# "AGPLv3". If not, see <http://www.gnu.org/licenses/>.
#
import sys, os
SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
sys.path.insert(0, SCRIPT_DIR)
sys.path.insert(0, "..")
from twisted.trial import unittest, runner, reporter
from twisted.internet import selectreactor, main
class MyReactor(selectreactor.SelectReactor):
def runUntilCurrent(self):
self._cancellations = 20000000
selectreactor.SelectReactor.runUntilCurrent(self)
main.installReactor(MyReactor())
from twisted.internet import defer, reactor
from twisted.application import internet
from twisted.python import failure
from twisted.python.runtime import seconds
import twisted.internet.base
twisted.internet.base.DelayedCall.debug = True
from twisted.web import client, http
from tests import testmessages
verbose = int(os.environ.get('VERBOSE_T', '-1'))
if verbose < 0: testmessages.silence_all_messages()
from tests import testclock
def install():
from twisted.internet.main import installReactor
reactor = Qt4Reactor()
installReactor(reactor)
return reactor
def install_pausing_reactor():
class PausingReactor(SelectReactor):
"""A SelectReactor that can be paused and resumed."""
def __init__(self):
SelectReactor.__init__(self)
self.paused = False
self._return_value = None
self._release_requested = False
self._mainLoopGen = None
# Older versions of twisted do not have the _started attribute, make it a synonym for running in that case
if not hasattr(self, '_started'):
PausingReactor._started = property(lambda self: self.running)
def _mainLoopGenerator(self):
"""Generator that acts as mainLoop, but yields when requested."""
while self._started:
try:
while self._started:
if self._release_requested:
self._release_requested = False
self.paused = True
yield self._return_value
self.paused = False
self.iterate()
except KeyboardInterrupt:
# Keyboard interrupt pauses the reactor
self.pause()
except GeneratorExit:
# GeneratorExit means stop the generator; Do it cleanly by stopping the whole reactor.
log.debug('Got GeneratorExit, stopping reactor.',
exc_info=True)
self.paused = False
self.stop()
except:
twisted_log.msg("Unexpected error in main loop.")
twisted_log.err()
else:
twisted_log.msg('Main loop terminated.')
def run(self, installSignalHandlers=False):
"""Starts or resumes the reactor."""
if not self._started:
self.startRunning(installSignalHandlers)
self._mainLoopGen = self._mainLoopGenerator()
try:
return next(self._mainLoopGen)
except StopIteration:
pass
def pause(self, return_value=None):
"""Causes reactor to pause after this iteration.
If :return_value: is specified, it will be returned by the reactor.run call."""
self._return_value = return_value
self._release_requested = True
def stop(self):
"""Stops the reactor."""
SelectReactor.stop(self)
# If this was called while the reactor was paused we have to resume in order for it to complete
if self.paused:
self.run()
# These need to be re-registered so that the PausingReactor can be safely restarted after a stop
self.addSystemEventTrigger('during', 'shutdown', self.crash)
self.addSystemEventTrigger('during', 'shutdown',
self.disconnectAll)
# Configure twisted to use the PausingReactor.
installReactor(PausingReactor())
@event('manager.shutdown')
def stop_reactor(manager):
"""Shut down the twisted reactor after all tasks have run."""
if not reactor._stopped:
log.debug('Stopping twisted reactor.')
reactor.stop()
def install():
"""Configure the twisted mainloop to be run using the select() reactor."""
reactor = SelectReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
def install():
"""Install the poll() reactor."""
p = PollReactor()
from twisted.internet.main import installReactor
installReactor(p)
def install():
"""Install the Syncless reactor."""
# As a side effect, this calls `from syncless import coio', which
# creates and starts the coio.main_loop_tasklet, which calls
# event_loop() indefinitely.
installReactor(SynclessReactor())
def install():
"""Use the VIFF reactor."""
reactor = ViffReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
def posixinstall():
"""Install the Qt reactor."""
from twisted.internet.main import installReactor
p = QtReactor()
installReactor(p)
def win32install():
"""Install the Qt reactor."""
from twisted.internet.main import installReactor
p = QtEventReactor()
installReactor(p)
self._return_value = return_value
self._release_requested = True
def stop(self):
"""Stops the reactor."""
SelectReactor.stop(self)
# If this was called while the reactor was paused we have to resume in order for it to complete
if self.paused:
self.run()
# These need to be re-registered so that the PausingReactor can be safely restarted after a stop
self.addSystemEventTrigger('during', 'shutdown', self.crash)
self.addSystemEventTrigger('during', 'shutdown', self.disconnectAll)
# Configure twisted to use the PausingReactor.
installReactor(PausingReactor())
except ImportError:
# If twisted is not found, errors will be shown later
pass
# Define a base class with some methods that are used for all deluge versions
class DelugePlugin(object):
"""Base class for deluge plugins, contains settings and methods for connecting to a deluge daemon."""
def prepare_connection_info(self, config):
config.setdefault('host', 'localhost')
config.setdefault('port', 58846)
if 'user' in config or 'pass' in config:
warnings.warn('deluge `user` and `pass` options have been renamed `username` and `password`',
def install():
"""Install the poll() reactor."""
p = PollReactor()
main.installReactor(p)
def install():
threadable.init(1)
r = Win32Reactor()
import main
main.installReactor(r)
def install():
from twisted.python import threadable
p = Proactor()
threadable.init()
main.installReactor(p)
def install():
r = IOCPReactor()
main.installReactor(r)
def install():
reactor = PygletReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
def install():
"""
Configure the twisted mainloop to be run inside the glib mainloop.
"""
reactor = Glib2Reactor()
from twisted.internet.main import installReactor
installReactor(reactor)
