cargo fmt (#103)

lib/storage/src/content_manager/collections_ops.rs

@@ -1,8 +1,8 @@
-use std::collections::HashMap;
-use std::sync::Arc;
+use crate::content_manager::errors::StorageError;
 use async_trait::async_trait;
 use collection::collection::Collection;
-use crate::content_manager::errors::StorageError;
+use std::collections::HashMap;
+use std::sync::Arc;
 
 pub type Collections = HashMap<String, Arc<Collection>>;
 
@@ -30,12 +30,11 @@ pub trait Checker {
         }
         Ok(())
     }
-
 }
 
 #[async_trait]
 impl Checker for Collections {
     async fn is_collection_exists(&self, collection_name: &str) -> bool {
         self.contains_key(collection_name)
     }
-}
+}

lib/storage/src/content_manager/mod.rs

@@ -1,4 +1,4 @@
+mod collections_ops;
 pub mod errors;
 pub mod storage_ops;
 pub mod toc;
-mod collections_ops;

lib/storage/src/content_manager/toc.rs

@@ -20,14 +20,14 @@ use collection::operations::types::{
 use collection::operations::CollectionUpdateOperations;
 use segment::types::{PointIdType, ScoredPoint};
 
+use crate::content_manager::collections_ops::{Checker, Collections};
 use crate::content_manager::errors::StorageError;
 use crate::content_manager::storage_ops::{AliasOperations, StorageOperations};
 use crate::types::StorageConfig;
 use collection::collection_manager::collection_managers::{CollectionSearcher, CollectionUpdater};
 use collection::collection_manager::simple_collection_searcher::SimpleCollectionSearcher;
 use collection::collection_manager::simple_collection_updater::SimpleCollectionUpdater;
 use std::ops::Deref;
-use crate::content_manager::collections_ops::{Checker, Collections};
 
 /// Since sled is used for reading only during the initialization, large read cache is not required
 #[allow(clippy::identity_op)]
@@ -117,7 +117,11 @@ impl TableOfContent {
             None => collection_name.to_string(),
             Some(resolved_alias) => from_utf8(&resolved_alias).unwrap().to_string(),
         };
-        self.collections.read().await.validate_collection_exists(&resolved_name).await?;
+        self.collections
+            .read()
+            .await
+            .validate_collection_exists(&resolved_name)
+            .await?;
         Ok(resolved_name)
     }
 
@@ -134,7 +138,8 @@ impl TableOfContent {
                 wal_config: wal_config_diff,
                 optimizers_config: optimizers_config_diff,
             } => {
-                self.collections.read()
+                self.collections
+                    .read()
                     .await
                     .validate_collection_not_exists(&collection_name)
                     .await?;
@@ -168,7 +173,9 @@ impl TableOfContent {
                 )?;
 
                 let mut write_collections = self.collections.write().await;
-                write_collections.validate_collection_not_exists(&collection_name).await?;
+                write_collections
+                    .validate_collection_not_exists(&collection_name)
+                    .await?;
                 write_collections.insert(collection_name, Arc::new(collection));
                 Ok(true)
             }
@@ -217,8 +224,12 @@ impl TableOfContent {
                             collection_name,
                             alias_name,
                         } => {
-                            collection_lock.validate_collection_exists(&collection_name).await?;
-                            collection_lock.validate_collection_not_exists(&alias_name).await?;
+                            collection_lock
+                                .validate_collection_exists(&collection_name)
+                                .await?;
+                            collection_lock
+                                .validate_collection_not_exists(&alias_name)
+                                .await?;
 
                             self.alias_persistence
                                 .insert(alias_name.as_bytes(), collection_name.as_bytes())?;

lib/storage/tests/alias_tests.rs

@@ -1,15 +1,14 @@
-use tempdir::TempDir;
-use tokio::runtime::Runtime;
 use collection::collection_builder::optimizers_builder::OptimizersConfig;
 use storage::content_manager::toc::TableOfContent;
 use storage::types::{PerformanceConfig, StorageConfig};
-
+use tempdir::TempDir;
+use tokio::runtime::Runtime;
 
 #[cfg(test)]
 mod tests {
+    use super::*;
     use segment::types::Distance;
     use storage::content_manager::storage_ops::{AliasOperations, StorageOperations};
-    use super::*;
 
     #[test]
     fn test_alias_operation() {
@@ -27,7 +26,9 @@ mod tests {
                 flush_interval_sec: 2,
             },
             wal: Default::default(),
-            performance: PerformanceConfig { max_search_threads: 1 },
+            performance: PerformanceConfig {
+                max_search_threads: 1,
+            },
             hnsw_index: Default::default(),
         };
 
@@ -36,45 +37,50 @@ mod tests {
 
         let toc = TableOfContent::new(&config, runtime);
 
-        handle.block_on(toc.perform_collection_operation(
-            StorageOperations::CreateCollection {
-                name: "test".to_string(),
-                vector_size: 10,
-                distance: Distance::Cosine,
-                hnsw_config: None,
-                wal_config: None,
-                optimizers_config: None,
-            }
-        )).unwrap();
-
-        handle.block_on(toc.perform_collection_operation(
-            StorageOperations::ChangeAliases {
-                actions: vec![AliasOperations::CreateAlias {
-                    collection_name: "test".to_string(),
-                    alias_name: "test_alias".to_string(),
-                }]
-            }
-        )).unwrap();
+        handle
+            .block_on(
+                toc.perform_collection_operation(StorageOperations::CreateCollection {
+                    name: "test".to_string(),
+                    vector_size: 10,
+                    distance: Distance::Cosine,
+                    hnsw_config: None,
+                    wal_config: None,
+                    optimizers_config: None,
+                }),
+            )
+            .unwrap();
 
-        handle.block_on(toc.perform_collection_operation(
-            StorageOperations::ChangeAliases {
-                actions: vec![
-                    AliasOperations::CreateAlias {
+        handle
+            .block_on(
+                toc.perform_collection_operation(StorageOperations::ChangeAliases {
+                    actions: vec![AliasOperations::CreateAlias {
                         collection_name: "test".to_string(),
-                        alias_name: "test_alias2".to_string(),
-                    },
-                    AliasOperations::DeleteAlias {
                         alias_name: "test_alias".to_string(),
-                    },
-                    AliasOperations::RenameAlias {
-                        old_alias_name: "test_alias2".to_string(),
-                        new_alias_name: "test_alias3".to_string()
-                    }
-                ]
-            }
-        )).unwrap();
+                    }],
+                }),
+            )
+            .unwrap();
 
-        handle.block_on(toc.get_collection(&"test_alias3")).unwrap();
+        handle
+            .block_on(
+                toc.perform_collection_operation(StorageOperations::ChangeAliases {
+                    actions: vec![
+                        AliasOperations::CreateAlias {
+                            collection_name: "test".to_string(),
+                            alias_name: "test_alias2".to_string(),
+                        },
+                        AliasOperations::DeleteAlias {
+                            alias_name: "test_alias".to_string(),
+                        },
+                        AliasOperations::RenameAlias {
+                            old_alias_name: "test_alias2".to_string(),
+                            new_alias_name: "test_alias3".to_string(),
+                        },
+                    ],
+                }),
+            )
+            .unwrap();
 
+        handle.block_on(toc.get_collection(&"test_alias3")).unwrap();
     }
 }