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::LazyLock;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;1314pub use anyhow::Result;15use tracing::{info, instrument, warn};1617use self::logging::{ErrorInfoBuilder, nix_logging_cxx};18use self::nix_cxx::set_fetcher_setting;19use self::nix_raw::{20 BindingsBuilder as c_bindings_builder, EvalState as c_eval_state, GC_SUCCESS,21 GC_allow_register_threads, GC_get_stack_base, GC_register_my_thread, GC_stack_base,22 GC_thread_is_registered, GC_unregister_my_thread, ListBuilder as c_list_builder, PrimOp,23 PrimOpFun, Store as c_store, StorePath as c_store_path, alloc_primop, alloc_value,24 bindings_builder_free, bindings_builder_insert, c_context, c_context_create, c_context_free,25 clear_err, copy_value, err_NIX_ERR_KEY, err_NIX_ERR_NIX_ERROR, err_NIX_ERR_OVERFLOW,26 err_NIX_ERR_UNKNOWN, err_code, err_info_msg, err_msg, eval_state_build,27 eval_state_builder_load, eval_state_builder_new, eval_state_builder_set_eval_setting,28 expr_eval_from_string, fetchers_settings, fetchers_settings_free, fetchers_settings_new,29 flake_lock, flake_lock_flags, flake_lock_flags_free, flake_lock_flags_new, flake_reference,30 flake_reference_and_fragment_from_string, flake_reference_parse_flags,31 flake_reference_parse_flags_free, flake_reference_parse_flags_new,32 flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,33 flake_settings_new, gc_now as gc_now_raw, get_attr_byname, get_attr_name_byidx, get_attrs_size,34 get_list_byidx, get_list_size, get_string, get_type, has_attr_byname, init_bool, init_int,35 init_primop, init_string, libexpr_init, libstore_init, libutil_init, list_builder_free,36 list_builder_insert, locked_flake, locked_flake_free, locked_flake_get_output_attrs,37 make_attrs, make_bindings_builder, make_list, make_list_builder, realised_string,38 realised_string_free, realised_string_get_buffer_size, realised_string_get_buffer_start,39 realised_string_get_store_path, realised_string_get_store_path_count, register_primop,40 set_err_msg, setting_set, state_free, store_open, store_parse_path, store_path_free,41 store_path_name, string_realise, value, value_call, value_decref, value_force, value_incref,42};434445pub mod logging;46#[doc(hidden)]47pub mod macros;48pub mod util;4950#[allow(51 non_upper_case_globals,52 non_camel_case_types,53 non_snake_case,54 dead_code55)]56mod nix_raw {57 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));58}59#[cxx::bridge]60pub mod nix_cxx {61 unsafe extern "C++" {62 type nix_fetchers_settings;63 include!("nix-eval/src/lib.hh");6465 #[allow(clippy::missing_safety_doc)]66 unsafe fn set_fetcher_setting(67 settings: *mut nix_fetchers_settings,68 setting: *const c_char,69 value: *const c_char,70 );71 }72}7374#[derive(Debug, PartialEq, Eq)]75pub enum NixType {76 Thunk,77 Int,78 Float,79 Bool,80 String,81 Path,82 Null,83 Attrs,84 List,85 Function,86 External,87}88impl NixType {89 fn from_int(c: c_uint) -> Self {90 match c {91 0 => Self::Thunk,92 1 => Self::Int,93 2 => Self::Float,94 3 => Self::Bool,95 4 => Self::String,96 5 => Self::Path,97 6 => Self::Null,98 7 => Self::Attrs,99 8 => Self::List,100 9 => Self::Function,101 10 => Self::External,102 _ => unreachable!("unknown nix type: {c}"),103 }104 }105}106107enum FunctorKind {108 Function,109 Functor,110}111112#[derive(Debug)]113#[repr(i32)]114pub enum NixErrorKind {115 Unknown = err_NIX_ERR_UNKNOWN,116 Overflow = err_NIX_ERR_OVERFLOW,117 Key = err_NIX_ERR_KEY,118 Generic = err_NIX_ERR_NIX_ERROR,119}120impl NixErrorKind {121 fn from_int(v: c_int) -> Option<Self> {122 Some(match v {123 0 => return None,124 nix_raw::err_NIX_ERR_UNKNOWN => Self::Unknown,125 nix_raw::err_NIX_ERR_OVERFLOW => Self::Overflow,126 nix_raw::err_NIX_ERR_KEY => Self::Key,127 nix_raw::err_NIX_ERR_NIX_ERROR => Self::Generic,128 _ => {129 debug_assert!(false, "unexpected nix error kind: {v}");130 Self::Unknown131 }132 })133 }134}135136pub fn gc_now() {137 unsafe { gc_now_raw() };138}139140pub fn gc_register_my_thread() {141 assert_eq!(unsafe { GC_thread_is_registered() }, 0);142143 let mut sb = GC_stack_base {144 mem_base: null_mut(),145 };146 let r = unsafe { GC_get_stack_base(&mut sb) };147 if r as u32 != GC_SUCCESS {148 panic!("failed to get thread stack base");149 }150 unsafe { GC_register_my_thread(&sb) };151}152pub fn gc_unregister_my_thread() {153 assert_eq!(unsafe { GC_thread_is_registered() }, 1);154155 unsafe { GC_unregister_my_thread() };156}157158pub struct ThreadRegisterGuard {}159impl ThreadRegisterGuard {160 #[allow(clippy::new_without_default)]161 pub fn new() -> Self {162 gc_register_my_thread();163 Self {}164 }165}166impl Drop for ThreadRegisterGuard {167 fn drop(&mut self) {168 gc_unregister_my_thread();169 }170}171172#[repr(transparent)]173pub struct NixContext(*mut c_context);174impl NixContext {175 pub fn set_err(&mut self, err: NixErrorKind, msg: &CStr) {176 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };177 }178 pub fn new() -> Self {179 let ctx = unsafe { c_context_create() };180 Self(ctx)181 }182 fn error_kind(&self) -> Option<NixErrorKind> {183 let code = unsafe { err_code(self.0) };184 NixErrorKind::from_int(code)185 }186 fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {187 if let NixErrorKind::Generic = self.error_kind()? {188 let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };189 let mut err_out = String::new();190 unsafe {191 err_info_msg(192 null_mut(),193 self.0,194 Some(copy_nix_str),195 (&raw mut err_out).cast(),196 )197 };198 return Some((Cow::Owned(err_out), Some(ei)));199 };200201 202 203 let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };204 Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))205 }206 fn clean_err(&mut self) {207 unsafe {208 clear_err(self.0);209 }210 }211212 fn bail_if_error(&self) -> Result<()> {213 if let Some((err, stack)) = self.error() {214 let mut e = Err(anyhow!("{err}"));215 if let Some(stack) = stack {216 for ele in stack.stack_frames {217 e = e.with_context(|| {218 if ele.pos.is_empty() {219 ele.msg220 } else {221 format!("{} at {}", ele.msg, ele.pos)222 }223 })224 }225 }226 return e.context("<nix frames>");227 };228 Ok(())229 }230231 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {232 self.clean_err();233 let o = f(self.0);234 self.bail_if_error()?;235 self.clean_err();236 Ok(o)237 }238}239240impl Default for NixContext {241 fn default() -> Self {242 Self::new()243 }244}245impl Drop for NixContext {246 fn drop(&mut self) {247 unsafe {248 c_context_free(self.0);249 }250 }251}252struct GlobalState {253 254 #[allow(dead_code)]255 store: Store,256 state: EvalState,257}258impl GlobalState {259 fn new() -> Result<Self> {260 let mut ctx = NixContext::new();261 let store = ctx262 .run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })263 .map(Store)?;264265 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;266 ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;267 ctx.run_in_context(|c| unsafe {268 eval_state_builder_set_eval_setting(269 c,270 builder,271 c"lazy-trees".as_ptr(),272 c"true".as_ptr(),273 )274 })?;275 ctx.run_in_context(|c| unsafe {276 eval_state_builder_set_eval_setting(277 c,278 builder,279 c"lazy-locks".as_ptr(),280 c"true".as_ptr(),281 )282 })?;283 let state = ctx284 .run_in_context(|c| unsafe { eval_state_build(c, builder) })285 .map(EvalState)?;286287 Ok(Self { store, state })288 }289}290291struct ThreadState {292 ctx: NixContext,293}294impl ThreadState {295 fn new() -> Result<Self> {296 let ctx = NixContext::new();297298 Ok(Self { ctx })299 }300}301302static GLOBAL_STATE: LazyLock<GlobalState> = LazyLock::new(|| {303 info!("initializing nix global state");304 GlobalState::new().expect("global state init shouldn't fail")305});306307thread_local! {308 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));309}310fn with_default_context<T>(f: impl FnOnce(*mut c_context, *mut c_eval_state) -> T) -> Result<T> {311 let global = &GLOBAL_STATE.state;312 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));313 let mut ctx = NixContext(ctx);314 let v = ctx.run_in_context(|c| f(c, state));315 316 std::mem::forget(ctx);317 v318}319320pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {321 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())322}323324pub struct FetchSettings(*mut fetchers_settings);325impl FetchSettings {326 pub fn new() -> Self {327 Self::try_new().expect("allocation should not fail")328 }329 fn try_new() -> Result<Self> {330 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)331 }332 pub fn set(&mut self, setting: &CStr, value: &CStr) {333 unsafe {334 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());335 };336 }337}338unsafe impl Send for FetchSettings {}339unsafe impl Sync for FetchSettings {}340341impl Default for FetchSettings {342 fn default() -> Self {343 Self::new()344 }345}346347impl Drop for FetchSettings {348 fn drop(&mut self) {349 unsafe { fetchers_settings_free(self.0) };350 }351}352pub struct FlakeSettings(*mut flake_settings);353impl FlakeSettings {354 pub fn new() -> Result<Self> {355 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)356 }357}358unsafe impl Send for FlakeSettings {}359unsafe impl Sync for FlakeSettings {}360impl Drop for FlakeSettings {361 fn drop(&mut self) {362 unsafe {363 flake_settings_free(self.0);364 }365 }366}367368pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);369impl FlakeReferenceParseFlags {370 pub fn new(settings: &FlakeSettings) -> Result<Self> {371 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })372 .map(Self)373 }374 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {375 with_default_context(|c, _| {376 unsafe {377 flake_reference_parse_flags_set_base_directory(378 c,379 self.0,380 dir.as_ptr().cast(),381 dir.len(),382 )383 };384 })385 }386}387impl Drop for FlakeReferenceParseFlags {388 fn drop(&mut self) {389 unsafe {390 flake_reference_parse_flags_free(self.0);391 }392 }393}394pub struct FlakeLockFlags(*mut flake_lock_flags);395impl FlakeLockFlags {396 pub fn new(settings: &FlakeSettings) -> Result<Self> {397 let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })398 .map(Self)?;399 400401 Ok(o)402 }403}404impl Drop for FlakeLockFlags {405 fn drop(&mut self) {406 unsafe {407 flake_lock_flags_free(self.0);408 }409 }410}411412unsafe extern "C" fn copy_nix_str(start: *const c_char, n: c_uint, user_data: *mut c_void) {413 let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };414 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");415 unsafe { *user_data.cast::<String>() = s.to_owned() };416}417418struct Store(*mut c_store);419unsafe impl Send for Store {}420unsafe impl Sync for Store {}421422impl Store {423 fn parse_path(&self, path: &CStr) -> Result<StorePath> {424 with_default_context(|c, _| {425 StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })426 })427 }428}429430#[repr(transparent)]431pub struct EvalState(*mut c_eval_state);432unsafe impl Send for EvalState {}433unsafe impl Sync for EvalState {}434435impl Drop for EvalState {436 fn drop(&mut self) {437 unsafe {438 state_free(self.0);439 }440 }441}442443pub struct FlakeReference(*mut flake_reference);444impl FlakeReference {445 #[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]446 pub fn new(447 s: &str,448 flake: &FlakeSettings,449 parse: &FlakeReferenceParseFlags,450 fetch: &FetchSettings,451 ) -> Result<(Self, String)> {452 let mut out = null_mut();453 let mut fragment = String::new();454 455 with_default_context(|c, _| unsafe {456 flake_reference_and_fragment_from_string(457 c,458 fetch.0,459 flake.0,460 parse.0,461 s.as_ptr().cast(),462 s.len(),463 &mut out,464 Some(copy_nix_str),465 (&raw mut fragment).cast(),466 )467 })?;468 assert!(!out.is_null());469470 Ok((Self(out), fragment))471 }472 #[instrument(name = "lock-flake", skip(self, fetch, flake, lock))]473 pub fn lock(474 &mut self,475 fetch: &FetchSettings,476 flake: &FlakeSettings,477 lock: &FlakeLockFlags,478 ) -> Result<LockedFlake> {479 with_default_context(|c, es| unsafe { flake_lock(c, fetch.0, flake.0, es, lock.0, self.0) })480 .map(LockedFlake)481 }482}483unsafe impl Send for FlakeReference {}484unsafe impl Sync for FlakeReference {}485486pub struct LockedFlake(*mut locked_flake);487impl LockedFlake {488 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {489 with_default_context(|c, es| unsafe {490 locked_flake_get_output_attrs(c, settings.0, es, self.0)491 })492 .map(Value)493 }494}495unsafe impl Send for LockedFlake {}496unsafe impl Sync for LockedFlake {}497impl Drop for LockedFlake {498 fn drop(&mut self) {499 unsafe {500 locked_flake_free(self.0);501 };502 }503}504505type FieldName = [u8; 64];506fn init_field_name(v: &str) -> FieldName {507 let mut f = [0; 64];508 assert!(v.len() < 64, "max field name is 63 chars");509 assert!(510 v.bytes().all(|v| v != 0),511 "nul bytes are unsupported in field name"512 );513 f[0..v.len()].copy_from_slice(v.as_bytes());514 f515}516517pub struct RealisedString(*mut realised_string);518impl fmt::Debug for RealisedString {519 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {520 self.as_str().fmt(f)521 }522}523524impl RealisedString {525 pub fn as_str(&self) -> &str {526 let len = unsafe { realised_string_get_buffer_size(self.0) };527 let data: *const u8 = unsafe { realised_string_get_buffer_start(self.0) }.cast();528 let data = unsafe { slice::from_raw_parts(data, len) };529 std::str::from_utf8(data).expect("non-utf8 strings not supported")530 }531 pub fn path_count(&self) -> usize {532 unsafe { realised_string_get_store_path_count(self.0) }533 }534 pub fn path(&self, i: usize) -> String {535 assert!(i < self.path_count());536 let path = unsafe { realised_string_get_store_path(self.0, i) };537 let mut err_out = String::new();538 unsafe { store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };539 err_out540 }541}542543unsafe impl Send for RealisedString {}544impl Drop for RealisedString {545 fn drop(&mut self) {546 unsafe { realised_string_free(self.0) }547 }548}549550#[repr(transparent)]551pub struct Value(*mut value);552553unsafe impl Send for Value {}554unsafe impl Sync for Value {}555556pub trait AsFieldName {557 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;558 fn to_field_name(&self) -> Result<String>;559}560impl AsFieldName for Value {561 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {562 let f = self.to_string()?;563 v(init_field_name(&f))564 }565 fn to_field_name(&self) -> Result<String> {566 self.to_string()567 }568}569impl<E> AsFieldName for E570where571 E: AsRef<str>,572{573 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {574 let f = self.as_ref();575 v(init_field_name(f))576 }577 fn to_field_name(&self) -> Result<String> {578 Ok(self.as_ref().to_owned())579 }580}581582struct AttrsBuilder(*mut c_bindings_builder);583impl AttrsBuilder {584 fn new(capacity: usize) -> Self {585 with_default_context(|c, es| unsafe { make_bindings_builder(c, es, capacity) })586 .map(Self)587 .expect("alloc should not fail")588 }589 fn insert(&mut self, k: &impl AsFieldName, v: Value) {590 k.as_field_name(|name| {591 with_default_context(|c, _| unsafe {592 bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0);593 594 })595 })596 .expect("builder insert shouldn't fail");597 }598}599impl Drop for AttrsBuilder {600 fn drop(&mut self) {601 unsafe { bindings_builder_free(self.0) };602 }603}604605struct ListBuilder(*mut c_list_builder, c_uint);606impl ListBuilder {607 fn new(capacity: usize) -> Self {608 with_default_context(|c, es| unsafe { make_list_builder(c, es, capacity) })609 .map(|l| Self(l, 0))610 .expect("alloc should not fail")611 }612}613impl ListBuilder {614 fn push(&mut self, v: Value) {615 with_default_context(|c, _| unsafe {616 list_builder_insert(617 c,618 self.0,619 {620 let v = self.1;621 self.1 += 1;622 v623 },624 v.0,625 )626 })627 .expect("list insert shouldn't fail");628 }629}630impl Drop for ListBuilder {631 fn drop(&mut self) {632 unsafe { list_builder_free(self.0) };633 }634}635636impl Value {637 pub fn new_primop(v: NativeFn) -> Self {638 let out = Self::new_uninit();639 with_default_context(|c, _| unsafe { init_primop(c, out.0, v.0) })640 .expect("primop initialization should not fail");641 out642 }643 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {644 let out = Self::new_uninit();645 let mut b = AttrsBuilder::new(v.len());646 for (k, v) in v {647 b.insert(&k, v);648 }649 with_default_context(|c, _| unsafe { make_attrs(c, out.0, b.0) })650 .expect("attrs initialization should not fail");651652 out653 }654 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {655 let out = Self::new_uninit();656 let mut b = ListBuilder::new(v.len());657 for v in v {658 b.push(v.into());659 }660 with_default_context(|c, _| unsafe { make_list(c, b.0, out.0) })661 .expect("list initialization should not fail");662663 out664 }665 fn new_uninit() -> Self {666 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })667 .expect("value allocation should not fail");668 Self(out)669 }670 pub fn new_str(v: &str) -> Self {671 let s = CString::new(v).expect("string should not contain NULs");672 let out = Self::new_uninit();673 674 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })675 .expect("string initialization should not fail");676 out677 }678 pub fn new_int(i: i64) -> Self {679 let out = Self::new_uninit();680 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })681 .expect("int initialization should not fail");682 out683 }684 pub fn new_bool(v: bool) -> Self {685 let out = Self::new_uninit();686 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })687 .expect("bool initialization should not fail");688 out689 }690 691 692 693 694 695 pub fn type_of(&self) -> NixType {696 let ty = with_default_context(|c, _| unsafe { get_type(c, self.0) })697 .expect("get_type should not fail");698 NixType::from_int(ty)699 }700 fn builtin_to_string(&self) -> Result<Self> {701 let builtin = Self::eval("builtins.toString")?;702 builtin.call(self.clone())703 }704 fn force(&mut self, s: *mut nix_raw::EvalState) -> Result<()> {705 with_default_context(|c, _| unsafe { value_force(c, s, self.0) })?;706 Ok(())707 }708 pub fn to_string(&self) -> Result<String> {709 let ty = self.type_of();710 if !matches!(ty, NixType::String) {711 bail!("unexpected type: {ty:?}, expected string");712 }713 let mut str_out = String::new();714 with_default_context(|c, _| unsafe {715 get_string(c, self.0, Some(copy_nix_str), (&raw mut str_out).cast())716 })?;717718 Ok(str_out)719 }720 pub fn to_realised_string(&self) -> Result<RealisedString> {721 with_default_context(|c, es| unsafe { string_realise(c, es, self.0, false) })722 .map(RealisedString)723724 725 726 727 728 729 730 731 }732733 pub fn has_field(&self, field: &str) -> Result<bool> {734 if !matches!(self.type_of(), NixType::Attrs) {735 bail!("invalid type: expected attrs");736 }737738 let f = init_field_name(field);739 with_default_context(|c, es| unsafe { has_attr_byname(c, self.0, es, f.as_ptr().cast()) })740 }741 742 743 744 pub fn list_fields(&self) -> Result<Vec<String>> {745 if !matches!(self.type_of(), NixType::Attrs) {746 bail!("invalid type: expected attrs");747 }748749 let len = with_default_context(|c, _| unsafe { get_attrs_size(c, self.0) })?;750 let mut out = Vec::with_capacity(len as usize);751752 for i in 0..len {753 let name =754 with_default_context(|c, es| unsafe { get_attr_name_byidx(c, self.0, es, i) })?;755 let c = unsafe { CStr::from_ptr(name) };756 out.push(c.to_str().expect("nix field names are utf-8").to_owned());757 }758 Ok(out)759 }760 pub fn get_elem(&self, v: usize) -> Result<Self> {761 if !matches!(self.type_of(), NixType::List) {762 bail!("invalid type: expected list");763 }764 let len = with_default_context(|c, _| unsafe { get_list_size(c, self.0) })? as usize;765 if v >= len {766 bail!("oob list get: {v} >= {len}");767 }768769 with_default_context(|c, es| unsafe { get_list_byidx(c, self.0, es, v as u32) }).map(Self)770 }771 pub fn attrs_update(self, other: Value ) -> Result<Self> {772 let attrs_update_fn = Self::eval("a: b: a // b")?;773774 attrs_update_fn775 .call(self)?776 .call(other)777 .context("attrs update")778 }779 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {780 if !matches!(self.type_of(), NixType::Attrs) {781 bail!("invalid type: expected attrs");782 }783784 name.as_field_name(|name| {785 with_default_context(|c, es| unsafe {786 get_attr_byname(c, self.0, es, name.as_ptr().cast())787 })788 .map(Self)789 })790 .with_context(|| format!("getting field {:?}", name.to_field_name()))791 }792 pub fn call(&self, v: Value) -> Result<Self> {793 let kind = self794 .functor_kind()795 .ok_or_else(|| anyhow!("can only call function or functor"))?;796797 let function = match kind {798 FunctorKind::Function => self.clone(),799 FunctorKind::Functor => {800 let f = self801 .get_field("__functor")802 .context("getting functor value")?;803 assert_eq!(804 f.type_of(),805 NixType::Function,806 "invalid functor encountered"807 );808 f809 }810 };811812 let out = Value::new_uninit();813 with_default_context(|c, es| unsafe { value_call(c, es, function.0, v.0, out.0) })?;814815 Ok(out)816 }817 pub fn eval(v: &str) -> Result<Self> {818 let s = CString::new(v).expect("expression shouldn't have internal NULs");819 let out = Self::new_uninit();820 with_default_context(|c, es| unsafe {821 expr_eval_from_string(c, es, s.as_ptr(), c"/root".as_ptr(), out.0)822 })?;823 Ok(out)824 }825 pub fn build(&self, output: &str) -> Result<PathBuf> {826 if !self.is_derivation() {827 bail!("expected derivation to build")828 }829 let output_name = self830 .get_field("outputName")831 .context("getting output name field")?832 .to_string()?;833 let v = if output_name != output {834 let out = self.get_field(output).context("getting target output")?;835 if !out.is_derivation() {836 bail!("unknown output: {output}");837 }838 out839 } else {840 self.clone()841 };842 843 let s = v.builtin_to_string()?;844 let rs = s.to_realised_string()?;845 let drv_path = rs.as_str().to_owned();846 Ok(PathBuf::from(drv_path))847 }848 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {849 let to_json = Self::eval("builtins.toJSON")?;850 let s = to_json.call(self.clone())?.to_string()?;851 Ok(serde_json::from_str(&s)?)852 }853 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {854 Self::eval(&nixlike::serialize(v)?)855 }856857 858 859 860 861 862863 fn is_derivation(&self) -> bool {864 if !matches!(self.type_of(), NixType::Attrs) {865 return false;866 }867 let Some(ty) = self.get_field("type").ok() else {868 return false;869 };870 matches!(ty.to_string().as_deref(), Ok("derivation"))871 }872 fn functor_kind(&self) -> Option<FunctorKind> {873 match self.type_of() {874 NixType::Attrs => self875 .has_field("__functor")876 .expect("has_field shouldn't fail for attrs")877 .then_some(FunctorKind::Functor),878 NixType::Function => Some(FunctorKind::Function),879 _ => None,880 }881 }882 pub fn is_function(&self) -> bool {883 self.functor_kind().is_some()884 }885 pub fn is_null(&self) -> bool {886 matches!(self.type_of(), NixType::Null)887 }888 pub fn is_string(&self) -> bool {889 matches!(self.type_of(), NixType::String)890 }891 pub fn is_attrs(&self) -> bool {892 matches!(self.type_of(), NixType::Attrs)893 }894}895896impl From<String> for Value {897 fn from(value: String) -> Self {898 Value::new_str(&value)899 }900}901impl From<bool> for Value {902 fn from(value: bool) -> Self {903 Value::new_bool(value)904 }905}906impl From<&str> for Value {907 fn from(value: &str) -> Self {908 Value::new_str(value)909 }910}911impl<T> From<Vec<T>> for Value912where913 T: Into<Value>,914{915 fn from(value: Vec<T>) -> Self {916 Value::new_list(value)917 }918}919920impl Clone for Value {921 fn clone(&self) -> Self {922 with_default_context(|c, _| unsafe { value_incref(c, self.0) })923 .expect("value incref should not fail");924 Self(self.0)925 }926}927impl Drop for Value {928 fn drop(&mut self) {929 with_default_context(|c, _| unsafe { value_decref(c, self.0) })930 .expect("value drop should not fail");931 }932}933934pub fn init_libraries() {935 unsafe { GC_allow_register_threads() };936937 let mut ctx = NixContext::new();938 ctx.run_in_context(|c| unsafe { libutil_init(c) })939 .expect("util init should not fail");940 ctx.run_in_context(|c| unsafe { libstore_init(c) })941 .expect("store init should not fail");942 ctx.run_in_context(|c| unsafe { libexpr_init(c) })943 .expect("expr init should not fail");944945 nix_logging_cxx::apply_tracing_logger();946}947948unsafe extern "C" fn nix_primop_closure_adapter<const N: usize>(949 user_data: *mut c_void,950 context: *mut c_context,951 state: *mut nix_raw::EvalState,952 args: *mut *mut value,953 ret: *mut value,954) {955 let user_closure: &UserClosure<N> = unsafe { &*user_data.cast_const().cast() };956 let mut e = None;957 let args: [&Value; N] = array::from_fn(|i| {958 let v: &mut Value = unsafe { &mut *args.add(i).cast() };959960 info!("forcing arg");961 if matches!(v.type_of(), NixType::Thunk)962 && let Err(err) = v.force(state)963 {964 e = Some(err);965 };966 v as &Value967 });968 info!("args forced");969 let ctx: &mut NixContext = unsafe { &mut *context.cast() };970971 if let Some(e) = e {972 warn!("set err = {e}");973 unsafe { init_int(context, ret, 0) };974 return ctx.set_err(975 NixErrorKind::Unknown,976 &CString::new(e.to_string()).expect("forcing argument value failed"),977 );978 }979980 let state: &EvalState = unsafe { std::mem::transmute(&state) };981982 match user_closure(state, args) {983 Ok(v) => {984 unsafe { copy_value(context, ret, v.0) };985 }986 Err(e) => {987 unsafe { init_int(context, ret, 0) };988 warn!("set err = {e:#?}");989 ctx.set_err(990 NixErrorKind::Unknown,991 &CString::new(e.to_string()).expect("error should not contain internal nuls"),992 );993 }994 }995}996997type UserClosure<const N: usize> = Box<dyn Fn(&EvalState, [&Value; N]) -> Result<Value>>;998999pub struct NativeFn(*mut PrimOp);1000impl NativeFn {1001 pub fn new<const N: usize>(1002 name: &'static CStr,1003 doc: &'static CStr,1004 args: [&'static CStr; N],1005 f: impl Fn(&EvalState, [&Value; N]) -> Result<Value> + 'static,1006 ) -> Self {1007 1008 let closure: Box<UserClosure<N>> = Box::new(Box::new(f));1009 let f: PrimOpFun = Some(nix_primop_closure_adapter::<N>);1010 let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();1011 args.push(null());1012 let args = args.as_mut_ptr();1013 let primop = unsafe {1014 alloc_primop(1015 null_mut(),1016 f,1017 N as i32,1018 name.as_ptr(),1019 args,1020 doc.as_ptr(),1021 Box::into_raw(closure).cast(),1022 )1023 };10241025 assert!(!primop.is_null(), "primop allocation should not fail");10261027 Self(primop)1028 }1029 pub fn register(self) {1030 unsafe { register_primop(null_mut(), self.0) };1031 }1032}10331034struct StorePath(*mut c_store_path);1035impl StorePath {}10361037impl Drop for StorePath {1038 fn drop(&mut self) {1039 unsafe { store_path_free(self.0) }1040 }1041}10421043#[test_log::test]1044fn test_native() -> Result<()> {1045 init_libraries();1046 NativeFn::new(1047 c"__uppercaseSuffix2",1048 c"make string uppercase and add suffix",1049 [c"str", c"suffix"],1050 |_, [str, suffix]: [&Value; 2]| {1051 let str = str.to_string()?;1052 let suffix = suffix.to_string()?;1053 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1054 },1055 )1056 .register();10571058 let mut fetch_settings = FetchSettings::new();1059 fetch_settings.set(c"warn-dirty", c"false");10601061 let manifest = format!("git+file://{}/../../", env!("CARGO_MANIFEST_DIR"));1062 let flake = FlakeSettings::new()?;1063 let parse = FlakeReferenceParseFlags::new(&flake)?;1064 let (mut r, _) = FlakeReference::new(&manifest, &flake, &parse, &fetch_settings)?;1065 let lock = FlakeLockFlags::new(&flake)?;1066 let locked = r.lock(&fetch_settings, &flake, &lock)?;1067 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;10681069 let builtins = Value::eval("builtins")?;1070 assert_eq!(builtins.type_of(), NixType::Attrs);10711072 assert_eq!(attrs.type_of(), NixType::Attrs);1073 let test_data = nix_go!(attrs.testData);10741075 let test_string: String = nix_go_json!(test_data.testString);1076 assert_eq!(test_string, "hello");10771078 let s = nix_go!(attrs.packages["x86_64-linux"].fleet.drvPath);1079 let s = CString::new(s.to_string()?).expect("path str is cstring");10801081 let uppercase_suffix = Value::new_primop(NativeFn::new(1082 c"uppercase_suffix",1083 c"make string uppercase and add suffix",1084 [c"str", c"suffix"],1085 |es, [str, suffix]: [&Value; 2]| {1086 let str = str.to_string()?;1087 let suffix = suffix.to_string()?;1088 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1089 },1090 ));10911092 let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));1093 assert_eq!(test_result, "PREFIX_BODY_SUFFIX");1094 let test_result: String = nix_go_json!(builtins.uppercaseSuffix2("test")("suffix"));1095 assert_eq!(test_result, "TESTsuffix");10961097 let nix_ctx = NixContext::new();1098 let store = GLOBAL_STATE.store.parse_path(s.as_c_str())?;10991100 11011102 Ok(())1103}1104110511061107110811091110111111121113111411151116111711181119112011211122