[testnet] Backport the "fn root_key" and the MissingEntries change (linera-io#4916) (linera-io#4926)

Backport linera-io#4916.

## Motivation

The "fn root_key(&self)" function and the "MissingEntries(Vec<u8>)" are
of interest to TestNet usage.

## Proposal

Backport the change.
It is not completely straightforward, since the handling of `root_key`
has changed in main for RocksDB and StorageService (see
linera-io#4859 and
linera-io#4858).

## Test Plan

The same test function has been added.

## Release Plan

To TestNet Conway.

## Links

None.

---------

Signed-off-by: Mathieu Dutour Sikiric <[email protected]>
Co-authored-by: Andreas Fackler <[email protected]>

Author: MathieuDutSik

linera-sdk/src/views/system_api.rs

@@ -111,6 +111,10 @@ impl ReadableKeyValueStore for KeyValueStore {
         1
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, KeyValueStoreError> {
+        Ok(Vec::new())
+    }
+
     async fn contains_key(&self, key: &[u8]) -> Result<bool, KeyValueStoreError> {
         ensure!(
             key.len() <= Self::MAX_KEY_SIZE,

linera-service/src/proxy/grpc.rs

@@ -361,7 +361,7 @@ where
             }
             ViewError::NotFound(_)
             | ViewError::CannotAcquireCollectionEntry
-            | ViewError::MissingEntries => Status::not_found(err.to_string()),
+            | ViewError::MissingEntries(_) => Status::not_found(err.to_string()),
         };
         status.set_source(Arc::new(err));
         status

linera-storage-service/src/client.rs

@@ -98,6 +98,10 @@ impl ReadableKeyValueStore for StorageServiceStoreInternal {
         self.max_stream_queries
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, StorageServiceStoreError> {
+        Ok(self.start_key[self.prefix_len..].to_vec())
+    }
+
     async fn read_value_bytes(
         &self,
         key: &[u8],

linera-storage/src/migration.rs

@@ -135,7 +135,7 @@ where
                 .await?;
             let mut batch = MultiPartitionBatch::new();
             for (base_key, value) in chunk_base_keys.iter().zip(values) {
-                let value = value.ok_or(ViewError::MissingEntries)?;
+                let value = value.ok_or(ViewError::MissingEntries(Vec::new()))?;
                 let (root_key, key) = map_base_key(base_key)?;
                 batch.put_key_value(root_key, key, value);
             }
@@ -169,7 +169,7 @@ where
                 return Ok(());
             }
             let result = self.migrate_v0_to_v1().await;
-            if let Err(ViewError::MissingEntries) = result {
+            if let Err(ViewError::MissingEntries(_)) = result {
                 tracing::warn!(
                     "It looks like a migration is already in progress on this database. \
                      I will wait for {:?} minutes and retry.",

linera-views/src/backends/dual.rs

@@ -96,6 +96,13 @@ where
         }
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, Self::Error> {
+        Ok(match self {
+            Self::First(store) => store.root_key().map_err(DualStoreError::First)?,
+            Self::Second(store) => store.root_key().map_err(DualStoreError::Second)?,
+        })
+    }
+
     async fn read_value_bytes(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
         let result = match self {
             Self::First(store) => store

linera-views/src/backends/dynamo_db.rs

@@ -719,6 +719,11 @@ impl ReadableKeyValueStore for DynamoDbStoreInternal {
         self.max_stream_queries
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, DynamoDbStoreInternalError> {
+        assert!(self.start_key.starts_with(EMPTY_ROOT_KEY));
+        Ok(self.start_key[EMPTY_ROOT_KEY.len()..].to_vec())
+    }
+
     async fn read_value_bytes(
         &self,
         key: &[u8],

linera-views/src/backends/indexed_db.rs

@@ -119,6 +119,12 @@ impl ReadableKeyValueStore for IndexedDbStore {
         self.max_stream_queries
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, IndexedDbStoreError> {
+        assert!(self.start_key.starts_with(&ROOT_KEY_DOMAIN));
+        let root_key = self.start_key[ROOT_KEY_DOMAIN.len()..].to_vec();
+        Ok(root_key)
+    }
+
     async fn read_value_bytes(&self, key: &[u8]) -> Result<Option<Vec<u8>>, IndexedDbStoreError> {
         let key = self.full_key(key);
         let key = js_sys::Uint8Array::from(key.as_slice());

linera-views/src/backends/journaling.rs

@@ -123,6 +123,10 @@ where
         self.store.max_stream_queries()
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, Self::Error> {
+        self.store.root_key()
+    }
+
     async fn read_value_bytes(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
         self.store.read_value_bytes(key).await
     }

linera-views/src/backends/lru_caching.rs

@@ -291,6 +291,10 @@ where
         self.store.max_stream_queries()
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, Self::Error> {
+        self.store.root_key()
+    }
+
     async fn read_value_bytes(&self, key: &[u8]) -> Result<Option<Vec<u8>>, Self::Error> {
         let Some(cache) = &self.cache else {
             return self.store.read_value_bytes(key).await;

linera-views/src/backends/memory.rs

@@ -73,6 +73,7 @@ impl MemoryDatabases {
         let map = store.clone();
         Ok(MemoryStore {
             map,
+            root_key: root_key.to_vec(),
             max_stream_queries,
         })
     }
@@ -111,6 +112,8 @@ static MEMORY_DATABASES: LazyLock<Mutex<MemoryDatabases>> =
 pub struct MemoryStore {
     /// The map used for storing the data.
     map: Arc<RwLock<MemoryStoreMap>>,
+    /// The root key.
+    root_key: Vec<u8>,
     /// The maximum number of queries used for a stream.
     max_stream_queries: usize,
 }
@@ -130,6 +133,10 @@ impl ReadableKeyValueStore for MemoryStore {
         self.max_stream_queries
     }
 
+    fn root_key(&self) -> Result<Vec<u8>, MemoryStoreError> {
+        Ok(self.root_key.clone())
+    }
+
     async fn read_value_bytes(&self, key: &[u8]) -> Result<Option<Vec<u8>>, MemoryStoreError> {
         let map = self
             .map
@@ -247,6 +254,7 @@ impl MemoryStore {
     pub fn new_for_testing() -> Self {
         Self {
             map: Arc::default(),
+            root_key: Vec::new(),
             max_stream_queries: TEST_MEMORY_MAX_STREAM_QUERIES,
         }
     }