def runMachine(start):
eventHub = core.EventHub()
qeventHub = core.QueuedEventHub(eventHub)
subsystems = core.SubsystemList()
subsystems.append(qeventHub)
machine = state.Machine(deps=subsystems)
sequence = raw_input('Enter sequence: ')
machine.start(start)
assert machine.currentState() is not None, 'State machine not started'
for x in sequence:
eventType = globals()[x.upper()]
qeventHub.publish(eventType, core.Event())
qeventHub.publishEvents()
assert machine.currentState(
) is not None, 'State machine ended prematurely'
# State machine finished, send finish event
qeventHub.publish(FINISH, core.Event())
qeventHub.publishEvents()
assert machine.currentState() is None, 'State machine has not ended'
machine.stop()
def testSubsystemPassing(self):
eventHub = core.EventHub("EventHub")
qeventHub = core.QueuedEventHub(eventHub, "QueuedEventHub")
machine = state.Machine(deps = [eventHub, qeventHub])
machine.start(Start)
startState = machine.currentState()
# Check for subsystems
self.assertEquals(eventHub, startState.eventHub)
self.assertEquals(qeventHub, startState.queuedEventHub)
def setUp(self):
# Create the event hub to collect all published events
self.eventHub = core.EventHub()
self.vehicle = MockVehicle(self.eventHub)
self.controller = MockController(self.eventHub)
# The QueuedEventHub lets us queue the events to be released when ready
self.qeventHub = core.QueuedEventHub(self.eventHub)
deps = [self.vehicle, self.controller, self.qeventHub, self.eventHub]
self.motionManager = motion.basic.MotionManager({}, deps)
# Replace Timer with out Mock Timer Class
MockTimer.LOG = {}
timer._origTimer = timer.Timer
timer.Timer = MockTimer
def setUp(self):
# Need a QueuedEventHub
self.eventHub = core.EventHub()
self.qeventHub = core.QueuedEventHub(self.eventHub)
cfg = {
'Monitor': {
'Systems': {
'Test': {
'eventType': 'ram.test.monitor.TestMonitor.TESTEVENT',
'property': 'number',
'name': 'testing123',
'warning': 5,
'critical': 10
}
}
}
}
self.monitor = monitor.Monitor(cfg=cfg.get('Monitor', {}),
deps=[self.qeventHub])
def setUp(self):
self.vehicle = MockVehicle()
cfg = {
'name': 'TestController',
'type': 'BWPDController',
'angularPGain': 10,
'angularDGain': 1,
'desiredQuaternion': [0, 0, 0, 1]
}
cfg = core.ConfigNode.fromString(str(cfg))
self.eventHub = core.EventHub()
deps = core.SubsystemList()
deps.append(self.eventHub)
deps.append(self.vehicle)
self.actualDepth = 0
self.desiredDepth = 0
self.controller = core.SubsystemMaker.newObject(cfg, deps)
self.qeventHub = core.QueuedEventHub(self.eventHub)
def testQueuedEvents(self):
self.event = None
eventHub = core.EventHub()
qeventHub = core.QueuedEventHub(eventHub)
timerManager = timer.TimerManager(deps=[eventHub])
# Subscribe event queue
qeventHub.subscribeToType(TestTimer.TIMER_EVENT, self.handleTimer)
# Create times
newTimer = timerManager.newTimer(TestTimer.TIMER_EVENT, 0.25)
# Start the timer and sleep to wait for it to complete, then check
newTimer.start()
time.sleep(0.1)
self.assertEquals(0, self.sec)
self.assertEquals(0.25 * 1e9, self.nsec)
self.assertEquals(None, self.event)
# Now release the events
qeventHub.publishEvents()
self.assertEquals(TestTimer.TIMER_EVENT, self.event.type)
def setUp(self, extraDeps=None, cfg=None):
# Handle case where the timer is still mocked for some reason, we make
# sure to un mock it
if AITestCase.__timerMocked:
self.mockTimer()
# Replace the Timer class with the Mock one
self.mockTimer()
if extraDeps is None:
extraDeps = []
if cfg is None:
cfg = {}
self.eventHub = core.EventHub()
self.qeventHub = core.QueuedEventHub(self.eventHub)
self.timerManager = timer.TimerManager(deps=[self.eventHub])
self.estimator = MockEstimator(cfg=cfg.get('StateEstimator', {}))
self.controller = MockController(eventHub=self.eventHub,
estimator=self.estimator)
self.vehicle = MockVehicle(cfg=cfg.get('Vehicle', {}))
self.visionSystem = MockVisionSystem()
aCfg = cfg.get('Ai', {})
self.ai = AI(aCfg)
deps = [
self.controller, self.timerManager, self.eventHub, self.qeventHub,
self.vehicle, self.visionSystem, self.ai, self.estimator
]
mCfg = cfg.get('MotionManager', {})
self.motionManager = motion.basic.MotionManager(mCfg, deps)
deps.append(self.motionManager)
deps.extend(extraDeps)
sCfg = cfg.get('StateMachine', {})
self.machine = state.Machine(cfg=sCfg, deps=deps)
def testEventHub(self):
eventHub = core.EventHub()
qeventHub = core.QueuedEventHub(eventHub)
mockEventSource = MockEventSource(eventHub)
machine = state.Machine(deps = [eventHub, qeventHub])
machine.start(Start)
# Send an event, and make sure it does get through until the queue
# releases it
mockEventSource.sendEvent(MockEventSource.ANOTHER_EVT, value = 20)
startState = machine.currentState()
self.assertEquals(Start, type(startState))
# Release events and make sure we have transition properly
qeventHub.publishEvents()
self.assertEquals(QueueTestState, type(machine.currentState()))
self.assert_(startState.anotherEvtEvent)
self.assertEquals(20, startState.anotherEvtEvent.value)
# Fire off another event and make sure we haven't gone anywhere
mockEventSource.sendEvent(MockEventSource.THING_UPDATED, value = 34)
qeventHub.publishEvents()
self.assertEquals(QueueTestState, type(machine.currentState()))
def setUp(self):
self.eventHub = core.EventHub()
self.qeventHub = core.QueuedEventHub(self.eventHub)
self.epub = core.EventPublisher()
def AnalyzeComputer(log_name, suppress, size, type_locs):
data = [0] * 7
type_index = type_locs
def numToCpuType(num):
return {
0: 'User',
1: 'Nice',
2: 'Sys',
3: 'Idle',
4: 'IOWait',
5: 'IRQ',
6: 'SIRQ'
}.get(num, 'Invalid')
def _onUser(event):
data[0] = event.number
def _onNice(event):
data[1] = event.number
def _onSys(event):
data[2] = event.number
def _onIdle(event):
data[3] = event.number
def _onIowt(event):
data[4] = event.number
def _onIrq(event):
data[5] = event.number
def _onSirq(event):
data[6] = event.number
def rewrite():
output = ''
for l in type_index:
output += numToCpuType(l) + ': %%%5.2f ' % data[l]
print '\r', output,
sys.stdout.flush()
print 'PyTop, a CPU analysis program (Crtl+C to exit)'
# Create subsystems
eventHub = core.EventHub()
qeventHub = core.QueuedEventHub(eventHub)
cfg = {
'CpuMonitor': {
'type': 'CpuMonitor',
'depends_on': '[ "QueuedEventHub" ]',
'log_results': suppress,
'bufferSize': size
}
}
if log_name is not None:
cfg['CpuMonitor']['log_name'] = log_name
monitor = ram.monitor.CpuMonitor(cfg=cfg.get('CpuMonitor'),
deps=[qeventHub])
# Register events we are listening to
connections = []
eventTypes = [
ram.monitor.CpuMonitor.USER_UPDATE, ram.monitor.CpuMonitor.NICE_UPDATE,
ram.monitor.CpuMonitor.SYS_UPDATE, ram.monitor.CpuMonitor.IDLE_UPDATE,
ram.monitor.CpuMonitor.IOWT_UPDATE, ram.monitor.CpuMonitor.IRQ_UPDATE,
ram.monitor.CpuMonitor.SIRQ_UPDATE
]
eventFuncs = [_onUser, _onNice, _onSys, _onIdle, _onIowt, _onIrq, _onSirq]
for index in type_index:
conn = qeventHub.subscribeToType(eventTypes[index], eventFuncs[index])
connections.append(conn)
start = time.time()
while True:
try:
# Allow cpu time to pass
time.sleep(1.0 / size)
end = time.time()
# Update monitor and publish the events
monitor.update(end - start)
qeventHub.publishEvents()
rewrite()
start = end
except KeyboardInterrupt:
break
# Unbackground monitor and close connections
monitor.unbackground()
for conn in connections:
conn.disconnect()
