{"id":47795021,"url":"https://github.com/eclipse-score/lifecycle","last_synced_at":"2026-04-03T16:13:52.722Z","repository":{"id":323830178,"uuid":"1053330741","full_name":"eclipse-score/lifecycle","owner":"eclipse-score","description":"Repository for the lifecycle feature","archived":false,"fork":false,"pushed_at":"2026-03-26T00:32:38.000Z","size":28889,"stargazers_count":2,"open_issues_count":26,"forks_count":16,"subscribers_count":2,"default_branch":"main","last_synced_at":"2026-03-26T16:55:38.758Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"https://eclipse-score.github.io/lifecycle","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/eclipse-score.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":".github/CODEOWNERS","security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":"NOTICE","maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2025-09-09T09:52:08.000Z","updated_at":"2026-03-24T07:49:48.000Z","dependencies_parsed_at":"2025-11-28T04:04:31.553Z","dependency_job_id":"4f4ab05b-467e-413e-be4a-48d5150d210e","html_url":"https://github.com/eclipse-score/lifecycle","commit_stats":null,"previous_names":["eclipse-score/inc_lifecycle","eclipse-score/lifecycle"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/eclipse-score/lifecycle","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/eclipse-score%2Flifecycle","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/eclipse-score%2Flifecycle/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/eclipse-score%2Flifecycle/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/eclipse-score%2Flifecycle/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/eclipse-score","download_url":"https://codeload.github.com/eclipse-score/lifecycle/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/eclipse-score%2Flifecycle/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31362716,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-03T15:19:21.178Z","status":"ssl_error","status_checked_at":"2026-04-03T15:19:20.670Z","response_time":107,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-04-03T16:13:51.969Z","updated_at":"2026-04-03T16:13:52.703Z","avatar_url":"https://github.com/eclipse-score.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Overview\r\n\r\nPortable and high-performance implementation of a Lifecycle feature for S-CORE project.\r\n\r\nThis repository contains source code for Launch Manager and Health Monitor. Lifecycle feature is implemented in C++ language, but Rust language bindings are also provided. Additionally, to demonstrate how to use Lifecycle, a set of example applications can be found in ``demo`` folder.\r\n\r\nHigh level functionality provided by Lifecycle:\r\n\r\n* **Launch Manager**\r\n    * **Portability**: Compatible with multiple operating systems including Linux, QNX7, and QNX8.\r\n    * **Process Group Management**: Applications can be grouped into ProcessGroups, which are managed collectively as a single unit.\r\n    * **Startup and Shutdown Dependencies**: The order of application startup and shutdown is determined by predefined dependency configurations.\r\n    * **Failure Recovery**: Recovery actions are initiated upon detection of abnormal process termination.\r\n* **Health Monitor**\r\n    * **Supervision Types**: Supports Alive supervision, Deadline supervision, and Logical supervision.\r\n    * **Failure Recovery**: Recovery actions are requested to Launch Manager when supervision failures are detected.\r\n    * **Configurable Detection Timing**: The maximum failure detection time can be adjusted via a tunable supervision evaluation cycle.\r\n    * **External Watchdog Integration**: Compatible with external watchdogs through configurable watchdog device file.\r\n\r\n![Lifecycle Management Overview](images/lcm_overview.png)\r\n\r\n# Getting Started\r\n\r\nThis section contains information on how to build and use Lifecycle feature.\r\n\r\n## Prerequisites\r\n\r\n* C++ Compiler: gcc/clang with C++17 support\r\n* Rust Version: 1.85 (edition 2021)\r\n* Build System: Bazel\r\n* Operating System: Linux (Ubuntu 22.04+)\r\n* Dependencies: S-Core Baselibs, Google Flatbuffers, libacl1-dev\r\n* Dependencies of example applications: Docker, Python (3.12)\r\n\r\n## Building the project\r\n\r\nIt is recommended to use the devcontainer for building the project, see [eclipse-score/devcontainer/README.md#inside-the-container](https://github.com/eclipse-score/devcontainer/blob/main/README.md#inside-the-container)\r\n\r\nBuild all components for **Linux** by running\r\n\r\n```sh\r\nbazel build --config=x86_64-linux //...\r\n```\r\n\r\nTo test launch_manager and health_monitor with the sanitizers enabled use one of the following\r\n\r\n```\r\nbazel test --config=x86_64-linux --define sanitize=thread //...\r\n\r\nbazel test --config=x86_64-linux --define sanitize=address //...\r\n\r\nbazel test --config=x86_64-linux --define sanitize=undefined //...\r\n```\r\n\r\nTo build all components with ``score::mw::log`` enabled, use this command:\r\n\r\n```sh\r\nbazel build --config=x86_64-linux --cxxopt=-DLC_LOG_SCORE_MW_LOG //...\r\n```\r\n\r\n## IDE support\r\n\r\n### C++\r\nUse Visual Studio Code with `clangd`. Make sure you don't have the MS C++ IntelliSense extension installed as this is likely to clash with `clangd`.\r\nThen you need to call `./scripts/generate_cpp_compile_commands.sh` to generate compilation DB for clangd and restart it in VS Code. Indexing shall work.\r\n\r\n### Rust\r\n\r\n\r\n### QNX\r\n\r\n#### Envionment Setup\r\nEither add to ~/.netrc\r\n```sh\r\nmachine qnx.com\r\nlogin \u003cqnx email\u003e\r\npassword \u003cqnx password\u003e\r\n```\r\n(Makes sure your netrc has the right permissions `chmod 600 ~/.netrc`)\r\n\r\nOr export env vars:\r\n```sh\r\nexport SCORE_QNX_USER=\u003cqnx email\u003e\r\nexport SCORE_QNX_PASSWORD=\u003cqnx password\u003e\r\n```\r\nAlso if you are not running on the devcontainer make sure the qnx license\r\nis in the correct directory:\r\n\r\n```sh\r\nsudo mkdir /opt/score_qnx/license\r\ncp -r ~/.qnx/license/* /opt/score_qnx/license\r\nsudo chmod 777 -R /opt/score_qnx/\r\n```\r\n\r\nNext make the `~/.bazelrc` that contains the following:\r\n`common --action_env=QNXLM_LICENSE_FILE=\u003cLicense server / file\u003e`\r\n\r\n#### Build\r\n\r\n##### Fetch QNX SDP\r\n\r\nNote: For the next command if you are getting checksum mismatch errors then its\r\npossible you need to agree the terms and condition of the SDP by clicking the\r\nURL in the error message and completing the form.\r\n\r\n```sh\r\nbazel fetch @score_toolchains_qnx//...\r\ncred_helper=\"$(find -L $(bazel info output_base)/external -name qnx_credential_helper.py -print -quit)\"\r\nbazel fetch @toolchains_qnx_sdp//... --credential_helper=*.qnx.com=\"$cred_helper\"\r\n```\r\n\r\n##### Build For QNX\r\n\r\n```sh\r\nbazel build --config=x86_64-qnx -- //src/...\r\nbazel build --config=arm64-qnx -- //src/...\r\n```\r\n\r\nTODO: Currently rust binaries are not compiling for QNX.\r\n\r\n## Running Lifecycle feature and example applications\r\n\r\nThe ``examples`` folder contains a demo setup running in a docker container, consisting of a set of example applications and corresponding configuration. As per configuration, Launch Manager will start Health Monitor and a set of configured applications. For more information see [examples/README.md](examples/README.md) file.\r\n\r\n## Configuration\r\n\r\nLifecycle feature is configured by json files.\r\n\r\nFollowing json code demonstrates Launch Manager configuration. Key elements of the configuration:\r\n\r\n  * A single process group is configured (``MainPG``), with three states.\r\n  * A single process is configured with ``LD_LIBRARY_PATH`` environmental variable and no command line arguments.\r\n  * The configured process will run in ``Startup`` and ``Recovery`` state.\r\n\r\n```json\r\n{\r\n  \"versionMajor\": 7,\r\n  \"versionMinor\": 0,\r\n  \"Process\": [\r\n    {\r\n      \"identifier\": \"healthmonitor\",\r\n      \"uid\": 0,\r\n      \"gid\": 0,\r\n      \"path\": \"/opt/health_monitor/health_monitor\",\r\n      \"functionClusterAffiliation\": \"STATE_MANAGEMENT\",\r\n      \"numberOfRestartAttempts\": 0,\r\n      \"executable_reportingBehavior\": \"ReportsExecutionState\",\r\n      \"sgids\": [],\r\n      \"startupConfig\": [\r\n        {\r\n          \"executionError\": \"1\",\r\n          \"schedulingPolicy\": \"SCHED_OTHER\",\r\n          \"schedulingPriority\": \"0\",\r\n          \"identifier\": \"health_monitor_startup_config\",\r\n          \"enterTimeoutValue\": 20000,\r\n          \"exitTimeoutValue\": 1000,\r\n          \"terminationBehavior\": \"ProcessIsNotSelfTerminating\",\r\n          \"executionDependency\": [],\r\n          \"processGroupStateDependency\": [\r\n            {\r\n              \"stateMachine_name\": \"MainPG\",\r\n              \"stateName\": \"MainPG/Startup\"\r\n            },\r\n            {\r\n              \"stateMachine_name\": \"MainPG\",\r\n              \"stateName\": \"MainPG/Recovery\"\r\n            }\r\n          ],\r\n          \"environmentVariable\": [\r\n            {\r\n              \"key\": \"LD_LIBRARY_PATH\",\r\n              \"value\": \"/opt/lib\"\r\n            }\r\n          ],\r\n          \"processArgument\": []\r\n        }\r\n      ]\r\n    }\r\n  ],\r\n  \"ModeGroup\": [\r\n    {\r\n      \"identifier\": \"MainPG\",\r\n      \"initialMode_name\": \"Off\",\r\n      \"recoveryMode_name\": \"MainPG/Recovery\",\r\n      \"modeDeclaration\": [\r\n        {\r\n          \"identifier\": \"MainPG/Off\"\r\n        },\r\n        {\r\n          \"identifier\": \"MainPG/Startup\"\r\n        },\r\n        {\r\n          \"identifier\": \"MainPG/Recovery\"\r\n        }\r\n      ]\r\n    }\r\n  ]\r\n}\r\n```\r\n\r\nFor the convenience of the end user, a python module is provided for Launch Manager. Following code demonstrates Launch Manager configuration. Key elements of the configuration:\r\n\r\n  * A single machine is configured with, global ``LD_LIBRARY_PATH`` environmental variable.\r\n  * A single process group is configured (``MainPG``), with three states.\r\n  * 50 processes are configured, each with unique UID and GID.\r\n    * All processes are started from the same executable.\r\n    * All processes will be started in ``Startup`` state of ``MainPG`` process group.\r\n    * Each process has its own ``PROCESSIDENTIFIER`` environmental variable. Value of that variable is different for each process.\r\n    * Only second process has command line argument configured.\r\n\r\n```python\r\nconf_gen = LaunchManagerConfGen()\r\nqt_am_machine = conf_gen.add_machine(\"qt_am_machine\",\r\n                                     env_variables = {\"LD_LIBRARY_PATH\": \"/opt/lib\"})\r\n\r\npg_machine = conf_gen.machine_add_process_group(qt_am_machine,\r\n                                                \"MainPG\", [\"Off\", \"Startup\", \"Recovery\"])\r\n\r\nfor i in range(50):\r\n    cpp_lifecycle_app = conf_gen.process_group_add_process(pg_machine,\r\n                                                           f\"{process_group_name}_cpp_lifecycle_app{i}\",\r\n                                                           executable_name = \"/opt/cpp_lifecycle_app/cpp_lifecycle_app\",\r\n                                                           uid = 1000 + i,\r\n                                                           gid = 1000 + i)\r\n    conf_gen.process_add_startup_config(cpp_lifecycle_app,\r\n                                        f\"cpp_lifecycle_app_startup_config_{i}\",\r\n                                        process_arguments = [\"-c\", \"2000\"] if i == 1 else [],\r\n                                        env_variables = {\"PROCESSIDENTIFIER\": f\"{process_group_name}_lc{i}\"},\r\n                                        scheduling_policy = \"SCHED_OTHER\",\r\n                                        scheduling_priority = 0,\r\n                                        enter_timeout = 5.0,\r\n                                        exit_timeout = 2.0,\r\n                                        use_in = [\"Startup\"])\r\n\r\nconf_gen.generate_json(\"./lm_demo.json\")\r\n```\r\n\r\nFollowing json code demonstrates Health Monitor configuration. Key elements of the configuration:\r\n\r\n  * Single process is supervised.\r\n  * Alive, deadline and logical supervision is configured for that process.\r\n  * Single process group is configured.\r\n  * Recovery action for that process group is configured.\r\n\r\nSample configuration of the monitored application:\r\n```json\r\n{\r\n    \"versionMajor\": 8,\r\n    \"versionMinor\": 0,\r\n    \"process\": [],\r\n    \"hmMonitorInterface\": [\r\n        {\r\n            \"instanceSpecifier\": \"demo/demo_application0/Port1\",\r\n            \"processShortName\": \"demo_application0\",\r\n            \"portPrototype\": \"Port1\",\r\n            \"interfacePath\": \"demo_application_0_MainPG\",\r\n            \"refProcessIndex\":0\r\n        }\r\n    ]\r\n}\r\n```\r\n\r\nSample configuration of Health Monitor daemon:\r\n```json\r\n{\r\n    \"versionMajor\": 8,\r\n    \"versionMinor\": 0,\r\n    \"process\": [\r\n        {\r\n            \"index\": 0,\r\n            \"shortName\": \"demo_application0\",\r\n            \"identifier\": \"demo_app0_MainPG\",\r\n            \"processType\": \"REGULAR_PROCESS\",\r\n            \"refProcessGroupStates\": [\r\n                {\r\n                    \"identifier\": \"MainPG/Startup\"\r\n                }\r\n            ],\r\n            \"processExecutionErrors\": [\r\n                {\r\n                    \"processExecutionError\": 1\r\n                }\r\n            ]\r\n        }\r\n    ],\r\n    \"hmMonitorInterface\": [\r\n        {\r\n            \"instanceSpecifier\": \"demo/demo_application0/Port1\",\r\n            \"processShortName\": \"demo_application0\",\r\n            \"portPrototype\": \"Port1\",\r\n            \"interfacePath\": \"demo_application_0_MainPG\",\r\n            \"refProcessIndex\": 0,\r\n            \"permittedUid\": 0\r\n        }\r\n    ],\r\n    \"hmSupervisionCheckpoint\": [\r\n        {\r\n            \"shortName\": \"Checkpoint0_1\",\r\n            \"checkpointId\": 1,\r\n            \"refInterfaceIndex\": 0\r\n        },\r\n        {\r\n            \"shortName\": \"Checkpoint0_2\",\r\n            \"checkpointId\": 2,\r\n            \"refInterfaceIndex\": 0\r\n        },\r\n        {\r\n            \"shortName\": \"Checkpoint0_3\",\r\n            \"checkpointId\": 3,\r\n            \"refInterfaceIndex\": 0\r\n        }\r\n    ],\r\n    \"hmAliveSupervision\": [\r\n        {\r\n            \"ruleContextKey\": \"AliveSupervision0\",\r\n            \"refCheckPointIndex\": 0,\r\n            \"aliveReferenceCycle\": 100.0,\r\n            \"minAliveIndications\": 1,\r\n            \"maxAliveIndications\": 3,\r\n            \"isMinCheckDisabled\": false,\r\n            \"isMaxCheckDisabled\": false,\r\n            \"failedSupervisionCyclesTolerance\": 1,\r\n            \"refProcessIndex\": 0,\r\n            \"refProcessGroupStates\": [\r\n                {\r\n                    \"identifier\": \"MainPG/Startup\"\r\n                }\r\n            ]\r\n        }\r\n    ],\r\n    \"hmDeadlineSupervision\": [\r\n        {\r\n            \"ruleContextKey\": \"DeadlineSupervision0\",\r\n            \"maxDeadline\": 80.0,\r\n            \"minDeadline\": 40.0,\r\n            \"checkpointTransition\": {\r\n                \"refSourceCPIndex\": 0,\r\n                \"refTargetCPIndex\": 1\r\n            },\r\n            \"refProcessIndices\": [\r\n                0\r\n            ],\r\n            \"refProcessGroupStates\": [\r\n                {\r\n                    \"identifier\": \"MainPG/Startup\"\r\n                }\r\n            ]\r\n        }\r\n    ],\r\n    \"hmLogicalSupervision\": [\r\n        {\r\n            \"ruleContextKey\": \"LogicalSupervision0\",\r\n            \"checkpoints\": [\r\n                {\r\n                    \"refCheckPointIndex\": 0,\r\n                    \"isInitial\": true,\r\n                    \"isFinal\": false\r\n                },\r\n                {\r\n                    \"refCheckPointIndex\": 1,\r\n                    \"isInitial\": false,\r\n                    \"isFinal\": false\r\n                },\r\n                {\r\n                    \"refCheckPointIndex\": 2,\r\n                    \"isInitial\": false,\r\n                    \"isFinal\": true\r\n                }\r\n            ],\r\n            \"transitions\": [\r\n                {\r\n                    \"checkpointSourceIdx\": 0,\r\n                    \"checkpointTargetIdx\": 1\r\n                },\r\n                {\r\n                    \"checkpointSourceIdx\": 1,\r\n                    \"checkpointTargetIdx\": 2\r\n                }\r\n            ],\r\n            \"refProcessIndices\": [\r\n                0\r\n            ],\r\n            \"refProcessGroupStates\": [\r\n                {\r\n                    \"identifier\": \"MainPG/Startup\"\r\n                }\r\n            ]\r\n        }\r\n    ],\r\n    \"hmLocalSupervision\": [\r\n        {\r\n            \"ruleContextKey\": \"LocalSupervision0\",\r\n            \"infoRefInterfacePath\": \"demo_application_0\",\r\n            \"hmRefAliveSupervision\": [\r\n                {\r\n                    \"refAliveSupervisionIdx\": 0\r\n                }\r\n            ],\r\n            \"hmRefDeadlineSupervision\": [\r\n                {\r\n                    \"refDeadlineSupervisionIdx\": 0\r\n                }\r\n            ],\r\n            \"hmRefLogicalSupervision\": [\r\n                {\r\n                    \"refLogicalSupervisionIdx\": 0\r\n                }\r\n            ]\r\n        }\r\n    ],\r\n    \"hmGlobalSupervision\": [\r\n        {\r\n            \"ruleContextKey\": \"GlobalSupervision_MainPG\",\r\n            \"isSeverityCritical\": false,\r\n            \"localSupervision\": [\r\n                {\r\n                    \"refLocalSupervisionIndex\": 0\r\n                }\r\n            ],\r\n            \"refProcesses\": [\r\n                {\r\n                    \"index\": 0\r\n                }\r\n            ],\r\n            \"refProcessGroupStates\": [\r\n                {\r\n                    \"identifier\": \"MainPG/Startup\"\r\n                }\r\n            ]\r\n        }\r\n    ],\r\n    \"hmRecoveryNotification\": [\r\n        {\r\n            \"shortName\": \"RecoveryNotification_MainPG\",\r\n            \"recoveryNotificationTimeout\": 4000.0,\r\n            \"processGroupMetaModelIdentifier\": \"MainPG/Recovery\",\r\n            \"refGlobalSupervisionIndex\": 0,\r\n            \"instanceSpecifier\": \"\",\r\n            \"shouldFireWatchdog\": false\r\n        }\r\n    ]\r\n}\r\n```\r\n\r\nFull configuration for example applications can be found in ``examples/config`` folder.\r\n\r\n# Architecture\r\n\r\nThe Lifecycle feature is divided in to two logical components, Launch Manager and Health Monitor. In our solution each component is implemented as a separate daemon.\r\n\r\n## Launch Manager architecture\r\n\r\nFollowing diagram shows high level overview of Launch Manager architecture.\r\n![Launch Manager architecture overview](images/lm_arch_overview.png)\r\n\r\nMain components are:\r\n  * **Control client library:** Library used to control states of Process Groups. Each Process Group has a set of states that could be activated or switched off. This library can be used to control states of Process Groups from C++ or Rust application. Please note that by controlling Process Group states, we are starting or stopping applications. Rights to use this library has to be assigned during configuration step, otherwise an attempt to use this interface will be blocked.\r\n  * **Lifecycle client library:** Library used by S-CORE applications, to report application states back to Launch Manager. Every non native application should use this interface. This interface is available in C++ and Rust language.\r\n  * **Configuration manager:** Small portability layer, designed to protect business logic from changes in configuration format. Current implementation reads data from FlatBuffers files and populate internal data structures.\r\n  * **OS abstraction layer (OSAL):** Portability layer designed to protect business logic, from differences in POSIX based OSs. At the moment we support ``Linux`` based OSs and ``QNX``. It is worth to note, that we follow ``fork`` then ``exec`` path, when starting new processes. This approach provides greater flexibility than the ``spawn`` method, particularly when setting up the execution environment and access rights for child processes.\r\n  * **Process Group manager:** Business logic is implemented in Process Group manager. Following diagram shows high level overview, of this component.\r\n\r\n![Process Group manager architecture overview](images/process_group_manager_arch_overview.png)\r\n\r\nKey components of Process Group manager are:\r\n  * **OS Handler:** A simple thread tasked with collecting exit status of child processes. As soon as exit status of a child process becomes available, we collect it and pass that information to the Process Group manager.\r\n  * **Process Group:** Graph that holds information about processes that belongs to a particular Process Group. This is the place where we store start-up configuration, the information on how to start a process, as well as information on when to start a process.\r\n  * **Thread pool / Job queue:** This is our scalability engine. By controlling queue size and number of threads, we can scale up and scale down (in line with hardware capabilities we are running on).\r\n  * **Worker thread:** A simple wrapper around POSIX thread. It will fetch a job from a queue, if there is anything to be done, or sleep otherwise.\r\n  * **Process Group Manager:** This is where main business logic is implemented. This thread will service all external communication channels and if there is a Process Group state change requested, it will add initial process start to the queue. When thread pool process all start / stop operations, this component will send response to the requesting Control client library. If a Process Group end up in an error state, and there is no active request from outside, Process Group manager will execute a recovery action.\r\n\r\n## Health Monitor architecture\r\n\r\nFollowing diagram shows high level overview of Health Monitor architecture.\r\n![Health Monitor architecture overview](images/hm_arch_overview.png)\r\n\r\n  * **Health Monitor library (hm lib):** Library used by supervised applications to report checkpoints, that have been configured for monitoring. This library executes without a background thread, so we can avoid forced context switches when application reports a checkpoint.\r\n  * **Configuration:** Portability layer designed to shield business logic from changes in configuration format. Its implementation follows factory design pattern. We read data from FlatBuffers files and return fully initialized objects.\r\n  * **Supervision:** This component periodically reads all reported checkpoints from shared memory and evaluates supervision status for each configured process. Upon detection of an error condition, the recovery component is triggered to initiate appropriate corrective actions.\r\n  * **Recovery:** When an error is detected by supervision component, recovery component will perform preconfigured recovery action.\r\n  * **Watchdog:** This component is responsible for the initialization, control, and servicing of the external watchdog.\r\n\r\nThe Health Monitor is implemented as a single-threaded process. The frequency at which the supervision component evaluates reported checkpoints can be configured via a dedicated parameter. This configurability enables optimization of CPU utilization against worst-case fault detection latency. Depending on the target hardware platform, a trade-off can be made between detection time and CPU consumption.\r\n\r\nThe external watchdog abstraction layer is implemented using the ``/dev/watchdog`` device interface, which is commonly available on Linux-based operating systems. For QNX environments, the same interface can be implemented using a resource manager.\r\n\r\n\r\n# Requirements coverage\r\n\r\nThis overview represent a high level illustration of requirements coverage and is not a traceability view. Full list of requirement can be found here: [Lifecycle Requirements](https://eclipse-score.github.io/score/main/features/lifecycle/requirements/index.html).\r\n\r\n## ✅ Launch Manager features\r\n\r\n### Process management Capabilities\r\n\r\n    - Launch processes with dependency ordering ✅\r\n    - Parallel execution \u0026 Multiple instances of executables ✅\r\n    - UID/GID, Security policy and scheduler configuration ✅\r\n    - Timeouts \u0026 Retry on process startup ✅\r\n    - Validate dependency consistency (Tooling / startup) ⏳\r\n    - OCI compliance, ASLR support \u0026 process adoptions ⏳\r\n\r\n### Run targets \u0026 Conditional Launching\r\n\r\n    - Define, Launch \u0026 Switch between named run targets ✅\r\n    - Launch based on conditions (run targets / dependencies), Debug mode ✅\r\n    - Configurable timeouts and polling intervals for conditions ⏳\r\n    - Pre/post-start validation ⏳\r\n    - Define process dependencies and stop sequences (dependency based) ✅\r\n\r\n### Process Termination\r\n\r\n    - Configurable stop timeout ✅\r\n    - Terminate based on dependency order ✅\r\n    - SIGTERM/SIGKILL delay ✅\r\n    - Normal, slow, fast shutdown modes ⏳\r\n\r\n### Control Interface\r\n\r\n    - Allow external users to send control commands (activate, Stop, etc..) ✅\r\n    - Request run target launch ✅\r\n    - Component state reporting ⏳\r\n    - Report \u0026 query component status (started/running/degraded) ⏳\r\n\r\n## ✅ Health monitor features\r\n\r\n### Monitoring \u0026 Recovery\r\n\r\n    - Abnormal process termination detection ✅\r\n    - Timing \u0026 logical monitoring ✅\r\n    - Drop supervision ✅\r\n    - Recovery actions (run target switch \u0026 process relaunch) ⏳\r\n    - Configurable recovery wait time ✅\r\n    - External monitor notifications \u0026 watchdog support ✅\r\n    - Internal monitoring (self-health) checks ✅\r\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Feclipse-score%2Flifecycle","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Feclipse-score%2Flifecycle","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Feclipse-score%2Flifecycle/lists"}