def gotList(mappings):
    mappings = [ ((x[0][0],int(x[0][1]),x[1])) for x in mappings.items()]
    mappings.sort()
    for prot,port,ddict in mappings:
        desc = mappingDesc%ddict
        print "%s/%d -> %s"%(prot,port,desc)
    reactor.stop()

    def command_result(command_st):

        commands = command_st.strip().split()

        if(len(commands) > 1):

            op = commands[0]

            key = str(commands[1])

            print "####KEY", key

            if(len(commands) > 2):
                value = commands[2].encode('ascii', 'ignore')

            if op == "q":

                reactor.stop()

            elif op == "set":

                print "adding key:", key, "-->", value
                server.set(key, value).addCallback(set_done, server)

            elif op == "get":

                print "getting key:", key

                server.get(key).addCallback(get_done, server)

            else:

                print "command: ",command_st," is wrong format"

        get_input()

 def callback(results):
     reactor.stop()
     for success, result in results:
         if success:
             print ElementTree.dump(result)
         else:
             print result.printTraceback()

	def clientConnectionFailed(self, connector, reason):
		'''
		called when tcp connection attemp failed!
		'''
		
		print "connection failed: %s" % reason
		reactor.stop()

    def quit(self, shutdown=False):
        """
        Quits the GtkUI

        :param shutdown: whether or not to shutdown the daemon as well
        :type shutdown: boolean
        """
        if shutdown:

            def on_daemon_shutdown(result):
                try:
                    reactor.stop()
                except ReactorNotRunning:
                    log.debug("Attempted to stop the reactor but it is not running...")

            client.daemon.shutdown().addCallback(on_daemon_shutdown)
            return
        if client.is_classicmode():
            reactor.stop()
            return
        if not client.connected():
            reactor.stop()
            return

        def on_client_disconnected(result):
            reactor.stop()

        client.disconnect().addCallback(on_client_disconnected)

    def handleCmd_EOS(self, prefix, args):
        if prefix != self.server_name:
            return
        if self.ism.syncd:
            return

        LOG.info("Finished receiving IRC sync data.")

        self.showirc = True

        # Check for conflicting bridges.
        if self.ism.findConflictingBridge():
            LOG.error("My nick prefix is in use! Terminating.")
            self.transport.loseConnection()
            reactor.stop()
            return

        # Set up nick reservation
        scfg = getServiceConfig()
        self.sendLine(
            "TKL + Q * %s* %s 0 %d :Reserved for Dtella" %
            (cfg.dc_to_irc_prefix, scfg.my_host, time.time()))
        self.ism.killConflictingUsers()

        # Send my own bridge nick
        self.pushBotJoin(do_nick=True)

        # When we enter the syncd state, register this instance with Dtella.
        # This will eventually trigger event_DtellaUp, where we send our state.
        self.schedulePing()
        self.ism.addMeToMain()

    def terminate(self):
        # join the CheckChannelStreamRepeat thread
        self.thread.do_run = False
        self.thread.join()

        self.close_commands()
        reactor.stop()

 def check_counters_and_stop(self):
      if len(self.counters) >= self.number_counters:
         reactor.stop()
         echo('OUT')
      else:
          echo("{0} {1}".format(count, stack()[0][3]))
          reactor.callLater(.5, self.check_counters_and_stop)

def game_loop():
	
	#Networking
	sent_data = datagrabber.grab()
	if sent_data != None:
		print sent_data

	#Logic
	if mo.quit():
		tick.stop()
		reactor.stop()

	if rtrn.pressed():
		hand.cards[0].flip()

	#Animation
	#

	#Video
	mo.window.clear(mo.sf.Color.WHITE)
	#
	hand.draw()
	opponent.draw()
	#
	mo.window.display()

 def processEnded(self, reason):
     if isinstance(reason.value, ProcessTerminated):
         self._exit_status = reason.value.status
     if isinstance(reason.value, ProcessDone):
         self._exit_status = reason.value.status
     self._process = None
     reactor.stop()

 def stop(self):
     """
     停止代理服务器
     :return:
     """
     print('停止监听端口{}, 停止代理服务器'.format(self._port))
     reactor.stop()

 def errback(error):
     if isinstance(error, Failure):
         self.log.critical( "Invalid monitor: %s" % self.options.monitor)
         reactor.stop()
         return defer.fail(RemoteBadMonitor(
                    "Invalid monitor: %s" % self.options.monitor, ''))
     return error

 def err_cb(failure):
     failure.trap(Exception)
     logging.error("Error: {0}".format(failure))
     if args['debug']:
         traceback.print_exc()
     if reactor.running:
         reactor.stop()

    def dataReceived(self, data):
        # TOFIX: Figure out how to get this method to work.
        # if not self.known_proto:
            # self.known_proto = True
            # assert self.known_proto == b'h2'

        events = self.conn.receive_data(data)

        for event in events:
            self.messageHandler.storeEvent(event)
            if isinstance(event, ResponseReceived):
                self.handleResponse(event.headers, event.stream_id)
            elif isinstance(event, DataReceived):
                self.handleData(event.data, event.stream_id)
            elif isinstance(event, StreamEnded):
                self.endStream(event.stream_id)
            elif isinstance(event, SettingsAcknowledged):
                self.settingsAcked(event)
            elif isinstance(event, StreamReset):
                reactor.stop()
                raise RuntimeError("Stream reset: %d" % event.error_code)
            else:
                print(event)

        data = self.conn.data_to_send()
        if data:
            self.transport.write(data)

 def stop(self,dummy=None):
     """
     Exit routine; stops twisted reactor
     """
     print "Closing Python Manager"
     reactor.stop()        
     print "Done"

    def _stuned(ip):
        if stun.getUDPClient() is None:
            print 'UDP CLIENT IS NONE - EXIT'
            reactor.stop()
            return

        print '+++++ EXTERNAL UDP ADDRESS IS', stun.getUDPClient().externalAddress
        
        if sys.argv[1] == 'listen':
            print '+++++ START LISTENING'
            return
        
        if sys.argv[1] == 'connect':
            print '+++++ CONNECTING TO REMOTE MACHINE'
            _try2connect()
            return

        lid = misc.getLocalIdentity()
        udp_contact = 'udp://'+stun.getUDPClient().externalAddress[0]+':'+str(stun.getUDPClient().externalAddress[1])
        lid.setProtoContact('udp', udp_contact)
        lid.sign()
        misc.setLocalIdentity(lid)
        misc.saveLocalIdentity()
        
        print '+++++ UPDATE IDENTITY', str(lid.contacts)
        _send_servers().addBoth(_id_sent)

def setup_complete(config):
    print "Got config"
    keys = config.config.keys()
    keys.sort()
    defaults = []
    for k in keys:
        if k == 'HiddenServices':
            for hs in config.config[k]:
                for xx in ['dir', 'version', 'authorize_client']:
                    if getattr(hs, xx):
                        print 'HiddenService%s %s' % (xx.capitalize(),
                                                      getattr(hs, xx))
                for port in hs.ports:
                    print 'HiddenServicePort', port
            continue

        v = getattr(config, k)
        if isinstance(v, types.ListType):
            for val in v:
                if val != DEFAULT_VALUE:
                    print k, val

        elif v == DEFAULT_VALUE:
            defaults.append(k)

        else:
            print k, v

    if 'defaults' in sys.argv:
        print "Set to default value:"
        for k in defaults:
            print "# %s" % k

    reactor.stop()

 def _failure(self, why):
     from twisted.internet import reactor
     from buildbot_worker.scripts.logwatcher import WorkerTimeoutError
     if why.check(WorkerTimeoutError):
         print(rewrap("""\
             The worker took more than 10 seconds to start and/or connect
             to the buildmaster, so we were unable to confirm that it
             started and connected correctly.
             Please 'tail twistd.log' and look for a line that says
             'message from master: attached' to verify correct startup.
             If you see a bunch of messages like 'will retry in 6 seconds',
             your worker might not have the correct hostname or portnumber
             for the buildmaster, or the buildmaster might not be running.
             If you see messages like
                'Failure: twisted.cred.error.UnauthorizedLogin'
             then your worker might be using the wrong botname or password.
             Please correct these problems and then restart the worker.
             """))
     else:
         print(rewrap("""\
             Unable to confirm that the worker started correctly.
             You may need to stop it, fix the config file, and restart.
             """))
         print(why)
     self.rc = 1
     reactor.stop()

def single_shot_main(args):
    try:
        client = WinrsClient(args.remote, args.username, args.password)
        results = yield client.run_command(args.command)
        pprint(results)
    finally:
        reactor.stop()

 def quit(self, exit_value=0, with_restart=False):
     """Shutdown and stop the reactor."""
     yield self.shutdown(with_restart)
     if reactor.running:
         reactor.stop()
     else:
         sys.exit(exit_value)