wip

Author: m-hilgendorf

packages/std/packages/std/manifest.rs

@@ -1,12 +1,14 @@
 use std::{
 	collections::BTreeMap,
-	io::{Read, Seek},
-	path::Path,
+	io::{Read, Seek, Write},
+	path::{Path, PathBuf},
 	str::FromStr as _,
 	sync::LazyLock,
 };
 use tangram_client as tg;
 
+use crate::CLOSEST_ARTIFACT_PATH;
+
 /// The magic number used to indicate an executable has a manifest.
 pub const MAGIC_NUMBER: &[u8] = b"tangram\0";
 
@@ -300,49 +302,70 @@ impl Manifest {
 			.as_ref()
 			.ok_or_else(|| tg::error!("expected a wrap binary"))?;
 
+		tg::cache::cache(tg, tg::cache::Arg {
+			artifacts: vec![file.id().into(), stub.id().into(), wrap.id().into()]
+		})
+		.await
+		.map_err(|source| tg::error!(!source, "failed to cache artifacts"))?;
+
+		// Get their paths on disk.
+		let path: PathBuf = CLOSEST_ARTIFACT_PATH.clone().into();
+		let file = path.join(file.id().to_string());
+		let stub = path.join(stub.id().to_string());
+		let wrap = path.join(wrap.id().to_string());
+		
+		// Create a temp file for the manifest.
+		let mut manifest = tempfile::NamedTempFile::new().map_err(|source| tg::error!(!source, "failed to get temp file"))?;
+		let output = "/tmp/__wrap_output__";
+
 		// Create the manifest file. TODO: asyncify.
-		let contents = tangram_serialize::to_vec(self)
+		let contents = serde_json::to_vec(self)
 			.map_err(|source| tg::error!(!source, "failed to serialize manifest"))?;
-		let contents = std::io::Cursor::new(contents);
-		let blob = tg::Blob::with_reader(tg, contents)
-			.await
-			.map_err(|source| tg::error!(!source, "failed to create blob"))?;
-		let manifest = tg::File::with_contents(blob);
-		manifest
-			.store(tg)
-			.await
-			.map_err(|source| tg::error!(!source, "failed to store manifest file"))?;
-
-		let host = std::env::var("TANGRAM_HOST").map_err(|_| tg::error!("expected TANGRAM_HOST to be set"))?;
-
-		// Run the build.
-		let output = tg::build::build(
-			tg,
-			tg::build::Arg {
-				executable: Some(tg::command::Executable::Artifact(
-					tg::command::ArtifactExecutable {
-						artifact: wrap.clone().into(),
-						path: None,
-					},
-				)),
-				args: vec![
-					tg::Template::with_components(vec![file.clone().into()]).into(),
-					tg::Template::with_components(vec![manifest.into()]).into(),
-					tg::Template::with_components(vec![stub.clone().into()]).into(),
-				],
-				host: Some(host),
-				..tg::build::Arg::default()
-			},
-		)
-		.await
-		.map_err(|source| tg::error!(!source, "failed to embed wrapper"))
-		.inspect_err(|error| eprintln!("{error:#?}"))?
-		.try_unwrap_object()
-		.map_err(|_| tg::error!("expected an object"))?
-		.try_unwrap_file()
-		.map_err(|_| tg::error!("expected a file"))?;
-
-		Ok(output)
+		manifest.as_file_mut().write_all(&contents).map_err(|source| tg::error!(!source, "failed to write manifest"))?;
+
+		// Run the command.
+		let success = std::process::Command::new(wrap)
+			.arg(file)
+			.arg(manifest.path())
+			.arg(stub)
+			.arg(output)
+			.stdout(std::process::Stdio::inherit())
+			.stderr(std::process::Stdio::inherit())
+			.output()
+			.map_err(|source| tg::error!(!source, "failed to wrap the binary"))?
+			.status
+			.success();
+		if !success {
+			return Err(tg::error!("failed to run the command"));
+		}
+
+		let bytes = std::fs::read(output).map_err(|source| tg::error!(!source, "failed to read the output"))?;
+		let cursor = std::io::Cursor::new(bytes);
+		let blob = tg::Blob::with_reader(tg, cursor).await.map_err(|source| tg::error!(!source, "failed to create blob"))?;
+
+		// Obtain the dependencies from the manifest to add to the file.
+		// NOTE: We know the wrapper file has no dependencies, so there is no need to merge.
+		let dependencies = self.dependencies();
+		let dependencies = if dependencies.is_empty() {
+			None
+		} else {
+			Some(dependencies)
+		};
+
+		// Create a file with the new blob and references.
+		let mut output_file = tg::File::builder(blob).executable(true);
+		if let Some(dependencies) = dependencies {
+			output_file = output_file.dependencies(dependencies);
+		}
+		let output_file = output_file.build();
+
+		#[cfg(feature = "tracing")]
+		{
+			let file_id = output_file.id();
+			tracing::trace!(?file_id, "created wrapper file");
+		}
+
+		Ok(output_file)
 	}
 
 	/// Create a new wrapper from a manifest. Will locate the wrapper file from the `TANGRAM_WRAPPER_ID` environment variable.

packages/std/packages/stub/include/json.h

@@ -513,8 +513,6 @@ static int print_json_string (String* string) {
 static JsonValue* json_get (JsonObject* object, const char* k) {
 	while (object) {
 		if (object->value && cstreq(object->key, k)) {
-			print_json_string(&object->key);
-			trace(" == %s?\n", k);
 			return object->value;
 		}
 		object = object->next;
@@ -532,4 +530,4 @@ static uint64_t json_array_len (JsonArray* array) {
 		len++;
 	}
 	return len;
-}
+}

packages/std/packages/stub/include/manifest.h

@@ -17,6 +17,8 @@ typedef struct {
 	String*	preloads;
 	size_t	argc;
 	String* argv;
+	size_t	interp_argc;
+	String*	interp_argv;
 	Table	env;
 } Manifest;
 

packages/std/packages/stub/include/syscall.h

@@ -12,10 +12,14 @@
 #define MAP_FIXED		0x10
 #define MAP_FIXED_NOREPLACE 	0x100000
 #define MAP_FAILED		(void*)-1
-
 #define RLIMIT_STACK 3
+#define GRND_NONBLOCK 0x01
+
+#define O_RDONLY     00
+#define O_WRONLY     01
+#define O_RDWR	     02
+#define O_CREAT	   0100
 
-#define O_RDONLY 0
 #define SEEK_SET 0
 #define SEEK_CUR 1
 #define SEEK_END 2
@@ -40,8 +44,8 @@ static inline long write (int fd, const void *buf, size_t count) {
 	return syscall3(__NR_write, (long)fd, (long)buf, (long)count);
 }
 
-static inline int open (const char* path, int mode) {
-	return (int)syscall2(__NR_open, (long)path, (long)mode);
+static inline int open (const char* path, int flags, int mode) {
+	return (int)syscall3(__NR_open, (long)path, (long)flags, (long)mode);
 }
 
 static inline int close (int fd) {
@@ -97,6 +101,10 @@ static inline int stat (const char* pathname, stat_t* statbuf) {
 	return (int)syscall2(__NR_stat, (long)pathname, (long)statbuf);
 }
 
-// static inline int execve (const char* pathname, const char** const argv, const char** envp) {
-// 	return (int)syscall3(__NR_execve, (long)pathname, (long)argv, (long)envp);
-// }
+static inline long getrandom (void *buf, size_t buflen, unsigned int flags) {
+	return (long)syscall3(__NR_getrandom, (long)buf, (long)buflen, (long)flags);
+}
+
+static inline int execve (char* pathname, char** const argv, char** envp) {
+	return (int)syscall3(__NR_execve, (long)pathname, (long)argv, (long)envp);
+}

packages/std/packages/stub/include/table.h

@@ -139,6 +139,14 @@ static String lookup (
 	return empty;
 }
 
+static String clookup (
+	Table* table,
+	const char* key
+) {
+	String key_ = STRING_LITERAL(key);
+	return lookup(table, key_);
+}
+
 static void clear (
 	Table* table
 ) {

packages/std/packages/stub/include/util.h

@@ -83,4 +83,79 @@ static bool starts_with (String a, String prefix) {
 		}
 	}
 	return true;
+}
+
+static bool cstarts_with (String a, const char* prefix) {
+	for (size_t n = 0; n < a.len; n++) {
+		if (!prefix[n]) {
+			return false;
+		}
+		if (a.ptr[n] != prefix[n]) {
+			return false;
+		}
+	}
+	return true;
+}
+
+static String join (Arena* arena, String separator, String* strings, size_t nstrings) {
+	size_t len = 0;
+	for (size_t n = 0; n < nstrings; n++) {
+		len += strings[n].len;
+		if (n != (nstrings - 1)) {
+			len += separator.len;
+		}
+	}
+
+	String out = {0};
+	out.ptr = ALLOC_N(arena, len + 1, uint8_t);
+
+	for (size_t n = 0; n < nstrings; n++) {
+		if (strings[n].ptr) {
+			memcpy(out.ptr + out.len, strings[n].ptr, strings[n].len);
+			out.len += strings[n].len;
+			if (separator.ptr && n != (nstrings - 1)) {
+				memcpy(out.ptr + out.len, separator.ptr, separator.len);
+				out.len += separator.len;
+			}
+		}
+	}
+
+	return out;
+}
+
+static void reverse (String* s) {
+	int i = 0;
+	int j = s->len - 1;
+	while (i < j) {
+		char buf = s->ptr[i];
+		s->ptr[i] = s->ptr[j];
+		s->ptr[j] = buf;
+		i++;
+		j--;
+	}
+}
+
+static void double_to_string (Arena* arena, double d, String* s) {
+	s->ptr = ALLOC_N(arena, 64, uint8_t);
+	char sign = d >= 0 ? 0 : '-';
+
+	double mag = d >= 0 ? d : -d;
+	uint64_t whole = (uint64_t)mag;
+	double frac = d - (double)whole;
+	ABORT_IF(frac != 0, "only integer numbers are supported");
+	
+	do {
+		"012345689"[whole % 10];
+		whole /= 10;
+	} while (whole != 0);
+
+	if (sign) {
+		s->ptr[s->len++] = sign;
+	}
+
+	reverse(s);
+}
+
+static String clone_str (Arena* arena, String s) {
+	ABORT("todo");
 }