Move chainstate storage init inside constructor

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(

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,62 @@ 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)?;
+
+    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(())
 }

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,16 @@ 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("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:?}`"
     )]

chainstate/storage/Cargo.toml

@@ -17,6 +17,8 @@ utxo = { path = '../../utxo' }
 
 mockall = { workspace = true, optional = true }
 
+parity-scale-codec.workspace = true
+
 [dev-dependencies]
 crypto = { path = '../../crypto' }
 test-utils = {path = '../../test-utils'}

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,38 @@ 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 storage = Self::from_backend(backend)?;
+
+        // Set defaults if missing
+        let mut db_tx = storage.transaction_rw(None)?;
+
+        if db_tx.get_storage_version()?.is_none() {
+            db_tx.set_storage_version(ChainstateStorageVersion::CURRENT)?;
+        }
+
+        if db_tx.get_magic_bytes()?.is_none() {
+            db_tx.set_magic_bytes(chain_config.magic_bytes())?;
+        }
+
+        if db_tx.get_chain_type()?.is_none() {
+            db_tx.set_chain_type(chain_config.chain_type().name())?;
+        }
+
+        db_tx.commit()?;
+
+        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 +172,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 +227,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<ChainstateStorageVersion>>;
         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>>>;
@@ -356,7 +382,7 @@ impl<B: storage::Backend> PoSAccountingStorageRead<SealedStorageTag> for Store<B
 
 impl<B: storage::Backend> BlockchainStorageWrite for Store<B> {
     delegate_to_transaction! {
-        fn set_storage_version(&mut self, version: u32) -> crate::Result<()>;
+        fn set_storage_version(&mut self, version: ChainstateStorageVersion) -> crate::Result<()>;
         fn set_magic_bytes(&mut self, bytes: &[u8; 4]) -> crate::Result<()>;
         fn set_chain_type(&mut self, chain: &str) -> crate::Result<()>;
         fn set_best_block_id(&mut self, id: &Id<GenBlock>) -> crate::Result<()>;

chainstate/storage/src/internal/store_tx.rs

@@ -37,11 +37,12 @@ use utxo::{Utxo, UtxosBlockUndo, UtxosStorageRead, UtxosStorageWrite};
 
 use crate::{
     schema::{self as db, Schema},
-    BlockchainStorageRead, BlockchainStorageWrite, SealedStorageTag, TipStorageTag,
+    BlockchainStorageRead, BlockchainStorageWrite, ChainstateStorageVersion, SealedStorageTag,
+    TipStorageTag,
 };
 
 mod well_known {
-    use super::{Codec, GenBlock, Id};
+    use super::{ChainstateStorageVersion, Codec, GenBlock, Id};
 
     /// Pre-defined database keys
     pub trait Entry {
@@ -61,7 +62,7 @@ mod well_known {
         };
     }
 
-    declare_entry!(StoreVersion: u32);
+    declare_entry!(StoreVersion: ChainstateStorageVersion);
     declare_entry!(BestBlockId: Id<GenBlock>);
     declare_entry!(UtxosBestBlockId: Id<GenBlock>);
     declare_entry!(TxIndexEnabled: bool);
@@ -79,8 +80,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<ChainstateStorageVersion>> {
+                self.read_value::<well_known::StoreVersion>()
             }
 
             fn get_magic_bytes(&self) -> crate::Result<Option<[u8; 4]>> {
@@ -394,7 +395,7 @@ impl_read_ops!(StoreTxRo);
 impl_read_ops!(StoreTxRw);
 
 impl<'st, B: storage::Backend> BlockchainStorageWrite for StoreTxRw<'st, B> {
-    fn set_storage_version(&mut self, version: u32) -> crate::Result<()> {
+    fn set_storage_version(&mut self, version: ChainstateStorageVersion) -> crate::Result<()> {
         self.write_value::<well_known::StoreVersion>(&version)
     }