Compare commits

..
14 changed files with 885 additions and 2827 deletions

View file

@ -45,6 +45,7 @@ ExecStart=/usr/local/bin/idunn serve \
--idunn-identity-store /var/lib/gamecult/idunn/idunn-service-identity.cc \
--odin-correlation-store /var/lib/gamecult/odin/topology.cc \
--odin-trust-anchor /etc/gamecult/idunn/odin-topology-anchor.cc \
--deployment-brake-operator-anchor /etc/gamecult/idunn/deployment-brake-operator-anchor.cc \
--host-actuator-bind 10.77.0.1:17890 \
--source-uid 986 \
--source-gid 978

View file

@ -16,6 +16,7 @@ target="${2:-}"
compose=/srv/compose/yggdrasil-apps.yaml
brake_store=/var/lib/gamecult/idunn-authority/deployment-brake.cc
brake_lock=/var/lib/gamecult/idunn-authority/deployment-brake.cc.lock
brake_anchor=/etc/gamecult/idunn/deployment-brake-operator-anchor.cc
generation_lock=/var/lib/gamecult/idunn-authority/idunn-generation.lock
idunn_provision=/usr/local/bin/idunn-provision
@ -153,7 +154,7 @@ deployment_target_policy() {
esac
}
require_deployment_admission() {
require_signed_deployment_grant() {
source_commit="$3"
deployment_request_id="$4"
release_authority_id="$5"
@ -179,17 +180,28 @@ require_deployment_admission() {
[ -z "$release_authority_sha256" ] || { echo "source-observed release cannot claim Bifrost authority digest" >&2; exit 1; }
require_root_owned_resolved_executable "$idunn_provision"
require_root_owned_regular_path "$brake_store"
require_root_owned_regular_path "$brake_lock"
require_root_owned_regular_path "$brake_anchor"
# This validation is the deployment-admission point. An absent or clear stop
# admits; an engaged or unreadable one makes the status verb exit nonzero.
# The root actuator remains the sole shared-lock holder through the
# synchronous consequence, so an engage or clear cannot race or rewrite it.
# The lock file is created here when no store has ever been written.
exec 9>>"$brake_lock"
# This validation is the deployment-admission point. The signed expiry is a
# start-before deadline: it denies a later transaction, but does not become a
# timer-shaped veto over one already admitted. The root actuator remains the
# sole shared-lock holder through the synchronous consequence, so an explicit
# engage/release transition cannot race or rewrite that transaction.
exec 9<"$brake_lock"
/usr/bin/flock --shared 9
now_unix_millis="$(/usr/bin/date +%s%3N)"
case "$now_unix_millis" in
''|*[!0-9]*) echo "root actuator clock did not produce Unix milliseconds" >&2; exit 1 ;;
esac
"$idunn_provision" deployment-brake-status \
--store "$brake_store" \
--runtime-id yggdrasil
--operator-anchor "$brake_anchor" \
--runtime-id yggdrasil \
--release-id "$source_commit" \
--deployment-id "$deployment_request_id" \
--now-unix-millis "$now_unix_millis"
if [ "$minimum_source_revision_required" = true ]; then
require_root_owned_resolved_executable /usr/local/bin/idunn
@ -310,7 +322,7 @@ case "$action:$target" in
manifest="/srv/odin/deploy-manifests/$target"
require_root_owned_regular_path "$manifest"
[ -x "$manifest" ] || { echo "root actuator manifest is not executable: $manifest" >&2; exit 1; }
require_deployment_admission "$@"
require_signed_deployment_grant "$@"
export IDUNN_ACTUATOR=1
export IDUNN_COMMAND_AUTHORITY=idunn-daemon
export IDUNN_SOURCE_COMMIT="$source_commit"

View file

@ -240,7 +240,7 @@ Fencing retries its phase forward on a capped backoff and never stops its live
candidate, since that is the only running copy of the admitted body; the
deadline opens the same incident. The one exception is yielding: a continuity
whose route proof has not succeeded gives way, through its own post-fencing
abort, to a deployment the deployment stop admits and that awaits the
abort, to a deployment the deployment brake has released and that awaits the
handover; a continuity that has proven its route never yields. The
`ContinuityExhausted` incident (six charged attempts in an hour,
`restarts_page`) pages and gates nothing. When continuity next acts is derived
@ -257,14 +257,9 @@ held until a lift succeeds. It is a migration with a deletion line (follow-up
still owe dependency failures not growing the streak and the dead-generation
route refresh.
The deployment brake is a stop, not a per-deploy gate: it gates changes to
source, release, configuration, schema, unit, or authority binding only while
engaged. Its one reader and writer is `src/brake.rs` (`idunn.deployment_stop.v1`:
engaged or clear, who, why, when, sequence). An absent or clear store admits;
a store that is present but unreadable, foreign, for another runtime, a symlink
or owned by another uid fails closed. Nothing is signed, bound to a release or
consumed, and one clear admits every deploy until it is engaged again. The
lifecycle brake separately gates restart of an already-admitted incarnation. Neither target brake may gate Idunn itself or an
The deployment brake gates changes to source, release, configuration, schema,
unit, or authority binding. The lifecycle brake separately gates restart of an
already-admitted incarnation. Neither target brake may gate Idunn itself or an
unrelated service.
If Odin is unavailable, Idunn preserves existing routes and continuity for

View file

@ -4,15 +4,6 @@ Status: target, Self, 2026-10-19 (campaign `idunn-deploy-provenance` in
Eureka's mind). It states the ends. The map will live in
`deploy-provenance-map.md`.
Live as of cut `brake-is-a-stop` (2026-11-13): the deployment brake is the
stop of invariant 3 and the signed per-deploy release is gone. `src/brake.rs`
reads and writes it; `idunn-provision deployment-brake-engage|clear|status`
take only `--store`, `--runtime-id` and `--reason`; the writer's login name and
the verb's clock are recorded; an absent or clear store admits. The
transaction stamps `deployment_admitted_at_unix_millis` (record v6). Still
planned: the typed authority provenance on the transaction (invariant 2), and a
steward-scoped store.
## Why
Operator, 2026-10-19:

View file

@ -48,8 +48,8 @@ and health. CultMesh carries typed projections between them.
scaling, restart, host reboot recovery, and crash recovery use the same
source-to-recipe-to-artifact provenance and the same distinct write-lease and
route-membership primitives.
Deployment may change that chain only while the deployment stop admits it
(absent or clear; an engaged stop halts). Continuity may restart only the already-admitted chain and
Deployment may change that chain only while the deployment brake admits the
exact transaction. Continuity may restart only the already-admitted chain and
is governed by a separate lifecycle brake.
- **Deletion line:** hard-coded target copies, raw `deploy_command` and
`restart_command` state, `sh -c` actuation, root Git inspection, staged
@ -209,8 +209,8 @@ non-regular carry source fails the deployment before anything moves.
What `current_link` names is observed from the symlink and confirmed by the
latest Admitted static transaction's `flip.release_id`; it is stored nowhere
else. A rollback is a flip back to `flip.previous_release_id`: release
directories stay, and Idunn prunes none. The deployment stop is read exactly as for a
service, by the binding's runtime id. Release ids are per transaction, so
directories stay, and Idunn prunes none. The brake is read exactly as for a
service, naming the binding's runtime id and the sealed release id. Release ids are per transaction, so
redeploying an unchanged tarball with a changed site file is a new release that
carries the new file, never an in-place re-carry of an existing one: the carry
is part of a release. If `current_link` is replaced by a directory or by a link
@ -230,8 +230,9 @@ transaction (`CommandKind::Rollback`) that reuses the previous release exactly:
the plan, sealed release and installed release are copied from the transaction
that flipped it, so there is no source, no build and no source cleanup, and it
creates no admitted generation. It starts at Sealing with that evidence and
reaches the same deployment stop as a deploy, which admits it unless engaged;
then `advance_static` flips, with the same three durable steps, the same
reaches the same deployment brake as a deploy, which the operator releases for
the rollback transaction's id and the previous sealed release id; then
`advance_static` flips, with the same three durable steps, the same
nothing-aborts-after-the-rename rule and the same stuck-flip behavior.
The previous release is derived, never stored: the newest Admitted static
@ -299,82 +300,6 @@ names both content addresses and the executable artifact digest. Present and
Ready remain Odin-owned correlations over independently verified runtime
evidence; the deployment-plan module deliberately does not model them.
## The deployment stop
`src/brake.rs` is the only reader and writer of the stop. A stop halts work
that has not crossed an irreversible step, and it is read again at each such
step: Sealing (`advance_sealing`), the static flip intent (`advance_static`) and
the entry into Fencing for a deploy (`advance_warming`). An engaged stop there
makes the transaction wait with a note naming who engaged it and why; nothing
aborts and nothing moves. After the flip intent is recorded, or once a deploy
has fenced, the transaction runs to its end: a stop halts before the
irreversible step, never mid-fence or mid-flip. Continuity is never gated.
The sequence of a stop record is positive and advances by one per verb; nothing
reads it for authority, so it is not validated further.
Absent means the store file is missing in an existing directory. Anything else
Idunn cannot judge (a symlink, a zero-length or undecodable file, another
runtime's record, another owner, an unsearchable or non-directory parent) reads
as unreadable and fails closed; the wait note carries the
`idunn-provision deployment-brake-clear` command that replaces it.
A binding may name a second stop, the target's steward:
```toml
[brakes.steward]
user = "mind-streampixels" # a login, never root
store = "/var/lib/gamecult/idunn-steward/streampixels/deployment-brake.cc"
```
Deploys admit only when every stop admits. The steward's store is read as owned
by that user's uid: the owner uid proves who wrote the file, and the wait note
names the stop by the binding's steward user, never by the record's `by` (which
is the verb's own text). Idunn never writes the steward directory and no key,
group or ACL is involved. The operator's store is a separate stop the steward
cannot clear, and the wait note names each holding stop.
The steward owns its directory, so it could unlink any file in it. Binding
validation therefore refuses a steward store whose directory is shared with,
inside or around the directory of any other Idunn authority store (deployment
and lifecycle brakes, trust anchor, write-lease record, release authority).
Validation cannot see the file system: the root who provisions the directory
makes it contain the steward's store and nothing else.
A steward store owned by another uid, or a steward user that does not resolve
to a non-root uid, is unreadable and fails closed. Only the steward (the
owner uid) can repair it: a clear run as root leaves a root-owned file that is
still unreadable.
### Provisioning a steward (root, once per target)
1. Create the store directory, owned by the steward and holding nothing else:
`install -d -o mind-streampixels -g mind-streampixels -m 0755
/var/lib/gamecult/idunn-steward/streampixels`. It must not be, contain or sit
inside any other authority directory, and no workload `ReadWritePaths` may
cover it. Idunn (root) reads it without further grants; no group or ACL.
2. Add the stanza above to the target's operator binding, after `[brakes]`,
with the steward's real login. Deploys planned afterwards see it.
3. The steward engages and clears as itself, never through root:
`idunn-provision deployment-brake-engage --store <store> --runtime-id <id>
--reason <text>` and `deployment-brake-clear` with the same flags.
4. The operator reads it with `idunn-provision deployment-brake-status --store
<store> --runtime-id <id> --owner-user mind-streampixels`.
The binding is sealed into each plan. A deploy already planned keeps the
binding it was sealed with: editing the stanza does not apply to it. If the
steward's login is deleted or its directory is lost, that deploy stays
unreadable-held at Sealing (or the static flip intent). `idunn cancel` withdraws
only a deploy held for a readiness disagreement before Fencing, and `idunn
expire` only one in Warming through Committing, so neither frees a deploy held
by the stop. Recovery is to restore the steward's login or recreate the
directory owned by it (and have the steward clear its store).
Record v6 (`deployment_admitted_at_unix_millis`, key 38) is forward-only: an
Idunn that predates v6 cannot read a migrated `control.cc`, so, as for v5 (see
`route-continuity-cut.md`, "An older Idunn refuses the v5 store"), take a
byte-compared pre-install backup of `control.cc` and `history.cc` with Idunn
stopped, and roll back by restoring the backup, never by swapping the binary.
## Initial drivers and replaceable boundary
The first Yggdrasil implementation uses:
@ -413,7 +338,7 @@ For a singleton incarnation:
declaration, binding, launch contract, and input digests.
5. Derive the release-bound Expected incarnation from the validated sealed
release and its exact compiled plan. Publish it only once the deployment
stop has admitted this transaction (stamping `deployment_admitted_at_unix_millis`), under the candidate's own
brake has admitted this exact transaction, under the candidate's own
incarnation key, beside whatever the target's admitted incarnation projects.
6. Issue one opaque runtime-instance activation bound to the Expected digest,
pass the exact Expected and activation documents through the actuator's
@ -436,8 +361,8 @@ For a singleton incarnation:
and stop the incumbent.
Sealing resolves the source, freezes it, runs every recipe step, and installs
the release before the deployment stop is consulted at all (`advance_sealing`).
The stop gates step 5, the first Verse-visible change: publishing the
the release before the deployment brake is consulted at all (`advance_sealing`).
The brake gates step 5, the first Verse-visible change: publishing the
candidate's Expected incarnation on the move into `Starting`. Build and test
already run unbraked, inside the sealing phase.
@ -468,7 +393,7 @@ identity, and route membership. Every restart receives a new runtime-instance
activation and, for a state writer, a new process-bound lease only after the new
warming presence is observed. A lease from the dead process is never reused. A
continuity restart does not fetch a branch, rebuild, rerun a migration, alter
the launch contract, or pass the deployment stop. An explicit lifecycle
the launch contract, or consume the deployment brake. An explicit lifecycle
brake may suspend this actuation without changing deployment authority.
Continuity never stops. Six charged attempts in an hour only open the
@ -501,7 +426,7 @@ the admitted body. Both operator cases open an `operator-required` incident
on.
The one yield: a continuity whose route proof has not succeeded gives way to a
deployment the deployment stop admits that awaits the handover of the
deployment the deployment brake has released that awaits the handover of the
target. It begins its own post-fencing abort and the deployment fences what is
admitted. A continuity that has proven its route is serving never yields.

View file

@ -390,8 +390,6 @@ read-only command on Yggdrasil on 2026-09-29. Nothing was written to the host.
(`:3670`, `:3715`), and topology refresh (`:3780`). After three refused
continuity restarts, supervision stops restarting (`:3522-3528`) but keeps
supervising the route of a dead incarnation. Read.
Resolved by `cut-liveness-gates-presence`: route challenge and topology
refresh now run only for an incarnation observed running.
- F9. The continuity restart limit counts refused restarts per generation
(`is_refused_restart`, `:3469-3488`). A restart that succeeds admits a new
generation and resets the count. A unit that starts, is admitted, and then
@ -1162,7 +1160,7 @@ target's generation or to its `TargetSupervision` ends that target's iteration:
- **Why no existing owner can serve:**
- The generation does not exist for a first deploy (the ruling).
- The transaction dies with each attempt.
- The deployment brake is a stop that a steward or the operator writes (`src/brake.rs`); Idunn writes no brake.
- Brakes are operator-signed and are not Idunn's to write.
- **What it replaces:** two carry compensators, `for_new_incarnation` and the backoff copy in
`from_transaction`, plus a history scan.

View file

@ -155,7 +155,7 @@ cleaned up.
`idunn redeploy --daemon …`. The installed binary has no `redeploy` command
(probe of its usage text), so the script is dead and is **not** the current
pattern. The current pattern is `idunn up` followed by
`idunn-provision deployment-brake-clear` when a stop is engaged (an absent or clear store admits)
`idunn-provision deployment-brake-release`
(`runbooks/idunn-host-raven.md`, "Deploy Muninn to Raven").
- F24. Build placement (`gamecult-ops/inventory.md:559-566`): build on or for the
target's host. Yggdrasil has 16 vCPU and 62 GiB and carries live services, so

View file

@ -1,701 +0,0 @@
//! The deployment stop: the one reader and the one writer of the record that
//! halts deployments of a runtime. Engaged halts; absent or clear admits. Who
//! engaged it and why are on the record, and nothing is signed, issued, bound
//! to a release or consumed: the brake is a stop, not a per-deploy gate (ruling
//! brake-is-a-stop). The lifecycle brake is a different record and a different
//! store; nothing here touches it.
//!
//! The reader fails closed. A store that is present but foreign, ambiguous,
//! noncanonical, for another runtime, a symlink, or owned by anyone but the
//! expected uid reads as `Unreadable`, which does not admit.
use std::path::Path;
use crate::deployment::BrakeBinding;
use anyhow::{Context, Result, anyhow, bail, ensure};
use cultcache_rs::{CultCacheEnvelope, DatabaseEntry, SingleFileMessagePackBackingStore};
use serde::{Deserialize, Serialize};
pub(crate) const DEPLOYMENT_STOP_SCHEMA: &str = "idunn.deployment_stop.v1";
pub(crate) const DEPLOYMENT_STOP_KEY: &str = "deployment-stop";
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub(crate) enum StopState {
Engaged,
Clear,
}
impl StopState {
pub(crate) fn name(self) -> &'static str {
match self {
Self::Engaged => "engaged",
Self::Clear => "clear",
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, DatabaseEntry)]
#[cultcache(type = "idunn.deployment_stop", schema = "idunn.deployment_stop.v1")]
pub(crate) struct DeploymentStop {
#[cultcache(key = 0)]
pub(crate) schema_version: String,
#[cultcache(key = 1)]
pub(crate) runtime_id: String,
#[cultcache(key = 2)]
pub(crate) state: StopState,
/// The login name of the user who ran the verb, read from the process uid.
#[cultcache(key = 3)]
pub(crate) by: String,
#[cultcache(key = 4)]
pub(crate) reason: String,
/// The verb's clock.
#[cultcache(key = 5)]
pub(crate) at_unix_millis: u64,
/// The previous record's sequence plus one; 1 for the first.
#[cultcache(key = 6)]
pub(crate) sequence: u64,
}
fn bounded(value: &str, label: &str, max: usize) -> Result<()> {
ensure!(
!value.trim().is_empty() && value.len() <= max && !value.chars().any(char::is_control),
"deployment stop {label} is empty, oversized, or contains control characters"
);
Ok(())
}
impl DeploymentStop {
pub(crate) fn validate(&self) -> Result<()> {
ensure!(
self.schema_version == DEPLOYMENT_STOP_SCHEMA,
"deployment stop schema is unsupported"
);
bounded(&self.runtime_id, "runtime id", 256)?;
bounded(&self.by, "author", 256)?;
bounded(&self.reason, "reason", 1024)?;
ensure!(
self.at_unix_millis > 0 && self.sequence > 0,
"deployment stop time or sequence is zero"
);
Ok(())
}
fn envelope(&self) -> Result<CultCacheEnvelope> {
self.validate()?;
let stored_at = chrono::DateTime::from_timestamp_millis(i64::try_from(self.at_unix_millis)?)
.ok_or_else(|| anyhow!("deployment stop time is out of range"))?
.to_rfc3339();
Ok(CultCacheEnvelope {
key: DEPLOYMENT_STOP_KEY.into(),
r#type: Self::TYPE.into(),
payload: rmp_serde::to_vec(self)?,
stored_at,
schema_id: Some(DEPLOYMENT_STOP_SCHEMA.into()),
})
}
fn decode(envelope: &CultCacheEnvelope) -> Result<Self> {
ensure!(
envelope.r#type == Self::TYPE
&& envelope.key == DEPLOYMENT_STOP_KEY
&& envelope.schema_id.as_deref() == Some(DEPLOYMENT_STOP_SCHEMA),
"deployment stop store holds a foreign record"
);
let record: Self = rmp_serde::from_slice(&envelope.payload)?;
ensure!(
rmp_serde::to_vec(&record)? == envelope.payload,
"deployment stop is noncanonical"
);
record.validate()?;
Ok(record)
}
}
/// What one store says about a runtime's deployments.
#[derive(Debug, PartialEq, Eq)]
pub(crate) enum Stop {
/// No store, or an empty one: nothing halts.
Absent,
Clear(DeploymentStop),
Engaged(DeploymentStop),
/// Present but not a record this runtime can trust. Does not admit.
Unreadable(String),
}
impl Stop {
pub(crate) fn admits(&self) -> bool {
matches!(self, Self::Absent | Self::Clear(_))
}
}
/// One stop a binding names, with how to name it in a wait note.
pub(crate) struct NamedStop {
pub(crate) label: String,
/// The login the file system proves wrote the store: the steward user, whose
/// uid owns the file. None for the operator's store, whose record carries
/// only the verb's own claim of `by`.
pub(crate) proven_writer: Option<String>,
pub(crate) stop: Stop,
}
impl NamedStop {
/// The wait-note line for a stop that does not admit; None when it admits.
/// A steward stop is named by the proven owner, never by the record's `by`.
pub(crate) fn note(&self) -> Option<String> {
let label = &self.label;
match &self.stop {
Stop::Absent | Stop::Clear(_) => None,
Stop::Engaged(held) => Some(match &self.proven_writer {
Some(_) => format!("{label} engaged: {}", held.reason),
None => format!("{label} engaged by {}: {}", held.by, held.reason),
}),
Stop::Unreadable(why) => Some(format!("{label} is unreadable and fails closed: {why}")),
}
}
}
/// Every stop a binding names, each with the words that identify its store in
/// a wait note: the operator's, then the steward's when the binding names one.
/// Deployments admit iff every one admits. The operator's store is read as
/// owned by this process's uid; the steward's as owned by the steward user's
/// uid, so the file system proves who wrote it. A steward that does not
/// resolve to a non-root uid is an unreadable stop, never an absent one.
pub(crate) fn read_stops(brakes: &BrakeBinding, runtime_id: &str) -> Vec<NamedStop> {
let mut stops = vec![NamedStop {
label: "deployment brake".to_string(),
proven_writer: None,
stop: read_stop(&brakes.deployment_store, runtime_id, process_uid()),
}];
if let Some(steward) = &brakes.steward {
let label = format!("steward {} deployment brake", steward.user);
let stop = match crate::steward_orders::user_uid(&steward.user) {
Ok(uid) => read_stop_with_remedy(&steward.store, runtime_id, uid, |path| {
// Only the owner uid can mend it: a clear run as root leaves a
// root-owned file, which this reader refuses again.
format!(
"only {} (the store's owner uid) can repair it, by running as that user: \
idunn-provision deployment-brake-clear --store {} --runtime-id {runtime_id} \
--reason <text>; a clear run as root stays unreadable",
steward.user,
path.display()
)
}),
Err(why) => Stop::Unreadable(format!(
"{why:#}; the binding's steward user {} must be a non-root login",
steward.user
)),
};
stops.push(NamedStop {
label,
proven_writer: Some(steward.user.clone()),
stop,
});
}
stops
}
#[cfg(unix)]
pub(crate) fn process_uid() -> u32 {
// SAFETY: geteuid has no failure mode and no arguments.
unsafe { libc::geteuid() }
}
#[cfg(not(unix))]
pub(crate) fn process_uid() -> u32 {
0
}
#[cfg(unix)]
pub(crate) fn login_name(uid: u32) -> Result<String> {
// SAFETY: getpwuid returns null or a pointer into libc's static buffer,
// copied before any other call; the verbs are single threaded.
unsafe {
let entry = libc::getpwuid(uid);
ensure!(!entry.is_null(), "uid {uid} has no login name");
Ok(std::ffi::CStr::from_ptr((*entry).pw_name)
.to_string_lossy()
.into_owned())
}
}
#[cfg(not(unix))]
pub(crate) fn login_name(_: u32) -> Result<String> {
std::env::var("USERNAME").context("USERNAME is unset")
}
/// Open without following a final symlink and judge the file by fstat before
/// anything is read from it.
#[cfg(unix)]
fn check_file(path: &Path, expected_owner_uid: u32) -> Result<()> {
use std::os::unix::fs::{MetadataExt, OpenOptionsExt};
let file = std::fs::OpenOptions::new()
.read(true)
.custom_flags(libc::O_NOFOLLOW)
.open(path)
.with_context(|| format!("opening deployment stop store {}", path.display()))?;
let metadata = file.metadata()?;
ensure!(
metadata.is_file(),
"deployment stop store is not a regular file"
);
ensure!(
metadata.uid() == expected_owner_uid,
"deployment stop store is owned by uid {}, not {expected_owner_uid}",
metadata.uid()
);
Ok(())
}
#[cfg(not(unix))]
fn check_file(path: &Path, _: u32) -> Result<()> {
ensure!(
std::fs::metadata(path)?.is_file(),
"deployment stop store is not a regular file"
);
Ok(())
}
/// Absent means exactly this: the final component does not exist and its
/// parent is an existing directory. Every other failure to look (permission,
/// a parent that is a file, a symlink loop) is a store this runtime cannot
/// judge, and fails closed.
fn is_absent(path: &Path) -> Result<bool> {
match std::fs::symlink_metadata(path) {
Ok(_) => Ok(false),
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
let parent = path.parent().filter(|p| !p.as_os_str().is_empty());
let parent = parent.unwrap_or_else(|| Path::new("."));
ensure!(
std::fs::metadata(parent).is_ok_and(|m| m.is_dir()),
"deployment stop store directory {} does not exist",
parent.display()
);
Ok(true)
}
Err(error) => Err(error)
.with_context(|| format!("looking for deployment stop store {}", path.display())),
}
}
fn read_checked(path: &Path, runtime_id: &str, owner: u32) -> Result<Option<DeploymentStop>> {
if is_absent(path)? {
return Ok(None);
}
check_file(path, owner)?;
ensure!(
std::fs::metadata(path)?.len() > 0,
"deployment stop store is zero length"
);
let entries = SingleFileMessagePackBackingStore::new(path).pull_all_read_only_snapshot()?;
match entries.as_slice() {
[] => bail!("deployment stop store holds no record"),
[entry] => {
let record = DeploymentStop::decode(entry)?;
ensure!(
record.runtime_id == runtime_id,
"deployment stop belongs to runtime {}",
record.runtime_id
);
Ok(Some(record))
}
_ => bail!("deployment stop store is ambiguous"),
}
}
pub(crate) fn read_stop(path: &Path, runtime_id: &str, expected_owner_uid: u32) -> Stop {
read_stop_with_remedy(path, runtime_id, expected_owner_uid, |path| {
format!(
"to replace it run: idunn-provision deployment-brake-clear \
--store {} --runtime-id {runtime_id} --reason <text> (or deployment-brake-engage)",
path.display()
)
})
}
fn read_stop_with_remedy(
path: &Path,
runtime_id: &str,
expected_owner_uid: u32,
remedy: impl FnOnce(&Path) -> String,
) -> Stop {
match read_checked(path, runtime_id, expected_owner_uid) {
Ok(None) => Stop::Absent,
Ok(Some(record)) if record.state == StopState::Clear => Stop::Clear(record),
Ok(Some(record)) => Stop::Engaged(record),
Err(error) => Stop::Unreadable(format!("{error:#}; {}", remedy(path))),
}
}
/// Write the next record under a compare-exchange of the whole store, so a
/// concurrent verb or a store that moved since it was read is refused. The
/// author is the login name of the process uid and the sequence is the
/// predecessor's plus one (1 when there is none or it cannot be decoded);
/// neither is an argument.
///
/// This is also the operator's break-glass. A predecessor that is a retired v1
/// brake, another runtime's record, ambiguous, or zero length is replaced. A
/// file that is not a CultCache store at all (junk bytes) is replaced only
/// when it is a regular file owned by the caller, by removing it first. A
/// symlink or another user's file is refused. The sequence is not validated
/// beyond being positive: nothing reads it for authority.
pub(crate) fn replace_stop(
path: &Path,
runtime_id: &str,
state: StopState,
reason: &str,
now_unix_millis: u64,
) -> Result<DeploymentStop> {
let store = SingleFileMessagePackBackingStore::new(path);
let before = match store.pull_all_read_only_snapshot() {
Ok(entries) => entries,
Err(undecodable) => {
check_file(path, process_uid()).with_context(|| {
format!("deployment stop store is undecodable ({undecodable:#}) and not the caller's to replace")
})?;
std::fs::remove_file(path)?;
Vec::new()
}
};
let sequence = match before.as_slice() {
[entry] => match DeploymentStop::decode(entry) {
Ok(previous) => previous.sequence.saturating_add(1),
Err(_) => 1,
},
_ => 1,
};
let record = DeploymentStop {
schema_version: DEPLOYMENT_STOP_SCHEMA.into(),
runtime_id: runtime_id.into(),
state,
by: login_name(process_uid())?,
reason: reason.into(),
at_unix_millis: now_unix_millis,
sequence,
};
let next = record.envelope()?;
ensure!(
store.compare_exchange_snapshot(&before, &[next])?,
"deployment stop changed during transition"
);
Ok(record)
}
#[cfg(test)]
mod tests {
use super::*;
fn engage(path: &Path, reason: &str, at: u64) -> Result<DeploymentStop> {
replace_stop(path, "runtime", StopState::Engaged, reason, at)
}
#[test]
fn absent_and_empty_stores_admit_a_clear_one_admits_an_engaged_one_does_not() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("stop.cc");
let me = process_uid();
assert_eq!(read_stop(&path, "runtime", me), Stop::Absent);
engage(&path, "freeze for the audit", 100)?;
let Stop::Engaged(held) = read_stop(&path, "runtime", me) else {
bail!("an engaged stop did not read as engaged")
};
assert_eq!(held.reason, "freeze for the audit");
assert_eq!(held.by, login_name(me)?);
assert!(!Stop::Engaged(held).admits());
replace_stop(&path, "runtime", StopState::Clear, "audit done", 200)?;
let cleared = read_stop(&path, "runtime", me);
assert!(matches!(&cleared, Stop::Clear(record) if record.sequence == 2));
assert!(cleared.admits());
// Clear is not consumed: the same record admits again.
assert!(read_stop(&path, "runtime", me).admits());
Ok(())
}
#[test]
fn corrupt_foreign_other_runtime_symlinked_or_foreign_owned_stores_stop() -> Result<()> {
let dir = tempfile::tempdir()?;
let me = process_uid();
let path = dir.path().join("stop.cc");
engage(&path, "held", 100)?;
// Another runtime's record.
assert!(!read_stop(&path, "other", me).admits());
// Owned by someone other than the expected uid: even a CLEAR record
// from a foreign owner must not admit.
let cleared = dir.path().join("cleared.cc");
replace_stop(&cleared, "runtime", StopState::Clear, "thaw", 100)?;
assert!(read_stop(&cleared, "runtime", me).admits());
assert!(matches!(read_stop(&cleared, "runtime", me + 1), Stop::Unreadable(_)));
// A symlink to a valid, clear store.
let real = dir.path().join("real.cc");
replace_stop(&real, "runtime", StopState::Clear, "clear", 100)?;
let link = dir.path().join("link.cc");
#[cfg(unix)]
std::os::unix::fs::symlink(&real, &link)?;
#[cfg(unix)]
assert!(matches!(read_stop(&link, "runtime", me), Stop::Unreadable(_)));
// Bytes that are no store at all.
let junk = dir.path().join("junk.cc");
std::fs::write(&junk, b"not msgpack at all")?;
assert!(matches!(read_stop(&junk, "runtime", me), Stop::Unreadable(_)));
// A record of another type under another key (the retired v1 brake).
let foreign = dir.path().join("foreign.cc");
let store = SingleFileMessagePackBackingStore::new(&foreign);
let envelope = CultCacheEnvelope {
key: "deployment".into(),
r#type: "idunn.deployment_brake".into(),
payload: vec![0x90],
stored_at: "1970-01-01T00:00:00+00:00".into(),
schema_id: Some("idunn.deployment_brake.v1".into()),
};
assert!(store.compare_exchange_snapshot(&[], &[envelope])?);
assert!(matches!(read_stop(&foreign, "runtime", me), Stop::Unreadable(_)));
// A noncanonical payload under the right identity.
let mut stop = DeploymentStop::decode(&store_entry(&path)?)?;
stop.sequence = 9;
let mut loose = stop.envelope()?;
loose.payload.push(0xc0);
let noncanonical = dir.path().join("noncanonical.cc");
assert!(SingleFileMessagePackBackingStore::new(&noncanonical)
.compare_exchange_snapshot(&[], &[loose])?);
assert!(matches!(read_stop(&noncanonical, "runtime", me), Stop::Unreadable(_)));
Ok(())
}
/// A binding whose steward is the user running the test, so the steward's
/// store can really be owned by the steward. None when run as root, which
/// no steward may be.
fn binding_with_steward(dir: &Path, user: &str) -> BrakeBinding {
BrakeBinding {
deployment_store: dir.join("operator.cc"),
lifecycle_store: dir.join("lifecycle.cc"),
steward: Some(crate::deployment::StewardBrakeBinding {
user: user.into(),
store: dir.join("steward.cc"),
}),
}
}
fn admits_all(stops: &[NamedStop]) -> bool {
stops.iter().all(|named| named.stop.admits())
}
#[test]
fn the_steward_store_is_a_second_stop_and_the_operator_store_is_one_it_cannot_clear() -> Result<()> {
let me = process_uid();
if me == 0 {
eprintln!("SKIPPED: a steward is never root, and this run is root");
return Ok(());
}
let dir = tempfile::tempdir()?;
let binding = binding_with_steward(dir.path(), &login_name(me)?);
let (operator, steward) = (&binding.deployment_store, &binding.steward.as_ref().unwrap().store);
// Both absent: admits.
assert!(admits_all(&read_stops(&binding, "runtime")));
// Steward engaged alone: halts, and the stop names the steward's store.
replace_stop(steward, "runtime", StopState::Engaged, "steward freeze", 10)?;
let stops = read_stops(&binding, "runtime");
assert!(!admits_all(&stops));
assert!(matches!(&stops[1].stop, Stop::Engaged(held) if held.reason == "steward freeze"));
// The note names the proven owner, and never the record's claimed `by`.
assert_eq!(
stops[1].note().unwrap(),
format!("steward {} deployment brake engaged: steward freeze", login_name(me)?)
);
// Both engaged, then the steward clears its own: the operator's holds.
replace_stop(operator, "runtime", StopState::Engaged, "operator hold", 11)?;
replace_stop(steward, "runtime", StopState::Clear, "steward thaw", 12)?;
let stops = read_stops(&binding, "runtime");
assert!(matches!(&stops[0].stop, Stop::Engaged(_)) && matches!(&stops[1].stop, Stop::Clear(_)));
assert!(!admits_all(&stops));
// The other order: operator clear, steward engaged still halts.
replace_stop(operator, "runtime", StopState::Clear, "operator thaw", 13)?;
replace_stop(steward, "runtime", StopState::Engaged, "steward again", 14)?;
assert!(!admits_all(&read_stops(&binding, "runtime")));
// Both clear: admits.
replace_stop(steward, "runtime", StopState::Clear, "steward thaw", 15)?;
assert!(admits_all(&read_stops(&binding, "runtime")));
Ok(())
}
#[test]
fn steward_store_owned_by_another_uid_stops() -> Result<()> {
let me = process_uid();
let dir = tempfile::tempdir()?;
// Steward is "nobody" (a real non-root user that is not the writer);
// the file is written by this process, so even a Clear record fails.
if me == 65534 || user_missing("nobody") {
eprintln!("SKIPPED: needs a user `nobody` other than the caller");
return Ok(());
}
let binding = binding_with_steward(dir.path(), "nobody");
let steward = &binding.steward.as_ref().unwrap().store;
replace_stop(steward, "runtime", StopState::Clear, "forged clear", 10)?;
let stops = read_stops(&binding, "runtime");
assert!(matches!(&stops[1].stop, Stop::Unreadable(why) if why.contains("is owned by uid")
&& why.contains("only nobody (the store's owner uid) can repair it")
&& why.contains("stays unreadable")
&& why.contains("idunn-provision deployment-brake-clear")));
// The operator's stop keeps the operator's remedy.
replace_stop(&binding.deployment_store, "other-runtime", StopState::Clear, "x", 11)?;
assert!(matches!(&read_stops(&binding, "runtime")[0].stop, Stop::Unreadable(why)
if why.contains("to replace it run:") && !why.contains("only ")));
assert!(!admits_all(&stops));
Ok(())
}
fn user_missing(name: &str) -> bool {
crate::steward_orders::user_uid(name).is_err()
}
#[test]
fn an_unresolvable_or_root_steward_user_is_an_unreadable_stop_not_an_absent_one() -> Result<()> {
let dir = tempfile::tempdir()?;
for user in ["no-such-login-zz", "root"] {
let binding = binding_with_steward(dir.path(), user);
let stops = read_stops(&binding, "runtime");
assert!(matches!(&stops[1].stop, Stop::Unreadable(_)), "{user}");
assert!(!admits_all(&stops));
}
Ok(())
}
#[test]
fn a_binding_without_a_steward_reads_only_the_operator_store() -> Result<()> {
let dir = tempfile::tempdir()?;
let mut binding = binding_with_steward(dir.path(), "nobody");
binding.steward = None;
let stops = read_stops(&binding, "runtime");
assert_eq!(stops.len(), 1);
assert!(admits_all(&stops));
Ok(())
}
fn store_entry(path: &Path) -> Result<CultCacheEnvelope> {
let mut entries = SingleFileMessagePackBackingStore::new(path).pull_all_read_only_snapshot()?;
entries.pop().context("no entry")
}
#[test]
fn a_verb_replaces_a_retired_brake_record_and_the_sequence_advances_by_one() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("stop.cc");
let store = SingleFileMessagePackBackingStore::new(&path);
let retired = CultCacheEnvelope {
key: "deployment".into(),
r#type: "idunn.deployment_brake".into(),
payload: vec![0x90],
stored_at: "1970-01-01T00:00:00+00:00".into(),
schema_id: Some("idunn.deployment_brake.v1".into()),
};
assert!(store.compare_exchange_snapshot(&[], &[retired])?);
assert_eq!(engage(&path, "first", 10)?.sequence, 1);
assert_eq!(store.pull_all_read_only_snapshot()?.len(), 1);
assert_eq!(engage(&path, "second", 11)?.sequence, 2);
assert_eq!(
replace_stop(&path, "runtime", StopState::Clear, "third", 12)?.sequence,
3
);
assert_eq!(DeploymentStop::decode(&store_entry(&path)?)?.reason, "third");
Ok(())
}
#[test]
fn a_stale_exchange_is_refused_and_a_record_without_a_reason_is_not_written() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("stop.cc");
engage(&path, "held", 10)?;
let store = SingleFileMessagePackBackingStore::new(&path);
let stale = store.pull_all_read_only_snapshot()?;
engage(&path, "moved", 11)?;
let next = DeploymentStop {
schema_version: DEPLOYMENT_STOP_SCHEMA.into(),
runtime_id: "runtime".into(),
state: StopState::Clear,
by: "someone".into(),
reason: "late".into(),
at_unix_millis: 12,
sequence: 2,
}
.envelope()?;
assert!(!store.compare_exchange_snapshot(&stale, &[next])?);
assert!(replace_stop(&path, "runtime", StopState::Clear, " ", 13).is_err());
assert_eq!(DeploymentStop::decode(&store_entry(&path)?)?.reason, "moved");
Ok(())
}
#[test]
fn only_a_missing_file_in_an_existing_directory_is_absent() -> Result<()> {
let dir = tempfile::tempdir()?;
let me = process_uid();
// Parent is a regular file: ENOTDIR, not absence.
let file = dir.path().join("plain");
std::fs::write(&file, b"x")?;
assert!(matches!(read_stop(&file.join("stop.cc"), "runtime", me), Stop::Unreadable(_)));
// Parent does not exist.
assert!(matches!(
read_stop(&dir.path().join("nope/stop.cc"), "runtime", me),
Stop::Unreadable(_)
));
// Zero-length file.
let empty = dir.path().join("empty.cc");
std::fs::write(&empty, b"")?;
assert!(matches!(read_stop(&empty, "runtime", me), Stop::Unreadable(_)));
// An existing directory with no store is absent.
assert_eq!(read_stop(&dir.path().join("stop.cc"), "runtime", me), Stop::Absent);
// A parent that cannot be searched (skipped as root, which can).
#[cfg(unix)]
if me != 0 {
use std::os::unix::fs::PermissionsExt;
let locked = dir.path().join("locked");
std::fs::create_dir(&locked)?;
std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o000))?;
let reading = read_stop(&locked.join("stop.cc"), "runtime", me);
std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o700))?;
assert!(matches!(reading, Stop::Unreadable(_)), "{reading:?}");
}
Ok(())
}
#[test]
fn the_author_is_the_uid_login_never_the_environment() -> Result<()> {
let dir = tempfile::tempdir()?;
let path = dir.path().join("stop.cc");
// SAFETY: no other test reads USER, LOGNAME or LNAME.
unsafe {
std::env::set_var("USER", "spoof");
std::env::set_var("LOGNAME", "spoof");
}
let written = engage(&path, "held", 10)?;
assert_eq!(written.by, login_name(process_uid())?);
assert_ne!(written.by, "spoof");
Ok(())
}
#[test]
fn unreadable_names_the_command_and_a_break_glass_clear_replaces_junk_and_v1() -> Result<()> {
let dir = tempfile::tempdir()?;
let me = process_uid();
let path = dir.path().join("stop.cc");
std::fs::write(&path, b"junk that is no store")?;
let Stop::Unreadable(why) = read_stop(&path, "runtime", me) else {
bail!("junk admitted")
};
assert!(why.contains("idunn-provision deployment-brake-clear --store"), "{why}");
assert!(why.contains("--runtime-id runtime"), "{why}");
let cleared = replace_stop(&path, "runtime", StopState::Clear, "operator break-glass", 50)?;
assert_eq!(cleared.sequence, 1);
assert!(read_stop(&path, "runtime", me).admits());
// A symlink is not the caller's to replace.
let real = dir.path().join("real.cc");
std::fs::write(&real, b"junk")?;
let link = dir.path().join("link.cc");
#[cfg(unix)]
{
std::os::unix::fs::symlink(&real, &link)?;
assert!(replace_stop(&link, "runtime", StopState::Clear, "x", 60).is_err());
assert_eq!(std::fs::read(&real)?, b"junk");
}
Ok(())
}
}

File diff suppressed because it is too large Load diff

View file

@ -753,20 +753,6 @@ impl ProcessWriteLeaseBinding {
pub struct BrakeBinding {
pub deployment_store: PathBuf,
pub lifecycle_store: PathBuf,
/// A second deployment stop, written by the target's steward in a
/// directory only the steward can write. Absent means the operator's store
/// is the only stop.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub steward: Option<StewardBrakeBinding>,
}
/// The steward's own stop: the file's owner uid proves who wrote it.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StewardBrakeBinding {
/// Login name; must resolve to a non-root uid when the store is read.
pub user: String,
pub store: PathBuf,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@ -1444,39 +1430,6 @@ impl OperatorBinding {
self.brakes.deployment_store != self.brakes.lifecycle_store,
"deployment and lifecycle brakes are identical"
);
if let Some(steward) = &self.brakes.steward {
require_absolute_path(&steward.store, "steward deployment brake")?;
ensure!(
crate::steward_orders::login_grammar_ok(&steward.user) && steward.user != "root",
"steward brake user is invalid or root"
);
ensure!(
steward.store != self.brakes.deployment_store
&& steward.store != self.brakes.lifecycle_store,
"steward brake store is identical to another brake store"
);
// The steward owns its store's directory, so it could unlink any
// file there. Every other authority store must therefore live
// outside that directory, and the steward's directory must be
// clear of every directory an operator store lives in.
let steward_dir = steward.store.parent().unwrap_or(&steward.store);
let others = [
Some(&self.brakes.deployment_store),
Some(&self.brakes.lifecycle_store),
Some(&self.runtime_identity.trust_anchor_store),
self.process_write_lease.as_ref().map(|lease| &lease.record_path),
self.repository.release_authority_store.as_ref(),
];
for other in others.into_iter().flatten() {
let other_dir = other.parent().unwrap_or(other);
ensure!(
!paths_overlap(steward_dir, other_dir),
"steward brake directory {} is shared with or nested in the directory of Idunn authority {}: the steward owns its directory and could remove that file",
steward_dir.display(),
other.display()
);
}
}
self.workload.validate_launch_environment()?;
let workload = match &self.workload {
WorkloadBinding::HostActuator(workload) => {
@ -1509,10 +1462,7 @@ impl OperatorBinding {
&self.brakes.deployment_store,
&self.brakes.lifecycle_store,
&self.runtime_identity.trust_anchor_store,
]
.into_iter()
.chain(self.brakes.steward.as_ref().map(|steward| &steward.store))
{
] {
ensure!(
!paths_overlap(authority, &workload.release_root)
&& !paths_overlap(authority, &workload.current_link),
@ -1581,7 +1531,6 @@ impl OperatorBinding {
self.brakes.deployment_store.clone(),
self.brakes.lifecycle_store.clone(),
];
authority_paths.extend(self.brakes.steward.as_ref().map(|steward| steward.store.clone()));
if let Some(write_lease) = &self.process_write_lease {
authority_paths.push(write_lease.record_path.clone());
authority_paths.push(write_lease.lock_path());
@ -3116,65 +3065,6 @@ nodes = ["yggdrasil"]
text
}
const STEWARD: &str = "\n[brakes.steward]\nuser = \"mind-streampixels\"\nstore = \"/var/lib/gamecult/idunn-steward/streampixels/deployment-brake.cc\"\n";
#[test]
fn binding_without_steward_parses_and_admits_on_operator_store_only() {
for text in [BINDING.to_string(), static_binding(&[])] {
assert_eq!(OperatorBinding::parse(&text).unwrap().brakes.steward, None);
}
let steward = OperatorBinding::parse(&BINDING.replace("\n[rollout]", &format!("{STEWARD}\n[rollout]")))
.unwrap()
.brakes
.steward
.unwrap();
assert_eq!(steward.user, "mind-streampixels");
}
#[test]
fn a_steward_brake_must_be_a_distinct_absolute_non_root_login_and_clear_of_the_workload() {
let with = |steward: &str| BINDING.replace("\n[rollout]", &format!("{steward}\n[rollout]"));
let store = "/var/lib/gamecult/idunn-steward/x/deployment-brake.cc";
for bad in [
format!("\n[brakes.steward]\nuser = \"root\"\nstore = \"{store}\"\n"),
format!("\n[brakes.steward]\nuser = \"Bad User\"\nstore = \"{store}\"\n"),
"\n[brakes.steward]\nuser = \"mind\"\nstore = \"relative.cc\"\n".into(),
"\n[brakes.steward]\nuser = \"mind\"\nstore = \"/var/lib/gamecult/idunn-authority/test-service-deployment-brake.cc\"\n".into(),
"\n[brakes.steward]\nuser = \"mind\"\nstore = \"/var/lib/gamecult/idunn-authority/test-service-lifecycle-brake.cc\"\n".into(),
format!("\n[brakes.steward]\nuser = \"mind\"\nstore = \"{store}\"\nextra = 1\n"),
] {
assert!(OperatorBinding::parse(&with(&bad)).is_err(), "{bad}");
}
// A steward directory shared with, or enclosing, an operator store
// lets the steward unlink a root-owned file: refused.
for (deployment, steward_store) in [
("/var/lib/gamecult/steward-x/op.cc", "/var/lib/gamecult/steward-x/s.cc"),
("/var/lib/gamecult/steward-x/sub/op.cc", "/var/lib/gamecult/steward-x/s.cc"),
("/var/lib/gamecult/op.cc", "/var/lib/gamecult/steward-x/s.cc"),
] {
let shared = BINDING
.replace("/var/lib/gamecult/idunn-authority/test-service-deployment-brake.cc", deployment)
.replace("\n[rollout]", &format!("\n[brakes.steward]\nuser = \"mind\"\nstore = \"{steward_store}\"\n\n[rollout]"));
assert!(OperatorBinding::parse(&shared).is_err(), "{deployment} {steward_store}");
}
// Disjoint directories are the one admitted shape.
let disjoint = BINDING.replace(
"\n[rollout]",
"\n[brakes.steward]\nuser = \"mind\"\nstore = \"/var/lib/gamecult/steward-x/s.cc\"\n\n[rollout]",
);
OperatorBinding::parse(&disjoint).unwrap();
// steward_store_overlap_with_workload_path_refused
let overlapping = BINDING
.replace("\n[rollout]", &format!("\n[brakes.steward]\nuser = \"mind\"\nstore = \"{store}\"\n\n[rollout]"))
.replace(
"cpu_quota_percent = 200\n\n[workload.argument_bindings]",
"cpu_quota_percent = 200\nread_write_paths = [\"/var/lib/gamecult/idunn-steward/x\"]\n\n[workload.argument_bindings]",
);
assert!(OperatorBinding::parse(&overlapping).is_err());
let static_overlap = static_binding(&[("[rollout]", "[brakes.steward]\nuser = \"mind\"\nstore = \"/srv/site/releases/x/brake.cc\"\n\n[rollout]")]);
assert!(OperatorBinding::parse(&static_overlap).is_err());
}
#[test]
fn static_recipe_and_binding_admit() {
let recipe = TargetDeclaration::parse(STATIC_RECIPE).unwrap();

View file

@ -762,7 +762,7 @@ impl StaticReleasePort for FilesystemStaticRelease {
binding: &StaticReleaseBinding,
release_id: &str,
) -> Result<StaticFlip> {
use std::os::unix::fs::{OpenOptionsExt, PermissionsExt, symlink};
use std::os::unix::fs::{OpenOptionsExt, symlink};
// Everything up to and including the rename can refuse, and only that
// refuses: the link has not moved when `FlipRefused` is returned.
@ -823,10 +823,6 @@ impl StaticReleasePort for FilesystemStaticRelease {
.create_new(true)
.mode(0o444)
.open(&temporary_carry)?;
// The creation mode is masked by the service's umask
// (UMask=0027 yields 0440), and the web server reads this file
// as "other"; say 0444 on the open handle.
file.set_permissions(fs::Permissions::from_mode(0o444))?;
file.write_all(&bytes)?;
file.sync_all()?;
fs::rename(&temporary_carry, &carried)?;
@ -17049,43 +17045,6 @@ processes 9
Ok(())
}
/// The service runs with UMask=0027, which masks the create mode to 0440
/// and hides the carry from the web user. The umask is process-global, so
/// the proof runs in a child copy of this test binary and no sibling test
/// ever sees it.
#[cfg(unix)]
#[test]
fn static_release_carry_is_0444_under_the_service_umask() -> Result<()> {
use std::os::unix::fs::PermissionsExt;
const CHILD: &str = "IDUNN_TEST_CARRY_UMASK_CHILD";
const NAME: &str = "static_release_carry_is_0444_under_the_service_umask";
if std::env::var_os(CHILD).is_none() {
let path = format!("{}::{NAME}", module_path!().split_once("::").map_or("", |(_, rest)| rest));
let output = std::process::Command::new(std::env::current_exe()?)
.args(["--exact", path.as_str(), "--nocapture", "--test-threads=1"])
.env(CHILD, "1")
.output()?;
assert!(
output.status.success(),
"child under umask 0027 failed:\n{}\n{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
assert!(
String::from_utf8_lossy(&output.stdout).contains("1 passed"),
"the child filter matched no test:\n{}",
String::from_utf8_lossy(&output.stdout)
);
return Ok(());
}
unsafe { libc::umask(0o027) };
let site = stand_in_site()?;
FilesystemStaticRelease.carry_and_flip(&site.binding, RELEASE_A)?;
let carried = site.binding.current_link.join("config.json");
assert_eq!(fs::metadata(&carried)?.permissions().mode() & 0o777, 0o444);
Ok(())
}
#[cfg(unix)]
#[test]
fn static_release_missing_site_config_fails_before_the_link_moves() -> Result<()> {

View file

@ -1,4 +1,3 @@
mod brake;
pub mod control_plane;
pub mod deployment;
pub mod deployment_plan;

View file

@ -1,5 +1,4 @@
use crate::brake::{Stop, StopState, process_uid, read_stop, replace_stop};
use anyhow::{Context, Result, anyhow, bail, ensure};
use anyhow::{Context, Result, anyhow, bail};
use cultcache_rs::{
CultCacheEnvelope, CultCacheExpectedEnvelope, DatabaseEntry, SingleFileMessagePackBackingStore,
};
@ -7,13 +6,15 @@ use cultnet_rs::{
GAMECULT_SERVICE_TRUST_ANCHOR_SCHEMA, GameCultProviderHealthIdentity,
GameCultServiceTrustAnchorRecord, IDUNN_AUTHENTICATED_PROVIDER_HEALTH_PROJECTION_SCHEMA,
IDUNN_AUTHENTICATED_PROVIDER_HEALTH_PROJECTION_SIGNING_PURPOSE,
IDUNN_DAEMON_HEALTH_TRUST_BINDING_SCHEMA,
IDUNN_LIFECYCLE_BRAKE_AUTHORITY,
IDUNN_DAEMON_HEALTH_TRUST_BINDING_SCHEMA, IDUNN_DEPLOYMENT_BRAKE_AUTHORITY,
IDUNN_DEPLOYMENT_BRAKE_ID, IDUNN_DEPLOYMENT_BRAKE_SCHEMA, IDUNN_DEPLOYMENT_BRAKE_SCOPE,
IDUNN_DEPLOYMENT_RELEASE_PURPOSE, IDUNN_LIFECYCLE_BRAKE_AUTHORITY,
IDUNN_LIFECYCLE_BRAKE_SCHEMA, IDUNN_LIFECYCLE_BRAKE_SCOPE, IdunnDaemonHealthTrustBindingRecord,
IdunnLifecycleBrakeObservation,
IdunnDeploymentBrakeObservation, IdunnDeploymentBrakeOperatorIdentity,
IdunnDeploymentBrakeRecord, IdunnDeploymentBrakeReleasePurpose, IdunnLifecycleBrakeObservation,
IdunnLifecycleBrakeRecord, IdunnServiceIdentity, OdinTopologyIdentity, ServiceIdentityProfile,
ServiceIdentityTrustAnchor, derive_service_identity_id, enroll_service_identity_at,
evaluate_idunn_continuity_restart,
evaluate_idunn_continuity_restart, evaluate_idunn_deployment_brake,
export_service_identity_trust_anchor, open_service_identity_at,
};
use std::collections::{BTreeMap, BTreeSet};
@ -79,8 +80,17 @@ pub fn run(args: impl IntoIterator<Item = String>) -> Result<()> {
"export-odin-topology-public-anchor" => {
export_identity_anchor::<OdinTopologyIdentity>(&options, "Odin topology public anchor")?
}
"deployment-brake-engage" => deployment_brake_write(&options, StopState::Engaged)?,
"deployment-brake-clear" => deployment_brake_write(&options, StopState::Clear)?,
"enroll-deployment-brake-operator" => {
enroll_identity::<IdunnDeploymentBrakeOperatorIdentity>(&options)?
}
"export-deployment-brake-operator-anchor" => {
export_identity_anchor::<IdunnDeploymentBrakeOperatorIdentity>(
&options,
"deployment brake operator anchor",
)?
}
"deployment-brake-engage" => deployment_brake_engage(&options)?,
"deployment-brake-release" => deployment_brake_release(&options)?,
"deployment-brake-status" => deployment_brake_status(&options)?,
"lifecycle-brake-engage" => lifecycle_brake_engage(&options)?,
"lifecycle-brake-release" => lifecycle_brake_release(&options)?,
@ -147,57 +157,150 @@ fn provider_health_public_key(options: &BTreeMap<String, String>) -> Result<Stri
encode_public_key(&signer.entry().public_key)
}
/// Engage or clear the deployment stop. The author is the process uid's login
/// name and the time is this verb's clock: neither is an argument.
fn deployment_brake_write(options: &BTreeMap<String, String>, state: StopState) -> Result<()> {
require_only(options, &["store", "runtime-id", "reason"])?;
let now = u64::try_from(
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)?
.as_millis(),
fn deployment_brake_engage(options: &BTreeMap<String, String>) -> Result<()> {
require_only(
options,
&[
"store",
"runtime-id",
"owner",
"reason",
"observed-at-unix-millis",
],
)?;
let record = replace_stop(
&path(options, "store")?,
required(options, "runtime-id")?,
state,
required(options, "reason")?,
now,
)?;
println!(
"{} runtime={} by={} sequence={}",
record.state.name(),
record.runtime_id,
record.by,
record.sequence
);
Ok(())
let observed = parse_u64(options, "observed-at-unix-millis")?;
let record = IdunnDeploymentBrakeRecord {
schema_version: IDUNN_DEPLOYMENT_BRAKE_SCHEMA.into(),
brake_id: IDUNN_DEPLOYMENT_BRAKE_ID.into(),
authority: IDUNN_DEPLOYMENT_BRAKE_AUTHORITY.into(),
runtime_id: required(options, "runtime-id")?.into(),
status: "engaged".into(),
scope: IDUNN_DEPLOYMENT_BRAKE_SCOPE.into(),
reason: required(options, "reason")?.into(),
observed_at_unix_millis: observed,
expires_at_unix_millis: None,
authorization_id: None,
authorization_purpose: None,
authorized_release_id: None,
authorized_deployment_id: None,
authorized_by: None,
authorization_issued_at_unix_millis: None,
authorization_expires_at_unix_millis: None,
signature_algorithm: None,
signature: None,
private_state_exposed: false,
updated_by: required(options, "owner")?.into(),
};
record.validate()?;
replace_brake(&path(options, "store")?, record, observed)
}
/// Print the stop and exit nonzero unless deployments admit, so a script can
/// gate on it as it could on the retired exact-actuation validation.
fn deployment_brake_status(options: &BTreeMap<String, String>) -> Result<()> {
allow_only(options, &["store", "runtime-id", "owner-user"])?;
// A steward's store is owned by the steward: the operator names that user
// to read it, and the owner check is the same one Idunn makes.
let owner = match options.get("owner-user") {
Some(user) => crate::steward_orders::user_uid(user)?,
None => process_uid(),
fn deployment_brake_release(options: &BTreeMap<String, String>) -> Result<()> {
require_only(
options,
&[
"store",
"private-store",
"runtime-id",
"owner",
"reason",
"authorization-id",
"release-id",
"deployment-id",
"issued-at-unix-millis",
"expires-at-unix-millis",
],
)?;
let issued = parse_u64(options, "issued-at-unix-millis")?;
let expires = parse_u64(options, "expires-at-unix-millis")?;
let signer = open_service_identity_at::<IdunnDeploymentBrakeOperatorIdentity>(&path(
options,
"private-store",
)?)?;
let mut record = IdunnDeploymentBrakeRecord {
schema_version: IDUNN_DEPLOYMENT_BRAKE_SCHEMA.into(),
brake_id: IDUNN_DEPLOYMENT_BRAKE_ID.into(),
authority: IDUNN_DEPLOYMENT_BRAKE_AUTHORITY.into(),
runtime_id: required(options, "runtime-id")?.into(),
status: "released".into(),
scope: IDUNN_DEPLOYMENT_BRAKE_SCOPE.into(),
reason: required(options, "reason")?.into(),
observed_at_unix_millis: issued,
expires_at_unix_millis: Some(expires),
authorization_id: Some(required(options, "authorization-id")?.into()),
authorization_purpose: Some(IDUNN_DEPLOYMENT_RELEASE_PURPOSE.into()),
authorized_release_id: Some(required(options, "release-id")?.into()),
authorized_deployment_id: Some(required(options, "deployment-id")?.into()),
authorized_by: Some(signer.trust_anchor()?.identity_id),
authorization_issued_at_unix_millis: Some(issued),
authorization_expires_at_unix_millis: Some(expires),
signature_algorithm: Some("ed25519".into()),
signature: None,
private_state_exposed: false,
updated_by: required(options, "owner")?.into(),
};
let stop = read_stop(&path(options, "store")?, required(options, "runtime-id")?, owner);
match &stop {
Stop::Absent => println!("absent: deployments admit"),
Stop::Unreadable(why) => println!("unreadable: deployments wait ({why})"),
Stop::Clear(record) | Stop::Engaged(record) => println!(
"{} runtime={} by={} at={} sequence={} reason={}",
record.state.name(),
record.runtime_id,
record.by,
record.at_unix_millis,
record.sequence,
record.reason
),
record.signature = Some(
signer
.sign::<IdunnDeploymentBrakeReleasePurpose>(&rmp_serde::to_vec(&record)?)
.signature,
);
record.validate()?;
replace_brake(&path(options, "store")?, record, issued)
}
fn deployment_brake_status(options: &BTreeMap<String, String>) -> Result<()> {
allow_only(
options,
&[
"store",
"operator-anchor",
"runtime-id",
"release-id",
"deployment-id",
"now-unix-millis",
],
)?;
let exact_actuation_fields = ["release-id", "deployment-id", "now-unix-millis"];
let exact_actuation_field_count = exact_actuation_fields
.into_iter()
.filter(|field| options.contains_key(*field))
.count();
if exact_actuation_field_count != 0
&& exact_actuation_field_count != exact_actuation_fields.len()
{
bail!("exact deployment-brake actuation validation requires release, deployment, and time");
}
ensure!(stop.admits(), "the deployment brake does not admit deployments");
let record = read_brake(&path(options, "store")?)?;
if record.runtime_id != required(options, "runtime-id")? {
bail!("deployment brake belongs to another runtime")
}
if record.status == "engaged" {
if exact_actuation_field_count != 0 {
bail!("engaged deployment brake denies exact actuation validation");
}
println!(
"engaged runtime={} scope={} owner={} reason={}",
record.runtime_id, record.scope, record.updated_by, record.reason
);
return Ok(());
}
let anchor = read_operator_anchor(&path(options, "operator-anchor")?)?;
evaluate_idunn_deployment_brake(
IdunnDeploymentBrakeObservation::Present(&record),
&anchor,
required(options, "runtime-id")?,
required(options, "release-id")?,
required(options, "deployment-id")?,
parse_u64(options, "now-unix-millis")?,
)
.map_err(|d| anyhow!("deployment brake denied actuation: {d:?}"))?;
println!(
"released runtime={} release={} deployment={} owner={}",
record.runtime_id,
record.authorized_release_id.unwrap(),
record.authorized_deployment_id.unwrap(),
record.updated_by
);
Ok(())
}
@ -304,7 +407,7 @@ fn lifecycle_brake_status(options: &BTreeMap<String, String>) -> Result<()> {
Ok(())
}
pub(crate) fn replace_lifecycle_brake(path: &Path, record: IdunnLifecycleBrakeRecord) -> Result<()> {
fn replace_lifecycle_brake(path: &Path, record: IdunnLifecycleBrakeRecord) -> Result<()> {
record.validate()?;
let store = SingleFileMessagePackBackingStore::new(path);
let entries = store.pull_all_read_only_snapshot()?;
@ -379,6 +482,70 @@ fn lifecycle_identifier<'a>(options: &'a BTreeMap<String, String>, name: &str) -
Ok(value)
}
fn replace_brake(path: &Path, record: IdunnDeploymentBrakeRecord, millis: u64) -> Result<()> {
let store = SingleFileMessagePackBackingStore::new(path);
let entries = store.pull_all_read_only_snapshot()?;
let current = match entries.as_slice() {
[] => None,
[entry]
if entry.r#type == IdunnDeploymentBrakeRecord::TYPE
&& entry.key == IDUNN_DEPLOYMENT_BRAKE_ID =>
{
Some(entry.clone())
}
_ => bail!("deployment brake store is corrupt or ambiguous"),
};
let next = typed_envelope(
IDUNN_DEPLOYMENT_BRAKE_ID,
&record,
IDUNN_DEPLOYMENT_BRAKE_SCHEMA,
millis,
)?;
if !store.compare_exchange(
&[CultCacheExpectedEnvelope {
r#type: IdunnDeploymentBrakeRecord::TYPE.into(),
key: IDUNN_DEPLOYMENT_BRAKE_ID.into(),
current,
}],
&[next],
)? {
bail!("deployment brake changed during transition");
}
Ok(())
}
fn read_brake(path: &Path) -> Result<IdunnDeploymentBrakeRecord> {
let entries = SingleFileMessagePackBackingStore::new(path).pull_all_read_only_snapshot()?;
let [entry] = entries.as_slice() else {
bail!("deployment brake is missing or ambiguous")
};
if entry.r#type != IdunnDeploymentBrakeRecord::TYPE
|| entry.key != IDUNN_DEPLOYMENT_BRAKE_ID
|| entry.schema_id.as_deref() != Some(IDUNN_DEPLOYMENT_BRAKE_SCHEMA)
{
bail!("deployment brake is foreign")
}
let record: IdunnDeploymentBrakeRecord = rmp_serde::from_slice(&entry.payload)?;
if rmp_serde::to_vec(&record)? != entry.payload {
bail!("deployment brake is noncanonical")
}
record.validate()?;
Ok(record)
}
fn read_operator_anchor(path: &Path) -> Result<ServiceIdentityTrustAnchor> {
let entries = SingleFileMessagePackBackingStore::new(path).pull_all_read_only_snapshot()?;
let [entry] = entries.as_slice() else {
bail!("operator anchor is missing or ambiguous")
};
if entry.r#type != IdunnDeploymentBrakeOperatorIdentity::TRUST_ANCHOR_TYPE
|| entry.key != IdunnDeploymentBrakeOperatorIdentity::TRUST_ANCHOR_KEY
{
bail!("operator anchor is foreign")
}
Ok(rmp_serde::from_slice(&entry.payload)?)
}
fn validate_health_binding_store(path: &Path) -> Result<()> {
let entries = SingleFileMessagePackBackingStore::new(path).pull_all_read_only_snapshot()?;
validated_health_bindings(&entries)?;
@ -960,7 +1127,7 @@ fn normalized(path: &Path) -> Result<PathBuf> {
}
fn usage() -> &'static str {
"Usage: idunn-provision enroll-provider-health-identity --private-store <path>\n idunn-provision provider-health-public-key --private-store <path>\n idunn-provision export-provider-health-public-anchor --private-store <path> --public-anchor <path>\n idunn-provision enroll-idunn-identity --private-store <path>\n idunn-provision export-idunn-public-anchor --private-store <path> --public-anchor <path>\n idunn-provision enroll-odin-topology-identity --private-store <path>\n idunn-provision export-odin-topology-public-anchor --private-store <path> --public-anchor <path>\n idunn-provision deployment-brake-engage --store <path> --runtime-id <id> --reason <text>\n idunn-provision deployment-brake-clear --store <path> --runtime-id <id> --reason <text>\n idunn-provision deployment-brake-status --store <path> --runtime-id <id> [--owner-user <login>]\n idunn-provision lifecycle-brake-engage --store <path> --runtime-id <id> --target <id> --reason <text> --updated-at-unix-millis <u64>\n idunn-provision lifecycle-brake-release --store <path> --runtime-id <id> --target <id> --reason <text> --updated-at-unix-millis <u64> [--released-until-unix-millis <u64>]\n idunn-provision lifecycle-brake-status --store <path> --runtime-id <id> --target <id> --now-unix-millis <u64>\n idunn-provision create-daemon-health-trust-binding --output <path> --binding-id <id> --daemon <id> --health-contract <id> --source-runtime <id> --signer-public-key-hex <hex> --bound-at-unix-millis <u64> --release-binding-required <true|false>\n idunn-provision add-daemon-health-trust-binding --output <path> --binding-id <id> --daemon <id> --health-contract <id> --source-runtime <id> --signer-public-key-hex <hex> --bound-at-unix-millis <u64> --release-binding-required <true|false>\n idunn-provision require-daemon-health-release-binding --store <path> --binding-id <id> --daemon <id> --health-contract <id> --source-runtime <id> --signer-public-key-hex <hex>\n idunn-provision rotate-daemon-health-trust-signer --output <path> --binding-id <id> --signer-public-key-hex <hex> --bound-at-unix-millis <u64>\n idunn-provision validate-daemon-health-trust-binding --input <path>\n idunn-provision create-provider-projection-trust-anchor --output <path> --trust-anchor-id <id> --runtime-id <id> --idunn-public-anchor <path> --bound-at-unix-millis <u64> --expires-at-unix-millis <u64>\n idunn-provision validate-provider-projection-trust-anchor --input <path> --idunn-public-anchor <path>"
"Usage: idunn-provision enroll-provider-health-identity --private-store <path>\n idunn-provision provider-health-public-key --private-store <path>\n idunn-provision export-provider-health-public-anchor --private-store <path> --public-anchor <path>\n idunn-provision enroll-idunn-identity --private-store <path>\n idunn-provision export-idunn-public-anchor --private-store <path> --public-anchor <path>\n idunn-provision enroll-odin-topology-identity --private-store <path>\n idunn-provision export-odin-topology-public-anchor --private-store <path> --public-anchor <path>\n idunn-provision enroll-deployment-brake-operator --private-store <path>\n idunn-provision export-deployment-brake-operator-anchor --private-store <path> --public-anchor <path>\n idunn-provision deployment-brake-engage --store <path> --runtime-id <id> --owner <principal> --reason <text> --observed-at-unix-millis <u64>\n idunn-provision deployment-brake-release --store <path> --private-store <path> --runtime-id <id> --owner <principal> --reason <text> --authorization-id <id> --release-id <id> --deployment-id <id> --issued-at-unix-millis <u64> --expires-at-unix-millis <u64>\n idunn-provision deployment-brake-status --store <path> --operator-anchor <path> --runtime-id <id> [--release-id <id> --deployment-id <id> --now-unix-millis <u64>]\n idunn-provision lifecycle-brake-engage --store <path> --runtime-id <id> --target <id> --reason <text> --updated-at-unix-millis <u64>\n idunn-provision lifecycle-brake-release --store <path> --runtime-id <id> --target <id> --reason <text> --updated-at-unix-millis <u64> [--released-until-unix-millis <u64>]\n idunn-provision lifecycle-brake-status --store <path> --runtime-id <id> --target <id> --now-unix-millis <u64>\n idunn-provision create-daemon-health-trust-binding --output <path> --binding-id <id> --daemon <id> --health-contract <id> --source-runtime <id> --signer-public-key-hex <hex> --bound-at-unix-millis <u64> --release-binding-required <true|false>\n idunn-provision add-daemon-health-trust-binding --output <path> --binding-id <id> --daemon <id> --health-contract <id> --source-runtime <id> --signer-public-key-hex <hex> --bound-at-unix-millis <u64> --release-binding-required <true|false>\n idunn-provision require-daemon-health-release-binding --store <path> --binding-id <id> --daemon <id> --health-contract <id> --source-runtime <id> --signer-public-key-hex <hex>\n idunn-provision rotate-daemon-health-trust-signer --output <path> --binding-id <id> --signer-public-key-hex <hex> --bound-at-unix-millis <u64>\n idunn-provision validate-daemon-health-trust-binding --input <path>\n idunn-provision create-provider-projection-trust-anchor --output <path> --trust-anchor-id <id> --runtime-id <id> --idunn-public-anchor <path> --bound-at-unix-millis <u64> --expires-at-unix-millis <u64>\n idunn-provision validate-provider-projection-trust-anchor --input <path> --idunn-public-anchor <path>"
}
#[cfg(test)]
@ -1990,74 +2157,120 @@ mod tests {
}
#[test]
fn provision_engage_clear_sequence() -> Result<()> {
fn brake_operator_can_issue_one_exact_bounded_rollout_grant() -> Result<()> {
let temp = TempDir::new()?;
let private = temp.path().join("operator-private.cc");
let anchor = temp.path().join("operator-public.cc");
let store = temp.path().join("brake.cc");
let me = process_uid();
let engage = |verb: &str, reason: &str| {
invoke(&[
verb,
"--store",
store.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--reason",
reason,
])
};
assert_eq!(read_stop(&store, "yggdrasil", me), Stop::Absent);
invoke(&[
"deployment-brake-status",
"enroll-deployment-brake-operator",
"--private-store",
private.to_str().unwrap(),
])?;
invoke(&[
"export-deployment-brake-operator-anchor",
"--private-store",
private.to_str().unwrap(),
"--public-anchor",
anchor.to_str().unwrap(),
])?;
invoke(&[
"deployment-brake-engage",
"--store",
store.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--owner",
"operator/metacrat",
"--reason",
"sleep mode",
"--observed-at-unix-millis",
"100",
])?;
engage("deployment-brake-engage", "freeze")?;
let status = || {
assert_eq!(read_brake(&store)?.status, "engaged");
invoke(&[
"deployment-brake-status",
"--store",
store.to_str().unwrap(),
"--operator-anchor",
anchor.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
])?;
assert!(
invoke(&[
"deployment-brake-status",
"--store",
store.to_str().unwrap(),
"--operator-anchor",
anchor.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--release-id",
"commit-4",
"--deployment-id",
"request-4",
"--now-unix-millis",
"150",
])
};
assert!(status().is_err(), "an engaged stop must not pass status");
let Stop::Engaged(first) = read_stop(&store, "yggdrasil", me) else {
bail!("engage did not engage")
};
assert_eq!((first.sequence, first.reason.as_str()), (1, "freeze"));
assert!(!first.by.is_empty() && first.at_unix_millis > 0);
engage("deployment-brake-clear", "thawed")?;
status()?;
let Stop::Clear(second) = read_stop(&store, "yggdrasil", me) else {
bail!("clear did not clear")
};
assert_eq!((second.sequence, second.by), (2, first.by));
assert!(second.at_unix_millis >= first.at_unix_millis);
// The author and the time are not arguments, and the retired
// signing arguments are refused.
for stray in ["--owner", "--observed-at-unix-millis", "--private-store"] {
assert!(
invoke(&[
"deployment-brake-engage",
"--store",
store.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--reason",
"x",
stray,
"y",
])
.is_err(),
"{stray}"
);
}
for gone in ["deployment-brake-release", "enroll-deployment-brake-operator"] {
assert!(invoke(&[gone]).is_err(), "{gone}");
}
.is_err()
);
invoke(&[
"deployment-brake-release",
"--store",
store.to_str().unwrap(),
"--private-store",
private.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--owner",
"operator/metacrat",
"--reason",
"one rollout",
"--authorization-id",
"auth/r4",
"--release-id",
"commit-4",
"--deployment-id",
"request-4",
"--issued-at-unix-millis",
"200",
"--expires-at-unix-millis",
"800",
])?;
invoke(&[
"deployment-brake-status",
"--store",
store.to_str().unwrap(),
"--operator-anchor",
anchor.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--release-id",
"commit-4",
"--deployment-id",
"request-4",
"--now-unix-millis",
"500",
])?;
assert!(
invoke(&[
"deployment-brake-status",
"--store",
store.to_str().unwrap(),
"--operator-anchor",
anchor.to_str().unwrap(),
"--runtime-id",
"yggdrasil",
"--release-id",
"substituted",
"--deployment-id",
"request-4",
"--now-unix-millis",
"500"
])
.is_err()
);
Ok(())
}
@ -2096,6 +2309,7 @@ mod tests {
assert_eq!(engaged.status, "engaged");
assert_eq!(engaged.runtime_id, "idunn-yggdrasil");
assert_eq!(engaged.target, "ghostlight");
assert!(read_brake(&store).is_err());
assert!(
invoke(&[
"lifecycle-brake-status",
@ -2212,4 +2426,57 @@ mod tests {
assert_eq!(std::fs::read(&store)?, released_bytes);
Ok(())
}
#[test]
fn brake_compare_exchange_rejects_stale_transition_snapshot() -> Result<()> {
let temp = TempDir::new()?;
let store_path = temp.path().join("brake.cc");
let base = IdunnDeploymentBrakeRecord {
schema_version: IDUNN_DEPLOYMENT_BRAKE_SCHEMA.into(),
brake_id: IDUNN_DEPLOYMENT_BRAKE_ID.into(),
authority: IDUNN_DEPLOYMENT_BRAKE_AUTHORITY.into(),
runtime_id: "yggdrasil".into(),
status: "engaged".into(),
scope: IDUNN_DEPLOYMENT_BRAKE_SCOPE.into(),
reason: "first".into(),
observed_at_unix_millis: 100,
expires_at_unix_millis: None,
authorization_id: None,
authorization_purpose: None,
authorized_release_id: None,
authorized_deployment_id: None,
authorized_by: None,
authorization_issued_at_unix_millis: None,
authorization_expires_at_unix_millis: None,
signature_algorithm: None,
signature: None,
private_state_exposed: false,
updated_by: "operator/a".into(),
};
replace_brake(&store_path, base.clone(), 100)?;
let stale = SingleFileMessagePackBackingStore::new(&store_path)
.pull_all_read_only_snapshot()?
.remove(0);
let mut changed = base.clone();
changed.reason = "racing writer".into();
changed.observed_at_unix_millis = 101;
replace_brake(&store_path, changed, 101)?;
let candidate = typed_envelope(
IDUNN_DEPLOYMENT_BRAKE_ID,
&base,
IDUNN_DEPLOYMENT_BRAKE_SCHEMA,
102,
)?;
assert!(
!SingleFileMessagePackBackingStore::new(&store_path).compare_exchange(
&[CultCacheExpectedEnvelope {
r#type: IdunnDeploymentBrakeRecord::TYPE.into(),
key: IDUNN_DEPLOYMENT_BRAKE_ID.into(),
current: Some(stale)
}],
&[candidate]
)?
);
Ok(())
}
}

View file

@ -1528,7 +1528,12 @@ impl StewardBinding {
!self.principal.starts_with('-') && !self.principal.contains('/'),
"steward principal is invalid"
);
let user_ok = login_grammar_ok(&self.user);
let user_ok = !self.user.is_empty()
&& self.user.len() <= 32
&& self.user.bytes().all(|byte| {
byte.is_ascii_lowercase() || byte.is_ascii_digit() || matches!(byte, b'_' | b'-')
})
&& !self.user.starts_with(|first: char| first.is_ascii_digit() || first == '-');
ensure!(user_ok && self.user != "root", "steward user is invalid or root");
ensure!(
self.mind_control.is_absolute(),
@ -1576,18 +1581,7 @@ fn load_binding(path: &Path) -> Result<StewardBinding> {
StewardBinding::parse(&text)
}
/// A login name Idunn will resolve: the one grammar for every binding that names
/// a user.
pub(crate) fn login_grammar_ok(user: &str) -> bool {
!user.is_empty()
&& user.len() <= 32
&& user.bytes().all(|byte| {
byte.is_ascii_lowercase() || byte.is_ascii_digit() || matches!(byte, b'_' | b'-')
})
&& !user.starts_with(|first: char| first.is_ascii_digit() || first == '-')
}
pub(crate) fn user_uid(name: &str) -> Result<u32> {
fn user_uid(name: &str) -> Result<u32> {
let name = std::ffi::CString::new(name)?;
// SAFETY: `passwd` is plain data and getpwnam_r fills it, with strings in
// `buffer`, which outlives every read of them below (none are read).