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")?;

--- a/crates/nix-eval/src/lib.rs
+++ b/crates/nix-eval/src/lib.rs
@@ -11,6 +11,7 @@
 use serde::de::DeserializeOwned;
 
 pub use anyhow::Result;
+use tracing::instrument;
 
 use self::logging::nix_logging_cxx;
 use self::nix_cxx::set_fetcher_setting;
@@ -18,11 +19,12 @@
 	alloc_value, c_context, c_context_create, err_code, err_info_msg, eval_state_build,
 	eval_state_builder_new, 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_parse_flags, flake_reference_parse_flags_free,
-	flake_reference_parse_flags_new, flake_reference_parse_flags_set_base_directory,
-	flake_settings, flake_settings_free, flake_settings_new, init_bool, init_int, init_string,
-	locked_flake_free, locked_flake_get_output_attrs, set_err_msg, setting_set, state_free,
-	value_decref, value_incref,
+	flake_lock_flags_new, flake_lock_flags_set_mode_virtual, flake_reference_parse_flags,
+	flake_reference_parse_flags_free, flake_reference_parse_flags_new,
+	flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,
+	flake_settings_new, init_bool, init_int, init_string, locked_flake_free,
+	locked_flake_get_output_attrs, set_err_msg, setting_set, state_free, value_decref,
+	value_incref,
 };
 
 // Contains macros helpers
@@ -94,7 +96,7 @@
 
 #[derive(Debug)]
 #[repr(i32)]
-enum NixErrorKind {
+pub enum NixErrorKind {
 	Unknown = 1,
 	Overflow = 2,
 	Key = 3,
@@ -136,6 +138,7 @@
 
 pub struct ThreadRegisterGuard {}
 impl ThreadRegisterGuard {
+	#[allow(clippy::new_without_default)]
 	pub fn new() -> Self {
 		gc_register_my_thread();
 		Self {}
@@ -200,6 +203,12 @@
 		Ok(o)
 	}
 }
+
+impl Default for NixContext {
+	fn default() -> Self {
+		Self::new()
+	}
+}
 impl Drop for NixContext {
 	fn drop(&mut self) {
 		unsafe {
@@ -232,6 +241,17 @@
 			}
 			// eval_s
 		})?;
+		ctx.run_in_context(|c| {
+			unsafe {
+				nix_raw::eval_state_builder_set_eval_setting(
+					c,
+					builder,
+					c"lazy-locks".as_ptr(),
+					c"true".as_ptr(),
+				)
+			}
+			// eval_s
+		})?;
 		let state = ctx
 			.run_in_context(|c| unsafe { eval_state_build(c, builder) })
 			.map(EvalState)?;
@@ -319,7 +339,7 @@
 
 pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);
 impl FlakeReferenceParseFlags {
-	pub fn new(settings: &mut FlakeSettings) -> Result<Self> {
+	pub fn new(settings: &FlakeSettings) -> Result<Self> {
 		with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })
 			.map(Self)
 	}
@@ -346,7 +366,11 @@
 struct FlakeLockFlags(*mut flake_lock_flags);
 impl FlakeLockFlags {
 	fn new(settings: &mut FlakeSettings) -> Result<Self> {
-		with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) }).map(Self)
+		let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })
+			.map(Self)?;
+		with_default_context(|c, _| unsafe { flake_lock_flags_set_mode_virtual(c, o.0) })?;
+
+		Ok(o)
 	}
 }
 impl Drop for FlakeLockFlags {
@@ -381,10 +405,13 @@
 
 pub struct FlakeReference(*mut nix_raw::flake_reference);
 impl FlakeReference {
-	pub fn new(s: &str, fetch: &FetchSettings) -> Result<(Self, String)> {
-		let mut flake_settings = FlakeSettings::new()?;
-		let parse_flags = FlakeReferenceParseFlags::new(&mut flake_settings)?;
-
+	#[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]
+	pub fn new(
+		s: &str,
+		flake: &FlakeSettings,
+		parse: &FlakeReferenceParseFlags,
+		fetch: &FetchSettings,
+	) -> Result<(Self, String)> {
 		let mut out = null_mut();
 		let mut fragment = String::new();
 		// let fetch_settings = fetcher_settings;
@@ -392,8 +419,8 @@
 			nix_raw::flake_reference_and_fragment_from_string(
 				c,
 				fetch.0,
-				flake_settings.0,
-				parse_flags.0,
+				flake.0,
+				parse.0,
 				s.as_ptr().cast(),
 				s.len(),
 				&mut out,
@@ -405,6 +432,7 @@
 
 		Ok((Self(out), fragment))
 	}
+	#[instrument(name = "lock-flake", skip(self, fetch))]
 	pub fn lock(&mut self, fetch: &FetchSettings) -> Result<LockedFlake> {
 		let mut settings = FlakeSettings::new()?;
 		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>();
+}
 }