migration of existing dashboards and filters from v1 to v2

Author: nikhilsinhaparseable

server/src/users/dashboards.rs

@@ -20,13 +20,17 @@ use std::sync::RwLock;
 
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 
-use crate::{metadata::LOCK_EXPECT, option::CONFIG};
+use crate::{
+    metadata::LOCK_EXPECT, migration::to_bytes, option::CONFIG,
+    storage::object_storage::dashboard_path, utils::get_hash,
+};
 
 use super::TimeFilter;
 
 pub static DASHBOARDS: Lazy<Dashboards> = Lazy::new(Dashboards::default);
-pub const CURRENT_DASHBOARD_VERSION: &str = "v1";
+pub const CURRENT_DASHBOARD_VERSION: &str = "v2";
 
 #[derive(Debug, Serialize, Deserialize, Default, Clone)]
 pub struct Tiles {
@@ -94,8 +98,31 @@ impl Dashboards {
         let dashboards = store.get_all_dashboards().await.unwrap_or_default();
 
         for dashboard in dashboards {
-            if let Ok(dashboard) = serde_json::from_slice::<Dashboard>(&dashboard) {
-                this.push(dashboard);
+            if dashboard.is_empty() {
+                continue;
+            }
+            let mut dashboard_value = serde_json::from_slice::<serde_json::Value>(&dashboard)?;
+            if let Some(meta) = dashboard_value.clone().as_object() {
+                let version = meta.get("version").and_then(|version| version.as_str());
+                let user_id = meta.get("user_id").and_then(|user_id| user_id.as_str());
+                let dashboard_id = meta
+                    .get("dashboard_id")
+                    .and_then(|dashboard_id| dashboard_id.as_str());
+
+                if version == Some("v1") {
+                    dashboard_value = migrate_v1_v2(dashboard_value);
+                    if let (Some(user_id), Some(dashboard_id)) = (user_id, dashboard_id) {
+                        let path = dashboard_path(user_id, &format!("{}.json", dashboard_id));
+                        let dashboard_bytes = to_bytes(&dashboard_value);
+                        store.put_object(&path, dashboard_bytes.clone()).await?;
+                        if let Ok(dashboard) = serde_json::from_slice::<Dashboard>(&dashboard_bytes)
+                        {
+                            this.push(dashboard);
+                        }
+                    }
+                } else if let Ok(dashboard) = serde_json::from_slice::<Dashboard>(&dashboard) {
+                    this.push(dashboard);
+                }
             }
         }
 
@@ -135,3 +162,17 @@ impl Dashboards {
             .collect()
     }
 }
+
+fn migrate_v1_v2(mut dashboard_meta: Value) -> Value {
+    let dashboard_meta_map = dashboard_meta.as_object_mut().unwrap();
+    let user_id = dashboard_meta_map.get("user_id").unwrap().clone();
+    let str_user_id = user_id.as_str().unwrap();
+    let user_id_hash = get_hash(str_user_id);
+    dashboard_meta_map.insert("user_id".to_owned(), Value::String(user_id_hash));
+    dashboard_meta_map.insert(
+        "version".to_owned(),
+        Value::String(CURRENT_DASHBOARD_VERSION.into()),
+    );
+
+    dashboard_meta
+}

server/src/users/filters.rs

@@ -18,13 +18,17 @@
 
 use once_cell::sync::Lazy;
 use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use std::sync::RwLock;
 
 use super::TimeFilter;
-use crate::{metadata::LOCK_EXPECT, option::CONFIG};
+use crate::{
+    metadata::LOCK_EXPECT, migration::to_bytes, option::CONFIG,
+    storage::object_storage::filter_path, utils::get_hash,
+};
 
 pub static FILTERS: Lazy<Filters> = Lazy::new(Filters::default);
-pub const CURRENT_FILTER_VERSION: &str = "v1";
+pub const CURRENT_FILTER_VERSION: &str = "v2";
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
 pub struct Filter {
     pub version: Option<String>,
@@ -75,8 +79,37 @@ impl Filters {
         let filters = store.get_all_saved_filters().await.unwrap_or_default();
 
         for filter in filters {
-            if let Ok(filter) = serde_json::from_slice::<Filter>(&filter) {
-                this.push(filter);
+            if filter.is_empty() {
+                continue;
+            }
+
+            let mut filter_value = serde_json::from_slice::<serde_json::Value>(&filter)?;
+            if let Some(meta) = filter_value.clone().as_object() {
+                let version = meta.get("version").and_then(|version| version.as_str());
+                let user_id = meta.get("user_id").and_then(|user_id| user_id.as_str());
+                let filter_id = meta
+                    .get("filter_id")
+                    .and_then(|filter_id| filter_id.as_str());
+                let stream_name = meta
+                    .get("stream_name")
+                    .and_then(|stream_name| stream_name.as_str());
+
+                if version == Some("v1") {
+                    filter_value = migrate_v1_v2(filter_value);
+                    if let (Some(user_id), Some(stream_name), Some(filter_id)) =
+                        (user_id, stream_name, filter_id)
+                    {
+                        let path =
+                            filter_path(user_id, stream_name, &format!("{}.json", filter_id));
+                        let filter_bytes = to_bytes(&filter_value);
+                        store.put_object(&path, filter_bytes.clone()).await?;
+                        if let Ok(filter) = serde_json::from_slice::<Filter>(&filter_bytes) {
+                            this.push(filter);
+                        }
+                    }
+                } else if let Ok(filter) = serde_json::from_slice::<Filter>(&filter) {
+                    this.push(filter);
+                }
             }
         }
 
@@ -116,3 +149,17 @@ impl Filters {
             .collect()
     }
 }
+
+fn migrate_v1_v2(mut filter_meta: Value) -> Value {
+    let filter_meta_map = filter_meta.as_object_mut().unwrap();
+    let user_id = filter_meta_map.get("user_id").unwrap().clone();
+    let str_user_id = user_id.as_str().unwrap();
+    let user_id_hash = get_hash(str_user_id);
+    filter_meta_map.insert("user_id".to_owned(), Value::String(user_id_hash));
+    filter_meta_map.insert(
+        "version".to_owned(),
+        Value::String(CURRENT_FILTER_VERSION.into()),
+    );
+
+    filter_meta
+}