Revert "fix: Adding lock to init relayer instances" (#692)

Revert "fix: Adding lock to init relayer instances (#622)"

This reverts commit 51df3c5.

Author: collins-w

src/bootstrap/config_processor.rs

@@ -330,54 +330,54 @@ impl ApiKeyRepositoryTrait for RedisApiKeyRepository {
             .await?;
         let plugin_list_key = self.api_key_list_key();
 
-        debug!("Checking if API key entries exist");
+        debug!("Checking if plugin entries exist");
 
         let exists: bool = conn
             .exists(&plugin_list_key)
             .await
             .map_err(|e| self.map_redis_error(e, "has_entries_check"))?;
 
-        debug!("API key entries exist: {}", exists);
+        debug!("Plugin entries exist: {}", exists);
         Ok(exists)
     }
 
     async fn drop_all_entries(&self) -> Result<(), RepositoryError> {
         let mut conn = self
             .get_connection(self.connections.primary(), "drop_all_entries")
             .await?;
-        let api_key_list_key = self.api_key_list_key();
+        let plugin_list_key = self.api_key_list_key();
 
-        debug!("Dropping all API key entries");
+        debug!("Dropping all plugin entries");
 
-        // Get all API key IDs first
-        let api_key_ids: Vec<String> = conn
-            .smembers(&api_key_list_key)
+        // Get all plugin IDs first
+        let plugin_ids: Vec<String> = conn
+            .smembers(&plugin_list_key)
             .await
             .map_err(|e| self.map_redis_error(e, "drop_all_entries_get_ids"))?;
 
-        if api_key_ids.is_empty() {
-            debug!("No API key entries to drop");
+        if plugin_ids.is_empty() {
+            debug!("No plugin entries to drop");
             return Ok(());
         }
 
         // Use pipeline for atomic operations
         let mut pipe = redis::pipe();
         pipe.atomic();
 
-        // Delete all individual API key entries
-        for api_key_id in &api_key_ids {
-            let api_key_key = self.api_key_key(api_key_id);
-            pipe.del(&api_key_key);
+        // Delete all individual plugin entries
+        for plugin_id in &plugin_ids {
+            let plugin_key = self.api_key_key(plugin_id);
+            pipe.del(&plugin_key);
         }
 
-        // Delete the API key list key
-        pipe.del(&api_key_list_key);
+        // Delete the plugin list key
+        pipe.del(&plugin_list_key);
 
         pipe.exec_async(&mut conn)
             .await
             .map_err(|e| self.map_redis_error(e, "drop_all_entries_pipeline"))?;
 
-        debug!("Dropped {} API key entries", api_key_ids.len());
+        debug!("Dropped {} plugin entries", plugin_ids.len());
         Ok(())
     }
 }

src/bootstrap/initialize_relayers.rs

@@ -34,7 +34,6 @@ use crate::{
     utils::RedisConnections,
 };
 use async_trait::async_trait;
-use deadpool_redis::Pool;
 use std::sync::Arc;
 
 #[async_trait]
@@ -68,19 +67,6 @@ pub trait RelayerRepository: Repository<RelayerRepoModel, String> + Send + Sync
     /// Returns true if this repository uses persistent storage (e.g., Redis).
     /// Returns false for in-memory storage.
     fn is_persistent_storage(&self) -> bool;
-
-    /// Returns connection info for distributed operations.
-    ///
-    /// This method provides access to the underlying connection and key prefix
-    /// when using persistent storage. This is useful for distributed locking and
-    /// other coordination operations that need direct storage access.
-    ///
-    /// # Returns
-    /// * `Some((pool, prefix))` - If using persistent storage (e.g., Redis)
-    /// * `None` - If using in-memory storage (default)
-    fn connection_info(&self) -> Option<(Arc<Pool>, String)> {
-        None
-    }
 }
 
 #[cfg(test)]
@@ -110,7 +96,6 @@ mockall::mock! {
         async fn disable_relayer(&self, relayer_id: String, reason: DisabledReason) -> Result<RelayerRepoModel, RepositoryError>;
         async fn update_policy(&self, id: String, policy: RelayerNetworkPolicy) -> Result<RelayerRepoModel, RepositoryError>;
         fn is_persistent_storage(&self) -> bool;
-        fn connection_info(&self) -> Option<(Arc<Pool>, String)>;
     }
 }
 
@@ -135,24 +120,6 @@ impl RelayerRepositoryStorage {
             key_prefix,
         )?))
     }
-
-    /// Returns connection info for distributed operations.
-    ///
-    /// This method provides access to the underlying Redis connection and key prefix
-    /// when using Redis-backed storage. This is useful for distributed locking and
-    /// other coordination operations that need direct Redis access.
-    ///
-    /// # Returns
-    /// * `Some((pool, prefix))` - If using persistent storage (e.g., Redis)
-    /// * `None` - If using in-memory storage
-    pub fn connection_info(&self) -> Option<(Arc<Pool>, String)> {
-        match self {
-            RelayerRepositoryStorage::InMemory(_) => None,
-            RelayerRepositoryStorage::Redis(repo) => {
-                Some((repo.connections.primary().clone(), repo.key_prefix.clone()))
-            }
-        }
-    }
 }
 
 impl Default for RelayerRepositoryStorage {
@@ -318,15 +285,6 @@ impl RelayerRepository for RelayerRepositoryStorage {
             RelayerRepositoryStorage::Redis(_) => true,
         }
     }
-
-    fn connection_info(&self) -> Option<(Arc<Pool>, String)> {
-        match self {
-            RelayerRepositoryStorage::InMemory(_) => None,
-            RelayerRepositoryStorage::Redis(repo) => {
-                Some((repo.connections.primary().clone(), repo.key_prefix.clone()))
-            }
-        }
-    }
 }
 
 #[cfg(test)]
@@ -541,38 +499,4 @@ mod tests {
         repo.drop_all_entries().await.unwrap();
         assert!(!repo.has_entries().await.unwrap());
     }
-
-    #[tokio::test]
-    async fn test_connection_info_returns_none_for_in_memory() {
-        let storage = RelayerRepositoryStorage::new_in_memory();
-
-        // In-memory storage should return None for connection_info
-        assert!(storage.connection_info().is_none());
-    }
-
-    #[tokio::test]
-    async fn test_is_persistent_storage_returns_false_for_in_memory() {
-        let storage = RelayerRepositoryStorage::new_in_memory();
-
-        // In-memory storage should return false for is_persistent_storage
-        assert!(!storage.is_persistent_storage());
-    }
-
-    #[tokio::test]
-    async fn test_trait_connection_info_returns_none_for_in_memory() {
-        let storage = RelayerRepositoryStorage::new_in_memory();
-
-        // Test the RelayerRepository trait's connection_info method
-        let trait_ref: &dyn RelayerRepository = &storage;
-        assert!(trait_ref.connection_info().is_none());
-    }
-
-    #[tokio::test]
-    async fn test_struct_connection_info_returns_none_for_in_memory() {
-        let storage = RelayerRepositoryStorage::new_in_memory();
-
-        // Test the struct's own connection_info method
-        let result: Option<(Arc<Pool>, String)> = storage.connection_info();
-        assert!(result.is_none());
-    }
 }

src/repositories/api_key/api_key_redis.rs

@@ -166,8 +166,6 @@ impl RelayerRepository for InMemoryRelayerRepository {
     fn is_persistent_storage(&self) -> bool {
         false
     }
-
-    // Uses the trait default implementation which returns None
 }
 
 #[async_trait]

src/repositories/relayer/mod.rs

@@ -560,10 +560,6 @@ impl RelayerRepository for RedisRelayerRepository {
     fn is_persistent_storage(&self) -> bool {
         true
     }
-
-    fn connection_info(&self) -> Option<(Arc<deadpool_redis::Pool>, String)> {
-        Some((self.connections.primary().clone(), self.key_prefix.clone()))
-    }
 }
 
 #[cfg(test)]

src/repositories/relayer/relayer_in_memory.rs

@@ -8,9 +8,6 @@ pub use key::*;
 mod auth;
 pub use auth::*;
 
-mod polling;
-pub use polling::*;
-
 mod time;
 pub use time::*;