Native applications and ProgramSets

Industrial sites run many traditional programs: acquisition scripts, protocol conversion daemons, and third-party binaries. Historically, they were started manually, managed separately, and could fail unnoticed. JelinaOS brings them into a unified declarative management system—ProgramSet—providing configuration-driven management, automatic fault recovery, and startup with the system.

What is a ProgramSet?

A ProgramSet is a collection of non-containerized applications, each described through declarative configuration:

• Startup: Command, working directory, and execution identity.
• Program source: Packages obtained from download URLs in the release configuration.
• Runtime policies: Restart policy, environment variables, and stop signal.
• Dependencies: Startup order, mutual exclusions, and strong/weak dependencies.
• Supervision: Restart limits, remaining active after exit, and pre/post commands.

Once configured, applications are centrally managed by the system without handwritten startup scripts.

Configuration entry points

Configure ProgramSets in the cloud or through local management interfaces; the device agent executes them:

Entry point	Use case	Description
Cloud release (recommended)	Devices connected to JelinaCloud	Declare ProgramSets when creating a Release and deliver them to devices in batches
Local management interface	Local / isolated environments	Deliver target configuration through the local device management interface

Quick start

The following declares a ProgramSet in a cloud release, with the program package distributed through a download URL:

programs:
  collector:
    uri: http://files.example.com/collector/collector.tar.gz   # Program package download URL
    command: collector --config /data/collector.conf
    running: true
    restart: always
    environment:
      SITE_ID: plant-01
    working_directory: /opt/collector
    user: root

• command: Startup command, required.
• running: Whether to run the program; defaults to true.
• restart: Restart policy; always enables automatic restart after an abnormal exit.
• environment: Environment variables.
• working_directory: Working directory.

Common settings

Setting	Description
uri	Program package download URL
command	Startup command, required
running	Whether to run; defaults to true
restart	Restart policy: no / on-failure / always, etc.
environment	Environment variables
working_directory	Working directory
user / group	Execution identity
after / before, wants / requires, conflicts	Dependencies and ordering
start_limit_*, remain_after_exit, exec_start_*, etc.	Supervision and recovery behavior

For all fields, see docker-compose compatibility and extensions.

Advanced configuration: startup at boot and condition checks

programs:
  myapp:
    command: run.sh
    restart: always
    Install:
      WantedBy: multi-user.target   # Start at boot
    Unit:
      ConditionPathExists: /data/app/config.json   # Condition: start only if the configuration file exists

Management operations

The device agent centrally manages ProgramSet applications as system services. Service names follow system naming conventions; use device status commands to find actual service names before inspecting or operating them:

systemctl status <program-service-name>   # View status; use the service name shown on the device
systemctl restart <program-service-name>  # Restart
systemctl stop <program-service-name>     # Stop

Use cases

• Traditional industrial programs: Modern management of acquisition, control, and communication daemons.
• Scripts and toolchains: Bring temporary scripts into formal management with automatic recovery.
• Hybrid architectures: Work with containerized applications within the same orchestration system.

Choosing between native and containerized applications

Scenario	Recommendation
Direct hardware access and stringent real-time requirements	Native application (ProgramSet)
Existing traditional programs with sensitivity to migration costs	Native application (ProgramSet)
Multiple languages and dependencies requiring environment isolation	Containerized application
Modern microservices architecture and rapid iteration	Containerized application