Python reactor.callWhenRunning函数代码示例

    def run(self):
        self.fetchTask = self.tasks.new('Fetching data')
        self.parseTask = self.tasks.new('Parsing emails')
        self.publishTask = self.tasks.new('Creating graph')

        self.setup_twisted_logging()

        self.graph = nx.DiGraph()

        def write_graphml(stream):
            return nx.write_graphml(self.graph, stream)

        self.graph.write_graphml = write_graphml

        def stop(_):
            reactor.stop()

        def catchError(failure):
            self.error = failure

        def collect():
            d = self.asyncCollect(reactor)
            d.addErrback(catchError)
            d.addCallback(stop)

        self.error = None
        reactor.callWhenRunning(collect)
        reactor.run()

        if self.error:
            self.error.raiseException()

        return self.graph

    def start_reactor(self):
        reactor.callWhenRunning(
            lambda: self.log.info('twisted-reactor-started'))

        reactor.addSystemEventTrigger('before', 'shutdown',
                                      self.shutdown_components)
        reactor.run()

def main():
    install_qtreactor()
    opts, _ = parse_opts()

    start_logging(opts)
    bump_nofile_limit()
    monitor_maxrss(opts.maxrss)
    if opts.manhole:
        manhole_server()

    default_splash_server(portnum=opts.port,
                  slots=opts.slots,
                  cache_enabled=opts.cache_enabled,
                  cache_path=opts.cache_path,
                  cache_size=opts.cache_size,
                  proxy_profiles_path=opts.proxy_profiles_path,
                  js_profiles_path=opts.js_profiles_path,
                  js_disable_cross_domain_access=not opts.js_cross_domain_enabled,
                  disable_proxy=opts.disable_proxy,
                  proxy_portnum=opts.proxy_portnum)
    signal.signal(signal.SIGUSR1, lambda s, f: traceback.print_stack(f))

    from twisted.internet import reactor
    reactor.callWhenRunning(splash_started, opts, sys.stderr)
    reactor.run()

    def loop(self, display, widget):
        self.display = display
        self.widget = widget
        self.global_keymap.set_next_keymap(self.widget.keymap)

        reactor.callWhenRunning(self._start_loop)
        reactor.run()

    def twistedinteract(self):
        from twisted.internet import reactor
        from twisted.internet.abstract import FileDescriptor
        import signal
        outerself = self
        class Me(FileDescriptor):
            def fileno(self):
                """ We want to select on FD 0 """
                return 0

            def doRead(self):
                """called when input is ready"""
                try:
                    outerself.handle1()
                except EOFError:
                    reactor.stop()

        reactor.addReader(Me())
        reactor.callWhenRunning(signal.signal,
                                signal.SIGINT,
                                signal.default_int_handler)
        self.prepare()
        try:
            reactor.run()
        finally:
            self.restore()

def run(port_num, sslport_num, proxyport_num, authproxyport_num,
        authproxy_user, verbose=True):
    root = Root(port_num, sslport_num, proxyport_num)
    factory = Site(root)
    port = reactor.listenTCP(port_num, factory)
    sslport = reactor.listenSSL(sslport_num, factory, ssl_factory())
    proxyport = reactor.listenTCP(proxyport_num, ProxyFactory())
    authproxyport = reactor.listenTCP(authproxyport_num,
                                      AuthProxyFactory(authproxy_user))

    def print_listening():
        h = port.getHost()
        s = sslport.getHost()
        p = proxyport.getHost()
        ap = authproxyport.getHost()
        print("Mock server running at http://%s:%d (http), "
              "https://%s:%d (https) and http://%s:%d (proxy) "
              "and http://%s:%d (proxy with auth, user: %s)" %
              (h.host, h.port, s.host, s.port, p.host, p.port,
               ap.host, ap.port, authproxy_user))

    if verbose:
        import sys
        from twisted.python import log
        log.startLogging(sys.stdout)
        reactor.callWhenRunning(print_listening)

    reactor.run()

 def shutdown(reason, reactor, stopping=[]):
     """Stop the reactor."""
     if stopping: return
     stopping.append(True)
     if reason:
         log.msg(reason.value)
     reactor.callWhenRunning(reactor.stop)

 def __exit__(self, type, value, traceback):
     self._deferred.addErrback(self._handle_error)
     self._deferred.addBoth(defer.drop_param,
                            self.connection.database.disconnect)
     self._deferred.addBoth(defer.drop_param, reactor.stop)
     reactor.callWhenRunning(self._deferred.callback, self.connection)
     reactor.run()

 def startWorkers(self):
     def _doStart():
         for i in xrange(self._maxWorkers):
             self._startWorker()
         log.debug("Registering SIGCHLD handler")
         signal.signal(signal.SIGCHLD, self._sigchldhandler)
     reactor.callWhenRunning(_doStart)

def install():
  def wrapNextTurn(self):
    if self not in games:
      games.append(self)
    if self.turn == self.players[0]:
      self.player1Time += self.timeInc
    elif self.turn == self.players[1]:
      self.player0Time += self.timeInc
    retval = yield aspects.proceed

  aspects.with_wrap(wrapNextTurn, Match.nextTurn)

  def tick():
    import main
    for i in games:
      if i.turn == i.players[0]:
        i.player0Time -= 1
        if i.player0Time < 0:
          i.declareWinner(i.players[1], 'Laaaaaag')
      elif i.turn == i.players[1]:
        i.player1Time -= 1
        if i.player1Time < 0:
          i.declareWinner(i.players[0], 'Laaaaaag')
      else:
        games.remove(i)

    reactor.callLater(.01, tick)

  reactor.callWhenRunning(reactor.callLater, .01, tick)

def install():
  def wrapNextTurn(self):
    if self not in games:
      games.append(self)
    if self.turn == self.players[0]:
      p = [i for i in self.objects.players]
      p[1].time += self.timeInc
    elif self.turn == self.players[1]:
      p = [i for i in self.objects.players]
      p[0].time += self.timeInc
    retval = yield aspects.proceed

  aspects.with_wrap(wrapNextTurn, Match.nextTurn)

  def tick():
    import main
    for i in games:
      p = [j for j in i.objects.values() if isinstance(j,Player)]
      if i.turn == i.players[0]:
        p[0].time -= 1
        if p[0].time < 0:
          print "2 Wins!"
          i.declareWinner(i.players[1], 'Player 1 Lagged Out, Player 2 Wins')
      elif i.turn == i.players[1]:
        p[1].time -= 1
        if p[1].time < 0:
          print "1 Wins!"
          i.declareWinner(i.players[0], 'Player 2 Lagged Out, Player 1 Wins')
      else:
        games.remove(i)

    reactor.callLater(1, tick)

  reactor.callWhenRunning(reactor.callLater, 1, tick)

def main():
    opts, _ = parse_opts()
    if opts.version:
        print(__version__)
        sys.exit(0)

    install_qtreactor(opts.verbosity >= 5)

    start_logging(opts)
    log_splash_version()
    bump_nofile_limit()
    monitor_maxrss(opts.maxrss)
    if opts.manhole:
        manhole_server()

    default_splash_server(portnum=opts.port,
                  slots=opts.slots,
                  cache_enabled=opts.cache_enabled,
                  cache_path=opts.cache_path,
                  cache_size=opts.cache_size,
                  proxy_profiles_path=opts.proxy_profiles_path,
                  js_profiles_path=opts.js_profiles_path,
                  js_disable_cross_domain_access=not opts.js_cross_domain_enabled,
                  disable_proxy=opts.disable_proxy,
                  proxy_portnum=opts.proxy_portnum,
                  filters_path=opts.filters_path,
                  allowed_schemes=opts.allowed_schemes,
                  verbosity=opts.verbosity)
    signal.signal(signal.SIGUSR1, lambda s, f: traceback.print_stack(f))

    from twisted.internet import reactor
    reactor.callWhenRunning(splash_started, opts, sys.stderr)
    reactor.run()

def main():
    host, cport, mport = parse_args()
    use_codec = False

    Registry.DBPOOL = adbapi.ConnectionPool(
        'sqlite3', "sequoia/tests/auth/server_1/database.db",
        check_same_thread=False)

    mixer = AudioMixer()
    reactor.callWhenRunning(mixer.start)
    codec = speex.new() if use_codec else None
    media_tx = ServerMediaProtocol(codec, mixer)
    clients_factory = ServerClientsFactory(media_tx, use_codec)
    ctx_factory = ServerContextFactory(
        "sequoia/tests/auth/server_1/private_key.pem",
        "sequoia/tests/auth/server_1/certificate.pem",
        "sequoia/tests/auth/root/root_ca.crt")

    clients_listener = reactor.listenSSL(cport, clients_factory, ctx_factory,
        interface=host)
    show_connector_info(clients_listener, "Listening clients")
    media_listener = reactor.listenUDP(mport, media_tx,
        interface=host)
    show_connector_info(media_listener, "Serving media")

    reactor.run()

def main():
    from twisted.internet import reactor

    nanobot = NanoBot(reactor, "config.json")
    reactor.callWhenRunning(nanobot.run)
    reactor.addSystemEventTrigger("before", "shutdown", nanobot.shutdown)
    reactor.run()

    def handle(self, *args, **options):  # pylint: disable=too-many-locals
        import os

        from twisted.internet import reactor

        from lava_scheduler_daemon.service import JobQueue
        from lava_scheduler_daemon.dbjobsource import DatabaseJobSource

        daemon_options = self._configure(options)

        source = DatabaseJobSource()

        if options['use_fake']:
            import lava_scheduler_app
            opd = os.path.dirname
            dispatcher = os.path.join(
                opd(opd(os.path.abspath(lava_scheduler_app.__file__))),
                'fake-dispatcher')
        else:
            dispatcher = options['dispatcher']

        # Start scheduler service.
        service = JobQueue(
            source, dispatcher, reactor, daemon_options=daemon_options)
        reactor.callWhenRunning(service.startService)  # pylint: disable=no-member
        reactor.run()  # pylint: disable=no-member