refactor(GlobalState): Change constructors

Author: Sword-Smith

src/lib.rs

@@ -61,6 +61,7 @@ use models::blockchain::block::Block;
 use models::blockchain::shared::Hash;
 use models::peer::handshake_data::HandshakeData;
 use models::state::wallet::wallet_file::WalletFileContext;
+use models::state::GlobalState;
 use prelude::tasm_lib;
 use prelude::triton_vm;
 use prelude::twenty_first;
@@ -129,13 +130,10 @@ pub async fn initialize(cli_args: cli_args::Args) -> Result<MainLoopHandler> {
     let (rpc_server_to_main_tx, rpc_server_to_main_rx) =
         mpsc::channel::<RPCServerToMain>(RPC_CHANNEL_CAPACITY);
     let genesis = Block::genesis(cli_args.network);
-    let mut global_state_lock = GlobalStateLock::new(
-        data_directory.clone(),
-        genesis,
-        cli_args.clone(),
-        rpc_server_to_main_tx.clone(),
-    )
-    .await?;
+    let global_state =
+        GlobalState::try_new(data_directory.clone(), genesis, cli_args.clone()).await?;
+    let mut global_state_lock =
+        GlobalStateLock::from_global_state(global_state, rpc_server_to_main_tx.clone());
 
     // Construct the broadcast channel to communicate from the main task to peer tasks
     let (main_to_peer_broadcast_tx, _main_to_peer_broadcast_rx) =

src/models/state/mod.rs

@@ -166,83 +166,24 @@ pub struct GlobalStateLock {
 }
 
 impl GlobalStateLock {
-    pub(crate) fn new_internal(
-        wallet_state: WalletState,
-        chain: BlockchainState,
-        net: NetworkingState,
-        cli: cli_args::Args,
-        mempool: Mempool,
+    pub(crate) fn from_global_state(
+        global_state: GlobalState,
         rpc_server_to_main_tx: tokio::sync::mpsc::Sender<RPCServerToMain>,
     ) -> Self {
-        let global_state = GlobalState::new(wallet_state, chain, net, cli.clone(), mempool);
+        let cli = global_state.cli.clone();
         let global_state_lock = sync_tokio::AtomicRw::from((
             global_state,
             Some("GlobalState"),
             Some(crate::LOG_TOKIO_LOCK_EVENT_CB),
         ));
+
         Self {
             global_state_lock,
             cli,
             rpc_server_to_main_tx,
         }
     }
 
-    /// the key to the watery kingdom.
-    pub async fn new(
-        data_directory: DataDirectory,
-        genesis: Block,
-        cli_args: cli_args::Args,
-        rpc_server_to_main_tx: tokio::sync::mpsc::Sender<RPCServerToMain>,
-    ) -> Result<Self> {
-        // Get wallet object, create various wallet secret files
-        let wallet_dir = data_directory.wallet_directory_path();
-        DataDirectory::create_dir_if_not_exists(&wallet_dir).await?;
-        let wallet_file_context =
-            WalletFileContext::read_from_file_or_create(&data_directory.wallet_directory_path())?;
-        debug!("Now getting wallet state. This may take a while if the database needs pruning.");
-        let wallet_state = WalletState::try_new_from_context(
-            &data_directory,
-            wallet_file_context,
-            &cli_args,
-            &genesis,
-        )
-        .await?;
-        debug!("Got wallet state.");
-
-        let archival_state = ArchivalState::new(data_directory.clone(), genesis).await;
-        debug!("Got archival state");
-
-        // Get latest block. Use hardcoded genesis block if nothing is in database.
-        let latest_block: Block = archival_state.get_tip().await;
-
-        let peer_map: HashMap<SocketAddr, PeerInfo> = HashMap::new();
-        let peer_databases = NetworkingState::initialize_peer_databases(&data_directory).await?;
-        debug!("Got peer databases");
-
-        let networking_state = NetworkingState::new(peer_map, peer_databases);
-
-        let light_state: LightState = LightState::from(latest_block);
-        let blockchain_archival_state = BlockchainArchivalState {
-            light_state,
-            archival_state,
-        };
-        let blockchain_state = BlockchainState::Archival(Box::new(blockchain_archival_state));
-        let mempool = Mempool::new(
-            cli_args.max_mempool_size,
-            cli_args.max_mempool_num_tx,
-            blockchain_state.light_state().hash(),
-        );
-
-        Ok(GlobalStateLock::new_internal(
-            wallet_state,
-            blockchain_state,
-            networking_state,
-            cli_args,
-            mempool,
-            rpc_server_to_main_tx.clone(),
-        ))
-    }
-
     // check if mining
     pub async fn mining(&self) -> bool {
         self.lock(|s| match s.mining_state.mining_status {
@@ -676,6 +617,49 @@ impl Drop for GlobalState {
 }
 
 impl GlobalState {
+    pub(crate) async fn try_new(
+        data_directory: DataDirectory,
+        genesis: Block,
+        cli: cli_args::Args,
+    ) -> Result<Self> {
+        // Get wallet object, create various wallet secret files
+        let wallet_dir = data_directory.wallet_directory_path();
+        DataDirectory::create_dir_if_not_exists(&wallet_dir).await?;
+        let wallet_file_context =
+            WalletFileContext::read_from_file_or_create(&data_directory.wallet_directory_path())?;
+        debug!("Now getting wallet state. This may take a while if the database needs pruning.");
+        let wallet_state =
+            WalletState::try_new_from_context(&data_directory, wallet_file_context, &cli, &genesis)
+                .await?;
+        debug!("Got wallet state.");
+
+        let archival_state = ArchivalState::new(data_directory.clone(), genesis).await;
+        debug!("Got archival state");
+
+        // Get latest block. Use hardcoded genesis block if nothing is in database.
+        let latest_block: Block = archival_state.get_tip().await;
+
+        let peer_map: HashMap<SocketAddr, PeerInfo> = HashMap::new();
+        let peer_databases = NetworkingState::initialize_peer_databases(&data_directory).await?;
+        debug!("Got peer databases");
+
+        let net = NetworkingState::new(peer_map, peer_databases);
+
+        let light_state: LightState = LightState::from(latest_block);
+        let chain = BlockchainArchivalState {
+            light_state,
+            archival_state,
+        };
+        let chain = BlockchainState::Archival(Box::new(chain));
+        let mempool = Mempool::new(
+            cli.max_mempool_size,
+            cli.max_mempool_num_tx,
+            chain.light_state().hash(),
+        );
+
+        Ok(Self::new(wallet_state, chain, net, cli, mempool))
+    }
+
     pub fn new(
         wallet_state: WalletState,
         chain: BlockchainState,

src/tests/shared.rs

@@ -103,6 +103,7 @@ use crate::models::state::wallet::expected_utxo::UtxoNotifier;
 use crate::models::state::wallet::transaction_output::TxOutputList;
 use crate::models::state::wallet::wallet_entropy::WalletEntropy;
 use crate::models::state::wallet::wallet_state::WalletState;
+use crate::models::state::GlobalState;
 use crate::models::state::GlobalStateLock;
 use crate::prelude::twenty_first;
 use crate::triton_vm_job_queue::TritonVmJobQueue;
@@ -203,14 +204,14 @@ pub(crate) async fn mock_genesis_global_state_with_block(
             std::net::SocketAddr::from_str(&format!("123.123.123.{}:8080", i)).unwrap();
         peer_map.insert(peer_address, get_dummy_peer_outgoing(peer_address));
     }
-    let networking_state = NetworkingState::new(peer_map, peer_db);
+    let net = NetworkingState::new(peer_map, peer_db);
 
     // Sanity check
     assert_eq!(archival_state.genesis_block().hash(), genesis_block.hash());
     assert_eq!(archival_state.get_tip().await.hash(), genesis_block.hash());
 
     let light_state: LightState = LightState::from(genesis_block.to_owned());
-    let blockchain_state = BlockchainState::Archival(Box::new(BlockchainArchivalState {
+    let chain = BlockchainState::Archival(Box::new(BlockchainArchivalState {
         light_state,
         archival_state,
     }));
@@ -230,14 +231,9 @@ pub(crate) async fn mock_genesis_global_state_with_block(
         }
     });
 
-    GlobalStateLock::new_internal(
-        wallet_state,
-        blockchain_state,
-        networking_state,
-        cli.clone(),
-        mempool,
-        rpc_to_main_tx,
-    )
+    let global_state = GlobalState::new(wallet_state, chain, net, cli, mempool);
+
+    GlobalStateLock::from_global_state(global_state, rpc_to_main_tx)
 }
 
 /// Get a global state object for unit test purposes. This global state is