7 Commits
Author SHA1 Message Date
Willem Vanhulle a7e33b453a test: drop the scripted initrd sample machine now that NixOS removed it 2026-11-09 21:54:18 +01:00
release-plz f43ece2f72 chore: release v0.1.3
Signed-off-by: release-plz <willemvanhulle@protonmail.com>
2026-11-05 19:52:10 +00:00
Willem Vanhulle d41120e263 ci: sync the shared CI tasks
Make cargoToolchain optional in nix/ci-tasks.nix, so repositories without
Rust use the same file, and add a copy-build-output task that copies a build
result into the checkout as writable files. The shared files in ci/ and
nix/ci-tasks.nix stay identical across repositories.

Claude-Session: https://claude.ai/code/session_01D8dLLgYd8cfR2aQfA5eZXa
2026-11-05 20:45:36 +01:00
Willem Vanhulle f9f68b2a68 ci: move CI tasks into Nushell scripts and update dependencies weekly
Replace the shell scripts in flake.nix with Nushell scripts in ci/, exposed
as flake apps in nix/ci-tasks.nix, so every workflow command is a plain nix
call. Build the workspace dependencies in a step of their own, upload to
Cachix only after the builds, and run the formatting check through the
pre-commit hooks.

Automated pushes, tags and pull requests now use the wvhulle-bot account.
A weekly cron updates Cargo.lock and flake.lock and opens or updates one
pull request from bot/dependency-updates.

Claude-Session: https://claude.ai/code/session_01D8dLLgYd8cfR2aQfA5eZXa
2026-11-05 19:59:06 +01:00
Willem Vanhulle a81cc849b5 test: boot the sample machine into tuigreet
Log in through a full-screen greeter rather than agreety, so the checks cover
a greeter that redraws over status output.
2026-11-04 19:59:30 +01:00
Willem Vanhulle 89eec1ddaf fix: keep systemd status off the display manager until the boot finishes
bootvine restored systemd's status output as soon as a display manager took
the console. greetd's Type=idle only waits five seconds, so jobs still running
then wrote status lines over the login screen.

Restore the output when StartupFinished arrives instead, through a single
private path that owns the console watch. A quit key or stopping the service
still restores it at once, so a stuck boot stays visible.
2026-11-04 19:59:30 +01:00
Willem Vanhulle d0833ad563 fix: do not report collected systemd jobs as failed 2026-11-02 21:30:32 +01:00
29 changed files with 705 additions and 287 deletions

No files matched your search

+85
View File
@@ -0,0 +1,85 @@
when:
- repo: wvhulle/bootvine
event: [pull_request, push, manual]
variables:
- &nix_config
NIX_CONFIG: |
experimental-features = nix-command flakes
build-users-group =
accept-flake-config = true
- &after_dependency_step
- status: [success, failure]
steps:
- name: prepare-build-dependencies
image: nixos/nix:latest
depends_on: []
environment: *nix_config
commands:
- nix run --quiet .#build-unless-cached -- .#packages.x86_64-linux.workspace-dependencies
- name: build-and-test-bootvine
image: nixos/nix:latest
depends_on: [prepare-build-dependencies]
when: *after_dependency_step
environment: *nix_config
commands:
- nix run --quiet .#import-exported-paths
- nix run --quiet .#build-and-export-paths -- .#checks.x86_64-linux.bootvine-build
- name: build-repo-tasks
image: nixos/nix:latest
depends_on: [prepare-build-dependencies]
when: *after_dependency_step
environment: *nix_config
commands:
- nix run --quiet .#import-exported-paths
- nix run --quiet .#build-and-export-paths -- .#checks.x86_64-linux.repo-tasks-build
- name: lint-with-clippy
image: nixos/nix:latest
depends_on: [prepare-build-dependencies]
when: *after_dependency_step
environment: *nix_config
commands:
- nix run --quiet .#import-exported-paths
- nix build --quiet --print-build-logs .#checks.x86_64-linux.clippy-lints
- name: upload-builds-to-cachix
image: nixos/nix:latest
depends_on: [build-and-test-bootvine, build-repo-tasks]
when:
- event: [push, manual]
branch: main
status: [success, failure]
environment:
<<: *nix_config
CACHIX_AUTH_TOKEN:
from_secret: cachix_auth_token
commands:
- nix run --quiet .#upload-exported-paths
- name: run-pre-commit-hooks
image: nixos/nix:latest
depends_on: [prepare-build-dependencies]
when: *after_dependency_step
environment: *nix_config
commands:
- nix run --quiet .#run-pre-commit-hooks
- name: evaluate-flake-outputs
image: nixos/nix:latest
depends_on: []
environment: *nix_config
commands:
- nix flake check --quiet --no-build
- name: check-commit-messages
image: nixos/nix:latest
depends_on: []
when:
- event: pull_request
environment: *nix_config
commands:
- nix run --quiet .#check-commit-messages -- --fetch-target-branch FETCH_HEAD..HEAD
+28
View File
@@ -0,0 +1,28 @@
when:
- repo: wvhulle/bootvine
event: cron
cron: weekly-dependency-update
clone:
- name: clone-with-history
image: woodpeckerci/plugin-git
settings:
depth: 0
partial: false
steps:
- name: open-dependency-update-pr
image: nixos/nix:latest
environment:
NIX_CONFIG: |
experimental-features = nix-command flakes
build-users-group =
accept-flake-config = true
GIT_AUTHOR_NAME: wvhulle-bot
GIT_AUTHOR_EMAIL: willemvanhulle@protonmail.com
GIT_COMMITTER_NAME: wvhulle-bot
GIT_COMMITTER_EMAIL: willemvanhulle@protonmail.com
CODEBERG_TOKEN:
from_secret: bot_token
commands:
- nix run --quiet .#open-dependency-update-pr -- --cargo-lock --flake-lock
@@ -4,10 +4,10 @@ when:
branch: main branch: main
depends_on: depends_on:
- rust-and-flake-checks - checks
clone: clone:
- name: clone-with-history-and-tags - name: clone-with-history
image: woodpeckerci/plugin-git image: woodpeckerci/plugin-git
settings: settings:
depth: 0 depth: 0
@@ -25,21 +25,19 @@ variables:
GIT_COMMITTER_NAME: release-plz GIT_COMMITTER_NAME: release-plz
GIT_COMMITTER_EMAIL: willemvanhulle@protonmail.com GIT_COMMITTER_EMAIL: willemvanhulle@protonmail.com
CODEBERG_TOKEN: CODEBERG_TOKEN:
from_secret: codeberg_token from_secret: bot_token
CARGO_REGISTRY_TOKEN: CARGO_REGISTRY_TOKEN:
from_secret: cargo_registry_token from_secret: cargo_registry_token
steps: steps:
- name: publish-crate-and-tag-release - name: publish-unreleased-crate-version
image: nixos/nix:latest image: nixos/nix:latest
environment: *release_env environment: *release_env
commands: commands:
- git remote set-url origin "https://wvhulle:$${CODEBERG_TOKEN}@codeberg.org/$${CI_REPO}.git" - nix run --quiet .#publish-unreleased-crate-version
- git checkout -B main "$${CI_COMMIT_SHA}"
- nix run .#release-plz-release
- name: update-release-pr - name: open-or-update-release-pr
image: nixos/nix:latest image: nixos/nix:latest
environment: *release_env environment: *release_env
commands: commands:
- nix run .#release-plz-release-pr - nix run --quiet .#open-or-update-release-pr
-87
View File
@@ -1,87 +0,0 @@
when:
- repo: wvhulle/bootvine
event: [pull_request, push, manual]
variables:
- &nix_config
NIX_CONFIG: |
experimental-features = nix-command flakes
build-users-group =
accept-flake-config = true
- &cache_writing_env
<<: *nix_config
CACHIX_AUTH_TOKEN:
from_secret: cachix_auth_token
- &on_main_branch
- event: [push, manual]
branch: main
- &off_main_branch
- event: pull_request
- event: [push, manual]
branch:
exclude: main
- &on_pull_requests
- event: pull_request
steps:
- name: build-test-and-cache-bootvine
image: nixos/nix:latest
depends_on: []
when: *on_main_branch
environment: *cache_writing_env
commands:
- nix run .#build-and-push-to-cachix -- .#checks.x86_64-linux.bootvine-build
- name: build-and-test-bootvine
image: nixos/nix:latest
depends_on: []
when: *off_main_branch
environment: *nix_config
commands:
- nix build --print-build-logs .#checks.x86_64-linux.bootvine-build
- name: build-and-cache-repo-tasks
image: nixos/nix:latest
depends_on: []
when: *on_main_branch
environment: *cache_writing_env
commands:
- nix run .#build-and-push-to-cachix -- .#checks.x86_64-linux.repo-tasks-build
- name: build-repo-tasks
image: nixos/nix:latest
depends_on: []
when: *off_main_branch
environment: *nix_config
commands:
- nix build --print-build-logs .#checks.x86_64-linux.repo-tasks-build
- name: lint-rust-with-clippy
image: nixos/nix:latest
depends_on: []
environment: *nix_config
commands:
- nix build --print-build-logs .#checks.x86_64-linux.clippy-lints
- name: check-rust-formatting
image: nixos/nix:latest
depends_on: []
environment: *nix_config
commands:
- nix build --print-build-logs .#checks.x86_64-linux.rustfmt-formatting
- name: evaluate-flake-outputs
image: nixos/nix:latest
depends_on: []
environment: *nix_config
commands:
- nix flake check --no-build
- name: check-conventional-commit-messages
image: nixos/nix:latest
depends_on: []
when: *on_pull_requests
environment: *nix_config
commands:
- git fetch --quiet origin "$${CI_COMMIT_TARGET_BRANCH}"
- nix run .#check-conventional-commits -- FETCH_HEAD..HEAD
+7
View File
@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
## [Unreleased] ## [Unreleased]
## [0.1.3](https://codeberg.org/wvhulle/bootvine/compare/v0.1.2...v0.1.3) - 2026-11-05
### Fixed
- do not report collected systemd jobs as failed
- keep systemd status off the display manager until the boot finishes
## [0.1.2](https://codeberg.org/wvhulle/bootvine/compare/v0.1.1...v0.1.2) - 2026-11-02 ## [0.1.2](https://codeberg.org/wvhulle/bootvine/compare/v0.1.1...v0.1.2) - 2026-11-02
### Added ### Added
Generated
+1 -1
View File
@@ -144,7 +144,7 @@ dependencies = [
[[package]] [[package]]
name = "bootvine" name = "bootvine"
version = "0.1.2" version = "0.1.3"
dependencies = [ dependencies = [
"clap", "clap",
"crossterm 0.29.0", "crossterm 0.29.0",
+1 -1
View File
@@ -9,7 +9,7 @@ name = "bootvine"
readme = "../README.md" readme = "../README.md"
repository = "https://codeberg.org/wvhulle/bootvine" repository = "https://codeberg.org/wvhulle/bootvine"
rust-version = "1.91" rust-version = "1.91"
version = "0.1.2" version = "0.1.3"
[lints] [lints]
workspace = true workspace = true
+15 -1
View File
@@ -194,7 +194,7 @@ impl BootState {
}; };
let outcome = match result { let outcome = match result {
JobResult::Done => Outcome::Succeeded { at }, JobResult::Done => Outcome::Succeeded { at },
JobResult::Skipped | JobResult::Canceled => Outcome::Abandoned, JobResult::Skipped | JobResult::Canceled | JobResult::Collected => Outcome::Abandoned,
JobResult::Failed => Outcome::Failed(FailureKind::Broke), JobResult::Failed => Outcome::Failed(FailureKind::Broke),
JobResult::Timeout => Outcome::Failed(FailureKind::TimedOut), JobResult::Timeout => Outcome::Failed(FailureKind::TimedOut),
JobResult::Dependency => Outcome::Failed(FailureKind::DependencyFailed), JobResult::Dependency => Outcome::Failed(FailureKind::DependencyFailed),
@@ -337,6 +337,20 @@ mod tests {
); );
} }
#[test]
fn a_collected_job_on_a_multi_device_mount_source_is_not_a_failure() {
let mut state = BootState::new(Phase::Initrd);
queue_unit(
&mut state,
1,
waiting("dev-nvme0n1p1:-dev-nvme1n1p3.device", &[]),
500 * MS,
);
state.finish_job(1, JobResult::Collected, 2000 * MS);
assert!(state.failed.is_empty());
assert_eq!(state.tally().failed, 0);
}
#[test] #[test]
fn a_unit_entering_the_failed_state_counts_without_a_failed_job() { fn a_unit_entering_the_failed_state_counts_without_a_failed_job() {
let mut state = sample(); let mut state = sample();
+2
View File
@@ -20,6 +20,7 @@ pub enum JobResult {
Done, Done,
Skipped, Skipped,
Canceled, Canceled,
Collected,
Timeout, Timeout,
Dependency, Dependency,
#[serde(other)] #[serde(other)]
@@ -162,6 +163,7 @@ mod tests {
); );
assert_eq!(from_str("maintenance").ok(), Some(ActiveState::Inactive)); assert_eq!(from_str("maintenance").ok(), Some(ActiveState::Inactive));
assert_eq!(from_str("dependency").ok(), Some(JobResult::Dependency)); assert_eq!(from_str("dependency").ok(), Some(JobResult::Dependency));
assert_eq!(from_str("collected").ok(), Some(JobResult::Collected));
assert_eq!(from_str("frozen").ok(), Some(JobResult::Failed)); assert_eq!(from_str("frozen").ok(), Some(JobResult::Failed));
assert_eq!(from_str("stop").ok(), Some(JobKind::TakesDown)); assert_eq!(from_str("stop").ok(), Some(JobKind::TakesDown));
assert_eq!(from_str("restart").ok(), Some(JobKind::BringsUp)); assert_eq!(from_str("restart").ok(), Some(JobKind::BringsUp));
+10 -13
View File
@@ -19,7 +19,7 @@ use crate::{
boot_feed::{RootRequest, bus_inputs}, boot_feed::{RootRequest, bus_inputs},
link_error::Error, link_error::Error,
switch_root::INITRD_RELEASE, switch_root::INITRD_RELEASE,
systemd_bus::{Scope, Session, StatusOutput}, systemd_bus::{Scope, Session, StatusRelease, restore_status_after_watch},
}, },
}; };
@@ -33,16 +33,6 @@ pub struct Settings {
const FULL_REPAINT_INTERVAL: Duration = Duration::from_secs(5); const FULL_REPAINT_INTERVAL: Duration = Duration::from_secs(5);
struct ConfiguredStatusOnExit;
impl Drop for ConfiguredStatusOnExit {
fn drop(&mut self) {
if let Ok(session) = Session::open(Scope::System) {
session.set_show_status(StatusOutput::Configured).ok();
}
}
}
fn boot_already_finished(settings: &Settings) -> bool { fn boot_already_finished(settings: &Settings) -> bool {
settings.scope == Scope::System settings.scope == Scope::System
&& !settings.shutdown && !settings.shutdown
@@ -73,8 +63,14 @@ pub fn run(settings: &Settings) -> Result<(), Error> {
} }
async fn watch_live_boot(settings: &Settings, phase: Phase) -> Result<(), Error> { async fn watch_live_boot(settings: &Settings, phase: Phase) -> Result<(), Error> {
match settings.scope {
Scope::System => restore_status_after_watch(watch_on_console(settings, phase)).await,
Scope::User => watch_on_console(settings, phase).await.map(drop),
}
}
async fn watch_on_console(settings: &Settings, phase: Phase) -> Result<StatusRelease, Error> {
let for_system = settings.scope == Scope::System; let for_system = settings.scope == Scope::System;
let _restores_status = for_system.then_some(ConfiguredStatusOnExit);
let requests = RequestWatch::open(); let requests = RequestWatch::open();
let prompt_check: fn() -> ScreenInput = if requests.is_some() { let prompt_check: fn() -> ScreenInput = if requests.is_some() {
|| ScreenInput::PromptCheck || ScreenInput::PromptCheck
@@ -117,6 +113,7 @@ async fn watch_live_boot(settings: &Settings, phase: Phase) -> Result<(), Error>
ratatui::restore(); ratatui::restore();
match ending { match ending {
WatchEnding::Failed(error) => Err(error), WatchEnding::Failed(error) => Err(error),
WatchEnding::BootCompleted | WatchEnding::ViewerLeft => Ok(()), WatchEnding::BootCompleted => Ok(StatusRelease::AfterBoot),
WatchEnding::ViewerLeft => Ok(StatusRelease::Immediately),
} }
} }
+1 -2
View File
@@ -25,7 +25,6 @@ use crate::{
switch_root::Sysroot, switch_root::Sysroot,
systemd_bus::{ systemd_bus::{
BusConnection, FetchedUnit, JobListing, Scope, Session, Signal, SignalBatch, BusConnection, FetchedUnit, JobListing, Scope, Session, Signal, SignalBatch,
StatusOutput,
}, },
}, },
}; };
@@ -327,7 +326,7 @@ impl BootTracker {
) -> Result<Vec<BootChange>, Error> { ) -> Result<Vec<BootChange>, Error> {
connection.subscribe().await?; connection.subscribe().await?;
if self.scope == Scope::System { if self.scope == Scope::System {
connection.set_show_status(StatusOutput::Silent).await.ok(); connection.silence_status_output().await.ok();
} }
let shutting_down = self.phase == Phase::Shutdown; let shutting_down = self.phase == Phase::Shutdown;
let jobs: Vec<JobListing> = connection let jobs: Vec<JobListing> = connection
+78 -19
View File
@@ -1,5 +1,5 @@
use std::{ use std::{
future::ready, future::{Future, pending, ready},
io, iter, mem, io, iter, mem,
os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd}, os::fd::{AsFd, AsRawFd, BorrowedFd, RawFd},
pin::pin, pin::pin,
@@ -11,9 +11,13 @@ use dbus::{
arg::{AppendAll, PropMap, RefArg, Variant}, arg::{AppendAll, PropMap, RefArg, Variant},
channel::{BusType, Channel}, channel::{BusType, Channel},
}; };
use futures::{TryStreamExt, stream}; use futures::{Stream, StreamExt, TryStreamExt, future::select, stream};
use rustix::event::{PollFd, PollFlags, Timespec, poll}; use rustix::event::{PollFd, PollFlags, Timespec, poll};
use tokio::{io::unix::AsyncFd, time::timeout}; use tokio::{
io::unix::AsyncFd,
signal::unix::{Signal as OsSignal, SignalKind, signal},
time::timeout,
};
use crate::{ use crate::{
boot_model::{Activity, JobKind, JobResult, UnitFacts, UnitKind, UnitTimeouts}, boot_model::{Activity, JobKind, JobResult, UnitFacts, UnitKind, UnitTimeouts},
@@ -40,6 +44,8 @@ const PRIVATE_SOCKET: &str = "unix:path=/run/systemd/private";
const SIGNAL_RULE: &str = "type='signal',path_namespace='/org/freedesktop/systemd1'"; const SIGNAL_RULE: &str = "type='signal',path_namespace='/org/freedesktop/systemd1'";
const CALL_TIMEOUT: Duration = Duration::from_secs(1); const CALL_TIMEOUT: Duration = Duration::from_secs(1);
const UNLIMITED: Duration = Duration::from_micros(u64::MAX); const UNLIMITED: Duration = Duration::from_micros(u64::MAX);
const STATUS_SILENT_MODE: &str = "no";
const STATUS_RESET_MODE: &str = "";
#[derive(Clone, Copy, Debug, PartialEq, Eq)] #[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Scope { pub enum Scope {
@@ -48,18 +54,9 @@ pub enum Scope {
} }
#[derive(Clone, Copy, Debug, PartialEq, Eq)] #[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum StatusOutput { pub enum StatusRelease {
Silent, AfterBoot,
Configured, Immediately,
}
impl StatusOutput {
fn bus_mode(self) -> &'static str {
match self {
Self::Silent => "no",
Self::Configured => "",
}
}
} }
pub enum SignalBatch { pub enum SignalBatch {
@@ -157,6 +154,41 @@ fn read_boot_in_progress(reply: &Message) -> Result<bool, Error> {
Ok(finished.0 == 0) Ok(finished.0 == 0)
} }
async fn boot_finish_or_lost_connection() -> Result<(), Error> {
let mut connection = BusConnection::register(Session::open(Scope::System)?)?;
connection.subscribe().await?;
if connection.boot_in_progress().await? {
connection
.into_signals()
.any(|signal| ready(matches!(signal, Signal::BootFinished)))
.await;
}
Ok(())
}
async fn termination_request(listener: io::Result<OsSignal>) {
match listener {
Ok(mut listener) => {
listener.recv().await;
}
Err(_) => pending().await,
}
}
pub async fn restore_status_after_watch(
watch: impl Future<Output = Result<StatusRelease, Error>>,
) -> Result<(), Error> {
let terminated = termination_request(signal(SignalKind::terminate()));
let watched = watch.await;
if !matches!(watched, Ok(StatusRelease::Immediately)) {
select(pin!(terminated), pin!(boot_finish_or_lost_connection())).await;
}
if let Ok(session) = Session::open(Scope::System) {
session.restore_configured_status().ok();
}
watched.map(drop)
}
impl Session { impl Session {
pub fn open(scope: Scope) -> Result<Self, Error> { pub fn open(scope: Scope) -> Result<Self, Error> {
if scope == Scope::System if scope == Scope::System
@@ -193,8 +225,8 @@ impl Session {
Ok(self.channel.send_with_reply_and_block(call, CALL_TIMEOUT)?) Ok(self.channel.send_with_reply_and_block(call, CALL_TIMEOUT)?)
} }
pub fn set_show_status(&self, output: StatusOutput) -> Result<(), Error> { fn restore_configured_status(&self) -> Result<(), Error> {
self.blocking_call(manager_call("SetShowStatus", (output.bus_mode(),))?)?; self.blocking_call(manager_call("SetShowStatus", (STATUS_RESET_MODE,))?)?;
Ok(()) Ok(())
} }
@@ -297,8 +329,8 @@ impl BusConnection {
Ok(()) Ok(())
} }
pub async fn set_show_status(&mut self, output: StatusOutput) -> Result<(), Error> { pub async fn silence_status_output(&mut self) -> Result<(), Error> {
self.call(manager_call("SetShowStatus", (output.bus_mode(),))?) self.call(manager_call("SetShowStatus", (STATUS_SILENT_MODE,))?)
.await?; .await?;
Ok(()) Ok(())
} }
@@ -372,6 +404,10 @@ impl BusConnection {
if self.early_signals.is_empty() { if self.early_signals.is_empty() {
readable_or_timeout(&self.session, patience).await; readable_or_timeout(&self.session, patience).await;
} }
self.take_signals()
}
fn take_signals(&mut self) -> SignalBatch {
let still_connected = self.drain_replies().is_ok(); let still_connected = self.drain_replies().is_ok();
let signals = mem::take(&mut self.early_signals); let signals = mem::take(&mut self.early_signals);
if still_connected { if still_connected {
@@ -380,6 +416,29 @@ impl BusConnection {
SignalBatch::Closed(signals) SignalBatch::Closed(signals)
} }
} }
async fn next_signals(&mut self) -> SignalBatch {
if self.early_signals.is_empty() {
let Ok(mut readiness) = self.session.readable().await else {
return SignalBatch::Closed(Vec::new());
};
readiness.clear_ready();
}
self.take_signals()
}
fn into_signals(self) -> impl Stream<Item = Signal> {
unfold_carrying(self, |mut connection| async move {
match connection.next_signals().await {
SignalBatch::Open(signals) => Some(CarriedItem {
item: signals,
state: connection,
}),
SignalBatch::Closed(_) => None,
}
})
.flat_map(stream::iter)
}
} }
fn text_property(properties: &PropMap, property: &str) -> Option<String> { fn text_property(properties: &PropMap, property: &str) -> Option<String> {
+64
View File
@@ -0,0 +1,64 @@
#!/usr/bin/env nu
const CODEBERG_USER = "wvhulle-bot"
const TEA_LOGIN_NAME = "codeberg"
const UPDATE_BRANCH = "bot/dependency-updates"
const UPDATE_COMMIT_MESSAGE = "chore(deps): update lock files"
const PULL_REQUEST_DESCRIPTION = "Opened by the weekly dependency update job. The checks on this pull request are the trial build. Commits pushed to this branch by hand stop further automatic updates until it is merged."
def open-pull-request-heads []: nothing -> list<string> {
^tea pulls list --login $TEA_LOGIN_NAME --repo $env.CI_REPO --state open --fields head --output simple
| lines
| str trim
}
def remote-update-branch-commits []: nothing -> list<string> {
^git ls-remote --heads origin $"refs/heads/($UPDATE_BRANCH)"
| parse "{commit_id}\t{ref_name}"
| get commit_id
}
def update-branch-has-hand-written-commits []: nothing -> bool {
^git fetch --quiet origin $"+refs/heads/($UPDATE_BRANCH):refs/remotes/origin/($UPDATE_BRANCH)"
^git log --format=%an $"origin/main..origin/($UPDATE_BRANCH)"
| lines
| any {|commit_author| $commit_author != $env.GIT_AUTHOR_NAME }
}
def "main open-dependency-update-pr" [
--cargo-lock
--flake-lock
]: nothing -> nothing {
^git remote set-url origin $"https://($CODEBERG_USER):($env.CODEBERG_TOKEN)@codeberg.org/($env.CI_REPO).git"
^tea login add --name $TEA_LOGIN_NAME --url $env.CI_FORGE_URL --token $env.CODEBERG_TOKEN
^git fetch --quiet origin +refs/heads/main:refs/remotes/origin/main
let remote_commits = remote-update-branch-commits
let remote_commit = $remote_commits | str join
let pull_request_is_open = $UPDATE_BRANCH in (open-pull-request-heads)
if ($remote_commits | is-not-empty) and $pull_request_is_open and (update-branch-has-hand-written-commits) {
print $"Leaving ($UPDATE_BRANCH) alone because it contains hand-written commits"
return
}
^git checkout -B $UPDATE_BRANCH origin/main
if $cargo_lock {
^cargo update
}
if $flake_lock {
^nix flake update
}
if (^git diff --name-only | is-empty) {
print "Dependencies are up to date"
return
}
^git commit --all --message $UPDATE_COMMIT_MESSAGE
^git push $"--force-with-lease=($UPDATE_BRANCH):($remote_commit)" origin $UPDATE_BRANCH
if $pull_request_is_open {
print $"Updated the open pull request from ($UPDATE_BRANCH)"
} else {
^tea pulls create --login $TEA_LOGIN_NAME --repo $env.CI_REPO --head $UPDATE_BRANCH --base main --title $UPDATE_COMMIT_MESSAGE --description $PULL_REQUEST_DESCRIPTION
}
}
def main []: nothing -> nothing {
print "Run a subcommand, for example: open-dependency-update-pr --cargo-lock --flake-lock"
}
+93
View File
@@ -0,0 +1,93 @@
#!/usr/bin/env nu
const EXPORT_DIRECTORY_NAME = ".nix-built-paths"
const PATH_LIST_FILE_NAME = "paths.txt"
const CACHIX_CACHE_NAME = "wvhulle"
const CACHIX_CACHE_URL = "https://wvhulle.cachix.org"
def export-directory []: nothing -> path {
$env.CI_WORKSPACE | path join $EXPORT_DIRECTORY_NAME
}
def store-paths-from-lines []: string -> list<string> {
lines | compact --empty
}
def exported-store-paths []: nothing -> list<string> {
let path_list_file = export-directory | path join $PATH_LIST_FILE_NAME
if ($path_list_file | path exists) {
open --raw $path_list_file | store-paths-from-lines
} else {
[]
}
}
def nix-config-with-hook [existing_config: string, hook_program: string]: nothing -> string {
$"($existing_config)\npost-build-hook = ($hook_program)"
}
def "main export-built-paths-hook" []: nothing -> nothing {
let built_paths = $env.OUT_PATHS | split row " " | compact --empty
let directory = export-directory
mkdir $directory
^nix copy --quiet --to $"file://($directory)?compression=zstd" ...$built_paths
$built_paths | each {|built_path| $"($built_path)\n" } | str join | save --append ($directory | path join $PATH_LIST_FILE_NAME)
}
def --wrapped "main build-and-export-paths" [
...build_arguments: string
]: nothing -> nothing {
let hook_config = nix-config-with-hook ($env.NIX_CONFIG? | default "") $env.EXPORT_HOOK_PROGRAM
with-env {NIX_CONFIG: $hook_config} {
^nix build --quiet --print-build-logs ...$build_arguments
}
}
def "main build-unless-cached" [
installable: string
]: nothing -> nothing {
let built_output = ^nix eval --quiet --raw $"($installable).outPath"
let cache_lookup = do { ^nix path-info --quiet --store $CACHIX_CACHE_URL $built_output } | complete
if $cache_lookup.exit_code == 0 {
print $"($built_output) is already in Cachix"
} else {
main build-and-export-paths $installable
}
}
def "main import-exported-paths" []: nothing -> nothing {
let exported_paths = exported-store-paths
if ($exported_paths | is-empty) {
print "No exported paths to import"
} else {
^nix copy --quiet --no-check-sigs --from $"file://(export-directory)" ...$exported_paths
}
}
def "main upload-exported-paths" []: nothing -> nothing {
let exported_paths = exported-store-paths
if ($exported_paths | is-empty) {
print "No newly built paths to upload"
} else {
main import-exported-paths
^cachix push $CACHIX_CACHE_NAME ...$exported_paths
}
}
def "main copy-build-output" [
build_output: path
destination: path
]: nothing -> nothing {
if ($build_output | path expand | path type) == dir {
mkdir $destination
for output_entry in (ls $build_output | get name) {
cp --recursive --preserve [] $output_entry $destination
}
} else {
cp --preserve [] $build_output $destination
}
}
def main []: nothing -> nothing {
print "Run a subcommand, for example: build-and-export-paths"
}
+69
View File
@@ -0,0 +1,69 @@
#!/usr/bin/env nu
const CODEBERG_USER = "wvhulle-bot"
const TEA_LOGIN_NAME = "codeberg"
const RELEASE_ARCHIVE_PATTERN = "*.tar.gz"
const CHECKSUM_FILE_NAME = "sha256sum.txt"
def checksum-line [archive_digest: string, archive_name: string]: nothing -> string {
$"($archive_digest) ($archive_name)\n"
}
def run-release-plz [subcommand: string]: nothing -> nothing {
^release-plz $subcommand --forge gitea --git-token $env.CODEBERG_TOKEN
}
def "main authenticate-git-origin" []: nothing -> nothing {
^git remote set-url origin $"https://($CODEBERG_USER):($env.CODEBERG_TOKEN)@codeberg.org/($env.CI_REPO).git"
}
def "main publish-unreleased-crate-version" []: nothing -> nothing {
main authenticate-git-origin
^git checkout -B main $env.CI_COMMIT_SHA
^git fetch origin main:refs/remotes/origin/main
^git branch --set-upstream-to=origin/main main
run-release-plz release
}
def "main open-or-update-release-pr" []: nothing -> nothing {
run-release-plz release-pr
}
def "main collect-release-archives" [
build_result: path
dist_directory: path
]: nothing -> nothing {
mkdir $dist_directory
for archive_path in (glob ($build_result | path join $RELEASE_ARCHIVE_PATTERN)) {
cp $archive_path $dist_directory
}
}
def "main upload-release-assets" [
dist_directory: path
]: nothing -> nothing {
let archive_paths = glob ($dist_directory | path join $RELEASE_ARCHIVE_PATTERN) | sort
let checksum_file = $dist_directory | path join $CHECKSUM_FILE_NAME
$archive_paths
| each {|archive_path|
checksum-line (open --raw $archive_path | hash sha256) ($archive_path | path basename)
}
| str join
| save --force $checksum_file
^tea login add --name $TEA_LOGIN_NAME --url $env.CI_FORGE_URL --token $env.CODEBERG_TOKEN
^tea releases assets create --login $TEA_LOGIN_NAME --repo $env.CI_REPO $env.CI_COMMIT_TAG ...$archive_paths $checksum_file
}
def "main check-commit-messages" [
--fetch-target-branch
...revision_ranges: string
]: nothing -> nothing {
if $fetch_target_branch {
^git fetch --quiet origin $env.CI_COMMIT_TARGET_BRANCH
}
^convco check ...$revision_ranges
}
def main []: nothing -> nothing {
print "Run a subcommand, for example: check-commit-messages"
}
+7 -2
View File
@@ -275,8 +275,13 @@ While it runs, bootvine:
writes to the console and resets it while it re-executes, and drawing only writes to the console and resets it while it re-executes, and drawing only
the cells that changed would leave that on screen. the cells that changed would leave that on screen.
It restores the log level and the status output when it hands the console It restores the log level when it hands the console back. It keeps running
back. Kernel messages from before it starts are already on screen; see without touching the console until the boot finishes and only then restores the
status output, so jobs still running cannot write over a display manager that
started before them. This holds for a handover and for an error. Pressing a
[quit key](guide.md#leaving-the-tree) or stopping the service restores the
output at once, so a stuck boot stays visible; status lines can then reach a
display manager that starts before the boot finishes. Kernel messages from before it starts are already on screen; see
[early kernel messages](configuration.md#early-kernel-messages). [early kernel messages](configuration.md#early-kernel-messages).
### Resuming from hibernation ### Resuming from hibernation
+20 -10
View File
@@ -34,25 +34,26 @@ Commit messages follow [Conventional Commits](https://www.conventionalcommits.or
jj does not run git hooks, so check the commits you are about to push with: jj does not run git hooks, so check the commits you are about to push with:
```sh ```sh
nix run .#check-conventional-commits -- origin/main..HEAD nix run .#check-commit-messages -- origin/main..HEAD
``` ```
Git users can install the same commit-message check and a formatting check as Git users can install the same commit-message check and a formatting check as
hooks with `prek install` ([prek](https://github.com/j178/prek), from the dev hooks with `prek install` ([prek](https://github.com/j178/prek), from the dev
shell) or `pre-commit install` ([pre-commit](https://pre-commit.com)). shell) or `pre-commit install` ([pre-commit](https://pre-commit.com)). CI runs
the formatting hook with `nix run .#run-pre-commit-hooks`.
## Continuous integration ## Continuous integration
`.woodpecker/rust-and-flake-checks.yaml` runs on Codeberg's `.woodpecker/checks.yaml` runs on Codeberg's
[Woodpecker CI](https://woodpecker-ci.org) for every push and pull request: the bootvine build with its tests, the xtask build, clippy, [Woodpecker CI](https://woodpecker-ci.org) for every push and pull request: the bootvine build with its tests, the xtask build, clippy,
rustfmt, an evaluation of every flake output, and the commit-message check on the pre-commit hooks, an evaluation of every flake output, and the commit-message check on
pull requests. Builds on `main` are pushed to the `wvhulle` [Cachix](https://www.cachix.org) cache, which pull requests. The workspace dependencies are built or fetched in a step of their own. Builds on `main` are pushed to the `wvhulle` [Cachix](https://www.cachix.org) cache, which
`nixConfig` in `flake.nix` offers as a substituter. The two VM checks need KVM, `nixConfig` in `flake.nix` offers as a substituter. CI tasks are Nushell scripts in `ci/`, exposed as flake apps in `nix/ci-tasks.nix`. The two VM checks need KVM,
which Codeberg's runners lack, so they only run locally. which Codeberg's runners lack, so they only run locally.
## Releases ## Releases
`.woodpecker/release-pr-and-publish.yaml` runs `.woodpecker/publish-release-and-update-pr.yaml` runs
[release-plz](https://release-plz.dev) after the checks pass on `main`. It [release-plz](https://release-plz.dev) after the checks pass on `main`. It
keeps a pull request labelled `release` open on Codeberg that bumps the version keeps a pull request labelled `release` open on Codeberg that bumps the version
in `Cargo.toml` and adds the new commits to `CHANGELOG.md`. Only `feat`, `fix` in `Cargo.toml` and adds the new commits to `CHANGELOG.md`. Only `feat`, `fix`
@@ -61,11 +62,20 @@ minor version while bootvine is below 1.0. Merging that pull request publishes
the crate to crates.io, tags the merge `v<version>` and creates a Codeberg the crate to crates.io, tags the merge `v<version>` and creates a Codeberg
release with the changelog. Settings are in `release-plz.toml`. release with the changelog. Settings are in `release-plz.toml`.
The pipeline needs two Woodpecker secrets: `codeberg_token`, a Codeberg access The pipeline needs two Woodpecker secrets: `bot_token`, an access token of the
token with repository write access, and `cargo_registry_token`, a crates.io `wvhulle-bot` Codeberg account, which has write access to the repository, and
token that may publish new crates and updates. Preview the next release `cargo_registry_token`, a crates.io token that may publish new crates and updates. Preview the next release
locally from the dev shell with `release-plz update`. locally from the dev shell with `release-plz update`.
## Dependency updates
The `weekly-dependency-update` cron runs `.woodpecker/dependency-update-pr.yaml`,
which updates `Cargo.lock` and `flake.lock` and opens or updates one pull request
from the `bot/dependency-updates` branch as `wvhulle-bot`. The checks on that pull
request are the trial build. Commits pushed to the branch by hand stop further
automatic updates until it is merged. Updates that need changes to `Cargo.toml`
stay manual.
## Testing ## Testing
| What | Command | | What | Command |
+16 -8
View File
@@ -47,10 +47,10 @@ From top to bottom:
## Booting through the initrd ## Booting through the initrd
<img src="https://codeberg.org/wvhulle/bootvine/raw/branch/recordings/slow-services.webp" width="640" alt="A NixOS machine booting through the initrd into stage 2, handing over to a greetd login, then powering off"> <img src="https://codeberg.org/wvhulle/bootvine/raw/branch/recordings/slow-services.webp" width="640" alt="A NixOS machine booting through the initrd into stage 2, handing over to a tuigreet login, then powering off">
The `slow-services` machine boots with a held hardware probe in the initrd, The `slow-services` machine boots with a held hardware probe in the initrd,
slow units in stage 2 and one failing unit, hands over to its greetd login slow units in stage 2 and one failing unit, hands over to its tuigreet login
and powers off. With a systemd initrd, bootvine starts about a second after and powers off. With a systemd initrd, bootvine starts about a second after
the kernel: the kernel:
@@ -78,10 +78,9 @@ default target is reached, and the text login on `tty1` comes forward.
### Without a systemd initrd ### Without a systemd initrd
<img src="https://codeberg.org/wvhulle/bootvine/raw/branch/recordings/scripted-initrd.webp" width="640" alt="The same boot with NixOS's scripted initrd: the kernel and initrd lines scroll past before bootvine starts in stage 2"> An initrd without systemd, such as one built by initramfs-tools, has no units
for bootvine to follow. The initrd's lines scroll past as usual, and bootvine
The `scripted-initrd` machine uses NixOS's older scripted initrd, which has no starts in
systemd. The initrd's lines scroll past as usual, and bootvine starts in
stage 2, from `sysinit.target` on. stage 2, from `sysinit.target` on.
## Resuming from hibernation ## Resuming from hibernation
@@ -173,6 +172,16 @@ Failures from the initrd stay in the panel after the switch to the real root.
The recording is the `failures` machine, where every kind of failure systemd The recording is the `failures` machine, where every kind of failure systemd
reports happens one after another. reports happens one after another.
## Leaving the tree
`q`, `Ctrl-C` or `Esc` closes the tree during a boot or shutdown and gives the
console back with systemd's status lines, for when bootvine misbehaves or you
want to see what a stuck boot is doing. While a passphrase prompt is open, keys
go to the prompt instead.
These keys cannot help if bootvine itself has hung, because it reads them in
the same loop that draws the screen.
## Trying it ## Trying it
Neither of these touches your system's boot. Neither of these touches your system's boot.
@@ -202,9 +211,8 @@ shows the shutdown.
| Run | Shows | Recording | | Run | Shows | Recording |
| --- | --- | --- | | --- | --- | --- |
| `nix run .#sample-vm-slow-services` | slow units in the initrd and stage 2, one failing unit, and the handover to a greetd login | [booting through the initrd](#booting-through-the-initrd) | | `nix run .#sample-vm-slow-services` | slow units in the initrd and stage 2, one failing unit, and the handover to a tuigreet login | [booting through the initrd](#booting-through-the-initrd) |
| `nix run .#sample-vm-text-console` | the same units without a display manager, handing over at the default target | [without a display manager](#without-a-display-manager) | | `nix run .#sample-vm-text-console` | the same units without a display manager, handing over at the default target | [without a display manager](#without-a-display-manager) |
| `nix run .#sample-vm-scripted-initrd` | the same units with NixOS's scripted initrd, so bootvine starts in stage 2 only | [without a systemd initrd](#without-a-systemd-initrd) |
| `nix run .#sample-vm-encrypted-volume` | a LUKS volume unlocked in the initrd; the passphrase is `sample passphrase` | [passphrase prompts](#passphrase-prompts) | | `nix run .#sample-vm-encrypted-volume` | a LUKS volume unlocked in the initrd; the passphrase is `sample passphrase` | [passphrase prompts](#passphrase-prompts) |
| `nix run .#sample-vm-hibernate-resume` | a swap disk to hibernate to; run `systemctl hibernate`, then start the machine again | [resuming from hibernation](#resuming-from-hibernation) | | `nix run .#sample-vm-hibernate-resume` | a swap disk to hibernate to; run `systemctl hibernate`, then start the machine again | [resuming from hibernation](#resuming-from-hibernation) |
| `nix run .#sample-vm-failures` | a firmware failure in the initrd, then units that exit with an error, crash, time out, cannot be run, restart too often, report a status, die after starting, and one that fails only through its dependency | [failures](#failures) | | `nix run .#sample-vm-failures` | a firmware failure in the initrd, then units that exit with an error, crash, time out, cannot be run, restart too often, report a status, die after starting, and one that fails only through its dependency | [failures](#failures) |
+51 -63
View File
@@ -61,6 +61,7 @@
{ {
default = builds.bootvine; default = builds.bootvine;
inherit (builds) bootvine scripted-demos repo-tasks; inherit (builds) bootvine scripted-demos repo-tasks;
workspace-dependencies = builds.cargoArtifacts;
sample-unit-files = pkgs.callPackage ./vm-tests/slow-services/sample-unit-files.nix { sample-unit-files = pkgs.callPackage ./vm-tests/slow-services/sample-unit-files.nix {
inherit (vmTests) sampleUnits; inherit (vmTests) sampleUnits;
}; };
@@ -86,12 +87,29 @@
... ...
}: }:
let let
shellScriptApp = name: description: scriptArgs: { mkApp = drv: {
type = "app"; type = "app";
meta.description = description; program = lib.getExe drv;
program = lib.getExe (pkgs.writeShellApplication ({ inherit name; } // scriptArgs));
}; };
repoTaskApp =
name: description: xtaskArguments: runtimeInputs:
mkApp (
pkgs.runCommand name
{
nativeBuildInputs = [ pkgs.makeBinaryWrapper ];
meta.mainProgram = name;
}
''
makeWrapper ${lib.getExe builds.repo-tasks} $out/bin/${name} \
--add-flags ${lib.escapeShellArg xtaskArguments} \
--prefix PATH : ${lib.makeBinPath runtimeInputs}
''
)
// {
meta.description = description;
};
sampleMachineApps = lib.mapAttrs' ( sampleMachineApps = lib.mapAttrs' (
machineName: machineDescription: machineName: machineDescription:
lib.nameValuePair "sample-vm-${machineName}" { lib.nameValuePair "sample-vm-${machineName}" {
@@ -101,80 +119,50 @@
} }
) vmTests.machineDescriptions; ) vmTests.machineDescriptions;
releasePlzOnCodeberg = ciTaskApps = import ./nix/ci-tasks.nix {
subcommand: description: inherit pkgs mkApp;
shellScriptApp "release-plz-${subcommand}" description { cargoToolchain = rustToolchain;
runtimeInputs = [ preCommitInputs = [ rustToolchain ];
pkgs.release-plz extraReleaseInputs = [
pkgs.gitMinimal pkgs.pkg-config
pkgs.pkg-config pkgs.stdenv.cc
pkgs.stdenv.cc ];
rustToolchain releaseWrapperArgs = [
]; "--set"
runtimeEnv.PKG_CONFIG_PATH = "PKG_CONFIG_PATH"
lib.makeSearchPathOutput "dev" "lib/pkgconfig" (lib.makeSearchPathOutput "dev" "lib/pkgconfig" builds.bootvine.buildInputs)
builds.bootvine.buildInputs; ];
text = ''exec release-plz ${subcommand} --forge gitea --git-token "$CODEBERG_TOKEN"''; };
};
in in
sampleMachineApps sampleMachineApps
// ciTaskApps
// { // {
release-plz-release = releasePlzOnCodeberg "release" "Publish unpublished versions to crates.io and tag them with a Codeberg release";
release-plz-release-pr = releasePlzOnCodeberg "release-pr" "Open or update the Codeberg pull request that bumps the version and changelog";
record-screencasts = record-screencasts =
shellScriptApp "record-screencasts" repoTaskApp "record-screencasts"
"Re-record the scripted demo animations and the sample machine recordings into recordings/; publish them with publish-recordings" "Re-record the scripted demo animations and the sample machine recordings into recordings/; publish them with publish-recordings"
{ "record-screencasts --vm-check-outputs ${
runtimeInputs = [ pkgs.linkFarm "vm-check-outputs" (
pkgs.vhs lib.mapAttrs (machineName: _: self.checks.${system}."vm-${machineName}") vmTests.machines
pkgs.libwebp )
builds.scripted-demos }"
builds.repo-tasks [
]; pkgs.vhs
text = "exec xtask record-screencasts --vm-check-outputs ${ pkgs.libwebp
pkgs.linkFarm "vm-check-outputs" ( builds.scripted-demos
lib.mapAttrs (machineName: _: self.checks.${system}."vm-${machineName}") vmTests.machines ];
)
}";
};
publish-recordings = publish-recordings =
shellScriptApp "publish-recordings" repoTaskApp "publish-recordings"
"Replace the recordings branch on origin with a single commit holding recordings/" "Replace the recordings branch on origin with a single commit holding recordings/"
{ "publish-recordings"
runtimeInputs = [ [ pkgs.gitMinimal ];
pkgs.gitMinimal
builds.repo-tasks
];
text = "exec xtask publish-recordings";
};
build-and-push-to-cachix =
shellScriptApp "build-and-push-to-cachix"
"Build flake outputs and push everything built to the wvhulle Cachix cache"
{
runtimeInputs = [ pkgs.cachix ];
text = ''exec cachix watch-exec wvhulle -- nix build --print-build-logs "$@"'';
};
check-conventional-commits =
shellScriptApp "check-conventional-commits"
"Check that the commit messages in a git revision range are conventional commits"
{
runtimeInputs = [
pkgs.convco
pkgs.gitMinimal
];
text = ''exec convco check "$@"'';
};
} }
); );
checks = forEachSystem ( checks = forEachSystem (
{ pkgs, builds, ... }: { pkgs, builds, ... }:
{ {
inherit (builds) rustfmt-formatting clippy-lints; inherit (builds) clippy-lints;
bootvine-build = builds.bootvine; bootvine-build = builds.bootvine;
repo-tasks-build = builds.repo-tasks; repo-tasks-build = builds.repo-tasks;
} }
+120
View File
@@ -0,0 +1,120 @@
{
pkgs,
mkApp,
cargoToolchain ? null,
preCommitInputs ? [ ],
extraReleaseInputs ? [ ],
releaseWrapperArgs ? [ ],
}:
let
inherit (pkgs) lib;
cargoInputs = lib.optional (cargoToolchain != null) cargoToolchain;
nuScriptTool =
{
script,
name,
runtimeInputs ? [ ],
wrapperArgs ? [ ],
}:
pkgs.runCommand name
{
nativeBuildInputs = [ pkgs.makeBinaryWrapper ];
meta.mainProgram = name;
}
''
makeWrapper ${lib.getExe pkgs.nushell} $out/bin/${name} \
--add-flags ${script} \
--add-flags ${name} \
${lib.optionalString (runtimeInputs != [ ]) "--prefix PATH : ${lib.makeBinPath runtimeInputs}"} \
${lib.escapeShellArgs wrapperArgs}
'';
nixBuiltPathsTool = toolArgs: nuScriptTool (toolArgs // { script = ../ci/nix-built-paths.nu; });
exportBuiltPathsHook = nixBuiltPathsTool { name = "export-built-paths-hook"; };
exportingBuildApp =
name:
mkApp (nixBuiltPathsTool {
inherit name;
wrapperArgs = [
"--set"
"EXPORT_HOOK_PROGRAM"
(lib.getExe exportBuiltPathsHook)
];
});
releasePlzApp =
name:
mkApp (nuScriptTool {
inherit name;
script = ../ci/release-tasks.nu;
runtimeInputs =
cargoInputs
++ [
pkgs.release-plz
pkgs.gitMinimal
]
++ extraReleaseInputs;
wrapperArgs = releaseWrapperArgs;
});
releaseTaskApps =
lib.mapAttrs
(
name: runtimeInputs:
mkApp (nuScriptTool {
inherit name runtimeInputs;
script = ../ci/release-tasks.nu;
})
)
{
authenticate-git-origin = [ pkgs.gitMinimal ];
collect-release-archives = [ ];
upload-release-assets = [ pkgs.tea ];
check-commit-messages = [
pkgs.convco
pkgs.gitMinimal
];
};
preCommitHooksTool =
pkgs.runCommand "run-pre-commit-hooks"
{
nativeBuildInputs = [ pkgs.makeBinaryWrapper ];
meta.mainProgram = "run-pre-commit-hooks";
}
''
makeWrapper ${lib.getExe pkgs.prek} $out/bin/run-pre-commit-hooks \
--add-flags "run --all-files --show-diff-on-failure" \
--prefix PATH : ${lib.makeBinPath ([ pkgs.gitMinimal ] ++ preCommitInputs)}
'';
in
releaseTaskApps
// {
publish-unreleased-crate-version = releasePlzApp "publish-unreleased-crate-version";
open-or-update-release-pr = releasePlzApp "open-or-update-release-pr";
open-dependency-update-pr = mkApp (nuScriptTool {
name = "open-dependency-update-pr";
script = ../ci/dependency-updates.nu;
runtimeInputs = cargoInputs ++ [
pkgs.gitMinimal
pkgs.tea
];
});
run-pre-commit-hooks = mkApp preCommitHooksTool;
build-and-export-paths = exportingBuildApp "build-and-export-paths";
build-unless-cached = exportingBuildApp "build-unless-cached";
import-exported-paths = mkApp (nixBuiltPathsTool {
name = "import-exported-paths";
});
copy-build-output = mkApp (nixBuiltPathsTool {
name = "copy-build-output";
});
upload-exported-paths = mkApp (nixBuiltPathsTool {
name = "upload-exported-paths";
runtimeInputs = [ pkgs.cachix ];
});
}
+1 -4
View File
@@ -30,10 +30,7 @@ let
args: craneLib.buildPackage (commonArgs // { inherit cargoArtifacts; } // args); args: craneLib.buildPackage (commonArgs // { inherit cargoArtifacts; } // args);
in in
{ {
rustfmt-formatting = craneLib.cargoFmt { inherit cargoArtifacts;
inherit (commonArgs) src pname version;
cargoExtraArgs = "--all";
};
clippy-lints = craneLib.cargoClippy ( clippy-lints = craneLib.cargoClippy (
commonArgs commonArgs
+1 -2
View File
@@ -10,9 +10,8 @@ let
}; };
machineDescriptions = { machineDescriptions = {
slow-services = "slow and failing units, a held initrd probe and a greetd login"; slow-services = "slow and failing units, a held initrd probe and a tuigreet login";
text-console = "the slow units without a display manager, handing over at the default target"; text-console = "the slow units without a display manager, handing over at the default target";
scripted-initrd = "the slow units with the scripted initrd, so bootvine starts in stage 2";
encrypted-volume = "a LUKS volume unlocked in the initrd with the passphrase 'sample passphrase'"; encrypted-volume = "a LUKS volume unlocked in the initrd with the passphrase 'sample passphrase'";
failures = "units that fail in every way systemd reports, each with journal messages"; failures = "units that fail in every way systemd reports, each with journal messages";
hibernate-resume = "a swap disk to hibernate to, showing the kernel's image loading progress on resume"; hibernate-resume = "a swap disk to hibernate to, showing the kernel's image loading progress on resume";
+1 -4
View File
@@ -5,10 +5,7 @@
nodes.machine = nodes.machine =
{ lib, ... }: { lib, ... }:
{ {
imports = [ imports = [ machine ];
machine
(pkgs.path + "/nixos/tests/common/auto-format-root-device.nix")
];
boot.resumeDevice = "/dev/vdc"; boot.resumeDevice = "/dev/vdc";
swapDevices = lib.mkOverride 0 [ swapDevices = lib.mkOverride 0 [
-25
View File
@@ -1,25 +0,0 @@
{ machine, ... }:
{
name = "bootvine-scripted-initrd";
nodes.machine =
{ lib, ... }:
let
waitFor = flag: "/bin/sh -c 'until [ -e /run/${flag} ]; do sleep 0.1; done'";
in
{
imports = [
machine
../shared/recorded-display.nix
];
systemd.services = {
sample-database.serviceConfig.ExecStop = lib.mkForce (waitFor "release-sample-database");
backdoor.before = [ "sample-database.service" ];
};
};
testScript =
builtins.readFile ../shared/console.py
+ builtins.readFile ../shared/screen_recording.py
+ builtins.readFile ./check.py;
}
-28
View File
@@ -1,28 +0,0 @@
def unit_state(unit):
return machine.succeed(f"systemctl is-active {unit} || true").strip()
recording = ScreenRecording(machine)
machine.start()
recording.start()
wait_for_screen("Stage 2", "sample-database")
assert_bootvine_in_front()
assert_text_visible(font_has_512_glyphs=True)
machine.wait_for_unit("greetd.service")
retry(lambda _: unit_state("bootvine") == "inactive", timeout_seconds=60)
journal = bootvine_journal()
print(journal)
watched = [line for line in journal.splitlines() if line.startswith("bootvine: watching")]
assert watched, "bootvine never started"
assert not any(" in Initrd " in line for line in watched), "bootvine ran in a scripted initrd"
assert "handing the console over" in journal, "never handed the console over"
machine.succeed("systemctl poweroff --no-block")
retry(lambda _: unit_state("sample-database") == "deactivating", timeout_seconds=60)
wait_for_screen("Shutdown", "sample-database")
assert_bootvine_in_front()
machine.succeed("touch /run/release-sample-database")
machine.wait_for_shutdown()
recording.stop()
-6
View File
@@ -1,6 +0,0 @@
{ lib, ... }:
{
imports = [ ../slow-services/machine.nix ];
boot.initrd.systemd.enable = lib.mkForce false;
}
+1
View File
@@ -13,6 +13,7 @@
../shared/recorded-display.nix ../shared/recorded-display.nix
]; ];
testing.initrdBackdoor = true; testing.initrdBackdoor = true;
boot.kernelParams = lib.mkAfter [ "console=tty0" ];
boot.initrd.systemd.services.initrd-hardware-probe.serviceConfig.ExecStart = lib.mkForce ( boot.initrd.systemd.services.initrd-hardware-probe.serviceConfig.ExecStart = lib.mkForce (
waitFor "release-initrd-hardware-probe" waitFor "release-initrd-hardware-probe"
); );
+25 -1
View File
@@ -6,6 +6,17 @@ def unit_state(unit):
return machine.succeed(f"systemctl is-active {unit} || true").strip() return machine.succeed(f"systemctl is-active {unit} || true").strip()
def foreground_console_text():
terminal_number = foreground_terminal().removeprefix("tty")
return machine.succeed(f"tr -cd '[:print:]' < /dev/vcs{terminal_number}")
def assert_unit_start_stays_off_console(description):
machine.succeed(f"systemd-run --wait --description='{description}' /run/current-system/sw/bin/true")
console_text = foreground_console_text()
assert description not in console_text, f"systemd status reached the login screen:\n{console_text}"
recording = ScreenRecording(machine) recording = ScreenRecording(machine)
machine.start() machine.start()
recording.start() recording.start()
@@ -24,11 +35,17 @@ assert_text_visible(font_has_512_glyphs=True)
assert console_level() == "1", f"stage 2 sysctl reopened the kernel console: {console_level()}" assert console_level() == "1", f"stage 2 sysctl reopened the kernel console: {console_level()}"
machine.wait_for_unit("greetd.service") machine.wait_for_unit("greetd.service")
retry(lambda _: unit_state("bootvine") == "inactive", timeout_seconds=60) retry(lambda _: "another program took the console" in bootvine_journal(), timeout_seconds=60)
assert unit_state("late-sensor-probe") == "activating", "the boot finished before the display manager took over" assert unit_state("late-sensor-probe") == "activating", "the boot finished before the display manager took over"
assert foreground_terminal() != f"tty{BOOTVINE_TERMINAL}", "bootvine took the console back from the display manager" assert foreground_terminal() != f"tty{BOOTVINE_TERMINAL}", "bootvine took the console back from the display manager"
machine.wait_until_tty_matches("1", "Username:")
assert_unit_start_stays_off_console("Mid boot status probe")
show_status = machine.succeed("systemctl show -p ShowStatus --value").strip()
assert show_status == "no", f"systemd status output came back before the boot finished: {show_status}"
assert unit_state("bootvine") == "active", "bootvine left before the boot finished"
machine.succeed("touch /run/release-late-sensor-probe") machine.succeed("touch /run/release-late-sensor-probe")
machine.wait_for_unit("graphical.target") machine.wait_for_unit("graphical.target")
retry(lambda _: unit_state("bootvine") == "inactive", timeout_seconds=60)
journal = bootvine_journal() journal = bootvine_journal()
print(journal) print(journal)
@@ -43,6 +60,13 @@ machine.succeed('test "$(systemctl show -p Result --value bootvine)" = success')
assert console_level() != "1", f"kernel console level was not restored: {console_level()}" assert console_level() != "1", f"kernel console level was not restored: {console_level()}"
show_status = machine.succeed("systemctl show -p ShowStatus --value").strip() show_status = machine.succeed("systemctl show -p ShowStatus --value").strip()
assert show_status == "yes", f"systemd status output was not restored: {show_status}" assert show_status == "yes", f"systemd status output was not restored: {show_status}"
assert_unit_start_stays_off_console("Post boot status probe")
machine.wait_until_tty_matches("1", "Username:")
machine.send_chars("sample-user\n")
machine.wait_until_tty_matches("1", "Password:")
machine.send_chars("sample-user\n")
machine.wait_until_succeeds("pgrep -u sample-user bash", timeout=30)
foreground = foreground_terminal() foreground = foreground_terminal()
assert foreground != f"tty{BOOTVINE_TERMINAL}", "bootvine kept the console after handing it over" assert foreground != f"tty{BOOTVINE_TERMINAL}", "bootvine kept the console after handing it over"
+1 -1
View File
@@ -37,6 +37,6 @@ in
services.greetd = { services.greetd = {
enable = true; enable = true;
settings.default_session.command = "${pkgs.greetd}/bin/agreety --cmd ${pkgs.bashInteractive}/bin/bash"; settings.default_session.command = "${pkgs.tuigreet}/bin/tuigreet --time --cmd ${pkgs.bashInteractive}/bin/bash";
}; };
} }