Skip to content

Fix FlatBuffers field names to use lowercase snake_case in lm_flatcfg.fbs #290

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
shegazyy wants to merge 2 commits into
base: main
Choose a base branch
from
Open

Fix FlatBuffers field names to use lowercase snake_case in lm_flatcfg.fbs #290

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
169c9ee
Fix FlatBuffers field names to use snake_case in lm_flatcfg.fbs
shegazyy Jul 7, 2026
ba39318
Update lifecycle_config.py and JSON fixtures to use snake_case fields
shegazyy Jul 7, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
56 changes: 28 additions & 28 deletions score/launch_manager/src/daemon/src/configuration/config_schema/lm_flatcfg.fbs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,18 +16,18 @@ enum TerminationBehaviorEnum : byte {
}

table LMEcuCfg {
versionMajor: int (id:0);
versionMinor: int (id:1);
ModeGroup: [ModeGroup] (id:2);
Process: [Process] (id:3);
version_major: int (id:0);
version_minor: int (id:1);
mode_group: [ModeGroup] (id:2);
process: [Process] (id:3);
}

table ModeGroup {
identifier: string (id:0);
initialMode_name: string (id:1);
initialMode_value: string (id:2);
recoveryMode_name: string (id:3);
modeDeclaration: [ModeDeclaration] (id:4);
initial_mode_name: string (id:1);
initial_mode_value: string (id:2);
recovery_mode_name: string (id:3);
mode_declaration: [ModeDeclaration] (id:4);
}

// TODO: Could be moved into ModeGroup
Expand All @@ -37,41 +37,41 @@ table ModeDeclaration {

table Process {
identifier: string (id:0);
numberOfRestartAttempts: uint (id:1);
functionClusterAffiliation: string (id:2);
number_of_restart_attempts: uint (id:1);
function_cluster_affiliation: string (id:2);
coremask: string (id:3);
uid: uint (id:4);
gid: uint (id:5);
path: string (id:6);
securityPolicyDetails: string (id:7);
executable_reportingBehavior: ExecutionStateReportingBehaviorEnum (id:8);
startupConfig: [ProcessStartupConfig] (id:9);
security_policy_details: string (id:7);
executable_reporting_behavior: ExecutionStateReportingBehaviorEnum (id:8);
startup_config: [ProcessStartupConfig] (id:9);
sgids: [ProcessSgid] (id:10);
}

table ProcessStartupConfig {
identifier: string (id:0);
enterTimeoutValue: uint (id:1);
exitTimeoutValue: uint (id:2);
schedulingPriority: string (id:3);
schedulingPolicy: string (id:4);
executionError: string (id:5);
terminationBehavior: TerminationBehaviorEnum (id:6);
executionDependency: [ProcessExecutionDependency] (id:7);
processGroupStateDependency: [ProcessGroupStateDependency] (id:8);
environmentVariable: [EnvironmentVariable] (id:9);
processArgument: [ProcessArgument] (id:10);
memoryUsage: uint64 (id:11);
enter_timeout_value: uint (id:1);
exit_timeout_value: uint (id:2);
scheduling_priority: string (id:3);
scheduling_policy: string (id:4);
execution_error: string (id:5);
termination_behavior: TerminationBehaviorEnum (id:6);
execution_dependency: [ProcessExecutionDependency] (id:7);
process_group_state_dependency: [ProcessGroupStateDependency] (id:8);
environment_variable: [EnvironmentVariable] (id:9);
process_argument: [ProcessArgument] (id:10);
memory_usage: uint64 (id:11);
}

table ProcessGroupStateDependency {
stateMachine_name: string (id:0);
stateName: string (id:1);
state_machine_name: string (id:0);
state_name: string (id:1);
}

table ProcessExecutionDependency {
stateName: string (id:0);
targetProcess_identifier: string (id:1);
state_name: string (id:0);
target_process_identifier: string (id:1);
}

table EnvironmentVariable {
Expand Down
52 changes: 26 additions & 26 deletions score/launch_manager/src/daemon/src/configuration/configuration_manager.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -38,8 +38,8 @@ bool setResourceLimits(const LMFlatBuffer::ProcessStartupConfig& startup_config_
// we don't need to check the upper limit as this is done in the tooling

// 0 means not configured
if (startup_config_node.memoryUsage() > 0U)
instance.startup_config_.resource_limits_.as_ = startup_config_node.memoryUsage();
if (startup_config_node.memory_usage() > 0U)
instance.startup_config_.resource_limits_.as_ = startup_config_node.memory_usage();

return true;

Expand Down Expand Up @@ -275,7 +275,7 @@ bool ConfigurationManager::loadSWClusterConfiguration(uint8_t sw_cluster_index)
bool ConfigurationManager::loadMachineConfigs(const LMFlatBuffer::LMEcuCfg* root_node, const IdentifierHash& cluster) {
bool result = false;

const auto* mode_group = root_node ? root_node->ModeGroup() : nullptr;
const auto* mode_group = root_node ? root_node->mode_group() : nullptr;

if (mode_group != nullptr) {
result = true; // Assume success if we reach this point
Expand Down Expand Up @@ -318,11 +318,11 @@ bool ConfigurationManager::parseMachineConfigurations(const ModeGroup* node, con
bool ConfigurationManager::parseModeGroups(const ModeGroup* node, ProcessGroup& process_group_data) {
bool result = false;

const auto* mode_declaration_list = node ? node->modeDeclaration() : nullptr;
const auto* mode_declaration_list = node ? node->mode_declaration() : nullptr;
if (mode_declaration_list && (mode_declaration_list->size())) {
process_group_data.off_state_ = IdentifierHash("Off"); // default value if no other path is defined

const flatbuffers::String* recovery_state_name = node->recoveryMode_name();
const flatbuffers::String* recovery_state_name = node->recovery_mode_name();
if (recovery_state_name) {
process_group_data.recovery_state_ = getStringViewFromFlatBuffer(recovery_state_name);
} else {
Expand Down Expand Up @@ -359,7 +359,7 @@ bool ConfigurationManager::parseModeGroups(const ModeGroup* node, ProcessGroup&
bool ConfigurationManager::loadProcessConfigs(const LMFlatBuffer::LMEcuCfg* root_node) {
bool result = false;

const auto* process = root_node ? root_node->Process() : nullptr;
const auto* process = root_node ? root_node->process() : nullptr;

if (process != nullptr) {
result = true; // Assume success if we reach this point
Expand All @@ -382,7 +382,7 @@ static void setSchedulingParameters(const Process& node, const ProcessStartupCon
instance.startup_config_.cpu_mask_ = ConfigurationManager::kDefaultProcessorAffinityMask();
instance.startup_config_.scheduling_policy_ = ConfigurationManager::kDefaultSchedulingPolicy;
instance.startup_config_.scheduling_priority_ = ConfigurationManager::kDefaultNormalSchedulingPriority;
auto attribute = config.schedulingPolicy();
auto attribute = config.scheduling_policy();
if (attribute != nullptr) {
if (strcasecmp("SCHED_FIFO", attribute->c_str()) == 0) {
instance.startup_config_.scheduling_policy_ = SCHED_FIFO;
Expand All @@ -396,7 +396,7 @@ static void setSchedulingParameters(const Process& node, const ProcessStartupCon
LM_LOG_WARN() << "scheduling policy" << std::string_view{attribute->c_str(), attribute->size()} << "is not supported, using default";
}
}
attribute = config.schedulingPriority();
attribute = config.scheduling_priority();
if (attribute != nullptr) {
instance.startup_config_.scheduling_priority_ = std::stoi(attribute->c_str());
}
Expand All @@ -409,7 +409,7 @@ static void setSchedulingParameters(const Process& node, const ProcessStartupCon
bool ConfigurationManager::parseProcessConfigurations(const Process* node) {
bool result = false;

const auto* startup_config_list = node ? node->startupConfig() : nullptr;
const auto* startup_config_list = node ? node->startup_config() : nullptr;

if (startup_config_list && (startup_config_list->size())) {
result = true;
Expand All @@ -432,7 +432,7 @@ bool ConfigurationManager::parseProcessConfigurations(const Process* node) {
instance.startup_config_.gid_ = node->gid() & 0x7FFFFFFFU;

instance.startup_config_.security_policy_ =
getStringFromFlatBuffer(node->securityPolicyDetails()); // Set security policy if available
getStringFromFlatBuffer(node->security_policy_details()); // Set security policy if available

// extracting supplementary group IDs from Process configuration
// and assigning them to this particular startup config (aka OsProcess)
Expand All @@ -453,34 +453,34 @@ bool ConfigurationManager::parseProcessConfigurations(const Process* node) {
// startup configs
result = setResourceLimits(*startup_config_node, instance);
instance.pgm_config_.is_self_terminating_ = isSelfTerminatingProcess(
startup_config_node->terminationBehavior(), instance.startup_config_.short_name_);
startup_config_node->termination_behavior(), instance.startup_config_.short_name_);
instance.pgm_config_.startup_timeout_ms_ =
std::chrono::milliseconds(startup_config_node->enterTimeoutValue());
std::chrono::milliseconds(startup_config_node->enter_timeout_value());
instance.pgm_config_.termination_timeout_ms_ =
std::chrono::milliseconds(startup_config_node->exitTimeoutValue());
std::chrono::milliseconds(startup_config_node->exit_timeout_value());

auto execution_error_string = startup_config_node->executionError();
auto execution_error_string = startup_config_node->execution_error();
if (execution_error_string) {
instance.pgm_config_.execution_error_code_ =
static_cast<uint32_t>(std::stoi(execution_error_string->c_str()));
} else {
// default value
instance.pgm_config_.execution_error_code_ = kDefaultProcessExecutionError;
}
instance.pgm_config_.number_of_restart_attempts = node->numberOfRestartAttempts();
instance.pgm_config_.number_of_restart_attempts = node->number_of_restart_attempts();

// Set process_id from node's identifier
instance.process_id_ = getStringViewFromFlatBuffer(node->identifier());

// Parse process arguments and environment variables
parseProcessArguments(startup_config_node->processArgument(), instance);
parseProcessEnvironmentVars(startup_config_node->environmentVariable(), instance);
parseProcessArguments(startup_config_node->process_argument(), instance);
parseProcessEnvironmentVars(startup_config_node->environment_variable(), instance);

// Parse Execution dependency
parseExecutionDependency(startup_config_node->executionDependency(), instance);
parseExecutionDependency(startup_config_node->execution_dependency(), instance);

// Parse ProcessGroup dependency
parseProcessGroup(startup_config_node->processGroupStateDependency(), instance);
parseProcessGroup(startup_config_node->process_group_state_dependency(), instance);
}
} else {
LM_LOG_DEBUG() << "parseProcessConfigurations: Startup configs are not available or list is null";
Expand Down Expand Up @@ -589,8 +589,8 @@ void ConfigurationManager::parseProcessGroup(
if (process_pg_node) {
// Extract information from ProcessGroupStateDependency of flatconfig binary
ProcessGroupStateID pg_info;
pg_info.pg_name_ = getStringViewFromFlatBuffer(process_pg_node->stateMachine_name());
pg_info.pg_state_name_ = getStringViewFromFlatBuffer(process_pg_node->stateName());
pg_info.pg_name_ = getStringViewFromFlatBuffer(process_pg_node->state_machine_name());
pg_info.pg_state_name_ = getStringViewFromFlatBuffer(process_pg_node->state_name());
LM_LOG_DEBUG() << "ParseProcessProcessGroup: id:::pg_name_:" << pg_info.pg_name_
<< ", pg_state_name_:" << pg_info.pg_state_name_;

Expand All @@ -611,11 +611,11 @@ void ConfigurationManager::parseExecutionDependency(
for (const auto& process_dependency_node : *process_dependency_list) {
if (process_dependency_node) {
Dependency dep{};
auto state_name = getStringViewFromFlatBuffer(process_dependency_node->stateName());
auto state_name = getStringViewFromFlatBuffer(process_dependency_node->state_name());
dep.process_state_ = getProcessState(state_name);
dep.target_process_id_ = getStringViewFromFlatBuffer(process_dependency_node->targetProcess_identifier());
dep.target_process_id_ = getStringViewFromFlatBuffer(process_dependency_node->target_process_identifier());
LM_LOG_DEBUG() << "ParseProcessExecutionDependency: target process path:"
<< std::string_view{getStringFromFlatBuffer(process_dependency_node->targetProcess_identifier())}
<< std::string_view{getStringFromFlatBuffer(process_dependency_node->target_process_identifier())}
<< "ID:" << dep.target_process_id_;
process_instance.dependencies_.push_back(dep);

Expand Down Expand Up @@ -810,11 +810,11 @@ osal::CommsType ConfigurationManager::getCommsType(const Process* node, const ch

if (node != nullptr) {
// Check reporting behavior
comms_type = isReportingProcess(node->executable_reportingBehavior(), short_name);
comms_type = isReportingProcess(node->executable_reporting_behavior(), short_name);

// Check function cluster affiliation
comms_type =
getfunctionClusterAffiliation(comms_type, getStringFromFlatBuffer(node->functionClusterAffiliation()));
getfunctionClusterAffiliation(comms_type, getStringFromFlatBuffer(node->function_cluster_affiliation()));
}
return comms_type;
}
Expand Down
Loading
Loading