def test_use_sim_time_parameter():
with DirectNode(args=[], node_name=TEST_NODE_NAME) as direct_node:
assert not direct_node.node.get_parameter('use_sim_time').value
args = argparse.Namespace(use_sim_time=False)
with DirectNode(args, node_name=TEST_NODE_NAME) as direct_node:
assert not direct_node.node.get_parameter('use_sim_time').value
def __init__(self, args):
use_daemon = not getattr(args, 'no_daemon', False)
if use_daemon and is_daemon_running(args):
self.node = DaemonNode(args)
else:
if use_daemon:
spawn_daemon(args)
self.node = DirectNode(args)
def reset_if_addresses_changed(self):
new_addresses = get_interfaces_ip_addresses()
if new_addresses != self.addresses_at_start:
self.addresses_at_start = new_addresses
self.node.destroy_node()
rclpy.shutdown()
self.node = DirectNode(self.args)
self.node.__enter__()
print('Daemon node was reset')
def __init__(self, args):
use_daemon = not getattr(args, 'no_daemon', False)
if use_daemon and is_daemon_running(args):
self._daemon_node = DaemonNode(args)
self._direct_node = None
else:
if use_daemon:
spawn_daemon(args)
self._direct_node = DirectNode(args)
self._daemon_node = None
self._args = args
self._in_scope = False
class DaemonNode:
def __init__(self, args):
self._args = args
self._proxy = ServerProxy('http://localhost:%d/ros2cli/' %
get_daemon_port(),
allow_none=True)
self._methods = []
def __enter__(self):
self._proxy.__enter__()
try:
methods = self._proxy.system.listMethods()
except ProtocolError as e:
if e.errcode != 404:
raise
# remote daemon returned 404, likely using different rmw impl.
self._proxy.__exit__()
# fall back to use direct node
self._proxy = DirectNode(self._args)
self._proxy.__enter__()
else:
self._methods = [m for m in methods if not m.startswith('system.')]
return self
def __getattr__(self, name):
return getattr(self._proxy, name)
def __exit__(self, exc_type, exc_value, traceback):
self._proxy.__exit__(exc_type, exc_value, traceback)
class NetworkAwareNode:
"""A direct node, that resets itself when a network interface changes."""
def __init__(self, args):
self.args = args
# TODO(ivanpauno): A race condition is possible here, since it isn't possible to know
# exactly which interfaces were available at node creation.
self.node = DirectNode(args)
self.addresses_at_start = get_interfaces_ip_addresses()
def __enter__(self):
self.node.__enter__()
return self
def __getattr__(self, name):
attr = getattr(self.node, name)
if inspect.ismethod(attr):
return before_invocation(attr, self.reset_if_addresses_changed)
self.reset_if_addresses_changed()
return attr
def __exit__(self, exc_type, exc_value, traceback):
self.node.__exit__(exc_type, exc_value, traceback)
def reset_if_addresses_changed(self):
new_addresses = get_interfaces_ip_addresses()
if new_addresses != self.addresses_at_start:
self.addresses_at_start = new_addresses
self.node.destroy_node()
rclpy.shutdown()
self.node = DirectNode(self.args)
self.node.__enter__()
print('Daemon node was reset')
def main(self, *, args):
with NodeStrategy(args) as node:
node_names = get_node_names(node=node, include_hidden_nodes=True)
if args.node_name in (n.full_name for n in node_names):
with DirectNode(args) as node:
print(args.node_name)
subscribers = get_subscriber_info(
node=node, remote_node_name=args.node_name)
print(' Subscribers:')
print_names_and_types(subscribers)
publishers = get_publisher_info(
node=node, remote_node_name=args.node_name)
print(' Publishers:')
print_names_and_types(publishers)
services = get_service_info(node=node,
remote_node_name=args.node_name)
print(' Services:')
print_names_and_types(services)
actions_servers = get_action_server_info(
node=node, remote_node_name=args.node_name)
print(' Action Servers:')
print_names_and_types(actions_servers)
actions_clients = get_action_client_info(
node=node, remote_node_name=args.node_name)
print(' Action Clients:')
print_names_and_types(actions_clients)
else:
return "Unable to find node '" + args.node_name + "'"
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(
node=node, include_hidden_nodes=args.include_hidden_nodes)
if args.node_name not in [n.full_name for n in node_names]:
return 'Node not found'
with DirectNode(args) as node:
response = call_get_parameters(node=node,
node_name=args.node_name,
parameter_names=[args.name])
assert len(response.values) <= 1
# requested parameter not set
if not response.values:
return 'Parameter not set'
# extract type specific value
pvalue = response.values[0]
if pvalue.type == ParameterType.PARAMETER_BOOL:
label = 'Boolean value is:'
value = pvalue.bool_value
elif pvalue.type == ParameterType.PARAMETER_INTEGER:
label = 'Integer value is:'
value = pvalue.integer_value
elif pvalue.type == ParameterType.PARAMETER_DOUBLE:
label = 'Double value is:'
value = pvalue.double_value
elif pvalue.type == ParameterType.PARAMETER_STRING:
label = 'String value is:'
value = pvalue.string_value
elif pvalue.type == ParameterType.PARAMETER_BYTE_ARRAY:
label = 'Byte values are:'
value = pvalue.byte_array_value
elif pvalue.type == ParameterType.PARAMETER_BOOL_ARRAY:
label = 'Boolean values are:'
value = pvalue.bool_array_value
elif pvalue.type == ParameterType.PARAMETER_INTEGER_ARRAY:
label = 'Integer values are:'
value = pvalue.integer_array_value
elif pvalue.type == ParameterType.PARAMETER_DOUBLE_ARRAY:
label = 'Double values are:'
value = pvalue.double_array_value
elif pvalue.type == ParameterType.PARAMETER_STRING_ARRAY:
label = 'String values are:'
value = pvalue.string_array_value
elif pvalue.type == ParameterType.PARAMETER_NOT_SET:
label = 'Parameter not set.'
value = None
else:
return "Unknown parameter type '{pvalue.type}'" \
.format_map(locals())
# output response
if not args.hide_type:
print(label, value) if value is not None else print(label)
else:
print(value)
def main(self, *, args):
container = run_standalone_container(
container_node_name=args.container_node_name)
with DirectNode(args) as node:
load_component_into_container(
node=node,
remote_container_node_name=args.container_node_name,
package_name=args.package_name,
plugin_name=args.plugin_name,
node_name=args.node_name,
node_namespace=args.node_namespace,
log_level=args.log_level,
remap_rules=args.remap_rules,
parameters=args.parameters,
extra_arguments=args.extra_arguments)
while container.returncode is None:
try:
container.communicate()
except KeyboardInterrupt:
# the subprocess will also receive the signal and should shut down
# therefore we continue here until the process has finished
pass
return container.returncode
def main(self, *, args):
policy = self.get_policy(args.POLICY_FILE_PATH)
node_names = []
with NodeStrategy(args) as node:
node_names = get_node_names(node=node, include_hidden_nodes=False)
if not len(node_names):
print(
'No nodes detected in the ROS graph. No policy file was generated.',
file=sys.stderr)
return 1
with DirectNode(args) as node:
for node_name in node_names:
profile = self.get_profile(policy, node_name)
subscribe_topics = get_subscriber_info(node=node,
node_name=node_name)
if subscribe_topics:
self.add_permission(profile, 'topic', 'subscribe', 'ALLOW',
subscribe_topics, node_name)
publish_topics = get_publisher_info(node=node,
node_name=node_name)
if publish_topics:
self.add_permission(profile, 'topic', 'publish', 'ALLOW',
publish_topics, node_name)
reply_services = get_service_info(node=node,
node_name=node_name)
if reply_services:
self.add_permission(profile, 'service', 'reply', 'ALLOW',
reply_services, node_name)
with open(args.POLICY_FILE_PATH, 'w') as stream:
dump_policy(policy, stream)
return 0
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(
node=node, include_hidden_nodes=args.include_hidden_nodes)
if args.node_name not in node_names:
return 'Node not found'
with DirectNode(args) as node:
parameter = Parameter()
Parameter.name = args.name
parameter.value = get_parameter_value(string_value=args.value)
response = call_set_parameters(node=node,
node_name=args.node_name,
parameters=[parameter])
# output response
assert len(response.results) == 1
result = response.results[0]
if result.successful:
msg = 'Set parameter successful'
if result.reason:
msg += ': ' + result.reason
print(msg)
else:
msg = 'Setting parameter failed'
if result.reason:
msg += ': ' + result.reason
print(msg, file=sys.stderr)
def __init__(self, args):
self._args = args
self._proxy = ServerProxy(
'http://localhost:%d/%s/' %
(get_daemon_port(), rclpy.get_rmw_implementation_identifier()),
allow_none=True)
self._methods = []
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(
node=node, include_hidden_nodes=args.include_hidden_nodes)
node_name = get_absolute_node_name(args.node_name)
if node_name not in [n.full_name for n in node_names]:
return 'Node not found'
with DirectNode(args) as node:
parameter = Parameter()
Parameter.name = args.name
value = ParameterValue()
value.type = ParameterType.PARAMETER_NOT_SET
parameter.value = value
response = call_set_parameters(node=node,
node_name=args.node_name,
parameters=[parameter])
# output response
assert len(response.results) == 1
result = response.results[0]
if result.successful:
msg = 'Deleted parameter successfully'
if result.reason:
msg += ': ' + result.reason
print(msg)
else:
msg = 'Deleting parameter failed'
if result.reason:
msg += ': ' + result.reason
print(msg, file=sys.stderr)
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(
node=node, include_hidden_nodes=args.include_hidden_nodes)
node_names = [n.full_name for n in node_names]
node_name = get_absolute_node_name(args.node_name)
if node_name:
if node_name not in node_names:
return 'Node not found'
with DirectNode(args) as node:
states = call_get_states(node=node, node_names=node_names)
# output exceptions
for node_name in sorted(states.keys()):
state = states[node_name]
if isinstance(state, Exception):
print('Exception while calling service of node '
"'{node_name}': {state}".format_map(locals()),
file=sys.stderr)
del states[node_name]
if args.node_name:
return 1
# output current states
for node_name in sorted(states.keys()):
state = states[node_name]
prefix = ''
if not args.node_name:
prefix = '{node_name}: '.format_map(locals())
print(prefix +
'{state.label} [{state.id}]'.format_map(locals()))
def main(self, *, args):
with NodeStrategy(args) as node:
node_names = get_node_names(node=node)
with DirectNode(args) as node:
container_node_names = find_container_node_names(
node=node, node_names=node_names
)
rclpy.init()
node = rclpy.create_node(NODE_NAME_PREFIX + '_component_list_requester')
try:
if args.container_node_name is not None:
if args.container_node_name not in [n.full_name for n in container_node_names]:
return "Unable to find container node '" + args.container_node_name + "'"
if not args.containers_only:
components = get_container_components_info(
node=node, remote_container_node_name=args.container_node_name
)
if any(components):
print(*['{} {}'.format(c.uid, c.name) for c in components], sep='\n')
else:
for n in container_node_names:
print(n.full_name)
if not args.containers_only:
components = get_container_components_info(
node=node, remote_container_node_name=n.full_name
)
if any(components):
print(*[
2 * ' ' + '{} {}'.format(c.uid, c.name) for c in components
], sep='\n')
finally:
node.destroy_node()
rclpy.shutdown()
def main(self, *, args):
with DirectNode(args) as node:
topic_names_and_types = get_topic_names_and_types(
node=node, include_hidden_topics=True)
topic_name = args.topic_name
for (t_name, t_types) in topic_names_and_types:
if t_name == topic_name:
topic_types = t_types
break
else:
return "Unknown topic '%s'" % topic_name
line_end = '\n'
if args.verbose:
line_end = '\n\n'
type_str = topic_types[0] if len(topic_types) == 1 else topic_types
print('Type: %s' % type_str, end=line_end)
print('Publisher count: %d' % node.count_publishers(topic_name), end=line_end)
if args.verbose:
try:
for info in node.get_publishers_info_by_topic(topic_name):
print(info, end=line_end)
except NotImplementedError as e:
return str(e)
print('Subscription count: %d' % node.count_subscribers(topic_name), end=line_end)
if args.verbose:
try:
for info in node.get_subscriptions_info_by_topic(topic_name):
print(info, end=line_end)
except NotImplementedError as e:
return str(e)
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(
node=node, include_hidden_nodes=args.include_hidden_nodes)
node_name = get_absolute_node_name(args.node_name)
if node_name not in {n.full_name for n in node_names}:
return 'Node not found'
with DirectNode(args) as node:
if args.all:
transitions = call_get_transition_graph(
node=node, states={node_name: None})
else:
transitions = call_get_available_transitions(
node=node, states={node_name: None})
transitions = transitions[node_name]
if isinstance(transitions, Exception):
return 'Exception while calling service of node ' \
"'{args.node_name}': {transitions}" \
.format_map(locals())
for t in transitions:
print('- {t.transition.label} [{t.transition.id}]\n'
'\tStart: {t.start_state.label}\n'
'\tGoal: {t.goal_state.label}'.format_map(locals()))
def __call__(self, prefix, parsed_args, **kwargs):
with DirectNode(parsed_args) as node:
controllers = list_controllers(
node, parsed_args.controller_manager).controller
return [
c.name for c in controllers if c.state in self.valid_states
]
def main(self, *, args):
with DirectNode(args) as node:
try:
action_clients, action_servers = get_action_clients_and_servers(
node=node,
action_name=args.action_name,
)
except (ValueError, rclpy.exceptions.InvalidTopicNameException) as e:
raise RuntimeError(e)
print('Action: {}'.format(args.action_name))
print('Action clients: {}'.format(len(action_clients)))
if not args.count:
for client_name, client_types in action_clients:
if args.show_types:
types_formatted = ', '.join(client_types)
print(f' {client_name} [{types_formatted}]')
else:
print(f' {client_name}')
print('Action servers: {}'.format(len(action_servers)))
if not args.count:
for server_name, server_types in action_servers:
if args.show_types:
types_formatted = ', '.join(server_types)
print(f' {server_name} [{types_formatted}]')
else:
print(f' {server_name}')
def main(self, *, args):
container = run_standalone_container(
container_node_name=args.container_node_name)
with DirectNode(args) as node:
try:
load_component_into_container(
node=node,
remote_container_node_name=args.container_node_name,
package_name=args.package_name,
plugin_name=args.plugin_name,
node_name=args.node_name,
node_namespace=args.node_namespace,
log_level=args.log_level,
remap_rules=args.remap_rules,
parameters=args.parameters,
extra_arguments=args.extra_arguments)
except RuntimeError as ex:
# In case the component fails to load, kill the container.
print('{}, interrupting container node'.format(ex))
if platform.system() == 'Windows':
container.send_signal(signal.CTRL_C_EVENT)
else:
container.send_signal(signal.SIGINT)
while container.returncode is None:
try:
container.communicate()
except KeyboardInterrupt:
# the subprocess will also receive the signal and should shut down
# therefore we continue here until the process has finished
pass
return container.returncode
def main(self, *, args):
with NodeStrategy(args) as node:
node_names = get_node_names(node=node)
with DirectNode(args) as node:
container_node_names = find_container_node_names(
node=node, node_names=node_names)
rclpy.init()
node = rclpy.create_node(NODE_NAME_PREFIX +
'_component_load_requester')
try:
if args.container_node_name in [
n.full_name for n in container_node_names
]:
return load_component_into_container(
node=node,
remote_container_node_name=args.container_node_name,
package_name=args.package_name,
plugin_name=args.plugin_name,
node_name=args.node_name,
node_namespace=args.node_namespace,
log_level=args.log_level,
remap_rules=args.remap_rules,
parameters=args.parameters,
extra_arguments=args.extra_arguments)
else:
return "Unable to find container node '" + args.container_node_name + "'"
finally:
node.destroy_node()
rclpy.shutdown()
def __call__(self, prefix, parsed_args, **kwargs):
with DirectNode(parsed_args) as node:
parameter_names = call_list_parameters(
node=node, node_name=parsed_args.node_name)
return [
n for n in parameter_names
if not prefix or n.startswith(prefix)]
def __call__(self, prefix, parsed_args, **kwargs):
with DirectNode(parsed_args) as node:
parameter_names = call_list_parameters(
node=node, node_name=parsed_args.controller_manager
)
suffix = '.type'
return [n[: -len(suffix)] for n in parameter_names if n.endswith(suffix)]
def main(self, *, args):
with NodeStrategy(args) as node:
node_names = get_node_names(node=node)
with DirectNode(args) as node:
container_node_names = find_container_node_names(
node=node, node_names=node_names)
if args.container_node_name is not None:
if args.container_node_name not in [
n.full_name for n in container_node_names
]:
return "Unable to find container node '" + args.container_node_name + "'"
if not args.containers_only:
components = get_container_components_info(
node=node,
remote_container_node_name=args.container_node_name)
if any(components):
print(*[
'{} {}'.format(c.uid, c.name) for c in components
],
sep='\n')
else:
for n in container_node_names:
print(n.full_name)
if not args.containers_only:
components = get_container_components_info(
node=node, remote_container_node_name=n.full_name)
if any(components):
print(*[
' ' + '{} {}'.format(c.uid, c.name)
for c in components
],
sep='\n')
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(
node=node, include_hidden_nodes=args.include_hidden_nodes)
node_name = get_absolute_node_name(args.node_name)
if node_name:
if node_name not in [n.full_name for n in node_names]:
return 'Node not found'
node_names = [
n for n in node_names if node_name == n.full_name]
regex_filter = getattr(args, 'filter')
if regex_filter is not None:
regex_filter = re.compile(regex_filter[0])
with DirectNode(args) as node:
responses = {}
for node_name in node_names:
responses[node_name] = call_list_parameters(
node=node,
node_name=node_name.full_name,
prefixes=args.param_prefixes)
# print responses
for node_name in sorted(responses.keys()):
response = responses[node_name]
if response is None:
print(
'Wait for service timed out waiting for '
f'parameter services for node {node_name}')
continue
elif response.result() is None:
e = response.exception()
print(
'Exception while calling service of node '
f"'{node_name.full_name}': {e}", file=sys.stderr)
continue
response = response.result().result.names
sorted_names = sorted(response)
if regex_filter is not None:
sorted_names = [name for name in sorted_names if regex_filter.match(name)]
if not args.node_name and sorted_names:
print(f'{node_name.full_name}:')
# get descriptors for the node if needs to print parameter type
name_to_type_map = {}
if args.param_type is True:
resp = call_describe_parameters(
node=node, node_name=node_name.full_name,
parameter_names=sorted_names)
for descriptor in resp.descriptors:
name_to_type_map[descriptor.name] = get_parameter_type_string(
descriptor.type)
for name in sorted_names:
if args.param_type is True:
param_type_str = name_to_type_map[name]
print(f' {name} (type: {param_type_str})')
else:
print(f' {name}')
def main(self, *, args): # noqa: D102
with NodeStrategy(args) as node:
node_names = get_node_names(node=node, include_hidden_nodes=args.include_hidden_nodes)
absolute_node_name = get_absolute_node_name(args.node_name)
node_name = parse_node_name(absolute_node_name)
if absolute_node_name:
if absolute_node_name not in [n.full_name for n in node_names]:
return 'Node not found'
if not os.path.isdir(args.output_dir):
raise RuntimeError(
f"'{args.output_dir}' is not a valid directory.")
with DirectNode(args) as node:
yaml_output = {node_name.full_name: {'ros__parameters': {}}}
# retrieve values
response = call_list_parameters(node=node, node_name=absolute_node_name)
if response is None:
raise RuntimeError(
'Wait for service timed out waiting for '
f'parameter services for node {node_name.full_name}')
elif response.result() is None:
e = response.exception()
raise RuntimeError(
'Exception while calling service of node '
f"'{node_name.full_name}': {e}")
response = response.result().result.names
response = sorted(response)
parameter_values = self.get_parameter_values(node, absolute_node_name, response)
for param_name, pval in zip(response, parameter_values):
self.insert_dict(
yaml_output[node_name.full_name]['ros__parameters'], param_name, pval)
if args.print:
print(
"WARNING: '--print' is deprecated; this utility prints to stdout by default",
file=sys.stderr)
if args.output_dir != '.':
print(
"WARNING: '--output-dir' is deprecated; use redirection to save to a file",
file=sys.stderr)
else:
print(yaml.dump(yaml_output, default_flow_style=False))
return
if absolute_node_name[0] == '/':
file_name = absolute_node_name[1:].replace('/', '__')
else:
file_name = absolute_node_name.replace('/', '__')
print('Saving to: ', os.path.join(args.output_dir, file_name + '.yaml'))
with open(os.path.join(args.output_dir, file_name + '.yaml'), 'w') as yaml_file:
yaml.dump(yaml_output, yaml_file, default_flow_style=False)
def __enter__(self):
self._proxy.__enter__()
try:
methods = self._proxy.system.listMethods()
except ProtocolError as e:
if e.errcode != 404:
raise
# remote daemon returned 404, likely using different rmw impl.
self._proxy.__exit__()
# fall back to use direct node
self._proxy = DirectNode(self._args)
self._proxy.__enter__()
else:
self._methods = [m for m in methods if not m.startswith('system.')]
return self
def main(args):
qos_profile = qos_profile_from_short_keys(args.qos_profile,
reliability=args.qos_reliability,
durability=args.qos_durability)
with DirectNode(args) as node:
return publisher(node.node, args.message_type, args.topic_name,
args.values, 1. / args.rate, args.print, args.once,
qos_profile)
def main(args):
if not args.csv:
register_yaml_representer()
callback = subscriber_cb(args)
else:
callback = subscriber_cb_csv(args)
with DirectNode(args) as node:
subscriber(node, args.topic_name, args.message_type, callback)
class NodeStrategy:
def __init__(self, args):
if is_daemon_running(args):
self.node = DaemonNode(args)
else:
spawn_daemon(args)
self.node = DirectNode(args)
def __enter__(self):
self.node.__enter__()
return self
def __getattr__(self, name):
return self.node.__getattr__(name)
def __exit__(self, exc_type, exc_value, traceback):
self.node.__exit__(exc_type, exc_value, traceback)
