def setUp(self): cfg = { 'Ai' : { 'taskOrder' : ['ram.test.ai.task.TaskA', 'ram.test.ai.task.TaskB', 'ram.test.ai.task.TaskC'], 'failureTasks' : { 'ram.test.ai.task.TaskB' : 'ram.test.ai.task.BRecovery', 'ram.test.ai.task.TaskC' : 'ram.test.ai.task.CRecovery' } }, 'StateMachine' : { 'States' : { 'ram.test.ai.task.TaskB' : { 'timeout' : TestTask.CFG_TIMEOUT } } } } support.AITestCase.setUp(self, cfg = cfg) # We have to import these from the global level, because for some # reason TaskA here != ram.test.ai.task.TaskA self.TaskAcls = resolve('ram.test.ai.task.TaskA') self.TaskBcls = resolve('ram.test.ai.task.TaskB') self.TaskCcls = resolve('ram.test.ai.task.TaskC') self.BRecoverycls = resolve('ram.test.ai.task.BRecovery') self.CRecoverycls = resolve('ram.test.ai.task.CRecovery')
def setUp(self): cfg = { 'Ai': { 'taskOrder': [ 'ram.test.ai.task.TaskA', 'ram.test.ai.task.TaskB', 'ram.test.ai.task.TaskC' ], 'failureTasks': { 'ram.test.ai.task.TaskB': 'ram.test.ai.task.BRecovery', 'ram.test.ai.task.TaskC': 'ram.test.ai.task.CRecovery' } }, 'StateMachine': { 'States': { 'ram.test.ai.task.TaskB': { 'timeout': TestTask.CFG_TIMEOUT } } } } support.AITestCase.setUp(self, cfg=cfg) # We have to import these from the global level, because for some # reason TaskA here != ram.test.ai.task.TaskA self.TaskAcls = resolve('ram.test.ai.task.TaskA') self.TaskBcls = resolve('ram.test.ai.task.TaskB') self.TaskCcls = resolve('ram.test.ai.task.TaskC') self.BRecoverycls = resolve('ram.test.ai.task.BRecovery') self.CRecoverycls = resolve('ram.test.ai.task.CRecovery')
def _recordEvent(self, event): if self._firstRun: self._startTime = timer.time() self._firstRun = False newEvent = RemoteAi.StateEvent() # Explicit cast necessary for Ice newEvent.timeStamp = long(event.timeStamp - self._startTime) newEvent.eventType = event.type # Find the state name fullClassName = str(event.string) # Recreate the class stateClass = resolve(fullClassName) if issubclass(stateClass, task.Task): # It's a task, make that the type newEvent.type = "Task" else: newEvent.type = "State" # Parse out the last name from the fullClassName newEvent.name = fullClassName.split('.')[-1] # Record this event in the adapter self._obj.RecordEvent(newEvent)
def main(argv=None): if argv is None: argv = sys.argv defaultConfigPath = os.path.abspath(os.path.join(os.environ["RAM_SVN_DIR"], "tools", "oci", "data", "transdec.yml")) parser = optparse.OptionParser() parser.add_option( "-c", "--config", dest="configPath", default=defaultConfigPath, help="The path to the config file" ) parser.add_option( "-s", "--state", dest="startState", default="ram.ai.course.Gate", help="The state we are starting with" ) (options, args) = parser.parse_args(argv) # Create our C++ app app = ext.core.Application(options.configPath) # Hackish way to grab state machine then start the vehicle stateMachine = app.getSubsystem("StateMachine") stateMachine.start(logloader.resolve(options.startState)) # stateMachine.start(ram.ai.buoySonarCourse.Gate) # stateMachine.start(ram.ai.buoyPipeSonarCourse.Gate) # stateMachine.start(ram.ai.sonar.Searching) # Run the main loop such that only the QueuedEventHub is being updated, # and its waits for events, basically leave all the CPU to other stuff # queuedEventHub = app.getSubsystem("QueuedEventHub") # queuedEventHub.setWaitUpdate(True) app.mainLoop(singleSubsystem=True)
def main(argv = None): if argv is None: argv = sys.argv defaultConfigPath = os.path.abspath( os.path.join(os.environ['RAM_SVN_DIR'], 'tools', 'oci', 'data', 'transdec.yml')) parser = optparse.OptionParser() parser.add_option("-c", "--config", dest = "configPath", default = defaultConfigPath, help = "The path to the config file") parser.add_option("-s", "--state", dest = "startState", default = "ram.ai.course.Gate", help = "The state we are starting with") (options, args) = parser.parse_args(argv) # Create our C++ app app = ext.core.Application(options.configPath) # Hackish way to grab state machine then start the vehicle stateMachine = app.getSubsystem("StateMachine") stateMachine.start(logloader.resolve(options.startState)) #stateMachine.start(ram.ai.buoySonarCourse.Gate) #stateMachine.start(ram.ai.buoyPipeSonarCourse.Gate) #stateMachine.start(ram.ai.sonar.Searching) # Run the main loop such that only the QueuedEventHub is being updated, # and its waits for events, basically leave all the CPU to other stuff #queuedEventHub = app.getSubsystem("QueuedEventHub") #queuedEventHub.setWaitUpdate(True) app.mainLoop(singleSubsystem = True)
def testEvents(self): enterRecv = Reciever() exitRecv = Reciever() completeRecv = Reciever() self.machine.subscribe(state.Machine.STATE_ENTERED, enterRecv) self.machine.subscribe(state.Machine.STATE_EXITED, exitRecv) self.machine.subscribe(state.Machine.COMPLETE, completeRecv) startState = self.machine.currentState() self.machine.injectEvent(self._makeEvent("Change")) nextState = self.machine.currentState() self.assertNotEqual(startState, nextState) # Check enter event nextStateName = '%s.%s' % (nextState.__class__.__module__, nextState.__class__.__name__) eventStr = enterRecv.event.string self.assertEquals(state.Machine.STATE_ENTERED, enterRecv.event.type) self.assertEquals(self.machine, enterRecv.event.sender) self.assertEquals(nextStateName, eventStr) # Ensure the state resolves to the proper state self.assertEqual(nextState.__class__, logloader.resolve(eventStr)) # Check exit event startStateName = '%s.%s' % (startState.__class__.__module__, startState.__class__.__name__) eventStr = exitRecv.event.string self.assertEquals(state.Machine.STATE_EXITED, exitRecv.event.type) self.assertEquals(self.machine, exitRecv.event.sender) self.assertEquals(startStateName, exitRecv.event.string) # Ensure the state resolves to the proper state self.assertEqual(startState.__class__, logloader.resolve(eventStr)) # Check completion event self.machine.injectEvent(self._makeEvent(MockEventSource.ANOTHER_EVT)) self.machine.injectEvent(self._makeEvent("Start")) self.assertEquals(state.Machine.COMPLETE, completeRecv.event.type) self.assertEquals(self.machine, completeRecv.event.sender)
def _configCheck(self, cfg): for name, options in cfg.iteritems(): if name != "INCLUDE" and name != "INCLUDE_LOADED": try: class_ = resolve(name) attr = class_.getattr() for item in options.iterkeys(): if item not in attr: raise Exception("'%s' is not in %s." % (item, class_)) except ImportError: raise ImportError("There is no class %s." % (name))
def generateMotion(dottedName, complete = False, **kwargs): class_ = resolve(dottedName) if not issubclass(class_, Motion): raise Exception('%s is not of type %s' % (class_, Motion)) if complete and not class_.willComplete(): raise Exception('%s is an incomplete motion. A complete' 'motion is required' % class_) # Generate an instance of the motion using kwargs try: return class_(**kwargs) except TypeError, e: raise TypeError('Not enough arguments for motion %s' % dottedName)
def generateMotion(dottedName, complete=False, **kwargs): class_ = resolve(dottedName) if not issubclass(class_, Motion): raise Exception('%s is not of type %s' % (class_, Motion)) if complete and not class_.willComplete(): raise Exception('%s is an incomplete motion. A complete' 'motion is required' % class_) # Generate an instance of the motion using kwargs try: return class_(**kwargs) except TypeError, e: raise TypeError('Not enough arguments for motion %s' % dottedName)
def __init__(self, qeventHub, publisher, eventType, propName, name, warning, critical): self._qeventHub = qeventHub self._publisher = publisher self._eventType = eventType self._property = propName self._name = name self._warning = warning self._critical = critical self._lastValue = 0 eventType = resolve(self._eventType) self._conn = self._qeventHub.subscribe(eventType, self._publisher, self._handler)
def __init__(self, cfg=None, deps=None): if deps is None: deps = [] if cfg is None: cfg = {} core.Subsystem.__init__(self, cfg.get('name', 'Ai'), deps) self._connections = [] # Gather all the state machines stateMachines = [] for d in deps: if isinstance(d, ai.state.Machine): stateMachines.append(d) # Find the main one self._stateMachine = None for m in stateMachines: if m.getName() == cfg.get('AIMachineName', 'StateMachine'): self._stateMachine = m break #assert (not (self._stateMachine is None)), "Could not find aistate machine" # Store inter state data self._data = {} self._data['config'] = cfg.get('config', {}) self._checkConfig(self._data['config']) # Build list of next states self._nextTaskMap = {} self._taskOrder = [] taskOrder = cfg.get('taskOrder', None) if taskOrder is None: taskOrder = [] for i, taskName in enumerate(taskOrder): # Determine which task is really next nextTask = 'ram.ai.task.End' if i != (len(taskOrder) - 1): nextTask = taskOrder[i + 1] # Resolve dotted task names into classes taskClass = resolve(taskName) nextClass = resolve(nextTask) # Store the results self._nextTaskMap[taskClass] = nextClass # Record the current class self._taskOrder.append(taskClass) # Build list of failure tasks self._failureTaskMap = {} failureTasks = cfg.get('failureTasks', None) if failureTasks is None: failureTasks = {} for taskName, failTaskName in failureTasks.iteritems(): # Resolve dotted task names into classes taskClass = resolve(taskName) failureTaskClass = resolve(failTaskName) # Store results self._failureTaskMap[taskClass] = failureTaskClass
def __init__(self, cfg = None, deps = None): if deps is None: deps = [] if cfg is None: cfg = {} core.Subsystem.__init__(self, cfg.get('name', 'Ai'), deps) self._connections = [] # Gather all the state machines stateMachines = [] for d in deps: if isinstance(d, ai.state.Machine): stateMachines.append(d) # Find the main one self._stateMachine = None for m in stateMachines: if m.getName() == cfg.get('AIMachineName', 'StateMachine'): self._stateMachine = m break #assert (not (self._stateMachine is None)), "Could not find aistate machine" # Store inter state data self._data = {} self._data['config'] = cfg.get('config', {}) self._checkConfig(self._data['config']) # Build list of next states self._nextTaskMap = {} self._taskOrder = [] taskOrder = cfg.get('taskOrder', None) if taskOrder is None: taskOrder = [] for i, taskName in enumerate(taskOrder): # Determine which task is really next nextTask = 'ram.ai.task.End' if i != (len(taskOrder) - 1): nextTask = taskOrder[i + 1] # Resolve dotted task names into classes taskClass = resolve(taskName) nextClass = resolve(nextTask) # Store the results self._nextTaskMap[taskClass] = nextClass # Record the current class self._taskOrder.append(taskClass) # Build list of failure tasks self._failureTaskMap = {} failureTasks = cfg.get('failureTasks', None) if failureTasks is None: failureTasks = {} for taskName, failTaskName in failureTasks.iteritems(): # Resolve dotted task names into classes taskClass = resolve(taskName) failureTaskClass = resolve(failTaskName) # Store results self._failureTaskMap[taskClass] = failureTaskClass