disable orchestrator nodes migration (#517)

Author: JannikSt

crates/orchestrator/src/main.rs

@@ -175,7 +175,6 @@ async fn main() -> Result<()> {
 
     let store = Arc::new(RedisStore::new(&args.redis_store_url));
     let store_context = Arc::new(StoreContext::new(store.clone()));
-    store_context.node_store.migrate_existing_nodes().await?;
 
     let p2p_client = Arc::new(P2PClient::new(wallet.clone()).await.unwrap());
 

crates/orchestrator/src/store/domains/node_store.rs

@@ -205,70 +205,6 @@ impl NodeStore {
         }
         Ok(())
     }
-    pub async fn migrate_existing_nodes(&self) -> Result<()> {
-        let mut con = self.redis.client.get_multiplexed_async_connection().await?;
-
-        let mut cursor = 0;
-        loop {
-            let (new_cursor, keys): (u64, Vec<String>) = redis::cmd("SCAN")
-                .cursor_arg(cursor)
-                .arg("MATCH")
-                .arg(format!("{}:*", ORCHESTRATOR_BASE_KEY))
-                .arg("COUNT")
-                .arg(100)
-                .query_async(&mut con)
-                .await?;
-
-            for key in keys {
-                if let Some(address) = key.strip_prefix(&format!("{}:", ORCHESTRATOR_BASE_KEY)) {
-                    let _: () = con.sadd(ORCHESTRATOR_NODE_INDEX, address).await?;
-                }
-            }
-
-            if new_cursor == 0 {
-                break;
-            }
-            cursor = new_cursor;
-        }
-
-        // Handle legacy keys with double colons (orchestrator:node::address)
-        let mut cursor = 0;
-        loop {
-            let (new_cursor, keys): (u64, Vec<String>) = redis::cmd("SCAN")
-                .cursor_arg(cursor)
-                .arg("MATCH")
-                .arg("orchestrator:node::*")
-                .arg("COUNT")
-                .arg(100)
-                .query_async(&mut con)
-                .await?;
-
-            for key in keys {
-                if let Some(address) = key.strip_prefix("orchestrator:node::") {
-                    // Add to index
-                    let _: () = con.sadd(ORCHESTRATOR_NODE_INDEX, address).await?;
-
-                    // Get the value from the old key
-                    let value: Option<String> = con.get(&key).await?;
-                    if let Some(value) = value {
-                        // Set the value with the correct key format
-                        let new_key = format!("{}:{}", ORCHESTRATOR_BASE_KEY, address);
-                        let _: () = con.set(&new_key, value).await?;
-
-                        // Delete the old key with double colons
-                        let _: () = con.del(&key).await?;
-                    }
-                }
-            }
-
-            if new_cursor == 0 {
-                break;
-            }
-            cursor = new_cursor;
-        }
-
-        Ok(())
-    }
 }
 
 #[cfg(test)]
@@ -277,7 +213,7 @@ mod tests {
     use crate::models::node::NodeStatus;
     use crate::models::node::OrchestratorNode;
     use alloy::primitives::Address;
-    use redis::AsyncCommands;
+
     use std::str::FromStr;
 
     #[tokio::test]
@@ -356,62 +292,4 @@ mod tests {
             Address::from_str("0x0000000000000000000000000000000000000003").unwrap()
         );
     }
-
-    #[tokio::test]
-    async fn test_migration_handles_double_colon_keys() {
-        let app_state = create_test_app_state().await;
-        let node_store = &app_state.store_context.node_store;
-        let mut con = app_state
-            .store_context
-            .node_store
-            .redis
-            .client
-            .get_multiplexed_async_connection()
-            .await
-            .unwrap();
-
-        let test_address = "0x66295E2B4A78d1Cb57Db16Ac0260024900A5BA9B";
-        let test_node = OrchestratorNode {
-            address: Address::from_str(test_address).unwrap(),
-            ip_address: "192.168.1.1".to_string(),
-            port: 8080,
-            status: NodeStatus::Healthy,
-            ..Default::default()
-        };
-
-        // Manually create a legacy key with double colons
-        let legacy_key = format!("orchestrator:node::{}", test_address);
-        let _: () = con.set(&legacy_key, test_node.to_string()).await.unwrap();
-
-        // Verify the legacy key exists
-        let exists: bool = con.exists(&legacy_key).await.unwrap();
-        assert!(exists);
-
-        // Run migration
-        node_store.migrate_existing_nodes().await.unwrap();
-
-        // Verify the legacy key is removed
-        let legacy_exists: bool = con.exists(&legacy_key).await.unwrap();
-        assert!(!legacy_exists);
-
-        // Verify the correct key exists
-        let correct_key = format!("orchestrator:node:{}", test_address);
-        let correct_exists: bool = con.exists(&correct_key).await.unwrap();
-        assert!(correct_exists);
-
-        // Verify the node is in the index
-        let in_index: bool = con
-            .sismember("orchestrator:node_index", test_address)
-            .await
-            .unwrap();
-        assert!(in_index);
-
-        // Verify we can retrieve the node correctly
-        let retrieved_node = node_store
-            .get_node(&Address::from_str(test_address).unwrap())
-            .await
-            .unwrap();
-        assert!(retrieved_node.is_some());
-        assert_eq!(retrieved_node.unwrap().address, test_node.address);
-    }
 }