API Reference

This page is generated from the C++ headers and source files using Doxygen and Breathe.

Core

namespace ros2_fault_injection

Typedefs

using InjectorMap = std::unordered_map<std::string, std::shared_ptr<FaultInjector>>

Map of injector id to injector instance.

Enums

enum class AssertionState

Values:

enumerator Pending

enumerator Passed

enumerator Failed

Functions

const std::unordered_set<std::string> &allowed_config_keys_for_injector_type(const std::string &injector_type)

Get the allowed config keys for an injector type.

Parameters:

injector_type – Type name from an InjectorConfig, such as odom or scan.

Returns:

Set of accepted fault config keys. Unknown injector types return an empty set.

bool is_allowed_config_key(const std::string &injector_type, const std::string &key)

Check whether a config key is valid for an injector type.

Parameters:

• injector_type – Type name from an InjectorConfig.

• key – Fault config key to validate.

Returns:

true when the key is accepted by the injector type.

std::optional<std::string> validate_config_value(const std::string &injector_type, const std::string &key, const std::string &value)

Validate one runtime config value for an injector type.

This is used by runtime services before mutating a stored fault config. It keeps service updates consistent with scenario validation.

Parameters:

• injector_type – Type name from an InjectorConfig.

• key – Fault config key to validate.

• value – Proposed value stored as text.

Returns:

std::nullopt when valid, otherwise a human-readable validation error.

std::optional<std::string> validate_config_value(const FaultConfigField &field, const std::string &value)

ScenarioConfig load_scenario_config(const std::string &path)

Load a scenario YAML file.

Parameters:

path – Filesystem path to a scenario YAML file.

Throws:

std::exception – when the file cannot be parsed.

Returns:

Parsed scenario configuration.

const InjectorConfig *find_injector(const ScenarioConfig &scenario, const std::string &injector_id)

Find an injector config by id.

Parameters:

• scenario – Scenario to search.

• injector_id – Injector id to find.

Returns:

Pointer to the injector config, or nullptr when absent.

ValidationResult validate_scenario(const ScenarioConfig &scenario)

Validate a parsed scenario before starting injectors.

Parameters:

scenario – Scenario to validate.

Returns:

Validation errors and warnings.

std::string describe_fault(const FaultConfig &fault)

std::string describe_config(const std::unordered_map<std::string, std::string> &config)

std::string describe_config_update(const std::string &key, const std::string &value)

bool is_known_injector_type(const std::string &type)

std::vector<FaultConfigField> schema_for_builtin_injector_type(const std::string &type)

const FaultConfigField *find_schema_field(const std::vector<FaultConfigField> &schema, const std::string &key)

void validate_fault_config_against_schema(const FaultConfig &fault, const std::vector<FaultConfigField> &schema, ValidationResult &result)

void validate_required_schema_fields(const FaultConfig &fault, const std::vector<FaultConfigField> &schema, ValidationResult &result)

void validate_injector(const InjectorConfig &injector, ValidationResult &result)

bool is_initially_active(const ScenarioConfig &scenario, const FaultConfig &fault)

void validate_fault(const ScenarioConfig &scenario, const FaultConfig &fault, const InjectorConfig &injector, ValidationResult &result)

void validate_assertions(const ScenarioConfig &scenario, const AssertionConfig &assertion, ValidationResult &result)

struct AssertionConfig

#include <ros2_fault_injection/assertions/assertion_config.hpp>

Public Members

std::string id

std::string type

std::string topic

std::string fault_id

std::string state

std::optional<double> min_hz

std::optional<double> window

std::optional<double> within

std::optional<double> duration

struct AssertionResult

#include <ros2_fault_injection/assertions/assertion_result.hpp>

Public Members

std::string id

std::string type

AssertionState state

std::string message

class FaultAssertionRunner

#include <ros2_fault_injection/assertions/fault_assertion_runner.hpp>

Public Functions

FaultAssertionRunner(rclcpp::Node &node)

void start(const std::vector<AssertionConfig> &assertions)

std::vector<AssertionResult> results() const

struct FaultConfig

#include <ros2_fault_injection/config/fault_config.hpp>

Configuration for one injectable fault.

The top-level fields describe scheduling and ownership. The config map stores injector-specific fault parameters such as x_bias, range_noise_stddev, or delay_ms.

Public Members

std::string id

Unique fault identifier used by services, events, and schedules.

std::string injector_id

Identifier of the injector that owns this fault.

std::optional<std::chrono::milliseconds> start

Optional activation time relative to node startup.

std::optional<std::chrono::milliseconds> duration

Optional active window duration.

std::unordered_map<std::string, std::string> config

Injector-specific fault parameters parsed from YAML.

struct FaultConfigField

#include <ros2_fault_injection/config/fault_config_schema.hpp>

Public Members

std::string key

std::string type

std::string description

std::optional<double> min_value

std::optional<double> max_value

std::optional<std::string> default_value

class FaultController

#include <ros2_fault_injection/core/fault_controller.hpp>

Owns the runtime injector graph for one scenario.

The controller creates typed injectors, registers each fault with the injector named by FaultConfig::injector_id, and starts scheduled fault activation.

Public Functions

FaultController(rclcpp::Node &node, std::string scenario_file, ScenarioConfig scenario, FaultEventPublisher &events)

Construct and start the controller.

Parameters:

• node – ROS node used to create injector publishers, subscriptions, and timers.

• scenario_file – Scenario YAML file path used for runtime reloads.

• scenario – Parsed and validated scenario configuration.

• events – Shared event publisher used by scheduled faults.

const InjectorMap &injectors() const

Access the configured injectors by injector id.

Returns:

Map of injector id to injector instance.

ReloadScenarioResult reload_scenario()

struct FaultEvent

#include <ros2_fault_injection/core/fault_event_publisher.hpp>

Internal representation of a fault lifecycle event.

The publisher adds the timestamp when converting this struct to ros2_fault_injection/msg/FaultEvent.

Public Members

std::string fault_id

Fault identifier associated with the event.

std::string injector_id

Injector identifier that owns the fault.

std::string state

Fault state, for example active, inactive, or config_updated.

std::string source

Source of the event, for example startup, scheduled, or manual.

std::string details

Human-readable event details.

class FaultEventAssertion

#include <ros2_fault_injection/assertions/fault_event_assertion.hpp>

Assertion that passes when an expected fault event is observed.

A fault event assertion checks fault_id and state from /fault_injection/events. It is useful for verifying that scheduled, startup, or manual fault transitions actually occurred.

Public Functions

explicit FaultEventAssertion(const AssertionConfig &config)

Create an assertion from parsed scenario config.

Parameters:

config – Assertion configuration. Expected fields are id, fault_id, state, and optionally within.

void observe(const msg::FaultEvent &event)

Process a fault event.

If the event matches the configured fault_id and state, the assertion is marked as passed.

Parameters:

event – Fault event message published by the framework.

void update(double elapsed_seconds)

Check whether the assertion deadline has expired.

Parameters:

elapsed_seconds – Seconds since assertion monitoring started.

AssertionResult result() const

Current assertion result.

Returns:

Assertion state and human-readable message.

class FaultEventPublisher

#include <ros2_fault_injection/core/fault_event_publisher.hpp>

Publishes structured fault events on fault_injection/events.

Public Functions

explicit FaultEventPublisher(rclcpp::Node &node)

Create the event publisher.

Parameters:

node – Node used for publisher creation and event timestamps.

void publish(const FaultEvent &event)

Publish a fault event with the node’s current time.

Parameters:

event – Event payload to publish.

class FaultInjector

#include <ros2_fault_injection/core/fault_injector.hpp>

Common interface implemented by all typed fault injectors.

The interface keeps scheduling and services independent of message type. A typed injector owns the ROS subscription/publisher pair for a specific message type and applies the active faults during message callbacks.

Subclassed by ros2_fault_injection::FaultInjectorBase

Public Functions

virtual ~FaultInjector() = default

virtual std::string id() const = 0

Get the injector id from the scenario.

Returns:

Injector identifier.

virtual std::string type() const = 0

Get the injector type from the scenario.

The type is used for schema validation and plugin selection. It may differ from the injector id; for example, injector id motor_feedback can have type joint_state.

Returns:

Injector type string.

virtual std::vector<FaultConfigField> config_schema() const = 0

virtual void add_fault(const FaultConfig &fault_config) = 0

Register or replace a fault owned by this injector.

Parameters:

fault_config – Fault configuration to store.

virtual void activate_fault(const std::string &fault_id) = 0

Mark a known fault active.

Parameters:

fault_id – Fault identifier to activate.

virtual void deactivate_fault(const std::string &fault_id) = 0

Mark a fault inactive.

Parameters:

fault_id – Fault identifier to deactivate.

virtual bool has_fault(const std::string &fault_id) const = 0

Check whether this injector owns a fault id.

Parameters:

fault_id – Fault identifier to look up.

Returns:

true when the fault is registered.

virtual std::optional<FaultConfig> get_fault_config(const std::string &fault_id) const = 0

Get the stored configuration for a fault.

Parameters:

fault_id – Fault identifier to look up.

Returns:

Fault configuration when found, otherwise std::nullopt.

virtual bool set_fault_config_value(const std::string &fault_id, const std::string &key, const std::string &value) = 0

Update one runtime config value for a registered fault.

This updates entries inside FaultConfig::config; it does not mutate top-level scheduling fields such as start or duration.

Parameters:

• fault_id – Fault identifier to update.

• key – Config key to set.

• value – New value stored as text.

Returns:

true when the fault exists and the value was stored.

virtual std::vector<std::string> fault_ids() const = 0

List all fault ids registered with this injector.

Returns:

Fault identifiers.

virtual std::vector<std::string> active_fault_ids() const = 0

List currently active fault ids.

Returns:

Active fault identifiers.

virtual void clear_faults() = 0

class FaultInjectorBase : public ros2_fault_injection::FaultInjector

#include <ros2_fault_injection/core/fault_injector_base.hpp>

Shared implementation for typed fault injectors.

This base class stores fault configuration, active state, random number generation, and common helpers for drop/delay/config aggregation. Derived classes provide the message-specific ROS subscriptions and mutation logic.

Subclassed by ros2_fault_injection::ImuFaultInjector, ros2_fault_injection::JointStateFaultInjector, ros2_fault_injection::OdomFaultInjector, ros2_fault_injection::ScanFaultInjector, ros2_fault_injection::TfFaultInjector, ros2_fault_injection::TriggerServiceFaultInjector

Public Functions

explicit FaultInjectorBase(rclcpp::Node &node, InjectorConfig config)

Construct a base injector.

Parameters:

• node – ROS node used by derived classes.

• config – Injector configuration from the scenario.

virtual std::string id() const override

Get the injector id from the scenario.

Returns:

Injector identifier.

virtual std::string type() const override

Get the injector type from the scenario.

The type is used for schema validation and plugin selection. It may differ from the injector id; for example, injector id motor_feedback can have type joint_state.

Returns:

Injector type string.

virtual void add_fault(const FaultConfig &fault_config) override

Register or replace a fault owned by this injector.

Parameters:

fault_config – Fault configuration to store.

virtual void activate_fault(const std::string &fault_id) override

Mark a known fault active.

Parameters:

fault_id – Fault identifier to activate.

virtual void deactivate_fault(const std::string &fault_id) override

Mark a fault inactive.

Parameters:

fault_id – Fault identifier to deactivate.

virtual bool has_fault(const std::string &fault_id) const override

Check whether this injector owns a fault id.

Parameters:

fault_id – Fault identifier to look up.

Returns:

true when the fault is registered.

virtual std::optional<FaultConfig> get_fault_config(const std::string &fault_id) const override

Get the stored configuration for a fault.

Parameters:

fault_id – Fault identifier to look up.

Returns:

Fault configuration when found, otherwise std::nullopt.

virtual std::vector<std::string> fault_ids() const override

List all fault ids registered with this injector.

Returns:

Fault identifiers.

virtual std::vector<std::string> active_fault_ids() const override

List currently active fault ids.

Returns:

Active fault identifiers.

virtual std::vector<FaultConfigField> config_schema() const override

virtual bool set_fault_config_value(const std::string &fault_id, const std::string &key, const std::string &value) override

Update one runtime config value for a registered fault.

This updates entries inside FaultConfig::config; it does not mutate top-level scheduling fields such as start or duration.

Parameters:

• fault_id – Fault identifier to update.

• key – Config key to set.

• value – New value stored as text.

Returns:

true when the fault exists and the value was stored.

virtual void clear_faults() override

Protected Functions

double active_max_double(const std::string &key, double fallback = 0.0) const

Get the largest active numeric config value for a key.

Parameters:

• key – Config key to scan across active faults.

• fallback – Value returned when no active fault provides the key.

Returns:

Largest parsed value or fallback.

double active_sum_double(const std::string &key, double fallback = 0.0) const

Sum active numeric config values for a key.

Parameters:

• key – Config key to scan across active faults.

• fallback – Value returned when no active fault provides the key.

Returns:

Sum of parsed values or fallback.

int active_max_int(const std::string &key, int fallback = 0) const

Get the largest active integer config value for a key.

Parameters:

• key – Config key to scan across active faults.

• fallback – Value returned when no active fault provides the key.

Returns:

Largest parsed value or fallback.

bool active_bool(const std::string &key, bool fallback = false) const

std::string active_string(const std::string &key, const std::string &fallback = "") const

bool should_drop()

Decide whether the current message should be dropped.

Returns:

true when an active drop_probability fault drops the message.

std::chrono::milliseconds active_delay() const

Get the current active delay.

Returns:

Delay duration from active delay_ms faults.

Protected Attributes

rclcpp::Node &node_

InjectorConfig config_

mutable std::mutex mutex_

std::unordered_map<std::string, FaultConfig> faults_

std::unordered_map<std::string, bool> active_

std::mt19937 rng_

class FaultInjectorFactory

#include <ros2_fault_injection/core/fault_injector_factory.hpp>

Creates typed injectors from scenario configuration.

Public Functions

explicit FaultInjectorFactory(rclcpp::Node &node)

Construct a factory.

Parameters:

node – Node passed to created injectors.

std::shared_ptr<FaultInjector> create(const InjectorConfig &config)

Create the injector implementation selected by config.type.

Parameters:

config – Injector configuration.

Returns:

Shared injector instance, or nullptr when the type is unsupported.

class FaultInjectorPlugin

#include <ros2_fault_injection/core/fault_injector_plugin.hpp>

Plugin wrapper interface for creating typed fault injectors.

Fault injectors need a ROS node and scenario configuration when they are constructed, so pluginlib loads small default-constructible factory plugins instead of loading the injectors directly.

Subclassed by ros2_fault_injection::ImuFaultInjectorPlugin, ros2_fault_injection::JointStateFaultInjectorPlugin, ros2_fault_injection::OdomFaultInjectorPlugin, ros2_fault_injection::ScanFaultInjectorPlugin, ros2_fault_injection::TfFaultInjectorPlugin, ros2_fault_injection::TriggerServiceFaultInjectorPlugin

Public Functions

virtual ~FaultInjectorPlugin() = default

virtual std::string type() const = 0

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) = 0

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

class FaultScheduler

#include <ros2_fault_injection/core/fault_scheduler.hpp>

Schedules startup and timed fault activation.

The scheduler is message-type agnostic. It activates/deactivates faults through the FaultInjector interface and publishes lifecycle events.

Public Functions

explicit FaultScheduler(rclcpp::Node &node, FaultEventPublisher &event_pub)

Construct a scheduler.

Parameters:

• node – Node used to create wall timers.

• event_pub – Publisher used for scheduled fault events.

void schedule(const std::vector<FaultConfig> &faults, FaultInjector &injector, const std::vector<std::string> &initially_active_faults)

Schedule all faults belonging to one injector.

Parameters:

• faults – Faults assigned to the injector.

• injector – Injector to activate and deactivate.

• initially_active_faults – Fault ids that should start active.

void clear()

class FaultServiceManager

#include <ros2_fault_injection/core/fault_service_manager.hpp>

Owns runtime control services for fault injection.

The service manager exposes APIs for listing faults, reading status, activating/deactivating faults, and changing runtime config values.

Public Types

using InjectorMap = std::unordered_map<std::string, std::shared_ptr<FaultInjector>>

Map of injector id to injector instance.

using ReloadScenarioCallback = std::function<ReloadScenarioResult()>

Callback used by the reload service to ask the controller to reload its scenario.

Public Functions

FaultServiceManager(rclcpp::Node &node, const InjectorMap &injectors, FaultEventPublisher &events, ReloadScenarioCallback reload_scenario_callback)

Create all fault control services.

Parameters:

• node – Node used to create services.

• injectors – Runtime injectors indexed by id.

• events – Publisher used for manual state/config events.

• reload_scenario_callback – Callback used by the reload service.

class ImuFaultInjector : public ros2_fault_injection::FaultInjectorBase

#include <ros2_fault_injection/injectors/imu_fault_injector.hpp>

Fault injector for sensor_msgs/msg/Imu streams.

Subscribes to the configured input topic, applies active IMU faults, and republishes the result on the configured output topic.

Public Functions

explicit ImuFaultInjector(rclcpp::Node &node, const InjectorConfig &config)

Create the IMU fault injector.

Parameters:

• node – Node used to create publishers, subscriptions, and timers.

• config – Injector topic and QoS configuration.

virtual std::vector<FaultConfigField> config_schema() const override

Public Static Functions

static std::vector<FaultConfigField> static_config_schema()

class ImuFaultInjectorPlugin : public ros2_fault_injection::FaultInjectorPlugin

#include <ros2_fault_injection/core/builtin_fault_injector_plugin.hpp>

Public Functions

virtual std::string type() const override

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) override

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

struct InjectorConfig

#include <ros2_fault_injection/config/fault_config.hpp>

Runtime configuration for one topic injector.

An injector acts as a proxy between an input topic and an output topic. The type selects the message-specific injector implementation, while id is used by faults to target that injector.

Public Members

std::string id

Unique injector identifier used by fault definitions.

std::string type

Injector implementation type, for example odom, scan, joint_state, or imu.

std::optional<TopicEndpointConfig> topic

std::optional<TriggerServiceEndpointConfig> trigger_service

class JointStateFaultInjector : public ros2_fault_injection::FaultInjectorBase

#include <ros2_fault_injection/injectors/joint_state_fault_injector.hpp>

Fault injector for sensor_msgs/msg/JointState streams.

Subscribes to the configured input topic, applies active joint state faults, and republishes the result on the configured output topic.

Public Functions

explicit JointStateFaultInjector(rclcpp::Node &node, const InjectorConfig &config)

Create the joint state fault injector.

Parameters:

• node – Node used to create publishers, subscriptions, and timers.

• config – Injector topic and QoS configuration.

virtual std::vector<FaultConfigField> config_schema() const override

Public Static Functions

static std::vector<FaultConfigField> static_config_schema()

class JointStateFaultInjectorPlugin : public ros2_fault_injection::FaultInjectorPlugin

#include <ros2_fault_injection/core/builtin_fault_injector_plugin.hpp>

Public Functions

virtual std::string type() const override

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) override

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

class OdomFaultInjector : public ros2_fault_injection::FaultInjectorBase

#include <ros2_fault_injection/injectors/odom_fault_injector.hpp>

Fault injector for nav_msgs/msg/Odometry streams.

Subscribes to the configured input topic, applies active odometry faults, and republishes the result on the configured output topic.

Public Functions

explicit OdomFaultInjector(rclcpp::Node &node, const InjectorConfig &config)

Create the odometry fault injector.

Parameters:

• node – Node used to create publishers, subscriptions, and timers.

• config – Injector topic and QoS configuration.

virtual std::vector<FaultConfigField> config_schema() const override

Public Static Functions

static std::vector<FaultConfigField> static_config_schema()

class OdomFaultInjectorPlugin : public ros2_fault_injection::FaultInjectorPlugin

#include <ros2_fault_injection/core/builtin_fault_injector_plugin.hpp>

Public Functions

virtual std::string type() const override

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) override

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

struct ReloadScenarioResult

#include <ros2_fault_injection/core/fault_controller.hpp>

Public Members

bool success = {false}

std::string message

class ScanFaultInjector : public ros2_fault_injection::FaultInjectorBase

#include <ros2_fault_injection/injectors/scan_fault_injector.hpp>

Fault injector for sensor_msgs/msg/LaserScan streams.

Subscribes to the configured input topic, applies active laser scan faults, and republishes the result on the configured output topic.

Public Functions

explicit ScanFaultInjector(rclcpp::Node &node, const InjectorConfig &config)

Create the laser scan fault injector.

Parameters:

• node – Node used to create publishers, subscriptions, and timers.

• config – Injector topic and QoS configuration.

virtual std::vector<FaultConfigField> config_schema() const override

Public Static Functions

static std::vector<FaultConfigField> static_config_schema()

class ScanFaultInjectorPlugin : public ros2_fault_injection::FaultInjectorPlugin

#include <ros2_fault_injection/core/builtin_fault_injector_plugin.hpp>

Public Functions

virtual std::string type() const override

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) override

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

struct ScenarioConfig

#include <ros2_fault_injection/config/scenario_config.hpp>

Parsed YAML scenario.

Public Members

std::vector<InjectorConfig> injectors

All injectors configured by the scenario.

InjectorConfig injector

Legacy single-injector field kept for compatibility with older examples.

std::vector<FaultConfig> faults

All faults configured by the scenario.

std::vector<std::string> initially_active_faults

Fault ids requested active at startup.

std::vector<AssertionConfig> assertions

Assertions configured by the scenario.

class TfFaultInjector : public ros2_fault_injection::FaultInjectorBase

#include <ros2_fault_injection/injectors/tf_fault_injector.hpp>

Public Functions

explicit TfFaultInjector(rclcpp::Node &node, const InjectorConfig &config)

virtual std::vector<FaultConfigField> config_schema() const override

Public Static Functions

static std::vector<FaultConfigField> static_config_schema()

class TfFaultInjectorPlugin : public ros2_fault_injection::FaultInjectorPlugin

#include <ros2_fault_injection/core/builtin_fault_injector_plugin.hpp>

Public Functions

virtual std::string type() const override

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) override

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

struct TopicEndpointConfig

#include <ros2_fault_injection/config/fault_config.hpp>

Public Members

std::string input_topic

std::string output_topic

size_t qos_depth = {10}

struct TriggerServiceEndpointConfig

#include <ros2_fault_injection/config/fault_config.hpp>

Public Members

std::string proxy_service

std::string target_service

class TriggerServiceFaultInjector : public ros2_fault_injection::FaultInjectorBase

#include <ros2_fault_injection/injectors/trigger_service_fault_injector.hpp>

Public Functions

explicit TriggerServiceFaultInjector(rclcpp::Node &node, const InjectorConfig &config)

virtual std::vector<FaultConfigField> config_schema() const override

Public Static Functions

static std::vector<FaultConfigField> static_config_schema()

class TriggerServiceFaultInjectorPlugin : public ros2_fault_injection::FaultInjectorPlugin

#include <ros2_fault_injection/core/builtin_fault_injector_plugin.hpp>

Public Functions

virtual std::string type() const override

Injector type handled by this plugin.

Returns:

Type string used by InjectorConfig::type.

virtual std::shared_ptr<FaultInjector> create(rclcpp::Node &node, const InjectorConfig &config) override

Create a typed injector instance.

Parameters:

• node – ROS node used by the injector.

• config – Injector configuration from the scenario.

Returns:

Created fault injector.

struct ValidationResult

#include <ros2_fault_injection/config/scenario_validator.hpp>

Result of scenario validation.

Public Functions

inline bool ok() const

Check whether validation found any errors.

Returns:

true when errors is empty.

Public Members

std::vector<std::string> errors

Validation failures that should prevent startup.

std::vector<std::string> warnings

Non-fatal validation findings.