def __init__(self, app=None): self._reads = {} self._writes = {} if app is None: app = QApplication([]) self.qApp = app PosixReactorBase.__init__(self) self.addSystemEventTrigger('after', 'shutdown', self.cleanup)
def __init__(self, runLoop=None, runner=None): self._fdmap = {} self._idmap = {} if runner is None: runner = CFRunLoopRun self._runner = runner if runLoop is None: runLoop = CFRunLoopGetMain() self._cfrunloop = runLoop PosixReactorBase.__init__(self)
def __init__(self, ioloop=None): if not ioloop: ioloop = tornado.ioloop.IOLoop.instance() self._ioloop = ioloop self._readers = {} self._writers = {} self._fds = {} # a map of fd to a (reader, writer) tuple self._delayedCalls = {} self._running = False self._closed = False PosixReactorBase.__init__(self)
def __init__(self, io_loop=None): if not io_loop: io_loop = tornado.ioloop.IOLoop.instance() self._io_loop = io_loop self._readers = {} self._writers = {} self._fds = {} # a map of fd to a (reader, writer) tuple self._delayedCalls = {} self._running = False self._closed = False PosixReactorBase.__init__(self)
def __init__(self): """Initialize reactor and local fd storage.""" # These inits really ought to be before # L{PosixReactorBase.__init__} call, because it adds the # waker in the process self._reads = {} self._writes = {} self._selectables = {} self._signal_handlers = [] from syncless import coio self._wakeup_info = coio.wakeup_info() self._pending_events = self._wakeup_info.pending_events PosixReactorBase.__init__(self)
def __init__(self): self._reads = {} self._writes = {} self.savedTimeout = None self._timer = eTimer() self._timer.callback.append(self.simulate) self._insimulate = False self._wakeupPending = False # to limit the systemcalls per loop # twistes gets a cached monotonic time for internal timers # only updated once per loop (monotonic_time call in def simulate) PosixReactorBase.seconds = self.now PosixReactorBase.__init__(self) self.addSystemEventTrigger('after', 'shutdown', self.cleanup)
def __init__(self): self._reads = {} self._writes = {} self._timer = QTimer() self._timer.setSingleShot(True) if QCoreApplication.startingUp(): self.qApp = QCoreApplication([]) self._ownApp = True else: self.qApp = QCoreApplication.instance() self._ownApp = False self._blockApp = None self._readWriteQ = [] PosixReactorBase.__init__(self)
def __init__(self): self._loop = pyuv.Loop() self._async_handle = pyuv.Async(self._loop, self._async_cb) self._async_handle_lock = threading.Lock() self._async_callbacks = deque() self._readers = {} # map of reader objects to fd self._writers = {} # map of writer objects to fd self._fds = {} # map of fd to a (reader, writer) tuple self._delayedCalls = {} self._poll_handles = {} self._signal_fds = SocketPair() self._signal_checker = pyuv.util.SignalChecker(self._loop, self._signal_fds.reader_fileno()) self._signal_checker.unref() self._signal_checker.start() PosixReactorBase.__init__(self)
def __init__(self): self._reads = {} self._writes = {} self.savedTimeout = None self._shutdownRunning = 0 self._timer = eTimer() self._timer_conn = self._timer.timeout.connect(self.simulate) self._insimulate = False self._wakeupPending = False # to limit the systemcalls per loop # twistes gets a cached monotonic time for internal timers # only updated once per loop (monotonic_time call in def simulate) PosixReactorBase.seconds = self.now PosixReactorBase.__init__(self) self.addSystemEventTrigger('after', 'shutdown', self.cleanup)
def __init__(self): QObject.__init__(self) self._readers = {} self._writers = {} self._timer = QTimer() self._timer.setSingleShot(True) self.connect(self._timer, SIGNAL("timeout()"), self._timerSlot) self._eventLoop = QCoreApplication.instance() if self._eventLoop is None: # create dummy application for testing self._eventLoop = QCoreApplication([]) PosixReactorBase.__init__(self) # goes last, because it calls addReader
def __init__(self): self._io_loop = tornado.ioloop.IOLoop.current() self._readers = {} # map of reader objects to fd self._writers = {} # map of writer objects to fd self._fds = {} # a map of fd to a (reader, writer) tuple self._delayedCalls = {} PosixReactorBase.__init__(self) self.addSystemEventTrigger('during', 'shutdown', self.crash) # IOLoop.start() bypasses some of the reactor initialization. # Fire off the necessary events if they weren't already triggered # by reactor.run(). def start_if_necessary(): if not self._started: self.fireSystemEvent('startup') self._io_loop.add_callback(start_if_necessary)
def __init__(self): self._loop = pyuv.Loop() self._async_handle = pyuv.Async(self._loop, self._async_cb) self._async_handle_lock = threading.Lock() self._async_callbacks = deque() self._readers = {} # map of reader objects to fd self._writers = {} # map of writer objects to fd self._fds = {} # map of fd to a (reader, writer) tuple self._delayedCalls = {} self._poll_handles = {} self._signal_fds = SocketPair() self._signal_checker = pyuv.util.SignalChecker( self._loop, self._signal_fds.reader_fileno()) self._signal_checker.unref() self._signal_checker.start() PosixReactorBase.__init__(self)
def __init__(self): self._reads = {} self._writes = {} self._timer = QTimer() self._timer.setSingleShot(True) if QCoreApplication.startingUp(): self.qApp = QCoreApplication([]) self._ownApp = True else: self.qApp = QCoreApplication.instance() self._ownApp = False self._blockApp = None self._readWriteQ = [] """ some debugging instrumentation """ self._doSomethingCount = 0 PosixReactorBase.__init__(self)
def __init__(self, io_loop=None): if not io_loop: io_loop = tornado.ioloop.IOLoop.instance() self._io_loop = io_loop self._readers = {} # map of reader objects to fd self._writers = {} # map of writer objects to fd self._fds = {} # a map of fd to a (reader, writer) tuple self._delayedCalls = {} PosixReactorBase.__init__(self) # IOLoop.start() bypasses some of the reactor initialization. # Fire off the necessary events if they weren't already triggered # by reactor.run(). def start_if_necessary(): if not self._started: self.fireSystemEvent("startup") self._io_loop.add_callback(start_if_necessary)
def __init__(self): self._reads = {} self._writes = {} self._timer=QTimer() self._timer.setSingleShot(True) if QCoreApplication.startingUp(): self.qApp=QCoreApplication([]) self._ownApp=True else: self.qApp = QCoreApplication.instance() self._ownApp=False self._blockApp = None self._readWriteQ=[] """ some debugging instrumentation """ self._doSomethingCount=0 PosixReactorBase.__init__(self)
def __init__(self, io_loop=None): if not io_loop: io_loop = tornado.ioloop.IOLoop.instance() self._io_loop = io_loop self._readers = {} # map of reader objects to fd self._writers = {} # map of writer objects to fd self._fds = {} # a map of fd to a (reader, writer) tuple self._delayedCalls = {} PosixReactorBase.__init__(self) # The default is a ThreadedResolver which spawns worker threads # from a thread pool which is probably *correct* but was quite # confusing and inconsistent with default Tornado behavior. self.installResolver(BlockingResolver()) self.addSystemEventTrigger('during', 'shutdown', self.crash) # IOLoop.start() bypasses some of the reactor initialization. # Fire off the necessary events if they weren't already triggered # by reactor.run(). def start_if_necessary(): if not self._started: self.fireSystemEvent('startup') self._io_loop.add_callback(start_if_necessary)
def __init__(self, eventloop): self._asyncioEventloop = eventloop self._writers = set() self._readers = set() self._delayedCalls = set() PosixReactorBase.__init__(self)
def __init__(self): PosixReactorBase.__init__(self) self.iterationTimeout = Deferred() self.now = 100
def __init__(self): self._readers = {} self._writers = {} PosixReactorBase.__init__(self)