bencher_fingerprint

Author: epompeii

Cargo.lock

@@ -26,6 +26,7 @@ bencher_adapter = { path = "lib/bencher_adapter" }
 bencher_boundary = { path = "lib/bencher_boundary" }
 bencher_client = { path = "lib/bencher_client" }
 bencher_comment = { path = "lib/bencher_comment" }
+bencher_fingerprint = { path = "lib/bencher_fingerprint" }
 bencher_github = { path = "lib/bencher_github" }
 bencher_json = { path = "lib/bencher_json" }
 bencher_logger = { path = "lib/bencher_logger" }

Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "bencher_fingerprint"
+homepage.workspace = true
+version.workspace = true
+authors.workspace = true
+edition.workspace = true
+license-file.workspace = true
+
+[features]
+client = ["dep:windows"]
+schema = ["dep:schemars"]
+
+[dependencies]
+derive_more.workspace = true
+schemars = { workspace = true, optional = true }
+serde.workspace = true
+thiserror.workspace = true
+typeshare.workspace = true
+uuid = { workspace = true, features = ["serde"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+windows = { version = "0.60", optional = true, features = [
+    "System_Profile_SystemManufacturers",
+] }
+
+[lints]
+workspace = true

lib/bencher_fingerprint/Cargo.toml

@@ -0,0 +1,43 @@
+use std::str::FromStr;
+
+use derive_more::Display;
+#[cfg(feature = "schema")]
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+use uuid::Uuid;
+
+#[cfg(feature = "client")]
+mod target_os;
+
+#[typeshare::typeshare]
+#[derive(Debug, Display, Clone, Copy, Eq, PartialEq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "schema", derive(JsonSchema))]
+pub struct Fingerprint(Uuid);
+
+#[derive(Debug, Clone, thiserror::Error)]
+pub enum FingerprintError {
+    #[error("Failed to parse fingerprint: {0}")]
+    Parse(String),
+}
+
+impl FromStr for Fingerprint {
+    type Err = FingerprintError;
+
+    fn from_str(fingerprint: &str) -> Result<Self, Self::Err> {
+        Ok(Self(fingerprint.parse().map_err(|_e| {
+            FingerprintError::Parse(fingerprint.to_owned())
+        })?))
+    }
+}
+
+impl From<Uuid> for Fingerprint {
+    fn from(uuid: Uuid) -> Self {
+        Self(uuid)
+    }
+}
+
+impl From<Fingerprint> for Uuid {
+    fn from(fingerprint: Fingerprint) -> Self {
+        fingerprint.0
+    }
+}

lib/bencher_fingerprint/src/lib.rs

@@ -0,0 +1,20 @@
+use std::fs;
+
+use uuid::Uuid;
+
+const HEX_BASE: u32 = 16;
+
+impl crate::Fingerprint {
+    pub fn new() -> Option<Self> {
+        parse_machine_id("/var/lib/dbus/machine-id")
+            .or_else(|| parse_machine_id("/etc/machine-id"))
+            .map(Self)
+    }
+}
+
+fn parse_machine_id(path: &str) -> Option<Uuid> {
+    fs::read_to_string(path)
+        .ok()
+        .and_then(|id| u128::from_str_radix(id.trim(), HEX_BASE).ok())
+        .map(Uuid::from_u128)
+}

lib/bencher_fingerprint/src/target_os/linux.rs

@@ -0,0 +1,26 @@
+use std::process::Command;
+
+use uuid::Uuid;
+
+impl crate::Fingerprint {
+    pub fn new() -> Option<Self> {
+        Command::new("ioreg")
+            .arg("-d2")
+            .arg("-c")
+            .arg("IOPlatformExpertDevice")
+            .output()
+            .ok()
+            .and_then(|out| String::from_utf8(out.stdout).ok())
+            .and_then(|output| {
+                for line in output.lines() {
+                    if let Some((_, uuid)) = line.split_once(r#""IOPlatformUUID" = ""#) {
+                        if let Some((uuid, _)) = uuid.split_once('"') {
+                            return Uuid::parse_str(uuid).ok();
+                        }
+                    }
+                }
+                None
+            })
+            .map(Self)
+    }
+}

lib/bencher_fingerprint/src/target_os/macos.rs

@@ -0,0 +1,6 @@
+#[cfg(target_os = "linux")]
+mod linux;
+#[cfg(target_os = "macos")]
+mod macos;
+#[cfg(target_os = "windows")]
+mod windows;

lib/bencher_fingerprint/src/target_os/mod.rs

@@ -0,0 +1,16 @@
+use uuid::Uuid;
+
+impl crate::Fingerprint {
+    pub fn new() -> Option<Self> {
+        windows::System::Profile::SystemManufacturers::SmbiosInformation::SerialNumber()
+            .ok()
+            .as_ref()
+            .and_then(|hstring| {
+                let uuid = hstring.to_string();
+                println!("{uuid}");
+                println!("{}", uuid.trim());
+                Uuid::parse_str(&hstring.to_string().trim()).ok()
+            })
+            .map(Self)
+    }
+}

lib/bencher_fingerprint/src/target_os/windows.rs

@@ -8,14 +8,19 @@ publish = false
 
 [features]
 full = ["bencher_valid/full"]
-lite = ["bencher_valid/lite"]
+lite = ["bencher_fingerprint/client", "bencher_valid/lite"]
 db = ["diesel", "serde_yaml", "bencher_valid/db"]
 plus = ["bencher_valid/plus"]
-schema = ["dep:schemars", "ordered-float/schemars"]
+schema = [
+    "dep:schemars",
+    "ordered-float/schemars",
+    "bencher_fingerprint/schema",
+]
 table = ["dep:tabled"]
 
 [dependencies]
 # Workspace
+bencher_fingerprint.workspace = true
 bencher_valid = { workspace = true, features = ["schema"] }
 chrono = { workspace = true, features = ["serde"] }
 derive_more.workspace = true

lib/bencher_json/Cargo.toml

@@ -1,5 +1,6 @@
 use std::sync::LazyLock;
 
+pub use bencher_fingerprint::Fingerprint;
 pub use bencher_valid::{
     BenchmarkName, Boundary, BranchName, CdfBoundary, DateTime, DateTimeMillis, Email, GitHash,
     Index, IqrBoundary, Jwt, Model, ModelTest, NameId, NameIdKind, NonEmpty, PercentageBoundary,