Python SelectReactor.doIteration方法代码示例

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
    def doIteration(self, t):
        # Do the same as in mainLoop() first.
        self.runUntilCurrent()
        t2 = self.timeout()

        if t2 is not None:
            t = min(t, self.running and t2)

        SelectReactor.doIteration(self, t)
        self.loopCall()

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
class ReactorSlaveController(object):
    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 iterate(self):
        print 'in iterate'
        self.reactor.runUntilCurrent()
        self.reactor.doIteration(0)
        #t2 = self.reactor.timeout()
        #print 'timeout', t2
        #t = self.reactor.running and t2
        #self.reactor.doIteration(t)

    def run(self):
	clock = pygame.time.Clock()
        self.reactor.callLater(20, stupidTest)
        while self.keepGoing:
            timeChange = clock.tick(FRAMES_PER_SECOND)
            if self.futureCall:
                self.futureCallTimeout -= timeChange
                print 'future call in', self.futureCallTimeout
                if self.futureCallTimeout <= 0:
                    self.futureCall()
                    self.futureCallTimeout = None
                    self.futureCall= None
            retval = pygame_test.iterate()
            if retval == False:
                thingInControl.stop()
            self.iterate()

    def stop(self):
        print 'stopping'
        self.reactor.stop()
        self.keepGoing = False

    def callLater(self, when, fn):
        self.futureCallTimeout = when*1000
        self.futureCall = fn
        print 'future call in', self.futureCallTimeout

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
    def doIteration(self, delay):
        """
        Perform a single iteration of the reactor. Here we make sure that
        all of our file descriptors that we need to watch are and then delegate
        the actual watching back to the twisted reactor.
        """

        self.callTimeouts(delay)
        return SelectReactor.doIteration(self, delay)

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
class NetworkServerView(pb.Root):
    """We SEND events to the server through this object"""
    STATE_PREPARING = 0
    STATE_CONNECTING = 1
    STATE_CONNECTED = 2
    STATE_DISCONNECTING = 3
    STATE_DISCONNECTED = 4

    #----------------------------------------------------------------------
    def __init__(self, evManager, sharedObjectRegistry):
        self.evManager = evManager
        self.evManager.RegisterListener( self )

        self.pbClientFactory = pb.PBClientFactory()
        self.state = NetworkServerView.STATE_PREPARING
        self.reactor = None
        self.server = None

        self.sharedObjs = sharedObjectRegistry

    #----------------------------------------------------------------------
    def AttemptConnection(self):
        print "attempting a connection to", serverHost, serverPort
        self.state = NetworkServerView.STATE_CONNECTING
        if self.reactor:
            self.reactor.stop()
            self.PumpReactor()
        else:
            self.reactor = SelectReactor()
            installReactor(self.reactor)
        connection = self.reactor.connectTCP(serverHost, serverPort,
                                             self.pbClientFactory)
        # TODO: make this anonymous login()
        #deferred = self.pbClientFactory.login(credentials.Anonymous())
        userCred = credentials.UsernamePassword(avatarID, 'pass1')
        controller = NetworkServerController( self.evManager )
        deferred = self.pbClientFactory.login(userCred, client=controller)
        deferred.addCallback(self.Connected)
        deferred.addErrback(self.ConnectFailed)
        self.reactor.startRunning()

    #----------------------------------------------------------------------
    def Disconnect(self):
        print "disconnecting"
        if not self.reactor:
            return
        print 'stopping the reactor'
        self.reactor.stop()
        self.PumpReactor()
        self.state = NetworkServerView.STATE_DISCONNECTING

    #----------------------------------------------------------------------
    def Connected(self, server):
        print "CONNECTED"
        self.server = server
        self.state = NetworkServerView.STATE_CONNECTED
        ev = ServerConnectEvent( server )
        self.evManager.Post( ev )

    #----------------------------------------------------------------------
    def ConnectFailed(self, server):
        print "CONNECTION FAILED"
        print server
        print 'quitting'
        self.evManager.Post( QuitEvent() )
        #self.state = NetworkServerView.STATE_PREPARING
        self.state = NetworkServerView.STATE_DISCONNECTED

    #----------------------------------------------------------------------
    def PumpReactor(self):
        self.reactor.runUntilCurrent()
        self.reactor.doIteration(0)

    #----------------------------------------------------------------------
    def Notify(self, event):
        NSV = NetworkServerView
        if isinstance( event, TickEvent ):
            if self.state == NSV.STATE_PREPARING:
                self.AttemptConnection()
            elif self.state in [NSV.STATE_CONNECTED,
                                NSV.STATE_DISCONNECTING,
                                NSV.STATE_CONNECTING]:
                self.PumpReactor()
            return

        if isinstance( event, QuitEvent ):
            self.Disconnect()
            return

        ev = event
        if not isinstance( event, pb.Copyable ):
            evName = event.__class__.__name__
            copyableClsName = "Copyable"+evName
            if not hasattr( network, copyableClsName ):
                return
            copyableClass = getattr( network, copyableClsName )
            #NOTE, never even construct an instance of an event that
            # is serverToClient, as a side effect is often adding a
            # key to the registry with the local id().
            if copyableClass not in network.clientToServerEvents:
#.........这里部分代码省略.........

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
class NetworkServerView(pb.Root):
    """We SEND events to the server through this object"""
    STATE_PREPARING = 0
    STATE_CONNECTING = 1
    STATE_CONNECTED = 2

    def __init__(self, evm, shared_obj_registry):
        self.evm = evm
        self.evm.register(self)

        self.pbClientFactory = pb.PBClientFactory()
        
        self.reactor = None
        self.server = None

        self.shared_objs = shared_obj_registry
        self.state = NetworkServerView.STATE_PREPARING
 
    def connected(self, server):
        print 'Connection to %s %s successful' %SERVERHOST, SERVERPORT

        self.state = NetworkServerView.STATE_CONNECTED
        
        self.server = server
        self.evm.post(ev.ServerConnected(server))
        
    def connection_failed(self, error):
        print "Connection failed with error ", error

    def attempt_connection(self):
        print "Attempting connection to", SERVERHOST, SERVERPORT
        
        self.state = NetworkServerView.STATE_CONNECTING
        
        if self.reactor:
            self.reactor.stop()
            self.pump_reactor()
        else:
            self.reactor = SelectReactor()
            installReactor(self.reactor)
        
        connection = self.reactor.connectTCP(SERVERHOST, SERVERPORT,
                                             self.pbClientFactory)
        deferred = self.pbClientFactory.getRootObject()        
        deferred.addCallback(self.connected)
        deferred.addErrback(self.connection_failed)
        self.reactor.run()
        
    def pump_reactor(self):
        self.reactor.runUntilCurrent()
        self.reactor.doIteration(0)

        
    def disconnect(self):
        print "disconnecting"

    def notify(self, evt):
        if evt.id == 'Tick':
            if self.state == NetworkServerView.STATE_PREPARING:
                self.attempt_connection()
            elif self.state in [NetworkServerView.STATE_CONNECTING]:
                self.pump_reactor()

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
class NetworkServerView(pb.Root):
	"""We SEND events to the server through this object"""
	STATE_PREPARING = 0
	STATE_CONNECTING = 1
	STATE_CONNECTED = 2
	STATE_DISCONNECTING = 3
	STATE_DISCONNECTED = 4

	#----------------------------------------------------------------------
	def __init__(self, evManager, sharedObjectRegistry):
		self.evManager = evManager
		self.evManager.RegisterListener( self )

		self.pbClientFactory = pb.PBClientFactory()
		self.state = NetworkServerView.STATE_PREPARING
		self.reactor = None
		self.server = None

		self.sharedObjs = sharedObjectRegistry

	#----------------------------------------------------------------------
	def AttemptConnection(self):
		print "attempting a connection to", serverHost, serverPort
		self.state = NetworkServerView.STATE_CONNECTING
		if self.reactor:
			self.reactor.stop()
			self.PumpReactor()
		else:
			self.reactor = SelectReactor()
			installReactor(self.reactor)
		connection = self.reactor.connectTCP(serverHost, serverPort,
		                                     self.pbClientFactory)
		deferred = self.pbClientFactory.getRootObject()
		deferred.addCallback(self.Connected)
		deferred.addErrback(self.ConnectFailed)
		self.reactor.startRunning()

	#----------------------------------------------------------------------
	def Disconnect(self):
		print "disconnecting"
		if not self.reactor:
			return
		print 'stopping the reactor'
		self.reactor.stop()
                self.PumpReactor()
		self.state = NetworkServerView.STATE_DISCONNECTING

	#----------------------------------------------------------------------
	def Connected(self, server):
		print "CONNECTED"
		self.server = server
		self.state = NetworkServerView.STATE_CONNECTED
		ev = ServerConnectEvent( server )
		self.evManager.Post( ev )

	#----------------------------------------------------------------------
	def ConnectFailed(self, server):
		print "CONNECTION FAILED"
		#self.state = NetworkServerView.STATE_PREPARING
		self.state = NetworkServerView.STATE_DISCONNECTED

	#----------------------------------------------------------------------
	def PumpReactor(self):
		self.reactor.runUntilCurrent()
		self.reactor.doIteration(0)

	#----------------------------------------------------------------------
	def Notify(self, event):
		NSV = NetworkServerView
		if isinstance( event, TickEvent ):
			if self.state == NSV.STATE_PREPARING:
				self.AttemptConnection()
			elif self.state in [NSV.STATE_CONNECTED,
			                    NSV.STATE_DISCONNECTING,
			                    NSV.STATE_CONNECTING]:
				self.PumpReactor()
			return

		if isinstance( event, QuitEvent ):
			self.Disconnect()
			return

		ev = event
		if not isinstance( event, pb.Copyable ):
			evName = event.__class__.__name__
			copyableClsName = "Copyable"+evName
			if not hasattr( network, copyableClsName ):
				return
			copyableClass = getattr( network, copyableClsName )
			ev = copyableClass( event, self.sharedObjs )

		if ev.__class__ not in network.clientToServerEvents:
			#print "CLIENT NOT SENDING: " +str(ev)
			return
			
		if self.server:
			print " ====   Client sending", str(ev)
			remoteCall = self.server.callRemote("EventOverNetwork",
			                                    ev)
		else:
#.........这里部分代码省略.........

# 需要导入模块: from twisted.internet.selectreactor import SelectReactor [as 别名]
# 或者: from twisted.internet.selectreactor.SelectReactor import doIteration [as 别名]
 def doIteration(self, delay):
     print 'calling doIteration'
     SelectReactor.doIteration(self,delay)
     retval = pygame_test.iterate()
     if retval == False:
         thingInControl.stop()