context

Author: epompeii

lib/bencher_context/src/client/mod.rs

@@ -2,9 +2,10 @@ use std::collections::HashMap;
 
 use gix::Repository;
 
-mod fingerprint;
+mod platform;
 
-pub use fingerprint::Fingerprint;
+pub use platform::Fingerprint;
+use platform::OperatingSystem;
 
 use crate::ReportContext;
 
@@ -15,7 +16,8 @@ impl ReportContext {
         get_context()
     }
 
-    fn insert(&mut self, key: String, value: String) -> Option<String> {
+    fn insert(&mut self, path: &str, value: String) -> Option<String> {
+        let key = format!("bencher.dev{path}");
         self.0.insert(key, value)
     }
 }
@@ -27,62 +29,73 @@ impl From<ReportContext> for HashMap<String, String> {
     }
 }
 
-pub fn find_repo() -> Option<Repository> {
-    let current_dir = std::env::current_dir().ok()?;
-    for directory in current_dir.ancestors() {
-        if let Ok(repo) = gix::open(directory) {
-            return Some(repo);
-        }
-    }
-    None
-}
-
 pub fn get_context() -> ReportContext {
     let mut context = ReportContext::default();
+    git_context(&mut context);
+    platform_context(&mut context);
+    context
+}
+
+fn git_context(context: &mut ReportContext) {
+    let Some(repo) = find_repo() else {
+        return;
+    };
 
-    let repo = find_repo();
-    let repo_name = repo_name(repo.as_ref());
-    if let Some(repo_name) = repo_name {
-        context.insert("bencher.dev/repo/name".to_owned(), repo_name);
+    if let Some(repo_name) = repo_name(&repo) {
+        context.insert("/repo/name", repo_name);
     }
-    if let Some(repo) = &repo {
-        if let Some(root_commit) = find_default_branch_and_root_commit(repo) {
-            context.insert("bencher.dev/repo/hash".to_owned(), root_commit);
-        }
+
+    if let Some(root_commit) = repo_hash(&repo) {
+        context.insert("/repo/hash", root_commit);
     }
 
-    if let Some(repo) = &repo {
-        if let Some((branch_ref, branch_ref_name)) = current_branch_name(repo) {
-            context.insert("bencher.dev/branch/ref".to_owned(), branch_ref);
-            context.insert("bencher.dev/branch/ref/name".to_owned(), branch_ref_name);
-        }
+    if let Some((branch_ref, branch_ref_name)) = branch_ref(&repo) {
+        context.insert("/branch/ref", branch_ref);
+        context.insert("/branch/ref/name", branch_ref_name);
+    }
 
-        if let Some(hash) = current_branch_hash(repo) {
-            context.insert("bencher.dev/branch/hash".to_owned(), hash);
-        }
+    if let Some(hash) = branch_hash(&repo) {
+        context.insert("/branch/hash", hash);
     }
+}
+
+fn platform_context(context: &mut ReportContext) {
+    context.insert("/testbed/os", OperatingSystem::current().to_string());
 
-    let fingerprint = Fingerprint::new();
-    if let Some(fingerprint) = fingerprint {
-        context.insert(
-            "bencher.dev/testbed/fingerprint".to_owned(),
-            fingerprint.to_string(),
-        );
+    if let Some(fingerprint) = Fingerprint::current() {
+        context.insert("/testbed/fingerprint", fingerprint.to_string());
     }
+}
 
-    context
+fn find_repo() -> Option<Repository> {
+    let current_dir = std::env::current_dir().ok()?;
+    for directory in current_dir.ancestors() {
+        if let Ok(repo) = gix::open(directory) {
+            return Some(repo);
+        }
+    }
+    None
 }
 
-fn repo_name(repo: Option<&Repository>) -> Option<String> {
-    let repo = repo?;
+fn repo_name(repo: &Repository) -> Option<String> {
     let Some(parent) = repo.path().parent() else {
         return Some(ROOT.to_owned());
     };
     let file_name = parent.file_name()?;
     file_name.to_str().map(ToOwned::to_owned)
 }
 
-fn current_branch_name(repo: &Repository) -> Option<(String, String)> {
+fn repo_hash(repo: &Repository) -> Option<String> {
+    let head_id = repo.head_id().ok()?;
+    let rev_walk = repo.rev_walk([head_id]).all().ok()?;
+    if let Some(Ok(commit)) = rev_walk.last() {
+        Some(commit.id().object().ok()?.id.to_string())
+    } else {
+        None
+    }
+}
+
+fn branch_ref(repo: &Repository) -> Option<(String, String)> {
     repo.head().ok()?.referent_name().map(|name| {
         (
             String::from_utf8_lossy(name.as_bstr()).to_string(),
@@ -91,18 +104,8 @@ fn current_branch_name(repo: &Repository) -> Option<(String, String)> {
     })
 }
 
-fn current_branch_hash(repo: &Repository) -> Option<String> {
+fn branch_hash(repo: &Repository) -> Option<String> {
     let head_id = repo.head_id().ok()?;
     let head_object = head_id.object().ok()?;
     Some(head_object.id.to_string())
 }
-
-fn find_default_branch_and_root_commit(repo: &Repository) -> Option<String> {
-    let head_id = repo.head_id().ok()?;
-    let rev_walk = repo.rev_walk([head_id]).all().ok()?;
-    if let Some(Ok(commit)) = rev_walk.last() {
-        Some(commit.id().object().ok()?.id.to_string())
-    } else {
-        None
-    }
-}

lib/bencher_context/src/client/fingerprint/mod.rs renamed to lib/bencher_context/src/client/platform/mod.rs

@@ -5,3 +5,11 @@ mod target_os;
 
 #[derive(Debug, Display, Clone, Copy)]
 pub struct Fingerprint(Uuid);
+
+#[allow(dead_code)]
+#[derive(Debug, Display, Clone, Copy)]
+pub enum OperatingSystem {
+    Linux,
+    Macos,
+    Windows,
+}

lib/bencher_context/src/client/fingerprint/target_os/linux.rs renamed to lib/bencher_context/src/client/platform/target_os/linux.rs

@@ -2,10 +2,12 @@ use std::fs;
 
 use uuid::Uuid;
 
+use crate::client::platform::OperatingSystem;
+
 const HEX_BASE: u32 = 16;
 
 impl crate::Fingerprint {
-    pub fn new() -> Option<Self> {
+    pub fn current() -> Option<Self> {
         parse_machine_id("/var/lib/dbus/machine-id")
             .or_else(|| parse_machine_id("/etc/machine-id"))
             .map(Self)
@@ -18,3 +20,9 @@ fn parse_machine_id(path: &str) -> Option<Uuid> {
         .and_then(|id| u128::from_str_radix(id.trim(), HEX_BASE).ok())
         .map(Uuid::from_u128)
 }
+
+impl OperatingSystem {
+    pub fn current() -> Self {
+        Self::Linux
+    }
+}

lib/bencher_context/src/client/fingerprint/target_os/macos.rs renamed to lib/bencher_context/src/client/platform/target_os/macos.rs

@@ -2,8 +2,10 @@ use std::process::Command;
 
 use uuid::Uuid;
 
+use crate::client::platform::OperatingSystem;
+
 impl crate::Fingerprint {
-    pub fn new() -> Option<Self> {
+    pub fn current() -> Option<Self> {
         Command::new("ioreg")
             .arg("-d2")
             .arg("-c")
@@ -24,3 +26,9 @@ impl crate::Fingerprint {
             .map(Self)
     }
 }
+
+impl OperatingSystem {
+    pub fn current() -> Self {
+        Self::Macos
+    }
+}

lib/bencher_context/src/client/fingerprint/target_os/mod.rs renamed to lib/bencher_context/src/client/platform/target_os/mod.rs

@@ -1,11 +1,19 @@
 use uuid::Uuid;
 
+use crate::client::platform::OperatingSystem;
+
 impl crate::Fingerprint {
-    pub fn new() -> Option<Self> {
+    pub fn current() -> Option<Self> {
         windows::System::Profile::SystemManufacturers::SmbiosInformation::SerialNumber()
             .ok()
             .as_ref()
             .and_then(|uuid| Uuid::parse_str(&uuid.to_string().trim()).ok())
             .map(Self)
     }
 }
+
+impl OperatingSystem {
+    pub fn current() -> Self {
+        Self::Windows
+    }
+}

lib/bencher_context/src/client/fingerprint/target_os/windows.rs renamed to lib/bencher_context/src/client/platform/target_os/windows.rs

@@ -1,4 +1,4 @@
 fn main() {
     // This is here to test that fingerprinting works on all supported operating systems
-    let _ = bencher_context::Fingerprint::new();
+    let _ = bencher_context::Fingerprint::current();
 }