7 files changed
--- a/cmds/fleet/src/main.rs
+++ b/cmds/fleet/src/main.rs
@@ -24,8 +24,7 @@
#[cfg(feature = "indicatif")]
use indicatif::{ProgressState, ProgressStyle};
use nix_eval::{
- add_file_to_store, gc_register_my_thread, gc_unregister_my_thread, init_libraries,
- init_tokio_for_nix,
+ eval_store, gc_register_my_thread, gc_unregister_my_thread, init_libraries, init_tokio_for_nix,
};
use opentelemetry::trace::TracerProvider;
use opentelemetry_appender_tracing::layer::OpenTelemetryTracingBridge;
@@ -33,6 +32,7 @@
OtlpBaseSettings, OtlpLogsSettings, OtlpTracesSettings, ResolvedOtlpSettings,
};
use opentelemetry_sdk::{logs::SdkLoggerProvider, trace::SdkTracerProvider};
+use tokio::task::spawn_blocking;
use tracing::{Instrument, error, info, info_span};
#[cfg(feature = "indicatif")]
use tracing_indicatif::IndicatifLayer;
@@ -59,7 +59,8 @@
Utf8PathBuf::try_from(entry.path()).context("prefetch path should be utf8")?;
let span = info_span!("prefetching", name = %name);
tasks.push(async move {
- let added = tokio::task::spawn_blocking(move || add_file_to_store(&name, &path))
+ let store = eval_store();
+ let added = spawn_blocking(move || store.add_file(&name, &path))
.instrument(span.clone())
.await??;
let _g = span.enter();
@@ -121,9 +122,7 @@
Opts::Prefetch(p) => p.run(config).await?,
Opts::Tf(t) => t.run(config).await?,
// TODO: actually parse commands before starting the async runtime
- Opts::Complete(c) => {
- tokio::task::spawn_blocking(move || c.run(RootOpts::command())).await?
- }
+ Opts::Complete(c) => spawn_blocking(move || c.run(RootOpts::command())).await?,
};
Ok(())
}
--- a/crates/fleet-base/src/host.rs
+++ b/crates/fleet-base/src/host.rs
@@ -13,7 +13,7 @@
use camino::{Utf8Path, Utf8PathBuf};
use chrono::{DateTime, Utc};
use fleet_shared::SecretData;
-use nix_eval::{Store, Value, nix_go, nix_go_json, util::assert_warn};
+use nix_eval::{Store, Value, eval_store, nix_go, nix_go_json, util::assert_warn};
use remowt_client::{AgentBundle, Remowt};
use remowt_endpoints::fs::FsClient;
use remowt_link_shared::Address;
@@ -427,8 +427,10 @@
let store = self.nix_store().await?;
{
let path = path.clone();
- spawn_blocking(move || nix_eval::copy_closure_to(&store, path.as_ref()))
- .await?
+ let store = eval_store();
+ spawn_blocking(move || store.copy_to(&store, path.as_ref()))
+ .await
+ .expect("copy_to panicked")
.context("copying closure to remote store")?;
}
Ok(path)
--- a/crates/nix-eval/src/drv.rs
+++ b/crates/nix-eval/src/drv.rs
@@ -1,41 +1,21 @@
use std::collections::{HashMap, HashSet, VecDeque};
-use std::ffi::CString;
use anyhow::{Result, bail};
+use camino::{Utf8Component, Utf8Path, Utf8PathBuf};
use serde::Deserialize;
use crate::nix_raw::{derivation_free, derivation_to_json, store_drv_from_store_path};
-use crate::{copy_nix_str, with_store_context};
-
-fn store_dir() -> Result<String> {
- let mut out = String::new();
- with_store_context(|c, store, _| unsafe {
- crate::nix_raw::store_get_storedir(c, store, Some(copy_nix_str), (&raw mut out).cast())
- })?;
- Ok(out)
-}
-
-fn to_absolute_store_path(store_dir: &str, path: &str) -> String {
- if path.starts_with('/') {
- path.to_owned()
- } else {
- format!("{store_dir}/{path}")
- }
-}
+use crate::{Store, copy_nix_str, with_default_context};
pub struct Derivation(*mut crate::nix_raw::derivation);
unsafe impl Send for Derivation {}
impl Derivation {
- pub fn from_path(drv_path: &str) -> Result<Self> {
- let path_c = CString::new(drv_path)?;
- let store_path = with_store_context(|c, store, _| unsafe {
- crate::nix_raw::store_parse_path(c, store, path_c.as_ptr())
- })?;
- let drv = with_store_context(|c, store, _| unsafe {
- store_drv_from_store_path(c, store, store_path)
+ pub fn from_path(store: &Store, drv_path: &Utf8Path) -> Result<Self> {
+ let store_path = store.parse_path(drv_path)?;
+ let drv = with_default_context(|c, _| unsafe {
+ store_drv_from_store_path(c, store.as_ptr(), store_path.as_ptr())
});
- unsafe { crate::nix_raw::store_path_free(store_path) };
let drv = drv?;
if drv.is_null() {
bail!("failed to read derivation from {drv_path}");
@@ -45,7 +25,7 @@
pub fn to_json_string(&self) -> Result<String> {
let mut out = String::new();
- with_store_context(|c, _, _| unsafe {
+ with_default_context(|c, _| unsafe {
derivation_to_json(c, self.0, Some(copy_nix_str), (&raw mut out).cast())
})?;
Ok(out)
@@ -78,9 +58,9 @@
#[derive(Debug, Deserialize)]
pub struct DrvInputs {
#[serde(default)]
- pub srcs: Vec<String>,
+ pub srcs: Vec<Utf8PathBuf>,
#[serde(default)]
- pub drvs: HashMap<String, DrvInputEntry>,
+ pub drvs: HashMap<Utf8PathBuf, DrvInputEntry>,
}
#[derive(Debug, Deserialize)]
@@ -90,23 +70,23 @@
#[derive(Debug, Clone)]
pub struct DrvGraph {
- pub root: String,
- pub nodes: HashMap<String, DrvNode>,
+ pub root: Utf8PathBuf,
+ pub nodes: HashMap<Utf8PathBuf, DrvNode>,
}
#[derive(Debug, Clone)]
pub struct DrvNode {
pub name: String,
- pub input_drvs: HashMap<String, Vec<String>>,
- pub input_srcs: Vec<String>,
+ pub input_drvs: HashMap<Utf8PathBuf, Vec<String>>,
+ pub input_srcs: Vec<Utf8PathBuf>,
// TODO: CA outputs without a known paths are skipped
- pub outputs: HashMap<String, String>,
+ pub outputs: HashMap<String, Utf8PathBuf>,
}
impl DrvGraph {
- pub fn resolve(drv_path: &str) -> Result<Self> {
- let sd = store_dir()?;
- let root = to_absolute_store_path(&sd, drv_path);
+ pub fn resolve(store: &Store, drv_path: &Utf8Path) -> Result<Self> {
+ let sd = store.store_dir()?;
+ let root = sd.join(drv_path);
let mut nodes = HashMap::new();
let mut queue = VecDeque::new();
@@ -115,14 +95,14 @@
visited.insert(root.clone());
while let Some(path) = queue.pop_front() {
- let drv = Derivation::from_path(&path)?;
+ let drv = Derivation::from_path(store, &path)?;
let parsed = drv.parsed()?;
- let input_drvs: HashMap<String, Vec<String>> = parsed
+ let input_drvs: HashMap<Utf8PathBuf, Vec<String>> = parsed
.inputs
.drvs
.into_iter()
- .map(|(k, v)| (to_absolute_store_path(&sd, &k), v.outputs))
+ .map(|(k, v)| (sd.join(&k), v.outputs))
.collect();
for dep_path in input_drvs.keys() {
@@ -131,10 +111,10 @@
}
}
- let outputs: HashMap<String, String> = parsed
+ let outputs: HashMap<String, Utf8PathBuf> = parsed
.outputs
.into_iter()
- .filter_map(|(name, out)| out.path.map(|p| (name, to_absolute_store_path(&sd, &p))))
+ .filter_map(|(name, out)| out.path.map(|p| (name, sd.join(&p))))
.collect();
nodes.insert(
@@ -151,11 +131,11 @@
Ok(Self { root, nodes })
}
- pub fn wanted_outputs(&self, root_outputs: &[String]) -> HashMap<String, Vec<String>> {
- let mut wanted: HashMap<String, HashSet<String>> = HashMap::new();
+ pub fn wanted_outputs(&self, root_outputs: &[String]) -> HashMap<Utf8PathBuf, Vec<String>> {
+ let mut wanted: HashMap<Utf8PathBuf, HashSet<String>> = HashMap::new();
wanted.insert(self.root.clone(), root_outputs.iter().cloned().collect());
- let mut queue: VecDeque<String> = VecDeque::new();
+ let mut queue: VecDeque<Utf8PathBuf> = VecDeque::new();
queue.push_back(self.root.clone());
while let Some(path) = queue.pop_front() {
let Some(node) = self.nodes.get(&path) else {
@@ -186,12 +166,19 @@
}
}
-fn extract_drv_name(drv_path: &str) -> String {
- drv_path
- .rsplit('/')
+pub fn extract_drv_name(drv_path: &Utf8Path) -> String {
+ let comp = drv_path
+ .components()
+ .rev()
.next()
- .and_then(|f| f.strip_suffix(".drv"))
- .and_then(|f| f.split_once('-').map(|(_, name)| name))
- .unwrap_or(drv_path)
- .to_owned()
+ .expect("drv path is at least one component");
+ let Utf8Component::Normal(n) = comp else {
+ panic!("drv path is normal");
+ };
+
+ let n = n.strip_suffix(".drv").unwrap_or(n);
+
+ let n = n.split_once(' ').map(|(_, n)| n).unwrap_or(n);
+
+ n.to_owned()
}
--- a/crates/nix-eval/src/lib.rs
+++ b/crates/nix-eval/src/lib.rs
@@ -25,7 +25,7 @@
PrimOpFun, Store as c_store, StorePath as c_store_path, alloc_primop, alloc_value,
bindings_builder_free, bindings_builder_insert, c_context, c_context_create, c_context_free,
clear_err, copy_value, err_NIX_ERR_KEY, err_NIX_ERR_NIX_ERROR, err_NIX_ERR_OVERFLOW,
- err_NIX_ERR_UNKNOWN, err_code, err_info_msg, err_msg, eval_state_build,
+ err_NIX_ERR_UNKNOWN, err_NIX_OK, err_code, err_info_msg, err_msg, eval_state_build,
eval_state_builder_load, eval_state_builder_new, eval_state_builder_set_eval_setting,
expr_eval_from_string, fetchers_settings, fetchers_settings_free, fetchers_settings_new,
flake_lock, flake_lock_flags, flake_lock_flags_free, flake_lock_flags_new, flake_reference,
@@ -320,15 +320,16 @@
struct GlobalState {
// Store should be valid as long as EvalState is valid
#[allow(dead_code)]
- store: Store,
+ store: Arc<Store>,
state: EvalState,
}
impl GlobalState {
fn new() -> Result<Self> {
let mut ctx = NixContext::new();
- let store = ctx
- .run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })
- .map(Store)?;
+ let store = Arc::new(
+ ctx.run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })
+ .map(Store)?,
+ );
let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;
ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;
@@ -385,66 +386,8 @@
v
}
-/// Same as with_default_context, but also passes store...
-/// Yep, this code is garbage and needs to be refactored.
-pub(crate) fn with_store_context<T>(
- f: impl FnOnce(*mut c_context, *mut c_store, *mut c_eval_state) -> T,
-) -> Result<T> {
- let global = &GLOBAL_STATE;
- let (ctx, store, state) =
- THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.store.0, global.state.0));
- let mut ctx = NixContext(ctx);
- let v = ctx.run_in_context(|c| f(c, store, state));
- std::mem::forget(ctx);
- v
-}
-
pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {
with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())
-}
-
-#[instrument(skip(dst))]
-pub fn copy_closure_to(dst: &Store, path: &Utf8Path) -> Result<()> {
- let path_c = CString::new(path.as_str())?;
- with_store_context(|c, src_store, _state| -> Result<()> {
- let sp = unsafe { store_parse_path(c, src_store, path_c.as_ptr()) };
- if sp.is_null() {
- bail!("failed to parse store path {path}");
- }
- let rc = unsafe { store_copy_closure(c, src_store, dst.0, sp) };
- unsafe { store_path_free(sp) };
- if rc != nix_raw::err_NIX_OK {
- bail!("store_copy_closure failed (code {rc})");
- }
- Ok(())
- })?
-}
-
-#[instrument]
-pub fn switch_profile(profile: &str, store_path: &Utf8Path) -> Result<()> {
- let msg = with_store_context(|_c, store, _state| unsafe {
- nix_cxx::switch_profile(store.cast(), profile, store_path.as_str())
- })?
- .to_string();
- if msg.is_empty() {
- Ok(())
- } else {
- bail!("failed to switch profile {profile}: {msg}");
- }
-}
-
-// TODO: fleet operator-managed key file
-#[instrument]
-pub fn sign_closure(store_path: &str, key_file: &str) -> Result<()> {
- let msg = with_store_context(|_c, store, _state| unsafe {
- nix_cxx::sign_closure(store.cast(), store_path, key_file)
- })?
- .to_string();
- if msg.is_empty() {
- Ok(())
- } else {
- bail!("failed to sign {store_path}: {msg}");
- }
}
#[derive(Debug)]
@@ -480,48 +423,8 @@
current: g.current,
})
.collect())
-}
-
-#[instrument]
-pub fn add_file_to_store(name: &str, path: &Utf8Path) -> Result<AddedFile> {
- let res = with_store_context(|_c, store, _state| unsafe {
- nix_cxx::add_file_to_store(store.cast(), name, path.as_str())
- })?;
- if !res.error.is_empty() {
- bail!("failed to add {path} to store: {}", res.error);
- }
- Ok(AddedFile {
- store_path: Utf8PathBuf::from(res.store_path),
- hash: res.hash,
- })
-}
-
-pub fn build_drv_outputs(drv_path: &str, output_names: &[String]) -> Result<Vec<String>> {
- let joined = output_names.join("\n");
- let res = with_store_context(|_c, store, _state| unsafe {
- nix_cxx::build_drv_outputs(store.cast(), drv_path, &joined)
- })?;
- if !res.error.is_empty() {
- bail!("build of {drv_path} failed: {}", res.error);
- }
- Ok(res.outputs)
}
-pub fn substitute_paths(paths: &[String]) -> Result<Vec<String>> {
- let joined = paths.join("\n");
- let res = with_store_context(|_c, store, _state| unsafe {
- nix_cxx::substitute_paths(store.cast(), &joined)
- })?;
- if !res.error.is_empty() {
- warn!("substitute_paths reported: {}", res.error);
- }
- Ok(res.outputs)
-}
-
-pub fn is_valid_path(path: &str) -> Result<bool> {
- with_store_context(|_c, store, _state| unsafe { nix_cxx::is_valid_path(store.cast(), path) })
-}
-
pub struct FetchSettings(*mut fetchers_settings);
impl FetchSettings {
pub fn new() -> Self {
@@ -624,6 +527,10 @@
unsafe impl Send for Store {}
unsafe impl Sync for Store {}
+pub fn eval_store() -> Arc<Store> {
+ GLOBAL_STATE.store.clone()
+}
+
impl Store {
pub fn open(uri: &str) -> Result<Self> {
let uri = CString::new(uri)?;
@@ -634,11 +541,108 @@
Ok(Store(ptr))
}
- fn parse_path(&self, path: &CStr) -> Result<StorePath> {
+ pub fn parse_path(&self, path: &Utf8Path) -> Result<StorePath> {
+ let path = CString::new(path.as_str()).expect("valid cstr");
with_default_context(|c, _| {
StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })
})
}
+
+ #[instrument(skip(self))]
+ pub fn sign_closure(&self, path: &Utf8Path, key_file: &Utf8Path) -> Result<()> {
+ let err = with_default_context(|_, _| unsafe {
+ nix_cxx::sign_closure(self.as_ptr().cast(), path.as_str(), key_file.as_str())
+ })?
+ .to_string();
+
+ if err.is_empty() {
+ Ok(())
+ } else {
+ bail!("failed to sign {path}: {err}");
+ }
+ }
+
+ #[instrument(skip(self, dst))]
+ pub fn copy_to(&self, dst: &Store, path: &Utf8Path) -> Result<()> {
+ let sp = self
+ .parse_path(&path)
+ .context("failed to parse store path")?;
+ let rc = with_default_context(|c, _| unsafe {
+ store_copy_closure(c, self.as_ptr(), dst.0, sp.as_ptr())
+ })?;
+ if rc != err_NIX_OK {
+ bail!("store_copy_closure failed (code {rc})");
+ }
+ Ok(())
+ }
+
+ /// Would only work with local store.
+ #[instrument(skip(self))]
+ pub fn switch_profile(&self, profile: &str, path: &Utf8Path) -> Result<()> {
+ let msg = unsafe { nix_cxx::switch_profile(self.as_ptr().cast(), profile, path.as_str()) };
+ if msg.is_empty() {
+ Ok(())
+ } else {
+ bail!("failed to switch profile {profile}: {msg}");
+ }
+ }
+
+ #[instrument(skip(self))]
+ pub fn add_file(&self, name: &str, path: &Utf8Path) -> Result<AddedFile> {
+ let msg = unsafe { nix_cxx::add_file_to_store(self.as_ptr().cast(), name, path.as_str()) };
+ if !msg.error.is_empty() {
+ bail!("failed to add {path} to store: {}", msg.error)
+ }
+ Ok(AddedFile {
+ store_path: Utf8PathBuf::from(msg.store_path),
+ hash: msg.hash,
+ })
+ }
+
+ #[instrument(skip(self))]
+ pub fn substitute_paths(&self, paths: &[Utf8PathBuf]) -> Result<Vec<Utf8PathBuf>> {
+ let joined = paths.into_iter().join("\n");
+ let res = unsafe { nix_cxx::substitute_paths(self.as_ptr().cast(), &joined) };
+ if !res.error.is_empty() {
+ warn!("substitute_paths reported: {}", res.error);
+ }
+ Ok(res.outputs.into_iter().map(Utf8PathBuf::from).collect())
+ }
+
+ #[instrument(skip(self))]
+ pub fn is_valid_path(&self, path: &Utf8Path) -> bool {
+ unsafe { nix_cxx::is_valid_path(self.as_ptr().cast(), path.as_str()) }
+ }
+
+ #[instrument(skip(self))]
+ pub fn build_drv_outputs(
+ &self,
+ drv_path: &Utf8Path,
+ output_names: &[String],
+ ) -> Result<Vec<String>> {
+ let joined = output_names.join("\n");
+ let res =
+ unsafe { nix_cxx::build_drv_outputs(self.as_ptr().cast(), drv_path.as_str(), &joined) };
+ if !res.error.is_empty() {
+ bail!("build of {drv_path} failed: {}", res.error);
+ }
+ Ok(res.outputs)
+ }
+
+ #[instrument(skip(self))]
+ pub fn store_dir(&self) -> Result<Utf8PathBuf> {
+ let mut out = String::new();
+ with_default_context(|c, es| unsafe {
+ nix_raw::store_get_storedir(c, self.as_ptr(), Some(copy_nix_str), (&raw mut out).cast())
+ })?;
+ let p = Utf8PathBuf::from(out);
+ assert!(p.is_absolute());
+ Ok(p)
+ }
+
+ fn as_ptr(&self) -> *mut c_store {
+ self.0
+ }
}
impl Drop for Store {
fn drop(&mut self) {
@@ -1060,11 +1064,12 @@
self.clone()
};
- let drv_path = v
- .get_field("drvPath")
- .context("getting drvPath")?
- .to_string()?;
- let graph = Arc::new(drv::DrvGraph::resolve(&drv_path)?);
+ let drv_path = Utf8PathBuf::from(
+ v.get_field("drvPath")
+ .context("getting drvPath")?
+ .to_string()?,
+ );
+ let graph = Arc::new(drv::DrvGraph::resolve(&eval_store(), &drv_path)?);
let _guard = logging::register_build_graph(&Span::current(), &graph);
scheduler::build_graph_sync(graph.clone(), vec![output.to_owned()])?;
@@ -1255,8 +1260,12 @@
}
}
-struct StorePath(*mut c_store_path);
-impl StorePath {}
+pub struct StorePath(*mut c_store_path);
+impl StorePath {
+ fn as_ptr(&self) -> *mut c_store_path {
+ self.0
+ }
+}
impl Drop for StorePath {
fn drop(&mut self) {
--- a/crates/nix-eval/src/logging.rs
+++ b/crates/nix-eval/src/logging.rs
@@ -2,6 +2,7 @@
use std::fmt::Arguments;
use std::sync::{LazyLock, Mutex};
+use camino::{Utf8Path, Utf8PathBuf};
use cxx::ExternType;
use tracing::{
Level, Span, debug, debug_span, error, error_span, info, info_span, trace, trace_span, warn,
@@ -11,6 +12,8 @@
use tracing_indicatif::span_ext::IndicatifSpanExt as _;
use vte::Parser;
+use crate::drv::extract_drv_name;
+
#[derive(Debug)]
enum ActivityType {
Unknown = 0,
@@ -33,20 +36,13 @@
a.strip_prefix(pref)?.strip_suffix(suff)
}
-fn parse_path(path: &str) -> &str {
- strip_prefix_suffix(path, "\x1b[35;1m", "\x1b[0m").unwrap_or(path)
+fn parse_path(path: &str) -> Utf8PathBuf {
+ Utf8PathBuf::from(strip_prefix_suffix(path, "\x1b[35;1m", "\x1b[0m").unwrap_or(path))
}
-fn parse_drv(drv: &str) -> &str {
+fn parse_drv(drv: &str) -> String {
let drv = parse_path(drv);
- if let Some(pkg) = drv.strip_prefix("/nix/store/") {
- let mut it = pkg.splitn(2, '-');
- it.next();
- if let Some(pkg) = it.next() {
- return pkg;
- }
- }
- drv
+ extract_drv_name(&drv)
}
fn parse_host(host: &str) -> &str {
if host.is_empty() || host == "local" {
@@ -287,19 +283,19 @@
struct DrvGraphEntry {
name: String,
- parent: Option<String>,
+ parent: Option<Utf8PathBuf>,
span: Option<Span>,
refcount: usize,
}
-static DRV_GRAPH: LazyLock<Mutex<HashMap<String, DrvGraphEntry>>> =
+static DRV_GRAPH: LazyLock<Mutex<HashMap<Utf8PathBuf, DrvGraphEntry>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
-static ACTIVITY_TO_DRV: LazyLock<Mutex<HashMap<u64, String>>> =
+static ACTIVITY_TO_DRV: LazyLock<Mutex<HashMap<u64, Utf8PathBuf>>> =
LazyLock::new(|| Mutex::new(HashMap::new()));
pub struct BuildGraphGuard {
- paths: Vec<String>,
+ paths: Vec<Utf8PathBuf>,
}
impl Drop for BuildGraphGuard {
@@ -369,7 +365,7 @@
BuildGraphGuard { paths }
}
-fn ensure_drv_span(drv_path: &str) -> Option<Span> {
+fn ensure_drv_span(drv_path: &Utf8Path) -> Option<Span> {
let mut drv_graph = DRV_GRAPH.lock().expect("not poisoned");
if let Some(span) = drv_graph.get(drv_path).and_then(|e| e.span.clone()) {
@@ -442,7 +438,7 @@
self.fields.first().and_then(|f| match f {
FieldValue::Str(drv_path) => {
let clean = parse_path(drv_path);
- let span = ensure_drv_span(clean);
+ let span = ensure_drv_span(&clean);
if span.is_some() {
ACTIVITY_TO_DRV
.lock()
1use std::collections::{HashMap, HashSet};1use std::collections::{HashMap, HashSet};
2use std::mem;
2use std::sync::Arc;3use std::sync::Arc;
34
4use anyhow::{Context, Result, bail};5use anyhow::{Context, Result, bail};
6use camino::{Utf8Path, Utf8PathBuf};
5use futures::stream::{FuturesUnordered, StreamExt};7use futures::stream::{FuturesUnordered, StreamExt};
6use tokio::sync::{Semaphore, broadcast};8use tokio::sync::{Semaphore, broadcast};
9use tokio::task::spawn_blocking;
7use tracing::{debug, info, instrument, warn};10use tracing::{debug, info, instrument, warn};
811
9use crate::drv::DrvGraph;12use crate::drv::DrvGraph;
13use crate::{Store, eval_store};
1014
11#[derive(Clone, Debug)]15#[derive(Clone, Debug)]
12pub enum BuildEvent {16pub enum BuildEvent {
17 satisfied: usize,21 satisfied: usize,
18 },22 },
19 DrvStarted {23 DrvStarted {
20 drv_path: String,24 drv_path: Utf8PathBuf,
21 name: String,25 name: String,
22 wanted: Vec<String>,26 wanted: Vec<String>,
23 },27 },
24 DrvSkipped {28 DrvSkipped {
25 drv_path: String,29 drv_path: Utf8PathBuf,
26 name: String,30 name: String,
27 },31 },
28 DrvFinished {32 DrvFinished {
29 drv_path: String,33 drv_path: Utf8PathBuf,
30 name: String,34 name: String,
31 },35 },
32 DrvFailed {36 DrvFailed {
33 drv_path: String,37 drv_path: Utf8PathBuf,
34 name: String,38 name: String,
35 error: String,39 error: String,
36 },40 },
37 DrvCancelled {41 DrvCancelled {
38 drv_path: String,42 drv_path: Utf8PathBuf,
39 name: String,43 name: String,
40 failed_dep: String,44 failed_dep: Utf8PathBuf,
41 },45 },
42}46}
4347
44pub struct Scheduler {48pub struct Scheduler {
49 store: Arc<Store>,
45 parallelism: usize,50 parallelism: usize,
46 events: broadcast::Sender<BuildEvent>,51 events: broadcast::Sender<BuildEvent>,
47}52}
51 let parallelism = parallelism.max(1);56 let parallelism = parallelism.max(1);
52 let (events, _) = broadcast::channel(1024);57 let (events, _) = broadcast::channel(1024);
53 Self {58 Self {
59 store: eval_store(),
54 parallelism,60 parallelism,
55 events,61 events,
56 }62 }
71 async fn substitute_prepass(77 async fn substitute_prepass(
72 &self,78 &self,
73 graph: &DrvGraph,79 graph: &DrvGraph,
74 wanted: &HashMap<String, Vec<String>>,80 wanted: &HashMap<Utf8PathBuf, Vec<String>>,
75 ) -> Result<()> {81 ) -> Result<()> {
76 let paths = collect_substitute_paths(graph, wanted);82 let paths = collect_substitute_paths(graph, wanted);
77 if paths.is_empty() {83 if paths.is_empty() {
82 .send(BuildEvent::SubstitutePrepassStarted { paths: paths.len() });88 .send(BuildEvent::SubstitutePrepassStarted { paths: paths.len() });
83 debug!("substitute pre-pass: {} paths", paths.len());89 debug!("substitute pre-pass: {} paths", paths.len());
8490
91 let store = self.store.clone();
85 let satisfied = tokio::task::spawn_blocking(move || crate::substitute_paths(&paths))92 let satisfied = spawn_blocking(move || store.substitute_paths(&paths))
86 .await93 .await
87 .expect("substitute pre-pass task should not panic")?;94 .expect("substitute pre-pass task should not panic")?;
8895
95 async fn build_topo(102 async fn build_topo(
96 &self,103 &self,
97 graph: &Arc<DrvGraph>,104 graph: &Arc<DrvGraph>,
98 wanted: HashMap<String, Vec<String>>,105 wanted: HashMap<Utf8PathBuf, Vec<String>>,
99 ) -> Result<()> {106 ) -> Result<()> {
100 let mut indeg: HashMap<String, usize> = graph107 let mut indeg: HashMap<Utf8PathBuf, usize> = graph
101 .nodes108 .nodes
102 .iter()109 .iter()
103 .map(|(k, n)| (k.clone(), n.input_drvs.len()))110 .map(|(k, n)| (k.clone(), n.input_drvs.len()))
104 .collect();111 .collect();
105 let mut dependents: HashMap<String, Vec<String>> = HashMap::new();112 let mut dependents: HashMap<Utf8PathBuf, Vec<Utf8PathBuf>> = HashMap::new();
106 for (path, node) in &graph.nodes {113 for (path, node) in &graph.nodes {
107 for dep in node.input_drvs.keys() {114 for dep in node.input_drvs.keys() {
108 dependents115 dependents
113 }120 }
114121
115 let sem = Arc::new(Semaphore::new(self.parallelism));122 let sem = Arc::new(Semaphore::new(self.parallelism));
116 let mut ready: Vec<String> = indeg123 let mut ready: Vec<Utf8PathBuf> = indeg
117 .iter()124 .iter()
118 .filter(|(_, d)| **d == 0)125 .filter(|(_, d)| **d == 0)
119 .map(|(k, _)| k.clone())126 .map(|(k, _)| k.clone())
120 .collect();127 .collect();
121 let mut in_flight = FuturesUnordered::new();128 let mut in_flight = FuturesUnordered::new();
122 let mut failed: HashMap<String, String> = HashMap::new();129 let mut failed: HashMap<Utf8PathBuf, String> = HashMap::new();
123 130
124 let mut tainted: HashMap<String, String> = HashMap::new();131 let mut tainted: HashMap<Utf8PathBuf, Utf8PathBuf> = HashMap::new();
125132
126 loop {133 loop {
127 let batch: Vec<String> = std::mem::take(&mut ready);134 let batch: Vec<Utf8PathBuf> = mem::take(&mut ready);
128 for path in batch {135 for path in batch {
129 if let Some(failed_dep) = tainted.get(&path) {136 if let Some(failed_dep) = tainted.get(&path) {
130 let name = graph137 let name = graph
145 let events = self.events.clone();152 let events = self.events.clone();
146 let graph = graph.clone();153 let graph = graph.clone();
147 let wanted_here = wanted.get(&path).cloned().unwrap_or_default();154 let wanted_here = wanted.get(&path).cloned().unwrap_or_default();
155 let store = self.store.clone();
148 in_flight.push(tokio::spawn(async move {156 in_flight.push(tokio::spawn(async move {
149 let _permit = sem.acquire_owned().await.expect("semaphore not closed");157 let _permit = sem.acquire_owned().await.expect("semaphore not closed");
150 let node = graph158 let node = graph
158 && wanted_here.iter().all(|o| {166 && wanted_here.iter().all(|o| {
159 node.outputs167 node.outputs
160 .get(o)168 .get(o)
161 .map(|p| crate::is_valid_path(p).unwrap_or(false))169 .map(|p| store.is_valid_path(p))
162 .unwrap_or(false)170 .unwrap_or(false)
163 });171 });
164 if all_valid {172 if all_valid {
176 });184 });
177185
178 let path_for_build = path.clone();186 let path_for_build = path.clone();
187 let store = store.clone();
179 let res = tokio::task::spawn_blocking(move || {188 let res = spawn_blocking(move || {
180 crate::build_drv_outputs(&path_for_build, &wanted_here)189 store.build_drv_outputs(&path_for_build, &wanted_here)
181 })190 })
182 .await191 .await
183 .expect("build task should not panic");192 .expect("build task should not panic");
259}268}
260269
261fn propagate_done(270fn propagate_done(
262 dependents: &HashMap<String, Vec<String>>,271 dependents: &HashMap<Utf8PathBuf, Vec<Utf8PathBuf>>,
263 indeg: &mut HashMap<String, usize>,272 indeg: &mut HashMap<Utf8PathBuf, usize>,
264 ready: &mut Vec<String>,273 ready: &mut Vec<Utf8PathBuf>,
265 finished: &str,274 finished: &Utf8Path,
266) {275) {
267 if let Some(deps) = dependents.get(finished) {276 if let Some(deps) = dependents.get(finished) {
268 for d in deps {277 for d in deps {
276}285}
277286
278fn mark_tainted(287fn mark_tainted(
279 dependents: &HashMap<String, Vec<String>>,288 dependents: &HashMap<Utf8PathBuf, Vec<Utf8PathBuf>>,
280 failed: &str,289 failed: &Utf8Path,
281 tainted: &mut HashMap<String, String>,290 tainted: &mut HashMap<Utf8PathBuf, Utf8PathBuf>,
282) {291) {
283 let mut queue: Vec<String> = dependents.get(failed).cloned().unwrap_or_default();292 let mut queue: Vec<Utf8PathBuf> = dependents.get(failed).cloned().unwrap_or_default();
284 while let Some(node) = queue.pop() {293 while let Some(node) = queue.pop() {
285 if tainted294 if tainted
286 .entry(node.clone())295 .entry(node.clone())
298 }307 }
299}308}
300309
301fn path_to_root(graph: &DrvGraph, from: &str) -> Vec<String> {310fn path_to_root(graph: &DrvGraph, from: &Utf8Path) -> Vec<String> {
302 let mut dependents: HashMap<&str, Vec<&str>> = HashMap::new();311 let mut dependents: HashMap<&Utf8Path, Vec<&Utf8Path>> = HashMap::new();
303 for (path, node) in &graph.nodes {312 for (path, node) in &graph.nodes {
304 for dep in node.input_drvs.keys() {313 for dep in node.input_drvs.keys() {
305 dependents314 dependents.entry(dep).or_default().push(path);
306 .entry(dep.as_str())
307 .or_default()
308 .push(path.as_str());
309 }315 }
310 }316 }
311317
312 let mut chain: Vec<String> = vec![node_name(graph, from)];318 let mut chain: Vec<String> = vec![node_name(graph, from)];
313 let mut cur = from;319 let mut cur = from;
314 let mut seen: HashSet<&str> = HashSet::new();320 let mut seen: HashSet<&Utf8Path> = HashSet::new();
315 seen.insert(cur);321 seen.insert(cur);
316 while cur != graph.root.as_str() {322 while cur != graph.root.as_str() {
317 let Some(next) = dependents.get(cur).and_then(|v| v.first().copied()) else {323 let Some(next) = dependents.get(cur).and_then(|v| v.first().copied()) else {
326 chain332 chain
327}333}
328334
329fn node_name(graph: &DrvGraph, path: &str) -> String {335fn node_name(graph: &DrvGraph, path: &Utf8Path) -> String {
330 graph336 graph
331 .nodes337 .nodes
332 .get(path)338 .get(path)
333 .map(|n| n.name.clone())339 .map(|n| n.name.clone())
334 .unwrap_or_else(|| path.to_owned())340 .unwrap_or_else(|| path.to_string())
335}341}
336342
337fn collect_substitute_paths(343fn collect_substitute_paths(
338 graph: &DrvGraph,344 graph: &DrvGraph,
339 wanted: &HashMap<String, Vec<String>>,345 wanted: &HashMap<Utf8PathBuf, Vec<String>>,
340) -> Vec<String> {346) -> Vec<Utf8PathBuf> {
341 let mut paths: HashSet<String> = HashSet::new();347 let mut paths: HashSet<Utf8PathBuf> = HashSet::new();
342 for node in graph.nodes.values() {348 for node in graph.nodes.values() {
343 for src in &node.input_srcs {349 for src in &node.input_srcs {
344 paths.insert(src.clone());350 paths.insert(src.clone());
--- a/crates/remowt-fleet/src/lib.rs
+++ b/crates/remowt-fleet/src/lib.rs
@@ -1,13 +1,15 @@
use std::path::PathBuf;
use anyhow::{Context as _, Result};
+use bifrostlink::declarative::endpoints;
use bifrostlink::Config;
-use bifrostlink::declarative::endpoints;
use camino::Utf8PathBuf;
+use nix_eval::eval_store;
use remowt_client::Remowt;
use remowt_endpoints::nix_daemon::NixDaemonClient;
use serde::{Deserialize, Serialize};
use tokio::net::UnixListener;
+use tokio::task::spawn_blocking;
use tracing::error;
pub struct Nix;
@@ -35,9 +37,10 @@
profile: String,
store_path: Utf8PathBuf,
) -> Result<(), NixError> {
- tokio::task::spawn_blocking(move || nix_eval::switch_profile(&profile, &store_path))
+ let store = eval_store();
+ spawn_blocking(move || store.switch_profile(&profile, &store_path))
.await
- .map_err(|e| NixError::Profile(e.to_string()))?
+ .expect("switch_profile panicked")
.map_err(|e| NixError::Profile(e.to_string()))
}
@@ -47,11 +50,12 @@
store_path: Utf8PathBuf,
key_file: Utf8PathBuf,
) -> Result<(), NixError> {
- tokio::task::spawn_blocking(move || {
- nix_eval::sign_closure(store_path.as_str(), key_file.as_str())
+ spawn_blocking(move || {
+ let store = eval_store();
+ store.sign_closure(&store_path, &key_file)
})
.await
- .map_err(|e| NixError::Sign(e.to_string()))?
+ .expect("store signing panicked")
.map_err(|e| NixError::Sign(e.to_string()))
}
@@ -60,11 +64,11 @@
&self,
profile: String,
) -> Result<Vec<nix_eval::ProfileGeneration>, NixError> {
- tokio::task::spawn_blocking(move || {
+ spawn_blocking(move || {
nix_eval::list_generations(&format!("/nix/var/nix/profiles/{profile}"))
})
.await
- .map_err(|e| NixError::ListGenerations(e.to_string()))?
+ .expect("generation listing panicked")
.map_err(|e| NixError::ListGenerations(e.to_string()))
}
}