git.delta.rocks / fleet / refs/commits / 78196e185cf1

1use std::borrow::Cow;2use std::cell::RefCell;3use std::collections::HashMap;4use std::ffi::{CStr, CString, c_char, c_int, c_uint, c_void};5use std::ptr::{null, null_mut};6use std::sync::{Arc, LazyLock, OnceLock};7use std::{array, fmt, slice};89use anyhow::{Context, anyhow, bail};10use camino::{Utf8Path, Utf8PathBuf};11use itertools::Itertools;12use serde::Serialize;13use serde::de::DeserializeOwned;14use std::mem::transmute;1516pub use anyhow::Result;17use tracing::{Span, instrument, warn};1819use self::logging::{ErrorInfoBuilder, nix_logging_cxx};20use self::nix_cxx::set_fetcher_setting;21use self::nix_raw::{22	BindingsBuilder as c_bindings_builder, EvalState as c_eval_state, GC_SUCCESS,23	GC_allow_register_threads, GC_get_stack_base, GC_register_my_thread, GC_stack_base,24	GC_thread_is_registered, GC_unregister_my_thread, ListBuilder as c_list_builder, PrimOp,25	PrimOpFun, Store as c_store, StorePath as c_store_path, alloc_primop, alloc_value,26	bindings_builder_free, bindings_builder_insert, c_context, c_context_create, c_context_free,27	clear_err, copy_value, err_NIX_ERR_KEY, err_NIX_ERR_NIX_ERROR, err_NIX_ERR_OVERFLOW,28	err_NIX_ERR_UNKNOWN, err_NIX_OK, err_code, err_info_msg, err_msg, eval_state_build,29	eval_state_builder_load, eval_state_builder_new, eval_state_builder_set_eval_setting,30	expr_eval_from_string, fetchers_settings, fetchers_settings_free, fetchers_settings_new,31	flake_lock, flake_lock_flags, flake_lock_flags_free, flake_lock_flags_new, flake_reference,32	flake_reference_and_fragment_from_string, flake_reference_parse_flags,33	flake_reference_parse_flags_free, flake_reference_parse_flags_new,34	flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,35	flake_settings_new, gc_now as gc_now_raw, get_attr_byname, get_attr_name_byidx, get_attrs_size,36	get_list_byidx, get_list_size, get_string, get_type, has_attr_byname, init_bool, init_int,37	init_primop, init_string, libexpr_init, libstore_init, libutil_init, list_builder_free,38	list_builder_insert, locked_flake, locked_flake_free, locked_flake_get_output_attrs,39	make_attrs, make_bindings_builder, make_list, make_list_builder, realised_string,40	realised_string_free, realised_string_get_buffer_size, realised_string_get_buffer_start,41	realised_string_get_store_path, realised_string_get_store_path_count, register_primop,42	set_err_msg, setting_get, setting_set, state_free, store_copy_closure, store_free, store_open,43	store_parse_path, store_path_free, store_path_name, string_realise, value, value_call,44	value_decref, value_force, value_incref,45};4647// Contains macros helpers48pub mod drv;49pub mod logging;50#[doc(hidden)]51pub mod macros;52pub mod scheduler;5354#[doc(hidden)]55pub mod __macro_support {56	pub use std::collections::hash_map::HashMap;5758	pub use anyhow::Context;59	pub use tokio::task::block_in_place;60}61pub mod util;6263#[allow(64	non_upper_case_globals,65	non_camel_case_types,66	non_snake_case,67	dead_code68)]69mod nix_raw {70	include!(concat!(env!("OUT_DIR"), "/bindings.rs"));71}72#[cxx::bridge]73pub mod nix_cxx {74	struct AddFileToStoreResult {75		error: String,76		store_path: String,77		hash: String,78	}79	struct CxxProfileGeneration {80		id: u64,81		store_path: String,82		creation_time_unix: i64,83		current: bool,84	}85	struct CxxListGenerationsResult {86		error: String,87		generations: Vec<CxxProfileGeneration>,88	}89	struct CxxBuildResult {90		error: String,91		outputs: Vec<String>,92	}93	unsafe extern "C++" {94		type nix_fetchers_settings;95		type Store;96		include!("nix-eval/src/lib.hh");9798		#[allow(clippy::missing_safety_doc)]99		unsafe fn set_fetcher_setting(100			settings: *mut nix_fetchers_settings,101			setting: *const c_char,102			value: *const c_char,103		);104105		#[allow(clippy::missing_safety_doc)]106		unsafe fn switch_profile(store: *mut Store, profile: &str, store_path: &str) -> String;107108		#[allow(clippy::missing_safety_doc)]109		unsafe fn sign_closure(store: *mut Store, store_path: &str, key_file: &str) -> String;110111		#[allow(clippy::missing_safety_doc)]112		unsafe fn add_file_to_store(113			store: *mut Store,114			name: &str,115			path: &str,116		) -> AddFileToStoreResult;117118		fn list_generations(profile_path: &str) -> CxxListGenerationsResult;119120		#[allow(clippy::missing_safety_doc)]121		unsafe fn build_drv_outputs(122			store: *mut Store,123			drv_path: &str,124			output_names_joined: &str,125		) -> CxxBuildResult;126127		#[allow(clippy::missing_safety_doc)]128		unsafe fn substitute_paths(store: *mut Store, paths_joined: &str) -> CxxBuildResult;129130		#[allow(clippy::missing_safety_doc)]131		unsafe fn is_valid_path(store: *mut Store, path: &str) -> bool;132	}133}134135#[derive(Debug, PartialEq, Eq)]136pub enum NixType {137	Thunk,138	Int,139	Float,140	Bool,141	String,142	Path,143	Null,144	Attrs,145	List,146	Function,147	External,148}149impl NixType {150	fn from_int(c: c_uint) -> Self {151		match c {152			0 => Self::Thunk,153			1 => Self::Int,154			2 => Self::Float,155			3 => Self::Bool,156			4 => Self::String,157			5 => Self::Path,158			6 => Self::Null,159			7 => Self::Attrs,160			8 => Self::List,161			9 => Self::Function,162			10 => Self::External,163			_ => unreachable!("unknown nix type: {c}"),164		}165	}166}167168enum FunctorKind {169	Function,170	Functor,171}172173#[derive(Debug)]174#[repr(i32)]175pub enum NixErrorKind {176	Unknown = err_NIX_ERR_UNKNOWN,177	Overflow = err_NIX_ERR_OVERFLOW,178	Key = err_NIX_ERR_KEY,179	Generic = err_NIX_ERR_NIX_ERROR,180}181impl NixErrorKind {182	fn from_int(v: c_int) -> Option<Self> {183		Some(match v {184			0 => return None,185			nix_raw::err_NIX_ERR_UNKNOWN => Self::Unknown,186			nix_raw::err_NIX_ERR_OVERFLOW => Self::Overflow,187			nix_raw::err_NIX_ERR_KEY => Self::Key,188			nix_raw::err_NIX_ERR_NIX_ERROR => Self::Generic,189			_ => {190				debug_assert!(false, "unexpected nix error kind: {v}");191				Self::Unknown192			}193		})194	}195}196197pub fn gc_now() {198	unsafe { gc_now_raw() };199}200201pub fn gc_register_my_thread() {202	assert_eq!(unsafe { GC_thread_is_registered() }, 0);203204	let mut sb = GC_stack_base {205		mem_base: null_mut(),206	};207	let r = unsafe { GC_get_stack_base(&mut sb) };208	if r as u32 != GC_SUCCESS {209		panic!("failed to get thread stack base");210	}211	unsafe { GC_register_my_thread(&sb) };212}213pub fn gc_unregister_my_thread() {214	assert_eq!(unsafe { GC_thread_is_registered() }, 1);215216	unsafe { GC_unregister_my_thread() };217}218219pub struct ThreadRegisterGuard {}220impl ThreadRegisterGuard {221	#[allow(clippy::new_without_default)]222	pub fn new() -> Self {223		gc_register_my_thread();224		Self {}225	}226}227impl Drop for ThreadRegisterGuard {228	fn drop(&mut self) {229		gc_unregister_my_thread();230	}231}232233#[repr(transparent)]234pub struct NixContext(*mut c_context);235impl NixContext {236	pub fn set_err_raw(&mut self, err: NixErrorKind, msg: &CStr) {237		unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };238	}239	pub fn set_err(&mut self, err: anyhow::Error) {240		let fmt = format!("{err:?}").replace("\0", "\\0");241		self.set_err_raw(242			NixErrorKind::Generic,243			&CString::new(fmt).expect("NUL bytes were just replaced"),244		);245	}246	pub fn new() -> Self {247		let ctx = unsafe { c_context_create() };248		Self(ctx)249	}250	fn error_kind(&self) -> Option<NixErrorKind> {251		let code = unsafe { err_code(self.0) };252		NixErrorKind::from_int(code)253	}254	fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {255		if let NixErrorKind::Generic = self.error_kind()? {256			let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };257			let mut err_out = String::new();258			unsafe {259				err_info_msg(260					null_mut(),261					self.0,262					Some(copy_nix_str),263					(&raw mut err_out).cast(),264				)265			};266			return Some((Cow::Owned(err_out), Some(ei)));267		};268269		// TODO: Can throw error (resulting in panic) if unable to retrieve error. Should be able to resolve by passing context as a first argument,270		// but it looks ugly271		let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };272		Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))273	}274	fn clean_err(&mut self) {275		unsafe {276			clear_err(self.0);277		}278	}279280	fn bail_if_error(&self) -> Result<()> {281		if let Some((err, stack)) = self.error() {282			let mut e = Err(anyhow!("{err}"));283			if let Some(stack) = stack {284				for ele in stack.stack_frames {285					e = e.with_context(|| {286						if ele.pos.is_empty() {287							ele.msg288						} else {289							format!("{} at {}", ele.msg, ele.pos)290						}291					})292				}293			}294			return e.context("<nix frames>");295		};296		Ok(())297	}298299	fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {300		self.clean_err();301		let o = f(self.0);302		self.bail_if_error()?;303		self.clean_err();304		Ok(o)305	}306}307308impl Default for NixContext {309	fn default() -> Self {310		Self::new()311	}312}313impl Drop for NixContext {314	fn drop(&mut self) {315		unsafe {316			c_context_free(self.0);317		}318	}319}320struct GlobalState {321	// Store should be valid as long as EvalState is valid322	#[allow(dead_code)]323	store: Arc<Store>,324	state: EvalState,325}326impl GlobalState {327	fn new() -> Result<Self> {328		let mut ctx = NixContext::new();329		let store = Arc::new(330			ctx.run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })331				.map(Store)?,332		);333334		let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;335		ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;336		ctx.run_in_context(|c| unsafe {337			eval_state_builder_set_eval_setting(338				c,339				builder,340				c"lazy-trees".as_ptr(),341				c"true".as_ptr(),342			)343		})?;344		ctx.run_in_context(|c| unsafe {345			eval_state_builder_set_eval_setting(346				c,347				builder,348				c"lazy-locks".as_ptr(),349				c"true".as_ptr(),350			)351		})?;352		let state = ctx353			.run_in_context(|c| unsafe { eval_state_build(c, builder) })354			.map(EvalState)?;355356		Ok(Self { store, state })357	}358}359360struct ThreadState {361	ctx: NixContext,362}363impl ThreadState {364	fn new() -> Result<Self> {365		let ctx = NixContext::new();366367		Ok(Self { ctx })368	}369}370371static GLOBAL_STATE: LazyLock<GlobalState> =372	LazyLock::new(|| GlobalState::new().expect("global state init shouldn't fail"));373374thread_local! {375	static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));376}377pub(crate) fn with_default_context<T>(378	f: impl FnOnce(*mut c_context, *mut c_eval_state) -> T,379) -> Result<T> {380	let global = &GLOBAL_STATE.state;381	let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));382	let mut ctx = NixContext(ctx);383	let v = ctx.run_in_context(|c| f(c, state));384	// It is reused for thread385	std::mem::forget(ctx);386	v387}388389pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {390	with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())391}392393pub fn get_setting(s: &CStr) -> Result<String> {394	let mut out = String::new();395	with_default_context(|c, _| unsafe {396		setting_get(c, s.as_ptr(), Some(copy_nix_str), (&raw mut out).cast())397	})?;398	Ok(out)399}400401#[derive(Debug)]402pub struct AddedFile {403	pub store_path: Utf8PathBuf,404	pub hash: String,405}406407#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]408pub struct ProfileGeneration {409	pub id: u64,410	pub store_path: Utf8PathBuf,411	pub creation_time_unix: i64,412	pub current: bool,413}414415#[instrument]416pub fn list_generations(profile_path: &str) -> Result<Vec<ProfileGeneration>> {417	let res = nix_cxx::list_generations(profile_path);418	if !res.error.is_empty() {419		bail!(420			"failed to list generations at {profile_path}: {}",421			res.error422		);423	}424	Ok(res425		.generations426		.into_iter()427		.map(|g| ProfileGeneration {428			id: g.id,429			store_path: Utf8PathBuf::from(g.store_path),430			creation_time_unix: g.creation_time_unix,431			current: g.current,432		})433		.collect())434}435436pub struct FetchSettings(*mut fetchers_settings);437impl FetchSettings {438	pub fn new() -> Self {439		Self::try_new().expect("allocation should not fail")440	}441	fn try_new() -> Result<Self> {442		with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)443	}444	pub fn set(&mut self, setting: &CStr, value: &CStr) {445		unsafe {446			set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());447		};448	}449}450unsafe impl Send for FetchSettings {}451unsafe impl Sync for FetchSettings {}452453impl Default for FetchSettings {454	fn default() -> Self {455		Self::new()456	}457}458459impl Drop for FetchSettings {460	fn drop(&mut self) {461		unsafe { fetchers_settings_free(self.0) };462	}463}464pub struct FlakeSettings(*mut flake_settings);465impl FlakeSettings {466	pub fn new() -> Result<Self> {467		with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)468	}469}470unsafe impl Send for FlakeSettings {}471unsafe impl Sync for FlakeSettings {}472impl Drop for FlakeSettings {473	fn drop(&mut self) {474		unsafe {475			flake_settings_free(self.0);476		}477	}478}479480pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);481impl FlakeReferenceParseFlags {482	pub fn new(settings: &FlakeSettings) -> Result<Self> {483		with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })484			.map(Self)485	}486	pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {487		with_default_context(|c, _| {488			unsafe {489				flake_reference_parse_flags_set_base_directory(490					c,491					self.0,492					dir.as_ptr().cast(),493					dir.len(),494				)495			};496		})497	}498}499impl Drop for FlakeReferenceParseFlags {500	fn drop(&mut self) {501		unsafe {502			flake_reference_parse_flags_free(self.0);503		}504	}505}506pub struct FlakeLockFlags(*mut flake_lock_flags);507impl FlakeLockFlags {508	pub fn new(settings: &FlakeSettings) -> Result<Self> {509		let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })510			.map(Self)?;511		// with_default_context(|c, _| unsafe { flake_lock_flags_set_mode_virtual(c, o.0) })?;512513		Ok(o)514	}515}516impl Drop for FlakeLockFlags {517	fn drop(&mut self) {518		unsafe {519			flake_lock_flags_free(self.0);520		}521	}522}523524pub(crate) unsafe extern "C" fn copy_nix_str(525	start: *const c_char,526	n: c_uint,527	user_data: *mut c_void,528) {529	let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };530	let s = std::str::from_utf8(s).expect("c string has invalid utf-8");531	unsafe { *user_data.cast::<String>() = s.to_owned() };532}533534pub struct Store(*mut c_store);535unsafe impl Send for Store {}536unsafe impl Sync for Store {}537538pub fn eval_store() -> Arc<Store> {539	GLOBAL_STATE.store.clone()540}541542impl Store {543	pub fn open(uri: &str) -> Result<Self> {544		let uri = CString::new(uri)?;545		let ptr = with_default_context(|c, _| unsafe { store_open(c, uri.as_ptr(), null_mut()) })?;546		if ptr.is_null() {547			bail!("failed to open store");548		}549		Ok(Store(ptr))550	}551552	pub fn parse_path(&self, path: &Utf8Path) -> Result<StorePath> {553		let path = CString::new(path.as_str()).expect("valid cstr");554		with_default_context(|c, _| {555			StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })556		})557	}558559	#[instrument(skip(self))]560	pub fn sign_closure(&self, path: &Utf8Path, key_file: &Utf8Path) -> Result<()> {561		let err = with_default_context(|_, _| unsafe {562			nix_cxx::sign_closure(self.as_ptr().cast(), path.as_str(), key_file.as_str())563		})?564		.to_string();565566		if err.is_empty() {567			Ok(())568		} else {569			bail!("failed to sign {path}: {err}");570		}571	}572573	#[instrument(skip(self, dst))]574	pub fn copy_to(&self, dst: &Store, path: &Utf8Path) -> Result<()> {575		let sp = self576			.parse_path(path)577			.context("failed to parse store path")?;578		let rc = with_default_context(|c, _| unsafe {579			store_copy_closure(c, self.as_ptr(), dst.0, sp.as_ptr())580		})?;581		if rc != err_NIX_OK {582			bail!("store_copy_closure failed (code {rc})");583		}584		Ok(())585	}586587	/// Would only work with local store.588	#[instrument(skip(self))]589	pub fn switch_profile(&self, profile: &str, path: &Utf8Path) -> Result<()> {590		let msg = unsafe { nix_cxx::switch_profile(self.as_ptr().cast(), profile, path.as_str()) };591		if msg.is_empty() {592			Ok(())593		} else {594			bail!("failed to switch profile {profile}: {msg}");595		}596	}597598	#[instrument(skip(self))]599	pub fn add_file(&self, name: &str, path: &Utf8Path) -> Result<AddedFile> {600		let msg = unsafe { nix_cxx::add_file_to_store(self.as_ptr().cast(), name, path.as_str()) };601		if !msg.error.is_empty() {602			bail!("failed to add {path} to store: {}", msg.error)603		}604		Ok(AddedFile {605			store_path: Utf8PathBuf::from(msg.store_path),606			hash: msg.hash,607		})608	}609610	#[instrument(skip(self, paths))]611	pub fn substitute_paths(&self, paths: &[Utf8PathBuf]) -> Result<Vec<Utf8PathBuf>> {612		let joined = paths.into_iter().join("\n");613		let res = unsafe { nix_cxx::substitute_paths(self.as_ptr().cast(), &joined) };614		if !res.error.is_empty() {615			warn!("substitute_paths reported: {}", res.error);616		}617		Ok(res.outputs.into_iter().map(Utf8PathBuf::from).collect())618	}619620	#[instrument(skip(self))]621	pub fn is_valid_path(&self, path: &Utf8Path) -> bool {622		unsafe { nix_cxx::is_valid_path(self.as_ptr().cast(), path.as_str()) }623	}624625	#[instrument(skip(self))]626	pub fn build_drv_outputs(627		&self,628		drv_path: &Utf8Path,629		output_names: &[String],630	) -> Result<Vec<String>> {631		let joined = output_names.join("\n");632		let res =633			unsafe { nix_cxx::build_drv_outputs(self.as_ptr().cast(), drv_path.as_str(), &joined) };634		if !res.error.is_empty() {635			bail!("build of {drv_path} failed: {}", res.error);636		}637		Ok(res.outputs)638	}639640	#[instrument(skip(self))]641	pub fn store_dir(&self) -> Result<Utf8PathBuf> {642		let mut out = String::new();643		with_default_context(|c, es| unsafe {644			nix_raw::store_get_storedir(c, self.as_ptr(), Some(copy_nix_str), (&raw mut out).cast())645		})?;646		let p = Utf8PathBuf::from(out);647		assert!(p.is_absolute());648		Ok(p)649	}650651	fn as_ptr(&self) -> *mut c_store {652		self.0653	}654}655impl Drop for Store {656	fn drop(&mut self) {657		unsafe { store_free(self.0) }658	}659}660661#[repr(transparent)]662pub struct EvalState(*mut c_eval_state);663unsafe impl Send for EvalState {}664unsafe impl Sync for EvalState {}665666impl Drop for EvalState {667	fn drop(&mut self) {668		unsafe {669			state_free(self.0);670		}671	}672}673674pub struct FlakeReference(*mut flake_reference);675impl FlakeReference {676	#[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]677	pub fn new(678		s: &str,679		flake: &FlakeSettings,680		parse: &FlakeReferenceParseFlags,681		fetch: &FetchSettings,682	) -> Result<(Self, String)> {683		let mut out = null_mut();684		let mut fragment = String::new();685		// let fetch_settings = fetcher_settings;686		with_default_context(|c, _| unsafe {687			flake_reference_and_fragment_from_string(688				c,689				fetch.0,690				flake.0,691				parse.0,692				s.as_ptr().cast(),693				s.len(),694				&mut out,695				Some(copy_nix_str),696				(&raw mut fragment).cast(),697			)698		})?;699		assert!(!out.is_null());700701		Ok((Self(out), fragment))702	}703	#[instrument(name = "lock-flake", skip(self, fetch, flake, lock))]704	pub fn lock(705		&mut self,706		fetch: &FetchSettings,707		flake: &FlakeSettings,708		lock: &FlakeLockFlags,709	) -> Result<LockedFlake> {710		with_default_context(|c, es| unsafe { flake_lock(c, fetch.0, flake.0, es, lock.0, self.0) })711			.map(LockedFlake)712	}713}714unsafe impl Send for FlakeReference {}715unsafe impl Sync for FlakeReference {}716717pub struct LockedFlake(*mut locked_flake);718impl LockedFlake {719	pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {720		with_default_context(|c, es| unsafe {721			locked_flake_get_output_attrs(c, settings.0, es, self.0)722		})723		.map(Value)724	}725}726unsafe impl Send for LockedFlake {}727unsafe impl Sync for LockedFlake {}728impl Drop for LockedFlake {729	fn drop(&mut self) {730		unsafe {731			locked_flake_free(self.0);732		};733	}734}735736type FieldName = [u8; 64];737fn init_field_name(v: &str) -> FieldName {738	let mut f = [0; 64];739	assert!(v.len() < 64, "max field name is 63 chars");740	assert!(741		v.bytes().all(|v| v != 0),742		"nul bytes are unsupported in field name"743	);744	f[0..v.len()].copy_from_slice(v.as_bytes());745	f746}747748pub struct RealisedString(*mut realised_string);749impl fmt::Debug for RealisedString {750	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {751		self.as_str().fmt(f)752	}753}754755impl RealisedString {756	pub fn as_str(&self) -> &str {757		let len = unsafe { realised_string_get_buffer_size(self.0) };758		let data: *const u8 = unsafe { realised_string_get_buffer_start(self.0) }.cast();759		let data = unsafe { slice::from_raw_parts(data, len) };760		std::str::from_utf8(data).expect("non-utf8 strings not supported")761	}762	pub fn path_count(&self) -> usize {763		unsafe { realised_string_get_store_path_count(self.0) }764	}765	pub fn path(&self, i: usize) -> String {766		assert!(i < self.path_count());767		let path = unsafe { realised_string_get_store_path(self.0, i) };768		let mut err_out = String::new();769		unsafe { store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };770		err_out771	}772}773774unsafe impl Send for RealisedString {}775impl Drop for RealisedString {776	fn drop(&mut self) {777		unsafe { realised_string_free(self.0) }778	}779}780781#[repr(transparent)]782pub struct Value(*mut value);783784unsafe impl Send for Value {}785unsafe impl Sync for Value {}786787pub trait AsFieldName {788	fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;789	fn to_field_name(&self) -> Result<String>;790}791impl AsFieldName for Value {792	fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {793		let f = self.to_string()?;794		v(init_field_name(&f))795	}796	fn to_field_name(&self) -> Result<String> {797		self.to_string()798	}799}800impl<E> AsFieldName for E801where802	E: AsRef<str>,803{804	fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {805		let f = self.as_ref();806		v(init_field_name(f))807	}808	fn to_field_name(&self) -> Result<String> {809		Ok(self.as_ref().to_owned())810	}811}812813struct AttrsBuilder(*mut c_bindings_builder);814impl AttrsBuilder {815	fn new(capacity: usize) -> Self {816		with_default_context(|c, es| unsafe { make_bindings_builder(c, es, capacity) })817			.map(Self)818			.expect("alloc should not fail")819	}820	fn insert(&mut self, k: &impl AsFieldName, v: Value) {821		k.as_field_name(|name| {822			with_default_context(|c, _| unsafe {823				bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0);824				// bindings_builder_insert doesn't do incref825			})826		})827		.expect("builder insert shouldn't fail");828	}829}830impl Drop for AttrsBuilder {831	fn drop(&mut self) {832		unsafe { bindings_builder_free(self.0) };833	}834}835836struct ListBuilder(*mut c_list_builder, c_uint);837impl ListBuilder {838	fn new(capacity: usize) -> Self {839		with_default_context(|c, es| unsafe { make_list_builder(c, es, capacity) })840			.map(|l| Self(l, 0))841			.expect("alloc should not fail")842	}843}844impl ListBuilder {845	fn push(&mut self, v: Value) {846		with_default_context(|c, _| unsafe {847			list_builder_insert(848				c,849				self.0,850				{851					let v = self.1;852					self.1 += 1;853					v854				},855				v.0,856			)857		})858		.expect("list insert shouldn't fail");859	}860}861impl Drop for ListBuilder {862	fn drop(&mut self) {863		unsafe { list_builder_free(self.0) };864	}865}866867impl Value {868	pub fn new_primop(v: NativeFn) -> Self {869		let out = Self::new_uninit();870		with_default_context(|c, _| unsafe { init_primop(c, out.0, v.0) })871			.expect("primop initialization should not fail");872		out873	}874	pub fn new_attrs(v: HashMap<&str, Value>) -> Self {875		let out = Self::new_uninit();876		let mut b = AttrsBuilder::new(v.len());877		for (k, v) in v {878			b.insert(&k, v);879		}880		with_default_context(|c, _| unsafe { make_attrs(c, out.0, b.0) })881			.expect("attrs initialization should not fail");882883		out884	}885	fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {886		let out = Self::new_uninit();887		let mut b = ListBuilder::new(v.len());888		for v in v {889			b.push(v.into());890		}891		with_default_context(|c, _| unsafe { make_list(c, b.0, out.0) })892			.expect("list initialization should not fail");893894		out895	}896	fn new_uninit() -> Self {897		let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })898			.expect("value allocation should not fail");899		Self(out)900	}901	pub fn new_str(v: &str) -> Self {902		let s = CString::new(v).expect("string should not contain NULs");903		let out = Self::new_uninit();904		// String is copied, `s` is free to be dropped905		with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })906			.expect("string initialization should not fail");907		out908	}909	pub fn new_int(i: i64) -> Self {910		let out = Self::new_uninit();911		with_default_context(|c, _| unsafe { init_int(c, out.0, i) })912			.expect("int initialization should not fail");913		out914	}915	pub fn new_bool(v: bool) -> Self {916		let out = Self::new_uninit();917		with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })918			.expect("bool initialization should not fail");919		out920	}921	// TODO: As far as I can see, there is no way to get Thunks from nix public C api, so this function is useless922	// fn force(&mut self, st: &mut EvalState) -> Result<()> {923	// 	with_default_context(|c, _| unsafe { value_force(c, st.0, self.0) })?;924	// 	Ok(())925	// }926	pub fn type_of(&self) -> NixType {927		let ty = with_default_context(|c, _| unsafe { get_type(c, self.0) })928			.expect("get_type should not fail");929		NixType::from_int(ty)930	}931	fn builtin_to_string(&self) -> Result<Self> {932		let builtin = Self::eval("builtins.toString")?;933		builtin.call(self.clone())934	}935	fn force(&mut self, s: *mut nix_raw::EvalState) -> Result<()> {936		with_default_context(|c, _| unsafe { value_force(c, s, self.0) })?;937		Ok(())938	}939	pub fn to_string(&self) -> Result<String> {940		let ty = self.type_of();941		if !matches!(ty, NixType::String) {942			bail!("unexpected type: {ty:?}, expected string");943		}944		let mut str_out = String::new();945		with_default_context(|c, _| unsafe {946			get_string(c, self.0, Some(copy_nix_str), (&raw mut str_out).cast())947		})?;948949		Ok(str_out)950	}951	pub fn to_realised_string(&self) -> Result<RealisedString> {952		with_default_context(|c, es| unsafe { string_realise(c, es, self.0, false) })953			.map(RealisedString)954955		// let store_paths = unsafe { nix_raw::realised_string_get_store_path_count(str) };956		// for i in 0..store_paths {957		// 	let store_path = unsafe { nix_raw::realised_string_get_store_path(str, i) };958		// 	nix_raw::store_path_name(store_path, callback, user_data);959		// }960		// dbg!(store_paths);961		// todo!();962	}963964	pub fn has_field(&self, field: &str) -> Result<bool> {965		if !matches!(self.type_of(), NixType::Attrs) {966			bail!("invalid type: expected attrs");967		}968969		let f = init_field_name(field);970		with_default_context(|c, es| unsafe { has_attr_byname(c, self.0, es, f.as_ptr().cast()) })971	}972	// pub fn derivation_path(&self) {973	// 	nix_raw::real974	// }975	pub fn list_fields(&self) -> Result<Vec<String>> {976		if !matches!(self.type_of(), NixType::Attrs) {977			bail!("invalid type: expected attrs");978		}979980		let len = with_default_context(|c, _| unsafe { get_attrs_size(c, self.0) })?;981		let mut out = Vec::with_capacity(len as usize);982983		for i in 0..len {984			let name =985				with_default_context(|c, es| unsafe { get_attr_name_byidx(c, self.0, es, i) })?;986			let c = unsafe { CStr::from_ptr(name) };987			out.push(c.to_str().expect("nix field names are utf-8").to_owned());988		}989		Ok(out)990	}991	pub fn get_elem(&self, v: usize) -> Result<Self> {992		if !matches!(self.type_of(), NixType::List) {993			bail!("invalid type: expected list");994		}995		let len = with_default_context(|c, _| unsafe { get_list_size(c, self.0) })? as usize;996		if v >= len {997			bail!("oob list get: {v} >= {len}");998		}9991000		with_default_context(|c, es| unsafe { get_list_byidx(c, self.0, es, v as u32) }).map(Self)1001	}1002	pub fn attrs_update(self, other: Value /*, ignore_errors: bool*/) -> Result<Self> {1003		let attrs_update_fn = Self::eval("a: b: a // b")?;10041005		attrs_update_fn1006			.call(self)?1007			.call(other)1008			.context("attrs update")1009	}1010	pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {1011		if !matches!(self.type_of(), NixType::Attrs) {1012			bail!("invalid type: expected attrs");1013		}10141015		name.as_field_name(|name| {1016			with_default_context(|c, es| unsafe {1017				get_attr_byname(c, self.0, es, name.as_ptr().cast())1018			})1019			.map(Self)1020		})1021		.with_context(|| format!("getting field {:?}", name.to_field_name()))1022	}1023	pub fn call(&self, v: Value) -> Result<Self> {1024		let kind = self1025			.functor_kind()1026			.ok_or_else(|| anyhow!("can only call function or functor"))?;10271028		let function = match kind {1029			FunctorKind::Function => self.clone(),1030			FunctorKind::Functor => {1031				let f = self1032					.get_field("__functor")1033					.context("getting functor value")?;1034				assert_eq!(1035					f.type_of(),1036					NixType::Function,1037					"invalid functor encountered"1038				);1039				f1040			}1041		};10421043		let out = Value::new_uninit();1044		with_default_context(|c, es| unsafe { value_call(c, es, function.0, v.0, out.0) })?;10451046		Ok(out)1047	}1048	pub fn eval(v: &str) -> Result<Self> {1049		let s = CString::new(v).expect("expression shouldn't have internal NULs");1050		let out = Self::new_uninit();1051		with_default_context(|c, es| unsafe {1052			expr_eval_from_string(c, es, s.as_ptr(), c"/root".as_ptr(), out.0)1053		})?;1054		Ok(out)1055	}1056	#[instrument(name = "build", skip(self), fields(output))]1057	pub fn build(&self, output: &str) -> Result<Utf8PathBuf> {1058		if !self.is_derivation() {1059			bail!("expected derivation to build")1060		}1061		let output_name = self1062			.get_field("outputName")1063			.context("getting output name field")?1064			.to_string()?;1065		let v = if output_name != output {1066			let out = self.get_field(output).context("getting target output")?;1067			if !out.is_derivation() {1068				bail!("unknown output: {output}");1069			}1070			out1071		} else {1072			self.clone()1073		};10741075		let drv_path = Utf8PathBuf::from(1076			v.get_field("drvPath")1077				.context("getting drvPath")?1078				.to_string()?,1079		);1080		let graph = Arc::new(drv::DrvGraph::resolve(&eval_store(), &drv_path)?);1081		let _guard = logging::register_build_graph(&Span::current(), &graph);10821083		scheduler::build_graph_sync(graph.clone(), vec![output.to_owned()])?;10841085		let s = v.builtin_to_string()?;1086		let rs = s.to_realised_string()?;1087		let out_path = rs.as_str().to_owned();1088		Ok(Utf8PathBuf::from(out_path))1089	}1090	pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {1091		let to_json = Self::eval("builtins.toJSON")?;1092		let s = to_json.call(self.clone())?.to_string()?;1093		Ok(serde_json::from_str(&s)?)1094	}1095	pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {1096		Self::eval(&nixlike::serialize(v)?)1097	}10981099	// Convert to string/evaluate derivations/etc1100	// fn to_string_weak(&self) -> Result<String> {1101	// 	// TODO: For now, it works exactly like to_string, see the comment for fn force()1102	// 	self.to_string()1103	// }11041105	fn is_derivation(&self) -> bool {1106		if !matches!(self.type_of(), NixType::Attrs) {1107			return false;1108		}1109		let Some(ty) = self.get_field("type").ok() else {1110			return false;1111		};1112		matches!(ty.to_string().as_deref(), Ok("derivation"))1113	}1114	fn functor_kind(&self) -> Option<FunctorKind> {1115		match self.type_of() {1116			NixType::Attrs => self1117				.has_field("__functor")1118				.expect("has_field shouldn't fail for attrs")1119				.then_some(FunctorKind::Functor),1120			NixType::Function => Some(FunctorKind::Function),1121			_ => None,1122		}1123	}1124	pub fn is_function(&self) -> bool {1125		self.functor_kind().is_some()1126	}1127	pub fn is_null(&self) -> bool {1128		matches!(self.type_of(), NixType::Null)1129	}1130	pub fn is_string(&self) -> bool {1131		matches!(self.type_of(), NixType::String)1132	}1133	pub fn is_attrs(&self) -> bool {1134		matches!(self.type_of(), NixType::Attrs)1135	}1136}11371138impl From<String> for Value {1139	fn from(value: String) -> Self {1140		Value::new_str(&value)1141	}1142}1143impl From<bool> for Value {1144	fn from(value: bool) -> Self {1145		Value::new_bool(value)1146	}1147}1148impl From<&str> for Value {1149	fn from(value: &str) -> Self {1150		Value::new_str(value)1151	}1152}1153impl<T> From<Vec<T>> for Value1154where1155	T: Into<Value>,1156{1157	fn from(value: Vec<T>) -> Self {1158		Value::new_list(value)1159	}1160}11611162impl Clone for Value {1163	fn clone(&self) -> Self {1164		with_default_context(|c, _| unsafe { value_incref(c, self.0) })1165			.expect("value incref should not fail");1166		Self(self.0)1167	}1168}1169impl Drop for Value {1170	fn drop(&mut self) {1171		with_default_context(|c, _| unsafe { value_decref(c, self.0) })1172			.expect("value drop should not fail");1173	}1174}11751176static TOKIO_FOR_NIX: OnceLock<Arc<tokio::runtime::Runtime>> = OnceLock::new();11771178pub fn init_libraries() {1179	unsafe { GC_allow_register_threads() };11801181	let mut ctx = NixContext::new();1182	ctx.run_in_context(|c| unsafe { libutil_init(c) })1183		.expect("util init should not fail");1184	ctx.run_in_context(|c| unsafe { libstore_init(c) })1185		.expect("store init should not fail");1186	ctx.run_in_context(|c| unsafe { libexpr_init(c) })1187		.expect("expr init should not fail");11881189	nix_logging_cxx::apply_tracing_logger();1190}11911192pub fn init_tokio_for_nix(tokio: Arc<tokio::runtime::Runtime>) {1193	TOKIO_FOR_NIX1194		.set(tokio)1195		.expect("tokio for nix should only be initialized once");1196}11971198pub fn await_in_nix<F: Send + 'static>(f: impl Future<Output = F> + Send + 'static) -> F {1199	// It should be possible to do Handle::current(), but some of the planned features don't work well with that1200	let runtime = TOKIO_FOR_NIX1201		.get()1202		.expect("init_tokio_for_nix was not called");1203	std::thread::spawn(move || runtime.block_on(f))1204		.join()1205		.expect("await_in_nix inner thread panicked")1206}12071208unsafe extern "C" fn nix_primop_closure_adapter<const N: usize>(1209	user_data: *mut c_void,1210	mut context: *mut c_context,1211	state: *mut nix_raw::EvalState,1212	args: *mut *mut value,1213	ret: *mut value,1214) {1215	let user_closure: &UserClosure<N> = unsafe { &*user_data.cast_const().cast() };1216	let args: [&Value; N] = array::from_fn(|i| {1217		let v: &mut Value = unsafe { &mut *args.add(i).cast() };1218		v as &Value1219	});1220	let ctx: &mut NixContext = unsafe { transmute(&mut context) };12211222	let state: &EvalState = unsafe { std::mem::transmute(&state) };12231224	match user_closure(state, args) {1225		Ok(v) => {1226			unsafe { copy_value(context, ret, v.0) };1227		}1228		Err(e) => {1229			ctx.set_err(e);1230		}1231	}1232}12331234type UserClosure<const N: usize> = Box<dyn Fn(&EvalState, [&Value; N]) -> Result<Value>>;12351236pub struct NativeFn(*mut PrimOp);1237impl NativeFn {1238	pub fn new<const N: usize>(1239		name: &'static CStr,1240		doc: &'static CStr,1241		args: [&'static CStr; N],1242		f: impl Fn(&EvalState, [&Value; N]) -> Result<Value> + 'static,1243	) -> Self {1244		// Double-boxing to make it thin pointer, as vtable gets outside of first Box1245		let closure: Box<UserClosure<N>> = Box::new(Box::new(f));1246		let f: PrimOpFun = Some(nix_primop_closure_adapter::<N>);1247		let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();1248		args.push(null());1249		let args = args.as_mut_ptr();1250		let primop = unsafe {1251			alloc_primop(1252				null_mut(),1253				f,1254				N as i32,1255				name.as_ptr(),1256				args,1257				doc.as_ptr(),1258				Box::into_raw(closure).cast(),1259			)1260		};12611262		assert!(!primop.is_null(), "primop allocation should not fail");12631264		Self(primop)1265	}1266	pub fn register(self) {1267		unsafe { register_primop(null_mut(), self.0) };1268	}1269}12701271pub struct StorePath(*mut c_store_path);1272impl StorePath {1273	fn as_ptr(&self) -> *mut c_store_path {1274		self.01275	}1276}12771278impl Drop for StorePath {1279	fn drop(&mut self) {1280		unsafe { store_path_free(self.0) }1281	}1282}12831284#[test_log::test]1285fn test_native() -> Result<()> {1286	init_libraries();1287	NativeFn::new(1288		c"__uppercaseSuffix2",1289		c"make string uppercase and add suffix",1290		[c"str", c"suffix"],1291		|_, [str, suffix]: [&Value; 2]| {1292			let str = str.to_string()?;1293			let suffix = suffix.to_string()?;1294			Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1295		},1296	)1297	.register();12981299	let mut fetch_settings = FetchSettings::new();1300	fetch_settings.set(c"warn-dirty", c"false");13011302	let manifest = format!("git+file://{}/../../", env!("CARGO_MANIFEST_DIR"));1303	let flake = FlakeSettings::new()?;1304	let parse = FlakeReferenceParseFlags::new(&flake)?;1305	let (mut r, _) = FlakeReference::new(&manifest, &flake, &parse, &fetch_settings)?;1306	let lock = FlakeLockFlags::new(&flake)?;1307	let locked = r.lock(&fetch_settings, &flake, &lock)?;1308	let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;13091310	let builtins = Value::eval("builtins")?;1311	assert_eq!(builtins.type_of(), NixType::Attrs);13121313	assert_eq!(attrs.type_of(), NixType::Attrs);1314	let test_data = nix_go!(attrs.testData);13151316	let test_string: String = nix_go_json!(test_data.testString);1317	assert_eq!(test_string, "hello");13181319	let s = nix_go!(attrs.packages["x86_64-linux"].fleet.drvPath);1320	let s = CString::new(s.to_string()?).expect("path str is cstring");13211322	let uppercase_suffix = Value::new_primop(NativeFn::new(1323		c"uppercase_suffix",1324		c"make string uppercase and add suffix",1325		[c"str", c"suffix"],1326		|es, [str, suffix]: [&Value; 2]| {1327			let str = str.to_string()?;1328			let suffix = suffix.to_string()?;1329			Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1330		},1331	));13321333	let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));1334	assert_eq!(test_result, "PREFIX_BODY_SUFFIX");1335	let test_result: String = nix_go_json!(builtins.uppercaseSuffix2("test")("suffix"));1336	assert_eq!(test_result, "TESTsuffix");13371338	let drv_path =1339		nix_go!(attrs.packages["x86_64-linux"]["fleet-install-secrets"].drvPath).to_string()?;1340	let graph = drv::DrvGraph::resolve(&drv_path)?;1341	eprintln!(1342		"fleet-install-secrets dependency graph: {} nodes",1343		graph.nodes.len()1344	);1345	for (path, node) in &graph.nodes {1346		if !node.input_drvs.is_empty() {1347			eprintln!("  {} ({} deps)", node.name, node.input_drvs.len());1348		}1349	}13501351	Ok(())1352}13531354// pub struct GcAlloc;1355// unsafe impl GlobalAlloc for GcAlloc {1356// 	unsafe fn alloc(&self, l: Layout) -> *mut u8 {1357// 		let ptr = unsafe { GC_malloc(l.size()) };1358// 		ptr.cast()1359// 	}1360// 	unsafe fn dealloc(&self, ptr: *mut u8, _: Layout) {1361// 		// unsafe { GC_free(ptr.cast()) };1362// 	}1363//1364// 	unsafe fn realloc(&self, ptr: *mut u8, _: Layout, new_size: usize) -> *mut u8 {1365// 		let ptr = unsafe { GC_realloc(ptr.cast(), new_size) };1366// 		ptr.cast()1367// 	}1368// }1369//1370// #[global_allocator]1371// static GC: GcAlloc = GcAlloc;