[Rock-dev] Prefix Extension for orogen deployments

[Chris Mueller]

Hi everyone,

i'm currently working on an extension for orogen deployments that allows
to start only specific tasks at runtime controlled by a prefix given via
command line arguments / argument vector.

The purpose for this extension is developing central deployments that
can be used for a multi-robot system and that is configurable at runtime 
(via
command arguments) for starting only a set of tasks of a specific 
robotic system
defined in an orogen deployment.

Unfortanetly this is not quite easy. I'm currently searching for
an elegant solution for this problem and would like to hear your advices
(especially it will affect a little the internal architecture for a 
deployment
executable and its relating deployment specification).

Here are some of my thoughts about this issue:

* Therefore we want to decide at runtime, which task should be started, we
need an instance of each task for all robotic systems in the 
deployment's main.cpp
template.

* No task should be started if a command line prefix is not set to specifiy
the current robot system. (I guess, this could be very badly if all 
tasks for all systems
are running on the same machine).

* We need a mapping in an orogen deployment file for specifing the task 
implementation
for a given prefix. Something like e.g.

map = { "sherpa" => "sherpa_simulation::Core", "crex" => 
"crex_simulation::Core" };

* At the beginning in a deployment executable the argument vector must 
be evaluated
and only the tasks matching the prefix should be started.

My current idea is to introduce a new singleton method for the 
deployment specification that
can automatically handle the mentioned prefix/implementation mapping.

prefixes = [:sherpa, :crex]

e.g. set = prefixed_taskset("simulation", "simulation::Core", prefixes)

would be equivalent to something like that:

sherpa_task = task("sherpa_simulation", "sherpa_simulation::Core")
crex_task = task("crex_simulation", "crex_simulation::Core")

--

Individual configuration would be done via a task map:   set[:sherpa]   
(equivalent to sherpa_task)

It should also be possible to use the same implementation for all tasks 
but with different configuration.

e.g. set = prefixed_taskset("monsterinterface", 
"monster::InterfaceModule", prefixes, :same_implementation)
# configure with set[:sherpa] and set[:crex]



Best Regards
Chris Müller