From 5e3d4be72089a4c766b508877bc52a196bd7bead Mon Sep 17 00:00:00 2001 From: Karsten Knese Date: Thu, 11 Oct 2018 14:03:41 -0700 Subject: [PATCH] Lifecycle refactor (#298) * no static initialization of states anymore * make transition labels more descriptive * introduce labeled keys * define default transition keys * fix memory management * introduce service for transition graph * export transition keys * remove keys, transition id unique, label ambiguous * semicolon for macro call --- .../include/rcl_lifecycle/data_types.h | 13 +- .../rcl_lifecycle}/default_state_machine.h | 16 +- .../include/rcl_lifecycle/rcl_lifecycle.h | 39 +- .../include/rcl_lifecycle/transition_map.h | 1 - rcl_lifecycle/src/com_interface.c | 29 + rcl_lifecycle/src/com_interface.h | 1 + rcl_lifecycle/src/default_state_machine.c | 1044 ++++++++++------- rcl_lifecycle/src/rcl_lifecycle.c | 106 +- rcl_lifecycle/src/states.h | 51 - rcl_lifecycle/src/transition_map.c | 21 - .../test/test_default_state_machine.cpp | 238 ++-- .../test/test_multiple_instances.cpp | 9 +- rcl_lifecycle/test/test_transition_map.cpp | 24 +- 13 files changed, 933 insertions(+), 659 deletions(-) rename rcl_lifecycle/{src => include/rcl_lifecycle}/default_state_machine.h (57%) delete mode 100644 rcl_lifecycle/src/states.h diff --git a/rcl_lifecycle/include/rcl_lifecycle/data_types.h b/rcl_lifecycle/include/rcl_lifecycle/data_types.h index b8dc102..e6f9a8f 100644 --- a/rcl_lifecycle/include/rcl_lifecycle/data_types.h +++ b/rcl_lifecycle/include/rcl_lifecycle/data_types.h @@ -24,8 +24,6 @@ extern "C" { #endif -typedef uint8_t rcl_lifecycle_transition_key_t; - typedef struct rcl_lifecycle_transition_t rcl_lifecycle_transition_t; typedef struct rcl_lifecycle_state_t @@ -33,16 +31,6 @@ typedef struct rcl_lifecycle_state_t const char * label; unsigned int id; - // a valid key is a generic identifier for deciding - // which transitions to trigger. - // This serves the purpose of hiding a unique ID from - // users prospective. - // e.g. shutdown - // the concrete transition for the state "unconfigured" - // is "unconfigured_shutdown". However, the user only specifies - // "shutdown". So we register the "unconfigured_shutdown" - // transition with the impuls "shutdown". - rcl_lifecycle_transition_key_t * valid_transition_keys; rcl_lifecycle_transition_t * valid_transitions; unsigned int valid_transition_size; } rcl_lifecycle_state_t; @@ -71,6 +59,7 @@ typedef struct rcl_lifecycle_com_interface_t rcl_service_t srv_get_state; rcl_service_t srv_get_available_states; rcl_service_t srv_get_available_transitions; + rcl_service_t srv_get_transition_graph; } rcl_lifecycle_com_interface_t; typedef struct rcl_lifecycle_state_machine_t diff --git a/rcl_lifecycle/src/default_state_machine.h b/rcl_lifecycle/include/rcl_lifecycle/default_state_machine.h similarity index 57% rename from rcl_lifecycle/src/default_state_machine.h rename to rcl_lifecycle/include/rcl_lifecycle/default_state_machine.h index 993541e..d9802f2 100644 --- a/rcl_lifecycle/src/default_state_machine.h +++ b/rcl_lifecycle/include/rcl_lifecycle/default_state_machine.h @@ -12,8 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. -#ifndef DEFAULT_STATE_MACHINE_H_ -#define DEFAULT_STATE_MACHINE_H_ +#ifndef RCL_LIFECYCLE__DEFAULT_STATE_MACHINE_H_ +#define RCL_LIFECYCLE__DEFAULT_STATE_MACHINE_H_ #include "rcl/macros.h" #include "rcl/types.h" @@ -26,6 +26,16 @@ extern "C" { #endif +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_configure_label; +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_cleanup_label; +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_activate_label; +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_deactivate_label; +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_shutdown_label; + +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_transition_success_label; +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_transition_failure_label; +RCL_LIFECYCLE_PUBLIC extern const char * rcl_lifecycle_transition_error_label; + RCL_LIFECYCLE_PUBLIC RCL_WARN_UNUSED rcl_ret_t @@ -36,4 +46,4 @@ rcl_lifecycle_init_default_state_machine( } #endif -#endif // DEFAULT_STATE_MACHINE_H_ +#endif // RCL_LIFECYCLE__DEFAULT_STATE_MACHINE_H_ diff --git a/rcl_lifecycle/include/rcl_lifecycle/rcl_lifecycle.h b/rcl_lifecycle/include/rcl_lifecycle/rcl_lifecycle.h index 0e95286..8236f99 100644 --- a/rcl_lifecycle/include/rcl_lifecycle/rcl_lifecycle.h +++ b/rcl_lifecycle/include/rcl_lifecycle/rcl_lifecycle.h @@ -23,6 +23,7 @@ extern "C" #include #include "rcl_lifecycle/data_types.h" +#include "rcl_lifecycle/default_state_machine.h" #include "rcl_lifecycle/visibility_control.h" RCL_LIFECYCLE_PUBLIC @@ -89,6 +90,7 @@ rcl_lifecycle_state_machine_init( const rosidl_service_type_support_t * ts_srv_get_state, const rosidl_service_type_support_t * ts_srv_get_available_states, const rosidl_service_type_support_t * ts_srv_get_available_transitions, + const rosidl_service_type_support_t * ts_srv_get_transition_graph, bool default_states, const rcl_allocator_t * allocator); @@ -109,27 +111,32 @@ rcl_lifecycle_state_machine_is_initialized( RCL_LIFECYCLE_PUBLIC RCL_WARN_UNUSED const rcl_lifecycle_transition_t * -rcl_lifecycle_is_valid_callback_transition( - rcl_lifecycle_state_machine_t * state_machine, - rcl_lifecycle_transition_key_t key); +rcl_lifecycle_get_transition_by_id( + const rcl_lifecycle_state_t * state, + uint8_t id); + +RCL_LIFECYCLE_PUBLIC +RCL_WARN_UNUSED +const rcl_lifecycle_transition_t * +rcl_lifecycle_get_transition_by_label( + const rcl_lifecycle_state_t * state, + const char * label); -/// Execute a transition -/* - * Important note for \param key here: - * This is meant as feedback from the high level - * callback associated with this transition. - * The key is the index for the valid transitions - * associated with the current state. - * This key may either be a valid external stimuli - * such as "configure" or direct return codes from - * callbacks such as RCL_LIFECYCLE_RET_OK et. al. - */ RCL_LIFECYCLE_PUBLIC RCL_WARN_UNUSED rcl_ret_t -rcl_lifecycle_trigger_transition( +rcl_lifecycle_trigger_transition_by_id( rcl_lifecycle_state_machine_t * state_machine, - rcl_lifecycle_transition_key_t key, bool publish_notification); + uint8_t id, + bool publish_notification); + +RCL_LIFECYCLE_PUBLIC +RCL_WARN_UNUSED +rcl_ret_t +rcl_lifecycle_trigger_transition_by_label( + rcl_lifecycle_state_machine_t * state_machine, + const char * label, + bool publish_notification); RCL_LIFECYCLE_PUBLIC void diff --git a/rcl_lifecycle/include/rcl_lifecycle/transition_map.h b/rcl_lifecycle/include/rcl_lifecycle/transition_map.h index 9b2b782..629db96 100644 --- a/rcl_lifecycle/include/rcl_lifecycle/transition_map.h +++ b/rcl_lifecycle/include/rcl_lifecycle/transition_map.h @@ -57,7 +57,6 @@ rcl_ret_t rcl_lifecycle_register_transition( rcl_lifecycle_transition_map_t * transition_map, rcl_lifecycle_transition_t transition, - rcl_lifecycle_transition_key_t key, const rcl_allocator_t * allocator); RCL_LIFECYCLE_PUBLIC diff --git a/rcl_lifecycle/src/com_interface.c b/rcl_lifecycle/src/com_interface.c index bdc3306..886192c 100644 --- a/rcl_lifecycle/src/com_interface.c +++ b/rcl_lifecycle/src/com_interface.c @@ -42,6 +42,7 @@ static const char * srv_change_state_service = "~/change_state"; static const char * srv_get_state_service = "~/get_state"; static const char * srv_get_available_states_service = "~/get_available_states"; static const char * srv_get_available_transitions_service = "~/get_available_transitions"; +static const char * srv_get_transition_graph = "~/get_transition_graph"; rcl_lifecycle_com_interface_t rcl_lifecycle_get_zero_initialized_com_interface() @@ -53,6 +54,7 @@ rcl_lifecycle_get_zero_initialized_com_interface() com_interface.srv_get_state = rcl_get_zero_initialized_service(); com_interface.srv_get_available_states = rcl_get_zero_initialized_service(); com_interface.srv_get_available_transitions = rcl_get_zero_initialized_service(); + com_interface.srv_get_transition_graph = rcl_get_zero_initialized_service(); return com_interface; } @@ -65,6 +67,7 @@ rcl_lifecycle_com_interface_init( const rosidl_service_type_support_t * ts_srv_get_state, const rosidl_service_type_support_t * ts_srv_get_available_states, const rosidl_service_type_support_t * ts_srv_get_available_transitions, + const rosidl_service_type_support_t * ts_srv_get_transition_graph, const rcl_allocator_t * allocator) { RCL_CHECK_ARGUMENT_FOR_NULL(allocator, RCL_RET_INVALID_ARGUMENT, rcl_get_default_allocator()) @@ -77,6 +80,8 @@ rcl_lifecycle_com_interface_init( ts_srv_get_available_states, RCL_RET_INVALID_ARGUMENT, *allocator) RCL_CHECK_ARGUMENT_FOR_NULL( ts_srv_get_available_transitions, RCL_RET_INVALID_ARGUMENT, *allocator) + RCL_CHECK_ARGUMENT_FOR_NULL( + ts_srv_get_transition_graph, RCL_RET_INVALID_ARGUMENT, *allocator) // initialize publisher { @@ -141,6 +146,17 @@ rcl_lifecycle_com_interface_init( } } + // initialize get transition graph service + { + rcl_service_options_t service_options = rcl_service_get_default_options(); + rcl_ret_t ret = rcl_service_init( + &com_interface->srv_get_transition_graph, node_handle, + ts_srv_get_transition_graph, srv_get_transition_graph, &service_options); + + if (ret != RCL_RET_OK) { + goto fail; + } + } return RCL_RET_OK; fail: @@ -160,6 +176,10 @@ fail: RCUTILS_LOG_ERROR_NAMED( ROS_PACKAGE_NAME, "Failed to destroy get_available_transitions service"); } + if (RCL_RET_OK != rcl_service_fini(&com_interface->srv_get_transition_graph, node_handle)) { + RCUTILS_LOG_ERROR_NAMED( + ROS_PACKAGE_NAME, "Failed to destroy get_transition_graph service"); + } return RCL_RET_ERROR; } @@ -171,6 +191,15 @@ rcl_lifecycle_com_interface_fini( { rcl_ret_t fcn_ret = RCL_RET_OK; + // destroy get transition graph srv + { + rcl_ret_t ret = rcl_service_fini( + &com_interface->srv_get_transition_graph, node_handle); + if (ret != RCL_RET_OK) { + fcn_ret = RCL_RET_ERROR; + } + } + // destroy get available transitions srv { rcl_ret_t ret = rcl_service_fini( diff --git a/rcl_lifecycle/src/com_interface.h b/rcl_lifecycle/src/com_interface.h index 6eb8746..49c05d1 100644 --- a/rcl_lifecycle/src/com_interface.h +++ b/rcl_lifecycle/src/com_interface.h @@ -37,6 +37,7 @@ rcl_lifecycle_com_interface_init( const rosidl_service_type_support_t * ts_srv_get_state, const rosidl_service_type_support_t * ts_srv_get_available_states, const rosidl_service_type_support_t * ts_srv_get_available_transitions, + const rosidl_service_type_support_t * ts_srv_get_transition_graph, const rcl_allocator_t * allocator); rcl_ret_t diff --git a/rcl_lifecycle/src/default_state_machine.c b/rcl_lifecycle/src/default_state_machine.c index 8ee63d4..2a2563c 100644 --- a/rcl_lifecycle/src/default_state_machine.c +++ b/rcl_lifecycle/src/default_state_machine.c @@ -12,6 +12,8 @@ // See the License for the specific language governing permissions and // limitations under the License. +#include "rcl_lifecycle/default_state_machine.h" + #include #include #include @@ -24,160 +26,629 @@ #include "rcl_lifecycle/transition_map.h" -#include "default_state_machine.h" // NOLINT -#include "states.h" // NOLINT - #ifdef __cplusplus extern "C" { #endif -rcl_lifecycle_transition_key_t * empty_transition_key = NULL; -rcl_lifecycle_transition_t * empty_transition = NULL; -unsigned int empty_transition_size = 0; +const char * rcl_lifecycle_configure_label = "configure"; +const char * rcl_lifecycle_cleanup_label = "cleanup"; +const char * rcl_lifecycle_activate_label = "activate"; +const char * rcl_lifecycle_deactivate_label = "deactivate"; +const char * rcl_lifecycle_shutdown_label = "shutdown"; -// Primary States -rcl_lifecycle_state_t rcl_state_unknown = { - "unknown", lifecycle_msgs__msg__State__PRIMARY_STATE_UNKNOWN, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_unconfigured = { - "unconfigured", lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_inactive = { - "inactive", lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_active = { - "active", lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_finalized = { - "finalized", lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED, NULL, NULL, 0 -}; -// Transition States -rcl_lifecycle_state_t rcl_state_configuring = { - "configuring", lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_cleaningup = { - "cleaningup", lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_shuttingdown = { - "shuttingdown", lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_activating = { - "activating", lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_deactivating = { - "deactivating", lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, NULL, NULL, 0 -}; -rcl_lifecycle_state_t rcl_state_errorprocessing = { - "errorprocessing", lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, NULL, NULL, 0 -}; +const char * rcl_lifecycle_transition_success_label = "transition_success"; +const char * rcl_lifecycle_transition_failure_label = "transition_failure"; +const char * rcl_lifecycle_transition_error_label = "transition_error"; -// Transitions -const rcl_lifecycle_transition_t rcl_transition_configure = { - "configure", lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE, - &rcl_state_unconfigured, &rcl_state_configuring -}; -const rcl_lifecycle_transition_t rcl_transition_configure_success = { - "configure_success", lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, - &rcl_state_configuring, &rcl_state_inactive -}; -const rcl_lifecycle_transition_t rcl_transition_configure_failure = { - "configure_failure", lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE, - &rcl_state_configuring, &rcl_state_unconfigured -}; -const rcl_lifecycle_transition_t rcl_transition_configure_error = { - "configure_error", lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR, - &rcl_state_configuring, &rcl_state_errorprocessing -}; +rcl_ret_t +_register_primary_states( + rcl_lifecycle_transition_map_t * transition_map, const rcutils_allocator_t * allocator) +{ + rcl_ret_t ret = RCL_RET_ERROR; -const rcl_lifecycle_transition_t rcl_transition_cleanup = { - "cleanup", lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP, - &rcl_state_inactive, &rcl_state_cleaningup -}; -const rcl_lifecycle_transition_t rcl_transition_cleanup_success = { - "cleanup_success", lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, - &rcl_state_cleaningup, &rcl_state_unconfigured -}; -const rcl_lifecycle_transition_t rcl_transition_cleanup_failure = { - "cleanup_failure", lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE, - &rcl_state_cleaningup, &rcl_state_inactive -}; -const rcl_lifecycle_transition_t rcl_transition_cleanup_error = { - "cleanup_error", lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR, - &rcl_state_cleaningup, &rcl_state_errorprocessing -}; + // default values for when registering states + // all states are registered with no transitions attached + // the valid transitions per state are filled once transitions are registered + rcl_lifecycle_transition_t * valid_transitions = NULL; + unsigned int valid_transition_size = 0; -const rcl_lifecycle_transition_t rcl_transition_activate = { - "activate", lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE, - &rcl_state_inactive, &rcl_state_activating -}; -const rcl_lifecycle_transition_t rcl_transition_activate_success = { - "activate_success", lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, - &rcl_state_activating, &rcl_state_active -}; -const rcl_lifecycle_transition_t rcl_transition_activate_failure = { - "activate_failure", lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE, - &rcl_state_activating, &rcl_state_inactive -}; -const rcl_lifecycle_transition_t rcl_transition_activate_error = { - "activate_error", lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR, - &rcl_state_activating, &rcl_state_errorprocessing -}; + // register unknown state + { + rcl_lifecycle_state_t rcl_state_unknown = { + "unknown", lifecycle_msgs__msg__State__PRIMARY_STATE_UNKNOWN, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_unknown, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } -const rcl_lifecycle_transition_t rcl_transition_deactivate = { - "deactivate", lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE, - &rcl_state_active, &rcl_state_deactivating -}; -const rcl_lifecycle_transition_t rcl_transition_deactivate_success = { - "deactivate_success", lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, - &rcl_state_deactivating, &rcl_state_inactive -}; -const rcl_lifecycle_transition_t rcl_transition_deactivate_failure = { - "deactivate_failure", lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE, - &rcl_state_deactivating, &rcl_state_active -}; -const rcl_lifecycle_transition_t rcl_transition_deactivate_error = { - "deactivate_error", lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR, - &rcl_state_deactivating, &rcl_state_errorprocessing -}; + // register unconfigured state + { + rcl_lifecycle_state_t rcl_state_unconfigured = { + "unconfigured", lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_unconfigured, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } -const rcl_lifecycle_transition_t rcl_transition_unconfigured_shutdown = { - "unconfigured_shutdown", lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, - &rcl_state_unconfigured, &rcl_state_shuttingdown -}; -const rcl_lifecycle_transition_t rcl_transition_inactive_shutdown = { - "inactive_shutdown", lifecycle_msgs__msg__Transition__TRANSITION_INACTIVE_SHUTDOWN, - &rcl_state_inactive, &rcl_state_shuttingdown -}; -const rcl_lifecycle_transition_t rcl_transition_active_shutdown = { - "active_shutdown", lifecycle_msgs__msg__Transition__TRANSITION_ACTIVE_SHUTDOWN, - &rcl_state_active, &rcl_state_shuttingdown -}; -const rcl_lifecycle_transition_t rcl_transition_shutdown_success = { - "shutdown_success", lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS, - &rcl_state_shuttingdown, &rcl_state_finalized -}; -const rcl_lifecycle_transition_t rcl_transition_shutdown_failure = { - "shutdown_failure", lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE, - &rcl_state_shuttingdown, &rcl_state_finalized -}; -const rcl_lifecycle_transition_t rcl_transition_shutdown_error = { - "shutdown_error", lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR, - &rcl_state_shuttingdown, &rcl_state_errorprocessing -}; + // register inactive state + { + rcl_lifecycle_state_t rcl_state_inactive = { + "inactive", lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_inactive, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } -const rcl_lifecycle_transition_t rcl_transition_error_success = { - "errorprocessing_success", lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, - &rcl_state_errorprocessing, &rcl_state_unconfigured -}; -const rcl_lifecycle_transition_t rcl_transition_error_failure = { - "errorprocessing_failure", lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE, - &rcl_state_errorprocessing, &rcl_state_finalized -}; -const rcl_lifecycle_transition_t rcl_transition_error_error = { - "errorprocessing_error", lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR, - &rcl_state_errorprocessing, &rcl_state_finalized -}; + // register active state + { + rcl_lifecycle_state_t rcl_state_active = { + "active", lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_active, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register finalized state + { + rcl_lifecycle_state_t rcl_state_finalized = { + "finalized", lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_finalized, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + return ret; +} + +rcl_ret_t +_register_transition_states( + rcl_lifecycle_transition_map_t * transition_map, const rcutils_allocator_t * allocator) +{ + rcl_ret_t ret = RCL_RET_ERROR; + + // default values for when registering states + // all states are registered with no transitions attached + // the valid transitions per state are filled once transitions are registered + rcl_lifecycle_transition_t * valid_transitions = NULL; + unsigned int valid_transition_size = 0; + + // register configuring state + { + rcl_lifecycle_state_t rcl_state_configuring = { + "configuring", lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_configuring, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register cleaningup state + { + rcl_lifecycle_state_t rcl_state_cleaningup = { + "cleaningup", lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_cleaningup, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register shutting down state + { + rcl_lifecycle_state_t rcl_state_shuttingdown = { + "shuttingdown", lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_shuttingdown, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register activating state + { + rcl_lifecycle_state_t rcl_state_activating = { + "activating", lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_activating, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register deactivating state + { + rcl_lifecycle_state_t rcl_state_deactivating = { + "deactivating", lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_deactivating, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register errorprocessing state + { + rcl_lifecycle_state_t rcl_state_errorprocessing = { + "errorprocessing", lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, + valid_transitions, valid_transition_size + }; + ret = rcl_lifecycle_register_state( + transition_map, rcl_state_errorprocessing, allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + return ret; +} + +rcl_ret_t +_register_transitions( + rcl_lifecycle_transition_map_t * transition_map, const rcutils_allocator_t * allocator) +{ + rcl_ret_t ret = RCL_RET_ERROR; + + // retrieve primary and transition states from the transition map + // note: These states are pointing to the states inside the map + // the states created before (see _register_primary_states) were copied into the map + // and thus have to be retrieved from the map again to not invalidate pointers. + + rcl_lifecycle_state_t * unconfigured_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); + rcl_lifecycle_state_t * inactive_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); + rcl_lifecycle_state_t * active_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); + rcl_lifecycle_state_t * finalized_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); + + rcl_lifecycle_state_t * configuring_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING); + rcl_lifecycle_state_t * activating_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING); + rcl_lifecycle_state_t * deactivating_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING); + rcl_lifecycle_state_t * cleaningup_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP); + rcl_lifecycle_state_t * shuttingdown_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); + rcl_lifecycle_state_t * errorprocessing_state = rcl_lifecycle_get_state( + transition_map, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); + + // register transition from unconfigured to configuring + { + rcl_lifecycle_transition_t rcl_transition_configure = { + rcl_lifecycle_configure_label, + lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE, + unconfigured_state, configuring_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_configure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from configuring to inactive + { + rcl_lifecycle_transition_t rcl_transition_on_configure_success = { + rcl_lifecycle_transition_success_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, + configuring_state, inactive_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_configure_success, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from configuring to unconfigured + { + rcl_lifecycle_transition_t rcl_transition_on_configure_failure = { + rcl_lifecycle_transition_failure_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE, + configuring_state, unconfigured_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_configure_failure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from configuring to errorprocessing + { + rcl_lifecycle_transition_t rcl_transition_on_configure_error = { + rcl_lifecycle_transition_error_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR, + configuring_state, errorprocessing_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_configure_error, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from inactive to cleaningup + { + rcl_lifecycle_transition_t rcl_transition_cleanup = { + rcl_lifecycle_cleanup_label, + lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP, + inactive_state, cleaningup_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_cleanup, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from cleaningup to unconfigured + { + rcl_lifecycle_transition_t rcl_transition_on_cleanup_success = { + rcl_lifecycle_transition_success_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, + cleaningup_state, unconfigured_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_cleanup_success, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from cleaningup to inactive + { + rcl_lifecycle_transition_t rcl_transition_on_cleanup_failure = { + rcl_lifecycle_transition_failure_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE, + cleaningup_state, inactive_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_cleanup_failure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from cleaniningup to errorprocessing + { + rcl_lifecycle_transition_t rcl_transition_on_cleanup_error = { + rcl_lifecycle_transition_error_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR, + cleaningup_state, errorprocessing_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_cleanup_error, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from inactive to activating + { + rcl_lifecycle_transition_t rcl_transition_activate = { + rcl_lifecycle_activate_label, + lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE, + inactive_state, activating_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_activate, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from activating to active + { + rcl_lifecycle_transition_t rcl_transition_on_activate_success = { + rcl_lifecycle_transition_success_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, + activating_state, active_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_activate_success, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from activating to inactive + { + rcl_lifecycle_transition_t rcl_transition_on_activate_failure = { + rcl_lifecycle_transition_failure_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE, + activating_state, inactive_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_activate_failure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from activating to errorprocessing + { + rcl_lifecycle_transition_t rcl_transition_on_activate_error = { + rcl_lifecycle_transition_error_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR, + activating_state, errorprocessing_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_activate_error, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from active to deactivating + { + rcl_lifecycle_transition_t rcl_transition_deactivate = { + rcl_lifecycle_deactivate_label, + lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE, + active_state, deactivating_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_deactivate, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from deactivating to inactive + { + rcl_lifecycle_transition_t rcl_transition_on_deactivate_success = { + rcl_lifecycle_transition_success_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, + deactivating_state, inactive_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_deactivate_success, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from deactivating to active + { + rcl_lifecycle_transition_t rcl_transition_on_deactivate_failure = { + rcl_lifecycle_transition_failure_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE, + deactivating_state, active_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_deactivate_failure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from deactivating to errorprocessing + { + rcl_lifecycle_transition_t rcl_transition_on_deactivate_error = { + rcl_lifecycle_transition_error_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR, + deactivating_state, errorprocessing_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_deactivate_error, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from unconfigured to shuttingdown + { + rcl_lifecycle_transition_t rcl_transition_unconfigured_shutdown = { + rcl_lifecycle_shutdown_label, + lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, + unconfigured_state, shuttingdown_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_unconfigured_shutdown, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from inactive to shuttingdown + { + rcl_lifecycle_transition_t rcl_transition_inactive_shutdown = { + rcl_lifecycle_shutdown_label, + lifecycle_msgs__msg__Transition__TRANSITION_INACTIVE_SHUTDOWN, + inactive_state, shuttingdown_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_inactive_shutdown, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from active to shuttingdown + { + rcl_lifecycle_transition_t rcl_transition_active_shutdown = { + rcl_lifecycle_shutdown_label, + lifecycle_msgs__msg__Transition__TRANSITION_ACTIVE_SHUTDOWN, + active_state, shuttingdown_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_active_shutdown, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from shutting down to finalized + { + rcl_lifecycle_transition_t rcl_transition_on_shutdown_success = { + rcl_lifecycle_transition_success_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS, + shuttingdown_state, finalized_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_shutdown_success, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from shutting down to finalized + { + rcl_lifecycle_transition_t rcl_transition_on_shutdown_failure = { + rcl_lifecycle_transition_failure_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE, + shuttingdown_state, finalized_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_shutdown_failure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from shutting down to errorprocessing + { + rcl_lifecycle_transition_t rcl_transition_on_shutdown_error = { + rcl_lifecycle_transition_error_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR, + shuttingdown_state, errorprocessing_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_shutdown_error, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from errorprocessing to uncofigured + { + rcl_lifecycle_transition_t rcl_transition_on_error_success = { + rcl_lifecycle_transition_success_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, + errorprocessing_state, unconfigured_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_error_success, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from errorprocessing to finalized + { + rcl_lifecycle_transition_t rcl_transition_on_error_failure = { + rcl_lifecycle_transition_failure_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE, + errorprocessing_state, finalized_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_error_failure, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + // register transition from errorprocessing to finalized + { + rcl_lifecycle_transition_t rcl_transition_on_error_error = { + rcl_lifecycle_transition_error_label, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR, + errorprocessing_state, finalized_state + }; + ret = rcl_lifecycle_register_transition( + transition_map, + rcl_transition_on_error_error, + allocator); + if (ret != RCL_RET_OK) { + return ret; + } + } + + return ret; +} // default implementation as despicted on // design.ros2.org @@ -185,288 +656,39 @@ rcl_ret_t rcl_lifecycle_init_default_state_machine( rcl_lifecycle_state_machine_t * state_machine, const rcutils_allocator_t * allocator) { - rcutils_ret_t ret; - /* - * we once register all primary states - */ - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_unknown, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_unconfigured, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_inactive, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_active, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_finalized, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - /* - * we once register all transition states - */ - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_configuring, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_cleaningup, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_shuttingdown, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_activating, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_deactivating, allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_state( - &state_machine->transition_map, rcl_state_errorprocessing, allocator); + rcl_ret_t ret = RCL_RET_ERROR; + + // *************************** + // register all primary states + // *************************** + ret = _register_primary_states(&state_machine->transition_map, allocator); if (ret != RCL_RET_OK) { goto fail; } - /* - * we register all transitions from each primary state - * it registers the transition and the key on which to trigger - */ - // transition configure - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_configure, - lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_configure_success, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_configure_failure, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_configure_error, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, - allocator); + // ****************************** + // register all transition states + // ****************************** + ret = _register_transition_states(&state_machine->transition_map, allocator); if (ret != RCL_RET_OK) { goto fail; } - // transition cleanup - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_cleanup, - lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_cleanup_success, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_cleanup_failure, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_cleanup_error, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, - allocator); + // ************************ + // register all transitions + // ************************ + ret = _register_transitions(&state_machine->transition_map, allocator); if (ret != RCL_RET_OK) { goto fail; } - // transition activate - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_activate, - lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_activate_success, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_activate_failure, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_activate_error, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } + // ************************************* + // set the initial state to unconfigured + // ************************************* + state_machine->current_state = rcl_lifecycle_get_state( + &state_machine->transition_map, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); - // transition deactivate - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_deactivate, - lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_deactivate_success, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_deactivate_failure, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_deactivate_error, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - - // transition shutdown - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_unconfigured_shutdown, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_inactive_shutdown, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_active_shutdown, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_shutdown_success, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_shutdown_failure, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_shutdown_error, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - - // error state - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_error_success, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_error_failure, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - ret = rcl_lifecycle_register_transition( - &state_machine->transition_map, - rcl_transition_error_error, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, - allocator); - if (ret != RCL_RET_OK) { - goto fail; - } - - state_machine->current_state = &rcl_state_unconfigured; - - return RCL_RET_OK; + return ret; fail: if (rcl_lifecycle_transition_map_fini(&state_machine->transition_map, allocator) != RCL_RET_OK) { diff --git a/rcl_lifecycle/src/rcl_lifecycle.c b/rcl_lifecycle/src/rcl_lifecycle.c index 7b23cc1..5a1e746 100644 --- a/rcl_lifecycle/src/rcl_lifecycle.c +++ b/rcl_lifecycle/src/rcl_lifecycle.c @@ -17,6 +17,8 @@ extern "C" { #endif +#include "rcl_lifecycle/rcl_lifecycle.h" + #include #include #include @@ -27,12 +29,10 @@ extern "C" #include "rcutils/logging_macros.h" #include "rcutils/strdup.h" -#include "rcl_lifecycle/rcl_lifecycle.h" +#include "rcl_lifecycle/default_state_machine.h" #include "rcl_lifecycle/transition_map.h" -#include "com_interface.h" // NOLINT -#include "default_state_machine.h" // NOLINT -#include "states.h" // NOLINT +#include "./com_interface.h" rcl_lifecycle_state_t rcl_lifecycle_get_zero_initialized_state() @@ -192,6 +192,7 @@ rcl_lifecycle_state_machine_init( const rosidl_service_type_support_t * ts_srv_get_state, const rosidl_service_type_support_t * ts_srv_get_available_states, const rosidl_service_type_support_t * ts_srv_get_available_transitions, + const rosidl_service_type_support_t * ts_srv_get_transition_graph, bool default_states, const rcl_allocator_t * allocator) { @@ -205,7 +206,7 @@ rcl_lifecycle_state_machine_init( &state_machine->com_interface, node_handle, ts_pub_notify, ts_srv_change_state, ts_srv_get_state, - ts_srv_get_available_states, ts_srv_get_available_transitions, + ts_srv_get_available_states, ts_srv_get_available_transitions, ts_srv_get_transition_graph, allocator); if (ret != RCL_RET_OK) { return RCL_RET_ERROR; @@ -277,45 +278,57 @@ rcl_lifecycle_state_machine_is_initialized(const rcl_lifecycle_state_machine_t * } const rcl_lifecycle_transition_t * -rcl_lifecycle_is_valid_transition( - rcl_lifecycle_state_machine_t * state_machine, - rcl_lifecycle_transition_key_t key) +rcl_lifecycle_get_transition_by_id( + const rcl_lifecycle_state_t * state, + uint8_t id) { - unsigned int current_id = state_machine->current_state->id; - const rcl_lifecycle_state_t * current_state = rcl_lifecycle_get_state( - &state_machine->transition_map, current_id); + RCL_CHECK_FOR_NULL_WITH_MSG(state, + "state pointer is null", return NULL, rcl_get_default_allocator()); - RCL_CHECK_FOR_NULL_WITH_MSG(current_state, - "rcl_lifecycle_get_state returns NULL", return NULL, rcl_get_default_allocator()); - - for (unsigned int i = 0; i < current_state->valid_transition_size; ++i) { - if (current_state->valid_transition_keys[i] == key) { - return ¤t_state->valid_transitions[i]; + for (unsigned int i = 0; i < state->valid_transition_size; ++i) { + if (state->valid_transitions[i].id == id) { + return &state->valid_transitions[i]; } } RCUTILS_LOG_WARN_NAMED( ROS_PACKAGE_NAME, - "No callback transition matching %d found for current state %s", - key, state_machine->current_state->label); + "No transition matching %d found for current state %s", + id, state->label); + + return NULL; +} + +const rcl_lifecycle_transition_t * +rcl_lifecycle_get_transition_by_label( + const rcl_lifecycle_state_t * state, + const char * label) +{ + RCL_CHECK_FOR_NULL_WITH_MSG(state, + "state pointer is null", return NULL, rcl_get_default_allocator()); + + for (unsigned int i = 0; i < state->valid_transition_size; ++i) { + if (strcmp(state->valid_transitions[i].label, label) == 0) { + return &state->valid_transitions[i]; + } + } + + RCUTILS_LOG_WARN_NAMED( + ROS_PACKAGE_NAME, + "No transition matching %s found for current state %s", + label, state->label); return NULL; } rcl_ret_t -rcl_lifecycle_trigger_transition( +_trigger_transition( rcl_lifecycle_state_machine_t * state_machine, - rcl_lifecycle_transition_key_t key, bool publish_notification) + const rcl_lifecycle_transition_t * transition, + bool publish_notification) { - const rcl_lifecycle_transition_t * transition = - rcl_lifecycle_is_valid_transition(state_machine, key); - // If we have a faulty transition pointer if (!transition) { - RCUTILS_LOG_ERROR_NAMED( - ROS_PACKAGE_NAME, - "No transition found for node %s with key %d", - state_machine->current_state->label, key); RCL_SET_ERROR_MSG("Transition is not registered.", rcl_get_default_allocator()); return RCL_RET_ERROR; } @@ -326,6 +339,7 @@ rcl_lifecycle_trigger_transition( return RCL_RET_ERROR; } state_machine->current_state = transition->goal; + if (publish_notification) { rcl_ret_t ret = rcl_lifecycle_com_interface_publish_notification( &state_machine->com_interface, transition->start, state_machine->current_state); @@ -338,6 +352,39 @@ rcl_lifecycle_trigger_transition( return RCL_RET_OK; } +rcl_ret_t +rcl_lifecycle_trigger_transition_by_id( + rcl_lifecycle_state_machine_t * state_machine, + uint8_t id, + bool publish_notification) +{ + if (!state_machine) { + RCUTILS_LOG_ERROR_NAMED(ROS_PACKAGE_NAME, "state machine pointer is null"); + return RCL_RET_ERROR; + } + + const rcl_lifecycle_transition_t * transition = + rcl_lifecycle_get_transition_by_id(state_machine->current_state, id); + + return _trigger_transition(state_machine, transition, publish_notification); +} + +rcl_ret_t +rcl_lifecycle_trigger_transition_by_label( + rcl_lifecycle_state_machine_t * state_machine, + const char * label, + bool publish_notification) +{ + if (!state_machine) { + RCUTILS_LOG_ERROR_NAMED(ROS_PACKAGE_NAME, "state machine pointer is null"); + return RCL_RET_ERROR; + } + + const rcl_lifecycle_transition_t * transition = + rcl_lifecycle_get_transition_by_label(state_machine->current_state, label); + + return _trigger_transition(state_machine, transition, publish_notification); +} void rcl_print_state_machine(const rcl_lifecycle_state_machine_t * state_machine) @@ -353,9 +400,8 @@ rcl_print_state_machine(const rcl_lifecycle_state_machine_t * state_machine) for (size_t j = 0; j < map->states[i].valid_transition_size; ++j) { RCUTILS_LOG_INFO_NAMED( ROS_PACKAGE_NAME, - "\tNode %s: Key %d: Transition: %s", + "\tNode %s: Transition: %s", map->states[i].label, - map->states[i].valid_transition_keys[j], map->states[i].valid_transitions[j].label); } } diff --git a/rcl_lifecycle/src/states.h b/rcl_lifecycle/src/states.h deleted file mode 100644 index 0da6689..0000000 --- a/rcl_lifecycle/src/states.h +++ /dev/null @@ -1,51 +0,0 @@ -// Copyright 2015 Open Source Robotics Foundation, Inc. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#ifndef STATES_H_ -#define STATES_H_ - -#include "rcl_lifecycle/data_types.h" -#include "rcl_lifecycle/visibility_control.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -// primary states based on -// design.ros2.org/articles/node_lifecycle.html -extern rcl_lifecycle_state_t rcl_state_unknown; -extern rcl_lifecycle_state_t rcl_state_unconfigured; -extern rcl_lifecycle_state_t rcl_state_inactive; -extern rcl_lifecycle_state_t rcl_state_active; -extern rcl_lifecycle_state_t rcl_state_finalized; - -extern rcl_lifecycle_state_t rcl_state_configuring; -extern rcl_lifecycle_state_t rcl_state_cleaningup; -extern rcl_lifecycle_state_t rcl_state_shuttingdown; -extern rcl_lifecycle_state_t rcl_state_activating; -extern rcl_lifecycle_state_t rcl_state_deactivating; -extern rcl_lifecycle_state_t rcl_state_errorprocessing; - -extern const rcl_lifecycle_transition_t rcl_transition_configure; -extern const rcl_lifecycle_transition_t rcl_transition_cleanup; -extern const rcl_lifecycle_transition_t rcl_transition_shutdown; -extern const rcl_lifecycle_transition_t rcl_transition_activate; -extern const rcl_lifecycle_transition_t rcl_transition_deactivate; - -#ifdef __cplusplus -} -#endif // extern "C" - -#endif // STATES_H_ diff --git a/rcl_lifecycle/src/transition_map.c b/rcl_lifecycle/src/transition_map.c index c6fb76e..b242b9b 100644 --- a/rcl_lifecycle/src/transition_map.c +++ b/rcl_lifecycle/src/transition_map.c @@ -55,11 +55,6 @@ rcl_lifecycle_transition_map_fini( { rcl_ret_t fcn_ret = RCL_RET_OK; - // for each state free the allocations for their keys/transitions - for (unsigned int i = 0; i < transition_map->states_size; ++i) { - allocator->deallocate(transition_map->states[i].valid_transition_keys, allocator->state); - allocator->deallocate(transition_map->states[i].valid_transitions, allocator->state); - } // free the primary states allocator->deallocate(transition_map->states, allocator->state); transition_map->states = NULL; @@ -106,7 +101,6 @@ rcl_ret_t rcl_lifecycle_register_transition( rcl_lifecycle_transition_map_t * transition_map, rcl_lifecycle_transition_t transition, - rcl_lifecycle_transition_key_t key, const rcutils_allocator_t * allocator) { RCUTILS_CHECK_ALLOCATOR_WITH_MSG( @@ -135,7 +129,6 @@ rcl_lifecycle_register_transition( // finally set the new transition to the end of the array transition_map->transitions[transition_map->transitions_size - 1] = transition; - // connect transition to state key // we have to copy the transitons here once more to the actual state // as we can't assign only the pointer. This pointer gets invalidated whenever // we add a new transition and re-shuffle/re-allocate new memory for it. @@ -152,20 +145,6 @@ rcl_lifecycle_register_transition( } state->valid_transitions = new_valid_transitions; - rcl_lifecycle_transition_key_t * new_valid_transition_keys = allocator->reallocate( - state->valid_transition_keys, - state->valid_transition_size * sizeof(rcl_lifecycle_transition_key_t), - allocator->state); - if (!new_valid_transitions) { - RCL_SET_ERROR_MSG( - "failed to reallocate memory for new transitions keys on state", - rcl_get_default_allocator()); - return RCL_RET_ERROR; - } - state->valid_transition_keys = new_valid_transition_keys; - - // assign key - state->valid_transition_keys[state->valid_transition_size - 1] = key; state->valid_transitions[state->valid_transition_size - 1] = transition; return RCL_RET_OK; diff --git a/rcl_lifecycle/test/test_default_state_machine.cpp b/rcl_lifecycle/test/test_default_state_machine.cpp index a3a1f4c..5ba1ec7 100644 --- a/rcl_lifecycle/test/test_default_state_machine.cpp +++ b/rcl_lifecycle/test/test_default_state_machine.cpp @@ -28,8 +28,7 @@ #include "rcutils/logging_macros.h" #include "rcl_lifecycle/rcl_lifecycle.h" - -#include "../src/default_state_machine.h" +#include "rcl_lifecycle/default_state_machine.h" class TestDefaultStateMachine : public ::testing::Test { @@ -62,48 +61,47 @@ protected: } }; -std::vector keys = -{ - lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE, - lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE, - lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE, - lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR -}; - void test_trigger_transition( rcl_lifecycle_state_machine_t * state_machine, - int key, + uint8_t key_id, unsigned int expected_current_state, unsigned int expected_goal_state) { EXPECT_EQ( expected_current_state, state_machine->current_state->id); EXPECT_EQ( - RCL_RET_OK, rcl_lifecycle_trigger_transition( - state_machine, key, false)); + RCL_RET_OK, rcl_lifecycle_trigger_transition_by_id( + state_machine, key_id, false)); EXPECT_EQ( expected_goal_state, state_machine->current_state->id); } + /* * Test suite */ TEST_F(TestDefaultStateMachine, zero_init) { rcl_lifecycle_state_machine_t state_machine = rcl_lifecycle_get_zero_initialized_state_machine(); - ASSERT_EQ(rcl_lifecycle_state_machine_is_initialized(&state_machine), RCL_RET_ERROR); + EXPECT_EQ(rcl_lifecycle_state_machine_is_initialized(&state_machine), RCL_RET_ERROR); rcl_reset_error(); const rcl_lifecycle_transition_map_t * transition_map = &state_machine.transition_map; - ASSERT_EQ(transition_map->states_size, (unsigned int)0); - ASSERT_EQ(transition_map->states, nullptr); - ASSERT_EQ(transition_map->transitions_size, (unsigned int)0); - ASSERT_EQ(transition_map->transitions, nullptr); + EXPECT_EQ(transition_map->states_size, 0u); + EXPECT_EQ(transition_map->states, nullptr); + EXPECT_EQ(transition_map->transitions_size, 0u); + EXPECT_EQ(transition_map->transitions, nullptr); auto ret = rcl_lifecycle_state_machine_fini(&state_machine, this->node_ptr, this->allocator); - ASSERT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe(); + EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe(); +} + +TEST_F(TestDefaultStateMachine, default_init) { + rcl_lifecycle_state_machine_t state_machine = rcl_lifecycle_get_zero_initialized_state_machine(); + + auto ret = rcl_lifecycle_init_default_state_machine(&state_machine, this->allocator); + EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe(); + + ret = rcl_lifecycle_state_machine_fini(&state_machine, this->node_ptr, this->allocator); + EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe(); } TEST_F(TestDefaultStateMachine, default_sequence) { @@ -121,7 +119,7 @@ TEST_F(TestDefaultStateMachine, default_sequence) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -133,7 +131,7 @@ TEST_F(TestDefaultStateMachine, default_sequence) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); @@ -145,7 +143,7 @@ TEST_F(TestDefaultStateMachine, default_sequence) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -157,19 +155,19 @@ TEST_F(TestDefaultStateMachine, default_sequence) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, + lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); @@ -184,13 +182,39 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { ret = rcl_lifecycle_init_default_state_machine(&state_machine, this->allocator); EXPECT_EQ(RCL_RET_OK, ret) << rcl_get_error_string_safe(); + std::vector transition_ids = + { + lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE, + lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP, + lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE, + lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE, + lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR, + }; + { // supposed to stay unconfigured for all invalid - for (auto it = keys.begin(); it != keys.end(); ++it) { + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CONFIGURE || *it == lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN) {continue;} - EXPECT_EQ( - RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ( state_machine.current_state->id, @@ -205,12 +229,12 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING); - for (auto it = keys.begin(); it != keys.end(); ++it) { - if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR) {continue;} + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { + if (*it == lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR) {continue;} - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING); @@ -220,18 +244,17 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { { // supposed to stay inactive for all invalid test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); - for (auto it = keys.begin(); it != keys.end(); ++it) { + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CLEANUP || *it == lifecycle_msgs__msg__Transition__TRANSITION_ACTIVATE || *it == lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN) {continue;} RCUTILS_LOG_INFO_NAMED(ROS_PACKAGE_NAME, "applying key %u", *it); - EXPECT_EQ( - RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -245,12 +268,12 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING); - for (auto it = keys.begin(); it != keys.end(); ++it) { - if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR) {continue;} + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { + if (*it == lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR) {continue;} - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING); @@ -260,16 +283,16 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { { // supposed to stay active for all invalid test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); - for (auto it = keys.begin(); it != keys.end(); ++it) { + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { if (*it == lifecycle_msgs__msg__Transition__TRANSITION_DEACTIVATE || *it == lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN) {continue;} - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); @@ -283,12 +306,12 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING); - for (auto it = keys.begin(); it != keys.end(); ++it) { - if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR) {continue;} + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { + if (*it == lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR) {continue;} - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING); @@ -299,7 +322,7 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { // skip inactive, we tested that already test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); test_trigger_transition( @@ -308,12 +331,12 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP); - for (auto it = keys.begin(); it != keys.end(); ++it) { - if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR) {continue;} + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { + if (*it == lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR) {continue;} - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP); @@ -323,22 +346,22 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { { // supposed to stay shutting down for all invalid test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); // shutdown directly, since we tested already unconfigured test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, + lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); - for (auto it = keys.begin(); it != keys.end(); ++it) { - if (*it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE || - *it == lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR) {continue;} + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { + if (*it == lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE || + *it == lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR) {continue;} - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); @@ -348,12 +371,12 @@ TEST_F(TestDefaultStateMachine, wrong_default_sequence) { { // supposed to stay finalized for all invalid test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); - for (auto it = keys.begin(); it != keys.end(); ++it) { - EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition(&state_machine, *it, false)); + for (auto it = transition_ids.begin(); it != transition_ids.end(); ++it) { + EXPECT_EQ(RCL_RET_ERROR, rcl_lifecycle_trigger_transition_by_id(&state_machine, *it, false)); rcl_reset_error(); EXPECT_EQ(state_machine.current_state->id, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); @@ -380,7 +403,7 @@ TEST_F(TestDefaultStateMachine, default_in_a_loop) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -392,7 +415,7 @@ TEST_F(TestDefaultStateMachine, default_in_a_loop) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); @@ -404,7 +427,7 @@ TEST_F(TestDefaultStateMachine, default_in_a_loop) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -416,20 +439,20 @@ TEST_F(TestDefaultStateMachine, default_in_a_loop) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); } test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, + lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); @@ -452,7 +475,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_FAILURE, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); @@ -465,7 +488,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -477,7 +500,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_FAILURE, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -490,7 +513,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); test_trigger_transition( @@ -501,7 +524,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_FAILURE, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); @@ -513,7 +536,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); test_trigger_transition( @@ -523,7 +546,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_FAILURE, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -535,17 +558,17 @@ TEST_F(TestDefaultStateMachine, default_sequence_failure) { lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, + lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_FAILURE, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); @@ -568,13 +591,13 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); @@ -587,7 +610,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -599,13 +622,13 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); @@ -618,7 +641,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -630,7 +653,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__PRIMARY_STATE_ACTIVE); @@ -641,13 +664,13 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_DEACTIVATE_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_DEACTIVATING, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); @@ -659,7 +682,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); test_trigger_transition( @@ -669,30 +692,30 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_resolved) { lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CLEANUP_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_CLEANINGUP, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); ///////////////////////////// test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_SHUTDOWN, + lifecycle_msgs__msg__Transition__TRANSITION_UNCONFIGURED_SHUTDOWN, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_SHUTDOWN_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_SHUTTINGDOWN, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_UNCONFIGURED); @@ -717,13 +740,13 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_unresolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_FAILURE, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_FAILURE, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); @@ -745,7 +768,7 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_unresolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_SUCCESS, + lifecycle_msgs__msg__Transition__TRANSITION_ON_CONFIGURE_SUCCESS, lifecycle_msgs__msg__State__TRANSITION_STATE_CONFIGURING, lifecycle_msgs__msg__State__PRIMARY_STATE_INACTIVE); @@ -757,14 +780,17 @@ TEST_F(TestDefaultStateMachine, default_sequence_error_unresolved) { test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ACTIVATE_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_ACTIVATING, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING); test_trigger_transition( &state_machine, - lifecycle_msgs__msg__Transition__TRANSITION_CALLBACK_ERROR, + lifecycle_msgs__msg__Transition__TRANSITION_ON_ERROR_ERROR, lifecycle_msgs__msg__State__TRANSITION_STATE_ERRORPROCESSING, lifecycle_msgs__msg__State__PRIMARY_STATE_FINALIZED); + + EXPECT_EQ(RCL_RET_OK, + rcl_lifecycle_state_machine_fini(&state_machine, this->node_ptr, this->allocator)); } } diff --git a/rcl_lifecycle/test/test_multiple_instances.cpp b/rcl_lifecycle/test/test_multiple_instances.cpp index f5cfdca..133237b 100644 --- a/rcl_lifecycle/test/test_multiple_instances.cpp +++ b/rcl_lifecycle/test/test_multiple_instances.cpp @@ -26,8 +26,7 @@ #include "rcl/rcl.h" #include "rcl_lifecycle/rcl_lifecycle.h" - -#include "../src/default_state_machine.h" +#include "rcl_lifecycle/default_state_machine.h" class TestMultipleInstances : public ::testing::Test { @@ -62,15 +61,15 @@ protected: void test_trigger_transition( rcl_lifecycle_state_machine_t * state_machine, - int key, + uint8_t key_id, unsigned int expected_current_state, unsigned int expected_goal_state) { EXPECT_EQ( expected_current_state, state_machine->current_state->id); EXPECT_EQ( - RCL_RET_OK, rcl_lifecycle_trigger_transition( - state_machine, key, false)); + RCL_RET_OK, rcl_lifecycle_trigger_transition_by_id( + state_machine, key_id, false)); EXPECT_EQ( expected_goal_state, state_machine->current_state->id); } diff --git a/rcl_lifecycle/test/test_transition_map.cpp b/rcl_lifecycle/test/test_transition_map.cpp index 77d69af..6bb3b86 100644 --- a/rcl_lifecycle/test/test_transition_map.cpp +++ b/rcl_lifecycle/test/test_transition_map.cpp @@ -20,6 +20,7 @@ #include "rcl/error_handling.h" +#include "rcl_lifecycle/rcl_lifecycle.h" #include "rcl_lifecycle/transition_map.h" class TestTransitionMap : public ::testing::Test @@ -50,7 +51,7 @@ TEST_F(TestTransitionMap, initialized) { rcl_allocator_t allocator = rcl_get_default_allocator(); - rcl_lifecycle_state_t state0 = {"my_state", 0, NULL, NULL, 0}; + rcl_lifecycle_state_t state0 = {"my_state_0", 0, NULL, 0}; rcl_ret_t ret = rcl_lifecycle_register_state(&transition_map, state0, &allocator); EXPECT_EQ(RCL_RET_OK, ret); EXPECT_EQ(RCL_RET_OK, rcl_lifecycle_transition_map_is_initialized(&transition_map)); @@ -58,7 +59,7 @@ TEST_F(TestTransitionMap, initialized) { ret = rcl_lifecycle_register_state(&transition_map, state0, &allocator); EXPECT_EQ(RCL_RET_ERROR, ret) << rcl_get_error_string_safe(); - rcl_lifecycle_state_t state1 = {"my_state", 1, NULL, NULL, 0}; + rcl_lifecycle_state_t state1 = {"my_state_1", 1, NULL, 0}; ret = rcl_lifecycle_register_state(&transition_map, state1, &allocator); rcl_lifecycle_state_t * start_state = @@ -71,7 +72,24 @@ TEST_F(TestTransitionMap, initialized) { rcl_lifecycle_transition_t transition01 = {"from0to1", 0, start_state, goal_state}; ret = rcl_lifecycle_register_transition( - &transition_map, transition01, 0, &allocator); + &transition_map, transition01, &allocator); EXPECT_EQ(RCL_RET_OK, ret); + + rcl_lifecycle_transition_t transition10 = {"from1to0", 1, + goal_state, start_state}; + ret = rcl_lifecycle_register_transition( + &transition_map, transition10, &allocator); + EXPECT_EQ(RCL_RET_OK, ret); + + const rcl_lifecycle_transition_t * trans = + rcl_lifecycle_get_transition_by_id(start_state, 0); + EXPECT_EQ(0u, trans->id); + trans = rcl_lifecycle_get_transition_by_label(start_state, "from0to1"); + EXPECT_EQ(0u, trans->id); + trans = rcl_lifecycle_get_transition_by_id(goal_state, 1); + EXPECT_EQ(1u, trans->id); + trans = rcl_lifecycle_get_transition_by_label(goal_state, "from1to0"); + EXPECT_EQ(1u, trans->id); + EXPECT_EQ(RCL_RET_OK, rcl_lifecycle_transition_map_fini(&transition_map, &allocator)); }