devcycle_bucketing_rs/config/
platform_data.rs

1use once_cell::sync::Lazy;
2use serde::{Deserialize, Serialize};
3use std::collections::HashMap;
4use std::sync::{Arc, RwLock};
5
6cfg_if::cfg_if! {
7    if #[cfg(target_family = "wasm")] {
8        fn resolve_hostname() -> String {
9            std::env::var("HOSTNAME")
10                .unwrap_or_else(|_| "unknown".to_string())
11        }
12    } else {
13        fn resolve_hostname() -> String {
14            hostname::get()
15                .ok()
16                .and_then(|h| h.into_string().ok())
17                .or_else(|| std::env::var("HOSTNAME").ok())
18                .unwrap_or_else(|| "unknown".to_string())
19        }
20    }
21}
22
23// Global platform data storage per SDK key
24pub(crate) static PLATFORM_DATA: Lazy<RwLock<HashMap<String, Arc<PlatformData>>>> =
25    Lazy::new(|| RwLock::new(HashMap::new()));
26
27#[derive(Debug, Clone, Serialize, Deserialize)]
28#[serde(rename_all = "camelCase")]
29pub struct PlatformData {
30    pub sdk_type: String,
31    pub sdk_version: String,
32    pub platform_version: String,
33    pub device_model: String,
34    pub platform: String,
35    pub hostname: String,
36}
37
38impl PlatformData {
39    pub fn generate() -> Self {
40        PlatformData {
41            sdk_type: "server".to_string(),
42            sdk_version: env!("CARGO_PKG_VERSION").to_string(),
43            platform_version: std::env::consts::OS.to_string(),
44            device_model: "unknown".to_string(),
45            platform: "Rust".to_string(),
46            hostname: resolve_hostname(),
47        }
48    }
49}
50
51pub fn get_platform_data(sdk_key: &str) -> Result<Arc<PlatformData>, String> {
52    let data = PLATFORM_DATA
53        .read()
54        .expect("Failed to acquire read lock on PLATFORM_DATA: lock poisoned");
55    data.get(sdk_key).cloned().ok_or_else(|| {
56        format!(
57            "Platform data not set for SDK key: {}. Call set_platform_data() first.",
58            sdk_key
59        )
60    })
61}
62
63pub fn set_platform_data(sdk_key: String, platform_data: PlatformData) {
64    let mut data = PLATFORM_DATA
65        .write()
66        .expect("Failed to acquire write lock on PLATFORM_DATA (lock may be poisoned)");
67    data.insert(sdk_key, Arc::new(platform_data));
68}