def test_script_resolve_name():
from rosgraph.names import script_resolve_name, get_ros_namespace, ns_join
assert '/global' == script_resolve_name('/myscript', '/global')
val = script_resolve_name('/myscript', '')
assert get_ros_namespace() == val, val
val = script_resolve_name('/myscript', 'foo')
assert ns_join(get_ros_namespace(), 'foo') == val, val
assert '/myscript/private' == script_resolve_name('/myscript', '~private')
def _load_launch(self, launch, ros_config, is_core=False, filename=None, argv=None, verbose=True):
"""
subroutine of launch for loading XML DOM into config. Load_launch assumes that it is
creating the root XmlContext, and is thus affected by command-line arguments.
@param launch: DOM node of the root <launch> tag in the file
@type launch: L{Node}
@param ros_config: launch configuration to load XML file into
@type ros_config: L{ROSLaunchConfig}
@param is_core: (optional) if True, load file using ROS core rules. Default False.
@type is_core: bool
@param filename: (optional) name of file being loaded
@type filename: str
@param verbose: (optional) print verbose output. Default False.
@type verbose: bool
@param argv: (optional) command-line args. Default sys.argv.
"""
if argv is None:
argv = sys.argv
self._launch_tag(launch, ros_config, filename)
self.root_context = loader.LoaderContext(get_ros_namespace(), filename)
loader.load_sysargs_into_context(self.root_context, argv)
if len(launch.getElementsByTagName('master')) > 0:
print("WARNING: ignoring defunct <master /> tag", file=sys.stderr)
self._recurse_load(ros_config, launch.childNodes, self.root_context, None, is_core, verbose)
def _load_launch(self, launch, ros_config, is_core=False, filename=None, argv=None, verbose=True):
if argv is None:
argv = sys.argv
self._launch_tag(launch, ros_config, filename)
self.root_context = LaunchtreeContext(get_ros_namespace(), filename, config=ros_config)
loader.load_sysargs_into_context(self.root_context, argv)
if len(launch.getElementsByTagName('master')) > 0:
print "WARNING: ignoring defunct <master /> tag"
self._recurse_load(ros_config, launch.childNodes, self.root_context, None, is_core, verbose)
def load_str(str, filename, default_namespace=None, verbose=False):
"""
Load the YAML document as a string
:param filename: name of filename, only used for debugging, ``str``
:param default_namespace: namespace to load filename into, ``str``
:param str: YAML text, ``str``
:returns: list of parameter dictionary and
corresponding namespaces for each YAML document in the file, ``[(dict, str)...]``
"""
paramlist = []
default_namespace = default_namespace or get_ros_namespace()
for doc in yaml.load_all(str):
if NS in doc:
ns = ns_join(default_namespace, doc.get(NS, None))
if verbose:
print("reading parameters into namespace [%s]"%ns)
del doc[NS]
else:
ns = default_namespace
paramlist.append((doc, ns))
return paramlist
def load_str(str, filename, default_namespace=None, verbose=False):
"""
Load the YAML document as a string
:param filename: name of filename, only used for debugging, ``str``
:param default_namespace: namespace to load filename into, ``str``
:param str: YAML text, ``str``
:returns: list of parameter dictionary and
corresponding namespaces for each YAML document in the file, ``[(dict, str)...]``
"""
paramlist = []
default_namespace = default_namespace or get_ros_namespace()
for doc in yaml.load_all(str):
if NS in doc:
ns = ns_join(default_namespace, doc.get(NS, None))
if verbose:
print("reading parameters into namespace [%s]" % ns)
del doc[NS]
else:
ns = default_namespace
paramlist.append((doc, ns))
return paramlist
@rtype: str
"""
def validator(param_value, caller_id):
if not param_value or not isstring(param_value):
raise ParameterInvalid("ERROR: parameter [%s] must be a non-empty string"%param_name)
#TODO: actual validation of chars
if not is_global(param_value):
raise ParameterInvalid("ERROR: parameter [%s] must be a globally referenced name"%param_name)
return param_value
return validator
#########################################################
#Global Namespace Routines
# - Global state, e.g. singletons and namespace
_caller_namespace = get_ros_namespace()
_caller_id = _caller_namespace+'unnamed' #default for non-node.
def get_namespace():
"""
Get namespace of local node.
@return: fully-qualified name of local node or '' if not applicable
@rtype: str
"""
return _caller_namespace
def get_name():
"""
Get fully resolved name of local node. If this is not a node,
use empty string
@return: fully-qualified name of local node or '' if not applicable
def test_get_ros_namespace():
if 'ROS_NAMESPACE' in os.environ:
rosns = os.environ['ROS_NAMESPACE']
del os.environ['ROS_NAMESPACE']
else:
rosns = None
sysargv = sys.argv
from rosgraph.names import get_ros_namespace
try:
sys.argv = []
assert '/' == get_ros_namespace()
assert '/' == get_ros_namespace(argv=[])
assert '/' == get_ros_namespace(env={})
assert '/' == get_ros_namespace(env={}, argv=[])
os.environ['ROS_NAMESPACE'] = 'unresolved'
assert '/unresolved/' == get_ros_namespace()
assert '/unresolved/' == get_ros_namespace(
env={'ROS_NAMESPACE': 'unresolved'})
sys.argv = ['foo', '__ns:=unresolved_override']
assert '/unresolved_override/' == get_ros_namespace(
env={'ROS_NAMESPACE': 'unresolved'})
assert '/override2/' == get_ros_namespace(
env={'ROS_NAMESPACE': 'unresolved'},
argv=['foo', '__ns:=override2'])
sys.argv = []
os.environ['ROS_NAMESPACE'] = '/resolved/'
assert '/resolved/' == get_ros_namespace()
assert '/resolved/' == get_ros_namespace(
env={'ROS_NAMESPACE': '/resolved'})
del os.environ['ROS_NAMESPACE']
sys.argv = ['foo', '__ns:=unresolved_ns']
assert '/unresolved_ns/' == get_ros_namespace()
assert '/unresolved_ns2/' == get_ros_namespace(
argv=['foo', '__ns:=unresolved_ns2'])
sys.argv = ['foo', '__ns:=/resolved_ns/']
assert '/resolved_ns/' == get_ros_namespace()
assert '/resolved_ns2/' == get_ros_namespace(
argv=['foo', '__ns:=resolved_ns2'])
finally:
sys.argv = sysargv
# restore
if rosns:
os.environ['ROS_NAMESPACE'] = rosns
@rtype: str
"""
def validator(param_value, caller_id):
if not param_value or not isstring(param_value):
raise ParameterInvalid("ERROR: parameter [%s] must be a non-empty string"%param_name)
#TODO: actual validation of chars
if not is_global(param_value):
raise ParameterInvalid("ERROR: parameter [%s] must be a globally referenced name"%param_name)
return param_value
return validator
#########################################################
#Global Namespace Routines
# - Global state, e.g. singletons and namespace
_caller_namespace = get_ros_namespace()
_caller_id = _caller_namespace+'unnamed' #default for non-node.
def get_namespace():
"""
Get namespace of local node.
@return: fully-qualified name of local node or '' if not applicable
@rtype: str
"""
return _caller_namespace
def get_name():
"""
Get fully resolved name of local node. If this is not a node,
use empty string
@return: fully-qualified name of local node or '' if not applicable
def test_get_ros_namespace():
if 'ROS_NAMESPACE' in os.environ:
rosns = os.environ['ROS_NAMESPACE']
del os.environ['ROS_NAMESPACE']
else:
rosns = None
sysargv = sys.argv
from rosgraph.names import get_ros_namespace
try:
sys.argv = []
assert '/' == get_ros_namespace()
assert '/' == get_ros_namespace(argv=[])
assert '/' == get_ros_namespace(env={})
assert '/' == get_ros_namespace(env={}, argv=[])
os.environ['ROS_NAMESPACE'] = 'unresolved'
assert '/unresolved/' == get_ros_namespace()
assert '/unresolved/' == get_ros_namespace(env={'ROS_NAMESPACE': 'unresolved'})
sys.argv = ['foo', '__ns:=unresolved_override']
assert '/unresolved_override/' == get_ros_namespace(env={'ROS_NAMESPACE': 'unresolved'})
assert '/override2/' == get_ros_namespace(env={'ROS_NAMESPACE': 'unresolved'}, argv=['foo', '__ns:=override2'])
sys.argv = []
os.environ['ROS_NAMESPACE'] = '/resolved/'
assert '/resolved/' == get_ros_namespace()
assert '/resolved/' == get_ros_namespace(env={'ROS_NAMESPACE': '/resolved'})
del os.environ['ROS_NAMESPACE']
sys.argv = ['foo', '__ns:=unresolved_ns']
assert '/unresolved_ns/' == get_ros_namespace()
assert '/unresolved_ns2/' == get_ros_namespace(argv=['foo', '__ns:=unresolved_ns2'])
sys.argv = ['foo', '__ns:=/resolved_ns/']
assert '/resolved_ns/' == get_ros_namespace()
assert '/resolved_ns2/' == get_ros_namespace(argv=['foo', '__ns:=resolved_ns2'])
finally:
sys.argv = sysargv
# restore
if rosns:
os.environ['ROS_NAMESPACE'] = rosns
