git.delta.rocks / jrsonnet / refs/commits / 771ccbb734d6

--- a/crates/fleet-base/src/opts.rs
+++ b/crates/fleet-base/src/opts.rs
@@ -7,7 +7,10 @@
 };
 
 use anyhow::{Context, Result, bail};
-use nix_eval::{FetchSettings, FlakeReference, FlakeSettings, Value, nix_go, util::assert_warn};
+use nix_eval::{
+	FetchSettings, FlakeReference, FlakeReferenceParseFlags, FlakeSettings, Value, nix_go,
+	util::assert_warn,
+};
 use nom::{
 	Parser,
 	bytes::complete::take_while1,
@@ -213,16 +216,21 @@
 		let mut fetch_settings = FetchSettings::new();
 		fetch_settings.set(c"warn-dirty", c"false");
 
-		// TODO: use correct directory, not cwd
+		let mut flake_settings = FlakeSettings::new()?;
+		let mut parse = FlakeReferenceParseFlags::new(&flake_settings)?;
+		// For some reason, lazy trees not being used when there is no base dir set
+		parse.set_base_dir("/")?;
+
 		let (mut flake, _) = FlakeReference::new(
 			directory
 				.to_str()
 				.ok_or_else(|| anyhow::anyhow!("fleet dir should have utf-8 path"))?,
+			&flake_settings,
+			&parse,
 			&fetch_settings,
 		)?;
 		let flake = flake.lock(&fetch_settings)?;
 
-		let mut flake_settings = FlakeSettings::new()?;
 		let flake = flake.get_attrs(&mut flake_settings)?;
 
 		let builtins_field = Value::eval("builtins")?;

11use serde::de::DeserializeOwned;11use serde::de::DeserializeOwned;
1212
13pub use anyhow::Result;13pub use anyhow::Result;
14use tracing::instrument;
1415
15use self::logging::nix_logging_cxx;16use self::logging::nix_logging_cxx;
16use self::nix_cxx::set_fetcher_setting;17use self::nix_cxx::set_fetcher_setting;
17use self::nix_raw::{18use self::nix_raw::{
18	alloc_value, c_context, c_context_create, err_code, err_info_msg, eval_state_build,19	alloc_value, c_context, c_context_create, err_code, err_info_msg, eval_state_build,
19	eval_state_builder_new, expr_eval_from_string, fetchers_settings, fetchers_settings_free,20	eval_state_builder_new, expr_eval_from_string, fetchers_settings, fetchers_settings_free,
20	fetchers_settings_new, flake_lock, flake_lock_flags, flake_lock_flags_free,21	fetchers_settings_new, flake_lock, flake_lock_flags, flake_lock_flags_free,
21	flake_lock_flags_new, flake_reference_parse_flags, flake_reference_parse_flags_free,22	flake_lock_flags_new, flake_lock_flags_set_mode_virtual, flake_reference_parse_flags,
22	flake_reference_parse_flags_new, flake_reference_parse_flags_set_base_directory,23	flake_reference_parse_flags_free, flake_reference_parse_flags_new,
23	flake_settings, flake_settings_free, flake_settings_new, init_bool, init_int, init_string,24	flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,
24	locked_flake_free, locked_flake_get_output_attrs, set_err_msg, setting_set, state_free,25	flake_settings_new, init_bool, init_int, init_string, locked_flake_free,
9496
95#[derive(Debug)]97#[derive(Debug)]
96#[repr(i32)]98#[repr(i32)]
97enum NixErrorKind {99pub enum NixErrorKind {
98	Unknown = 1,100	Unknown = 1,
99	Overflow = 2,101	Overflow = 2,
100	Key = 3,102	Key = 3,
136138
137pub struct ThreadRegisterGuard {}139pub struct ThreadRegisterGuard {}
138impl ThreadRegisterGuard {140impl ThreadRegisterGuard {
141	#[allow(clippy::new_without_default)]
139	pub fn new() -> Self {142	pub fn new() -> Self {
140		gc_register_my_thread();143		gc_register_my_thread();
141		Self {}144		Self {}
201	}204	}
202}205}
206
207impl Default for NixContext {
208	fn default() -> Self {
209		Self::new()
210	}
211}
203impl Drop for NixContext {212impl Drop for NixContext {
204	fn drop(&mut self) {213	fn drop(&mut self) {
205		unsafe {214		unsafe {
232			}241			}
233			// eval_s242			// eval_s
234		})?;243		})?;
244		ctx.run_in_context(|c| {
245			unsafe {
246				nix_raw::eval_state_builder_set_eval_setting(
247					c,
248					builder,
249					c"lazy-locks".as_ptr(),
250					c"true".as_ptr(),
251				)
252			}
253			// eval_s
254		})?;
235		let state = ctx255		let state = ctx
236			.run_in_context(|c| unsafe { eval_state_build(c, builder) })256			.run_in_context(|c| unsafe { eval_state_build(c, builder) })
237			.map(EvalState)?;257			.map(EvalState)?;
319339
320pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);340pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);
321impl FlakeReferenceParseFlags {341impl FlakeReferenceParseFlags {
322	pub fn new(settings: &mut FlakeSettings) -> Result<Self> {342	pub fn new(settings: &FlakeSettings) -> Result<Self> {
323		with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })343		with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })
324			.map(Self)344			.map(Self)
325	}345	}
346struct FlakeLockFlags(*mut flake_lock_flags);366struct FlakeLockFlags(*mut flake_lock_flags);
347impl FlakeLockFlags {367impl FlakeLockFlags {
348	fn new(settings: &mut FlakeSettings) -> Result<Self> {368	fn new(settings: &mut FlakeSettings) -> Result<Self> {
349		with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) }).map(Self)369		let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })
370			.map(Self)?;
371		with_default_context(|c, _| unsafe { flake_lock_flags_set_mode_virtual(c, o.0) })?;
372
373		Ok(o)
350	}374	}
351}375}
352impl Drop for FlakeLockFlags {376impl Drop for FlakeLockFlags {
381405
382pub struct FlakeReference(*mut nix_raw::flake_reference);406pub struct FlakeReference(*mut nix_raw::flake_reference);
383impl FlakeReference {407impl FlakeReference {
408	#[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]
384	pub fn new(s: &str, fetch: &FetchSettings) -> Result<(Self, String)> {409	pub fn new(
385		let mut flake_settings = FlakeSettings::new()?;410		s: &str,
386		let parse_flags = FlakeReferenceParseFlags::new(&mut flake_settings)?;411		flake: &FlakeSettings,
387412		parse: &FlakeReferenceParseFlags,
413		fetch: &FetchSettings,
414	) -> Result<(Self, String)> {
388		let mut out = null_mut();415		let mut out = null_mut();
389		let mut fragment = String::new();416		let mut fragment = String::new();
392			nix_raw::flake_reference_and_fragment_from_string(419			nix_raw::flake_reference_and_fragment_from_string(
393				c,420				c,
394				fetch.0,421				fetch.0,
395				flake_settings.0,422				flake.0,
396				parse_flags.0,423				parse.0,
397				s.as_ptr().cast(),424				s.as_ptr().cast(),
398				s.len(),425				s.len(),
399				&mut out,426				&mut out,
405432
406		Ok((Self(out), fragment))433		Ok((Self(out), fragment))
407	}434	}
435	#[instrument(name = "lock-flake", skip(self, fetch))]
408	pub fn lock(&mut self, fetch: &FetchSettings) -> Result<LockedFlake> {436	pub fn lock(&mut self, fetch: &FetchSettings) -> Result<LockedFlake> {
409		let mut settings = FlakeSettings::new()?;437		let mut settings = FlakeSettings::new()?;
410		let lock_flags = FlakeLockFlags::new(&mut settings)?;438		let lock_flags = FlakeLockFlags::new(&mut settings)?;

--- a/crates/nix-eval/src/logging.cc
+++ b/crates/nix-eval/src/logging.cc
@@ -8,19 +8,6 @@
   TracingLogger() {}
 
   bool isVerbose() override { return true; }
-  // void addFields(nlohmann::json & json, const Fields & fields)
-  //    {
-  //        if (fields.empty())
-  //            return;
-  //        auto & arr = json["fields"] = nlohmann::json::array();
-  //        for (auto & f : fields)
-  //            if (f.type == Logger::Field::tInt)
-  //                arr.push_back(f.i);
-  //            else if (f.type == Logger::Field::tString)
-  //                arr.push_back(f.s);
-  //            else
-  //                unreachable();
-  //    }
   void log(Verbosity lvl, std::string_view s) override {
     rust::Str str(s.data(), s.size());
     emit_log(lvl, str);
@@ -60,16 +47,18 @@
   };
 
   void writeToStdout(std::string_view s) override {
-    printf("writeToStdout() called\n");
+    emit_warn("writeToStdout() called, but unsupported");
   }
   void warn(const std::string &msg) override { emit_warn(msg); }
 
   virtual std::optional<char> ask(std::string_view s) {
-    printf("ask() called\n");
+    emit_warn("ask() called, but unsupported");
     return {};
   }
 };
 
 extern "C" {
-void apply_tracing_logger() { logger = std::make_unique<TracingLogger>(); }
+void apply_tracing_logger() {
+  logger = std::make_unique<TracingLogger>();
+}
 }

--- a/flake.lock
+++ b/flake.lock
@@ -105,7 +105,6 @@
       },
       "locked": {
         "lastModified": 1757000273,
-        "narHash": "sha256-9AKhwsSlegWnNFy8++OMNctrxJUUIE7nG4s4ZHmFPic=",
         "owner": "deltarocks",
         "repo": "nix",
         "rev": "eba1f549ec21208cf98343f1351a95e2e6eb3fbb",