1use std::borrow::Cow;2use std::cell::RefCell;3use std::ffi::{CStr, CString, c_char, c_int, c_uint, c_void};4use std::ptr::{null, null_mut};5use std::sync::{Arc, LazyLock, OnceLock};6use std::{array, fmt, slice};7use std::{collections::HashMap, path::PathBuf};89use anyhow::{Context, anyhow, bail};10use itertools::Itertools;11use serde::Serialize;12use serde::de::DeserializeOwned;13use std::mem::transmute;1415pub use anyhow::Result;16use tracing::{Instrument, info, instrument, warn};1718use self::logging::{ErrorInfoBuilder, nix_logging_cxx};19use self::nix_cxx::set_fetcher_setting;20use self::nix_raw::{21 BindingsBuilder as c_bindings_builder, EvalState as c_eval_state, GC_SUCCESS,22 GC_allow_register_threads, GC_get_stack_base, GC_register_my_thread, GC_stack_base,23 GC_thread_is_registered, GC_unregister_my_thread, ListBuilder as c_list_builder, PrimOp,24 PrimOpFun, Store as c_store, StorePath as c_store_path, alloc_primop, alloc_value,25 bindings_builder_free, bindings_builder_insert, c_context, c_context_create, c_context_free,26 clear_err, copy_value, err_NIX_ERR_KEY, err_NIX_ERR_NIX_ERROR, err_NIX_ERR_OVERFLOW,27 err_NIX_ERR_UNKNOWN, err_code, err_info_msg, err_msg, eval_state_build,28 eval_state_builder_load, eval_state_builder_new, eval_state_builder_set_eval_setting,29 expr_eval_from_string, fetchers_settings, fetchers_settings_free, fetchers_settings_new,30 flake_lock, flake_lock_flags, flake_lock_flags_free, flake_lock_flags_new, flake_reference,31 flake_reference_and_fragment_from_string, flake_reference_parse_flags,32 flake_reference_parse_flags_free, flake_reference_parse_flags_new,33 flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,34 flake_settings_new, gc_now as gc_now_raw, get_attr_byname, get_attr_name_byidx, get_attrs_size,35 get_list_byidx, get_list_size, get_string, get_type, has_attr_byname, init_bool, init_int,36 init_primop, init_string, libexpr_init, libstore_init, libutil_init, list_builder_free,37 list_builder_insert, locked_flake, locked_flake_free, locked_flake_get_output_attrs,38 make_attrs, make_bindings_builder, make_list, make_list_builder, realised_string,39 realised_string_free, realised_string_get_buffer_size, realised_string_get_buffer_start,40 realised_string_get_store_path, realised_string_get_store_path_count, register_primop,41 set_err_msg, setting_set, state_free, store_open, store_parse_path, store_path_free,42 store_path_name, string_realise, value, value_call, value_decref, value_force, value_incref,43};444546pub mod logging;47#[doc(hidden)]48pub mod macros;49pub mod util;5051#[allow(52 non_upper_case_globals,53 non_camel_case_types,54 non_snake_case,55 dead_code56)]57mod nix_raw {58 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));59}60#[cxx::bridge]61pub mod nix_cxx {62 unsafe extern "C++" {63 type nix_fetchers_settings;64 include!("nix-eval/src/lib.hh");6566 #[allow(clippy::missing_safety_doc)]67 unsafe fn set_fetcher_setting(68 settings: *mut nix_fetchers_settings,69 setting: *const c_char,70 value: *const c_char,71 );72 }73}7475#[derive(Debug, PartialEq, Eq)]76pub enum NixType {77 Thunk,78 Int,79 Float,80 Bool,81 String,82 Path,83 Null,84 Attrs,85 List,86 Function,87 External,88}89impl NixType {90 fn from_int(c: c_uint) -> Self {91 match c {92 0 => Self::Thunk,93 1 => Self::Int,94 2 => Self::Float,95 3 => Self::Bool,96 4 => Self::String,97 5 => Self::Path,98 6 => Self::Null,99 7 => Self::Attrs,100 8 => Self::List,101 9 => Self::Function,102 10 => Self::External,103 _ => unreachable!("unknown nix type: {c}"),104 }105 }106}107108enum FunctorKind {109 Function,110 Functor,111}112113#[derive(Debug)]114#[repr(i32)]115pub enum NixErrorKind {116 Unknown = err_NIX_ERR_UNKNOWN,117 Overflow = err_NIX_ERR_OVERFLOW,118 Key = err_NIX_ERR_KEY,119 Generic = err_NIX_ERR_NIX_ERROR,120}121impl NixErrorKind {122 fn from_int(v: c_int) -> Option<Self> {123 Some(match v {124 0 => return None,125 nix_raw::err_NIX_ERR_UNKNOWN => Self::Unknown,126 nix_raw::err_NIX_ERR_OVERFLOW => Self::Overflow,127 nix_raw::err_NIX_ERR_KEY => Self::Key,128 nix_raw::err_NIX_ERR_NIX_ERROR => Self::Generic,129 _ => {130 debug_assert!(false, "unexpected nix error kind: {v}");131 Self::Unknown132 }133 })134 }135}136137pub fn gc_now() {138 unsafe { gc_now_raw() };139}140141pub fn gc_register_my_thread() {142 assert_eq!(unsafe { GC_thread_is_registered() }, 0);143144 let mut sb = GC_stack_base {145 mem_base: null_mut(),146 };147 let r = unsafe { GC_get_stack_base(&mut sb) };148 if r as u32 != GC_SUCCESS {149 panic!("failed to get thread stack base");150 }151 unsafe { GC_register_my_thread(&sb) };152}153pub fn gc_unregister_my_thread() {154 assert_eq!(unsafe { GC_thread_is_registered() }, 1);155156 unsafe { GC_unregister_my_thread() };157}158159pub struct ThreadRegisterGuard {}160impl ThreadRegisterGuard {161 #[allow(clippy::new_without_default)]162 pub fn new() -> Self {163 gc_register_my_thread();164 Self {}165 }166}167impl Drop for ThreadRegisterGuard {168 fn drop(&mut self) {169 gc_unregister_my_thread();170 }171}172173#[repr(transparent)]174pub struct NixContext(*mut c_context);175impl NixContext {176 pub fn set_err_raw(&mut self, err: NixErrorKind, msg: &CStr) {177 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };178 }179 pub fn set_err(&mut self, err: anyhow::Error) {180 let mut fmt = format!("{err:?}").replace("\0", "\\0");181 self.set_err_raw(182 NixErrorKind::Generic,183 &CString::new(fmt).expect("NUL bytes were just replaced"),184 );185 }186 pub fn new() -> Self {187 let ctx = unsafe { c_context_create() };188 Self(ctx)189 }190 fn error_kind(&self) -> Option<NixErrorKind> {191 let code = unsafe { err_code(self.0) };192 NixErrorKind::from_int(code)193 }194 fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {195 if let NixErrorKind::Generic = self.error_kind()? {196 let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };197 let mut err_out = String::new();198 unsafe {199 err_info_msg(200 null_mut(),201 self.0,202 Some(copy_nix_str),203 (&raw mut err_out).cast(),204 )205 };206 return Some((Cow::Owned(err_out), Some(ei)));207 };208209 210 211 let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };212 Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))213 }214 fn clean_err(&mut self) {215 unsafe {216 clear_err(self.0);217 }218 }219220 fn bail_if_error(&self) -> Result<()> {221 if let Some((err, stack)) = self.error() {222 let mut e = Err(anyhow!("{err}"));223 if let Some(stack) = stack {224 for ele in stack.stack_frames {225 e = e.with_context(|| {226 if ele.pos.is_empty() {227 ele.msg228 } else {229 format!("{} at {}", ele.msg, ele.pos)230 }231 })232 }233 }234 return e.context("<nix frames>");235 };236 Ok(())237 }238239 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {240 self.clean_err();241 let o = f(self.0);242 self.bail_if_error()?;243 self.clean_err();244 Ok(o)245 }246}247248impl Default for NixContext {249 fn default() -> Self {250 Self::new()251 }252}253impl Drop for NixContext {254 fn drop(&mut self) {255 unsafe {256 c_context_free(self.0);257 }258 }259}260struct GlobalState {261 262 #[allow(dead_code)]263 store: Store,264 state: EvalState,265}266impl GlobalState {267 fn new() -> Result<Self> {268 let mut ctx = NixContext::new();269 let store = ctx270 .run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })271 .map(Store)?;272273 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;274 ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;275 ctx.run_in_context(|c| unsafe {276 eval_state_builder_set_eval_setting(277 c,278 builder,279 c"lazy-trees".as_ptr(),280 c"true".as_ptr(),281 )282 })?;283 ctx.run_in_context(|c| unsafe {284 eval_state_builder_set_eval_setting(285 c,286 builder,287 c"lazy-locks".as_ptr(),288 c"true".as_ptr(),289 )290 })?;291 let state = ctx292 .run_in_context(|c| unsafe { eval_state_build(c, builder) })293 .map(EvalState)?;294295 Ok(Self { store, state })296 }297}298299struct ThreadState {300 ctx: NixContext,301}302impl ThreadState {303 fn new() -> Result<Self> {304 let ctx = NixContext::new();305306 Ok(Self { ctx })307 }308}309310static GLOBAL_STATE: LazyLock<GlobalState> = LazyLock::new(|| {311 info!("initializing nix global state");312 GlobalState::new().expect("global state init shouldn't fail")313});314315thread_local! {316 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));317}318fn with_default_context<T>(f: impl FnOnce(*mut c_context, *mut c_eval_state) -> T) -> Result<T> {319 let global = &GLOBAL_STATE.state;320 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));321 let mut ctx = NixContext(ctx);322 let v = ctx.run_in_context(|c| f(c, state));323 324 std::mem::forget(ctx);325 v326}327328pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {329 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())330}331332pub struct FetchSettings(*mut fetchers_settings);333impl FetchSettings {334 pub fn new() -> Self {335 Self::try_new().expect("allocation should not fail")336 }337 fn try_new() -> Result<Self> {338 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)339 }340 pub fn set(&mut self, setting: &CStr, value: &CStr) {341 unsafe {342 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());343 };344 }345}346unsafe impl Send for FetchSettings {}347unsafe impl Sync for FetchSettings {}348349impl Default for FetchSettings {350 fn default() -> Self {351 Self::new()352 }353}354355impl Drop for FetchSettings {356 fn drop(&mut self) {357 unsafe { fetchers_settings_free(self.0) };358 }359}360pub struct FlakeSettings(*mut flake_settings);361impl FlakeSettings {362 pub fn new() -> Result<Self> {363 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)364 }365}366unsafe impl Send for FlakeSettings {}367unsafe impl Sync for FlakeSettings {}368impl Drop for FlakeSettings {369 fn drop(&mut self) {370 unsafe {371 flake_settings_free(self.0);372 }373 }374}375376pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);377impl FlakeReferenceParseFlags {378 pub fn new(settings: &FlakeSettings) -> Result<Self> {379 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })380 .map(Self)381 }382 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {383 with_default_context(|c, _| {384 unsafe {385 flake_reference_parse_flags_set_base_directory(386 c,387 self.0,388 dir.as_ptr().cast(),389 dir.len(),390 )391 };392 })393 }394}395impl Drop for FlakeReferenceParseFlags {396 fn drop(&mut self) {397 unsafe {398 flake_reference_parse_flags_free(self.0);399 }400 }401}402pub struct FlakeLockFlags(*mut flake_lock_flags);403impl FlakeLockFlags {404 pub fn new(settings: &FlakeSettings) -> Result<Self> {405 let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })406 .map(Self)?;407 408409 Ok(o)410 }411}412impl Drop for FlakeLockFlags {413 fn drop(&mut self) {414 unsafe {415 flake_lock_flags_free(self.0);416 }417 }418}419420unsafe extern "C" fn copy_nix_str(start: *const c_char, n: c_uint, user_data: *mut c_void) {421 let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };422 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");423 unsafe { *user_data.cast::<String>() = s.to_owned() };424}425426struct Store(*mut c_store);427unsafe impl Send for Store {}428unsafe impl Sync for Store {}429430impl Store {431 fn parse_path(&self, path: &CStr) -> Result<StorePath> {432 with_default_context(|c, _| {433 StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })434 })435 }436}437438#[repr(transparent)]439pub struct EvalState(*mut c_eval_state);440unsafe impl Send for EvalState {}441unsafe impl Sync for EvalState {}442443impl Drop for EvalState {444 fn drop(&mut self) {445 unsafe {446 state_free(self.0);447 }448 }449}450451pub struct FlakeReference(*mut flake_reference);452impl FlakeReference {453 #[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]454 pub fn new(455 s: &str,456 flake: &FlakeSettings,457 parse: &FlakeReferenceParseFlags,458 fetch: &FetchSettings,459 ) -> Result<(Self, String)> {460 let mut out = null_mut();461 let mut fragment = String::new();462 463 with_default_context(|c, _| unsafe {464 flake_reference_and_fragment_from_string(465 c,466 fetch.0,467 flake.0,468 parse.0,469 s.as_ptr().cast(),470 s.len(),471 &mut out,472 Some(copy_nix_str),473 (&raw mut fragment).cast(),474 )475 })?;476 assert!(!out.is_null());477478 Ok((Self(out), fragment))479 }480 #[instrument(name = "lock-flake", skip(self, fetch, flake, lock))]481 pub fn lock(482 &mut self,483 fetch: &FetchSettings,484 flake: &FlakeSettings,485 lock: &FlakeLockFlags,486 ) -> Result<LockedFlake> {487 with_default_context(|c, es| unsafe { flake_lock(c, fetch.0, flake.0, es, lock.0, self.0) })488 .map(LockedFlake)489 }490}491unsafe impl Send for FlakeReference {}492unsafe impl Sync for FlakeReference {}493494pub struct LockedFlake(*mut locked_flake);495impl LockedFlake {496 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {497 with_default_context(|c, es| unsafe {498 locked_flake_get_output_attrs(c, settings.0, es, self.0)499 })500 .map(Value)501 }502}503unsafe impl Send for LockedFlake {}504unsafe impl Sync for LockedFlake {}505impl Drop for LockedFlake {506 fn drop(&mut self) {507 unsafe {508 locked_flake_free(self.0);509 };510 }511}512513type FieldName = [u8; 64];514fn init_field_name(v: &str) -> FieldName {515 let mut f = [0; 64];516 assert!(v.len() < 64, "max field name is 63 chars");517 assert!(518 v.bytes().all(|v| v != 0),519 "nul bytes are unsupported in field name"520 );521 f[0..v.len()].copy_from_slice(v.as_bytes());522 f523}524525pub struct RealisedString(*mut realised_string);526impl fmt::Debug for RealisedString {527 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {528 self.as_str().fmt(f)529 }530}531532impl RealisedString {533 pub fn as_str(&self) -> &str {534 let len = unsafe { realised_string_get_buffer_size(self.0) };535 let data: *const u8 = unsafe { realised_string_get_buffer_start(self.0) }.cast();536 let data = unsafe { slice::from_raw_parts(data, len) };537 std::str::from_utf8(data).expect("non-utf8 strings not supported")538 }539 pub fn path_count(&self) -> usize {540 unsafe { realised_string_get_store_path_count(self.0) }541 }542 pub fn path(&self, i: usize) -> String {543 assert!(i < self.path_count());544 let path = unsafe { realised_string_get_store_path(self.0, i) };545 let mut err_out = String::new();546 unsafe { store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };547 err_out548 }549}550551unsafe impl Send for RealisedString {}552impl Drop for RealisedString {553 fn drop(&mut self) {554 unsafe { realised_string_free(self.0) }555 }556}557558#[repr(transparent)]559pub struct Value(*mut value);560561unsafe impl Send for Value {}562unsafe impl Sync for Value {}563564pub trait AsFieldName {565 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;566 fn to_field_name(&self) -> Result<String>;567}568impl AsFieldName for Value {569 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {570 let f = self.to_string()?;571 v(init_field_name(&f))572 }573 fn to_field_name(&self) -> Result<String> {574 self.to_string()575 }576}577impl<E> AsFieldName for E578where579 E: AsRef<str>,580{581 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {582 let f = self.as_ref();583 v(init_field_name(f))584 }585 fn to_field_name(&self) -> Result<String> {586 Ok(self.as_ref().to_owned())587 }588}589590struct AttrsBuilder(*mut c_bindings_builder);591impl AttrsBuilder {592 fn new(capacity: usize) -> Self {593 with_default_context(|c, es| unsafe { make_bindings_builder(c, es, capacity) })594 .map(Self)595 .expect("alloc should not fail")596 }597 fn insert(&mut self, k: &impl AsFieldName, v: Value) {598 k.as_field_name(|name| {599 with_default_context(|c, _| unsafe {600 bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0);601 602 })603 })604 .expect("builder insert shouldn't fail");605 }606}607impl Drop for AttrsBuilder {608 fn drop(&mut self) {609 unsafe { bindings_builder_free(self.0) };610 }611}612613struct ListBuilder(*mut c_list_builder, c_uint);614impl ListBuilder {615 fn new(capacity: usize) -> Self {616 with_default_context(|c, es| unsafe { make_list_builder(c, es, capacity) })617 .map(|l| Self(l, 0))618 .expect("alloc should not fail")619 }620}621impl ListBuilder {622 fn push(&mut self, v: Value) {623 with_default_context(|c, _| unsafe {624 list_builder_insert(625 c,626 self.0,627 {628 let v = self.1;629 self.1 += 1;630 v631 },632 v.0,633 )634 })635 .expect("list insert shouldn't fail");636 }637}638impl Drop for ListBuilder {639 fn drop(&mut self) {640 unsafe { list_builder_free(self.0) };641 }642}643644impl Value {645 pub fn new_primop(v: NativeFn) -> Self {646 let out = Self::new_uninit();647 with_default_context(|c, _| unsafe { init_primop(c, out.0, v.0) })648 .expect("primop initialization should not fail");649 out650 }651 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {652 let out = Self::new_uninit();653 let mut b = AttrsBuilder::new(v.len());654 for (k, v) in v {655 b.insert(&k, v);656 }657 with_default_context(|c, _| unsafe { make_attrs(c, out.0, b.0) })658 .expect("attrs initialization should not fail");659660 out661 }662 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {663 let out = Self::new_uninit();664 let mut b = ListBuilder::new(v.len());665 for v in v {666 b.push(v.into());667 }668 with_default_context(|c, _| unsafe { make_list(c, b.0, out.0) })669 .expect("list initialization should not fail");670671 out672 }673 fn new_uninit() -> Self {674 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })675 .expect("value allocation should not fail");676 Self(out)677 }678 pub fn new_str(v: &str) -> Self {679 let s = CString::new(v).expect("string should not contain NULs");680 let out = Self::new_uninit();681 682 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })683 .expect("string initialization should not fail");684 out685 }686 pub fn new_int(i: i64) -> Self {687 let out = Self::new_uninit();688 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })689 .expect("int initialization should not fail");690 out691 }692 pub fn new_bool(v: bool) -> Self {693 let out = Self::new_uninit();694 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })695 .expect("bool initialization should not fail");696 out697 }698 699 700 701 702 703 pub fn type_of(&self) -> NixType {704 let ty = with_default_context(|c, _| unsafe { get_type(c, self.0) })705 .expect("get_type should not fail");706 NixType::from_int(ty)707 }708 fn builtin_to_string(&self) -> Result<Self> {709 let builtin = Self::eval("builtins.toString")?;710 builtin.call(self.clone())711 }712 fn force(&mut self, s: *mut nix_raw::EvalState) -> Result<()> {713 with_default_context(|c, _| unsafe { value_force(c, s, self.0) })?;714 Ok(())715 }716 pub fn to_string(&self) -> Result<String> {717 let ty = self.type_of();718 if !matches!(ty, NixType::String) {719 bail!("unexpected type: {ty:?}, expected string");720 }721 let mut str_out = String::new();722 with_default_context(|c, _| unsafe {723 get_string(c, self.0, Some(copy_nix_str), (&raw mut str_out).cast())724 })?;725726 Ok(str_out)727 }728 pub fn to_realised_string(&self) -> Result<RealisedString> {729 with_default_context(|c, es| unsafe { string_realise(c, es, self.0, false) })730 .map(RealisedString)731732 733 734 735 736 737 738 739 }740741 pub fn has_field(&self, field: &str) -> Result<bool> {742 if !matches!(self.type_of(), NixType::Attrs) {743 bail!("invalid type: expected attrs");744 }745746 let f = init_field_name(field);747 with_default_context(|c, es| unsafe { has_attr_byname(c, self.0, es, f.as_ptr().cast()) })748 }749 750 751 752 pub fn list_fields(&self) -> Result<Vec<String>> {753 if !matches!(self.type_of(), NixType::Attrs) {754 bail!("invalid type: expected attrs");755 }756757 let len = with_default_context(|c, _| unsafe { get_attrs_size(c, self.0) })?;758 let mut out = Vec::with_capacity(len as usize);759760 for i in 0..len {761 let name =762 with_default_context(|c, es| unsafe { get_attr_name_byidx(c, self.0, es, i) })?;763 let c = unsafe { CStr::from_ptr(name) };764 out.push(c.to_str().expect("nix field names are utf-8").to_owned());765 }766 Ok(out)767 }768 pub fn get_elem(&self, v: usize) -> Result<Self> {769 if !matches!(self.type_of(), NixType::List) {770 bail!("invalid type: expected list");771 }772 let len = with_default_context(|c, _| unsafe { get_list_size(c, self.0) })? as usize;773 if v >= len {774 bail!("oob list get: {v} >= {len}");775 }776777 with_default_context(|c, es| unsafe { get_list_byidx(c, self.0, es, v as u32) }).map(Self)778 }779 pub fn attrs_update(self, other: Value ) -> Result<Self> {780 let attrs_update_fn = Self::eval("a: b: a // b")?;781782 attrs_update_fn783 .call(self)?784 .call(other)785 .context("attrs update")786 }787 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {788 if !matches!(self.type_of(), NixType::Attrs) {789 bail!("invalid type: expected attrs");790 }791792 name.as_field_name(|name| {793 with_default_context(|c, es| unsafe {794 get_attr_byname(c, self.0, es, name.as_ptr().cast())795 })796 .map(Self)797 })798 .with_context(|| format!("getting field {:?}", name.to_field_name()))799 }800 pub fn call(&self, v: Value) -> Result<Self> {801 let kind = self802 .functor_kind()803 .ok_or_else(|| anyhow!("can only call function or functor"))?;804805 let function = match kind {806 FunctorKind::Function => self.clone(),807 FunctorKind::Functor => {808 let f = self809 .get_field("__functor")810 .context("getting functor value")?;811 assert_eq!(812 f.type_of(),813 NixType::Function,814 "invalid functor encountered"815 );816 f817 }818 };819820 let out = Value::new_uninit();821 with_default_context(|c, es| unsafe { value_call(c, es, function.0, v.0, out.0) })?;822823 Ok(out)824 }825 pub fn eval(v: &str) -> Result<Self> {826 let s = CString::new(v).expect("expression shouldn't have internal NULs");827 let out = Self::new_uninit();828 with_default_context(|c, es| unsafe {829 expr_eval_from_string(c, es, s.as_ptr(), c"/root".as_ptr(), out.0)830 })?;831 Ok(out)832 }833 pub fn build(&self, output: &str) -> Result<PathBuf> {834 if !self.is_derivation() {835 bail!("expected derivation to build")836 }837 let output_name = self838 .get_field("outputName")839 .context("getting output name field")?840 .to_string()?;841 let v = if output_name != output {842 let out = self.get_field(output).context("getting target output")?;843 if !out.is_derivation() {844 bail!("unknown output: {output}");845 }846 out847 } else {848 self.clone()849 };850 851 let s = v.builtin_to_string()?;852 let rs = s.to_realised_string()?;853 let drv_path = rs.as_str().to_owned();854 Ok(PathBuf::from(drv_path))855 }856 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {857 let to_json = Self::eval("builtins.toJSON")?;858 let s = to_json.call(self.clone())?.to_string()?;859 Ok(serde_json::from_str(&s)?)860 }861 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {862 Self::eval(&nixlike::serialize(v)?)863 }864865 866 867 868 869 870871 fn is_derivation(&self) -> bool {872 if !matches!(self.type_of(), NixType::Attrs) {873 return false;874 }875 let Some(ty) = self.get_field("type").ok() else {876 return false;877 };878 matches!(ty.to_string().as_deref(), Ok("derivation"))879 }880 fn functor_kind(&self) -> Option<FunctorKind> {881 match self.type_of() {882 NixType::Attrs => self883 .has_field("__functor")884 .expect("has_field shouldn't fail for attrs")885 .then_some(FunctorKind::Functor),886 NixType::Function => Some(FunctorKind::Function),887 _ => None,888 }889 }890 pub fn is_function(&self) -> bool {891 self.functor_kind().is_some()892 }893 pub fn is_null(&self) -> bool {894 matches!(self.type_of(), NixType::Null)895 }896 pub fn is_string(&self) -> bool {897 matches!(self.type_of(), NixType::String)898 }899 pub fn is_attrs(&self) -> bool {900 matches!(self.type_of(), NixType::Attrs)901 }902}903904impl From<String> for Value {905 fn from(value: String) -> Self {906 Value::new_str(&value)907 }908}909impl From<bool> for Value {910 fn from(value: bool) -> Self {911 Value::new_bool(value)912 }913}914impl From<&str> for Value {915 fn from(value: &str) -> Self {916 Value::new_str(value)917 }918}919impl<T> From<Vec<T>> for Value920where921 T: Into<Value>,922{923 fn from(value: Vec<T>) -> Self {924 Value::new_list(value)925 }926}927928impl Clone for Value {929 fn clone(&self) -> Self {930 with_default_context(|c, _| unsafe { value_incref(c, self.0) })931 .expect("value incref should not fail");932 Self(self.0)933 }934}935impl Drop for Value {936 fn drop(&mut self) {937 with_default_context(|c, _| unsafe { value_decref(c, self.0) })938 .expect("value drop should not fail");939 }940}941942static TOKIO_FOR_NIX: OnceLock<Arc<tokio::runtime::Runtime>> = OnceLock::new();943944pub fn init_libraries() {945 unsafe { GC_allow_register_threads() };946947 let mut ctx = NixContext::new();948 ctx.run_in_context(|c| unsafe { libutil_init(c) })949 .expect("util init should not fail");950 ctx.run_in_context(|c| unsafe { libstore_init(c) })951 .expect("store init should not fail");952 ctx.run_in_context(|c| unsafe { libexpr_init(c) })953 .expect("expr init should not fail");954955 nix_logging_cxx::apply_tracing_logger();956}957958pub fn init_tokio_for_nix(tokio: Arc<tokio::runtime::Runtime>) {959 TOKIO_FOR_NIX960 .set(tokio)961 .expect("tokio for nix should only be initialized once");962}963964pub fn await_in_nix<F: Send + 'static>(f: impl Future<Output = F> + Send + 'static) -> F {965 966 let runtime = TOKIO_FOR_NIX967 .get()968 .expect("init_tokio_for_nix was not called");969 std::thread::spawn(move || runtime.block_on(f)).join().expect("await_in_nix inner thread panicked")970}971972unsafe extern "C" fn nix_primop_closure_adapter<const N: usize>(973 user_data: *mut c_void,974 mut context: *mut c_context,975 state: *mut nix_raw::EvalState,976 args: *mut *mut value,977 ret: *mut value,978) {979 let user_closure: &UserClosure<N> = unsafe { &*user_data.cast_const().cast() };980 let args: [&Value; N] = array::from_fn(|i| {981 let v: &mut Value = unsafe { &mut *args.add(i).cast() };982 v as &Value983 });984 let ctx: &mut NixContext = unsafe { transmute(&mut context) };985986 let state: &EvalState = unsafe { std::mem::transmute(&state) };987988 match user_closure(state, args) {989 Ok(v) => {990 unsafe { copy_value(context, ret, v.0) };991 }992 Err(e) => {993 ctx.set_err(e);994 }995 }996}997998type UserClosure<const N: usize> = Box<dyn Fn(&EvalState, [&Value; N]) -> Result<Value>>;9991000pub struct NativeFn(*mut PrimOp);1001impl NativeFn {1002 pub fn new<const N: usize>(1003 name: &'static CStr,1004 doc: &'static CStr,1005 args: [&'static CStr; N],1006 f: impl Fn(&EvalState, [&Value; N]) -> Result<Value> + 'static,1007 ) -> Self {1008 1009 let closure: Box<UserClosure<N>> = Box::new(Box::new(f));1010 let f: PrimOpFun = Some(nix_primop_closure_adapter::<N>);1011 let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();1012 args.push(null());1013 let args = args.as_mut_ptr();1014 let primop = unsafe {1015 alloc_primop(1016 null_mut(),1017 f,1018 N as i32,1019 name.as_ptr(),1020 args,1021 doc.as_ptr(),1022 Box::into_raw(closure).cast(),1023 )1024 };10251026 assert!(!primop.is_null(), "primop allocation should not fail");10271028 Self(primop)1029 }1030 pub fn register(self) {1031 unsafe { register_primop(null_mut(), self.0) };1032 }1033}10341035struct StorePath(*mut c_store_path);1036impl StorePath {}10371038impl Drop for StorePath {1039 fn drop(&mut self) {1040 unsafe { store_path_free(self.0) }1041 }1042}10431044#[test_log::test]1045fn test_native() -> Result<()> {1046 init_libraries();1047 NativeFn::new(1048 c"__uppercaseSuffix2",1049 c"make string uppercase and add suffix",1050 [c"str", c"suffix"],1051 |_, [str, suffix]: [&Value; 2]| {1052 let str = str.to_string()?;1053 let suffix = suffix.to_string()?;1054 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1055 },1056 )1057 .register();10581059 let mut fetch_settings = FetchSettings::new();1060 fetch_settings.set(c"warn-dirty", c"false");10611062 let manifest = format!("git+file://{}/../../", env!("CARGO_MANIFEST_DIR"));1063 let flake = FlakeSettings::new()?;1064 let parse = FlakeReferenceParseFlags::new(&flake)?;1065 let (mut r, _) = FlakeReference::new(&manifest, &flake, &parse, &fetch_settings)?;1066 let lock = FlakeLockFlags::new(&flake)?;1067 let locked = r.lock(&fetch_settings, &flake, &lock)?;1068 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;10691070 let builtins = Value::eval("builtins")?;1071 assert_eq!(builtins.type_of(), NixType::Attrs);10721073 assert_eq!(attrs.type_of(), NixType::Attrs);1074 let test_data = nix_go!(attrs.testData);10751076 let test_string: String = nix_go_json!(test_data.testString);1077 assert_eq!(test_string, "hello");10781079 let s = nix_go!(attrs.packages["x86_64-linux"].fleet.drvPath);1080 let s = CString::new(s.to_string()?).expect("path str is cstring");10811082 let uppercase_suffix = Value::new_primop(NativeFn::new(1083 c"uppercase_suffix",1084 c"make string uppercase and add suffix",1085 [c"str", c"suffix"],1086 |es, [str, suffix]: [&Value; 2]| {1087 let str = str.to_string()?;1088 let suffix = suffix.to_string()?;1089 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1090 },1091 ));10921093 let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));1094 assert_eq!(test_result, "PREFIX_BODY_SUFFIX");1095 let test_result: String = nix_go_json!(builtins.uppercaseSuffix2("test")("suffix"));1096 assert_eq!(test_result, "TESTsuffix");10971098 let nix_ctx = NixContext::new();1099 let store = GLOBAL_STATE.store.parse_path(s.as_c_str())?;11001101 11021103 Ok(())1104}1105110611071108110911101111111211131114111511161117111811191120112111221123