trixd is the TrinityX daemon that runs on the controller and does whatever its plugins declare. The daemon itself is the platform: authentication and roles, request validation, a published API description, change handling, queued work and replication between the two controllers of an HA pair. Everything it does for the cluster is a plugin, and a site can add its own without changing the daemon or waiting for a release.
plugin: hello
backend: backend
endpoints:
- path: greet/<who>
methods: [GET]
minimum: reader
handler: greetclass Backend:
"""A plugin that greets."""
def greet(self, who: str) -> dict:
"""Greet whoever was named in the path."""
return {"message": f"hello {who}"}From that declaration alone trixd serves the route under /api/v1/hello/, checks the
caller's token and role before the handler runs, validates the request, and publishes
the route with who may call it in the API description at /api/v1/docs. A plugin cannot
expose a route its manifest does not name, and no user route exists without naming the
lowest role it admits.
| Capability | How |
|---|---|
| Routes, each with its own access | minimum, the lowest role admitted; token: node for a node's own token; public for none |
| Validated input | a JSON Schema per route; a body that fails it never reaches the handler |
| Renders | an output computed from declared inputs, redone when one changes, coalesced so a burst of changes costs one run, and served from a route |
| Acting on a change | hooks: on events named <source>.<object>.<event>; the core dispatches them, so a new event needs no list anywhere |
| Being told of a change | POST /api/v1/system/notify to say something happened, POST /api/v1/system/bulk to hand over a whole set in one request |
| Queued work | work that is long or must run in order goes on the daemon's task queue, which picks up after a restart |
| Replication | replicate: true on a route sends that call to the other controller |
| Stored settings | declarations, kept in the daemon's database and kept the same on both controllers |
- Reload without a restart.
POST /api/v1/system/plugins/<name>/reload, orsystemctl reload trixdfor all of them, loads plugins from disk while the daemon runs. - A site's plugins survive an upgrade. They live in
[PLUGINS] SITE_DIRECTORY, which an upgrade leaves alone. - A broken plugin is contained. One that cannot load is refused, with the reason in the log, and the daemon and the other plugins carry on.
- The core knows no plugin. Nothing in the daemon's core imports a plugin, and a test enforces it, so a site's plugin has the same interface as a shipped one.
- Start from one that works.
python -m trixd.server plugin new <name> --config <path>writes a plugin that loads as it stands;plugin check <name>says why one will not. The guide is docs/writing-a-plugin.md.
| Plugin | What it does |
|---|---|
| luna | the route to Luna, TrinityX's node and boot daemon, and the changes made through it; see The luna plugin |
| directory | the cluster's users and groups |
| prometheus | the monitoring configuration and each node's hardware alert rules |
| services | starting, stopping and querying a catalogue of services |
| slurm | slurm's node and partition configuration, computed from the node list |
| genders | the genders file, computed from the node list |
A booting node never depends on trixd. Nothing this daemon serves sits on the boot path: outputs are redone when something changes, never when a node boots.
| Word | Meaning |
|---|---|
trixd.ini |
this daemon's configuration file; clients have their own copy |
| ini account | the account [API] USERNAME and PASSWORD in trixd.ini name |
| rootus | what the ini account is: it passes every check. It is never stored as a user |
| principal | a stored user: a name, a password (or none, if PAM or LDAP checks it) and a role |
| role | none, reader, operator or manager, lowest first; a user with no row holds none |
| minimum | the lowest role a route admits, written in the route's manifest entry |
| plugin | a directory with a manifest.yaml and a backend class; it adds routes under /api/v1/<plugin>/ |
| manifest | a plugin's declaration of its routes, their minimums, schemas and renders |
| render | an output computed from inputs, such as the Prometheus target list or a slurm file, redone when an input changes |
| declaration | a settings document a plugin stores, kept in the declaration table |
| hook | what a plugin does when an event it declared under hooks: happens, such as luna.node.update |
| node token | a token a booted node gets for itself, confined to that node |
| service token | a short-lived token one controller's trixd gives the other's, for replication |
| replication | how the two controllers of an HA pair keep principal and declaration the same |
A plugin route, for example PATCH /api/v1/prometheus/rules:
trixd/server.pyserves the app built bytrixd/app.pyon both listeners.- The route was built from the plugin's manifest by
trixd/core/plugins/binder.py. - Its gate,
trixd/core/security/gate.py, verifies the token (core/security/tokens.py), resolves the caller (core/security/principals.py, which asks the sources incore/security/sources/throughchain.py), compares their role with the route's minimum (core/security/access.py) and writes the decision to the audit trail (core/security/audit.py). - The body is validated against the manifest's schema, then the backend method in
trixd/plugins/prometheus/backend.pyruns. - A return value becomes a JSON 200. A
TrixdErrorfromtrixd/common/errors.pybecomes its own status (400, 401, 403, 404, 409, 502 or 503), a body that fails its schema is a 422, and anything else is a 500, with the detail in the log.
Startup (trixd/core/lifespan.py): read and check trixd.ini, open the database
and bring its schema to the newest Alembic revision, load the signing key, load the
plugins, start the task worker, read Luna's table hashes as a baseline, run every
render once, start the background timers, and only then open the listeners.
| Path | What lives there |
|---|---|
trixd/app.py |
Builds the application. Reads no configuration. |
trixd/server.py |
The entry point: read the ini, serve TLS and plain together. |
trixd/common/ |
Settings, constants, typed errors, logging. |
trixd/core/security/ |
Keys, tokens, the sign-in sources and chain, the role gate, the audit trail. |
trixd/core/plugins/ |
Manifest, loader, registry, router binder, route swap, scaffold. |
trixd/core/render/ |
The render engine, and the register of background triggers a plugin fills. |
trixd/core/replication/ |
Keeping two controllers' tables the same. |
trixd/core/tasks.py |
The queue: one worker, one task at a time, requeued after a restart. |
trixd/plugins/luna/ |
Everything that knows what Luna is: the client, the reader for Luna's own luna.ini, the credentials it is reached with, the table-hash trigger, and the hooks a change through the luna plugin runs. |
trixd/db/ |
Engine, models and the Alembic migrations. |
trixd/api/v1/ |
The daemon's own routes: auth, identity, system, and docs.py, the docs page and the document it shows. |
trixd/static/ |
What the docs page loads: the TrinityX look, logo and icon, and Swagger UI 5.32.15, so it works without internet. |
trixd/plugins/ |
The plugins that ship: luna (the route to Luna), directory, prometheus, services, slurm, genders. |
trixd/utils/ |
Helpers with no daemon state: the shell runner, file writes, declarations. |
tests/ |
unit/ for pytest, e2e/ against a running daemon, perf/ for timing at scale. |
docs/writing-a-plugin.md |
How to write a plugin. |
docs/openapi.json |
The whole API with every shipped plugin, and who may call each route (x-trixd-access, x-trixd-minimum). |
docs/manifest.schema.json |
The plugin manifest format, as a JSON Schema. |
tools/build_schemas.py |
Writes both from the code; a test fails when they drift. |
setup.py |
The package itself; see Building and publishing. |
Python 3.10 or newer.
python3 -m venv .venv && . .venv/bin/activate
pip install -r requirements.txt pytest httpx
pip install -e .
mkdir -p dev
The Luna plugin reads Luna's address, and the secret for the token it presents to Luna,
from Luna's own luna.ini. On a workstation there is no Luna, so write a small one,
dev/luna.ini, and point at it:
[API]
ENDPOINT = localhost:7050
PROTOCOL = https
; Any 32 hexadecimal characters, for a workstation.
SECRET_KEY = 004f2af45d3a4e161a7dd2d17fdae47fexport TRIXD_LUNA_INI=dev/luna.ini
Then write dev/trixd.ini. Comments go on lines of their own: a comment after a value
becomes part of the value.
[API]
; No BIND, so only the plain listener on the loopback opens and no certificate is needed.
BIND =
INSECURE_BIND = 127.0.0.1:7071
USERNAME = trixd
PASSWORD = trixd
[DATABASE]
URL = sqlite:///dev/trixd.db
[LOGGER]
LOGFILE =
[AUTH]
CHAIN = local
[PLUGINS]
DIRECTORY = trixd/plugins
SITE_DIRECTORY = dev/plugins
ENABLED = services, gendersThen:
python -m trixd.server --config dev/trixd.ini
curl -s http://127.0.0.1:7071/api/v1/system/health
TOKEN=$(curl -s -X POST http://127.0.0.1:7071/api/v1/auth/token \
-H 'Content-Type: application/json' -d '{"username":"trixd","password":"trixd"}' \
| python -c 'import sys, json; print(json.load(sys.stdin)["token"])')
curl -s http://127.0.0.1:7071/api/v1/system/plugins -H "x-access-tokens: $TOKEN"
A token goes in the x-access-tokens header, or as Authorization: Bearer <token>.
http://127.0.0.1:7071/api/v1/docs lists every route, with what it does, what to send,
what comes back and who may call it; Authorize there takes a token for Try it out.
The page is FastAPI's own, on Swagger UI files shipped in the package, so it loads nothing
from the internet; trixd/static/trixd.css gives it the TrinityX look. Without Luna, obol or
Prometheus the plugins still load: a route whose work needs one answers 503, and a
render that could not run answers 404 with the reason.
/trinity/local/python/bin/python3 -m trixd.server --config /trinity/local/trixd/daemon/config/trixd.ini
The unit trixd runs that. systemctl reload trixd reloads the plugins
from disk without a restart; a change to trixd.ini needs a restart.
| Port | Setting | When Luna's luna.ini says https |
When it says http |
|---|---|---|---|
| 7070 | BIND |
HTTPS on CERTFILE and KEYFILE, the cluster pair; a missing one stops the start, by name |
plain HTTP, no certificate |
| 7071 | INSECURE_BIND |
plain HTTP, on every address | plain HTTP, on every address |
The protocol is the one all.yml chose for Luna (luna_protocol), read from Luna's own
luna.ini, as Luna's 7050 follows it. Clients always use 7070; only the scheme changes,
and they take it from their own ini. There is no redirect between the two: a client on
the wrong scheme is a misconfiguration to fix, not to hide. The replication link to the
other controller follows the same protocol.
Both ports answer on every address, because nodes call trixd too. 7071 is clear text:
a password or token sent to it is readable on the network it crosses, so anything that
can use https on 7070 should. A site that wants 7071 on the controller alone sets
INSECURE_BIND = 127.0.0.1:7071.
The daemon reads /trinity/local/trixd/daemon/config/trixd.ini, or the path given with
--config or in TRIXD_CONFIG. The layout follows Luna's: /trinity/local/trixd holds
only daemon, a link into the shared Python, as /trinity/local/luna does, and the
configuration and the database (daemon/var/trixd.db) live inside it. Unlike luna.ini,
trixd.ini is never in the wheel: the wheel ships trixd.ini.sample, which explains each
key, so pip writes only the sample and an upgrade leaves the site's trixd.ini and its
database as they were. A plugins folder appears beside daemon only when a site writes
a plugin of its own. Unlike Luna's tree there is no utils: no tool reads a trixd.ini
from there. A missing file, an unknown algorithm or an unreadable duration stops the daemon with
the key named. Durations take s, m, h or d; a bare number is seconds,
except EXPIRY, where it is hours as in luna.ini.
Everything else a trixd.ini gets wrong is loud and not fatal: the daemon names it and
comes up. A file that exists but cannot be read, a mode the daemon has no rights to
among them, is named with the reason, and the daemon then starts on its built-in
defaults rather than on what that file says. A section or a key trixd does not read, a
misspelled [DATABASE] URL among them, is named one by one, because the alternative is
a fresh default database and nothing said; the keys trixd reads are the ones it actually
asks the file for, so a setting added to the code is covered without a second list to
remember. [API] MAX_BODY takes K, M and G as powers of 1024, with or without a
B or iB after them, so 8M, 8MB and 8MiB are one ceiling, and
[REPLICATION] ENABLED takes yes or no, on or off, true or false, 1 or 0. Either one
unreadable is named along with the value used instead: the default for MAX_BODY, and
on for ENABLED, since reading it as off would quietly stop an HA pair reconciling. An
empty [API] USERNAME or PASSWORD is named too, because that account is the one
principal that holds rootus: without it the directory, slurm and replication routes
answer 403 to every caller.
Plugins load from two places: [PLUGINS] DIRECTORY, the shipped ones inside the
package, and SITE_DIRECTORY (/trinity/local/trixd/plugins), a site's own, which an
upgrade leaves alone and which cannot take a shipped plugin's name. A restart loads only
what ENABLED lists, by default all six. An ENABLED that names nothing at all is the
exception: it loads every plugin found rather than none, which is what an installed site
already runs on, so the count it enabled is logged at startup.
Clients get a trixd.ini of their own beside the luna.ini the installer writes for
the alertx CLI, the On Demand apps and the node image. The Luna CLI and the luna2
utilities get none: they talk to Luna only. Each names where the daemon answers and the
ini account. Where each goes, and who can read it, is the installer's business: the
trinity/trixd role in trinityx-combined.
The ladder is none < reader < operator < manager, the same names luna2-daemon uses,
plus rootus, which is the ini account and never a role a user can be given.
| Role | May |
|---|---|
| none | sign in and ask who it is (GET /api/v1/auth/whoami), nothing else |
| reader | read everything apart from the routes kept for rootus: the read-only user, for an auditor or anyone who only needs to see |
| operator | that, and act: start, stop, restart, reload or query a catalogued service, and tell trixd of a change (system/notify, system/bulk) |
| manager | that, and change configuration: rules, settings, a node's hardware rules, the service catalogue |
| rootus | everything, and alone: users and roles, the cluster directory, plugin control, replication, and plugin settings that name a command or a path run as root |
rootus is the administrator. There is no separate admin role: whoever administers trixd does it as the ini account.
Every user route names its minimum, and the gate compares it with the caller's role
before the handler runs. A refusal is a 403 that says both, as in
this needs manager; you hold operator, and goes to the audit trail. The other
controller is not an exception: it signs in with the account both controllers are
configured with and is judged on that account, as any caller holding it would be.
The whole decision is these lines. The position on the ladder is the rank:
# trixd/common/constants.py
ROLES: tuple = (ROLE_NONE, ROLE_READER, ROLE_OPERATOR, ROLE_MANAGER)
MINIMUMS: tuple = ROLES + (ROLE_ROOTUS,)
# trixd/core/security/access.py
def rank(role: str) -> int:
return MINIMUMS.index(role) if role in MINIMUMS else 0
def permits(who, minimum: str) -> tuple:
held = getattr(who, "role", ROLE_NONE) or ROLE_NONE
if who is not None and is_rootus(who.name): # the trixd.ini account
return True, held
return rank(held) >= rank(minimum), heldThe gate, trixd/core/security/gate.py, calls permits once per request, after the
token is verified and the caller is resolved. An unknown role ranks as none.
Users are managed by rootus with GET /api/v1/identity/users,
PUT /api/v1/identity/users/<name> (create, or change the role, password or whether
the user is enabled) and DELETE. A change applies to tokens already handed out:
the role is looked up on each request, through a cache of [AUTH] CACHE seconds
(60 by default) that a change clears at once, on this controller and, when the
change arrives there, on the other.
Signing in: the ini account is checked against trixd.ini and nothing else.
Anyone else is tried against the sources in [AUTH] CHAIN in order, and the first
that knows the name decides: local (a stored password), pam (the controller's
own accounts, which through sssd include the cluster directory; system accounts are
refused), ldap (a directory bind) and oidc, which is a placeholder. Someone who
signs in through PAM or LDAP gets a row on first sign-in, with role none, and can
read nothing until rootus gives them a role.
peercred signs a person in with no password. Named in [AUTH] CHAIN, it opens
[AUTH] SOCKET (/run/trixd/peercred.sock), where a process on this controller asks
GET or POST /api/v1/auth/token and gets a token for the account it runs as, which
the kernel reports; nothing else of the API is served there. uid 0, a uid whose name
does not lead back to it, the ini account, a system account, a disabled user and an
account PAM's account check refuses (expired or locked) are refused, in the log and the
audit trail.
[AUTH] GROUP_ROLES = admins:manager gives a member of an operating-system group that
role when it is higher than the role they hold, for any user whose name is an
operating-system account. It is worked out on each lookup and never stored, so leaving
the group takes it away within [AUTH] CACHE.
POST /api/v1/auth/token with a JSON username and password answers 201 with
{"token": "..."}, valid for [API] EXPIRY. trixd signs and verifies those with its
own material, from [TOKENS]: a shared secret, SECRET_KEY or SECRET_FILE, or a
keypair.
The key ring is read once, when the daemon starts. Changing what trixd signs with
therefore takes a restart; until then it goes on accepting tokens signed with the old
material, whatever luna.ini now says.
[TOKENS] ALGORITHM = EdDSA switches to a keypair, so a daemon that can verify a
token cannot mint one. Generate the keypair with
python -m trixd.server keygen --config <path>.
The example and the capabilities are at the top of this page; the guide, docs/writing-a-plugin.md, has the rest.
python -m trixd.server plugin new hello --config <path> writes a working one into
SITE_DIRECTORY, and rootus plugs it in without a restart; add it to ENABLED so a
restart keeps it:
curl -X POST http://127.0.0.1:7071/api/v1/system/plugins/hello/reload \
-H "x-access-tokens: $TOKEN"
luna is a reserved plugin name: it is the pass-through to Luna.
A TrinityX controller also runs Luna (luna2-daemon, port 7050), which owns the physical estate: nodes, groups, images, networks, boot and hardware. trixd is a separate process with its own unit, ports, configuration and database, and reaches Luna only through Luna's HTTP API, by object name, through this plugin. Luna is not changed for it, and neither imports the other.
/api/v1/luna/<path> is the pass-through: it hands the request to Luna unchanged, up
to [API] MAX_BODY, and Luna decides who may. After Luna has answered, the plugin
publishes what changed as events, luna.node.update and luna.node.delete among them,
for any plugin that declared a hook on them. Any plugin can call Luna as the person
too, with persons.call and persons.may; see
Calling Luna as a person.
- The luna plugin,
trixd/plugins/luna/backend.py, forwards/api/v1/luna/config/node/node001to Luna as/config/node/node001, at the address Luna's ownluna.ininames, with the method, query, headers and body as sent, less the connection headers, and returns Luna's answer unchanged. Luna decides who may. The one limit is[API] MAX_BODY, which bounds every request this daemon reads and so bounds Luna's whole API through here as well: a body past it is answered 413 and never forwarded. It defaults to 8 MiB, which is well above anything the TrinityX tooling sends; raise it if a site has a Luna call that legitimately exceeds it. - After the answer has left,
trixd/plugins/luna/hooks.pylooks at what was asked. A successful rename, group move or delete is queued as a task (trixd/core/tasks.py). - The task worker runs the handler every plugin declared for that event under
hooks:; the prometheus plugin moves the node's rule file and rewrites it to the new name and group. - Then the renders that read Luna's nodes wake (
trixd/core/render/engine.py).
Nothing about how Luna signs is in trixd.ini. Its one Luna entry is
trixd's own account there, [DELEGATE:LUNA], which signs a person in at Luna on their
behalf; core reads every [DELEGATE:<component>] section alike and knows none by name. Where Luna answers, its protocol, whether
its certificate is checked, and the token secret both daemons share are read from
Luna's own luna.ini (/trinity/local/luna/daemon/config/luna.ini), and read again
when it changes. The one exception is [DELEGATE:LUNA] ENDPOINT: when it is set, a
person's calls and sign-ins go to that host:port instead, with luna.ini's protocol and
certificate check. On an HA pair it names the floating name, so a person's Luna token
always comes from the active Luna. trixd's own calls still go where luna.ini says.
An engineer changes Luna in one place and trixd follows. A trixd.ini
that still has a [LUNA] section or a [TOKENS] SECRET_KEY starts as before, with a
warning that names them as ignored.
slurm and genders write the same blocks luna2-daemon's node hook still writes, from the same generator and node list, so the two agree; once that hook stops, they are the only writers.
The secret in Luna's luna.ini is separate from trixd's own, read by the luna plugin for
the token it presents to Luna, so there are two - and a token one daemon minted verifies
at the other only where the installer has written the same value into both.
trixd's own calls to Luna, the ones its plugins make to read nodes and groups, carry a
token trixd signs itself with that secret, as Luna's administrator, id 0. No Luna
password is stored for trixd anywhere, and no sign-in call goes to Luna.
Luna knows a caller by the token's id alone, and reads a missing one as its
administrator, so trixd always sets it:
| Token | id |
At Luna |
|---|---|---|
| rootus, the ini account | 0 | Luna's administrator, the account luna.ini names |
| any other user | -1 | refused, 401: Luna never issues -1 |
| the other controller's service token | -1 | refused, 401 |
| a node token | none | confined to that node by its provision scope |
So a user who is not rootus reaches Luna only with a token Luna issued, and a role here decides nothing there. Luna's own roles do.
Luna cannot verify EdDSA yet.
/api/v1/luna/xyz reaches Luna as /xyz, and Luna enforces its own access. Once
Luna has answered, trixd acts on what changed: a node renamed or moved to
another group (POST config/node/<name> with newnodename or group) or deleted
(GET config/node/<name>/_delete) is handed to every plugin that declared it. The
prometheus plugin, for one, makes the node's hardware rule file carry the name and
group Luna now holds, whether or not Luna's own hook moved it.
A change made at Luna directly, not through this route, is picked up by comparing Luna's table hashes once an hour, which is the poller's own interval and not a setting. Luna answers that route only on the HA master, so on a single controller such a change reaches the rule files when trixd next starts, or when the next node change passes through it.
pip install pytest httpx
python -m pytest
| Kind | Where | What it covers |
|---|---|---|
| API and RBAC | tests/unit/test_daemon.py |
tokens both ways with Luna, roles on every route, the audit trail, the task queue, the pass-through |
| Plugins | tests/unit/test_plugins.py |
each shipped plugin's handlers and renders, the scaffold, site plugins |
| Replication | tests/unit/test_replication.py |
table hashes, the merge, deletions, two controllers converging |
| Integrations | tests/unit/test_integrations.py |
Luna, the peer, PAM, LDAP, obol, the slurm and genders generators, each stood in for at its edge; the role gate on its own |
| Foundations | tests/unit/test_foundations.py |
the shell runner, file writes and managed blocks, settings, keys, logging |
| Migrations | tests/unit/test_migrations.py |
every revision up, down and up again; the models against what the migrations build |
| Command line | tests/unit/test_entrypoint.py |
listeners, keygen, the plugin scaffold, a bad trixd.ini |
| Repository | tests/unit/test_repository.py |
plain ASCII and the licence header in every file, the version, a real wheel build |
Each test builds its own daemon in a temporary directory, so nothing outside the checkout is read or written, and the suite runs on Windows as well as Linux.
Timing at scale, with Luna stood in for (the files, database and plugin code are real):
python tests/perf/thousand_nodes.py 1000 8
End to end, a real daemon over HTTP, about 1,500 cases generated mostly from
docs/openapi.json (see tests/e2e/README):
TRIXD_E2E=local python -m pytest tests/e2e # a trixd started here, against a stand-in Luna
TRIXD_E2E_URL=http://<controller>:7071 python -m pytest tests/e2e
TRIXD_E2E=local python -m pytest tests/e2e -m stress -s # sustained reads and a boot storm
| Script | Where it runs | What it needs |
|---|---|---|
tests/e2e/on-the-controller.sh |
on the controller, as root | the daemon's trixd.ini, whose account it signs in as |
tests/e2e/node-rename.sh <node> |
on a development controller only | it renames a node at Luna and back |
The suites sign in with a test account, so they belong on a test controller, never on a customer's.
On each EL release, in containers, on the luna2-python trixd runs on there (podman or docker, and the internet):
bash tests/platforms/run-matrix.sh
| Release | Python | SQLite | glibc | Unit | End to end |
|---|---|---|---|---|---|
| Rocky 8.4 | 3.10.12 | 3.26.0 | 2.28 | pass | pass |
| Rocky 8.10 | 3.10.12 | 3.26.0 | 2.28 | pass | pass |
| Rocky 9.0 | 3.10.12 | 3.34.1 | 2.34 | pass | pass |
| Rocky 9.8 | 3.10.12 | 3.34.1 | 2.34 | pass | pass |
| Rocky 10.2 | 3.10.12 | 3.46.1 | 2.39 | pass | pass |
| AlmaLinux 10.2 | 3.10.12 | 3.46.1 | 2.39 | pass | pass |
SQLite is the operating system's, and it is 3.26.0 on every el8 release, so 8.4 stands for 8.0 as well. The pipeline runs the el8, el9 and el10 jobs on every push and publishes nothing unless they and the unit and end-to-end suites pass.
.gitlab-ci.yml includes the shared pip pipeline from ClusterVision/gitlab-cicd-pipelines.
It builds every branch with python setup.py sdist bdist_wheel, on Python 3.10 and an
old setuptools, which is why the package is declared in setup.py and not in
pyproject.toml. Two branches are also published to the repository server:
| Branch | Directory, from the CI/CD variable | Installed by |
|---|---|---|
development |
.../trinityx/16.1/trix/noarch/pip/testing/daemon (DEV_LOCATION) |
trix_stream: testing |
main |
.../trinityx/16.1/trix/noarch/pip/stable/daemon (LOCATION) |
trix_stream: stable |
A build's version is the release line and the commit's time, for example
trixd-1.0.1791360000-py3-none-any.whl. The pipeline points
trixd-1.0-py3-none-any.whl at the newest build and keeps the last five. The
installer installs that name with pip --upgrade, so a controller takes the newest
build on its next run, and GET /api/v1/system/version says which one it is running.
To build as the pipeline does: python setup.py sdist bdist_wheel, and dist/ holds
both files. The release line is DAEMON_RELEASE in trixd/common/constants.py.
Starting a new one means changing it and the installer's trixd_pip together.