OpenFrame Documentation
Deployment guides, the CLI reference, architecture and admin guides for OpenFrame
Flamingo Raises $4.5M Seed Round · Led by Vertex Ventures, bringing total funding to $6.7M to build the open, AI-native layer for IT and security.
Deployment guides, the CLI reference, architecture and admin guides for OpenFrame
Remote Management Scheduling is the server-side dispatch layer for recurring remote-management work in the OpenFrame Client service. It turns due script and software schedules into per-device deliveries, creates execution-tracking records before publishing work, and applies distinct offline and compatibility rules so that devices do not receive work they cannot execute.
The implementation is supplied by the com.openframe.oss:openframe-client-core library at version 7.0.11 and is run by this repository's OpenFrame Client service. This module owns dispatch decisions; schedule evaluation, message routing, execution, and result processing are performed by collaborating components.
flowchart LR
Scheduler["Scheduling trigger"] --> LocalService["Device Local Schedule Service"]
Scheduler --> ScriptDispatcher["Schedule Fire Dispatcher"]
Scheduler --> SoftwareDispatcher["Software Schedule Fire Dispatcher"]
OnlineEvent["Device online event"] --> BundleDispatcher["Software Bundle Online Dispatcher"]
LocalService --> TargetResolver["Schedule device target resolver"]
LocalService --> MachineRepo["Machine repository"]
LocalService --> LocalDispatchRepo["Local dispatch repository"]
LocalService --> ScriptDispatcher
ScriptDispatcher --> ScriptRepo["Script repository"]
ScriptDispatcher --> ExecutionRepos["Schedule and script execution repositories"]
ScriptDispatcher --> DeliveryRouter["Delivery router"]
ScriptDispatcher --> RetryStore["Script delivery retry store"]
SoftwareDispatcher --> PlatformResolver["Machine platform resolver"]
SoftwareDispatcher --> PackageServices["Package manager and update services"]
BundleDispatcher --> PackageServices
SoftwareDispatcher --> SoftwarePublisher["Software NATS publisher"]
BundleDispatcher --> SoftwarePublisher
SoftwarePublisher --> Agent["OpenFrame Client agent"]
DeliveryRouter --> Agent
The module is instantiated in the OpenFrame Client service. Its most important collaborators are provided by data, NATS delivery, and RMM services from the same OpenFrame OSS Library dependency:
| Collaboration | Purpose in this module |
|---|---|
| Schedule and target repositories/services | Load active schedules, resolve their assigned machines, and persist execution or dispatch state. |
| Machine repository and platform resolver | Supply online state, timezone, and operating-system information used to decide whether and how to dispatch. |
| Delivery router | Delivers scheduled script batches and can retain work for an offline machine when the route supports it. |
| NATS publishers | Send direct software script messages to a specific machine. |
| Package-manager and eligibility services | Select a package-management order or a direct script, based on machine capability and eligibility. |
| Retry store | Saves a delivery payload before dispatch so retry/watchdog facilities can republish it. |
Device Local Schedule Service evaluates active DATE_TIME script schedules whose time reference is DEVICE_LOCAL.
A device-local schedule stores its start value as a UTC wall-clock LocalDateTime. For each resolved target, the service combines that wall-clock time with the target machine's reported timezone to compute the actual instant at which that machine should run. It processes online and offline devices separately.
Key safeguards and behavior:
For an online device, a due occurrence outside its fire window is recorded as MISSED; otherwise it is recorded as FIRED before the service asks the Schedule Fire Dispatcher to send work to the single device.
For an offline device, SKIP behavior records the occurrence as missed. RETRY_ON_RECONNECT behavior depends on delivery routing: if the machine's script-schedule route can hold offline work, the service records FIRED and sends a batch with a deadline for that route to hold. Otherwise, it creates a reconnect-retry sentinel and records ARMED_FOR_RECONNECT. If the deadline has elapsed, it records MISSED.
Schedule Fire Dispatcher is the shared script-schedule dispatch boundary. It can resolve targets itself or accept a caller-provided target list, which is essential for single-device events such as a device-local occurrence or a device-online trigger.
Before publishing, it:
The dispatcher also enforces non-online target behavior for regular fires. Machines on a route that already holds scheduled work stay eligible for immediate routing; other non-online devices are either skipped or given a DeviceFirstOnlineDispatch retry record that expires after the schedule reconnect window.
Software Bundle Online Dispatcher applies every package in a software bundle to one machine when it is eligible for online dispatch. It is conditional on openframe.rmm.software.enabled=true.
For each package, it verifies that the machine reports a usable package manager, finds the canonical seeded software script for the package manager and requested action, and verifies that the script supports the machine operating system. It then derives a deterministic bundle/package execution identifier.
Eligible machines are dispatched through the package-update order path. That path enables the requested automatic-update policy and submits an administrative package update. Other machines receive a queued direct script execution; the dispatcher builds package-manager-specific arguments, publishes the software message to NATS, and saves the message in the retry store.
Software Schedule Fire Dispatcher dispatches each package in a software schedule to a supplied device set. It is also conditional on openframe.rmm.software.enabled=true.
The dispatcher resolves target operating systems in bulk and filters each package to machines compatible with the canonical software script. It partitions compatible machines into package-update-order targets and direct-script targets. Both groups share package metadata and a deterministic schedule/package execution identifier, but their delivery mechanisms differ:
sequenceDiagram
participant Trigger as "Scheduler"
participant Local as "Device Local Schedule Service"
participant Data as "Schedule and machine data"
participant Dispatch as "Schedule Fire Dispatcher"
participant Router as "Delivery router"
participant Agent as "Client agent"
Trigger->>Local: Evaluate due schedules
Local->>Data: Load active device local schedules
Local->>Data: Resolve targets, machines, and sentinels
Local->>Local: Calculate occurrence in each device timezone
alt "Online within fire window"
Local->>Data: Record fired sentinel
Local->>Dispatch: Dispatch to one machine
Dispatch->>Data: Save execution header and queued rows
Dispatch->>Router: Route machine batch
Router->>Agent: Deliver scheduled scripts
else "Offline with reconnect retry"
Local->>Data: Record armed or fired state
Local->>Dispatch: Arm retry or dispatch held batch
else "Late or skipped"
Local->>Data: Record missed sentinel
end
flowchart TD
Start["Software schedule or bundle fire"] --> Packages["Iterate configured packages"]
Packages --> Manager["Resolve package manager handler"]
Manager --> Script["Find active canonical software script"]
Script --> Compatible{"OS compatible targets?"}
Compatible -->|"No"| Skip["Log and skip package"]
Compatible -->|"Yes"| Eligible["Evaluate package update eligibility"]
Eligible --> Order["Enable policy and dispatch update order"]
Eligible --> Direct["Queue execution rows"]
Direct --> Publish["Publish software message per machine"]
Publish --> Retry["Store payload for retry"]
The module makes dispatch decisions durable before or alongside external message delivery:
A failure after persistence but before delivery can leave work queued for retry/recovery rather than silently treating it as completed. Conversely, the code deliberately does not infer a timezone, package manager, script, or platform compatibility when required data is absent.
openframe.rmm.schedule.device-local.catchup-seconds to define how long a device-local occurrence remains dispatchable when no reconnect-specific window applies.openframe.rmm.software.enabled is true and package manager telemetry is available.Remote Management Scheduling is invoked by scheduled-operation components that determine when normal schedule scans or online dispatches occur. It relies on the client-service delivery and telemetry pipeline to route messages and observe machine connectivity. The agent-side client receives scheduled script batches or software script messages, executes permitted work, and returns execution outcomes through the platform's delivery and result-processing pipeline.