Initial Dever 0.0.1

test/rust/dependency/go/build_fixture.rs

@@ -0,0 +1,220 @@
+//! 只在测试自己的目录中，用 dev Pod 已安装的绝对路径 Go 工具制作签名 fixture。
+
+use super::*;
+use ring::signature::{Ed25519KeyPair, KeyPair};
+use std::{
+    fs,
+    os::unix::fs::{DirBuilderExt, PermissionsExt},
+    path::{Path, PathBuf},
+    process::Command,
+};
+
+pub struct Fixture {
+    pub root: PathBuf,
+    pub signed: SignedResources,
+    pub files: BTreeMap<String, Vec<u8>>,
+    pub descriptor: serde_json::Value,
+}
+
+pub fn write(root: &Path, path: &str, bytes: impl AsRef<[u8]>) {
+    let path = root.join(path);
+    fs::create_dir_all(path.parent().unwrap()).unwrap();
+    for directory in path
+        .parent()
+        .unwrap()
+        .ancestors()
+        .take_while(|path| path.starts_with(root))
+    {
+        fs::set_permissions(directory, fs::Permissions::from_mode(0o700)).unwrap();
+    }
+    fs::write(&path, bytes).unwrap();
+    fs::set_permissions(path, fs::Permissions::from_mode(0o600)).unwrap();
+}
+
+fn go(root: &Path, arguments: &[&str]) -> String {
+    let result = Command::new("/usr/local/go/bin/go")
+        .args(arguments)
+        .current_dir(root)
+        .env_clear()
+        .env("GOTOOLCHAIN", "local")
+        .env("GOPROXY", "off")
+        .env("GOSUMDB", "off")
+        .env("CGO_ENABLED", "0")
+        .env("GO111MODULE", "off")
+        .env("GOCACHE", root.join("go-cache"))
+        .output()
+        .unwrap();
+    assert!(
+        result.status.success(),
+        "{}",
+        String::from_utf8_lossy(&result.stderr)
+    );
+    String::from_utf8(result.stdout).unwrap()
+}
+
+impl Fixture {
+    pub fn new() -> Self {
+        let root = std::env::temp_dir().join(format!(
+            "dever-go-acceptance-{}-{}",
+            std::process::id(),
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        fs::DirBuilder::new().mode(0o700).create(&root).unwrap();
+        let version = go(&root, &["version"]);
+        let target = BuildTarget::host().unwrap();
+        let arch = if target == BuildTarget::LinuxX86_64 {
+            "amd64"
+        } else {
+            "arm64"
+        };
+        let version_number = version
+            .split_whitespace()
+            .nth(2)
+            .unwrap()
+            .strip_prefix("go")
+            .unwrap();
+        write(&root, "selector.go", include_bytes!("selector.go"));
+        go(
+            &root,
+            &["build", "-trimpath", "-o", "selector", "selector.go"],
+        );
+        let mut files = BTreeMap::new();
+        files.insert(
+            "bin/analyze".into(),
+            fs::read(root.join("selector")).unwrap(),
+        );
+        for tool in ["compile", "link"] {
+            files.insert(
+                format!("bin/{tool}"),
+                fs::read(format!("/usr/local/go/pkg/tool/linux_{arch}/{tool}")).unwrap(),
+            );
+        }
+        let exports = go(
+            &root,
+            &[
+                "list",
+                "-deps",
+                "-export",
+                "-f",
+                "{{if .Export}}{{.ImportPath}}={{.Export}}{{end}}",
+                "bytes",
+                "context",
+                "encoding/binary",
+                "encoding/json",
+                "errors",
+                "fmt",
+                "io",
+                "math",
+                "os",
+                "regexp",
+                "sort",
+                "strconv",
+                "strings",
+                "time",
+                "unicode/utf8",
+                "embed",
+            ],
+        );
+        let mut cfg = String::new();
+        for line in exports.lines().filter(|line| !line.is_empty()) {
+            let (name, source) = line.split_once('=').unwrap();
+            let path = format!("stdlib/{name}.a");
+            cfg.push_str(&format!("packagefile {name}={path}\n"));
+            files.insert(path, fs::read(source).unwrap());
+        }
+        files.insert("stdlib/importcfg".into(), cfg.into_bytes());
+        let descriptor = serde_json::json!({"host":target.name(), "compiler":"bin/compile", "linker":"bin/link", "analyzer":"bin/analyze",
+            "stdlib_importcfg":"stdlib/importcfg", "goos":"linux", "goarch":arch, "go_version":version.trim()});
+        files.insert("dever-runtime.json".into(), serde_json::to_vec(&serde_json::json!({"format":"dever-worker-runtime-v1", "ecosystem":"go", "target":target.name(),
+            "executable":null, "arguments":[], "build":descriptor, "python_markers":null, "python_wheel_tags":[]})).unwrap());
+        let archive = archive(&files);
+        let metadata = serde_json::to_vec(&serde_json::json!({"format":"dever-registry-runtime-v1", "runtime":{"pack":{"name":"go", "version":version_number,
+            "sha256":crate::compiler::project::dependency::digest(&archive)}, "target":target.name(), "python_markers":null, "python_wheel_tags":[]}})).unwrap();
+        let loader = if arch == "amd64" {
+            "ld-linux-x86-64.so.2"
+        } else {
+            "ld-linux-aarch64.so.1"
+        };
+        let loader_source = if arch == "amd64" {
+            "/lib/x86_64-linux-gnu/ld-linux-x86-64.so.2"
+        } else {
+            "/lib/aarch64-linux-gnu/ld-linux-aarch64.so.1"
+        };
+        let artifacts = BTreeMap::from([
+            (
+                format!("runtime/go/{}/runtime.pack", target.name()),
+                archive,
+            ),
+            (
+                format!("runtime/go/{}/manifest.json", target.name()),
+                metadata,
+            ),
+            (
+                format!("process-runtime/{}/lib/{loader}", target.name()),
+                fs::read(loader_source).unwrap(),
+            ),
+            (
+                "sdk/go/component.go".into(),
+                fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("../sdk/go/component.go"))
+                    .unwrap(),
+            ),
+        ]);
+        let signed = sign(&root.join("installation"), &artifacts);
+        Self {
+            root,
+            signed,
+            files,
+            descriptor,
+        }
+    }
+}
+
+pub fn archive(files: &BTreeMap<String, Vec<u8>>) -> Vec<u8> {
+    let gzip = flate2::write::GzEncoder::new(Vec::new(), flate2::Compression::fast());
+    let mut tar = tar::Builder::new(gzip);
+    for (name, bytes) in files {
+        let mut header = tar::Header::new_gnu();
+        header.set_size(bytes.len() as u64);
+        header.set_mode(0o644);
+        header.set_cksum();
+        tar.append_data(&mut header, name, bytes.as_slice())
+            .unwrap();
+    }
+    tar.into_inner().unwrap().finish().unwrap()
+}
+
+pub fn sign(root: &Path, artifacts: &BTreeMap<String, Vec<u8>>) -> SignedResources {
+    let key = Ed25519KeyPair::from_seed_unchecked(&[93; 32]).unwrap();
+    let hex = |bytes: &[u8]| {
+        bytes
+            .iter()
+            .map(|byte| format!("{byte:02x}"))
+            .collect::<String>()
+    };
+    write(
+        root,
+        "state/trusted-release-key",
+        hex(key.public_key().as_ref()),
+    );
+    let entries = artifacts.iter().map(|(path, bytes)| {
+        write(root, &format!("versions/0.0.1/{path}"), bytes);
+        serde_json::json!({"path":path, "bytes":bytes.len(), "sha256":crate::compiler::project::dependency::digest(bytes)})
+    }).collect::<Vec<_>>();
+    let manifest = serde_json::to_vec(&serde_json::json!({"format":"dever-release-v2", "version":"0.0.1", "platform":BuildTarget::host().unwrap().name(), "artifacts":entries, "extensions":[]})).unwrap();
+    write(root, "versions/0.0.1/manifest.json", &manifest);
+    write(
+        root,
+        "versions/0.0.1/manifest.sig",
+        hex(key.sign(&manifest).as_ref()),
+    );
+    SignedResources::load(root, "0.0.1").unwrap()
+}
+
+impl Drop for Fixture {
+    fn drop(&mut self) {
+        fs::remove_dir_all(&self.root).unwrap();
+    }
+}