def test_update_epoch(self):
class Task(task.Task):
called = 0
def run(self):
self.called += 1
yield 0.1
self.called += 1
yield 0.1
self.called += 1
manager = task.TaskManager(12345.0)
t = Task()
manager.add(t)
assert t.called == 0
manager.update(12345.0)
assert t.called == 1
manager.update(12345.05)
assert t.called == 1
manager.update(12345.09)
assert t.called == 1
manager.update(12345.11)
assert t.called == 2
manager.update(12345.19)
assert t.called == 2
manager.update(12345.21)
assert t.called == 3
manager.update(12346.0)
assert t.called == 3
def test_add_remove(self):
class Task(task.Task):
called = 0
def run(self):
self.called += 1
yield 0.1
self.called += 1
t1 = Task()
t2 = Task()
manager = task.TaskManager(0.0)
t1_added = manager.add(t1)
t2_added = manager.add(t2)
assert t1_added is t1
assert t2_added is t2
assert t1.called == 0
assert t2.called == 0
manager.update(0.0)
assert t1.called == 1
assert t2.called == 1
manager.add(t1) # this must do nothing
manager.remove(t2)
manager.update(0.1)
assert t1.called == 2
assert t2.called == 1
manager.remove(t2) # this must do nothing
def test_custom_return_value(self):
def do_task(task):
yield 0.1
task.custom_value = 123
manager = task.TaskManager(0.0)
t = manager.add(do_task)
assert not (hasattr(t, 'custom_value'))
manager.update(0.2)
assert t.custom_value == 123
def __init__(self, config=ConfigData()):
tmp = sp.call("clear", shell=True)
print("TASKMASTER!!")
self.loop = False
# print (config.data)
self.task_list = task.TaskManager(create_tasks(config.data))
self.config = config
for process in config.data:
if config.data[process]["AUTO_S"] == "true":
self.start(process)
def test_exception(self):
def throws_exception(task):
yield 0.0
raise Exception()
manager = task.TaskManager(0.0)
t = manager.add(throws_exception)
# The TaskManager should not die, even if the task has thrown an
# exception.
manager.update(0.1)
assert not t.alive
assert not t.success
assert t.exception
def test_taskinfo(self):
def do_task(task):
assert task.count == 1
assert task.time < 0.1
yield 0.1
assert task.count == 2
assert task.time >= 0.1 and task.time < 0.11
last = task.time
yield 0.1
assert task.count == 3
assert task.time >= 0.2 and task.time < 0.21
assert (task.time - last) - task.dtime < 1.0e-5
manager = task.TaskManager(12345.0)
manager.add(do_task)
run_manager(manager, 0.5)
def test_blocking_task(self):
def blocking(task):
yield 3.0
def blocked(task, manager, param):
yield 1.0
param['stage'] = 1
t = manager.add(blocking)
param['blocking'] = t
yield t
param['stage'] = 2
yield 1.0
manager = task.TaskManager(0.0)
param = {'stage': 0, 'blocking': None}
t1 = manager.add(blocked, manager, param)
manager.update(0.0)
assert t1.running
assert param['stage'] == 0
manager.update(0.99)
assert t1.running
assert param['stage'] == 0
assert param['blocking'] is None
manager.update(1.01)
assert not t1.running
assert param['stage'] == 1
t2 = param['blocking']
assert t2 is not None
assert t2.running
assert t2.count == 1
manager.update(3.99)
assert not t1.running
assert t2.running
assert param['stage'] == 1
manager.update(4.01)
assert t1.running
assert not t2.running
assert not t2.alive
assert param['stage'] == 2
manager.update(4.99)
assert t1.running
assert t1.alive
assert param['stage'] == 2
manager.update(5.01)
assert not t1.running
assert not t1.alive
def test_propagate_exception(self):
def throws_exception(task):
yield 0.0
raise Exception()
def receives_exception(task, manager):
yield manager.add(throws_exception)
manager = task.TaskManager(0.0)
t = manager.add(receives_exception, manager)
manager.update(0.1)
assert not t.alive
assert not t.success
assert t.exception
assert not t.last_blocking.alive
assert not t.last_blocking.success
assert t.last_blocking.exception is t.exception
def test_add_return_value(self):
def do_task(task, l):
l[0] += 1
yield 0.1
l[0] += 1
yield 0.1
l[0] += 1
manager = task.TaskManager(0.0)
l = [0]
t = manager.add(do_task, l)
assert l[0] == 0
manager.update(0.0)
assert l[0] == 1
manager.update(0.1)
assert l[0] == 2
manager.remove(t)
manager.update(0.2)
assert l[0] == 2
def test_catch_propagated_exception(self):
def throws_exception(task):
yield 0.0
raise Exception()
def receives_exception(task, manager):
task.result = 0
try:
yield manager.add(throws_exception)
except Exception:
task.result = 123
manager = task.TaskManager(0.0)
t = manager.add(receives_exception, manager)
manager.update(0.1)
assert not t.alive
assert t.success
assert not t.last_blocking.alive
assert not t.last_blocking.success
assert t.result == 123
def test_pending_task(self):
def child(task):
yield 1.0
def parent(task, manager, param):
yield 1.0
t = manager.add(child)
param['child'] = t
yield 1.0
manager = task.TaskManager(0.0)
param = {'child': None}
t1 = manager.add(parent, manager, param)
assert t1.count == 0
manager.update(0.0)
assert t1.count == 1
manager.update(1.0)
assert t1.count == 2
t2 = param['child']
assert t2 is not None
assert t2.count == 1
def test_init(self):
def do_task(task, a, b, c, *args, **kwargs):
assert a == 123
assert b == 456.789
assert c == []
assert args == ('foo', 'bar', 'baz')
assert kwargs == {'apple': 12, 'orange': 34}
c.append('Done')
yield task.unit
manager = task.TaskManager(0.0)
c = []
manager.add(do_task,
123,
456.789,
c,
'foo',
'bar',
'baz',
apple=12,
orange=34)
manager.update(0.0)
assert c == ['Done']
def run():
# Unbuffer stdout
sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
parser = op.OptionParser(usage=__usage__, option_list=options())
opts, args = parser.parse_args()
if len(args) > 1:
parser.error("Invalid arguments: %s" % " ".join(args))
basedir = args[0] if len(args) else os.getcwd()
if opts.lib is not None:
sys.path.insert(0, opts.lib)
else:
libdir = os.path.join(basedir, "lib")
if os.path.isdir(libdir):
sys.path.insert(0, libdir)
configure_logging(opts)
cfg = load_config(basedir, opts.cfg)
mgr = task.TaskManager(cfg, basedir)
mgr.execute()
def test_finalize_removed(self):
class Task(task.Task):
finalized = False
def run(self, a, b, c):
assert a == 123
assert b == 456.789
assert c is None
yield 0.1
def finalize(self, a, b, c):
assert a == 123
assert b == 456.789
assert c is None
self.finalized = True
manager = task.TaskManager(0.0)
t = Task(123, 456.789, None)
manager.add(t)
assert not t.finalized
manager.update(0.0)
assert not t.finalized
manager.remove(t)
assert t.finalized
def test_suspend_resume_epoch(self):
class Task(task.Task):
def run(self):
yield 1.0
manager = task.TaskManager(12345.0)
t = Task()
manager.add(t)
assert t.running
manager.update(12345.0)
assert t.running
manager.update(12345.5)
assert t.running
t.suspend()
assert not t.running
manager.update(12346.5)
assert not t.running
t.resume()
assert t.running
manager.update(12346.99)
assert t.running
manager.update(12347.01)
assert not t.running
assert t.finished
def test_taskinfo(self):
class Task(task.Task):
finalized = False
def run(self):
assert self.count == 1
assert self.time < 0.1
yield 0.1
assert self.count == 2
assert self.time >= 0.1 and self.time < 0.11
last = self.time
yield 0.1
assert self.count == 3
assert self.time >= 0.2 and self.time < 0.21
assert (self.time - last) - self.dtime < 1.0e-5
def finalize(self):
self.finalized = True
manager = task.TaskManager(12345.0)
t = Task()
manager.add(t)
run_manager(manager, 0.5)
assert t.finalized
def test_last_blocking(self):
class BlockingTask(task.Task):
def run(self):
yield 0.1
class Task(task.Task):
def run(self, manager, blocking_task):
yield manager.add(blocking_task)
assert self.last_blocking is blocking_task
manager = task.TaskManager(0.0)
b = BlockingTask()
assert b.alive
t = Task(manager, b)
manager.add(t)
# Call manager.update() twice as a single call would not start running
# the blocking task.
# TODO: Consider running a blocking task immediately if the manager is
# the same.
manager.update(0.1)
manager.update(0.2)
assert not b.alive
assert b.success
assert t.last_blocking is b
def test_init_method(self):
class ClassA(object):
done = False
def do_task(self, task):
self.done = True
yield task.unit
class ClassB(object):
done = False
def do_task(self, task):
self.done = True
yield task.unit
manager = task.TaskManager(0.0)
a, b = ClassA(), ClassB()
manager.add(a.do_task)
manager.add(b.do_task)
assert not a.done
assert not b.done
manager.update(0.0)
assert a.done
assert b.done
def main(confidence=CONFIDENCE, responsiveness=RESPONSIVENESS):
'''Runs all the tasks required for Alto.
Uses a TaskManager to start the tasks, check that they are alive
and as a messaging bus.
Blinks the LED on any errors.
Emits:
System.started()
'''
task_manager = task.TaskManager()
GPIO.setmode(GPIO.BCM)
# Set up the LED first as it is used if there are any errors.
set_led = set_up_led(task_manager, LED_PIN)
try:
# Start the output tasks first and input tasks last.
# This should ensure that all the bindings are in place
# before the inputs are processed.
task_manager.start(imprint_engine.ImprintEngineTask, confidence,
responsiveness)
task_manager.start(servo_handler.ServoHandler, SERVO_CFG)
task_manager.start(ui.AltoUI)
task_manager.start(ButtonHandler)
set_up_buttons(task_manager, BUTTON_PINS)
# Indicate the system is ready by turning on the LED.
task_manager.emit('System.started')
set_led(1)
# Run forever
task_manager.process_messages()
except KeyboardInterrupt:
pass
except Exception as exc:
logging.exception('Error in main')
# Emit a blink error code
if isinstance(exc, picamera.PiCameraError):
# Camera problems are shown as two blinks.
blinks = 2
else:
# All other problems (most likely the TPU isn't conencted)
# are shown as three blinks.
blinks = 3
set_led(0)
time.sleep(1)
# Emit the pattern 10 times.
for _ in range(10):
for _ in range(blinks):
set_led(1)
time.sleep(0.15)
set_led(0)
time.sleep(0.10)
# Pause between sets.
time.sleep(0.5)
finally:
# Clean up the tasks and turn the LED off on exit.
task_manager.terminate()
set_led(0)
GPIO.cleanup()
