git.delta.rocks / jrsonnet / refs/commits / d70668683ed2

2222
23use crate::{23use crate::{
24	fleetdata::FleetData,24	fleetdata::FleetData,
25	host::{Config, ConfigHost, FleetConfigInternals},25	host::{Config, ConfigHost, FleetConfigInternals}, primops::init_primops,
26};26};
2727
28#[derive(Clone)]28#[derive(Clone)]
213			std::fs::read_to_string(&fleet_data_path).context("reading fleet state (fleet.nix)")?;213			std::fs::read_to_string(&fleet_data_path).context("reading fleet state (fleet.nix)")?;
214		let data = Arc::new(Mutex::new(FleetData::from_str(&bytes)?));214		let data = Arc::new(Mutex::new(FleetData::from_str(&bytes)?));
215
216		init_primops(data.clone());
215217
216		let mut fetch_settings = FetchSettings::new();218		let mut fetch_settings = FetchSettings::new();
217		fetch_settings.set(c"warn-dirty", c"false");219		fetch_settings.set(c"warn-dirty", c"false");

2use std::sync::{Arc, Mutex};2use std::sync::{Arc, Mutex};
33
4use nix_eval::{NativeFn, Value};4use nix_eval::{NativeFn, Value};
5use tracing::info;
56
6use crate::fleetdata::{FleetData, FleetSecrets};7use crate::fleetdata::{FleetData, FleetSecrets};
78
23struct FsSecretsBackend {}24struct FsSecretsBackend {}
2425
25pub fn init_primops(secrets: Arc<Mutex<FleetData>>) {26pub fn init_primops(secrets: Arc<Mutex<FleetData>>) {
26	NativeFn::new(
27		c"fleet_ensure_host_secret",
28		c"Ensure secret existence for a host, regenerating it in case of some mismatch",
29		[c"host", c"secret", c"generator"],
30		|[host, secret, generator]| {
31			todo!("ensure secret");27	info!("initializing primops");
32			Ok(Value::new_attrs(HashMap::from_iter([(
33				"raw",
34				Value::new_str("rawData"),
35			)])))
36		},
37	)
38	.register();
39	NativeFn::new(28	NativeFn::new(
40		c"fleet_ensure_host_secret",29		c"__fleetEnsureHostSecret",
41		c"Ensure secret existence for a host, regenerating it in case of some mismatch",30		c"Ensure secret existence for a host, regenerating it in case of some mismatch",
42		[c"host", c"secret", c"generator"],31		[c"host", c"secret", c"generator"],
43		|[host, secret, generator]| {32		|[host, secret, generator]| {

966		let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();966		let mut args = args.into_iter().map(|v| v.as_ptr()).collect_vec();
967		args.push(null());967		args.push(null());
968		let args = args.as_mut_ptr();968		let args = args.as_mut_ptr();
969		let primop = with_default_context(|c, _| unsafe {969		let primop = unsafe {
970			alloc_primop(970			alloc_primop(
971				c,971				null_mut(),
972				f,972				f,
973				N as i32,973				N as i32,
974				name.as_ptr(),974				name.as_ptr(),
975				args,975				args,
976				doc.as_ptr(),976				doc.as_ptr(),
977				Box::into_raw(closure).cast(),977				Box::into_raw(closure).cast(),
978			)978			)
979		})979		};
980		.expect("primop allocation should not fail");980
981		assert!(!primop.is_null(), "primop allocation should not fail");
981982
982		Self(primop)983		Self(primop)
983	}984	}
984	pub fn register(self) {985	pub fn register(self) {
985		with_default_context(|c, _| unsafe { register_primop(c, self.0) })986		unsafe { register_primop(null_mut(), self.0) };
986			.expect("primop registration should not fail");
987	}987	}
988}988}
989989
999#[test_log::test]999#[test_log::test]
1000fn test_native() -> Result<()> {1000fn test_native() -> Result<()> {
1001	init_libraries();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();
10021013
1003	let mut fetch_settings = FetchSettings::new();1014	let mut fetch_settings = FetchSettings::new();
1004	fetch_settings.set(c"warn-dirty", c"false");1015	fetch_settings.set(c"warn-dirty", c"false");
10361047
1037	let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));1048	let test_result: String = nix_go_json!(test_data.testPrimop(uppercase_suffix));
1038	assert_eq!(test_result, "PREFIX_BODY_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");
10391052
1040	let nix_ctx = NixContext::new();1053	let nix_ctx = NixContext::new();
1041	let store = GLOBAL_STATE.store.parse_path(s.as_c_str())?;1054	let store = GLOBAL_STATE.store.parse_path(s.as_c_str())?;

47		nix_expr_inner!(@field(out) $($tt)*);47		nix_expr_inner!(@field(out) $($tt)*);
48		out48		out
49	}};49	}};
50	($v:literal) => {{
51		use $crate::macros::NixExprBuilder;
52		NixExprBuilder::string($v)
53	}};
54	({$v:expr}) => {{50	($v:expr) => {{
55		$crate::Value::serialized(&$v)?51		$crate::Value::serialized(&$v)?
56	}}52	}}
57}53}

103        };103        };
104      };104      };
105      config = {105      config = {
106        parts = builtins.fleet_ensure_host_secret sysConfig.networking.hostName secretName config.generator;106        parts = builtins.fleetEnsureHostSecret sysConfig.networking.hostName secretName config.generator;
107      };107      };
108    }108    }
109  );109  );