Applications & installed software¶
Software & lifecycle → Applications is the catalog of software your tenant runs - PostgreSQL, nginx, a Java runtime, an in-house service. Each device and virtual machine records what is installed on it, at which version, on its Software tab. With end-of-life data on, each install's version finds its release cycle, so software ends show up on the Lifecycle overview, in the lists' Next end of life column and, if you ask for it, in compliance rules. An application's flows record the traffic it needs. With a licence on each application, the hosts export as a software bill of materials.
Nothing ships pre-filled: no applications, no groups, no installs.
The catalog¶
An application has a name, a slug (its import key; a rename keeps
it), an optional manufacturer, a license (an SPDX licence
expression such as PostgreSQL or MIT OR Apache-2.0, which its installs
inherit; see Licences), optional Package URL and
CPE templates (purl_template, cpe_template, with {version} and
{os_version} placeholders; see Package URLs and
CPEs), a description, tags and
custom fields. Applications are tenant-wide, like
platforms; a site role reads them, so its editors can pick them on their
devices.
Package names¶
Package names (one per line on the form) say which inventoried packages are the application, so Discovery records its installs from what it reads on each host:
| Entry | Takes |
|---|---|
deb:nginx |
the Debian/Ubuntu package nginx |
rpm:httpd |
the RPM package httpd |
deb:postgresql-1* |
postgresql-16, postgresql-17, … |
nginx |
nginx as a deb, rpm or apk package |
generic:Mozilla Firefox* |
a Windows program of that name |
Names are exact, or a glob whose only wildcard is *; there are no regular
expressions. Linux names compare in lower case, Windows program names
without case. At most 50 entries. When a host has several matching
packages, the earliest entry wins (nginx over nginx-common), then the
shortest name. Changing the list brings the installs in line at once.
The tree¶
Parent nests applications into a tree - a business domain, its processes, their applications:
The list opens in tree order: a parent, then its children under it, each
marked └ and indented one step per level, with the path before the name
(Payments › Checkout › checkout-api). Sorting by Name keeps that order;
the picker reads the same. An application cannot be its own ancestor. Deleting a parent
is refused while it has children: move or delete them first.
The list shows each application's installs and flows. Its Columns menu adds Parent, Manufacturer, Children and the End-of-life product; the rail has Parent and Manufacturer facets.
The application page¶
Overview carries the attributes, the Hierarchy card and, while end-of-life data is on, the End of life card (see End of life). Hierarchy shows the path to the root as linked crumbs and the children three levels deep, each linked with its install count; a deeper branch ends in +N, which opens that child's Child applications. Overview counts the installs - the count opens the Lifecycle overview filtered to this application - the flows and the requirements.
Installed on lists every install, with its Cycle and a manual chip
where the cycle was set by hand. ?cycle=8 narrows it to one cycle,
?cycle=none to the installs no cycle took; the chip above the table clears
it. Flows and Diagram show its flows (the Diagram is the Application map),
Requirements the flows it needs from wherever it is installed (see
Requirements), Child applications
the children, then Journal and Change log.
An application with installs, child applications, flows or requirements - or one another application's requirement names as Hosts of - cannot be deleted (409); the refusal names what holds it. The list's bulk delete skips such rows and says why.
Installs document flows¶
An application's requirements turn its installs into flows. Recording an install - by hand, by an import, by assigning an application group or a device profile - documents the flows the application needs on that host; removing it, or moving it to another host, takes them away. The host's Flows tab lists the requirements that apply to it and says when one can't be met (no primary address). Groups and profiles add nothing of their own: each install they make or remove is an ordinary install change.
Installed software¶
An install is one application at one version on exactly one device or virtual machine. The same version is recorded once per device or VM.
| Field | |
|---|---|
| Application | From the catalog. |
| Version | Free text, e.g. 16.4. |
| Cycle | The end-of-life release cycle. Blank derives it from the version and the application's product (16.4 → 16); a value you set sticks until you clear it. |
| Service | Optional: the service it answers on - one of the same device's or VM's. |
| Released, End of support | Optional dates; each wins over the cycle's. |
| License | Optional SPDX licence expression for this install only; blank uses the application's. The SBOM reports this one, else the application's. |
| Package URL, CPE | Optional finished purl / cpe for this install only; blank fills in the application's template. See Package URLs and CPEs. |
| Description, tags, custom fields | |
| Source | manual, import, discovery or group. Rows you add are manual, an import's are import, an application group's are group. Discovery made the install - from an inventoried package (its package names) or an accepted service-scan finding. |
| Group | The application group whose assignment made the install, while it is its. Read-only. |
| Last seen | When discovery last saw it. |
| Observed version | Read-only: the version discovery's package inventory reads on the host. On an install you made, the Software tab shows Discovery reads 1.26.3 when it differs from your version; your version is never overwritten. |
The Software tab on device and VM pages lists the installs with their
version, service, Group, License (the install's own, marked
override, else the application's), End of life status and lifetime bar
(Cycle, Source, Last seen, Package URL and CPE are in the Columns menu). Add software and the
row's edit open the same dialog; tick rows to delete several at once.
Assign group assigns an application group. The tab
label carries the count (install_count on /api/devices/ and
/api/virtual-machines/, list and detail), and the page's Overview has a
Software card: the first eight installs, each with its version and
lifetime bar, then View all N to the tab.
Installs can also be added from the application: Add on its Installed on tab opens the same dialog with the application fixed, where you choose Device or Virtual machine and pick one.
End of life¶
The application's product and an install's cycle together pick an end-of-life mapping, shared by every install of that application on that cycle and kept current by the daily refresh - see Map an application. An install's end is its own End of support when entered, else its cycle's end of life; the start the same way.
The End of life card on the application's Overview shows:
- Source - endoflife.date; for a deployment admin it links to Settings → General → End-of-life data. A custom product reads Custom.
- Product - its name, linked to the product's page on endoflife.date (a custom product links to its own page). A product missing from the cached catalog, or one none of the installs' versions match, says so in a line under the card.
- Cycles - each cycle the installs run, with its status, release date, end of life with the time left, latest version, LTS and the installs on it; the count opens Installed on filtered to that cycle. An Unmapped row counts the installs whose version matched no cycle. All cycles adds the product's other cycles, muted.
Change product opens the product picker - the fetched catalog and the tenant's own custom products, those marked Custom; Remove clears it. A deployment admin also gets Refresh now (not for a custom product), which fetches the catalog as the settings card does. To pin one install to another cycle, edit the install and set its Cycle.
Elsewhere the status links back here: the End of life badge on a device's or VM's Software tab and on Installed on, and the End date of a software row on the Lifecycle overview.
Application groups¶
Software & lifecycle → Application groups holds named sets of applications - RDS, SCADA, Web front end - so a server is marked with everything it runs in one step, and automation reads that from the Ansible inventory to set the host up.
A group has a name, a slug (the inventory key; a rename keeps it), a description, tags and custom fields, and its applications in order, each with an optional version its installs start at. Groups are tenant-wide, like applications.
The group page has Overview, Applications (add, remove, reorder, change a version), Hosts (the devices and VMs it is assigned to, with Assign and Unassign), Journal and Change log. An application's page lists the groups it is in.
Adding an application that has children offers Include children (on by default): every application under it joins too, right after it in tree order, skipping ones already in the group. Each stays its own member with its own version - only the picked application gets the version you enter - so removing or re-versioning one later leaves the others alone.
Assigning a group¶
Assign a group from the Software tab of a device or VM (Assign group), from the group's Hosts tab, or pick Application groups in the device and VM forms - a new server then gets its groups with its first save. The groups on a host show above its software as badges; the × on a badge unassigns it.
| When | What happens to the installs |
|---|---|
| A group is assigned | One install per application, at its version, Source group, Group set. An application the host already records is left alone - no second install. |
| A group is unassigned | The installs it made are removed while untouched; edited ones stay, with Group cleared. |
| An application joins the group | It is installed on every host the group is assigned to. |
| An application leaves the group | Its installs from the group go as on unassign. |
| An application's version changes | The untouched installs follow the new version (unless the host already records it); edited ones keep theirs. |
An install is untouched while its version is the group's version for that application, it names no service and its cycle was not set by hand. Anything else counts as edited. When another group on the same host also has the application, that group takes the install over instead.
A group that is assigned anywhere cannot be deleted (409): unassign it first. Deleting a device or VM takes its assignments along.
In device profiles
A device profile can name application groups: assigning the profile assigns them, as an ordinary group assignment. A group already on the host is left alone. A group says what a server runs; a profile says what a server is. A group a profile names cannot be deleted (409 naming the profiles). Profiles are applied from the Profiles card on a device's or VM's Overview, the Profiles field in its form, or Apply profile on a selection of the device and VM lists - see On devices and VMs.
Ansible inventory¶
/api/inventory/ansible/ gives every host's danbyte block two more keys,
and each assigned group becomes an inventory group app_group_<slug>:
"danbyte": {
"application_groups": ["rds"],
"applications": [
{"name": "Office", "slug": "office", "version": "365", "group": "rds"},
{"name": "RD Session Host", "slug": "rdsh", "version": "2022", "group": "rds"}
]
}
version is null when none is recorded, group is null for an install
no group made. A play can target hosts: app_group_rds, or loop over
danbyte.applications. See IaC runner for the whole export.
Service templates¶
A service template may name the application behind it (Postgres - TCP 5432 → PostgreSQL), so the software and the endpoint are recorded together.
Import & export¶
Both are in Import & export:
- Applications (
application) - matched byslug;parentby slug,manufacturerby name.licenseis the SPDX licence expression;purl_templateandcpe_templatethe package identifier templates. - Installed software (
installedsoftware) - matched byapplication(slug),deviceorvirtual_machine(name) andversion. A row an import creates is markedsource=import;groupby slug.licensesets the install's own licence (blank: the application's);purlandcpeits own package identifiers. - Application groups (
applicationgroup) - matched byslug. Their applications are kept on the group page or through the API. - Application group assignments (
applicationgroupassignment) - export only: assigning records installs, which the API and the pages do.
application,device,virtual_machine,version,license
postgresql,db-01,,16.4,
openjdk,,app-vm-02,17.0.9,GPL-2.0-only WITH Classpath-exception-2.0
A licence that isn't an SPDX expression, or a purl or CPE that fails the check, fails its row.
Permissions¶
application, installedsoftware and applicationflow are their own
object types (flows: Permissions). An install
belongs to its device's or VM's site: a site editor records software on the
devices and VMs of their sites, and a site role reads the applications. The
Lifecycle overview lists an install only to someone who may view both the
install and the device or VM it runs on.
applicationgroup is a tenant-wide catalog a site role reads, like
applications; its applications go with it, and changing them takes change
on the group. applicationgroupassignment belongs to its device's or VM's
site, like an install. Assigning takes add on the assignment and on
installed software at that site; unassigning takes delete on both, since
the installs are written as you.
API¶
| Endpoint | |
|---|---|
/api/applications/ |
CRUD. ?search=, ?manufacturer=, ?eol_source= and ?eol_product= (the applications mapped to one end-of-life product), ?parent= (an id, or none for the roots), ?ancestor= (everything under an application, any depth), ?picker=1 ({id, name, slug, path, depth, child_count}). POST bulk-delete/. Delete answers 409 while installs, children or flows exist. |
/api/applications/<id>/eol/ |
GET, PUT {"product", "source"} (source defaults to endoflife_date; custom for one of the tenant's own products), DELETE; 404 while end-of-life data is off. GET and PUT answer {source, product, cycles, other_cycles, unmapped_installs, in_catalog, source_label, product_label, product_url, custom, product_id}; each cycle carries install_count, the installs you may view. product_id is a custom product's id. |
/api/installed-software/ |
CRUD. ?device=, ?virtual_machine=, ?application=, ?service=, ?group=, ?cycle= (none for the installs no cycle took), ?search=. POST bulk-delete/. |
/api/application-groups/ |
CRUD. ?search=, ?application=, ?device=, ?virtual_machine=, ?picker=1 ({id, name, slug}). POST bulk-delete/. Delete answers 409 while the group is assigned. |
/api/application-group-assignments/ |
List, POST (assign), DELETE (unassign). ?group=, ?device=, ?virtual_machine=. POST set/ makes a host's groups exactly a list. |
An application carries parent, path, depth, manufacturer,
license, purl_template, cpe_template, package_names (a list, see
Package names; 400 with the reason for an entry that is
not one), eol_source, eol_product, eol ({source, product, cycles}, null while
the feature is off), install_count, child_count and flow_count. The
detail adds ancestors (root first) and children (three levels deep), each
{id, name, install_count}, children with child_count and their own
children; the list leaves both empty. Write parent_id and
manufacturer_id.
An install carries application ({id, name, slug, path}), device or
virtual_machine, version, cycle, cycle_manual, service,
release_date, end_of_support, eol (the cycle's status and facts),
effective_release, effective_end, effective_source, source,
last_seen, observed_version (read-only), group ({id, name, slug} or null), license (its own)
and effective_license (its own, else the application's), purl and
cpe (its own) and effective_purl / effective_cpe (what the SBOM
writes). Write application_id, device_id or virtual_machine_id,
service_id, cycle (blank to derive it), license, purl and cpe. A license that isn't an SPDX licence
expression answers 400. Every reference must be the
active tenant's; the service must be on the same device or VM.
curl -X POST https://danbyte.example/api/installed-software/ \
-H "Authorization: Token $TOKEN" -H "Content-Type: application/json" \
-d '{"application_id": "…", "device_id": "…", "version": "16.4"}'
A group carries members ([{id, application, version, position}], in
order), member_count, host_count and install_count. Write members as
the whole ordered list [{"application_id", "version"}]: applications left
out are removed, new ones added, and the installs on every assigned host
follow. An entry with "include_children": true also adds every application
under it (all depths, the ones you may view) right after it in tree order,
each with a blank version, skipping applications already in the list. An assignment carries group, device or virtual_machine and
install_count (the installs the group made there that are still its). Its
DELETE answers what became of them: {"removed", "kept", "moved"}.
# A new server gets the RDS group and its installs
curl -X POST https://danbyte.example/api/application-group-assignments/ \
-H "Authorization: Token $TOKEN" -H "Content-Type: application/json" \
-d '{"group_id": "…", "device_id": "…"}'
# Or set every group of a VM at once
curl -X POST https://danbyte.example/api/application-group-assignments/set/ \
-H "Authorization: Token $TOKEN" -H "Content-Type: application/json" \
-d '{"virtual_machine_id": "…", "group_ids": ["…", "…"]}'
Every reference must be the active tenant's: another tenant's application,
group, device or VM answers 400.