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()