subsystem_controllers::PluginManager Class Reference

The PluginManager serves as a component to manage CARMA Guidance Plugins via their ros2 lifecycle interfaces. More...

#include <plugin_manager.h>

Collaboration diagram for subsystem_controllers::PluginManager:

Public Member Functions
	PluginManager (const std::vector< std::string > &required_plugins, const std::vector< std::string > &auto_activated_plugins, std::shared_ptr< ros2_lifecycle_manager::LifecycleManagerInterface > plugin_lifecycle_mgr, GetParentNodeStateFunc get_parent_state_func, ServiceNamesAndTypesFunc get_service_names_and_types_func, std::chrono::nanoseconds service_timeout, std::chrono::nanoseconds call_timeout)
	Constructor for PluginManager. More...
bool	configure ()
bool	activate ()
bool	deactivate ()
bool	cleanup ()
bool	shutdown ()
void	update_plugin_status (carma_planning_msgs::msg::Plugin::UniquePtr msg)
	Update the status of a certain plugin. More...
void	get_registered_plugins (SrvHeader, carma_planning_msgs::srv::PluginList::Request::SharedPtr req, carma_planning_msgs::srv::PluginList::Response::SharedPtr res)
	Returns the list of known plugins. More...
void	get_active_plugins (SrvHeader, carma_planning_msgs::srv::PluginList::Request::SharedPtr req, carma_planning_msgs::srv::PluginList::Response::SharedPtr res)
	Get the list of currently active plugins. More...
void	activate_plugin (SrvHeader, carma_planning_msgs::srv::PluginActivation::Request::SharedPtr req, carma_planning_msgs::srv::PluginActivation::Response::SharedPtr res)
	Activate the specified plugin. More...
void	get_strategic_plugins_by_capability (SrvHeader, carma_planning_msgs::srv::GetPluginApi::Request::SharedPtr req, carma_planning_msgs::srv::GetPluginApi::Response::SharedPtr res)
	Get strategic plugins by capability. More...
void	get_tactical_plugins_by_capability (SrvHeader, carma_planning_msgs::srv::GetPluginApi::Request::SharedPtr req, carma_planning_msgs::srv::GetPluginApi::Response::SharedPtr res)
	Get tactical plugins by capability. More...
void	get_control_plugins_by_capability (SrvHeader, carma_planning_msgs::srv::GetPluginApi::Request::SharedPtr req, carma_planning_msgs::srv::GetPluginApi::Response::SharedPtr res)
	Get control plugins by capability. More...

Protected Member Functions
void	add_plugin (const Entry &plugin)
	Add the specified entry to our plugin management This function will attempt to move the newly detected plugin to the required state based on this nodes own state. More...
bool	matching_capability (const std::vector< std::string > &base_capability_levels, const std::vector< std::string > &compared_capability_levels)
	Returns true if the provided base capability hierarchy can achieve the requested capability hierarchy A capability hierarchy is described as a list of strings where the first string is the most generic description of the capability while the last string the is the most detailed description. More...
bool	is_ros2_lifecycle_node (const std::string &node)
	Returns true if the specified fully qualified node name is a ROS2 lifecycle node. More...

Protected Attributes
std::unordered_set< std::string >	required_plugins_
	Set of required plugins a failure of which necessitates system shutdown. More...
std::unordered_set< std::string >	auto_activated_plugins_
	Set of use specified auto activated plugins which will automatically started without need for user input. More...
std::shared_ptr< ros2_lifecycle_manager::LifecycleManagerInterface >	plugin_lifecycle_mgr_
	Lifecycle Manager which will track the plugin nodes and call their lifecycle services on request. More...
GetParentNodeStateFunc	get_parent_state_func_
	Callback to retrieve the lifecycle state of the parent process. More...
ServiceNamesAndTypesFunc	get_service_names_and_types_func_
	Callback to get service names and types for the given node. More...
EntryManager	em_
	Entry manager to keep track of detected plugins. More...
std::chrono::nanoseconds	service_timeout_
	The timeout for services to be available. More...
std::chrono::nanoseconds	call_timeout_
	The timeout for service calls to return. More...
const std::string	plan_maneuvers_suffix_ = "/plan_maneuvers"
	Base service name of plan_trajectory service. More...
const std::string	plan_trajectory_suffix_ = "/plan_trajectory"
	Base service name of plan_trajectory service. More...
const std::string	control_trajectory_suffix_ = "/plan_trajectory"
	Base topic name of control plugin trajectory input topic. More...

Detailed Description

The PluginManager serves as a component to manage CARMA Guidance Plugins via their ros2 lifecycle interfaces.

Definition at line 48 of file plugin_manager.h.

Constructor & Destructor Documentation

PluginManager()

subsystem_controllers::PluginManager::PluginManager	(	const std::vector< std::string > &	required_plugins,
		const std::vector< std::string > &	auto_activated_plugins,
		std::shared_ptr< ros2_lifecycle_manager::LifecycleManagerInterface >	plugin_lifecycle_mgr,
		GetParentNodeStateFunc	get_parent_state_func,
		ServiceNamesAndTypesFunc	get_service_names_and_types_func,
		std::chrono::nanoseconds	service_timeout,
		std::chrono::nanoseconds	call_timeout
	)

Constructor for PluginManager.

Parameters

required_plugins	The set of plugins which will be treated as required. A failure in these plugins will result in an exception
auto_activated_plugins	The set of plugins which will be automatically activated at first system activation but not treated specially after that.
plugin_lifecycle_mgr	A fully initialized lifecycle manager which will be used trigger plugin transitions
get_parent_state_func	A callback which will allow this object to access the parent process lifecycle state
get_service_names_and_types_func	A callback which returns a map of service names to service types based on the provided base node name and namespace
service_timeout	The timeout for plugin services to be available in nanoseconds
call_timeout	The timeout for calls to plugin services to fail in nanoseconds

Definition at line 28 of file plugin_manager.cpp.

        : required_plugins_(required_plugins.begin(), required_plugins.end()),
            auto_activated_plugins_(auto_activated_plugins.begin(), auto_activated_plugins.end()),
            plugin_lifecycle_mgr_(plugin_lifecycle_mgr), get_parent_state_func_(get_parent_state_func),
            get_service_names_and_types_func_(get_service_names_and_types_func),
            service_timeout_(service_timeout), call_timeout_(call_timeout)
    {
        if (!plugin_lifecycle_mgr)
            throw std::invalid_argument("Input plugin_lifecycle_mgr to PluginManager constructor cannot be null");
 
        // For all required and auto activated plugins add unknown entries but with
        // user_requested_activation set to true.
        // This will be used later to determine how to transition the plugin specified by that entry
 
        for (const auto& p : required_plugins_) {
            RCLCPP_INFO_STREAM(rclcpp::get_logger("subsystem_controllers"), "Added a required plugin: " << p);
 
            Entry e(false, false, p, carma_planning_msgs::msg::Plugin::UNKNOWN, "", true);
            em_.update_entry(e);
            plugin_lifecycle_mgr_->add_managed_node(p);
        }
 
        for (const auto& p : auto_activated_plugins_) {
            RCLCPP_INFO_STREAM(rclcpp::get_logger("subsystem_controllers"), "Added an auto activated plugin: " << p);
 
            Entry e(false, false, p, carma_planning_msgs::msg::Plugin::UNKNOWN, "", true);
            em_.update_entry(e);
            plugin_lifecycle_mgr_->add_managed_node(p);
        }
    }

References auto_activated_plugins_, em_, plugin_lifecycle_mgr_, required_plugins_, and subsystem_controllers::EntryManager::update_entry().

Here is the call graph for this function:

Member Function Documentation

activate()

bool subsystem_controllers::PluginManager::activate

(

)

Definition at line 166 of file plugin_manager.cpp.

    {
        bool full_success = true;
        // Bring all required or auto activated plugins to the active state
        for (auto plugin : em_.get_entries())
        {
            // If this is not a plugin slated for activation then continue and leave up to user to activate manually later
            if (!plugin.user_requested_activation_)
                continue;
 
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE, plugin.name_, service_timeout_, call_timeout_);
 
            if(result_state != lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE)
            {
                // If this plugin was required then trigger exception
                if (required_plugins_.find(plugin.name_) != required_plugins_.end())
                {
                    throw std::runtime_error("Required plugin " + plugin.name_ + " could not be activated.");
                }
 
                // If this plugin was not required log an error and mark it is unavailable and deactivated
                RCLCPP_ERROR_STREAM(rclcpp::get_logger("subsystem_controllers"), "Failed to activate newly discovered non-required plugin: "
                    << plugin.name_ << " Marking as deactivated and unavailable!");
 
                Entry deactivated_entry = plugin;
                deactivated_entry.active_ = false;
                deactivated_entry.available_ = false;
                deactivated_entry.user_requested_activation_ = false;
                em_.update_entry(deactivated_entry);
 
                full_success = false;
            }
 
            // If this was an auto activated plugin and not required then we only activate is once
            if (auto_activated_plugins_.find(plugin.name_) != auto_activated_plugins_.end())
            {
                plugin.user_requested_activation_ = false;
            }
 
            plugin.active_ = true; // Mark plugin as active
 
            em_.update_entry(plugin);
 
        }
 
        return full_success;
    }

References subsystem_controllers::Entry::active_, auto_activated_plugins_, subsystem_controllers::Entry::available_, call_timeout_, em_, subsystem_controllers::EntryManager::get_entries(), plugin_lifecycle_mgr_, required_plugins_, service_timeout_, subsystem_controllers::EntryManager::update_entry(), and subsystem_controllers::Entry::user_requested_activation_.

Here is the call graph for this function:

activate_plugin()

void subsystem_controllers::PluginManager::activate_plugin	(	SrvHeader	,
		carma_planning_msgs::srv::PluginActivation::Request::SharedPtr	req,
		carma_planning_msgs::srv::PluginActivation::Response::SharedPtr	res
	)

Activate the specified plugin.

Parameters

	header	Middle ware header
	req	The req details containing the plugin to activate
[out]	res	The response containing the success flag

Definition at line 320 of file plugin_manager.cpp.

    {
        boost::optional<Entry> requested_plugin = em_.get_entry_by_name(req->plugin_name);
 
        if(!requested_plugin) // If not a known plugin then obviously not activated. Though really it would be better to have an indication of name failure in the message
        {
            res->newstate = false;
            return;
        }
 
        bool activated = false;
        if (req->activated)
        {
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE, requested_plugin->name_, service_timeout_, call_timeout_);
 
            activated = (result_state == lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE);
        } else {
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE, requested_plugin->name_, service_timeout_, call_timeout_);
 
            activated = (result_state == lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE);
        }
 
        Entry updated_entry(requested_plugin->available_, activated, requested_plugin->name_, requested_plugin->type_, requested_plugin->capability_, true); // Mark as user activated
        em_.update_entry(updated_entry);
 
        res->newstate = activated;
    }

References call_timeout_, em_, subsystem_controllers::EntryManager::get_entry_by_name(), plugin_lifecycle_mgr_, service_timeout_, and subsystem_controllers::EntryManager::update_entry().

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

add_plugin()

void subsystem_controllers::PluginManager::add_plugin ( const Entry &  plugin )

protected

Add the specified entry to our plugin management This function will attempt to move the newly detected plugin to the required state based on this nodes own state.

Parameters

plugin

The entry representing the plugin to add

Exceptions

std::runtime_error

if this was a required plugin and it could not be transitioned as needed

Definition at line 64 of file plugin_manager.cpp.

    {
        plugin_lifecycle_mgr_->add_managed_node(plugin.name_);
 
        em_.update_entry(plugin);
 
        Entry deactivated_entry = plugin;
 
        auto parent_node_state = get_parent_state_func_();
 
        // If this node is not in the active or inactive states then move the plugin to unconfigured
        if (parent_node_state != lifecycle_msgs::msg::State::PRIMARY_STATE_ACTIVE
            && parent_node_state != lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE)
        {
 
            deactivated_entry.active_ = false;
 
            // Move plugin to match this nodes state
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(parent_node_state, plugin.name_, service_timeout_, call_timeout_);
 
            if(result_state != parent_node_state)
            {
 
                // If this plugin was required then trigger exception
                if (required_plugins_.find(plugin.name_) != required_plugins_.end())
                {
                    throw std::runtime_error("Newly discovered required plugin " + plugin.name_ + " could not be brought to controller node state.");
                }
 
                // If this plugin was not required log an error and mark it is unavailable and deactivated
                RCLCPP_ERROR_STREAM(rclcpp::get_logger("subsystem_controllers"), "Failed to transition newly discovered non-required plugin: "
                    << plugin.name_ << " Marking as deactivated and unavailable!");
 
                deactivated_entry.available_ = false;
 
            }
 
            em_.update_entry(deactivated_entry);
            return;
        }
 
 
        // If the node is active or inactive then,
        // when adding a plugin, it should be brought to the inactive state
        // We do not need transition it beyond inactive in this function as that will be managed by the plugin activation process via UI or parameters
        auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE, plugin.name_, service_timeout_, call_timeout_);
 
        if(result_state != lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE)
        {
            // If this plugin was required then trigger exception
            if (required_plugins_.find(plugin.name_) != required_plugins_.end())
            {
                throw std::runtime_error("Newly discovered required plugin " + plugin.name_ + " could not be brought to inactive state.");
            }
 
            // If this plugin was not required log an error and mark it is unavailable and deactivated
            RCLCPP_ERROR_STREAM(rclcpp::get_logger("subsystem_controllers"), "Failed to configure newly discovered non-required plugin: "
                << plugin.name_ << " Marking as deactivated and unavailable!");
 
            deactivated_entry.available_ = false;
        }
 
        deactivated_entry.active_ = false;
        em_.update_entry(deactivated_entry);
 
    }

References subsystem_controllers::Entry::active_, subsystem_controllers::Entry::available_, call_timeout_, em_, get_parent_state_func_, subsystem_controllers::Entry::name_, plugin_lifecycle_mgr_, required_plugins_, service_timeout_, and subsystem_controllers::EntryManager::update_entry().

Referenced by update_plugin_status().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup()

bool subsystem_controllers::PluginManager::cleanup

(

)

Definition at line 248 of file plugin_manager.cpp.

    {
        bool full_success = true;
        // Bring all required or auto activated plugins to the unconfigured state
        for (auto plugin : em_.get_entries())
        {
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_UNCONFIGURED, plugin.name_, service_timeout_, call_timeout_);
 
            if(result_state != lifecycle_msgs::msg::State::PRIMARY_STATE_UNCONFIGURED)
            {
                // If this plugin was required then trigger exception
                if (required_plugins_.find(plugin.name_) != required_plugins_.end())
                {
                    throw std::runtime_error("Required plugin " + plugin.name_ + " could not be cleaned up.");
                }
 
                // If this plugin was not required log an error and mark it is unavailable and deactivated
                RCLCPP_ERROR_STREAM(rclcpp::get_logger("subsystem_controllers"), "Failed to cleanup non-required plugin: "
                    << plugin.name_ << " Marking as deactivated and unavailable!");
 
                Entry deactivated_entry = plugin;
                deactivated_entry.active_ = false;
                deactivated_entry.available_ = false;
                deactivated_entry.user_requested_activation_ = false;
                em_.update_entry(deactivated_entry);
 
                full_success = false;
            }
 
        }
 
        return full_success;
    }

References subsystem_controllers::Entry::active_, subsystem_controllers::Entry::available_, call_timeout_, em_, subsystem_controllers::EntryManager::get_entries(), plugin_lifecycle_mgr_, required_plugins_, service_timeout_, subsystem_controllers::EntryManager::update_entry(), and subsystem_controllers::Entry::user_requested_activation_.

Here is the call graph for this function:

configure()

bool subsystem_controllers::PluginManager::configure

(

)

Below are the state transition methods which will cause this manager to trigger the corresponding state transitions in the managed plugins.

Exceptions

std::runtime_error

If a required node could not transition successfully

Returns

True if all components transitioned successfully

Definition at line 131 of file plugin_manager.cpp.

    {
        bool full_success = true;
        // Bring all known plugins to the inactive state
        for (auto plugin : em_.get_entries())
        {
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE, plugin.name_, service_timeout_, call_timeout_);
 
            if(result_state != lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE)
            {
                // If this plugin was required then trigger exception
                if (required_plugins_.find(plugin.name_) != required_plugins_.end())
                {
                    throw std::runtime_error("Required plugin " + plugin.name_ + " could not be configured.");
                }
 
                // If this plugin was not required log an error and mark it is unavailable and deactivated
                RCLCPP_ERROR_STREAM(rclcpp::get_logger("subsystem_controllers"), "Failed to configure newly discovered non-required plugin: "
                    << plugin.name_ << " Marking as deactivated and unavailable!");
 
                Entry deactivated_entry = plugin;
                deactivated_entry.active_ = false;
                deactivated_entry.available_ = false;
                deactivated_entry.user_requested_activation_ = false;
                em_.update_entry(deactivated_entry);
 
                full_success = false;
            }
 
        }
 
        return full_success;
 
    }

References subsystem_controllers::Entry::active_, subsystem_controllers::Entry::available_, call_timeout_, em_, subsystem_controllers::EntryManager::get_entries(), plugin_lifecycle_mgr_, required_plugins_, service_timeout_, subsystem_controllers::EntryManager::update_entry(), and subsystem_controllers::Entry::user_requested_activation_.

Here is the call graph for this function:

deactivate()

bool subsystem_controllers::PluginManager::deactivate

(

)

Definition at line 214 of file plugin_manager.cpp.

    {
        bool full_success = true;
        // Bring all required or auto activated plugins to the active state
        for (auto plugin : em_.get_entries())
        {
            auto result_state = plugin_lifecycle_mgr_->transition_node_to_state(lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE, plugin.name_, service_timeout_, call_timeout_);
 
            if(result_state != lifecycle_msgs::msg::State::PRIMARY_STATE_INACTIVE)
            {
                // If this plugin was required then trigger exception
                if (required_plugins_.find(plugin.name_) != required_plugins_.end())
                {
                    throw std::runtime_error("Required plugin " + plugin.name_ + " could not be deactivated.");
                }
 
                // If this plugin was not required log an error and mark it is unavailable and deactivated
                RCLCPP_ERROR_STREAM(rclcpp::get_logger("subsystem_controllers"), "Failed to deactivate non-required plugin: "
                    << plugin.name_ << " Marking as deactivated and unavailable!");
 
                Entry deactivated_entry = plugin;
                deactivated_entry.active_ = false;
                deactivated_entry.available_ = false;
                deactivated_entry.user_requested_activation_ = false;
                em_.update_entry(deactivated_entry);
 
                full_success = false;
            }
 
        }
 
        return full_success;
    }

References subsystem_controllers::Entry::active_, subsystem_controllers::Entry::available_, call_timeout_, em_, subsystem_controllers::EntryManager::get_entries(), plugin_lifecycle_mgr_, required_plugins_, service_timeout_, subsystem_controllers::EntryManager::update_entry(), and subsystem_controllers::Entry::user_requested_activation_.

Here is the call graph for this function:

get_active_plugins()

void subsystem_controllers::PluginManager::get_active_plugins	(	SrvHeader	,
		carma_planning_msgs::srv::PluginList::Request::SharedPtr	req,
		carma_planning_msgs::srv::PluginList::Response::SharedPtr	res
	)

Get the list of currently active plugins.

Parameters

	header	Middle ware header
	req	The req details
[out]	res	The response containing the list of active plugins

Definition at line 302 of file plugin_manager.cpp.

    {
        // convert to plugin list
        for(const auto& plugin : em_.get_entries())
        {
            if(plugin.active_)
            {
                carma_planning_msgs::msg::Plugin msg;
                msg.activated = plugin.active_;
                msg.available = plugin.available_;
                msg.name = plugin.name_;
                msg.type = plugin.type_;
                msg.capability = plugin.capability_;
                res->plugins.push_back(msg);
            }
        }
    }

References em_, and subsystem_controllers::EntryManager::get_entries().

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

get_control_plugins_by_capability()

void subsystem_controllers::PluginManager::get_control_plugins_by_capability	(	SrvHeader	,
		carma_planning_msgs::srv::GetPluginApi::Request::SharedPtr	req,
		carma_planning_msgs::srv::GetPluginApi::Response::SharedPtr	res
	)

Get control plugins by capability.

Parameters

header	Middle ware header
req	The req which identifies which capability is required
res	The res which identifies the control plugins with the requested capability

Definition at line 375 of file plugin_manager.cpp.

    {
        std::vector<std::string> req_capability_levels;
        boost::split(req_capability_levels, req->capability, boost::is_any_of("/"));
 
        for(const auto& plugin : em_.get_entries())
        {
 
            std::vector<std::string> plugin_capability_levels;
            boost::split(plugin_capability_levels, plugin.capability_, boost::is_any_of("/"));
 
            if(plugin.type_ == carma_planning_msgs::msg::Plugin::CONTROL &&
                (req->capability.size() == 0 || (matching_capability(plugin_capability_levels, req_capability_levels) && plugin.active_ && plugin.available_)))
            {
                RCLCPP_DEBUG_STREAM(rclcpp::get_logger("guidance_controller"), "discovered control plugin: " << plugin.name_);
                res->plan_service.push_back(plugin.name_ + control_trajectory_suffix_);
            }
            else
            {
                RCLCPP_DEBUG_STREAM(rclcpp::get_logger("guidance_controller"), "not valid control plugin: " << plugin.name_);
            }
        }
    }

References control_trajectory_suffix_, em_, subsystem_controllers::EntryManager::get_entries(), matching_capability(), and process_traj_logs::split.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

get_registered_plugins()

void subsystem_controllers::PluginManager::get_registered_plugins	(	SrvHeader	,
		carma_planning_msgs::srv::PluginList::Request::SharedPtr	req,
		carma_planning_msgs::srv::PluginList::Response::SharedPtr	res
	)

Returns the list of known plugins.

Parameters

	req	The req details
[out]	res	The response containing the list of known plugins

Definition at line 287 of file plugin_manager.cpp.

    {
        // convert to plugin list
        for(const auto& plugin :  em_.get_entries())
        {
            carma_planning_msgs::msg::Plugin msg;
            msg.activated = plugin.active_;
            msg.available = plugin.available_;
            msg.name = plugin.name_;
            msg.type = plugin.type_;
            msg.capability = plugin.capability_;
            res->plugins.push_back(msg);
        }
    }

References em_, and subsystem_controllers::EntryManager::get_entries().

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

get_strategic_plugins_by_capability()

void subsystem_controllers::PluginManager::get_strategic_plugins_by_capability	(	SrvHeader	,
		carma_planning_msgs::srv::GetPluginApi::Request::SharedPtr	req,
		carma_planning_msgs::srv::GetPluginApi::Response::SharedPtr	res
	)

Get strategic plugins by capability.

Parameters

header	Middle ware header
req	The req which identifies which capability is required
res	The res which identifies the strategic plugins with the requested capability

Definition at line 423 of file plugin_manager.cpp.

    {
        std::vector<std::string> req_capability_levels;
        boost::split(req_capability_levels, req->capability, boost::is_any_of("/"));
 
        for(const auto& plugin : em_.get_entries())
        {
 
            std::vector<std::string> plugin_capability_levels;
            boost::split(plugin_capability_levels, plugin.capability_, boost::is_any_of("/"));
 
            if(plugin.type_ == carma_planning_msgs::msg::Plugin::STRATEGIC &&
                (req->capability.size() == 0 || (matching_capability(plugin_capability_levels, req_capability_levels) && plugin.active_ && plugin.available_)))
            {
                RCLCPP_DEBUG_STREAM(rclcpp::get_logger("guidance_controller"), "discovered strategic plugin: " << plugin.name_);
                res->plan_service.push_back(plugin.name_ + plan_maneuvers_suffix_);
            }
            else
            {
                RCLCPP_DEBUG_STREAM(rclcpp::get_logger("guidance_controller"), "not valid strategic plugin: " << plugin.name_);
            }
        }
    }

References em_, subsystem_controllers::EntryManager::get_entries(), matching_capability(), plan_maneuvers_suffix_, and process_traj_logs::split.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

get_tactical_plugins_by_capability()

void subsystem_controllers::PluginManager::get_tactical_plugins_by_capability	(	SrvHeader	,
		carma_planning_msgs::srv::GetPluginApi::Request::SharedPtr	req,
		carma_planning_msgs::srv::GetPluginApi::Response::SharedPtr	res
	)

Get tactical plugins by capability.

Parameters

header	Middle ware header
req	The req which identifies which capability is required
res	The res which identifies the tactical plugins with the requested capability

Definition at line 399 of file plugin_manager.cpp.

    {
        std::vector<std::string> req_capability_levels;
        boost::split(req_capability_levels, req->capability, boost::is_any_of("/"));
 
        for(const auto& plugin : em_.get_entries())
        {
 
            std::vector<std::string> plugin_capability_levels;
            boost::split(plugin_capability_levels, plugin.capability_, boost::is_any_of("/"));
 
            if(plugin.type_ == carma_planning_msgs::msg::Plugin::TACTICAL &&
                (req->capability.size() == 0 || (matching_capability(plugin_capability_levels, req_capability_levels) && plugin.active_ && plugin.available_)))
            {
                RCLCPP_DEBUG_STREAM(rclcpp::get_logger("guidance_controller"), "discovered tactical plugin: " << plugin.name_);
                res->plan_service.push_back(plugin.name_ + plan_trajectory_suffix_);
            }
            else
            {
                RCLCPP_DEBUG_STREAM(rclcpp::get_logger("guidance_controller"), "not valid tactical plugin: " << plugin.name_);
            }
        }
    }

References em_, subsystem_controllers::EntryManager::get_entries(), matching_capability(), plan_trajectory_suffix_, and process_traj_logs::split.

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

is_ros2_lifecycle_node()

bool subsystem_controllers::PluginManager::is_ros2_lifecycle_node ( const std::string &  node )

protected

Returns true if the specified fully qualified node name is a ROS2 lifecycle node.

Parameters

node	The fully specified name of the node to evaluate

Returns

True if ros2 lifecycle node. False otherwise

matching_capability()

bool subsystem_controllers::PluginManager::matching_capability ( const std::vector< std::string > &  base_capability_levels, const std::vector< std::string > &  compared_capability_levels  )

protected

Returns true if the provided base capability hierarchy can achieve the requested capability hierarchy A capability hierarchy is described as a list of strings where the first string is the most generic description of the capability while the last string the is the most detailed description.

For example the capability "tactical_plan/plan_trajectory" would be described as ["tactical_plan", "plan_trajectory"] if the user wanted to match this to "tactical_plan/plan_trajectory/platooning_trajectory" then the compared_capability_levels would be ["tactical_plan", "plan_trajectory", "compared_capability_levels"] Matching those two inputs as ( ["tactical_plan", "plan_trajectory"], ["tactical_plan", "plan_trajectory", "compared_capability_levels"]) would be false because the compared_capability_levels is more detailed than the base. By contrast, matching ( ["tactical_plan", "plan_trajectory", "compared_capability_levels"], ["tactical_plan", "plan_trajectory"] ) would be true since the base is more generic then the request

// TODO check with Kyle on this because it maybe should be the reverse since a more specific capability may require specific meta data.

Parameters

base_capability_levels	The base hierarchy to check for compatability
compared_capability_levels	The compared_capability_levels which are being checked against the base

Returns

True if base_capability_levels supports compared_capability_levels

Definition at line 364 of file plugin_manager.cpp.

    {
        for (size_t i=0; i < base_capability_levels.size() &&  i < compared_capability_levels.size(); i++)
        {
            if (compared_capability_levels[i].compare(base_capability_levels[i]) != 0)
                return false;
        }
 
        return true;
    }

References process_bag::i.

Referenced by get_control_plugins_by_capability(), get_strategic_plugins_by_capability(), and get_tactical_plugins_by_capability().

Here is the caller graph for this function:

shutdown()

bool subsystem_controllers::PluginManager::shutdown

(

)

Definition at line 282 of file plugin_manager.cpp.

    {
        return plugin_lifecycle_mgr_->shutdown(service_timeout_, call_timeout_, false, em_.get_entry_names()).empty();
    }

References call_timeout_, em_, subsystem_controllers::EntryManager::get_entry_names(), plugin_lifecycle_mgr_, and service_timeout_.

Here is the call graph for this function:

update_plugin_status()

void subsystem_controllers::PluginManager::update_plugin_status

(

carma_planning_msgs::msg::Plugin::UniquePtr

msg

)

Update the status of a certain plugin.

Parameters

msg	A plugin status message

Definition at line 348 of file plugin_manager.cpp.

    {
        boost::optional<Entry> requested_plugin = em_.get_entry_by_name(msg->name);
 
        if (!requested_plugin) // This is a new plugin so we need to add it
        {
            Entry plugin(msg->available, msg->activated, msg->name, msg->type, msg->capability, false);
            add_plugin(plugin);
            return;
        }
 
        Entry plugin(msg->available, msg->activated, msg->name, msg->type, msg->capability, requested_plugin->user_requested_activation_);
 
        em_.update_entry(plugin);
    }

References add_plugin(), em_, subsystem_controllers::EntryManager::get_entry_by_name(), and subsystem_controllers::EntryManager::update_entry().

Referenced by subsystem_controllers::GuidanceControllerNode::handle_on_configure().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

auto_activated_plugins_

std::unordered_set<std::string> subsystem_controllers::PluginManager::auto_activated_plugins_

protected

Set of use specified auto activated plugins which will automatically started without need for user input.

Definition at line 194 of file plugin_manager.h.

Referenced by PluginManager(), and activate().

call_timeout_

std::chrono::nanoseconds subsystem_controllers::PluginManager::call_timeout_

protected

The timeout for service calls to return.

Definition at line 212 of file plugin_manager.h.

Referenced by activate(), activate_plugin(), add_plugin(), cleanup(), configure(), deactivate(), and shutdown().

control_trajectory_suffix_

const std::string subsystem_controllers::PluginManager::control_trajectory_suffix_ = "/plan_trajectory"

protected

Base topic name of control plugin trajectory input topic.

Definition at line 221 of file plugin_manager.h.

Referenced by get_control_plugins_by_capability().

em_

EntryManager subsystem_controllers::PluginManager::em_

protected

Entry manager to keep track of detected plugins.

Definition at line 206 of file plugin_manager.h.

Referenced by PluginManager(), activate(), activate_plugin(), add_plugin(), cleanup(), configure(), deactivate(), get_active_plugins(), get_control_plugins_by_capability(), get_registered_plugins(), get_strategic_plugins_by_capability(), get_tactical_plugins_by_capability(), shutdown(), and update_plugin_status().

get_parent_state_func_

GetParentNodeStateFunc subsystem_controllers::PluginManager::get_parent_state_func_

protected

Callback to retrieve the lifecycle state of the parent process.

Definition at line 200 of file plugin_manager.h.

Referenced by add_plugin().

get_service_names_and_types_func_

ServiceNamesAndTypesFunc subsystem_controllers::PluginManager::get_service_names_and_types_func_

protected

Callback to get service names and types for the given node.

Definition at line 203 of file plugin_manager.h.

plan_maneuvers_suffix_

const std::string subsystem_controllers::PluginManager::plan_maneuvers_suffix_ = "/plan_maneuvers"

protected

Base service name of plan_trajectory service.

Definition at line 215 of file plugin_manager.h.

Referenced by get_strategic_plugins_by_capability().

plan_trajectory_suffix_

const std::string subsystem_controllers::PluginManager::plan_trajectory_suffix_ = "/plan_trajectory"

protected

Base service name of plan_trajectory service.

Definition at line 218 of file plugin_manager.h.

Referenced by get_tactical_plugins_by_capability().

plugin_lifecycle_mgr_

std::shared_ptr<ros2_lifecycle_manager::LifecycleManagerInterface> subsystem_controllers::PluginManager::plugin_lifecycle_mgr_

protected

Lifecycle Manager which will track the plugin nodes and call their lifecycle services on request.

Definition at line 197 of file plugin_manager.h.

Referenced by PluginManager(), activate(), activate_plugin(), add_plugin(), cleanup(), configure(), deactivate(), and shutdown().

required_plugins_

std::unordered_set<std::string> subsystem_controllers::PluginManager::required_plugins_

protected

Set of required plugins a failure of which necessitates system shutdown.

Definition at line 190 of file plugin_manager.h.

Referenced by PluginManager(), activate(), add_plugin(), cleanup(), configure(), and deactivate().

service_timeout_

std::chrono::nanoseconds subsystem_controllers::PluginManager::service_timeout_

protected

The timeout for services to be available.

Definition at line 209 of file plugin_manager.h.

Referenced by activate(), activate_plugin(), add_plugin(), cleanup(), configure(), deactivate(), and shutdown().

---

The documentation for this class was generated from the following files:

• subsystem_controllers/include/subsystem_controllers/guidance_controller/plugin_manager.h
• subsystem_controllers/src/guidance_controller/plugin_manager.cpp