def _launch(launch_description):
loop = osrf_pycommon.process_utils.get_loop()
ls = LaunchService()
ls.include_launch_description(launch_description)
launch_task = loop.create_task(ls.run_async())
loop.run_until_complete(asyncio.sleep(5, loop=loop))
if not launch_task.done():
loop.create_task(ls.shutdown())
loop.run_until_complete(launch_task)
return ls.context
def _assert_launch_no_errors(actions, *, timeout_sec=5):
ld = LaunchDescription(actions)
ls = LaunchService(debug=True)
ls.include_launch_description(ld)
loop = osrf_pycommon.process_utils.get_loop()
launch_task = loop.create_task(ls.run_async())
loop.run_until_complete(asyncio.sleep(timeout_sec))
if not launch_task.done():
loop.create_task(ls.shutdown())
loop.run_until_complete(launch_task)
assert 0 == launch_task.result()
return ls.context
def main(args=None):
rclpy.init(args=args)
ls = LaunchService(debug=True)
server = SimWorker(ls)
print("Waiting until launch ready")
while not server.launch_ready:
rclpy.spin_once(server)
loop = osrf_pycommon.process_utils.get_loop()
launch_task = loop.create_task(ls.run_async())
print("Spinning")
# This is probably not the most awesome way to hand
# off between rclpy and the launch service... but it works.
# asyncio code copied from https://github.com/ros2/launch/pull/210
while True:
loop.run_until_complete(asyncio.sleep(0, loop=loop))
rclpy.spin_once(server)
loop.close()
rclpy.shutdown()
class ComponentsLauncher:
def __init__(self):
self._components_list = list()
self._launch_task = None
self._loop = None
self._launch_service = None
def add_component(self, component):
assert (isinstance(component, Component))
self._components_list.append(component)
def launch(self):
components_launch_description_list = map(
lambda c: c.launch_description, self._components_list)
launch_description = LaunchDescription(
components_launch_description_list)
self._launch_service = LaunchService(argv=argv)
self._launch_service.include_launch_description(launch_description)
self._loop = osrf_pycommon.process_utils.get_loop()
self._launch_task = self._loop.create_task(
self._launch_service.run_async())
self._loop.run_until_complete(self._launch_task)
def shutdown(self):
if self._launch_task is None:
print_error(
"ComponentsLauncher.shutdown: components launcher has not been launched"
)
return
if not self._launch_task.done():
asyncio.ensure_future(self._launch_service.shutdown(),
loop=self._loop)
self._loop.run_until_complete(self._launch_task)
def test_launch_service_emit_event():
"""
Test the emitting of events in the LaunchService class.
Also covers basic tests for include_launch_description(), run(), and
shutdown().
"""
ls = LaunchService(debug=True)
assert ls._LaunchService__context._event_queue.qsize() == 0
from launch.actions import OpaqueFunction
from launch.actions import RegisterEventHandler
from launch.event_handler import EventHandler
handled_events = queue.Queue()
ld = LaunchDescription([
RegisterEventHandler(
EventHandler(
matcher=lambda event: not isinstance(event, ExecutionComplete),
entities=OpaqueFunction(function=lambda context: handled_events
.put(context.locals.event), ),
))
])
ls.include_launch_description(ld)
assert ls._LaunchService__context._event_queue.qsize() == 1
class MockEvent:
name = 'Event'
ls.emit_event(MockEvent())
assert ls._LaunchService__context._event_queue.qsize() == 2
assert handled_events.qsize() == 0
# Spin up a background thread for testing purposes.
def perform_test_sequence():
# First event (after including description of event handler).
handled_events.get(block=True, timeout=5.0)
# Emit and then check for a second event.
ls.emit_event(MockEvent())
handled_events.get(block=True, timeout=5.0)
# Shutdown (generates a third event).
ls.shutdown()
t = threading.Thread(target=perform_test_sequence)
t.start()
# Run the launch service.
assert ls.run(shutdown_when_idle=False) == 0
# Join background thread if still running.
t.join()
# Check that the shutdown event was handled.
handled_events.get(block=False)
assert handled_events.qsize() == 0
ls.emit_event(MockEvent())
assert handled_events.qsize() == 0
assert ls.run(shutdown_when_idle=True) == 0
# Check that the mock and shutdown events were handled.
assert handled_events.qsize() == 2
handled_events.get(block=False)
handled_events.get(block=False)
loop = osrf_pycommon.process_utils.get_loop()
assert loop.run_until_complete(ls.run_async(shutdown_when_idle=True)) == 0
# Check that the shutdown events was handled.
assert handled_events.qsize() == 1
handled_events.get(block=False)
def check_launch_component_container(file):
root_entity, parser = Parser.load(file)
ld = parser.parse_description(root_entity)
ls = LaunchService()
ls.include_launch_description(ld)
loop = osrf_pycommon.process_utils.get_loop()
launch_task = loop.create_task(ls.run_async())
node_container, load_composable_node = ld.describe_sub_entities()
talker = node_container._ComposableNodeContainer__composable_node_descriptions[
0]
listener = load_composable_node._LoadComposableNodes__composable_node_descriptions[
0]
def perform(substitution):
return perform_substitutions(ls.context, substitution)
# Check container params
assert perform(node_container._Node__package) == 'rclcpp_components'
assert perform(
node_container._Node__node_executable) == 'component_container'
assert perform(node_container._Node__node_name) == 'my_container'
assert perform(node_container._Node__node_namespace) == ''
assert perform(node_container._Node__arguments[0]) == 'test_args'
assert perform(load_composable_node._LoadComposableNodes__target_container
) == 'my_container'
# Check node parameters
talker_remappings = list(talker._ComposableNode__remappings)
listener_remappings = list(listener._ComposableNode__remappings)
talker_params = evaluate_parameters(ls.context,
talker._ComposableNode__parameters)
listener_params = evaluate_parameters(ls.context,
listener._ComposableNode__parameters)
talker_extra_args = evaluate_parameters(
ls.context, talker._ComposableNode__extra_arguments)
listener_extra_args = evaluate_parameters(
ls.context, listener._ComposableNode__extra_arguments)
assert perform(talker._ComposableNode__package) == 'composition'
assert perform(
talker._ComposableNode__node_plugin) == 'composition::Talker'
assert perform(talker._ComposableNode__node_name) == 'talker'
assert perform(talker._ComposableNode__node_namespace) == 'test_namespace'
assert (perform(talker_remappings[0][0]),
perform(talker_remappings[0][1])) == ('chatter', '/remap/chatter')
assert talker_params[0]['use_sim_time'] is True
assert perform(listener._ComposableNode__package) == 'composition'
assert perform(
listener._ComposableNode__node_plugin) == 'composition::Listener'
assert perform(listener._ComposableNode__node_name) == 'listener'
assert perform(
listener._ComposableNode__node_namespace) == 'test_namespace'
assert (perform(listener_remappings[0][0]),
perform(listener_remappings[0][1])) == ('chatter',
'/remap/chatter')
assert listener_params[0]['use_sim_time'] is True
# Check extra arguments
assert talker_extra_args[0]['use_intra_process_comms'] is True
assert listener_extra_args[0]['use_intra_process_comms'] is True
timeout_sec = 5
loop.run_until_complete(asyncio.sleep(timeout_sec))
if not launch_task.done():
loop.create_task(ls.shutdown())
loop.run_until_complete(launch_task)
assert 0 == launch_task.result()
