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 _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, 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
