1use std::borrow::Cow;2use std::cell::RefCell;3use std::ffi::{CStr, CString, c_char, c_int, c_uint, c_void};4use std::fmt;5use std::ptr::null_mut;6use std::sync::LazyLock;7use std::{collections::HashMap, path::PathBuf};89use anyhow::{Context, anyhow, bail};10use serde::Serialize;11use serde::de::DeserializeOwned;1213pub use anyhow::Result;14use tracing::instrument;1516use self::logging::nix_logging_cxx;17use self::nix_cxx::set_fetcher_setting;18use self::nix_raw::{19 alloc_value, c_context, c_context_create, err_code, err_info_msg, eval_state_build,20 eval_state_builder_new, expr_eval_from_string, fetchers_settings, fetchers_settings_free,21 fetchers_settings_new, flake_lock, flake_lock_flags, flake_lock_flags_free,22 flake_lock_flags_new, flake_lock_flags_set_mode_virtual, flake_reference_parse_flags,23 flake_reference_parse_flags_free, flake_reference_parse_flags_new,24 flake_reference_parse_flags_set_base_directory, flake_settings, flake_settings_free,25 flake_settings_new, init_bool, init_int, init_string, locked_flake_free,26 locked_flake_get_output_attrs, set_err_msg, setting_set, state_free, value_decref,27 value_incref,28};293031pub mod logging;32#[doc(hidden)]33pub mod macros;34pub mod util;3536#[allow(37 non_upper_case_globals,38 non_camel_case_types,39 non_snake_case,40 dead_code41)]42mod nix_raw {43 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));44}45#[cxx::bridge]46pub mod nix_cxx {47 unsafe extern "C++" {48 type nix_fetchers_settings;49 include!("nix-eval/src/lib.hh");5051 unsafe fn set_fetcher_setting(52 settings: *mut nix_fetchers_settings,53 setting: *const c_char,54 value: *const c_char,55 );56 }57}5859#[derive(Debug, PartialEq, Eq)]60pub enum NixType {61 Thunk,62 Int,63 Float,64 Bool,65 String,66 Path,67 Null,68 Attrs,69 List,70 Function,71 External,72}73impl NixType {74 fn from_int(c: c_uint) -> Self {75 match c {76 0 => Self::Thunk,77 1 => Self::Int,78 2 => Self::Float,79 3 => Self::Bool,80 4 => Self::String,81 5 => Self::Path,82 6 => Self::Null,83 7 => Self::Attrs,84 8 => Self::List,85 9 => Self::Function,86 10 => Self::External,87 _ => unreachable!("unknown nix type: {c}"),88 }89 }90}9192enum FunctorKind {93 Function,94 Functor,95}9697#[derive(Debug)]98#[repr(i32)]99pub enum NixErrorKind {100 Unknown = 1,101 Overflow = 2,102 Key = 3,103 Generic = 4,104}105impl NixErrorKind {106 fn from_int(v: c_int) -> Option<Self> {107 Some(match v {108 0 => return None,109 -1 => Self::Unknown,110 -2 => Self::Overflow,111 -3 => Self::Key,112 -4 => Self::Generic,113 _ => {114 debug_assert!(false, "unexpected nix error kind: {v}");115 Self::Unknown116 }117 })118 }119}120121pub fn gc_register_my_thread() {122 assert_eq!(unsafe { nix_raw::GC_thread_is_registered() }, 0);123124 let mut sb = nix_raw::GC_stack_base {125 mem_base: null_mut(),126 };127 let r = unsafe { nix_raw::GC_get_stack_base(&mut sb) };128 if r as u32 != nix_raw::GC_SUCCESS {129 panic!("failed to get thread stack base");130 }131 unsafe { nix_raw::GC_register_my_thread(&sb) };132}133pub fn gc_unregister_my_thread() {134 assert_eq!(unsafe { nix_raw::GC_thread_is_registered() }, 1);135136 unsafe { nix_raw::GC_unregister_my_thread() };137}138139pub struct ThreadRegisterGuard {}140impl ThreadRegisterGuard {141 #[allow(clippy::new_without_default)]142 pub fn new() -> Self {143 gc_register_my_thread();144 Self {}145 }146}147impl Drop for ThreadRegisterGuard {148 fn drop(&mut self) {149 gc_unregister_my_thread();150 }151}152153pub struct NixContext(*mut c_context);154impl NixContext {155 pub fn set_err(&mut self, err: NixErrorKind, msg: &CStr) {156 unsafe { set_err_msg(self.0, err as c_int, msg.as_ptr()) };157 }158 pub fn new() -> Self {159 let ctx = unsafe { c_context_create() };160 Self(ctx)161 }162 fn error_kind(&self) -> Option<NixErrorKind> {163 let code = unsafe { err_code(self.0) };164 NixErrorKind::from_int(code)165 }166 fn error<'t>(&self) -> Option<Cow<'t, str>> {167 if let NixErrorKind::Generic = self.error_kind()? {168 let mut err_out = String::new();169 unsafe {170 err_info_msg(171 null_mut(),172 self.0,173 Some(copy_nix_str),174 (&raw mut err_out).cast(),175 )176 };177 return Some(Cow::Owned(err_out));178 };179180 181 182 let str = unsafe { nix_raw::err_msg(null_mut(), self.0, null_mut()) };183 Some(unsafe { CStr::from_ptr(str) }.to_string_lossy())184 }185 fn clean_err(&mut self) {186 unsafe {187 nix_raw::clear_err(self.0);188 }189 }190191 fn bail_if_error(&self) -> Result<()> {192 if let Some(err) = self.error() {193 bail!("{err}");194 };195 Ok(())196 }197198 fn run_in_context<T>(&mut self, f: impl FnOnce(*mut c_context) -> T) -> Result<T> {199 self.clean_err();200 let o = f(self.0);201 self.bail_if_error()?;202 self.clean_err();203 Ok(o)204 }205}206207impl Default for NixContext {208 fn default() -> Self {209 Self::new()210 }211}212impl Drop for NixContext {213 fn drop(&mut self) {214 unsafe {215 nix_raw::c_context_free(self.0);216 }217 }218}219struct GlobalState {220 221 #[allow(dead_code)]222 store: Store,223 state: EvalState,224}225impl GlobalState {226 fn new() -> Result<Self> {227 let mut ctx = NixContext::new();228 let store = ctx229 .run_in_context(|c| unsafe { nix_raw::store_open(c, c"daemon".as_ptr(), null_mut()) })230 .map(Store)?;231232 let builder = ctx.run_in_context(|c| unsafe { eval_state_builder_new(c, store.0) })?;233 ctx.run_in_context(|c| {234 unsafe {235 nix_raw::eval_state_builder_set_eval_setting(236 c,237 builder,238 c"lazy-trees".as_ptr(),239 c"true".as_ptr(),240 )241 }242 243 })?;244 ctx.run_in_context(|c| {245 unsafe {246 nix_raw::eval_state_builder_set_eval_setting(247 c,248 builder,249 c"lazy-locks".as_ptr(),250 c"true".as_ptr(),251 )252 }253 254 })?;255 let state = ctx256 .run_in_context(|c| unsafe { eval_state_build(c, builder) })257 .map(EvalState)?;258259 Ok(Self { store, state })260 }261}262263struct ThreadState {264 ctx: NixContext,265}266impl ThreadState {267 fn new() -> Result<Self> {268 let ctx = NixContext::new();269270 Ok(Self { ctx })271 }272}273274static GLOBAL_STATE: LazyLock<GlobalState> =275 LazyLock::new(|| GlobalState::new().expect("global state init shouldn't fail"));276277thread_local! {278 static THREAD_STATE: RefCell<ThreadState> = RefCell::new(ThreadState::new().expect("thread state init shouldn't fail"));279}280fn with_default_context<T>(281 f: impl FnOnce(*mut c_context, *mut nix_raw::EvalState) -> T,282) -> Result<T> {283 let global = &GLOBAL_STATE.state;284 let (ctx, state) = THREAD_STATE.with_borrow_mut(|w| (w.ctx.0, global.0));285 let mut ctx = NixContext(ctx);286 let v = ctx.run_in_context(|c| f(c, state));287 288 std::mem::forget(ctx);289 v290}291292pub fn set_setting(s: &CStr, v: &CStr) -> Result<()> {293 with_default_context(|c, _| unsafe { setting_set(c, s.as_ptr(), v.as_ptr()) }).map(|_| ())294}295296pub struct FetchSettings(*mut fetchers_settings);297impl FetchSettings {298 pub fn new() -> Self {299 Self::try_new().expect("allocation should not fail")300 }301 fn try_new() -> Result<Self> {302 with_default_context(|c, _| unsafe { fetchers_settings_new(c) }).map(Self)303 }304 pub fn set(&mut self, setting: &CStr, value: &CStr) {305 unsafe {306 set_fetcher_setting(self.0.cast(), setting.as_ptr(), value.as_ptr());307 };308 }309}310unsafe impl Send for FetchSettings {}311unsafe impl Sync for FetchSettings {}312313impl Default for FetchSettings {314 fn default() -> Self {315 Self::new()316 }317}318319impl Drop for FetchSettings {320 fn drop(&mut self) {321 unsafe { fetchers_settings_free(self.0) };322 }323}324pub struct FlakeSettings(*mut flake_settings);325impl FlakeSettings {326 pub fn new() -> Result<Self> {327 with_default_context(|c, _| unsafe { flake_settings_new(c) }).map(Self)328 }329}330unsafe impl Send for FlakeSettings {}331unsafe impl Sync for FlakeSettings {}332impl Drop for FlakeSettings {333 fn drop(&mut self) {334 unsafe {335 flake_settings_free(self.0);336 }337 }338}339340pub struct FlakeReferenceParseFlags(*mut flake_reference_parse_flags);341impl FlakeReferenceParseFlags {342 pub fn new(settings: &FlakeSettings) -> Result<Self> {343 with_default_context(|c, _| unsafe { flake_reference_parse_flags_new(c, settings.0) })344 .map(Self)345 }346 pub fn set_base_dir(&mut self, dir: &str) -> Result<()> {347 with_default_context(|c, _| {348 unsafe {349 flake_reference_parse_flags_set_base_directory(350 c,351 self.0,352 dir.as_ptr().cast(),353 dir.len(),354 )355 };356 })357 }358}359impl Drop for FlakeReferenceParseFlags {360 fn drop(&mut self) {361 unsafe {362 flake_reference_parse_flags_free(self.0);363 }364 }365}366struct FlakeLockFlags(*mut flake_lock_flags);367impl FlakeLockFlags {368 fn new(settings: &mut FlakeSettings) -> Result<Self> {369 let o = with_default_context(|c, _| unsafe { flake_lock_flags_new(c, settings.0) })370 .map(Self)?;371 with_default_context(|c, _| unsafe { flake_lock_flags_set_mode_virtual(c, o.0) })?;372373 Ok(o)374 }375}376impl Drop for FlakeLockFlags {377 fn drop(&mut self) {378 unsafe {379 flake_lock_flags_free(self.0);380 }381 }382}383384unsafe extern "C" fn copy_nix_str(start: *const c_char, n: c_uint, user_data: *mut c_void) {385 let s = unsafe { std::slice::from_raw_parts(start.cast::<u8>(), n as usize) };386 let s = std::str::from_utf8(s).expect("c string has invalid utf-8");387 unsafe { *user_data.cast::<String>() = s.to_owned() };388}389390struct Store(*mut nix_raw::Store);391unsafe impl Send for Store {}392unsafe impl Sync for Store {}393394struct EvalState(*mut nix_raw::EvalState);395unsafe impl Send for EvalState {}396unsafe impl Sync for EvalState {}397398impl Drop for EvalState {399 fn drop(&mut self) {400 unsafe {401 state_free(self.0);402 }403 }404}405406pub struct FlakeReference(*mut nix_raw::flake_reference);407impl FlakeReference {408 #[instrument(name = "new-flake-reference", skip(flake, parse, fetch))]409 pub fn new(410 s: &str,411 flake: &FlakeSettings,412 parse: &FlakeReferenceParseFlags,413 fetch: &FetchSettings,414 ) -> Result<(Self, String)> {415 let mut out = null_mut();416 let mut fragment = String::new();417 418 with_default_context(|c, _| unsafe {419 nix_raw::flake_reference_and_fragment_from_string(420 c,421 fetch.0,422 flake.0,423 parse.0,424 s.as_ptr().cast(),425 s.len(),426 &mut out,427 Some(copy_nix_str),428 (&raw mut fragment).cast(),429 )430 })?;431 assert!(!out.is_null());432433 Ok((Self(out), fragment))434 }435 #[instrument(name = "lock-flake", skip(self, fetch))]436 pub fn lock(&mut self, fetch: &FetchSettings) -> Result<LockedFlake> {437 let mut settings = FlakeSettings::new()?;438 let lock_flags = FlakeLockFlags::new(&mut settings)?;439 with_default_context(|c, es| unsafe {440 flake_lock(c, fetch.0, settings.0, es, lock_flags.0, self.0)441 })442 .map(LockedFlake)443 }444}445unsafe impl Send for FlakeReference {}446unsafe impl Sync for FlakeReference {}447448pub struct LockedFlake(*mut nix_raw::locked_flake);449impl LockedFlake {450 pub fn get_attrs(&self, settings: &mut FlakeSettings) -> Result<Value> {451 with_default_context(|c, es| unsafe {452 locked_flake_get_output_attrs(c, settings.0, es, self.0)453 })454 .map(Value)455 }456}457unsafe impl Send for LockedFlake {}458unsafe impl Sync for LockedFlake {}459impl Drop for LockedFlake {460 fn drop(&mut self) {461 unsafe {462 locked_flake_free(self.0);463 };464 }465}466467type FieldName = [u8; 32];468fn init_field_name(v: &str) -> FieldName {469 let mut f = [0; 32];470 assert!(v.len() < 32, "max field name is 31 char");471 assert!(472 v.bytes().all(|v| v != 0),473 "nul bytes are unsupported in field name"474 );475 f[0..v.len()].copy_from_slice(v.as_bytes());476 f477}478479pub struct RealisedString(*mut nix_raw::realised_string);480impl fmt::Debug for RealisedString {481 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {482 self.as_str().fmt(f)483 }484}485486impl RealisedString {487 pub fn as_str(&self) -> &str {488 let len = unsafe { nix_raw::realised_string_get_buffer_size(self.0) };489 let data: *const u8 = unsafe { nix_raw::realised_string_get_buffer_start(self.0) }.cast();490 let data = unsafe { std::slice::from_raw_parts(data, len) };491 std::str::from_utf8(data).expect("non-utf8 strings not supported")492 }493 pub fn path_count(&self) -> usize {494 unsafe { nix_raw::realised_string_get_store_path_count(self.0) }495 }496 pub fn path(&self, i: usize) -> String {497 assert!(i < self.path_count());498 let path = unsafe { nix_raw::realised_string_get_store_path(self.0, i) };499 let mut err_out = String::new();500 unsafe { nix_raw::store_path_name(path, Some(copy_nix_str), (&raw mut err_out).cast()) };501 err_out502 }503}504505unsafe impl Send for RealisedString {}506impl Drop for RealisedString {507 fn drop(&mut self) {508 unsafe { nix_raw::realised_string_free(self.0) }509 }510}511512pub struct Value(*mut nix_raw::value);513514unsafe impl Send for Value {}515unsafe impl Sync for Value {}516517pub trait AsFieldName {518 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T>;519 fn to_field_name(&self) -> Result<String>;520}521impl AsFieldName for Value {522 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {523 let f = self.to_string()?;524 v(init_field_name(&f))525 }526 fn to_field_name(&self) -> Result<String> {527 self.to_string()528 }529}530impl<E> AsFieldName for E531where532 E: AsRef<str>,533{534 fn as_field_name<T>(&self, v: impl FnOnce(FieldName) -> Result<T>) -> Result<T> {535 let f = self.as_ref();536 v(init_field_name(f))537 }538 fn to_field_name(&self) -> Result<String> {539 Ok(self.as_ref().to_owned())540 }541}542543struct AttrsBuilder(*mut nix_raw::BindingsBuilder);544impl AttrsBuilder {545 fn new(capacity: usize) -> Self {546 with_default_context(|c, es| unsafe { nix_raw::make_bindings_builder(c, es, capacity) })547 .map(Self)548 .expect("alloc should not fail")549 }550 fn insert(&mut self, k: &impl AsFieldName, v: Value) {551 k.as_field_name(|name| {552 with_default_context(|c, _| unsafe {553 nix_raw::bindings_builder_insert(c, self.0, name.as_ptr().cast(), v.0)554 })555 })556 .expect("builder insert shouldn't fail");557 }558}559impl Drop for AttrsBuilder {560 fn drop(&mut self) {561 unsafe { nix_raw::bindings_builder_free(self.0) };562 }563}564565impl Value {566 pub fn new_attrs(v: HashMap<&str, Value>) -> Self {567 let out = Self::new_uninit();568 let mut b = AttrsBuilder::new(v.len());569 for (k, v) in v {570 b.insert(&k, v);571 }572 with_default_context(|c, _| unsafe { nix_raw::make_attrs(c, out.0, b.0) })573 .expect("attrs initialization should not fail");574 out575 }576 fn new_list<T: Into<Self>>(v: Vec<T>) -> Self {577 todo!()578 }579 fn new_uninit() -> Self {580 let out = with_default_context(|c, es| unsafe { alloc_value(c, es) })581 .expect("value allocation should not fail");582 Self(out)583 }584 pub fn new_str(v: &str) -> Self {585 let s = CString::new(v).expect("string should not contain NULs");586 let out = Self::new_uninit();587 588 with_default_context(|c, _| unsafe { init_string(c, out.0, s.as_ptr()) })589 .expect("string initialization should not fail");590 out591 }592 pub fn new_int(i: i64) -> Self {593 let out = Self::new_uninit();594 with_default_context(|c, _| unsafe { init_int(c, out.0, i) })595 .expect("int initialization should not fail");596 out597 }598 pub fn new_bool(v: bool) -> Self {599 let out = Self::new_uninit();600 with_default_context(|c, _| unsafe { init_bool(c, out.0, v) })601 .expect("bool initialization should not fail");602 out603 }604 605 606 607 608 609 pub fn type_of(&self) -> NixType {610 let ty = with_default_context(|c, _| unsafe { nix_raw::get_type(c, self.0) })611 .expect("get_type should not fail");612 NixType::from_int(ty)613 }614 pub fn to_string(&self) -> Result<String> {615 Ok(self.to_realised_string()?.as_str().to_owned())616 }617 pub fn to_realised_string(&self) -> Result<RealisedString> {618 with_default_context(|c, es| unsafe { nix_raw::string_realise(c, es, self.0, false) })619 .map(RealisedString)620621 622 623 624 625 626 627 628 }629630 pub fn has_field(&self, field: &str) -> Result<bool> {631 let f = init_field_name(field);632 with_default_context(|c, es| unsafe {633 nix_raw::has_attr_byname(c, self.0, es, f.as_ptr().cast())634 })635 }636 637 638 639 pub fn list_fields(&self) -> Result<Vec<String>> {640 if !matches!(self.type_of(), NixType::Attrs) {641 bail!("invalid type: expected attrs");642 }643644 let len = with_default_context(|c, _| unsafe { nix_raw::get_attrs_size(c, self.0) })?;645 let mut out = Vec::with_capacity(len as usize);646647 for i in 0..len {648 let name = with_default_context(|c, es| unsafe {649 nix_raw::get_attr_name_byidx(c, self.0, es, i)650 })?;651 let c = unsafe { CStr::from_ptr(name) };652 out.push(c.to_str().expect("nix field names are utf-8").to_owned());653 }654 Ok(out)655 }656 pub fn get_elem(&self, v: usize) -> Result<Self> {657 if !matches!(self.type_of(), NixType::List) {658 bail!("invalid type: expected list");659 }660 let len =661 with_default_context(|c, _| unsafe { nix_raw::get_list_size(c, self.0) })? as usize;662 if v >= len {663 bail!("oob list get: {v} >= {len}");664 }665666 with_default_context(|c, es| unsafe { nix_raw::get_list_byidx(c, self.0, es, v as u32) })667 .map(Self)668 }669 pub fn attrs_update(self, other: Value) -> Result<Self> {670 let a_fields = self.list_fields()?;671 let b_fields = other.list_fields()?;672 match (a_fields.len(), b_fields.len()) {673 (_, 0) => return Ok(self),674 (0, _) => return Ok(other),675 _ => {}676 }677 let mut out = HashMap::new();678 for f in a_fields.iter() {679 if b_fields.contains(f) {680 break;681 }682 out.insert(f.as_str(), self.get_field(f)?);683 }684 if out.is_empty() {685 686 return Ok(other);687 }688 for f in b_fields.iter() {689 out.insert(f.as_str(), other.get_field(f)?);690 }691 Ok(Self::new_attrs(out))692 }693 pub fn get_field(&self, name: impl AsFieldName) -> Result<Self> {694 if !matches!(self.type_of(), NixType::Attrs) {695 bail!("invalid type: expected attrs");696 }697698 name.as_field_name(|name| {699 with_default_context(|c, es| unsafe {700 nix_raw::get_attr_byname(c, self.0, es, name.as_ptr().cast())701 })702 .map(Self)703 })704 .with_context(|| format!("getting field {:?}", name.to_field_name()))705 }706 pub fn call(&self, v: Value) -> Result<Self> {707 let kind = self708 .functor_kind()709 .ok_or_else(|| anyhow!("can only call function or functor"))?;710711 let function = match kind {712 FunctorKind::Function => self.clone(),713 FunctorKind::Functor => {714 let f = self.get_field("__functor")?;715 assert_eq!(716 f.type_of(),717 NixType::Function,718 "invalid functor encountered"719 );720 f721 }722 };723724 let out = Value::new_uninit();725 with_default_context(|c, es| unsafe {726 nix_raw::value_call(c, es, function.0, v.0, out.0)727 })?;728729 Ok(out)730 }731 pub fn eval(v: &str) -> Result<Self> {732 let s = CString::new(v).expect("expression shouldn't have internal NULs");733 let out = Self::new_uninit();734 with_default_context(|c, es| unsafe {735 expr_eval_from_string(c, es, s.as_ptr(), c"/homeless-shelter".as_ptr(), out.0)736 })?;737 Ok(out)738 }739 pub async fn build(&self, output: &str) -> Result<PathBuf> {740 if !self.is_derivation() {741 bail!("expected derivation to build")742 }743 let output_name = self.get_field("outputName")?.to_string()?;744 let v = if output_name != output {745 let out = self.get_field(output)?;746 if !out.is_derivation() {747 bail!("unknown output: {output}");748 }749 out750 } else {751 self.clone()752 };753 754 let drv_path = tokio::task::spawn_blocking(move || v.get_field("outPath")?.to_string())755 .await756 .expect("should not fail")?;757 Ok(PathBuf::from(drv_path))758 }759 pub fn as_json<T: DeserializeOwned>(&self) -> Result<T> {760 let to_json = Self::eval("builtins.toJSON")?;761 let s = to_json.call(self.clone())?.to_string()?;762 Ok(serde_json::from_str(&s)?)763 }764 pub fn serialized<T: Serialize>(v: &T) -> Result<Self> {765 Self::eval(&nixlike::serialize(v)?)766 }767768 769 770 771 772 773774 fn is_derivation(&self) -> bool {775 if !matches!(self.type_of(), NixType::Attrs) {776 return false;777 }778 let Some(ty) = self.get_field("type").ok() else {779 return false;780 };781 matches!(ty.to_string().as_deref(), Ok("derivation"))782 }783 fn functor_kind(&self) -> Option<FunctorKind> {784 match self.type_of() {785 NixType::Attrs => self786 .has_field("__functor")787 .expect("has_field shouldn't fail for attrs")788 .then_some(FunctorKind::Functor),789 NixType::Function => Some(FunctorKind::Function),790 _ => None,791 }792 }793 pub fn is_function(&self) -> bool {794 self.functor_kind().is_some()795 }796}797798impl From<String> for Value {799 fn from(value: String) -> Self {800 Value::new_str(&value)801 }802}803impl From<bool> for Value {804 fn from(value: bool) -> Self {805 Value::new_bool(value)806 }807}808impl From<&str> for Value {809 fn from(value: &str) -> Self {810 Value::new_str(value)811 }812}813impl<T> From<Vec<T>> for Value814where815 T: Into<Value>,816{817 fn from(value: Vec<T>) -> Self {818 Value::new_list(value)819 }820}821822impl Clone for Value {823 fn clone(&self) -> Self {824 with_default_context(|c, _| unsafe { value_incref(c, self.0) })825 .expect("value incref should not fail");826 Self(self.0)827 }828}829impl Drop for Value {830 fn drop(&mut self) {831 with_default_context(|c, _| unsafe { value_decref(c, self.0) })832 .expect("value drop should not fail");833 }834}835836pub fn init_libraries() {837 unsafe { nix_raw::GC_allow_register_threads() };838839 let mut ctx = NixContext::new();840 ctx.run_in_context(|c| unsafe { nix_raw::libutil_init(c) })841 .expect("util init should not fail");842 ctx.run_in_context(|c| unsafe { nix_raw::libstore_init(c) })843 .expect("store init should not fail");844 ctx.run_in_context(|c| unsafe { nix_raw::libexpr_init(c) })845 .expect("expr init should not fail");846847 nix_logging_cxx::apply_tracing_logger();848}849850#[test_log::test]851fn test_native() -> Result<()> {852 init_libraries();853854 let mut fetch_settings = FetchSettings::new();855 fetch_settings.set(c"warn-dirty", c"false");856857 let manifest = format!("{}/../../", env!("CARGO_MANIFEST_DIR"));858 let (mut r, _) = FlakeReference::new(&manifest, &fetch_settings)?;859 let locked = r.lock(&fetch_settings)?;860 let attrs = locked.get_attrs(&mut FlakeSettings::new()?)?;861862 let builtins = Value::eval("builtins")?;863 assert_eq!(builtins.type_of(), NixType::Attrs);864865 assert_eq!(attrs.type_of(), NixType::Attrs);866 let test_data = nix_go!(attrs.testData);867868 let test_string: String = nix_go_json!(test_data.testString);869 assert_eq!(test_string, "hello");870871 Ok(())872}