Init storage with version

azarovh · azarovh · commit 702936c08d47 · 2023-08-01T21:58:06.000+03:00
diff --git a/chainstate/launcher/src/lib.rs b/chainstate/launcher/src/lib.rs
@@ -39,10 +39,10 @@ fn make_chainstate_and_storage_impl<B: 'static + storage::Backend>(
     chain_config: Arc<ChainConfig>,
     chainstate_config: ChainstateConfig,
 ) -> Result<Box<dyn ChainstateInterface>, Error> {
-    let mut storage = chainstate_storage::Store::new(storage_backend)
+    let storage = chainstate_storage::Store::new(storage_backend, &chain_config)
         .map_err(|e| Error::FailedToInitializeChainstate(e.into()))?;
 
-    storage_compatibility::check_storage_compatibility(&mut storage, chain_config.as_ref())
+    storage_compatibility::check_storage_compatibility(&storage, chain_config.as_ref())
         .map_err(InitializationError::StorageCompatibilityCheckError)?;
 
     let chainstate = chainstate::make_chainstate(
diff --git a/chainstate/launcher/src/storage_compatibility.rs b/chainstate/launcher/src/storage_compatibility.rs
@@ -14,16 +14,12 @@
 // limitations under the License.
 
 use chainstate::StorageCompatibilityCheckError;
-use chainstate_storage::{BlockchainStorageRead, BlockchainStorageWrite};
+use chainstate_storage::{BlockchainStorageRead, ChainstateStorageVersion};
 use common::chain::ChainConfig;
 use utils::ensure;
 
-const CHAINSTATE_STORAGE_VERSION_UNINITIALIZED: u32 = 0;
-const CHAINSTATE_STORAGE_VERSION_V1: u32 = 1;
-const CURRENT_CHAINSTATE_STORAGE_VERSION: u32 = CHAINSTATE_STORAGE_VERSION_V1;
-
-pub fn check_storage_compatibility<B: 'static + storage::Backend>(
-    storage: &mut chainstate_storage::Store<B>,
+pub fn check_storage_compatibility(
+    storage: &impl BlockchainStorageRead,
     chain_config: &ChainConfig,
 ) -> Result<(), StorageCompatibilityCheckError> {
     check_storage_version(storage)?;
@@ -33,74 +29,64 @@ pub fn check_storage_compatibility<B: 'static + storage::Backend>(
     Ok(())
 }
 
-fn check_storage_version<B: 'static + storage::Backend>(
-    storage: &mut chainstate_storage::Store<B>,
+fn check_storage_version(
+    storage: &impl BlockchainStorageRead,
 ) -> Result<(), StorageCompatibilityCheckError> {
     let storage_version = storage
         .get_storage_version()
-        .map_err(StorageCompatibilityCheckError::StorageError)?;
+        .map_err(StorageCompatibilityCheckError::StorageError)?
+        .ok_or(StorageCompatibilityCheckError::StorageVersionMissing)?;
+    let storage_version = ChainstateStorageVersion::new(storage_version)
+        .ok_or(StorageCompatibilityCheckError::StorageVersionConversionError)?;
+
+    ensure!(
+        storage_version == ChainstateStorageVersion::CURRENT,
+        StorageCompatibilityCheckError::ChainstateStorageVersionMismatch(
+            storage_version,
+            ChainstateStorageVersion::CURRENT
+        )
+    );
 
-    if storage_version == CHAINSTATE_STORAGE_VERSION_UNINITIALIZED {
-        storage
-            .set_storage_version(CURRENT_CHAINSTATE_STORAGE_VERSION)
-            .map_err(StorageCompatibilityCheckError::StorageError)?;
-    } else {
-        ensure!(
-            storage_version == CURRENT_CHAINSTATE_STORAGE_VERSION,
-            StorageCompatibilityCheckError::ChainstateStorageVersionMismatch(
-                storage_version,
-                CURRENT_CHAINSTATE_STORAGE_VERSION
-            )
-        );
-    }
     Ok(())
 }
 
-fn check_magic_bytes<B: 'static + storage::Backend>(
-    storage: &mut chainstate_storage::Store<B>,
+fn check_magic_bytes(
+    storage: &impl BlockchainStorageRead,
     chain_config: &ChainConfig,
 ) -> Result<(), StorageCompatibilityCheckError> {
     let storage_magic_bytes = storage
         .get_magic_bytes()
-        .map_err(StorageCompatibilityCheckError::StorageError)?;
-    let chain_config_magic_bytes = chain_config.magic_bytes();
+        .map_err(StorageCompatibilityCheckError::StorageError)?
+        .ok_or(StorageCompatibilityCheckError::MagicBytesMissing)?;
 
-    match storage_magic_bytes {
-        Some(storage_magic_bytes) => ensure!(
-            &storage_magic_bytes == chain_config_magic_bytes,
-            StorageCompatibilityCheckError::ChainConfigMagicBytesMismatch(
-                storage_magic_bytes,
-                chain_config_magic_bytes.to_owned()
-            )
-        ),
-        None => storage
-            .set_magic_bytes(chain_config_magic_bytes)
-            .map_err(StorageCompatibilityCheckError::StorageError)?,
-    };
+    ensure!(
+        &storage_magic_bytes == chain_config.magic_bytes(),
+        StorageCompatibilityCheckError::ChainConfigMagicBytesMismatch(
+            storage_magic_bytes,
+            chain_config.magic_bytes().to_owned()
+        )
+    );
 
     Ok(())
 }
 
-fn check_chain_type<B: 'static + storage::Backend>(
-    storage: &mut chainstate_storage::Store<B>,
+fn check_chain_type(
+    storage: &impl BlockchainStorageRead,
     chain_config: &ChainConfig,
 ) -> Result<(), StorageCompatibilityCheckError> {
-    let storage_chain_type =
-        storage.get_chain_type().map_err(StorageCompatibilityCheckError::StorageError)?;
+    let storage_chain_type = storage
+        .get_chain_type()
+        .map_err(StorageCompatibilityCheckError::StorageError)?
+        .ok_or(StorageCompatibilityCheckError::ChainTypeMissing)?;
     let chain_config_type = chain_config.chain_type().name();
 
-    match storage_chain_type {
-        Some(storage_chain_type) => ensure!(
-            storage_chain_type == chain_config_type,
-            StorageCompatibilityCheckError::ChainTypeMismatch(
-                storage_chain_type,
-                chain_config_type.to_owned()
-            )
-        ),
-        None => storage
-            .set_chain_type(chain_config_type)
-            .map_err(StorageCompatibilityCheckError::StorageError)?,
-    };
+    ensure!(
+        storage_chain_type == chain_config_type,
+        StorageCompatibilityCheckError::ChainTypeMismatch(
+            storage_chain_type,
+            chain_config_type.to_owned()
+        )
+    );
 
     Ok(())
 }
diff --git a/chainstate/src/detail/error.rs b/chainstate/src/detail/error.rs
@@ -21,6 +21,7 @@ use super::{
         storage::TransactionVerifierStorageError,
     },
 };
+use chainstate_storage::ChainstateStorageVersion;
 use chainstate_types::{GetAncestorError, PropertyQueryError};
 use common::{
     chain::{
@@ -214,10 +215,18 @@ pub enum InitializationError {
 pub enum StorageCompatibilityCheckError {
     #[error("Block storage error: `{0}`")]
     StorageError(#[from] chainstate_storage::Error),
+    #[error("Storage version is missing in the db")]
+    StorageVersionMissing,
+    #[error("Failed to convert storage error")]
+    StorageVersionConversionError,
+    #[error("Magic bytes are missing in the db")]
+    MagicBytesMissing,
+    #[error("Chain type is missing in the db")]
+    ChainTypeMissing,
     #[error(
-        "Node cannot load chainstate database because the versions mismatch: db `{0}`, app `{1}`"
+        "Node cannot load chainstate database because the versions mismatch: db `{0:?}`, app `{1:?}`"
     )]
-    ChainstateStorageVersionMismatch(u32, u32),
+    ChainstateStorageVersionMismatch(ChainstateStorageVersion, ChainstateStorageVersion),
     #[error(
         "Chain's config magic bytes do not match the one from database : expected `{0:?}`, actual `{1:?}`"
     )]
diff --git a/chainstate/storage/src/internal/mod.rs b/chainstate/storage/src/internal/mod.rs
@@ -22,8 +22,8 @@ use common::{
         config::EpochIndex,
         tokens::{TokenAuxiliaryData, TokenId},
         transaction::{Transaction, TxMainChainIndex, TxMainChainPosition},
-        AccountNonce, AccountType, Block, DelegationId, GenBlock, OutPointSourceId, PoolId,
-        UtxoOutPoint,
+        AccountNonce, AccountType, Block, ChainConfig, DelegationId, GenBlock, OutPointSourceId,
+        PoolId, UtxoOutPoint,
     },
     primitives::{Amount, BlockHeight, Id},
 };
@@ -42,12 +42,35 @@ use crate::{
 mod store_tx;
 pub use store_tx::{StoreTxRo, StoreTxRw};
 
+mod version;
+pub use version::ChainstateStorageVersion;
+
 /// Store for blockchain data, parametrized over the backend B
 pub struct Store<B: storage::Backend>(storage::Storage<B, Schema>);
 
 impl<B: storage::Backend> Store<B> {
     /// Create a new chainstate storage
-    pub fn new(backend: B) -> crate::Result<Self> {
+    pub fn new(backend: B, chain_config: &ChainConfig) -> crate::Result<Self> {
+        let mut storage = Self::from_backend(backend)?;
+
+        // Set defaults if missing
+
+        if storage.get_storage_version()?.is_none() {
+            storage.set_storage_version(ChainstateStorageVersion::CURRENT as u32)?;
+        }
+
+        if storage.get_magic_bytes()?.is_none() {
+            storage.set_magic_bytes(chain_config.magic_bytes())?;
+        }
+
+        if storage.get_chain_type()?.is_none() {
+            storage.set_chain_type(chain_config.chain_type().name())?;
+        }
+
+        Ok(storage)
+    }
+
+    fn from_backend(backend: B) -> crate::Result<Self> {
         let storage = Self(storage::Storage::new(backend).map_err(crate::Error::from)?);
         Ok(storage)
     }
@@ -146,7 +169,7 @@ impl<B: storage::Backend> Store<B> {
 impl<B: Default + storage::Backend> Store<B> {
     /// Create a default storage (mostly for testing, may want to remove this later)
     pub fn new_empty() -> crate::Result<Self> {
-        Self::new(B::default())
+        Self::from_backend(B::default())
     }
 }
 
@@ -201,7 +224,7 @@ macro_rules! delegate_to_transaction {
 
 impl<B: storage::Backend> BlockchainStorageRead for Store<B> {
     delegate_to_transaction! {
-        fn get_storage_version(&self) -> crate::Result<u32>;
+        fn get_storage_version(&self) -> crate::Result<Option<u32>>;
         fn get_magic_bytes(&self) -> crate::Result<Option<[u8; 4]>>;
         fn get_chain_type(&self) -> crate::Result<Option<String>>;
         fn get_best_block_id(&self) -> crate::Result<Option<Id<GenBlock>>>;
diff --git a/chainstate/storage/src/internal/store_tx.rs b/chainstate/storage/src/internal/store_tx.rs
@@ -79,8 +79,8 @@ macro_rules! impl_read_ops {
     ($TxType:ident) => {
         /// Blockchain data storage transaction
         impl<'st, B: storage::Backend> BlockchainStorageRead for $TxType<'st, B> {
-            fn get_storage_version(&self) -> crate::Result<u32> {
-                self.read_value::<well_known::StoreVersion>().map(|v| v.unwrap_or_default())
+            fn get_storage_version(&self) -> crate::Result<Option<u32>> {
+                self.read_value::<well_known::StoreVersion>()
             }
 
             fn get_magic_bytes(&self) -> crate::Result<Option<[u8; 4]>> {
diff --git a/chainstate/storage/src/internal/test.rs b/chainstate/storage/src/internal/test.rs
@@ -33,7 +33,7 @@ fn test_storage_get_default_version_in_tx() {
         let store = TestStore::new_empty().unwrap();
         let vtx = store.transaction_ro().unwrap().get_storage_version().unwrap();
         let vst = store.get_storage_version().unwrap();
-        assert_eq!(vtx, 0, "Default storage version wrong");
+        assert_eq!(vtx, None, "Default storage version wrong");
         assert_eq!(vtx, vst, "Transaction and non-transaction inconsistency");
     })
 }
@@ -73,9 +73,9 @@ fn test_storage_manipulation() {
     let mut store = TestStore::new_empty().unwrap();
 
     // Storage version manipulation
-    assert_eq!(store.get_storage_version(), Ok(0));
+    assert_eq!(store.get_storage_version(), Ok(None));
     assert_eq!(store.set_storage_version(2), Ok(()));
-    assert_eq!(store.get_storage_version(), Ok(2));
+    assert_eq!(store.get_storage_version(), Ok(Some(2)));
 
     // Store is now empty, the block is not there
     assert_eq!(store.get_block(block0.get_id()), Ok(None));
@@ -159,7 +159,7 @@ fn get_set_transactions() {
             let store = Store::clone(&store);
             utils::thread::spawn(move || {
                 let mut tx = store.transaction_rw(None).unwrap();
-                let v = tx.get_storage_version().unwrap();
+                let v = tx.get_storage_version().unwrap().unwrap();
                 tx.set_storage_version(v + 1).unwrap();
                 tx.commit().unwrap();
             })
@@ -168,16 +168,16 @@ fn get_set_transactions() {
             let store = Store::clone(&store);
             utils::thread::spawn(move || {
                 let tx = store.transaction_ro().unwrap();
-                let v1 = tx.get_storage_version().unwrap();
-                let v2 = tx.get_storage_version().unwrap();
+                let v1 = tx.get_storage_version().unwrap().unwrap();
+                let v2 = tx.get_storage_version().unwrap().unwrap();
                 assert!([2, 3].contains(&v1));
                 assert_eq!(v1, v2, "Version query in a transaction inconsistent");
             })
         };
 
         let _ = thr0.join();
         let _ = thr1.join();
-        assert_eq!(store.get_storage_version(), Ok(3));
+        assert_eq!(store.get_storage_version(), Ok(Some(3)));
     })
 }
 
@@ -193,7 +193,7 @@ fn test_storage_transactions() {
             let store = Store::clone(&store);
             utils::thread::spawn(move || {
                 let mut tx = store.transaction_rw(None).unwrap();
-                let v = tx.get_storage_version().unwrap();
+                let v = tx.get_storage_version().unwrap().unwrap();
                 tx.set_storage_version(v + 3).unwrap();
                 tx.commit().unwrap();
             })
@@ -202,15 +202,15 @@ fn test_storage_transactions() {
             let store = Store::clone(&store);
             utils::thread::spawn(move || {
                 let mut tx = store.transaction_rw(None).unwrap();
-                let v = tx.get_storage_version().unwrap();
+                let v = tx.get_storage_version().unwrap().unwrap();
                 tx.set_storage_version(v + 5).unwrap();
                 tx.commit().unwrap();
             })
         };
 
         let _ = thr0.join();
         let _ = thr1.join();
-        assert_eq!(store.get_storage_version(), Ok(10));
+        assert_eq!(store.get_storage_version(), Ok(Some(10)));
     })
 }
 
@@ -226,7 +226,7 @@ fn test_storage_transactions_with_result_check() {
             let store = Store::clone(&store);
             utils::thread::spawn(move || {
                 let mut tx = store.transaction_rw(None).unwrap();
-                let v = tx.get_storage_version().unwrap();
+                let v = tx.get_storage_version().unwrap().unwrap();
                 assert!(tx.set_storage_version(v + 3).is_ok());
                 assert!(tx.commit().is_ok());
             })
@@ -235,15 +235,15 @@ fn test_storage_transactions_with_result_check() {
             let store = Store::clone(&store);
             utils::thread::spawn(move || {
                 let mut tx = store.transaction_rw(None).unwrap();
-                let v = tx.get_storage_version().unwrap();
+                let v = tx.get_storage_version().unwrap().unwrap();
                 assert!(tx.set_storage_version(v + 5).is_ok());
                 assert!(tx.commit().is_ok());
             })
         };
 
         let _ = thr0.join();
         let _ = thr1.join();
-        assert_eq!(store.get_storage_version(), Ok(10));
+        assert_eq!(store.get_storage_version(), Ok(Some(10)));
     })
 }
 
diff --git a/chainstate/storage/src/internal/version.rs b/chainstate/storage/src/internal/version.rs
@@ -0,0 +1,32 @@
+// Copyright (c) 2023 RBB S.r.l
+// opensource@mintlayer.org
+// SPDX-License-Identifier: MIT
+// Licensed under the MIT License;
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// https://github.com/mintlayer/mintlayer-core/blob/master/LICENSE
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[repr(u32)]
+pub enum ChainstateStorageVersion {
+    // skipping 0 for historical reasons
+    V1 = 1,
+}
+
+impl ChainstateStorageVersion {
+    pub const CURRENT: Self = Self::V1;
+
+    pub fn new(value: u32) -> Option<Self> {
+        match value {
+            1 => Some(ChainstateStorageVersion::V1),
+            _ => None,
+        }
+    }
+}
diff --git a/chainstate/storage/src/lib.rs b/chainstate/storage/src/lib.rs
diff --git a/chainstate/storage/src/mock/mock_impl.rs b/chainstate/storage/src/mock/mock_impl.rs
diff --git a/chainstate/storage/src/mock/tests.rs b/chainstate/storage/src/mock/tests.rs
