Esempio n. 1
0
def run():
		
     # local heartbeat and Aggregator
     if options.aggregator:

          aggregator = Aggregator(options.agconfig)
          portal = create_portal(aggregator)
          
          heartbeat = Heartbeat(address=options.group, port=options.port)
          localip = socket.gethostbyname(socket.gethostname())
          heartbeat.setMessage(encode(options.id, localip, options.agport, aggregator.getPassword()))
          
          reactor.listenTCP(options.agport, pb.PBServerFactory(portal))
          aggregator.notifyOnMapped(heartbeat.start)

     # heartbeat monitor
     monitor = Monitor(address=options.group, port=options.port)

     # wx-twisted communication bridge (mediator)
     global twistedbridge
     twistedbridge = TwistedBridge(monitor)

     # monitor reports to the bridge via callbacks
     monitor.newHeartbeat(twistedbridge.newHeartbeat)
     monitor.lostHeartbeat(twistedbridge.lostHeartbeat)

     monitor.start()

     app = MyApp(redirect=False)
     app.MainLoop()
Esempio n. 2
0
    def test_password(self):
        """Aggregator should have random password"""

        assert type(self.aggregator.getPassword()) == type("")

        # ensure a second instance has differing password ...
        conf = Configurator()
        conf.fromString('')
        other = Aggregator(conf)
        assert other.getPassword() != self.aggregator.getPassword()
Esempio n. 3
0
    def setUpClass(self):
        """Start a DeviceServer in a child process to test against"""

        self.deviceserverprocess = SubProcessProtocol()
        self.deviceserverprocess.waitOnStartUp( ['server.py', 'deviceserver.conf', '-n'], \
                                                path=os.path.join(agdevicecontrol.path,'bin') )

        if self.deviceserverprocess.running is False:
            raise unittest.SkipTest, "DeviceServer didn't start correctly, skipping tests"

        #wait for slow single CPU buildbots to catch up
        import time
        time.sleep(1)

        # use the config above
        conf = Configurator()
        conf.fromString(configdata)

        # can be set by timeout
        self.failure = False


        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "Aggregator failed to connect to all deviceservers ... failing")
        
        self.aggregator = Aggregator(conf)
        self.done = False
        while not self.done:
            print "Waiting for aggregator to connect to deviceservers"
            reactor.iterate(0.1)
            if self.aggregator.connected:
                self.succeeded()

        if self.failure:
            raise unittest.SkipTest, "Aggregator didn't connect to all deviceservers ... skipping tests"



        # FIXME: we really should handle missing and newly appearing deviceservers.

        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "Aggregator failed to map all deviceservers ... failing")

        self.aggregator.notifyOnMapped(self.succeeded)

        self.done = False
        while not self.done:
            print "Waiting for aggregator to map deviceservers"
            reactor.iterate(0.1)


        if self.failure:
            raise unittest.SkipTest, "Aggregator didn't start correctly, skipping tests"
Esempio n. 4
0
class TestAggregator(SignalMixin, unittest.TestCase):

    def setUpClass(self):
        """Start a DeviceServer in a child process to test against"""

        self.deviceserverprocess = SubProcessProtocol()
        self.deviceserverprocess.waitOnStartUp( ['server.py', 'deviceserver.conf', '-n'], \
                                                path=os.path.join(agdevicecontrol.path,'bin') )

        if self.deviceserverprocess.running is False:
            raise unittest.SkipTest, "DeviceServer didn't start correctly, skipping tests"

        #wait for slow single CPU buildbots to catch up
        import time
        time.sleep(1)

        # use the config above
        conf = Configurator()
        conf.fromString(configdata)

        # can be set by timeout
        self.failure = False


        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "Aggregator failed to connect to all deviceservers ... failing")
        
        self.aggregator = Aggregator(conf)
        self.done = False
        while not self.done:
            print "Waiting for aggregator to connect to deviceservers"
            reactor.iterate(0.1)
            if self.aggregator.connected:
                self.succeeded()

        if self.failure:
            raise unittest.SkipTest, "Aggregator didn't connect to all deviceservers ... skipping tests"



        # FIXME: we really should handle missing and newly appearing deviceservers.

        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "Aggregator failed to map all deviceservers ... failing")

        self.aggregator.notifyOnMapped(self.succeeded)

        self.done = False
        while not self.done:
            print "Waiting for aggregator to map deviceservers"
            reactor.iterate(0.1)


        if self.failure:
            raise unittest.SkipTest, "Aggregator didn't start correctly, skipping tests"



    def tearDownClass(self):
        """Stop the DeviceServer running in a child process"""
        print "*** tearDownClass: ", self.deviceserverprocess.done
        self.deviceserverprocess.waitOnShutDown()


    def succeeded(self, *args):
        """Allow reactor iteration loop in test proper to exit and pass test"""
        self.done = True
	if self.timeout is not None:
	    self.timeout.cancel()  # safety timeout no longer necessary
        self.timeout = None
        self.lastargs = args  # make persistent for later checks


    def failed(self, reason):
        """Allow reactor iteration loop in test proper to exit and fail test"""
        self.done = True
        self.failure = reason
        self.timeout.cancel()  # safety timeout no longer necessary
        self.timeout = None

    def setUp(self):
        """I'm called at the very beginning of each test"""
        self.done = False
        self.failure = None
        self.timeout = None


    def tearDown(self):
        """I'm called at the end of each test"""
        if self.timeout:
            self.timeout.cancel()


    def timedOut(self):
        """I'm called when the safety timer expires indicating test probably won't complete"""

        print "timedOut callback, test did not complete"
        self.failed("Safety timeout callback ... test did not complete")
        reactor.crash()


        

    #---------- tests proper ------------------------------------

    def test_handled_configurator(self):
        """Aggregator instantiated with a configurator rather than .conf filename"""
        assert 'DeviceServer1' in self.aggregator.config


    def test_password(self):
        """Aggregator should have random password"""

        assert type(self.aggregator.getPassword()) == type("")

        # ensure a second instance has differing password ...
        conf = Configurator()
        conf.fromString('')
        other = Aggregator(conf)
        assert other.getPassword() != self.aggregator.getPassword()



    def test_devicelist_as_deferred(self):
        """Return aggregated device list"""

        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "retrieving devicelist timed out ... failing")

        d = self.aggregator.getDeviceList()
        assert isinstance(d, defer.Deferred)
        d.addCallback(self.succeeded)
        
        # idle until code above triggers succeeded or timeout causes failure
        while not self.done:
            reactor.iterate(0.1)
        
        # will arrive here eventually when either succeeded or failed method has fired
        if self.failure:
            self.failed(self.failure)

        devicelist = self.lastargs[0]
        assert len(devicelist) == 2
        assert 'Device1' in devicelist
        assert 'Device2' in devicelist



    def test_devicemap_as_deferred(self):
        """Return aggregated device map"""

        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "retrieving devicemap timed out ... failing")

        d = self.aggregator.getDeviceMap()
        assert isinstance(d, defer.Deferred)

        # caution: as this deferred is ready-to-go, the callback is called *immediately*
        d.addCallback(self.succeeded)
        # i.e., self.succeeded has now been called
        
        # idle until code above triggers succeeded or timeout causes failure
        while not self.done:
             reactor.iterate(0.1)
        
        # will arrive here eventually when either succeeded or failed method has fired
        if self.failure:
            self.failed(self.failure)

        devicemap = self.lastargs[0]
        print devicemap
        assert type(devicemap) == types.DictType
        assert len(devicemap) == 1
        assert 'PseudoDevice' in devicemap
        assert len(devicemap['PseudoDevice']) == 2
        assert 'Device1' in devicemap['PseudoDevice']
        assert 'Device2' in devicemap['PseudoDevice']



    def test_device_execute(self):
        """Proxy forward command to correct DeviceServer"""

        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "executing remote setParameter timed out ... failing")

        # 3-digit random integer
        value = int(random.random()*1000)
	
	# get a device key for use in next step
	self.done = False
	d = self.aggregator.getDeviceList()
	d.addCallback(self.succeeded)
	d.addErrback(self.failed)

	while not self.done:
	    reactor.iterate(0.1)

	if self.failure:
	    self.fail(self.failure)

	print
	print "DEBUG:"
	device = self.lastargs[0][0]
	print device.name

        # store number in 'remote' PseudoDevice
        d = self.aggregator.deviceExecute(device, 'setParameter', value)
        assert isinstance(d, defer.Deferred)
        d.addCallback(self.succeeded)
        
        # idle until code above triggers succeeded or timeout causes failure
        self.done = False
        while not self.done:
            reactor.iterate(0.1)
        
        # will arrive here eventually when either succeeded or failed method has fired
        if self.failure:
            self.failed(self.failure)


        # safety timeout
        self.timeout = reactor.callLater(10, self.failed, "executing remote getParameter timed out ... failing")

        # store number in 'remote' PseudoDevice
        d = self.aggregator.deviceExecute(device, 'getParameter')
        assert isinstance(d, defer.Deferred)
        d.addCallback(self.succeeded)
        
        # idle until code above triggers succeeded or timeout causes failure
        self.done = False
        while not self.done:
            reactor.iterate(0.1)
        
        # will arrive here eventually when either succeeded or failed method has fired
        if self.failure:
            self.failed(self.failure)

        returnvalue = self.lastargs[0]
        assert returnvalue == value


    if False:
        test_handled_configurator = True
        test_devicelist_as_deferred = True
        test_devicemap_as_deferred = True
        test_device_execute = True
        test_password = True