def test_setup_env(self):
from roslaunch.core import setup_env, Node, Machine
master_uri = 'http://masteruri:1234'
n = Node('nodepkg', 'nodetype')
m = Machine('name1', '1.2.3.4')
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
m = Machine('name1', '1.2.3.4')
d = setup_env(n, m, master_uri)
val = os.environ['ROS_ROOT']
self.assertEquals(d['ROS_ROOT'], val)
# test ROS_NAMESPACE
# test stripping
n = Node('nodepkg', 'nodetype', namespace="/ns2/")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns2")
# test node.env_args
n = Node('nodepkg',
'nodetype',
env_args=[('NENV1', 'val1'), ('NENV2', 'val2'),
('ROS_ROOT', '/new/root')])
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root")
self.assertEquals(d['NENV1'], "val1")
self.assertEquals(d['NENV2'], "val2")
def handle_spawn_vehicle(self, req):
"""
Spawn new vehicle.
This includes starting a new vehicle node and (if a looping node is
set) calling its /set_loop service, as well as its /toggle_simulation
service.
@param req: I{(SpawnVehicle)} Request messgae of the service that
spawns a new vehicle.
"""
namespace = "vehicle_" + str(req.vehicle_id)
args = "%i %s %f %f %f %f" % (req.vehicle_id, req.class_name, req.x,
req.y, req.yaw, req.v)
node = Node('sml_world',
'vehicle.py',
namespace=namespace,
args=args,
name=req.class_name.lower())
self.launch_queue.put(node)
loop_service = '/' + namespace + '/set_loop'
rospy.wait_for_service(loop_service)
if bool(req.node_id):
try:
set_loop = rospy.ServiceProxy(loop_service, SetLoop)
set_loop(req.node_id)
except rospy.ServiceException, e:
raise "Service call failed: %s" % e
def test_local_process_stop_timeouts(self):
from roslaunch.core import Node, Machine
# have to use real ROS configuration for these tests
ros_root = os.environ['ROS_ROOT']
rpp = os.environ.get('ROS_PACKAGE_PATH', None)
master_uri = 'http://masteruri:1234'
m = Machine('name1', ros_root, rpp, '1.2.3.4')
run_id = 'id'
n = Node('roslaunch', 'signal_logger.py')
n.name = 'logger'
n.machine = m
self.check_stop_timeouts(master_uri, n, run_id, 1.0, 1.0)
self.check_stop_timeouts(master_uri, n, run_id, 0.00001, 1.0)
# shorter sigterm times are risky in the test - the signal file might not get written; but in the wild, it's ok
self.check_stop_timeouts(master_uri, n, run_id, 1.0, 0.001)
self.check_stop_timeouts(master_uri, n, run_id, 2.0, 3.0)
def launch_coms(self):
"""Launch and register the communications used by the vehicle."""
# Go through list of comunication.
for com in self.coms:
com_name = com.partition(' ')[0]
subpub_name = com_name.lower() + '_com'
args = str(self.vehicle_id) + ' ' + com
node = Node('sml_world',
'communication.py',
namespace=self.namespace,
args=args,
name=com_name.lower())
self.launcher.launch(node)
# Register subscriptions for each of them.
rospy.Subscriber(self.namespace + subpub_name,
getattr(msgs, com_name + 'Com'),
getattr(self, 'process_' + subpub_name))
def launch_sensors(self):
"""Launch and register the sensors used by the vehicle."""
# Go through sensor list.
for sensor in self.sensors:
# Launch sensor node.
sensor_name = sensor.partition(' ')[0]
subpub_name = sensor_name.lower() + '_readings'
args = str(self.vehicle_id) + ' ' + sensor
node = Node('sml_world',
'sensor.py',
namespace=self.namespace,
args=args,
name=sensor_name.lower())
self.launcher.launch(node)
# Register subscriptions for each of them.
rospy.Subscriber(self.namespace + subpub_name,
getattr(msgs, sensor_name + 'Readings'),
getattr(self, 'process_' + subpub_name))
def test_create_node_process(self):
from roslaunch.core import Node, Machine, RLException
from roslaunch.node_args import NodeParamsException
from roslaunch.nodeprocess import create_node_process, LocalProcess
# have to use real ROS configuration for these tests
ros_root = os.environ['ROS_ROOT']
rpp = os.environ.get('ROS_PACKAGE_PATH', None)
master_uri = 'http://masteruri:1234'
m = Machine('name1', ros_root, rpp, '1.2.3.4')
run_id = 'id'
# test invalid params
n = Node('not_a_real_package','not_a_node')
n.machine = m
n.name = 'foo'
try: # should fail b/c node cannot be found
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except NodeParamsException:
pass
# have to specify a real node
n = Node('rospy','talker.py')
n.machine = m
try: # should fail b/c n.name is not set
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except ValueError:
pass
# have to specify a real node
n = Node('rospy','talker.py')
n.machine = None
n.name = 'talker'
try: # should fail b/c n.machine is not set
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except RLException:
pass
# basic integration test
n.machine = m
p = create_node_process(run_id, n, master_uri)
self.assert_(isinstance(p, LocalProcess))
# repeat some setup_local_process_env tests
d = p.env
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'], os.environ['PYTHONPATH'])
if rpp:
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s'%(k,d[k]))
# test package and name
self.assertEquals(p.package, 'rospy')
# - no 'correct' full answer here
self.assert_(p.name.startswith('talker'), p.name)
# test log_output
n.output = 'log'
self.assert_(create_node_process(run_id, n, master_uri).log_output)
n.output = 'screen'
self.failIf(create_node_process(run_id, n, master_uri).log_output)
# test respawn
n.respawn = True
self.assert_(create_node_process(run_id, n, master_uri).respawn)
n.respawn = False
self.failIf(create_node_process(run_id, n, master_uri).respawn)
# test cwd
n.cwd = None
self.assertEquals(create_node_process(run_id, n, master_uri).cwd, None)
n.cwd = 'ros-root'
self.assertEquals(create_node_process(run_id, n, master_uri).cwd, 'ros-root')
n.cwd = 'node'
self.assertEquals(create_node_process(run_id, n, master_uri).cwd, 'node')
# test args
# - simplest test (no args)
n.args = ''
p = create_node_process(run_id, n, master_uri)
# - the first arg should be the path to the node executable
rospack = rospkg.RosPack()
cmd = roslib.packages.find_node('rospy', 'talker.py', rospack)[0]
self.assertEquals(p.args[0], cmd)
# - test basic args
n.args = "arg1 arg2 arg3"
p = create_node_process(run_id, n, master_uri)
self.assertEquals(p.args[0], cmd)
for a in "arg1 arg2 arg3".split():
self.assert_(a in p.args)
# - test remap args
n.remap_args = [('KEY1', 'VAL1'), ('KEY2', 'VAL2')]
p = create_node_process(run_id, n, master_uri)
self.assert_('KEY1:=VAL1' in p.args)
self.assert_('KEY2:=VAL2' in p.args)
# - test __name
n = Node('rospy','talker.py')
n.name = 'fooname'
n.machine = m
self.assert_('__name:=fooname' in create_node_process(run_id, n, master_uri).args)
# - test substitution args
os.environ['SUB_TEST'] = 'subtest'
os.environ['SUB_TEST2'] = 'subtest2'
n.args = 'foo $(env SUB_TEST) $(env SUB_TEST2)'
p = create_node_process(run_id, n, master_uri)
self.failIf('SUB_TEST' in p.args)
self.assert_('foo' in p.args)
self.assert_('subtest' in p.args)
self.assert_('subtest2' in p.args)
def test_create_local_process_env(self):
# this is almost entirely identical to the setup_env test in test_core, with some additional
# higher level checks
from roslaunch.core import Node, Machine
from roslaunch.node_args import create_local_process_env
ros_root = '/ros/root1'
rpp = '/rpp1'
master_uri = 'http://masteruri:1234'
n = Node('nodepkg','nodetype')
m = Machine('name1', ros_root, rpp, '1.2.3.4')
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'], os.path.join(ros_root, 'core', 'roslib', 'src'))
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s'%(k,d[k]))
# test that it inherits local environment
env = os.environ.copy()
env['PATH'] = '/some/path'
env['FOO'] = 'foo'
d = create_local_process_env(n, m, master_uri, env=env)
self.assertEquals(d['FOO'], 'foo')
# test that it defaults to os.environ
os.environ['FOO'] = 'bar'
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['FOO'], 'bar')
# test that our ROS_ROOT and PYTHONPATH override env
env = os.environ.copy()
env['ROS_ROOT'] = '/not/ros/root/'
env['PYTHONPATH'] = '/some/path'
d = create_local_process_env(n, m, master_uri, env=env)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'], os.path.join(ros_root, 'core', 'roslib', 'src'))
# - make sure it didn't pollute original env
self.assertEquals(env['ROS_ROOT'], '/not/ros/root/')
self.assertEquals(env['PYTHONPATH'], '/some/path')
# don't set ROS_ROOT and ROS_PACKAGE_PATH. ROS_ROOT should default, ROS_PACKAGE_PATH does not
m = Machine('name1', '', '', '1.2.3.4')
d = create_local_process_env(n, m, master_uri)
val = os.environ['ROS_ROOT']
self.assertEquals(d['ROS_ROOT'], val)
self.assertEquals(d['PYTHONPATH'], os.path.join(val, 'core', 'roslib', 'src'))
self.failIf('ROS_PACKAGE_PATH' in d, 'ROS_PACKAGE_PATH should not be set: %s'%d)
# test ROS_IP
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
n = Node('nodepkg','nodetype', namespace="/ns1")
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns1")
# test stripping
n = Node('nodepkg','nodetype', namespace="/ns2/")
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns2")
# test ROS_NAMESPACE
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_IP'], "4.5.6.7")
# test node.env_args
n = Node('nodepkg','nodetype', env_args=[('NENV1', 'val1'), ('NENV2', 'val2'), ('ROS_ROOT', '/new/root')])
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root")
self.assertEquals(d['NENV1'], "val1")
self.assertEquals(d['NENV2'], "val2")
# test machine.env_args
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2'), ('ROS_ROOT', '/new/root2')])
n = Node('nodepkg','nodetype')
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root2")
self.assertEquals(d['MENV1'], "val1")
self.assertEquals(d['MENV2'], "val2")
# test node.env_args precedence
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2')])
n = Node('nodepkg','nodetype', env_args=[('MENV1', 'nodeval1')])
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['MENV1'], "nodeval1")
self.assertEquals(d['MENV2'], "val2")
def test_create_node_process(self):
from roslaunch.core import Node, Machine, RLException
from roslaunch.node_args import NodeParamsException
from roslaunch.nodeprocess import create_node_process, LocalProcess
# have to use real ROS configuration for these tests
ros_root = os.environ['ROS_ROOT']
rpp = os.environ.get('ROS_PACKAGE_PATH', None)
master_uri = 'http://masteruri:1234'
m = Machine('name1', ros_root, rpp, '1.2.3.4')
run_id = 'id'
# test invalid params
n = Node('not_a_real_package', 'not_a_node')
n.machine = m
n.name = 'foo'
try: # should fail b/c node cannot be found
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except NodeParamsException:
pass
# have to specify a real node
n = Node('roslaunch', 'talker.py')
n.machine = m
try: # should fail b/c n.name is not set
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except ValueError:
pass
# have to specify a real node
n = Node('roslaunch', 'talker.py')
n.machine = None
n.name = 'talker'
try: # should fail b/c n.machine is not set
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except RLException:
pass
# basic integration test
n.machine = m
p = create_node_process(run_id, n, master_uri)
self.assert_(isinstance(p, LocalProcess))
# repeat some setup_local_process_env tests
d = p.env
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'], os.environ['PYTHONPATH'])
if rpp:
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s' % (k, d[k]))
# test package and name
self.assertEquals(p.package, 'roslaunch')
# - no 'correct' full answer here
self.assert_(p.name.startswith('talker'), p.name)
# test log_output
n.output = 'log'
self.assert_(create_node_process(run_id, n, master_uri).log_output)
n.output = 'screen'
self.failIf(create_node_process(run_id, n, master_uri).log_output)
# test respawn
n.respawn = True
self.assert_(create_node_process(run_id, n, master_uri).respawn)
n.respawn = False
self.failIf(create_node_process(run_id, n, master_uri).respawn)
# test cwd
n.cwd = None
self.assertEquals(create_node_process(run_id, n, master_uri).cwd, None)
n.cwd = 'ros-root'
self.assertEquals(
create_node_process(run_id, n, master_uri).cwd, 'ros-root')
n.cwd = 'node'
self.assertEquals(
create_node_process(run_id, n, master_uri).cwd, 'node')
# sigint timeout
self.assertEquals(
create_node_process(run_id, n, master_uri).sigint_timeout, 15)
self.assertEquals(
create_node_process(run_id, n, master_uri,
sigint_timeout=1).sigint_timeout, 1)
self.assertRaises(RLException,
create_node_process,
run_id,
n,
master_uri,
sigint_timeout=0)
# sigterm timeout
self.assertEquals(
create_node_process(run_id, n, master_uri).sigterm_timeout, 2)
self.assertEquals(
create_node_process(run_id, n, master_uri,
sigterm_timeout=1).sigterm_timeout, 1)
self.assertRaises(RLException,
create_node_process,
run_id,
n,
master_uri,
sigterm_timeout=0)
# test args
# - simplest test (no args)
n.args = ''
p = create_node_process(run_id, n, master_uri)
# - the first arg should be the path to the node executable
rospack = rospkg.RosPack()
cmd = roslib.packages.find_node('roslaunch', 'talker.py', rospack)[0]
self.assertEquals(p.args[0], cmd)
# - test basic args
n.args = "arg1 arg2 arg3"
p = create_node_process(run_id, n, master_uri)
self.assertEquals(p.args[0], cmd)
for a in "arg1 arg2 arg3".split():
self.assert_(a in p.args)
# - test remap args
n.remap_args = [('KEY1', 'VAL1'), ('KEY2', 'VAL2')]
p = create_node_process(run_id, n, master_uri)
self.assert_('KEY1:=VAL1' in p.args)
self.assert_('KEY2:=VAL2' in p.args)
# - test __name
n = Node('roslaunch', 'talker.py')
n.name = 'fooname'
n.machine = m
self.assert_('__name:=fooname' in create_node_process(
run_id, n, master_uri).args)
# - test substitution args
os.environ['SUB_TEST'] = 'subtest'
os.environ['SUB_TEST2'] = 'subtest2'
n.args = 'foo $(env SUB_TEST) $(env SUB_TEST2)'
p = create_node_process(run_id, n, master_uri)
self.failIf('SUB_TEST' in p.args)
self.assert_('foo' in p.args)
self.assert_('subtest' in p.args)
self.assert_('subtest2' in p.args)
def test_Node():
from roslaunch.core import Node
n = Node('package', 'node_type')
assert n.package == 'package'
assert n.type == 'node_type'
assert n.xmltype() == 'node'
assert n.xmlattrs() == [('pkg', 'package'), ('type', 'node_type'),
('machine', None), ('ns', '/'), ('args', ''), ('output', None),
('cwd', None), ('respawn', False), ('respawn_delay', 0.0),
('name', None), ('launch-prefix', None), ('required', False)], \
n.xmlattrs()
assert n.output == None
#tripwire for now
n.to_xml()
val = n.to_remote_xml()
assert 'machine' not in val
# test bad constructors
try:
n = Node('package', 'node_type', cwd='foo')
assert False
except ValueError:
pass
try:
n = Node('package', 'node_type', output='foo')
assert False
except ValueError:
pass
try:
n = Node('package', '')
assert False
except ValueError:
pass
try:
n = Node('', 'node_type')
assert False
except ValueError:
pass
try:
n = Node('package', 'node_type', name='ns/node')
assert False
except ValueError:
pass
try:
n = Node('package', 'node_type', respawn=True, required=True)
assert False
except ValueError:
pass
def _node_tag(self, tag, context, ros_config, default_machine, is_test=False, verbose=True):
"""
Process XML <node> or <test> tag
@param tag: DOM node
@type tag: Node
@param context: namespace context
@type context: L{LoaderContext}
@param params: ROS parameter list
@type params: [L{Param}]
@param clear_params: list of ROS parameter names to clear before setting parameters
@type clear_params: [str]
@param default_machine: default machine to assign to node
@type default_machine: str
@param is_test: if set, will load as L{Test} object instead of L{Node} object
@type is_test: bool
"""
try:
if is_test:
self._check_attrs(tag, context, ros_config, XmlLoader.TEST_ATTRS)
(name,) = self.opt_attrs(tag, context, ('name',))
test_name, time_limit, retry = self._test_attrs(tag, context)
if not name:
name = test_name
else:
self._check_attrs(tag, context, ros_config, XmlLoader.NODE_ATTRS)
(name,) = self.reqd_attrs(tag, context, ('name',))
if not roslib.names.is_legal_name(name):
ros_config.add_config_error("WARN: illegal <node> name '%s'.\nhttp://ros.org/wiki/Names\nThis will likely cause problems with other ROS tools.\nNode xml is %s"%(name, tag.toxml()))
child_ns = self._ns_clear_params_attr('node', tag, context, ros_config, node_name=name)
param_ns = child_ns.child(name)
# required attributes
pkg, node_type = self.reqd_attrs(tag, context, ('pkg', 'type'))
# optional attributes
machine, args, output, respawn, cwd, launch_prefix, required = \
self.opt_attrs(tag, context, ('machine', 'args', 'output', 'respawn', 'cwd', 'launch-prefix', 'required'))
if tag.hasAttribute('machine') and not len(machine.strip()):
raise XmlParseException("<node> 'machine' must be non-empty: [%s]"%machine)
if not machine and default_machine:
machine = default_machine.name
# validate respawn, required
required, respawn = [_bool_attr(*rr) for rr in ((required, False, 'required'),\
(respawn, False, 'respawn'))]
# each node gets its own copy of <remap> arguments, which
# it inherits from its parent
remap_context = context.child('')
# nodes can have individual env args set in addition to
# the ROS-specific ones.
for t in [c for c in tag.childNodes if c.nodeType == DomNode.ELEMENT_NODE]:
tag_name = t.tagName.lower()
if tag_name == 'remap':
r = self._remap_tag(t, context, ros_config)
if r is not None:
remap_context.add_remap(r)
elif tag_name == 'param':
self._param_tag(t, param_ns, ros_config, force_local=True, verbose=verbose)
elif tag_name == 'rosparam':
self._rosparam_tag(t, param_ns, ros_config, verbose=verbose)
elif tag_name == 'env':
self._env_tag(t, context, ros_config)
else:
ros_config.add_config_error("WARN: unrecognized '%s' tag in <node> tag. Node xml is %s"%(t.tagName, tag.toxml()))
# #1036 evaluate all ~params in context
# TODO: can we get rid of force_local (above), remove this for loop, and just rely on param_tag logic instead?
for p in itertools.chain(context.params, param_ns.params):
pkey = p.key
if is_private(pkey):
# strip leading ~, which is optional/inferred
pkey = pkey[1:]
pkey = param_ns.ns + pkey
ros_config.add_param(Param(pkey, p.value), verbose=verbose)
if not is_test:
return Node(pkg, node_type, name=name, namespace=child_ns.ns, machine_name=machine,
args=args, respawn=respawn,
remap_args=remap_context.remap_args(), env_args=context.env_args,
output=output, cwd=cwd, launch_prefix=launch_prefix,
required=required, filename=context.filename)
else:
return Test(test_name, pkg, node_type, name=name, namespace=child_ns.ns,
machine_name=machine, args=args,
remap_args=remap_context.remap_args(), env_args=context.env_args,
time_limit=time_limit, cwd=cwd, launch_prefix=launch_prefix,
retry=retry, filename=context.filename)
except KeyError, e:
raise XmlParseException(
"<%s> tag is missing required attribute: %s. Node xml is %s"%(tag.tagName, e, tag.toxml()))
def test_setup_env(self):
from roslaunch.core import setup_env, Node, Machine
ros_root = '/ros/root1'
rpp = '/rpp1'
master_uri = 'http://masteruri:1234'
n = Node('nodepkg','nodetype')
m = Machine('name1', ros_root, rpp, '1.2.3.4')
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'], os.path.join(ros_root, 'core', 'roslib', 'src'))
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s'%(k,d[k]))
# don't set ROS_ROOT and ROS_PACKAGE_PATH. ROS_ROOT should default, ROS_PACKAGE_PATH does not
m = Machine('name1', '', '', '1.2.3.4')
d = setup_env(n, m, master_uri)
val = os.environ['ROS_ROOT']
self.assertEquals(d['ROS_ROOT'], val)
self.assertEquals(d['PYTHONPATH'], os.path.join(val, 'core', 'roslib', 'src'))
self.failIf('ROS_PACKAGE_PATH' in d, 'ROS_PACKAGE_PATH should not be set: %s'%d)
# test ROS_IP
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
n = Node('nodepkg','nodetype', namespace="/ns1")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns1")
# test stripping
n = Node('nodepkg','nodetype', namespace="/ns2/")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns2")
# test ROS_NAMESPACE
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_IP'], "4.5.6.7")
# test node.env_args
n = Node('nodepkg','nodetype', env_args=[('NENV1', 'val1'), ('NENV2', 'val2'), ('ROS_ROOT', '/new/root')])
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root")
self.assertEquals(d['NENV1'], "val1")
self.assertEquals(d['NENV2'], "val2")
# test machine.env_args
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2'), ('ROS_ROOT', '/new/root2')])
n = Node('nodepkg','nodetype')
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root2")
self.assertEquals(d['MENV1'], "val1")
self.assertEquals(d['MENV2'], "val2")
# test node.env_args precedence
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2')])
n = Node('nodepkg','nodetype', env_args=[('MENV1', 'nodeval1')])
d = setup_env(n, m, master_uri)
self.assertEquals(d['MENV1'], "nodeval1")
self.assertEquals(d['MENV2'], "val2")
def test_Node():
from roslaunch.core import Node
n = Node("package", "node_type")
assert n.package == "package"
assert n.type == "node_type"
assert n.xmltype() == "node"
assert n.xmlattrs() == [
("pkg", "package"),
("type", "node_type"),
("machine", None),
("ns", "/"),
("args", ""),
("output", None),
("cwd", None),
("respawn", False),
("respawn_delay", 0.0),
("name", None),
("launch-prefix", None),
("required", False),
], n.xmlattrs()
assert n.output == None
# tripwire for now
n.to_xml()
val = n.to_remote_xml()
assert "machine" not in val
# test bad constructors
try:
n = Node("package", "node_type", cwd="foo")
assert False
except ValueError:
pass
try:
n = Node("package", "node_type", output="foo")
assert False
except ValueError:
pass
try:
n = Node("package", "")
assert False
except ValueError:
pass
try:
n = Node("", "node_type")
assert False
except ValueError:
pass
try:
n = Node("package", "node_type", name="ns/node")
assert False
except ValueError:
pass
try:
n = Node("package", "node_type", respawn=True, required=True)
assert False
except ValueError:
pass
def test_Node():
from roslaunch.core import Node
n = Node('package', 'node_type')
assert n.package == 'package'
assert n.type == 'node_type'
assert n.xmltype() == 'node'
assert n.xmlattrs() == [('pkg', 'package'), ('type', 'node_type'), ('machine', None), ('ns', '/'), ('args', ''), ('output', None), ('cwd', None), ('respawn', False), ('name', None), ('launch-prefix', None), ('required', False)], n.xmlattrs()
assert n.output == None
#tripwire for now
n.to_xml()
val = n.to_remote_xml()
assert 'machine' not in val
# test bad constructors
try:
n = Node('package', 'node_type', cwd='foo')
assert False
except ValueError:
pass
try:
n = Node('package', 'node_type', output='foo')
assert False
except ValueError:
pass
try:
n = Node('package', '')
assert False
except ValueError:
pass
try:
n = Node('', 'node_type')
assert False
except ValueError:
pass
try:
n = Node('package', 'node_type', name='ns/node')
assert False
except ValueError:
pass
try:
n = Node('package', 'node_type', respawn=True, required=True)
assert False
except ValueError:
pass
