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_mut;5use std::sync::LazyLock;6use std::{collections::HashMap, path::PathBuf};7use std::{fmt, slice};89use anyhow::{Context, anyhow, bail};10use serde::Serialize;11use serde::de::DeserializeOwned;1213pub use anyhow::Result;14use tracing::instrument;1516use self::logging::{ErrorInfoBuilder, nix_logging_cxx};17use self::nix_cxx::set_fetcher_setting;18use self::nix_raw::{19 BindingsBuilder as c_bindings_builder, EvalState as c_eval_state, GC_SUCCESS,20 GC_allow_register_threads, GC_get_stack_base, GC_register_my_thread, GC_stack_base,21 GC_thread_is_registered, GC_unregister_my_thread, ListBuilder as c_list_builder,22 Store as c_store, StorePath as c_store_path, alloc_value, bindings_builder_free,23 bindings_builder_insert, c_context, c_context_create, c_context_free, clear_err, err_code,24 err_info_msg, err_msg, eval_state_build, eval_state_builder_load, eval_state_builder_new,25 eval_state_builder_set_eval_setting, expr_eval_from_string, fetchers_settings,26 fetchers_settings_free, fetchers_settings_new, flake_lock, flake_lock_flags,27 flake_lock_flags_free, flake_lock_flags_new, flake_reference,28 flake_reference_and_fragment_from_string, flake_reference_parse_flags,29 flake_reference_parse_flags_free, flake_reference_parse_flags_new,30 flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,31 flake_settings_new, gc_now as gc_now_raw, get_attr_byname, get_attr_name_byidx, get_attrs_size,32 get_list_byidx, get_list_size, get_string, get_type, has_attr_byname, init_bool, init_int,33 init_string, libexpr_init, libstore_init, libutil_init, list_builder_free, list_builder_insert,34 locked_flake, locked_flake_free, locked_flake_get_output_attrs, make_attrs,35 make_bindings_builder, make_list, make_list_builder, realised_string, realised_string_free,36 realised_string_get_buffer_size, realised_string_get_buffer_start,37 realised_string_get_store_path, realised_string_get_store_path_count, set_err_msg, setting_set,38 state_free, store_open, store_parse_path, store_path_free, store_path_name, string_realise,39 value, value_call, value_decref, value_incref,40};414243pub mod logging;44#[doc(hidden)]45pub mod macros;46pub mod util;4748#[allow(49 non_upper_case_globals,50 non_camel_case_types,51 non_snake_case,52 dead_code53)]54mod nix_raw {55 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));56}57#[cxx::bridge]58pub mod nix_cxx {59 unsafe extern "C++" {60 type nix_fetchers_settings;61 include!("nix-eval/src/lib.hh");6263 unsafe fn set_fetcher_setting(64 settings: *mut nix_fetchers_settings,65 setting: *const c_char,66 value: *const c_char,67 );68 }69}7071#[derive(Debug, PartialEq, Eq)]72pub enum NixType {73 Thunk,74 Int,75 Float,76 Bool,77 String,78 Path,79 Null,80 Attrs,81 List,82 Function,83 External,84}85impl NixType {86 fn from_int(c: c_uint) -> Self {87 match c {88 0 => Self::Thunk,89 1 => Self::Int,90 2 => Self::Float,91 3 => Self::Bool,92 4 => Self::String,93 5 => Self::Path,94 6 => Self::Null,95 7 => Self::Attrs,96 8 => Self::List,97 9 => Self::Function,98 10 => Self::External,99 _ => unreachable!("unknown nix type: {c}"),100 }101 }102}103104enum FunctorKind {105 Function,106 Functor,107}108109#[derive(Debug)]110#[repr(i32)]111pub enum NixErrorKind {112 Unknown = 1,113 Overflow = 2,114 Key = 3,115 Generic = 4,116}117impl NixErrorKind {118 fn from_int(v: c_int) -> Option<Self> {119 Some(match v {120 0 => return None,121 -1 => Self::Unknown,122 -2 => Self::Overflow,123 -3 => Self::Key,124 -4 => Self::Generic,125 _ => {126 debug_assert!(false, "unexpected nix error kind: {v}");127 Self::Unknown128 }129 })130 }131}132133pub fn gc_now() {134 unsafe { gc_now_raw() };135}136137pub fn gc_register_my_thread() {138 assert_eq!(unsafe { GC_thread_is_registered() }, 0);139140 let mut sb = GC_stack_base {141 mem_base: null_mut(),142 };143 let r = unsafe { GC_get_stack_base(&mut sb) };144 if r as u32 != GC_SUCCESS {145 panic!("failed to get thread stack base");146 }147 unsafe { GC_register_my_thread(&sb) };148}149pub fn gc_unregister_my_thread() {150 assert_eq!(unsafe { GC_thread_is_registered() }, 1);151152 unsafe { GC_unregister_my_thread() };153}154155pub struct ThreadRegisterGuard {}156impl ThreadRegisterGuard {157 #[allow(clippy::new_without_default)]158 pub fn new() -> Self {159 gc_register_my_thread();160 Self {}161 }162}163impl Drop for ThreadRegisterGuard {164 fn drop(&mut self) {165 gc_unregister_my_thread();166 }167}168169pub struct NixContext(*mut c_context);170impl NixContext {171 pub fn set_err(&mut self, err: NixErrorKind, msg: &CStr) {172 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };173 }174 pub fn new() -> Self {175 let ctx = unsafe { c_context_create() };176 Self(ctx)177 }178 fn error_kind(&self) -> Option<NixErrorKind> {179 let code = unsafe { err_code(self.0) };180 NixErrorKind::from_int(code)181 }182 fn error<'t>(&self) -> Option<(Cow<'t, str>, Option<Box<ErrorInfoBuilder>>)> {183 if let NixErrorKind::Generic = self.error_kind()? {184 let ei = unsafe { logging::nix_logging_cxx::extract_error_info(self.0) };185 let mut err_out = String::new();186 unsafe {187 err_info_msg(188 null_mut(),189 self.0,190 Some(copy_nix_str),191 (&raw mut err_out).cast(),192 )193 };194 return Some((Cow::Owned(err_out), Some(ei)));195 };196197 198 199 let str = unsafe { err_msg(null_mut(), self.0, null_mut()) };200 Some((unsafe { CStr::from_ptr(str) }.to_string_lossy(), None))201 }202 fn clean_err(&mut self) {203 unsafe {204 clear_err(self.0);205 }206 }207208 fn bail_if_error(&self) -> Result<()> {209 if let Some((err, stack)) = self.error() {210 let mut e = Err(anyhow!("{err}"));211 if let Some(stack) = stack {212 for ele in stack.stack_frames {213 e = e.with_context(|| {214 if ele.pos.is_empty() {215 ele.msg216 } else {217 format!("{} at {}", ele.msg, ele.pos)218 }219 })220 }221 }222 return e.context("<nix frames>");223 };224 Ok(())225 }226227 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {228 self.clean_err();229 let o = f(self.0);230 self.bail_if_error()?;231 self.clean_err();232 Ok(o)233 }234}235236impl Default for NixContext {237 fn default() -> Self {238 Self::new()239 }240}241impl Drop for NixContext {242 fn drop(&mut self) {243 unsafe {244 c_context_free(self.0);245 }246 }247}248struct GlobalState {249 250 #[allow(dead_code)]251 store: Store,252 state: EvalState,253}254impl GlobalState {255 fn new() -> Result<Self> {256 let mut ctx = NixContext::new();257 let store = ctx258 .run_in_context(|c| unsafe { store_open(c, c"auto".as_ptr(), null_mut()) })259 .map(Store)?;260261 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;262 ctx.run_in_context(|c| unsafe { eval_state_builder_load(c, builder) })?;263 ctx.run_in_context(|c| unsafe {264 eval_state_builder_set_eval_setting(265 c,266 builder,267 c"lazy-trees".as_ptr(),268 c"true".as_ptr(),269 )270 })?;271 ctx.run_in_context(|c| unsafe {272 eval_state_builder_set_eval_setting(273 c,274 builder,275 c"lazy-locks".as_ptr(),276 c"true".as_ptr(),277 )278 })?;279 let state = ctx280 .run_in_context(|c| unsafe { eval_state_build(c, builder) })281 .map(EvalState)?;282283 Ok(Self { store, state })284 }285}286287struct ThreadState {288 ctx: NixContext,289}290impl ThreadState {291 fn new() -> Result<Self> {292 let ctx = NixContext::new();293294 Ok(Self { ctx })295 }296}297298static GLOBAL_STATE: LazyLock<GlobalState> =299 LazyLock::new(|| GlobalState::new().expect("global state init shouldn't fail"));300301thread_local! {302 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));303}304fn with_default_context<T>(f: impl FnOnce(*mut c_context, *mut c_eval_state) -> T) -> Result<T> {305 let global = &GLOBAL_STATE.state;306 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));307 let mut ctx = NixContext(ctx);308 let v = ctx.run_in_context(|c| f(c, state));309 310 std::mem::forget(ctx);311 v312}313314pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {315 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())316}317318pub struct FetchSettings(*mut fetchers_settings);319impl FetchSettings {320 pub fn new() -> Self {321 Self::try_new().expect("allocation should not fail")322 }323 fn try_new() -> Result<Self> {324 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)325 }326 pub fn set(&mut self, setting: &CStr, value: &CStr) {327 unsafe {328 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());329 };330 }331}332unsafe impl Send for FetchSettings {}333unsafe impl Sync for FetchSettings {}334335impl Default for FetchSettings {336 fn default() -> Self {337 Self::new()338 }339}340341impl Drop for FetchSettings {342 fn drop(&mut self) {343 unsafe { fetchers_settings_free(self.0) };344 }345}346pub struct FlakeSettings(*mut flake_settings);347impl FlakeSettings {348 pub fn new() -> Result<Self> {349 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)350 }351}352unsafe impl Send for FlakeSettings {}353unsafe impl Sync for FlakeSettings {}354impl Drop for FlakeSettings {355 fn drop(&mut self) {356 unsafe {357 flake_settings_free(self.0);358 }359 }360}361362pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);363impl FlakeReferenceParseFlags {364 pub fn new(settings: &FlakeSettings) -> Result<Self> {365 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })366 .map(Self)367 }368 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {369 with_default_context(|c, _| {370 unsafe {371 flake_reference_parse_flags_set_base_directory(372 c,373 self.0,374 dir.as_ptr().cast(),375 dir.len(),376 )377 };378 })379 }380}381impl Drop for FlakeReferenceParseFlags {382 fn drop(&mut self) {383 unsafe {384 flake_reference_parse_flags_free(self.0);385 }386 }387}388pub struct FlakeLockFlags(*mut flake_lock_flags);389impl FlakeLockFlags {390 pub fn new(settings: &FlakeSettings) -> Result<Self> {391 let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })392 .map(Self)?;393 394395 Ok(o)396 }397}398impl Drop for FlakeLockFlags {399 fn drop(&mut self) {400 unsafe {401 flake_lock_flags_free(self.0);402 }403 }404}405406unsafe extern "C" fn copy_nix_str(start: *const c_char, n: c_uint, user_data: *mut c_void) {407 let s = unsafe { slice::from_raw_parts(start.cast::<u8>(), n as usize) };408 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");409 unsafe { *user_data.cast::<String>() = s.to_owned() };410}411412struct Store(*mut c_store);413unsafe impl Send for Store {}414unsafe impl Sync for Store {}415416impl Store {417 fn parse_path(&self, path: &CStr) -> Result<StorePath> {418 with_default_context(|c, _| {419 StorePath(unsafe { store_parse_path(c, self.0, path.as_ptr()) })420 })421 }422}423424struct EvalState(*mut c_eval_state);425unsafe impl Send for EvalState {}426unsafe impl Sync for EvalState {}427428impl Drop for EvalState {429 fn drop(&mut self) {430 unsafe {431 state_free(self.0);432 }433 }434}435436pub struct FlakeReference(*mut flake_reference);437impl FlakeReference {438 #[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]439 pub fn new(440 s: &str,441 flake: &FlakeSettings,442 parse: &FlakeReferenceParseFlags,443 fetch: &FetchSettings,444 ) -> Result<(Self, String)> {445 let mut out = null_mut();446 let mut fragment = String::new();447 448 with_default_context(|c, _| unsafe {449 flake_reference_and_fragment_from_string(450 c,451 fetch.0,452 flake.0,453 parse.0,454 s.as_ptr().cast(),455 s.len(),456 &mut out,457 Some(copy_nix_str),458 (&raw mut fragment).cast(),459 )460 })?;461 assert!(!out.is_null());462463 Ok((Self(out), fragment))464 }465 #[instrument(name = "lock-flake", skip(self, fetch, flake, lock))]466 pub fn lock(467 &mut self,468 fetch: &FetchSettings,469 flake: &FlakeSettings,470 lock: &FlakeLockFlags,471 ) -> Result<LockedFlake> {472 with_default_context(|c, es| unsafe { flake_lock(c, fetch.0, flake.0, es, lock.0, self.0) })473 .map(LockedFlake)474 }475}476unsafe impl Send for FlakeReference {}477unsafe impl Sync for FlakeReference {}478479pub struct LockedFlake(*mut locked_flake);480impl LockedFlake {481 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {482 with_default_context(|c, es| unsafe {483 locked_flake_get_output_attrs(c, settings.0, es, self.0)484 })485 .map(Value)486 }487}488unsafe impl Send for LockedFlake {}489unsafe impl Sync for LockedFlake {}490impl Drop for LockedFlake {491 fn drop(&mut self) {492 unsafe {493 locked_flake_free(self.0);494 };495 }496}497498type FieldName = [u8; 64];499fn init_field_name(v: &str) -> FieldName {500 let mut f = [0; 64];501 assert!(v.len() < 64, "max field name is 63 chars");502 assert!(503 v.bytes().all(|v| v != 0),504 "nul bytes are unsupported in field name"505 );506 f[0..v.len()].copy_from_slice(v.as_bytes());507 f508}509510pub struct RealisedString(*mut realised_string);511impl fmt::Debug for RealisedString {512 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {513 self.as_str().fmt(f)514 }515}516517impl RealisedString {518 pub fn as_str(&self) -> &str {519 let len = unsafe { realised_string_get_buffer_size(self.0) };520 let data: *const u8 = unsafe { realised_string_get_buffer_start(self.0) }.cast();521 let data = unsafe { slice::from_raw_parts(data, len) };522 std::str::from_utf8(data).expect("non-utf8 strings not supported")523 }524 pub fn path_count(&self) -> usize {525 unsafe { realised_string_get_store_path_count(self.0) }526 }527 pub fn path(&self, i: usize) -> String {528 assert!(i < self.path_count());529 let path = unsafe { realised_string_get_store_path(self.0, i) };530 let mut err_out = String::new();531 unsafe { store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };532 err_out533 }534}535536unsafe impl Send for RealisedString {}537impl Drop for RealisedString {538 fn drop(&mut self) {539 unsafe { realised_string_free(self.0) }540 }541}542543pub struct Value(*mut value);544545unsafe impl Send for Value {}546unsafe impl Sync for Value {}547548pub trait AsFieldName {549 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;550 fn to_field_name(&self) -> Result<String>;551}552impl AsFieldName for Value {553 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {554 let f = self.to_string()?;555 v(init_field_name(&f))556 }557 fn to_field_name(&self) -> Result<String> {558 self.to_string()559 }560}561impl<E> AsFieldName for E562where563 E: AsRef<str>,564{565 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {566 let f = self.as_ref();567 v(init_field_name(f))568 }569 fn to_field_name(&self) -> Result<String> {570 Ok(self.as_ref().to_owned())571 }572}573574struct AttrsBuilder(*mut c_bindings_builder);575impl AttrsBuilder {576 fn new(capacity: usize) -> Self {577 with_default_context(|c, es| unsafe { make_bindings_builder(c, es, capacity) })578 .map(Self)579 .expect("alloc should not fail")580 }581 fn insert(&mut self, k: &impl AsFieldName, v: Value) {582 k.as_field_name(|name| {583 with_default_context(|c, _| unsafe {584 bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0);585 586 })587 })588 .expect("builder insert shouldn't fail");589 }590}591impl Drop for AttrsBuilder {592 fn drop(&mut self) {593 unsafe { bindings_builder_free(self.0) };594 }595}596597struct ListBuilder(*mut c_list_builder, c_uint);598impl ListBuilder {599 fn new(capacity: usize) -> Self {600 with_default_context(|c, es| unsafe { make_list_builder(c, es, capacity) })601 .map(|l| Self(l, 0))602 .expect("alloc should not fail")603 }604}605impl ListBuilder {606 fn push(&mut self, v: Value) {607 with_default_context(|c, _| unsafe {608 list_builder_insert(609 c,610 self.0,611 {612 let v = self.1;613 self.1 += 1;614 v615 },616 v.0,617 )618 })619 .expect("list insert shouldn't fail");620 }621}622impl Drop for ListBuilder {623 fn drop(&mut self) {624 unsafe { list_builder_free(self.0) };625 }626}627628impl Value {629 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {630 let out = Self::new_uninit();631 let mut b = AttrsBuilder::new(v.len());632 for (k, v) in v {633 b.insert(&k, v);634 }635 with_default_context(|c, _| unsafe { make_attrs(c, out.0, b.0) })636 .expect("attrs initialization should not fail");637638 out639 }640 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {641 let out = Self::new_uninit();642 let mut b = ListBuilder::new(v.len());643 for v in v {644 b.push(v.into());645 }646 with_default_context(|c, _| unsafe { make_list(c, b.0, out.0) })647 .expect("list initialization should not fail");648649 out650 }651 fn new_uninit() -> Self {652 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })653 .expect("value allocation should not fail");654 Self(out)655 }656 pub fn new_str(v: &str) -> Self {657 let s = CString::new(v).expect("string should not contain NULs");658 let out = Self::new_uninit();659 660 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })661 .expect("string initialization should not fail");662 out663 }664 pub fn new_int(i: i64) -> Self {665 let out = Self::new_uninit();666 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })667 .expect("int initialization should not fail");668 out669 }670 pub fn new_bool(v: bool) -> Self {671 let out = Self::new_uninit();672 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })673 .expect("bool initialization should not fail");674 out675 }676 677 678 679 680 681 pub fn type_of(&self) -> NixType {682 let ty = with_default_context(|c, _| unsafe { get_type(c, self.0) })683 .expect("get_type should not fail");684 NixType::from_int(ty)685 }686 fn builtin_to_string(&self) -> Result<Self> {687 let builtin = Self::eval("builtins.toString")?;688 builtin.call(self.clone())689 }690 pub fn to_string(&self) -> Result<String> {691 let mut str_out = String::new();692 with_default_context(|c, _| unsafe {693 get_string(c, self.0, Some(copy_nix_str), (&raw mut str_out).cast())694 })?;695696 Ok(str_out)697 }698 pub fn to_realised_string(&self) -> Result<RealisedString> {699 with_default_context(|c, es| unsafe { string_realise(c, es, self.0, false) })700 .map(RealisedString)701702 703 704 705 706 707 708 709 }710711 pub fn has_field(&self, field: &str) -> Result<bool> {712 let f = init_field_name(field);713 with_default_context(|c, es| unsafe { has_attr_byname(c, self.0, es, f.as_ptr().cast()) })714 }715 716 717 718 pub fn list_fields(&self) -> Result<Vec<String>> {719 if !matches!(self.type_of(), NixType::Attrs) {720 bail!("invalid type: expected attrs");721 }722723 let len = with_default_context(|c, _| unsafe { get_attrs_size(c, self.0) })?;724 let mut out = Vec::with_capacity(len as usize);725726 for i in 0..len {727 let name =728 with_default_context(|c, es| unsafe { get_attr_name_byidx(c, self.0, es, i) })?;729 let c = unsafe { CStr::from_ptr(name) };730 out.push(c.to_str().expect("nix field names are utf-8").to_owned());731 }732 Ok(out)733 }734 pub fn get_elem(&self, v: usize) -> Result<Self> {735 if !matches!(self.type_of(), NixType::List) {736 bail!("invalid type: expected list");737 }738 let len = with_default_context(|c, _| unsafe { get_list_size(c, self.0) })? as usize;739 if v >= len {740 bail!("oob list get: {v} >= {len}");741 }742743 with_default_context(|c, es| unsafe { get_list_byidx(c, self.0, es, v as u32) }).map(Self)744 }745 pub fn attrs_update(self, other: Value ) -> Result<Self> {746 let attrs_update_fn = Self::eval("a: b: a // b")?;747748 attrs_update_fn749 .call(self)?750 .call(other)751 .context("attrs update")752 }753 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {754 if !matches!(self.type_of(), NixType::Attrs) {755 bail!("invalid type: expected attrs");756 }757758 name.as_field_name(|name| {759 with_default_context(|c, es| unsafe {760 get_attr_byname(c, self.0, es, name.as_ptr().cast())761 })762 .map(Self)763 })764 .with_context(|| format!("getting field {:?}", name.to_field_name()))765 }766 pub fn call(&self, v: Value) -> Result<Self> {767 let kind = self768 .functor_kind()769 .ok_or_else(|| anyhow!("can only call function or functor"))?;770771 let function = match kind {772 FunctorKind::Function => self.clone(),773 FunctorKind::Functor => {774 let f = self775 .get_field("__functor")776 .context("getting functor value")?;777 assert_eq!(778 f.type_of(),779 NixType::Function,780 "invalid functor encountered"781 );782 f783 }784 };785786 let out = Value::new_uninit();787 with_default_context(|c, es| unsafe { value_call(c, es, function.0, v.0, out.0) })?;788789 Ok(out)790 }791 pub fn eval(v: &str) -> Result<Self> {792 let s = CString::new(v).expect("expression shouldn't have internal NULs");793 let out = Self::new_uninit();794 with_default_context(|c, es| unsafe {795 expr_eval_from_string(c, es, s.as_ptr(), c"/root".as_ptr(), out.0)796 })?;797 Ok(out)798 }799 pub fn build(&self, output: &str) -> Result<PathBuf> {800 if !self.is_derivation() {801 bail!("expected derivation to build")802 }803 let output_name = self804 .get_field("outputName")805 .context("getting output name field")?806 .to_string()?;807 let v = if output_name != output {808 let out = self.get_field(output).context("getting target output")?;809 if !out.is_derivation() {810 bail!("unknown output: {output}");811 }812 out813 } else {814 self.clone()815 };816 817 let s = v.builtin_to_string()?;818 let rs = s.to_realised_string()?;819 let drv_path = rs.as_str().to_owned();820 Ok(PathBuf::from(drv_path))821 }822 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {823 let to_json = Self::eval("builtins.toJSON")?;824 let s = to_json.call(self.clone())?.to_string()?;825 Ok(serde_json::from_str(&s)?)826 }827 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {828 Self::eval(&nixlike::serialize(v)?)829 }830831 832 833 834 835 836837 fn is_derivation(&self) -> bool {838 if !matches!(self.type_of(), NixType::Attrs) {839 return false;840 }841 let Some(ty) = self.get_field("type").ok() else {842 return false;843 };844 matches!(ty.to_string().as_deref(), Ok("derivation"))845 }846 fn functor_kind(&self) -> Option<FunctorKind> {847 match self.type_of() {848 NixType::Attrs => self849 .has_field("__functor")850 .expect("has_field shouldn't fail for attrs")851 .then_some(FunctorKind::Functor),852 NixType::Function => Some(FunctorKind::Function),853 _ => None,854 }855 }856 pub fn is_function(&self) -> bool {857 self.functor_kind().is_some()858 }859 pub fn is_null(&self) -> bool {860 matches!(self.type_of(), NixType::Null)861 }862}863864impl From<String> for Value {865 fn from(value: String) -> Self {866 Value::new_str(&value)867 }868}869impl From<bool> for Value {870 fn from(value: bool) -> Self {871 Value::new_bool(value)872 }873}874impl From<&str> for Value {875 fn from(value: &str) -> Self {876 Value::new_str(value)877 }878}879impl<T> From<Vec<T>> for Value880where881 T: Into<Value>,882{883 fn from(value: Vec<T>) -> Self {884 Value::new_list(value)885 }886}887888impl Clone for Value {889 fn clone(&self) -> Self {890 with_default_context(|c, _| unsafe { value_incref(c, self.0) })891 .expect("value incref should not fail");892 Self(self.0)893 }894}895impl Drop for Value {896 fn drop(&mut self) {897 with_default_context(|c, _| unsafe { value_decref(c, self.0) })898 .expect("value drop should not fail");899 }900}901902pub fn init_libraries() {903 unsafe { GC_allow_register_threads() };904905 let mut ctx = NixContext::new();906 ctx.run_in_context(|c| unsafe { libutil_init(c) })907 .expect("util init should not fail");908 ctx.run_in_context(|c| unsafe { libstore_init(c) })909 .expect("store init should not fail");910 ctx.run_in_context(|c| unsafe { libexpr_init(c) })911 .expect("expr init should not fail");912913 nix_logging_cxx::apply_tracing_logger();914}915916struct StorePath(*mut c_store_path);917impl StorePath {}918919impl Drop for StorePath {920 fn drop(&mut self) {921 unsafe { store_path_free(self.0) }922 }923}924925#[test_log::test]926fn test_native() -> Result<()> {927 init_libraries();928929 let mut fetch_settings = FetchSettings::new();930 fetch_settings.set(c"warn-dirty", c"false");931932 let manifest = format!("git+file://{}/../../", env!("CARGO_MANIFEST_DIR"));933 let flake = FlakeSettings::new()?;934 let parse = FlakeReferenceParseFlags::new(&flake)?;935 let (mut r, _) = FlakeReference::new(&manifest, &flake, &parse, &fetch_settings)?;936 let lock = FlakeLockFlags::new(&flake)?;937 let locked = r.lock(&fetch_settings, &flake, &lock)?;938 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;939940 let builtins = Value::eval("builtins")?;941 assert_eq!(builtins.type_of(), NixType::Attrs);942943 assert_eq!(attrs.type_of(), NixType::Attrs);944 let test_data = nix_go!(attrs.testData);945946 let test_string: String = nix_go_json!(test_data.testString);947 assert_eq!(test_string, "hello");948949 let s = nix_go!(attrs.packages["x86_64-linux"].fleet.drvPath);950 let s = CString::new(s.to_string()?).expect("path str is cstring");951952 let nix_ctx = NixContext::new();953 let store = GLOBAL_STATE.store.parse_path(s.as_c_str())?;954955 956957 Ok(())958}959960961962963964965966967968969970971972973974975976977