Change the API of list_root_keys. (#4860)

## Motivation

The API of `list_root_keys` is taking the config and namespace. This is
a little bit illogical, since the function should be a function of the
database itself.

## Proposal

Restructure the API accordingly.

## Test Plan

The CI should catch the problems.

## Release Plan

This is an internal change, which is useful for debugging and
consistency.
It can be backported to TestNet Conway but that does not appear to be
essential.

## Links

None.

Author: MathieuDutSik

linera-storage-service/src/client.rs

@@ -518,16 +518,12 @@ impl KeyValueDatabase for StorageServiceDatabaseInternal {
         Ok(namespaces)
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, StorageServiceStoreError> {
-        let namespace = bcs::to_bytes(namespace)?;
-        let query = RequestListRootKeys { namespace };
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, StorageServiceStoreError> {
+        let query = RequestListRootKeys {
+            namespace: self.namespace.clone(),
+        };
         let request = tonic::Request::new(query);
-        let endpoint = config.http_address();
-        let endpoint = Endpoint::from_shared(endpoint)?;
-        let mut client = StorageServiceClient::connect(endpoint).make_sync().await?;
+        let mut client = StorageServiceClient::new(self.channel.clone());
         let response = client.process_list_root_keys(request).make_sync().await?;
         let response = response.into_inner();
         let ReplyListRootKeys { root_keys } = response;

linera-storage/src/db_storage.rs

@@ -1091,7 +1091,8 @@ where
         config: &Database::Config,
         namespace: &str,
     ) -> Result<Vec<BlobId>, ViewError> {
-        let root_keys = Database::list_root_keys(config, namespace).await?;
+        let database = Database::connect(config, namespace).await?;
+        let root_keys = database.list_root_keys().await?;
         let mut blob_ids = Vec::new();
         for root_key in root_keys {
             if root_key.len() == 1 + BLOB_ID_LENGTH && root_key[0] == BLOB_ID_TAG {
@@ -1114,7 +1115,8 @@ where
         config: &Database::Config,
         namespace: &str,
     ) -> Result<Vec<ChainId>, ViewError> {
-        let root_keys = Database::list_root_keys(config, namespace).await?;
+        let database = Database::connect(config, namespace).await?;
+        let root_keys = database.list_root_keys().await?;
         let mut chain_ids = Vec::new();
         for root_key in root_keys {
             if root_key.len() == 1 + CHAIN_ID_LENGTH && root_key[0] == CHAIN_ID_TAG {

linera-views/src/backends/dual.rs

@@ -304,15 +304,15 @@ where
         Ok(namespaces)
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, Self::Error> {
-        let mut root_keys = D1::list_root_keys(&config.first_config, namespace)
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, Self::Error> {
+        let mut root_keys = self
+            .first_database
+            .list_root_keys()
             .await
             .map_err(DualStoreError::First)?;
         root_keys.extend(
-            D2::list_root_keys(&config.second_config, namespace)
+            self.second_database
+                .list_root_keys()
                 .await
                 .map_err(DualStoreError::Second)?,
         );

linera-views/src/backends/dynamo_db.rs

@@ -401,12 +401,8 @@ impl KeyValueDatabase for DynamoDbDatabaseInternal {
         Ok(namespaces)
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, DynamoDbStoreInternalError> {
-        let database = Self::connect(config, namespace).await?;
-        let store = database.open_internal(PARTITION_KEY_ROOT_KEY.to_vec());
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, DynamoDbStoreInternalError> {
+        let store = self.open_internal(PARTITION_KEY_ROOT_KEY.to_vec());
         store.find_keys_by_prefix(EMPTY_ROOT_KEY).await
     }
 

linera-views/src/backends/indexed_db.rs

@@ -301,13 +301,9 @@ impl KeyValueDatabase for IndexedDbDatabase {
             .collect())
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, IndexedDbStoreError> {
-        let database = Self::connect(config, namespace).await?;
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, IndexedDbStoreError> {
         let start_key = STORED_ROOT_KEYS_PREFIX.to_vec();
-        let store = database.open_internal(start_key);
+        let store = self.open_internal(start_key);
         store.find_keys_by_prefix(&[]).await
     }
 

linera-views/src/backends/journaling.rs

@@ -190,11 +190,8 @@ where
         D::list_all(config).await
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, Self::Error> {
-        D::list_root_keys(config, namespace).await
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, Self::Error> {
+        self.database.list_root_keys().await
     }
 
     async fn delete_all(config: &Self::Config) -> Result<(), Self::Error> {

linera-views/src/backends/lru_caching.rs

@@ -433,11 +433,8 @@ where
         D::list_all(&config.inner_config).await
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, Self::Error> {
-        D::list_root_keys(&config.inner_config, namespace).await
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, Self::Error> {
+        self.database.list_root_keys().await
     }
 
     async fn delete_all(config: &Self::Config) -> Result<(), Self::Error> {

linera-views/src/backends/memory.rs

@@ -304,14 +304,11 @@ impl KeyValueDatabase for MemoryDatabase {
         Ok(databases.sync_list_all())
     }
 
-    async fn list_root_keys(
-        _config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, MemoryStoreError> {
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, MemoryStoreError> {
         let databases = MEMORY_DATABASES
             .lock()
             .expect("MEMORY_DATABASES lock should not be poisoned");
-        Ok(databases.sync_list_root_keys(namespace))
+        Ok(databases.sync_list_root_keys(&self.namespace))
     }
 
     async fn exists(_config: &Self::Config, namespace: &str) -> Result<bool, MemoryStoreError> {

linera-views/src/backends/metering.rs

@@ -496,14 +496,9 @@ where
         Ok(namespaces)
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, Self::Error> {
-        let name = D::get_name();
-        let counter = get_counter(&name);
-        let _latency = counter.list_root_keys_latency.measure_latency();
-        D::list_root_keys(config, namespace).await
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, Self::Error> {
+        let _latency = self.counter.list_root_keys_latency.measure_latency();
+        self.database.list_root_keys().await
     }
 
     async fn delete_all(config: &Self::Config) -> Result<(), Self::Error> {

linera-views/src/backends/rocks_db.rs

@@ -582,12 +582,9 @@ impl KeyValueDatabase for RocksDbDatabaseInternal {
         Ok(namespaces)
     }
 
-    async fn list_root_keys(
-        config: &Self::Config,
-        namespace: &str,
-    ) -> Result<Vec<Vec<u8>>, RocksDbStoreInternalError> {
-        let start_key = vec![STORED_ROOT_KEYS_PREFIX];
-        let store = RocksDbStoreInternal::build(config, namespace, start_key)?;
+    async fn list_root_keys(&self) -> Result<Vec<Vec<u8>>, RocksDbStoreInternalError> {
+        let mut store = self.open_shared(&[])?;
+        store.executor.start_key = vec![STORED_ROOT_KEYS_PREFIX];
         store.find_keys_by_prefix(&[]).await
     }