Skip to content

Variables ​

Ordyn has two variable layers:

  • persistent variables, which belong to the shared variable catalog and resolve through the scopes that apply to the current operation
  • runtime job variables, which exist only for one target during one job run

Persistent variables use vars.*. Runtime job variables use job.vars.*. The same templating system can read both.

Variable definitions ​

Create custom definitions for reusable values, choosing a stable key, value type, and optional default. System definitions are supplied by Ordyn; super administrators can edit their defaults. Use scoped overrides for values that differ across devices or environments.

Mark credentials as secret. Use Retrievable only when administrators need to reveal the stored value, for example for device recovery. Reveals are audited.

String variables support multiline values, including certificates. When a script needs exact original bytes, encode the value and decode it in the script; browser text entry normalizes line endings.

Scope and inheritance ​

Every persistent variable starts with its definition default. An applicable override replaces the value from every broader scope. The exact scopes depend on where Ordyn is resolving the variable.

SourceWhere it applies
Definition defaultEvery context in which the definition is available.
TenantEndpoints in that tenant.
Endpoint folderEndpoints in that folder and its descendant folders. Parent folders resolve before child folders.
GroupEndpoints that belong to the group. Group priority decides between matching groups.
EndpointThat endpoint.
ProductThe software product and endpoint tasks using it
PackageThe package and endpoint tasks using it. A package inherits from its product.
Infrastructure job folderInfrastructure jobs in that folder and its descendant folders. Parent folders resolve before child folders.
JobRuns of that saved job.
Submitted run valueThe selected target or targets in the run being started. Only prompt-enabled job variables accept submitted values.

Endpoint folders participate only in endpoint inheritance, and infrastructure job folders participate only in infrastructure-job inheritance. Endpoint-job folders, group folders, package folders, and variable-definition folders are organizational and don't override variables.

Endpoint job resolution ​

An endpoint task resolves the complete applicable chain in this order:

text
Definition default
→ endpoint tenant
→ endpoint folder ancestry
→ winning endpoint group
→ endpoint
→ task product
→ task package
→ job
→ submitted run value

An ordinary task skips the product and package layers and proceeds from the endpoint to the job and submitted value. A product task adds its product. A package task adds the package's product and then the package. This means a package value can override an endpoint value for that package task without affecting ordinary tasks in the same job.

The endpoint, product, and package layers remain live while an endpoint run is active. The job value and submitted run value are frozen when the run is created.

Infrastructure job resolution ​

Infrastructure jobs resolve custom definitions in this order:

text
Definition default
→ infrastructure job folder ancestry
→ job
→ submitted run value

The complete result is frozen when the run is created. Later changes to a definition default, folder override, or job override do not alter that run. See Job Variables for prompts and run behavior.

Product and package resolution ​

Outside an endpoint job, a product resolves the definition default and its product override. A package resolves the definition default, its product override, and its package override.

Matching groups ​

When an endpoint belongs to several groups with an override for the same definition, the override with the highest priority wins. If two or more matching groups share the highest priority, the group layer is ambiguous. The UI lists the conflicting groups, and Ordyn does not expose that variable to the task. Add a more specific endpoint, product, package, job, or submitted run value, or assign distinct group priorities, to resolve the conflict.

Null values and removal ​

An explicit null at a more specific scope masks values from broader scopes and is exposed to the job as an unresolved value. Removing the override removes the mask and restores normal inheritance.

Inspect effective values ​

Review the effective value and its source on the relevant scope before running work. A job's displayed default does not include every target-specific value; see Job Variables.

Use secret variable definitions for passwords and secret settings. Leaving a secret input blank while editing preserves it; clear it explicitly to remove the value.

To branch on customization rather than the value, use has_endpoint_variable_override as described under Advanced expressions.

Built-in credential variables ​

Ordyn provides these retrievable secret system variables for device credentials:

  • hardware.firmware.password
  • hardware.intel_amt.admin_password
  • hardware.intel_amt.mebx_password
  • windows.local_admin_password

Their values are encrypted and redacted by default. Authorized administrators can reveal a value from the Variables page; every reveal is audited. Configure a global default only when devices share a credential and use overrides where credentials differ.

windows.local_admin_username is a non-secret system variable. Its default is OrdynAdmin; a super administrator can edit that default from the Variables page.

Firmware password ​

hardware.firmware.password is a built-in secret variable that authorizes firmware-setting remediation on password-protected devices.

Configure it with the device's existing Dell Admin or BIOS setup password. The value is resolved through the normal endpoint variable precedence, so you can configure a shared secret at a broader scope and add endpoint overrides for devices with different passwords.

Firmware / BIOS Policy remediation uses the password when it finds drift and the device reports that an Admin BIOS password is set. Audit-only runs do not use it. If the device has no Admin BIOS password, a configured value is ignored.

A missing or incorrect value causes protected remediation to report an error. Editing this variable changes the stored credential. Use Set/change BIOS admin password to change the device's password. A successful job stores the applied password as an endpoint override and shows it in plain text in job output.

Value history ​

Select a variable and choose Revisions from its context menu to browse retained values. In an endpoint or other scope's variable list, revisions show values recorded for that scope.

To find a deleted override, open the scope's Variables tab, select View → All variables, and choose Revisions from the variable's context menu. If several override histories are available, choose the history you need using its last change time and actor. Open a revision from before deletion to read the recorded value. Viewing a revision does not restore the override.

Use Variables → Actions → Revision archive to find retained values when the variable or endpoint itself has been deleted. Search by variable key, label, or recorded scope name, such as an endpoint name.

To apply a retained value again, choose Restore on a revision from before deletion. This recreates the override and records a new revision. See Restore a revision for access and dependency requirements.

Revisions include values recorded at creation, replacement, clearing, and deletion, together with the original scope, time, and actor. These values remain available after the endpoint or variable is deleted. Retention has no expiry.

Firmware password job runs record the previous credential and the proposed password in their output and downloaded logs, including attempts with an uncertain outcome. These records are accessible while the job run is retained. A successful password change also saves the applied password as an endpoint variable override, creating a variable revision.

Secret values in revisions are masked. Use Reveal value when your assigned role supports viewing credentials in that scope. A version must have been retrievable when it was recorded. Changing the variable's retrievability does not unlock older versions. Reveals are audited. Job output displays firmware passwords directly without a reveal action.

Runtime job variables ​

Use Set job variable to store job.vars.<name> for later steps on the same target. Values are not shared with other targets or new runs. Writing the same name replaces its value.

Generate password creates a secret runtime value. A completed generation step keeps its value when the run resumes; another executed loop iteration generates a new one.

Runtime secrets remain with retained run data. See Infrastructure run retention. They do not become entries in persistent variable history.

Templating ​

Fields that support templating accept {{ ... }} placeholders.

Use template fields when you want Ordyn to resolve values during execution inside otherwise literal text. If the whole field is one template expression, Ordyn preserves the resolved scalar type. If you mix literal text and template expressions, Ordyn turns the result into text.

Common template sources include:

  • vars.* for persistent variables
  • job.vars.* for runtime job variables
  • steps["step-id"].result.* for earlier task results
  • endpoint.* for endpoint context
  • trigger.* for the event or action that started the job run
  • job.run.* for current run metadata
  • job.git.* for the infrastructure job's Git source
  • job.workspace for the absolute shared workspace path in supported endpoint and infrastructure job fields
  • collector["collector-id"].field for stored collector values
  • loop.* inside loop bodies

Common endpoint context fields include endpoint.id, endpoint.kind, endpoint.hostname, endpoint.fqdn, endpoint.tenant_id, and endpoint.primary_ip_address. The primary address comes from the endpoint's primary network interface and is null when no primary address is available.

Missing template paths fail the task instead of resolving as empty text.

For endpoint jobs, {{ job.workspace }} resolves to the workspace shared by all tasks for that endpoint target. Endpoint scripts and package commands use this directory as their default working directory. Each endpoint target has a separate workspace, and Ordyn removes it after the target finishes.

For infrastructure jobs, {{ job.workspace }} resolves to the reserved Runner's host workspace path. In Docker execution it resolves to the job's configured container workspace path. Use it in inline Runner script content, executable paths and arguments, string parameters, environment values, and rendered staged-file content. Runner working directories, file-placement destinations, Git checkout destinations, and artifact paths remain workspace-relative and do not accept this reference.

Saved Runner script content is executed verbatim. Use ORDYN_WORKSPACE in the script or pass the workspace through a string parameter.

Commands receive the resolved secret values they need. Do not rely on output redaction to protect transformed values or files; follow script secret guidance.

Endpoint infrastructure roles ​

Endpoint jobs can read the infrastructure roles configured in Edit endpoint:

VariableTypeMeaning
endpoint.infrastructure_roles.ordyn_server_hostbooleanWhether the endpoint is marked as an Ordyn server host.
endpoint.infrastructure_roles.ordyn_edge_hostbooleanWhether the endpoint is marked as an Ordyn edge host.
endpoint.infrastructure_roles.ordyn_hypervisor_hostbooleanWhether the endpoint is marked as an Ordyn hypervisor host.
endpoint.infrastructure_roles.edge_service_idstring or nullAssigned Edge service ID for an Ordyn edge host, or null when no Edge service applies.

These fields are available as Endpoint field references in the guided If branch editor.

The equivalent raw condition is:

text
endpoint.infrastructure_roles.ordyn_server_host == true

Role variables describe the job target endpoint even when another supported task uses a fixed execution endpoint.

Expressions ​

Some fields use raw expressions instead of {{ ... }} placeholders.

That is the case for:

  • condition editors
  • Set job variable
  • Set variable override

In those fields, write the expression directly, for example:

  • endpoint.primary_user
  • vars.site_code
  • job.vars.selected_site
  • job.run.total_steps
  • steps["check"].result.outcome
  • vars.registry.token

Secret variable expressions in Set job variable resolve the real value and store the result as an encrypted runtime secret. Set variable override rejects secret expressions for non-secret destinations. Setting a persistent secret override requires a source secret variable from the catalog; generated runtime passwords are not catalog variables.

To collect diagnostics only after the main work fails, add an If task in Cleanup with job.run.main_status == "failed". The main result can be succeeded, failed, aborted, or timed_out; it is not set while Tasks are running.

job.run.phase identifies the current section as main or cleanup. Cleanup can also use earlier step results and job variables.

Advanced expressions ​

Advanced expressions can reference:

  • earlier task results through steps["<step-id>"]
  • persistent inherited variables through vars.<name>
  • built-in endpoint context through endpoint.<field>
  • job run trigger details through trigger.<field>
  • explicit runtime job variables through job.vars.<name>
  • current run metadata through job.run.<field>

The same authored reference model is used by jobs, package workflows, and OS image workflows so branching logic behaves consistently across editors.

Examples:

  • steps["task-id"].result.outcome == "terminated"
  • steps["task-id"].result.reboot_required == true
  • steps["task-id"].result.is_installed == false
  • steps["task-id"].result.found == true
  • steps["task-id"].result.updated_key_count == 1
  • vars.site_code == "BER" || vars.site_code == "MUC"
  • endpoint.system.battery_charge_percent >= 50
  • trigger.type == "self_service"
  • trigger.self_service.windows_account == "ACME\\alex"
  • job.vars.install_state == "ready"
  • job.run.total_steps > 4
  • steps["task-id"].status == "succeeded" && vars.process_state != "failed"
  • contains(vars.site_code, "BER")
  • !contains(vars.site_code, "TEST")
  • is_empty(vars.maintenance_window)
  • !is_empty(job.vars.detected_version)
  • has_endpoint_variable_override("vars.site_code", "direct_endpoint") == true
  • has_endpoint_variable_override("vars.site_code", "effective") == false

Use a Set job variable step when you want to store a runtime value for later job steps or branches. That step writes into job.vars.*.

Supported operators:

  • ==
  • !=
  • >
  • >=
  • <
  • <=
  • &&
  • ||
  • parentheses for grouping

String values additionally support:

  • contains(value, needle)
  • !contains(value, needle)
  • is_empty(value)
  • !is_empty(value)

Array values support exact membership checks:

  • contains(vars.allowed_paths, "/opt/ordyn-api")
  • !contains(vars.ignored_paths, loop.vars.compose_project.working_dir)

In the visual condition editor these appear as contains, does not contain, is empty, and is not empty for string sources. Empty-string checks should use is empty / is not empty; do not rely on comparing against "" in the guided editor.

Variable override checks use:

text
has_endpoint_variable_override("vars.<variable-key>", "direct_endpoint")
has_endpoint_variable_override("vars.<variable-key>", "effective")

The first argument must be a persistent variable reference under vars.*. The second argument must be either direct_endpoint or effective.

Runtime references ​

Use task results for values produced earlier in the same run. Use a collector reference for the endpoint's latest stored value:

text
collector["collector-id"].battery_charge_percent >= 80

Stored collector values can be older than the current job. Use the result of Run collector when the branch needs that collection's output.

Git source variables ​

Infrastructure jobs with a Git source can use these values in steps after checkout:

VariableMeaning
job.git.refFull checked-out ref, such as refs/pull/42/head.
job.git.logical_branchLogical branch name from the repository specification.
job.git.commitFull commit SHA actually checked out.
job.git.repository_nameName of the selected repository entry.
job.git.repository_urlRepository URL.

For example, pass {{ job.git.commit }} to a build script to include the source revision in its output. These checkout values are unavailable when resolving the job's default branch.

Trigger variables ​

Every job run target receives trigger details under trigger.*.

Common fields:

VariableMeaning
trigger.typeThe run origin, such as manual, time, self_service, webhook_received, git_changed, snmp_trap_received, endpoint_connected, post_enrollment, system_boot, user_logon, user_logoff, job_completed, windows_update_approved, or system_shutdown_requested.
trigger.sourceThe source category, such as manual, schedule, self_service, webhook, snmp, or automation.
trigger.target_endpoint_idEndpoint target for this job run target. Infrastructure runs do not provide an endpoint target.

Git changes runs include the detected source revision:

VariableMeaning
trigger.git.repository_idShared repository entry ID.
trigger.git.refFull Git ref that changed.
trigger.git.commitDetected commit pinned for this build.

Manual runs can include:

VariableMeaning
trigger.modeManual run mode, such as selected endpoints, assigned endpoints, or scope.
trigger.user.idUser ID that started the run.
trigger.user.nameUser display name.
trigger.user.emailUser email address.

Time-based runs can include:

VariableMeaning
trigger.schedule.idSchedule ID.
trigger.schedule.nameSchedule name.
trigger.schedule.scheduled_for_atScheduled run time.
trigger.schedule.deferredWhether the run waited for an offline endpoint to reconnect.

Windows update approval runs can include:

VariableMeaning
trigger.windows_update.approval_countNumber of approval events combined into this run.
trigger.windows_update.ring_idsIDs of enabled Windows update rings involved in the combined event.
trigger.windows_update.approval_sourcesApproval sources included in the event, such as manual or automatic.
trigger.windows_update.reasonsReasons the approvals became active, such as approval or ring_enabled.
trigger.windows_update.first_event_atTime of the first combined approval event.
trigger.windows_update.last_event_atTime of the most recent combined approval event.

Self-service runs can include:

VariableMeaning
trigger.self_service.windows_accountWindows account that requested the run.
trigger.self_service.source_session_idWindows session ID that launched the portal request. Use it to target self-service user messages and session-scoped process termination.
trigger.self_service.source_endpoint_idEndpoint where the portal request came from.
trigger.self_service.source_endpoint_hostnameHostname where the portal request came from.
trigger.self_service.target_endpoint_idEndpoint selected for the job.
trigger.self_service.target_endpoint_hostnameHostname selected for the job.
trigger.self_service.target_endpoint_idsEndpoint IDs included in the self-service run. Multi-device self-service runs include every eligible assigned endpoint.
trigger.self_service.target_endpoint_countNumber of endpoints included in the self-service run.
trigger.self_service.authorization_basisPolicy basis that allowed the request.

Webhook runs can include:

VariableMeaning
trigger.webhook.event_idStored webhook event ID.
trigger.webhook.webhook_idWebhook definition ID.
trigger.webhook.service_client_idWebhook service client ID.
trigger.webhook.endpoint_idEndpoint targeted by an endpoint-scoped webhook. Infrastructure-scoped webhooks leave this value empty.
trigger.webhook.methodHTTP method.
trigger.webhook.source_ipResolved caller source IP.
trigger.webhook.content_typeRequest content type, when provided.
trigger.webhook.headersNormalized request headers.
trigger.webhook.queryQuery parameters.
trigger.webhook.bodyParsed request body.
trigger.webhook.raw_bodyRaw request body text, when present.
trigger.webhook.payloadFull normalized request payload.

SNMP trap runs can include:

When one trap fans out to multiple endpoints, every resulting run receives the same stored trap event and normalized payload.

VariableMeaning
trigger.snmp.event_idStored trap event ID.
trigger.snmp.service_client_idSNMP service client ID.
trigger.snmp.source_addressTrap source address.
trigger.snmp.source_portTrap source port.
trigger.snmp.versionSNMP version.
trigger.snmp.auth_identityCommunity or SNMPv3 identity.
trigger.snmp.trap_oidTrap OID.
trigger.snmp.enterprise_oidEnterprise OID, when present.
trigger.snmp.uptime_ticksDevice uptime ticks from the trap.
trigger.snmp.varbindsTrap varbind list.
trigger.snmp.payloadFull normalized trap payload.

Windows user logon and logoff runs can include:

VariableMeaning
trigger.windows_session.event_idUnique ID of the accepted logon or logoff event.
trigger.windows_session.occurred_atTime reported by the endpoint agent.
trigger.windows_session.principalWindows account name, when Windows provides it. This can be empty for logon or logoff events.
trigger.windows_session.session_idWindows session ID.
trigger.windows_session.is_consoleWhether this is the local console session.
trigger.windows_session.is_remote_desktopWhether this is a Remote Desktop session.

System boot runs can include:

VariableMeaning
trigger.system_boot.event_idUnique ID of the detected system boot event.
trigger.system_boot.boot_idBoot identity reported by the endpoint.
trigger.system_boot.previous_boot_idBoot identity reported before this boot.
trigger.system_boot.booted_atEstimated operating-system boot time, based on the report time and uptime when available.
trigger.system_boot.observed_atTime Ordyn detected the changed boot identity.
trigger.system_boot.uptime_secondsEndpoint uptime reported when the boot was detected.

Job-completed and shutdown automations can include:

VariableMeaning
trigger.source_job_run_idSource job run ID, when another job triggered the run.
trigger.source_job_run_target_idSource job run target ID, when available.
trigger.shutdown_request_idShutdown request ID for shutdown-triggered runs.

Branching example ​

process.terminate exposes a normalized runtime result:

  • result.outcome
    • terminated
    • not_running
    • failed
  • result.matched_process_count
  • result.terminated_process_count

That makes the common "terminate if running, otherwise continue" pattern much less brittle than matching free-form stderr text.

One example flow:

  1. terminate process AcmeApp.exe
  2. add a Set job variable task that stores the task's Outcome as job.vars.process_state
  3. add an if task that checks whether job.vars.process_state equals not_running or terminated
  4. run uninstall only in the selected then branch

Common patterns ​

  • Use a persistent variable for environment, tenant, or folder defaults.
  • Use Set variable override when job logic should set, null, or remove a persistent override for a tenant, endpoint folder, group, or endpoint.
  • Use Set job variable when a later step in the same target needs the computed value again.
  • Use templated fields for commands, file content, scripts, and other text that should mix literal text with resolved values.

Where to go next ​