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};464748pub 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 struct CxxPathInfo {94 error: String,95 nar_hash: String,96 nar_size: u64,97 references: Vec<String>,98 sigs: Vec<String>,99 }100 unsafe extern "C++" {101 type nix_fetchers_settings;102 type Store;103 include!("nix-eval/src/lib.hh");104105 #[allow(clippy::missing_safety_doc)]106 unsafe fn set_fetcher_setting(107 settings: *mut nix_fetchers_settings,108 setting: *const c_char,109 value: *const c_char,110 );111112 #[allow(clippy::missing_safety_doc)]113 unsafe fn switch_profile(store: *mut Store, profile: &str, store_path: &str) -> String;114115 #[allow(clippy::missing_safety_doc)]116 unsafe fn sign_closure(store: *mut Store, store_path: &str, key_file: &str) -> String;117118 #[allow(clippy::missing_safety_doc)]119 unsafe fn add_file_to_store(120 store: *mut Store,121 name: &str,122 path: &str,123 ) -> AddFileToStoreResult;124125 fn list_generations(profile_path: &str) -> CxxListGenerationsResult;126127 #[allow(clippy::missing_safety_doc)]128 unsafe fn build_drv_outputs(129 store: *mut Store,130 drv_path: &str,131 output_names_joined: &str,132 ) -> CxxBuildResult;133134 #[allow(clippy::missing_safety_doc)]135 unsafe fn substitute_paths(store: *mut Store, paths_joined: &str) -> CxxBuildResult;136137 #[allow(clippy::missing_safety_doc)]138 unsafe fn is_valid_path(store: *mut Store, path: &str) -> bool;139140 #[allow(clippy::missing_safety_doc)]141 unsafe fn query_path_info(store: *mut Store, path: &str) -> CxxPathInfo;142143 #[allow(clippy::missing_safety_doc)]144 unsafe fn compute_closure(store: *mut Store, path: &str) -> CxxBuildResult;145146 #[allow(clippy::missing_safety_doc)]147 unsafe fn nar_from_path(148 store: *mut Store,149 path: &str,150 sink_data: usize,151 sink: fn(usize, &[u8]) -> bool,152 ) -> String;153 }154}155156#[derive(Debug, PartialEq, Eq)]157pub enum NixType {158 Thunk,159 Int,160 Float,161 Bool,162 String,163 Path,164 Null,165 Attrs,166 List,167 Function,168 External,169}170impl NixType {171 fn from_int(c: c_uint) -> Self {172 match c {173 0 => Self::Thunk,174 1 => Self::Int,175 2 => Self::Float,176 3 => Self::Bool,177 4 => Self::String,178 5 => Self::Path,179 6 => Self::Null,180 7 => Self::Attrs,181 8 => Self::List,182 9 => Self::Function,183 10 => Self::External,184 _ => unreachable!("unknown nix type: {c}"),185 }186 }187}188189enum FunctorKind {190 Function,191 Functor,192}193194#[derive(Debug)]195#[repr(i32)]196pub enum NixErrorKind {197 Unknown = err_NIX_ERR_UNKNOWN,198 Overflow = err_NIX_ERR_OVERFLOW,199 Key = err_NIX_ERR_KEY,200 Generic = err_NIX_ERR_NIX_ERROR,201}202impl NixErrorKind {203 fn from_int(v: c_int) -> Option<Self> {204 Some(match v {205 0 => return None,206 nix_raw::err_NIX_ERR_UNKNOWN => Self::Unknown,207 nix_raw::err_NIX_ERR_OVERFLOW => Self::Overflow,208 nix_raw::err_NIX_ERR_KEY => Self::Key,209 nix_raw::err_NIX_ERR_NIX_ERROR => Self::Generic,210 _ => {211 debug_assert!(false, "unexpected nix error kind: {v}");212 Self::Unknown213 }214 })215 }216}217218pub fn gc_now() {219 unsafe { gc_now_raw() };220}221222pub fn gc_register_my_thread() {223 assert_eq!(unsafe { GC_thread_is_registered() }, 0);224225 let mut sb = GC_stack_base {226 mem_base: null_mut(),227 };228 let r = unsafe { GC_get_stack_base(&mut sb) };229 if r as u32 != GC_SUCCESS {230 panic!("failed to get thread stack base");231 }232 unsafe { GC_register_my_thread(&sb) };233}234pub fn gc_unregister_my_thread() {235 assert_eq!(unsafe { GC_thread_is_registered() }, 1);236237 unsafe { GC_unregister_my_thread() };238}239240pub struct ThreadRegisterGuard {}241impl ThreadRegisterGuard {242 #[allow(clippy::new_without_default)]243 pub fn new() -> Self {244 gc_register_my_thread();245 Self {}246 }247}248impl Drop for ThreadRegisterGuard {249 fn drop(&mut self) {250 gc_unregister_my_thread();251 }252}253254#[repr(transparent)]255pub struct NixContext(*mut c_context);256impl NixContext {257 pub fn set_err_raw(&mut self, err: NixErrorKind, msg: &CStr) {258 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };259 }260 pub fn set_err(&mut self, err: anyhow::Error) {261 let fmt = format!("{err:?}").replace("\0", "\\0");262 self.set_err_raw(263 NixErrorKind::Generic,264 &CString::new(fmt).expect("NUL bytes were just replaced"),265 );266 }267 pub fn new() -> Self {268 let ctx = unsafe { c_context_create() };269 Self(ctx)270 }271 fn error_kind(&self) -> Option<NixErrorKind> {272 let code = unsafe { err_code(self.0) };273 NixErrorKind::from_int(code)274 }275 fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {276 if let NixErrorKind::Generic = self.error_kind()? {277 let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };278 let mut err_out = String::new();279 unsafe {280 err_info_msg(281 null_mut(),282 self.0,283 Some(copy_nix_str),284 (&raw mut err_out).cast(),285 )286 };287 return Some((Cow::Owned(err_out), Some(ei)));288 };289290 291 292 let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };293 Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))294 }295 fn clean_err(&mut self) {296 unsafe {297 clear_err(self.0);298 }299 }300301 fn bail_if_error(&self) -> Result<()> {302 if let Some((err, stack)) = self.error() {303 let mut e = Err(anyhow!("{err}"));304 if let Some(stack) = stack {305 for ele in stack.stack_frames {306 e = e.with_context(|| {307 if ele.pos.is_empty() {308 ele.msg309 } else {310 format!("{} at {}", ele.msg, ele.pos)311 }312 })313 }314 }315 return e.context("<nix frames>");316 };317 Ok(())318 }319320 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {321 self.clean_err();322 let o = f(self.0);323 self.bail_if_error()?;324 self.clean_err();325 Ok(o)326 }327}328329impl Default for NixContext {330 fn default() -> Self {331 Self::new()332 }333}334impl Drop for NixContext {335 fn drop(&mut self) {336 unsafe {337 c_context_free(self.0);338 }339 }340}341struct GlobalState {342 343 #[allow(dead_code)]344 store: Arc<Store>,345 state: EvalState,346}347impl GlobalState {348 fn new() -> Result<Self> {349 let mut ctx = NixContext::new();350 let store = Arc::new(351 ctx.run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })352 .map(Store)?,353 );354355 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;356 ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;357 ctx.run_in_context(|c| unsafe {358 eval_state_builder_set_eval_setting(359 c,360 builder,361 c"lazy-trees".as_ptr(),362 c"true".as_ptr(),363 )364 })?;365 ctx.run_in_context(|c| unsafe {366 eval_state_builder_set_eval_setting(367 c,368 builder,369 c"lazy-locks".as_ptr(),370 c"true".as_ptr(),371 )372 })?;373 let state = ctx374 .run_in_context(|c| unsafe { eval_state_build(c, builder) })375 .map(EvalState)?;376377 Ok(Self { store, state })378 }379}380381struct ThreadState {382 ctx: NixContext,383}384impl ThreadState {385 fn new() -> Result<Self> {386 let ctx = NixContext::new();387388 Ok(Self { ctx })389 }390}391392static GLOBAL_STATE: LazyLock<GlobalState> =393 LazyLock::new(|| GlobalState::new().expect("global state init shouldn't fail"));394395thread_local! {396 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));397}398pub(crate) fn with_default_context<T>(399 f: impl FnOnce(*mut c_context, *mut c_eval_state) -> T,400) -> Result<T> {401 let global = &GLOBAL_STATE.state;402 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));403 let mut ctx = NixContext(ctx);404 let v = ctx.run_in_context(|c| f(c, state));405 406 std::mem::forget(ctx);407 v408}409410pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {411 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())412}413414pub fn get_setting(s: &CStr) -> Result<String> {415 let mut out = String::new();416 with_default_context(|c, _| unsafe {417 setting_get(c, s.as_ptr(), Some(copy_nix_str), (&raw mut out).cast())418 })?;419 Ok(out)420}421422#[derive(Debug)]423pub struct AddedFile {424 pub store_path: Utf8PathBuf,425 pub hash: String,426}427428#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]429pub struct ProfileGeneration {430 pub id: u64,431 pub store_path: Utf8PathBuf,432 pub creation_time_unix: i64,433 pub current: bool,434}435436#[instrument]437pub fn list_generations(profile_path: &str) -> Result<Vec<ProfileGeneration>> {438 let res = nix_cxx::list_generations(profile_path);439 if !res.error.is_empty() {440 bail!(441 "failed to list generations at {profile_path}: {}",442 res.error443 );444 }445 Ok(res446 .generations447 .into_iter()448 .map(|g| ProfileGeneration {449 id: g.id,450 store_path: Utf8PathBuf::from(g.store_path),451 creation_time_unix: g.creation_time_unix,452 current: g.current,453 })454 .collect())455}456457pub struct FetchSettings(*mut fetchers_settings);458impl FetchSettings {459 pub fn new() -> Self {460 Self::try_new().expect("allocation should not fail")461 }462 fn try_new() -> Result<Self> {463 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)464 }465 pub fn set(&mut self, setting: &CStr, value: &CStr) {466 unsafe {467 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());468 };469 }470}471unsafe impl Send for FetchSettings {}472unsafe impl Sync for FetchSettings {}473474impl Default for FetchSettings {475 fn default() -> Self {476 Self::new()477 }478}479480impl Drop for FetchSettings {481 fn drop(&mut self) {482 unsafe { fetchers_settings_free(self.0) };483 }484}485pub struct FlakeSettings(*mut flake_settings);486impl FlakeSettings {487 pub fn new() -> Result<Self> {488 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)489 }490}491unsafe impl Send for FlakeSettings {}492unsafe impl Sync for FlakeSettings {}493impl Drop for FlakeSettings {494 fn drop(&mut self) {495 unsafe {496 flake_settings_free(self.0);497 }498 }499}500501pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);502impl FlakeReferenceParseFlags {503 pub fn new(settings: &FlakeSettings) -> Result<Self> {504 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })505 .map(Self)506 }507 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {508 with_default_context(|c, _| {509 unsafe {510 flake_reference_parse_flags_set_base_directory(511 c,512 self.0,513 dir.as_ptr().cast(),514 dir.len(),515 )516 };517 })518 }519}520impl Drop for FlakeReferenceParseFlags {521 fn drop(&mut self) {522 unsafe {523 flake_reference_parse_flags_free(self.0);524 }525 }526}527pub struct FlakeLockFlags(*mut flake_lock_flags);528impl FlakeLockFlags {529 pub fn new(settings: &FlakeSettings) -> Result<Self> {530 let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })531 .map(Self)?;532 533534 Ok(o)535 }536}537impl Drop for FlakeLockFlags {538 fn drop(&mut self) {539 unsafe {540 flake_lock_flags_free(self.0);541 }542 }543}544545pub(crate) unsafe extern "C" fn copy_nix_str(546 start: *const c_char,547 n: c_uint,548 user_data: *mut c_void,549) {550 let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };551 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");552 unsafe { *user_data.cast::<String>() = s.to_owned() };553}554555pub struct Store(*mut c_store);556unsafe impl Send for Store {}557unsafe impl Sync for Store {}558559#[derive(Debug, Clone)]560pub struct PathInfo {561 pub nar_hash: String,562 pub nar_size: u64,563 pub references: Vec<Utf8PathBuf>,564 pub sigs: Vec<String>,565}566567pub fn eval_store() -> Arc<Store> {568 GLOBAL_STATE.store.clone()569}570571impl Store {572 pub fn open(uri: &str) -> Result<Self> {573 let uri = CString::new(uri)?;574 let ptr = with_default_context(|c, _| unsafe { store_open(c, uri.as_ptr(), null_mut()) })?;575 if ptr.is_null() {576 bail!("failed to open store");577 }578 Ok(Store(ptr))579 }580581 pub fn parse_path(&self, path: &Utf8Path) -> Result<StorePath> {582 let path = CString::new(path.as_str()).expect("valid cstr");583 with_default_context(|c, _| {584 StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })585 })586 }587588 #[instrument(skip(self))]589 pub fn sign_closure(&self, path: &Utf8Path, key_file: &Utf8Path) -> Result<()> {590 let err = with_default_context(|_, _| unsafe {591 nix_cxx::sign_closure(self.as_ptr().cast(), path.as_str(), key_file.as_str())592 })?593 .to_string();594595 if err.is_empty() {596 Ok(())597 } else {598 bail!("failed to sign {path}: {err}");599 }600 }601602 #[instrument(skip(self, dst))]603 pub fn copy_to(&self, dst: &Store, path: &Utf8Path) -> Result<()> {604 let sp = self605 .parse_path(path)606 .context("failed to parse store path")?;607 let rc = with_default_context(|c, _| unsafe {608 store_copy_closure(c, self.as_ptr(), dst.0, sp.as_ptr())609 })?;610 if rc != err_NIX_OK {611 bail!("store_copy_closure failed (code {rc})");612 }613 Ok(())614 }615616 617 #[instrument(skip(self))]618 pub fn switch_profile(&self, profile: &str, path: &Utf8Path) -> Result<()> {619 let msg = unsafe { nix_cxx::switch_profile(self.as_ptr().cast(), profile, path.as_str()) };620 if msg.is_empty() {621 Ok(())622 } else {623 bail!("failed to switch profile {profile}: {msg}");624 }625 }626627 #[instrument(skip(self))]628 pub fn add_file(&self, name: &str, path: &Utf8Path) -> Result<AddedFile> {629 let msg = unsafe { nix_cxx::add_file_to_store(self.as_ptr().cast(), name, path.as_str()) };630 if !msg.error.is_empty() {631 bail!("failed to add {path} to store: {}", msg.error)632 }633 Ok(AddedFile {634 store_path: Utf8PathBuf::from(msg.store_path),635 hash: msg.hash,636 })637 }638639 #[instrument(skip(self, paths))]640 pub fn substitute_paths(&self, paths: &[Utf8PathBuf]) -> Result<Vec<Utf8PathBuf>> {641 let joined = paths.into_iter().join("\n");642 let res = unsafe { nix_cxx::substitute_paths(self.as_ptr().cast(), &joined) };643 if !res.error.is_empty() {644 warn!("substitute_paths reported: {}", res.error);645 }646 Ok(res.outputs.into_iter().map(Utf8PathBuf::from).collect())647 }648649 #[instrument(skip(self))]650 pub fn is_valid_path(&self, path: &Utf8Path) -> bool {651 unsafe { nix_cxx::is_valid_path(self.as_ptr().cast(), path.as_str()) }652 }653654 #[instrument(skip(self))]655 pub fn query_path_info(&self, path: &Utf8Path) -> Result<PathInfo> {656 let res = unsafe { nix_cxx::query_path_info(self.as_ptr().cast(), path.as_str()) };657 if !res.error.is_empty() {658 bail!("failed to query path info for {path}: {}", res.error);659 }660 Ok(PathInfo {661 nar_hash: res.nar_hash,662 nar_size: res.nar_size,663 references: res.references.into_iter().map(Utf8PathBuf::from).collect(),664 sigs: res.sigs,665 })666 }667668 #[instrument(skip(self))]669 pub fn compute_closure(&self, path: &Utf8Path) -> Result<Vec<Utf8PathBuf>> {670 let res = unsafe { nix_cxx::compute_closure(self.as_ptr().cast(), path.as_str()) };671 if !res.error.is_empty() {672 bail!("failed to compute closure of {path}: {}", res.error);673 }674 Ok(res.outputs.into_iter().map(Utf8PathBuf::from).collect())675 }676677 #[instrument(skip(self, out))]678 pub fn nar_from_path(&self, path: &Utf8Path, out: &mut dyn std::io::Write) -> Result<()> {679 struct SinkState<'a> {680 out: &'a mut dyn std::io::Write,681 error: Option<std::io::Error>,682 }683 fn sink(state: usize, data: &[u8]) -> bool {684 let state = unsafe { &mut *(state as *mut SinkState) };685 match state.out.write_all(data) {686 Ok(()) => true,687 Err(e) => {688 state.error = Some(e);689 false690 }691 }692 }693 let mut state = SinkState { out, error: None };694 let msg = unsafe {695 nix_cxx::nar_from_path(696 self.as_ptr().cast(),697 path.as_str(),698 (&raw mut state) as usize,699 sink,700 )701 };702 if let Some(e) = state.error {703 return Err(anyhow!(e).context(format!("nar sink failed for {path}")));704 }705 if !msg.is_empty() {706 bail!("failed to dump nar of {path}: {msg}");707 }708 Ok(())709 }710711 #[instrument(skip(self))]712 pub fn build_drv_outputs(713 &self,714 drv_path: &Utf8Path,715 output_names: &[String],716 ) -> Result<Vec<String>> {717 let joined = output_names.join("\n");718 let res =719 unsafe { nix_cxx::build_drv_outputs(self.as_ptr().cast(), drv_path.as_str(), &joined) };720 if !res.error.is_empty() {721 bail!("build of {drv_path} failed: {}", res.error);722 }723 Ok(res.outputs)724 }725726 #[instrument(skip(self))]727 pub fn store_dir(&self) -> Result<Utf8PathBuf> {728 let mut out = String::new();729 with_default_context(|c, es| unsafe {730 nix_raw::store_get_storedir(c, self.as_ptr(), Some(copy_nix_str), (&raw mut out).cast())731 })?;732 let p = Utf8PathBuf::from(out);733 assert!(p.is_absolute());734 Ok(p)735 }736737 fn as_ptr(&self) -> *mut c_store {738 self.0739 }740}741impl Drop for Store {742 fn drop(&mut self) {743 unsafe { store_free(self.0) }744 }745}746747#[repr(transparent)]748pub struct EvalState(*mut c_eval_state);749unsafe impl Send for EvalState {}750unsafe impl Sync for EvalState {}751752impl Drop for EvalState {753 fn drop(&mut self) {754 unsafe {755 state_free(self.0);756 }757 }758}759760pub struct FlakeReference(*mut flake_reference);761impl FlakeReference {762 #[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]763 pub fn new(764 s: &str,765 flake: &FlakeSettings,766 parse: &FlakeReferenceParseFlags,767 fetch: &FetchSettings,768 ) -> Result<(Self, String)> {769 let mut out = null_mut();770 let mut fragment = String::new();771 772 with_default_context(|c, _| unsafe {773 flake_reference_and_fragment_from_string(774 c,775 fetch.0,776 flake.0,777 parse.0,778 s.as_ptr().cast(),779 s.len(),780 &mut out,781 Some(copy_nix_str),782 (&raw mut fragment).cast(),783 )784 })?;785 assert!(!out.is_null());786787 Ok((Self(out), fragment))788 }789 #[instrument(name = "lock-flake", skip(self, fetch, flake, lock))]790 pub fn lock(791 &mut self,792 fetch: &FetchSettings,793 flake: &FlakeSettings,794 lock: &FlakeLockFlags,795 ) -> Result<LockedFlake> {796 with_default_context(|c, es| unsafe { flake_lock(c, fetch.0, flake.0, es, lock.0, self.0) })797 .map(LockedFlake)798 }799}800unsafe impl Send for FlakeReference {}801unsafe impl Sync for FlakeReference {}802803pub struct LockedFlake(*mut locked_flake);804impl LockedFlake {805 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {806 with_default_context(|c, es| unsafe {807 locked_flake_get_output_attrs(c, settings.0, es, self.0)808 })809 .map(Value)810 }811}812unsafe impl Send for LockedFlake {}813unsafe impl Sync for LockedFlake {}814impl Drop for LockedFlake {815 fn drop(&mut self) {816 unsafe {817 locked_flake_free(self.0);818 };819 }820}821822type FieldName = [u8; 64];823fn init_field_name(v: &str) -> FieldName {824 let mut f = [0; 64];825 assert!(v.len() < 64, "max field name is 63 chars");826 assert!(827 v.bytes().all(|v| v != 0),828 "nul bytes are unsupported in field name"829 );830 f[0..v.len()].copy_from_slice(v.as_bytes());831 f832}833834pub struct RealisedString(*mut realised_string);835impl fmt::Debug for RealisedString {836 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {837 self.as_str().fmt(f)838 }839}840841impl RealisedString {842 pub fn as_str(&self) -> &str {843 let len = unsafe { realised_string_get_buffer_size(self.0) };844 let data: *const u8 = unsafe { realised_string_get_buffer_start(self.0) }.cast();845 let data = unsafe { slice::from_raw_parts(data, len) };846 std::str::from_utf8(data).expect("non-utf8 strings not supported")847 }848 pub fn path_count(&self) -> usize {849 unsafe { realised_string_get_store_path_count(self.0) }850 }851 pub fn path(&self, i: usize) -> String {852 assert!(i < self.path_count());853 let path = unsafe { realised_string_get_store_path(self.0, i) };854 let mut err_out = String::new();855 unsafe { store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };856 err_out857 }858}859860unsafe impl Send for RealisedString {}861impl Drop for RealisedString {862 fn drop(&mut self) {863 unsafe { realised_string_free(self.0) }864 }865}866867#[repr(transparent)]868pub struct Value(*mut value);869870unsafe impl Send for Value {}871unsafe impl Sync for Value {}872873pub trait AsFieldName {874 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;875 fn to_field_name(&self) -> Result<String>;876}877impl AsFieldName for Value {878 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {879 let f = self.to_string()?;880 v(init_field_name(&f))881 }882 fn to_field_name(&self) -> Result<String> {883 self.to_string()884 }885}886impl<E> AsFieldName for E887where888 E: AsRef<str>,889{890 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {891 let f = self.as_ref();892 v(init_field_name(f))893 }894 fn to_field_name(&self) -> Result<String> {895 Ok(self.as_ref().to_owned())896 }897}898899struct AttrsBuilder(*mut c_bindings_builder);900impl AttrsBuilder {901 fn new(capacity: usize) -> Self {902 with_default_context(|c, es| unsafe { make_bindings_builder(c, es, capacity) })903 .map(Self)904 .expect("alloc should not fail")905 }906 fn insert(&mut self, k: &impl AsFieldName, v: Value) {907 k.as_field_name(|name| {908 with_default_context(|c, _| unsafe {909 bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0);910 911 })912 })913 .expect("builder insert shouldn't fail");914 }915}916impl Drop for AttrsBuilder {917 fn drop(&mut self) {918 unsafe { bindings_builder_free(self.0) };919 }920}921922struct ListBuilder(*mut c_list_builder, c_uint);923impl ListBuilder {924 fn new(capacity: usize) -> Self {925 with_default_context(|c, es| unsafe { make_list_builder(c, es, capacity) })926 .map(|l| Self(l, 0))927 .expect("alloc should not fail")928 }929}930impl ListBuilder {931 fn push(&mut self, v: Value) {932 with_default_context(|c, _| unsafe {933 list_builder_insert(934 c,935 self.0,936 {937 let v = self.1;938 self.1 += 1;939 v940 },941 v.0,942 )943 })944 .expect("list insert shouldn't fail");945 }946}947impl Drop for ListBuilder {948 fn drop(&mut self) {949 unsafe { list_builder_free(self.0) };950 }951}952953impl Value {954 pub fn new_primop(v: NativeFn) -> Self {955 let out = Self::new_uninit();956 with_default_context(|c, _| unsafe { init_primop(c, out.0, v.0) })957 .expect("primop initialization should not fail");958 out959 }960 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {961 let out = Self::new_uninit();962 let mut b = AttrsBuilder::new(v.len());963 for (k, v) in v {964 b.insert(&k, v);965 }966 with_default_context(|c, _| unsafe { make_attrs(c, out.0, b.0) })967 .expect("attrs initialization should not fail");968969 out970 }971 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {972 let out = Self::new_uninit();973 let mut b = ListBuilder::new(v.len());974 for v in v {975 b.push(v.into());976 }977 with_default_context(|c, _| unsafe { make_list(c, b.0, out.0) })978 .expect("list initialization should not fail");979980 out981 }982 fn new_uninit() -> Self {983 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })984 .expect("value allocation should not fail");985 Self(out)986 }987 pub fn new_str(v: &str) -> Self {988 let s = CString::new(v).expect("string should not contain NULs");989 let out = Self::new_uninit();990 991 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })992 .expect("string initialization should not fail");993 out994 }995 pub fn new_int(i: i64) -> Self {996 let out = Self::new_uninit();997 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })998 .expect("int initialization should not fail");999 out1000 }1001 pub fn new_bool(v: bool) -> Self {1002 let out = Self::new_uninit();1003 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })1004 .expect("bool initialization should not fail");1005 out1006 }1007 1008 1009 1010 1011 1012 pub fn type_of(&self) -> NixType {1013 let ty = with_default_context(|c, _| unsafe { get_type(c, self.0) })1014 .expect("get_type should not fail");1015 NixType::from_int(ty)1016 }1017 fn builtin_to_string(&self) -> Result<Self> {1018 let builtin = Self::eval("builtins.toString")?;1019 builtin.call(self.clone())1020 }1021 fn force(&mut self, s: *mut nix_raw::EvalState) -> Result<()> {1022 with_default_context(|c, _| unsafe { value_force(c, s, self.0) })?;1023 Ok(())1024 }1025 pub fn to_string(&self) -> Result<String> {1026 let ty = self.type_of();1027 if !matches!(ty, NixType::String) {1028 bail!("unexpected type: {ty:?}, expected string");1029 }1030 let mut str_out = String::new();1031 with_default_context(|c, _| unsafe {1032 get_string(c, self.0, Some(copy_nix_str), (&raw mut str_out).cast())1033 })?;10341035 Ok(str_out)1036 }1037 pub fn to_realised_string(&self) -> Result<RealisedString> {1038 with_default_context(|c, es| unsafe { string_realise(c, es, self.0, false) })1039 .map(RealisedString)10401041 1042 1043 1044 1045 1046 1047 1048 }10491050 pub fn has_field(&self, field: &str) -> Result<bool> {1051 if !matches!(self.type_of(), NixType::Attrs) {1052 bail!("invalid type: expected attrs");1053 }10541055 let f = init_field_name(field);1056 with_default_context(|c, es| unsafe { has_attr_byname(c, self.0, es, f.as_ptr().cast()) })1057 }1058 1059 1060 1061 pub fn list_fields(&self) -> Result<Vec<String>> {1062 if !matches!(self.type_of(), NixType::Attrs) {1063 bail!("invalid type: expected attrs");1064 }10651066 let len = with_default_context(|c, _| unsafe { get_attrs_size(c, self.0) })?;1067 let mut out = Vec::with_capacity(len as usize);10681069 for i in 0..len {1070 let name =1071 with_default_context(|c, es| unsafe { get_attr_name_byidx(c, self.0, es, i) })?;1072 let c = unsafe { CStr::from_ptr(name) };1073 out.push(c.to_str().expect("nix field names are utf-8").to_owned());1074 }1075 Ok(out)1076 }1077 pub fn get_elem(&self, v: usize) -> Result<Self> {1078 if !matches!(self.type_of(), NixType::List) {1079 bail!("invalid type: expected list");1080 }1081 let len = with_default_context(|c, _| unsafe { get_list_size(c, self.0) })? as usize;1082 if v >= len {1083 bail!("oob list get: {v} >= {len}");1084 }10851086 with_default_context(|c, es| unsafe { get_list_byidx(c, self.0, es, v as u32) }).map(Self)1087 }1088 pub fn attrs_update(self, other: Value ) -> Result<Self> {1089 let attrs_update_fn = Self::eval("a: b: a // b")?;10901091 attrs_update_fn1092 .call(self)?1093 .call(other)1094 .context("attrs update")1095 }1096 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {1097 if !matches!(self.type_of(), NixType::Attrs) {1098 bail!("invalid type: expected attrs");1099 }11001101 name.as_field_name(|name| {1102 with_default_context(|c, es| unsafe {1103 get_attr_byname(c, self.0, es, name.as_ptr().cast())1104 })1105 .map(Self)1106 })1107 .with_context(|| format!("getting field {:?}", name.to_field_name()))1108 }1109 pub fn call(&self, v: Value) -> Result<Self> {1110 let kind = self1111 .functor_kind()1112 .ok_or_else(|| anyhow!("can only call function or functor"))?;11131114 let function = match kind {1115 FunctorKind::Function => self.clone(),1116 FunctorKind::Functor => {1117 let f = self1118 .get_field("__functor")1119 .context("getting functor value")?;1120 assert_eq!(1121 f.type_of(),1122 NixType::Function,1123 "invalid functor encountered"1124 );1125 f1126 }1127 };11281129 let out = Value::new_uninit();1130 with_default_context(|c, es| unsafe { value_call(c, es, function.0, v.0, out.0) })?;11311132 Ok(out)1133 }1134 pub fn eval(v: &str) -> Result<Self> {1135 let s = CString::new(v).expect("expression shouldn't have internal NULs");1136 let out = Self::new_uninit();1137 with_default_context(|c, es| unsafe {1138 expr_eval_from_string(c, es, s.as_ptr(), c"/root".as_ptr(), out.0)1139 })?;1140 Ok(out)1141 }1142 #[instrument(name = "build", skip(self), fields(output))]1143 pub fn build(&self, output: &str) -> Result<Utf8PathBuf> {1144 if !self.is_derivation() {1145 bail!("expected derivation to build")1146 }1147 let output_name = self1148 .get_field("outputName")1149 .context("getting output name field")?1150 .to_string()?;1151 let v = if output_name != output {1152 let out = self.get_field(output).context("getting target output")?;1153 if !out.is_derivation() {1154 bail!("unknown output: {output}");1155 }1156 out1157 } else {1158 self.clone()1159 };11601161 let drv_path = Utf8PathBuf::from(1162 v.get_field("drvPath")1163 .context("getting drvPath")?1164 .to_string()?,1165 );1166 let graph = Arc::new(drv::DrvGraph::resolve(&eval_store(), &drv_path)?);1167 let _guard = logging::register_build_graph(&Span::current(), &graph);11681169 scheduler::build_graph_sync(graph.clone(), vec![output.to_owned()])?;11701171 let s = v.builtin_to_string()?;1172 let rs = s.to_realised_string()?;1173 let out_path = rs.as_str().to_owned();1174 Ok(Utf8PathBuf::from(out_path))1175 }1176 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {1177 let to_json = Self::eval("builtins.toJSON")?;1178 let s = to_json.call(self.clone())?.to_string()?;1179 Ok(serde_json::from_str(&s)?)1180 }1181 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {1182 Self::eval(&nixlike::serialize(v)?)1183 }11841185 1186 1187 1188 1189 11901191 fn is_derivation(&self) -> bool {1192 if !matches!(self.type_of(), NixType::Attrs) {1193 return false;1194 }1195 let Some(ty) = self.get_field("type").ok() else {1196 return false;1197 };1198 matches!(ty.to_string().as_deref(), Ok("derivation"))1199 }1200 fn functor_kind(&self) -> Option<FunctorKind> {1201 match self.type_of() {1202 NixType::Attrs => self1203 .has_field("__functor")1204 .expect("has_field shouldn't fail for attrs")1205 .then_some(FunctorKind::Functor),1206 NixType::Function => Some(FunctorKind::Function),1207 _ => None,1208 }1209 }1210 pub fn is_function(&self) -> bool {1211 self.functor_kind().is_some()1212 }1213 pub fn is_null(&self) -> bool {1214 matches!(self.type_of(), NixType::Null)1215 }1216 pub fn is_string(&self) -> bool {1217 matches!(self.type_of(), NixType::String)1218 }1219 pub fn is_attrs(&self) -> bool {1220 matches!(self.type_of(), NixType::Attrs)1221 }1222}12231224impl From<String> for Value {1225 fn from(value: String) -> Self {1226 Value::new_str(&value)1227 }1228}1229impl From<bool> for Value {1230 fn from(value: bool) -> Self {1231 Value::new_bool(value)1232 }1233}1234impl From<&str> for Value {1235 fn from(value: &str) -> Self {1236 Value::new_str(value)1237 }1238}1239impl<T> From<Vec<T>> for Value1240where1241 T: Into<Value>,1242{1243 fn from(value: Vec<T>) -> Self {1244 Value::new_list(value)1245 }1246}12471248impl Clone for Value {1249 fn clone(&self) -> Self {1250 with_default_context(|c, _| unsafe { value_incref(c, self.0) })1251 .expect("value incref should not fail");1252 Self(self.0)1253 }1254}1255impl Drop for Value {1256 fn drop(&mut self) {1257 with_default_context(|c, _| unsafe { value_decref(c, self.0) })1258 .expect("value drop should not fail");1259 }1260}12611262static TOKIO_FOR_NIX: OnceLock<Arc<tokio::runtime::Runtime>> = OnceLock::new();12631264pub fn init_libraries() {1265 unsafe { GC_allow_register_threads() };12661267 let mut ctx = NixContext::new();1268 ctx.run_in_context(|c| unsafe { libutil_init(c) })1269 .expect("util init should not fail");1270 ctx.run_in_context(|c| unsafe { libstore_init(c) })1271 .expect("store init should not fail");1272 ctx.run_in_context(|c| unsafe { libexpr_init(c) })1273 .expect("expr init should not fail");12741275 nix_logging_cxx::apply_tracing_logger();1276}12771278pub fn init_tokio_for_nix(tokio: Arc<tokio::runtime::Runtime>) {1279 TOKIO_FOR_NIX1280 .set(tokio)1281 .expect("tokio for nix should only be initialized once");1282}12831284pub fn await_in_nix<F: Send + 'static>(f: impl Future<Output = F> + Send + 'static) -> F {1285 1286 let runtime = TOKIO_FOR_NIX1287 .get()1288 .expect("init_tokio_for_nix was not called");1289 std::thread::spawn(move || runtime.block_on(f))1290 .join()1291 .expect("await_in_nix inner thread panicked")1292}12931294unsafe extern "C" fn nix_primop_closure_adapter<const N: usize>(1295 user_data: *mut c_void,1296 mut context: *mut c_context,1297 state: *mut nix_raw::EvalState,1298 args: *mut *mut value,1299 ret: *mut value,1300) {1301 let user_closure: &UserClosure<N> = unsafe { &*user_data.cast_const().cast() };1302 let args: [&Value; N] = array::from_fn(|i| {1303 let v: &mut Value = unsafe { &mut *args.add(i).cast() };1304 v as &Value1305 });1306 let ctx: &mut NixContext = unsafe { transmute(&mut context) };13071308 let state: &EvalState = unsafe { std::mem::transmute(&state) };13091310 match user_closure(state, args) {1311 Ok(v) => {1312 unsafe { copy_value(context, ret, v.0) };1313 }1314 Err(e) => {1315 ctx.set_err(e);1316 }1317 }1318}13191320type UserClosure<const N: usize> = Box<dyn Fn(&EvalState, [&Value; N]) -> Result<Value>>;13211322pub struct NativeFn(*mut PrimOp);1323impl NativeFn {1324 pub fn new<const N: usize>(1325 name: &'static CStr,1326 doc: &'static CStr,1327 args: [&'static CStr; N],1328 f: impl Fn(&EvalState, [&Value; N]) -> Result<Value> + 'static,1329 ) -> Self {1330 1331 let closure: Box<UserClosure<N>> = Box::new(Box::new(f));1332 let f: PrimOpFun = Some(nix_primop_closure_adapter::<N>);1333 let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();1334 args.push(null());1335 let args = args.as_mut_ptr();1336 let primop = unsafe {1337 alloc_primop(1338 null_mut(),1339 f,1340 N as i32,1341 name.as_ptr(),1342 args,1343 doc.as_ptr(),1344 Box::into_raw(closure).cast(),1345 )1346 };13471348 assert!(!primop.is_null(), "primop allocation should not fail");13491350 Self(primop)1351 }1352 pub fn register(self) {1353 unsafe { register_primop(null_mut(), self.0) };1354 }1355}13561357pub struct StorePath(*mut c_store_path);1358impl StorePath {1359 fn as_ptr(&self) -> *mut c_store_path {1360 self.01361 }1362}13631364impl Drop for StorePath {1365 fn drop(&mut self) {1366 unsafe { store_path_free(self.0) }1367 }1368}13691370#[test_log::test]1371fn test_native() -> Result<()> {1372 init_libraries();1373 NativeFn::new(1374 c"__uppercaseSuffix2",1375 c"make string uppercase and add suffix",1376 [c"str", c"suffix"],1377 |_, [str, suffix]: [&Value; 2]| {1378 let str = str.to_string()?;1379 let suffix = suffix.to_string()?;1380 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1381 },1382 )1383 .register();13841385 let mut fetch_settings = FetchSettings::new();1386 fetch_settings.set(c"warn-dirty", c"false");13871388 let manifest = format!("git+file://{}/../../", env!("CARGO_MANIFEST_DIR"));1389 let flake = FlakeSettings::new()?;1390 let parse = FlakeReferenceParseFlags::new(&flake)?;1391 let (mut r, _) = FlakeReference::new(&manifest, &flake, &parse, &fetch_settings)?;1392 let lock = FlakeLockFlags::new(&flake)?;1393 let locked = r.lock(&fetch_settings, &flake, &lock)?;1394 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;13951396 let builtins = Value::eval("builtins")?;1397 assert_eq!(builtins.type_of(), NixType::Attrs);13981399 assert_eq!(attrs.type_of(), NixType::Attrs);1400 let test_data = nix_go!(attrs.testData);14011402 let test_string: String = nix_go_json!(test_data.testString);1403 assert_eq!(test_string, "hello");14041405 let s = nix_go!(attrs.packages["x86_64-linux"].fleet.drvPath);1406 let s = CString::new(s.to_string()?).expect("path str is cstring");14071408 let uppercase_suffix = Value::new_primop(NativeFn::new(1409 c"uppercase_suffix",1410 c"make string uppercase and add suffix",1411 [c"str", c"suffix"],1412 |es, [str, suffix]: [&Value; 2]| {1413 let str = str.to_string()?;1414 let suffix = suffix.to_string()?;1415 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1416 },1417 ));14181419 let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));1420 assert_eq!(test_result, "PREFIX_BODY_SUFFIX");1421 let test_result: String = nix_go_json!(builtins.uppercaseSuffix2("test")("suffix"));1422 assert_eq!(test_result, "TESTsuffix");14231424 let drv_path =1425 nix_go!(attrs.packages["x86_64-linux"]["fleet-install-secrets"].drvPath).to_string()?;1426 let graph = drv::DrvGraph::resolve(&drv_path)?;1427 eprintln!(1428 "fleet-install-secrets dependency graph: {} nodes",1429 graph.nodes.len()1430 );1431 for (path, node) in &graph.nodes {1432 if !node.input_drvs.is_empty() {1433 eprintln!(" {} ({} deps)", node.name, node.input_drvs.len());1434 }1435 }14361437 Ok(())1438}1439144014411442144314441445144614471448144914501451145214531454145514561457