`771ccbb734d6`

4 files changed

modifiedcrates/fleet-base/src/opts.rsdiff before after both

88
9use anyhow::{Context, Result, bail};9use anyhow::{Context, Result, bail};
10use nix_eval::{FetchSettings, FlakeReference, FlakeSettings, Value, nix_go, util::assert_warn};10use nix_eval::{
11	FetchSettings, FlakeReference, FlakeReferenceParseFlags, FlakeSettings, Value, nix_go,
12	util::assert_warn,
13};
11use nom::{14use nom::{
12	Parser,15	Parser,
213		let mut fetch_settings = FetchSettings::new();216		let mut fetch_settings = FetchSettings::new();
214		fetch_settings.set(c"warn-dirty", c"false");217		fetch_settings.set(c"warn-dirty", c"false");
215218
216		// TODO: use correct directory, not cwd219		let mut flake_settings = FlakeSettings::new()?;
220		let mut parse = FlakeReferenceParseFlags::new(&flake_settings)?;
221		// For some reason, lazy trees not being used when there is no base dir set
222		parse.set_base_dir("/")?;
223
217		let (mut flake, _) = FlakeReference::new(224		let (mut flake, _) = FlakeReference::new(
218			directory225			directory
219				.to_str()226				.to_str()
220				.ok_or_else(|| anyhow::anyhow!("fleet dir should have utf-8 path"))?,227				.ok_or_else(|| anyhow::anyhow!("fleet dir should have utf-8 path"))?,
228			&flake_settings,
229			&parse,
221			&fetch_settings,230			&fetch_settings,
222		)?;231		)?;
223		let flake = flake.lock(&fetch_settings)?;232		let flake = flake.lock(&fetch_settings)?;
224233
225		let mut flake_settings = FlakeSettings::new()?;
226		let flake = flake.get_attrs(&mut flake_settings)?;234		let flake = flake.get_attrs(&mut flake_settings)?;
227235
228		let builtins_field = Value::eval("builtins")?;236		let builtins_field = Value::eval("builtins")?;

modifiedcrates/nix-eval/src/lib.rsdiff before after both

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

modifiedcrates/nix-eval/src/logging.ccdiff before after both

8  TracingLogger() {}8  TracingLogger() {}
99
10  bool isVerbose() override { return true; }10  bool isVerbose() override { return true; }
11  // void addFields(nlohmann::json & json, const Fields & fields)
12  //    {
13  //        if (fields.empty())
14  //            return;
15  //        auto & arr = json["fields"] = nlohmann::json::array();
16  //        for (auto & f : fields)
17  //            if (f.type == Logger::Field::tInt)
18  //                arr.push_back(f.i);
19  //            else if (f.type == Logger::Field::tString)
20  //                arr.push_back(f.s);
21  //            else
22  //                unreachable();
23  //    }
24  void log(Verbosity lvl, std::string_view s) override {11  void log(Verbosity lvl, std::string_view s) override {
25    rust::Str str(s.data(), s.size());12    rust::Str str(s.data(), s.size());
26    emit_log(lvl, str);13    emit_log(lvl, str);
60  };47  };
6148
62  void writeToStdout(std::string_view s) override {49  void writeToStdout(std::string_view s) override {
63    printf("writeToStdout() called\n");50    emit_warn("writeToStdout() called, but unsupported");
64  }51  }
65  void warn(const std::string &msg) override { emit_warn(msg); }52  void warn(const std::string &msg) override { emit_warn(msg); }
6653
67  virtual std::optional<char> ask(std::string_view s) {54  virtual std::optional<char> ask(std::string_view s) {
68    printf("ask() called\n");55    emit_warn("ask() called, but unsupported");
69    return {};56    return {};
70  }57  }
71};58};

modifiedflake.lockdiff before after both

105      },105      },
106      "locked": {106      "locked": {
107        "lastModified": 1757000273,107        "lastModified": 1757000273,
108        "narHash": "sha256-9AKhwsSlegWnNFy8++OMNctrxJUUIE7nG4s4ZHmFPic=",
109        "owner": "deltarocks",108        "owner": "deltarocks",
110        "repo": "nix",109        "repo": "nix",
111        "rev": "eba1f549ec21208cf98343f1351a95e2e6eb3fbb",110        "rev": "eba1f549ec21208cf98343f1351a95e2e6eb3fbb",