feat: user key not change for multiple percetage roullout evaluation

Author: sebo

Cargo.lock

@@ -32,7 +32,7 @@ headers = "0.3"
 http = "0.2"
 lazy_static = "1.4"
 minstant = "0.1"
-parking_lot = "0.12"
+parking_lot = { version = "0.12", features = ["serde"] }
 rand = "0.8"
 regex = "1.5.6"
 semver = "1.0"

Cargo.toml

@@ -8,7 +8,6 @@ use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use sha1::Digest;
 use std::string::String;
-use std::time::{SystemTime, UNIX_EPOCH};
 use std::{collections::HashMap, str::FromStr};
 use tracing::{info, warn};
 
@@ -67,16 +66,15 @@ pub struct Distribution {
 impl Distribution {
     pub fn find_index(&self, eval_param: &EvalParams) -> Result<usize, FPError> {
         let user = eval_param.user;
+
         let hash_key = match &self.bucket_by {
-            None => match &user.key {
-                Some(key) => key.to_owned(),
-                None => temporal_rollout_key(),
-            },
+            None => user.key(),
             Some(custom_key) => match user.get(custom_key) {
                 None if eval_param.is_detail => {
                     return Err(FPError::EvalDetailError(format!(
                         "User with key:{:?} does not have attribute named: [{}]",
-                        user.key, custom_key
+                        user.key(),
+                        custom_key
                     )));
                 }
                 None => return Err(FPError::EvalError),
@@ -108,14 +106,6 @@ impl Distribution {
     }
 }
 
-fn temporal_rollout_key() -> String {
-    let start = SystemTime::now();
-    let since_the_epoch = start
-        .duration_since(UNIX_EPOCH)
-        .expect("Time went before epoch");
-    format!("{}", since_the_epoch.as_micros())
-}
-
 fn salt_hash(key: &str, salt: &str, bucket_size: u64) -> u32 {
     let size = 4;
     let mut hasher = sha1::Sha1::new();

src/evalutate.rs

@@ -1,24 +1,25 @@
-use std::collections::HashMap;
-
+use parking_lot::RwLock;
 use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::time::{SystemTime, UNIX_EPOCH};
 
-#[derive(Default, Debug, Deserialize, Serialize)]
+#[derive(Default, Debug, Serialize, Deserialize)]
 pub struct FPUser {
-    pub key: Option<String>,
+    key: RwLock<Option<String>>,
     attrs: HashMap<String, String>,
 }
 
 impl FPUser {
     pub fn new() -> Self {
-        let key = None;
+        let key = RwLock::new(None);
         FPUser {
             key,
             ..Default::default()
         }
     }
 
     pub fn stable_rollout(mut self, key: String) -> Self {
-        self.key = Some(key);
+        self.key = RwLock::new(Some(key));
         self
     }
 
@@ -39,6 +40,30 @@ impl FPUser {
     pub fn get_all(&self) -> &HashMap<String, String> {
         &self.attrs
     }
+
+    pub fn key(&self) -> String {
+        let key = {
+            let key = self.key.read();
+            (*key).clone()
+        };
+        match key {
+            Some(key) => key,
+            None => {
+                let mut guard = self.key.write();
+                let key = generate_key();
+                *guard = Some(key.clone());
+                key
+            }
+        }
+    }
+}
+
+fn generate_key() -> String {
+    let start = SystemTime::now();
+    let since_the_epoch = start
+        .duration_since(UNIX_EPOCH)
+        .expect("Time went before epoch");
+    format!("{}", since_the_epoch.as_micros())
 }
 
 #[cfg(test)]
@@ -48,10 +73,11 @@ mod tests {
     #[test]
     fn test_user_with() {
         let u = FPUser::new().with("name", "bob").with("phone", "123");
-        assert_eq!(u.key, None);
         assert_eq!(u.get("name"), Some(&"bob".to_owned()));
         assert_eq!(u.get("phone"), Some(&"123".to_owned()));
         assert_eq!(u.get_all().len(), 2);
+        // test generated key not change
+        assert_eq!(u.key(), u.key());
     }
 
     #[test]