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::instrument;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_code, err_info_msg, err_msg, eval_state_build,26 eval_state_builder_load, eval_state_builder_new, eval_state_builder_set_eval_setting,27 expr_eval_from_string, fetchers_settings, fetchers_settings_free, fetchers_settings_new,28 flake_lock, flake_lock_flags, flake_lock_flags_free, flake_lock_flags_new, flake_reference,29 flake_reference_and_fragment_from_string, flake_reference_parse_flags,30 flake_reference_parse_flags_free, flake_reference_parse_flags_new,31 flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,32 flake_settings_new, gc_now as gc_now_raw, get_attr_byname, get_attr_name_byidx, get_attrs_size,33 get_list_byidx, get_list_size, get_string, get_type, has_attr_byname, init_bool, init_int,34 init_primop, init_string, libexpr_init, libstore_init, libutil_init, list_builder_free,35 list_builder_insert, locked_flake, locked_flake_free, locked_flake_get_output_attrs,36 make_attrs, make_bindings_builder, make_list, make_list_builder, realised_string,37 realised_string_free, realised_string_get_buffer_size, realised_string_get_buffer_start,38 realised_string_get_store_path, realised_string_get_store_path_count, register_primop,39 set_err_msg, setting_set, state_free, store_copy_closure, store_get_fs_closure, store_open,40 store_parse_path, store_path_free, store_path_name, string_realise, value, value_call,41 value_decref, 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 unsafe fn set_fetcher_setting(66 settings: *mut nix_fetchers_settings,67 setting: *const c_char,68 value: *const c_char,69 );70 }71}7273#[derive(Debug, PartialEq, Eq)]74pub enum NixType {75 Thunk,76 Int,77 Float,78 Bool,79 String,80 Path,81 Null,82 Attrs,83 List,84 Function,85 External,86}87impl NixType {88 fn from_int(c: c_uint) -> Self {89 match c {90 0 => Self::Thunk,91 1 => Self::Int,92 2 => Self::Float,93 3 => Self::Bool,94 4 => Self::String,95 5 => Self::Path,96 6 => Self::Null,97 7 => Self::Attrs,98 8 => Self::List,99 9 => Self::Function,100 10 => Self::External,101 _ => unreachable!("unknown nix type: {c}"),102 }103 }104}105106enum FunctorKind {107 Function,108 Functor,109}110111#[derive(Debug)]112#[repr(i32)]113pub enum NixErrorKind {114 Unknown = 1,115 Overflow = 2,116 Key = 3,117 Generic = 4,118}119impl NixErrorKind {120 fn from_int(v: c_int) -> Option<Self> {121 Some(match v {122 0 => return None,123 -1 => Self::Unknown,124 -2 => Self::Overflow,125 -3 => Self::Key,126 -4 => Self::Generic,127 _ => {128 debug_assert!(false, "unexpected nix error kind: {v}");129 Self::Unknown130 }131 })132 }133}134135pub fn gc_now() {136 unsafe { gc_now_raw() };137}138139pub fn gc_register_my_thread() {140 assert_eq!(unsafe { GC_thread_is_registered() }, 0);141142 let mut sb = GC_stack_base {143 mem_base: null_mut(),144 };145 let r = unsafe { GC_get_stack_base(&mut sb) };146 if r as u32 != GC_SUCCESS {147 panic!("failed to get thread stack base");148 }149 unsafe { GC_register_my_thread(&sb) };150}151pub fn gc_unregister_my_thread() {152 assert_eq!(unsafe { GC_thread_is_registered() }, 1);153154 unsafe { GC_unregister_my_thread() };155}156157pub struct ThreadRegisterGuard {}158impl ThreadRegisterGuard {159 #[allow(clippy::new_without_default)]160 pub fn new() -> Self {161 gc_register_my_thread();162 Self {}163 }164}165impl Drop for ThreadRegisterGuard {166 fn drop(&mut self) {167 gc_unregister_my_thread();168 }169}170171#[repr(transparent)]172pub struct NixContext(*mut c_context);173impl NixContext {174 pub fn set_err(&mut self, err: NixErrorKind, msg: &CStr) {175 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };176 }177 pub fn new() -> Self {178 let ctx = unsafe { c_context_create() };179 Self(ctx)180 }181 fn error_kind(&self) -> Option<NixErrorKind> {182 let code = unsafe { err_code(self.0) };183 NixErrorKind::from_int(code)184 }185 fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {186 if let NixErrorKind::Generic = self.error_kind()? {187 let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };188 let mut err_out = String::new();189 unsafe {190 err_info_msg(191 null_mut(),192 self.0,193 Some(copy_nix_str),194 (&raw mut err_out).cast(),195 )196 };197 return Some((Cow::Owned(err_out), Some(ei)));198 };199200 201 202 let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };203 Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))204 }205 fn clean_err(&mut self) {206 unsafe {207 clear_err(self.0);208 }209 }210211 fn bail_if_error(&self) -> Result<()> {212 if let Some((err, stack)) = self.error() {213 let mut e = Err(anyhow!("{err}"));214 if let Some(stack) = stack {215 for ele in stack.stack_frames {216 e = e.with_context(|| {217 if ele.pos.is_empty() {218 ele.msg219 } else {220 format!("{} at {}", ele.msg, ele.pos)221 }222 })223 }224 }225 return e.context("<nix frames>");226 };227 Ok(())228 }229230 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {231 self.clean_err();232 let o = f(self.0);233 self.bail_if_error()?;234 self.clean_err();235 Ok(o)236 }237}238239impl Default for NixContext {240 fn default() -> Self {241 Self::new()242 }243}244impl Drop for NixContext {245 fn drop(&mut self) {246 unsafe {247 c_context_free(self.0);248 }249 }250}251struct GlobalState {252 253 #[allow(dead_code)]254 store: Store,255 state: EvalState,256}257impl GlobalState {258 fn new() -> Result<Self> {259 let mut ctx = NixContext::new();260 let store = ctx261 .run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })262 .map(Store)?;263264 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;265 ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;266 ctx.run_in_context(|c| unsafe {267 eval_state_builder_set_eval_setting(268 c,269 builder,270 c"lazy-trees".as_ptr(),271 c"true".as_ptr(),272 )273 })?;274 ctx.run_in_context(|c| unsafe {275 eval_state_builder_set_eval_setting(276 c,277 builder,278 c"lazy-locks".as_ptr(),279 c"true".as_ptr(),280 )281 })?;282 let state = ctx283 .run_in_context(|c| unsafe { eval_state_build(c, builder) })284 .map(EvalState)?;285286 Ok(Self { store, state })287 }288}289290struct ThreadState {291 ctx: NixContext,292}293impl ThreadState {294 fn new() -> Result<Self> {295 let ctx = NixContext::new();296297 Ok(Self { ctx })298 }299}300301static GLOBAL_STATE: LazyLock<GlobalState> =302 LazyLock::new(|| GlobalState::new().expect("global state init shouldn't fail"));303304thread_local! {305 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));306}307fn with_default_context<T>(f: impl FnOnce(*mut c_context, *mut c_eval_state) -> T) -> Result<T> {308 let global = &GLOBAL_STATE.state;309 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));310 let mut ctx = NixContext(ctx);311 let v = ctx.run_in_context(|c| f(c, state));312 313 std::mem::forget(ctx);314 v315}316317pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {318 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())319}320321pub struct FetchSettings(*mut fetchers_settings);322impl FetchSettings {323 pub fn new() -> Self {324 Self::try_new().expect("allocation should not fail")325 }326 fn try_new() -> Result<Self> {327 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)328 }329 pub fn set(&mut self, setting: &CStr, value: &CStr) {330 unsafe {331 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());332 };333 }334}335unsafe impl Send for FetchSettings {}336unsafe impl Sync for FetchSettings {}337338impl Default for FetchSettings {339 fn default() -> Self {340 Self::new()341 }342}343344impl Drop for FetchSettings {345 fn drop(&mut self) {346 unsafe { fetchers_settings_free(self.0) };347 }348}349pub struct FlakeSettings(*mut flake_settings);350impl FlakeSettings {351 pub fn new() -> Result<Self> {352 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)353 }354}355unsafe impl Send for FlakeSettings {}356unsafe impl Sync for FlakeSettings {}357impl Drop for FlakeSettings {358 fn drop(&mut self) {359 unsafe {360 flake_settings_free(self.0);361 }362 }363}364365pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);366impl FlakeReferenceParseFlags {367 pub fn new(settings: &FlakeSettings) -> Result<Self> {368 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })369 .map(Self)370 }371 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {372 with_default_context(|c, _| {373 unsafe {374 flake_reference_parse_flags_set_base_directory(375 c,376 self.0,377 dir.as_ptr().cast(),378 dir.len(),379 )380 };381 })382 }383}384impl Drop for FlakeReferenceParseFlags {385 fn drop(&mut self) {386 unsafe {387 flake_reference_parse_flags_free(self.0);388 }389 }390}391pub struct FlakeLockFlags(*mut flake_lock_flags);392impl FlakeLockFlags {393 pub fn new(settings: &FlakeSettings) -> Result<Self> {394 let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })395 .map(Self)?;396 397398 Ok(o)399 }400}401impl Drop for FlakeLockFlags {402 fn drop(&mut self) {403 unsafe {404 flake_lock_flags_free(self.0);405 }406 }407}408409unsafe extern "C" fn copy_nix_str(start: *const c_char, n: c_uint, user_data: *mut c_void) {410 let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };411 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");412 unsafe { *user_data.cast::<String>() = s.to_owned() };413}414415struct Store(*mut c_store);416unsafe impl Send for Store {}417unsafe impl Sync for Store {}418419impl Store {420 fn parse_path(&self, path: &CStr) -> Result<StorePath> {421 with_default_context(|c, _| {422 StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })423 })424 }425}426427struct EvalState(*mut c_eval_state);428unsafe impl Send for EvalState {}429unsafe impl Sync for EvalState {}430431impl Drop for EvalState {432 fn drop(&mut self) {433 unsafe {434 state_free(self.0);435 }436 }437}438439pub struct FlakeReference(*mut flake_reference);440impl FlakeReference {441 #[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]442 pub fn new(443 s: &str,444 flake: &FlakeSettings,445 parse: &FlakeReferenceParseFlags,446 fetch: &FetchSettings,447 ) -> Result<(Self, String)> {448 let mut out = null_mut();449 let mut fragment = String::new();450 451 with_default_context(|c, _| unsafe {452 flake_reference_and_fragment_from_string(453 c,454 fetch.0,455 flake.0,456 parse.0,457 s.as_ptr().cast(),458 s.len(),459 &mut out,460 Some(copy_nix_str),461 (&raw mut fragment).cast(),462 )463 })?;464 assert!(!out.is_null());465466 Ok((Self(out), fragment))467 }468 #[instrument(name = "lock-flake", skip(self, fetch, flake, lock))]469 pub fn lock(470 &mut self,471 fetch: &FetchSettings,472 flake: &FlakeSettings,473 lock: &FlakeLockFlags,474 ) -> Result<LockedFlake> {475 with_default_context(|c, es| unsafe { flake_lock(c, fetch.0, flake.0, es, lock.0, self.0) })476 .map(LockedFlake)477 }478}479unsafe impl Send for FlakeReference {}480unsafe impl Sync for FlakeReference {}481482pub struct LockedFlake(*mut locked_flake);483impl LockedFlake {484 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {485 with_default_context(|c, es| unsafe {486 locked_flake_get_output_attrs(c, settings.0, es, self.0)487 })488 .map(Value)489 }490}491unsafe impl Send for LockedFlake {}492unsafe impl Sync for LockedFlake {}493impl Drop for LockedFlake {494 fn drop(&mut self) {495 unsafe {496 locked_flake_free(self.0);497 };498 }499}500501type FieldName = [u8; 64];502fn init_field_name(v: &str) -> FieldName {503 let mut f = [0; 64];504 assert!(v.len() < 64, "max field name is 63 chars");505 assert!(506 v.bytes().all(|v| v != 0),507 "nul bytes are unsupported in field name"508 );509 f[0..v.len()].copy_from_slice(v.as_bytes());510 f511}512513pub struct RealisedString(*mut realised_string);514impl fmt::Debug for RealisedString {515 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {516 self.as_str().fmt(f)517 }518}519520impl RealisedString {521 pub fn as_str(&self) -> &str {522 let len = unsafe { realised_string_get_buffer_size(self.0) };523 let data: *const u8 = unsafe { realised_string_get_buffer_start(self.0) }.cast();524 let data = unsafe { slice::from_raw_parts(data, len) };525 std::str::from_utf8(data).expect("non-utf8 strings not supported")526 }527 pub fn path_count(&self) -> usize {528 unsafe { realised_string_get_store_path_count(self.0) }529 }530 pub fn path(&self, i: usize) -> String {531 assert!(i < self.path_count());532 let path = unsafe { realised_string_get_store_path(self.0, i) };533 let mut err_out = String::new();534 unsafe { store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };535 err_out536 }537}538539unsafe impl Send for RealisedString {}540impl Drop for RealisedString {541 fn drop(&mut self) {542 unsafe { realised_string_free(self.0) }543 }544}545546#[repr(transparent)]547pub struct Value(*mut value);548549unsafe impl Send for Value {}550unsafe impl Sync for Value {}551552pub trait AsFieldName {553 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;554 fn to_field_name(&self) -> Result<String>;555}556impl AsFieldName for Value {557 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {558 let f = self.to_string()?;559 v(init_field_name(&f))560 }561 fn to_field_name(&self) -> Result<String> {562 self.to_string()563 }564}565impl<E> AsFieldName for E566where567 E: AsRef<str>,568{569 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {570 let f = self.as_ref();571 v(init_field_name(f))572 }573 fn to_field_name(&self) -> Result<String> {574 Ok(self.as_ref().to_owned())575 }576}577578struct AttrsBuilder(*mut c_bindings_builder);579impl AttrsBuilder {580 fn new(capacity: usize) -> Self {581 with_default_context(|c, es| unsafe { make_bindings_builder(c, es, capacity) })582 .map(Self)583 .expect("alloc should not fail")584 }585 fn insert(&mut self, k: &impl AsFieldName, v: Value) {586 k.as_field_name(|name| {587 with_default_context(|c, _| unsafe {588 bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0);589 590 })591 })592 .expect("builder insert shouldn't fail");593 }594}595impl Drop for AttrsBuilder {596 fn drop(&mut self) {597 unsafe { bindings_builder_free(self.0) };598 }599}600601struct ListBuilder(*mut c_list_builder, c_uint);602impl ListBuilder {603 fn new(capacity: usize) -> Self {604 with_default_context(|c, es| unsafe { make_list_builder(c, es, capacity) })605 .map(|l| Self(l, 0))606 .expect("alloc should not fail")607 }608}609impl ListBuilder {610 fn push(&mut self, v: Value) {611 with_default_context(|c, _| unsafe {612 list_builder_insert(613 c,614 self.0,615 {616 let v = self.1;617 self.1 += 1;618 v619 },620 v.0,621 )622 })623 .expect("list insert shouldn't fail");624 }625}626impl Drop for ListBuilder {627 fn drop(&mut self) {628 unsafe { list_builder_free(self.0) };629 }630}631632impl Value {633 pub fn new_primop(v: NativeFn) -> Self {634 let out = Self::new_uninit();635 with_default_context(|c, _| unsafe { init_primop(c, out.0, v.0) })636 .expect("primop initialization should not fail");637 out638 }639 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {640 let out = Self::new_uninit();641 let mut b = AttrsBuilder::new(v.len());642 for (k, v) in v {643 b.insert(&k, v);644 }645 with_default_context(|c, _| unsafe { make_attrs(c, out.0, b.0) })646 .expect("attrs initialization should not fail");647648 out649 }650 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {651 let out = Self::new_uninit();652 let mut b = ListBuilder::new(v.len());653 for v in v {654 b.push(v.into());655 }656 with_default_context(|c, _| unsafe { make_list(c, b.0, out.0) })657 .expect("list initialization should not fail");658659 out660 }661 fn new_uninit() -> Self {662 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })663 .expect("value allocation should not fail");664 Self(out)665 }666 pub fn new_str(v: &str) -> Self {667 let s = CString::new(v).expect("string should not contain NULs");668 let out = Self::new_uninit();669 670 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })671 .expect("string initialization should not fail");672 out673 }674 pub fn new_int(i: i64) -> Self {675 let out = Self::new_uninit();676 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })677 .expect("int initialization should not fail");678 out679 }680 pub fn new_bool(v: bool) -> Self {681 let out = Self::new_uninit();682 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })683 .expect("bool initialization should not fail");684 out685 }686 687 688 689 690 691 pub fn type_of(&self) -> NixType {692 let ty = with_default_context(|c, _| unsafe { get_type(c, self.0) })693 .expect("get_type should not fail");694 NixType::from_int(ty)695 }696 fn builtin_to_string(&self) -> Result<Self> {697 let builtin = Self::eval("builtins.toString")?;698 builtin.call(self.clone())699 }700 pub fn to_string(&self) -> Result<String> {701 let mut str_out = String::new();702 with_default_context(|c, _| unsafe {703 get_string(c, self.0, Some(copy_nix_str), (&raw mut str_out).cast())704 })?;705706 Ok(str_out)707 }708 pub fn to_realised_string(&self) -> Result<RealisedString> {709 with_default_context(|c, es| unsafe { string_realise(c, es, self.0, false) })710 .map(RealisedString)711712 713 714 715 716 717 718 719 }720721 pub fn has_field(&self, field: &str) -> Result<bool> {722 let f = init_field_name(field);723 with_default_context(|c, es| unsafe { has_attr_byname(c, self.0, es, f.as_ptr().cast()) })724 }725 726 727 728 pub fn list_fields(&self) -> Result<Vec<String>> {729 if !matches!(self.type_of(), NixType::Attrs) {730 bail!("invalid type: expected attrs");731 }732733 let len = with_default_context(|c, _| unsafe { get_attrs_size(c, self.0) })?;734 let mut out = Vec::with_capacity(len as usize);735736 for i in 0..len {737 let name =738 with_default_context(|c, es| unsafe { get_attr_name_byidx(c, self.0, es, i) })?;739 let c = unsafe { CStr::from_ptr(name) };740 out.push(c.to_str().expect("nix field names are utf-8").to_owned());741 }742 Ok(out)743 }744 pub fn get_elem(&self, v: usize) -> Result<Self> {745 if !matches!(self.type_of(), NixType::List) {746 bail!("invalid type: expected list");747 }748 let len = with_default_context(|c, _| unsafe { get_list_size(c, self.0) })? as usize;749 if v >= len {750 bail!("oob list get: {v} >= {len}");751 }752753 with_default_context(|c, es| unsafe { get_list_byidx(c, self.0, es, v as u32) }).map(Self)754 }755 pub fn attrs_update(self, other: Value ) -> Result<Self> {756 let attrs_update_fn = Self::eval("a: b: a // b")?;757758 attrs_update_fn759 .call(self)?760 .call(other)761 .context("attrs update")762 }763 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {764 if !matches!(self.type_of(), NixType::Attrs) {765 bail!("invalid type: expected attrs");766 }767768 name.as_field_name(|name| {769 with_default_context(|c, es| unsafe {770 get_attr_byname(c, self.0, es, name.as_ptr().cast())771 })772 .map(Self)773 })774 .with_context(|| format!("getting field {:?}", name.to_field_name()))775 }776 pub fn call(&self, v: Value) -> Result<Self> {777 let kind = self778 .functor_kind()779 .ok_or_else(|| anyhow!("can only call function or functor"))?;780781 let function = match kind {782 FunctorKind::Function => self.clone(),783 FunctorKind::Functor => {784 let f = self785 .get_field("__functor")786 .context("getting functor value")?;787 assert_eq!(788 f.type_of(),789 NixType::Function,790 "invalid functor encountered"791 );792 f793 }794 };795796 let out = Value::new_uninit();797 with_default_context(|c, es| unsafe { value_call(c, es, function.0, v.0, out.0) })?;798799 Ok(out)800 }801 pub fn eval(v: &str) -> Result<Self> {802 let s = CString::new(v).expect("expression shouldn't have internal NULs");803 let out = Self::new_uninit();804 with_default_context(|c, es| unsafe {805 expr_eval_from_string(c, es, s.as_ptr(), c"/root".as_ptr(), out.0)806 })?;807 Ok(out)808 }809 pub fn build(&self, output: &str) -> Result<PathBuf> {810 if !self.is_derivation() {811 bail!("expected derivation to build")812 }813 let output_name = self814 .get_field("outputName")815 .context("getting output name field")?816 .to_string()?;817 let v = if output_name != output {818 let out = self.get_field(output).context("getting target output")?;819 if !out.is_derivation() {820 bail!("unknown output: {output}");821 }822 out823 } else {824 self.clone()825 };826 827 let s = v.builtin_to_string()?;828 let rs = s.to_realised_string()?;829 let drv_path = rs.as_str().to_owned();830 Ok(PathBuf::from(drv_path))831 }832 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {833 let to_json = Self::eval("builtins.toJSON")?;834 let s = to_json.call(self.clone())?.to_string()?;835 Ok(serde_json::from_str(&s)?)836 }837 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {838 Self::eval(&nixlike::serialize(v)?)839 }840841 842 843 844 845 846847 fn is_derivation(&self) -> bool {848 if !matches!(self.type_of(), NixType::Attrs) {849 return false;850 }851 let Some(ty) = self.get_field("type").ok() else {852 return false;853 };854 matches!(ty.to_string().as_deref(), Ok("derivation"))855 }856 fn functor_kind(&self) -> Option<FunctorKind> {857 match self.type_of() {858 NixType::Attrs => self859 .has_field("__functor")860 .expect("has_field shouldn't fail for attrs")861 .then_some(FunctorKind::Functor),862 NixType::Function => Some(FunctorKind::Function),863 _ => None,864 }865 }866 pub fn is_function(&self) -> bool {867 self.functor_kind().is_some()868 }869 pub fn is_null(&self) -> bool {870 matches!(self.type_of(), NixType::Null)871 }872}873874impl From<String> for Value {875 fn from(value: String) -> Self {876 Value::new_str(&value)877 }878}879impl From<bool> for Value {880 fn from(value: bool) -> Self {881 Value::new_bool(value)882 }883}884impl From<&str> for Value {885 fn from(value: &str) -> Self {886 Value::new_str(value)887 }888}889impl<T> From<Vec<T>> for Value890where891 T: Into<Value>,892{893 fn from(value: Vec<T>) -> Self {894 Value::new_list(value)895 }896}897898impl Clone for Value {899 fn clone(&self) -> Self {900 with_default_context(|c, _| unsafe { value_incref(c, self.0) })901 .expect("value incref should not fail");902 Self(self.0)903 }904}905impl Drop for Value {906 fn drop(&mut self) {907 with_default_context(|c, _| unsafe { value_decref(c, self.0) })908 .expect("value drop should not fail");909 }910}911912pub fn init_libraries() {913 unsafe { GC_allow_register_threads() };914915 let mut ctx = NixContext::new();916 ctx.run_in_context(|c| unsafe { libutil_init(c) })917 .expect("util init should not fail");918 ctx.run_in_context(|c| unsafe { libstore_init(c) })919 .expect("store init should not fail");920 ctx.run_in_context(|c| unsafe { libexpr_init(c) })921 .expect("expr init should not fail");922923 nix_logging_cxx::apply_tracing_logger();924}925926unsafe extern "C" fn nix_primop_closure_adapter<const N: usize>(927 user_data: *mut c_void,928 context: *mut c_context,929 state: *mut nix_raw::EvalState,930 args: *mut *mut value,931 ret: *mut value,932) {933 let user_closure: &UserClosure<N> = unsafe { &*user_data.cast_const().cast() };934 let args: [&Value; N] = array::from_fn(|i| {935 let v: &Value = unsafe { &*args.add(i).cast_const().cast() };936 v937 });938 let ctx: &mut NixContext = unsafe { &mut *context.cast() };939940 match user_closure(args) {941 Ok(v) => {942 unsafe { copy_value(context, ret, v.0) };943 }944 Err(e) => {945 ctx.set_err(946 NixErrorKind::Unknown,947 &CString::new(e.to_string()).expect("error should not contain internal nuls"),948 );949 }950 }951}952953type UserClosure<const N: usize> = Box<dyn Fn([&Value; N]) -> Result<Value>>;954955pub struct NativeFn(*mut PrimOp);956impl NativeFn {957 pub fn new<const N: usize>(958 name: &'static CStr,959 doc: &'static CStr,960 args: [&'static CStr; N],961 f: impl Fn([&Value; N]) -> Result<Value> + 'static,962 ) -> Self {963 964 let closure: Box<UserClosure<N>> = Box::new(Box::new(f));965 let f: PrimOpFun = Some(nix_primop_closure_adapter::<N>);966 let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();967 args.push(null());968 let args = args.as_mut_ptr();969 let primop = unsafe {970 alloc_primop(971 null_mut(),972 f,973 N as i32,974 name.as_ptr(),975 args,976 doc.as_ptr(),977 Box::into_raw(closure).cast(),978 )979 };980981 assert!(!primop.is_null(), "primop allocation should not fail");982983 Self(primop)984 }985 pub fn register(self) {986 unsafe { register_primop(null_mut(), self.0) };987 }988}989990struct StorePath(*mut c_store_path);991impl StorePath {}992993impl Drop for StorePath {994 fn drop(&mut self) {995 unsafe { store_path_free(self.0) }996 }997}998999#[test_log::test]1000fn test_native() -> Result<()> {1001 init_libraries();1002 NativeFn::new(1003 c"__uppercaseSuffix2",1004 c"make string uppercase and add suffix",1005 [c"str", c"suffix"],1006 |[str, suffix]: [&Value; 2]| {1007 let str = str.to_string()?;1008 let suffix = suffix.to_string()?;1009 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1010 },1011 )1012 .register();10131014 let mut fetch_settings = FetchSettings::new();1015 fetch_settings.set(c"warn-dirty", c"false");10161017 let manifest = format!("git+file://{}/../../", env!("CARGO_MANIFEST_DIR"));1018 let flake = FlakeSettings::new()?;1019 let parse = FlakeReferenceParseFlags::new(&flake)?;1020 let (mut r, _) = FlakeReference::new(&manifest, &flake, &parse, &fetch_settings)?;1021 let lock = FlakeLockFlags::new(&flake)?;1022 let locked = r.lock(&fetch_settings, &flake, &lock)?;1023 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;10241025 let builtins = Value::eval("builtins")?;1026 assert_eq!(builtins.type_of(), NixType::Attrs);10271028 assert_eq!(attrs.type_of(), NixType::Attrs);1029 let test_data = nix_go!(attrs.testData);10301031 let test_string: String = nix_go_json!(test_data.testString);1032 assert_eq!(test_string, "hello");10331034 let s = nix_go!(attrs.packages["x86_64-linux"].fleet.drvPath);1035 let s = CString::new(s.to_string()?).expect("path str is cstring");10361037 let uppercase_suffix = Value::new_primop(NativeFn::new(1038 c"uppercase_suffix",1039 c"make string uppercase and add suffix",1040 [c"str", c"suffix"],1041 |[str, suffix]: [&Value; 2]| {1042 let str = str.to_string()?;1043 let suffix = suffix.to_string()?;1044 Ok(Value::new_str(&format!("{}{suffix}", str.to_uppercase())))1045 },1046 ));10471048 let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));1049 assert_eq!(test_result, "PREFIX_BODY_SUFFIX");1050 let test_result: String = nix_go_json!(builtins.uppercaseSuffix2("test")("suffix"));1051 assert_eq!(test_result, "TESTsuffix");10521053 let nix_ctx = NixContext::new();1054 let store = GLOBAL_STATE.store.parse_path(s.as_c_str())?;10551056 10571058 Ok(())1059}1060106110621063106410651066106710681069107010711072107310741075107610771078