Add reseal timer to client

Hyunsik Jeong · Hyunsik Jeong · commit 54a2c5e0625e · 2018-12-11T12:36:46.000+09:00
diff --git a/codechain/run_node.rs b/codechain/run_node.rs
@@ -86,14 +86,22 @@ fn discovery_start(service: &NetworkService, cfg: &config::Network) -> Result<()
     Ok(())
 }
 
-fn client_start(cfg: &config::Operating, scheme: &Scheme, miner: Arc<Miner>) -> Result<ClientService, String> {
+fn client_start(
+    timer_loop: &TimerLoop,
+    cfg: &config::Operating,
+    scheme: &Scheme,
+    miner: Arc<Miner>,
+) -> Result<ClientService, String> {
     cinfo!(CLIENT, "Starting client");
     let db_path = cfg.db_path.as_ref().map(|s| s.as_str()).unwrap();
     let client_path = Path::new(db_path);
     let client_config = Default::default();
     let service = ClientService::start(&client_config, &scheme, &client_path, miner)
         .map_err(|e| format!("Client service error: {}", e))?;
 
+    let reseal_timer = timer_loop.new_timer("Client reseal timer", service.client());
+    service.client().register_reseal_timer(reseal_timer);
+
     Ok(service)
 }
 
@@ -229,7 +237,7 @@ pub fn run_node(matches: &ArgMatches) -> Result<(), String> {
     unlock_accounts(&*ap, &pf)?;
 
     let miner = new_miner(&config, &scheme, ap.clone())?;
-    let client = client_start(&config.operating, &scheme, miner.clone())?;
+    let client = client_start(&timer_loop, &config.operating, &scheme, miner.clone())?;
     let sync = BlockSyncExtension::new(client.client());
 
     scheme.engine.register_chain_notify(client.client().as_ref());
diff --git a/core/src/client/client.rs b/core/src/client/client.rs
@@ -25,6 +25,7 @@ use cnetwork::NodeId;
 use cstate::{
     ActionHandler, AssetScheme, AssetSchemeAddress, OwnedAsset, OwnedAssetAddress, StateDB, TopLevelState, TopStateView,
 };
+use ctimer::{TimeoutHandler, TimerApi, TimerToken};
 use ctypes::invoice::Invoice;
 use ctypes::transaction::Transaction;
 use ctypes::{BlockNumber, ShardId};
@@ -41,7 +42,8 @@ use super::{
     AccountData, AssetClient, Balance, BlockChain as BlockChainTrait, BlockChainClient, BlockChainInfo, BlockInfo,
     BlockProducer, ChainInfo, ChainNotify, ClientConfig, DatabaseClient, EngineClient, EngineInfo,
     Error as ClientError, ExecuteClient, ImportBlock, ImportResult, ImportSealedBlock, MiningBlockChainClient,
-    ParcelInfo, PrepareOpenBlock, RegularKey, RegularKeyOwner, ReopenBlock, Seq, Shard, StateOrBlock, TransactionInfo,
+    ParcelInfo, PrepareOpenBlock, RegularKey, RegularKeyOwner, ReopenBlock, ResealTimer, Seq, Shard, StateOrBlock,
+    TransactionInfo,
 };
 use crate::block::{ClosedBlock, IsBlock, OpenBlock, SealedBlock};
 use crate::blockchain::{
@@ -79,6 +81,9 @@ pub struct Client {
     genesis_accounts: Vec<Address>,
 
     importer: Importer,
+
+    /// Timer for reseal_min_period/reseal_max_period on miner client
+    reseal_timer: RwLock<Option<TimerApi>>,
 }
 
 impl Client {
@@ -121,13 +126,18 @@ impl Client {
             queue_parcels: AtomicUsize::new(0),
             genesis_accounts,
             importer,
+            reseal_timer: RwLock::new(None),
         });
 
         // ensure buffered changes are flushed.
         client.db.read().flush().map_err(ClientError::Database)?;
         Ok(client)
     }
 
+    pub fn register_reseal_timer(&self, timer: TimerApi) {
+        self.register_timer(timer);
+    }
+
     /// Returns engine reference.
     pub fn engine(&self) -> &CodeChainEngine {
         &*self.engine
@@ -260,6 +270,58 @@ impl Client {
     }
 }
 
+const RESEAL_MAX_TIMER_TOKEN: TimerToken = 0;
+const RESEAL_MIN_TIMER_TOKEN: TimerToken = 1;
+
+impl TimeoutHandler for Client {
+    fn on_timeout(&self, token: TimerToken) {
+        match token {
+            RESEAL_MAX_TIMER_TOKEN => {
+                // Working in PoW only
+                if self.engine().seals_internally().is_none() && !self.importer.miner.prepare_work_sealing(self) {
+                    self.update_sealing();
+                }
+            }
+            RESEAL_MIN_TIMER_TOKEN => {
+                if let Some(reseal_timer) = self.reseal_timer.read().as_ref() {
+                    reseal_timer.cancel(RESEAL_MAX_TIMER_TOKEN).expect("Reseal max timer clear succeeds");
+                };
+                if !self.ready_parcels().is_empty() {
+                    self.update_sealing();
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl ResealTimer for Client {
+    fn register_timer(&self, timer: TimerApi) {
+        timer
+            .schedule_once(self.importer.miner.get_options().reseal_max_period, RESEAL_MAX_TIMER_TOKEN)
+            .expect("Reseal max timer set succeeds");
+        *self.reseal_timer.write() = Some(timer);
+    }
+
+    fn set_max_timer(&self) {
+        if let Some(reseal_timer) = self.reseal_timer.read().as_ref() {
+            reseal_timer.cancel(RESEAL_MAX_TIMER_TOKEN).expect("Reseal max timer clear succeeds");
+            reseal_timer
+                .schedule_once(self.importer.miner.get_options().reseal_max_period, RESEAL_MAX_TIMER_TOKEN)
+                .expect("Reseal max timer set succeeds");
+        };
+    }
+
+    fn set_min_timer(&self) {
+        if let Some(reseal_timer) = self.reseal_timer.read().as_ref() {
+            reseal_timer.cancel(RESEAL_MIN_TIMER_TOKEN).expect("Reseal min timer clear succeeds");
+            reseal_timer
+                .schedule_once(self.importer.miner.get_options().reseal_min_period, RESEAL_MIN_TIMER_TOKEN)
+                .expect("Reseal min timer set succeeds");
+        };
+    }
+}
+
 impl DatabaseClient for Client {
     fn database(&self) -> Arc<KeyValueDB> {
         Arc::clone(&self.db())
diff --git a/core/src/client/mod.rs b/core/src/client/mod.rs
@@ -35,6 +35,7 @@ use ckey::{Address, PlatformAddress, Public};
 use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{ActionHandler, AssetScheme, AssetSchemeAddress, OwnedAsset, TopStateView};
+use ctimer::TimerApi;
 use ctypes::invoice::Invoice;
 use ctypes::transaction::Transaction;
 use ctypes::{BlockNumber, ShardId};
@@ -183,6 +184,16 @@ pub trait Shard {
     fn shard_root(&self, shard_id: ShardId, state: StateOrBlock) -> Option<H256>;
 }
 
+/// Provides a timer API for reseal_min_period/reseal_max_period on miner client
+pub trait ResealTimer {
+    /// Register timer API
+    fn register_timer(&self, timer: TimerApi);
+    /// Set reseal min timer as reseal_min_period, for creating blocks with parcels which are pending because of reseal_min_period
+    fn set_min_timer(&self);
+    /// Set reseal max timer as reseal_max_period, for creating empty blocks every reseal_max_period
+    fn set_max_timer(&self);
+}
+
 /// Provides methods to access account info
 pub trait AccountData: Seq + Balance {}
 
@@ -200,7 +211,7 @@ pub trait BlockChain: ChainInfo + BlockInfo + ParcelInfo + TransactionInfo {}
 
 /// Blockchain database client. Owns and manages a blockchain and a block queue.
 pub trait BlockChainClient:
-    Sync + Send + AccountData + BlockChain + ImportBlock + RegularKeyOwner + ChainTimeInfo {
+    Sync + Send + AccountData + BlockChain + ImportBlock + RegularKeyOwner + ChainTimeInfo + ResealTimer {
     /// Get block queue information.
     fn queue_info(&self) -> BlockQueueInfo;
 
diff --git a/core/src/client/test_client.rs b/core/src/client/test_client.rs
@@ -39,6 +39,7 @@ use ckey::{public_to_address, Address, Generator, NetworkId, PlatformAddress, Ra
 use cmerkle::skewed_merkle_root;
 use cnetwork::NodeId;
 use cstate::{ActionHandler, StateDB};
+use ctimer::{TimeoutHandler, TimerApi, TimerToken};
 use ctypes::invoice::Invoice;
 use ctypes::parcel::{Action, Parcel};
 use ctypes::transaction::Transaction;
@@ -55,8 +56,8 @@ use crate::blockchain_info::BlockChainInfo;
 use crate::client::ImportResult;
 use crate::client::{
     AccountData, Balance, BlockChain, BlockChainClient, BlockInfo, BlockProducer, BlockStatus, ChainInfo, ImportBlock,
-    ImportSealedBlock, MiningBlockChainClient, ParcelInfo, PrepareOpenBlock, RegularKeyOwner, ReopenBlock, Seq,
-    StateOrBlock, TransactionInfo,
+    ImportSealedBlock, MiningBlockChainClient, ParcelInfo, PrepareOpenBlock, RegularKeyOwner, ReopenBlock, ResealTimer,
+    Seq, StateOrBlock, TransactionInfo,
 };
 use crate::db::{COL_STATE, NUM_COLUMNS};
 use crate::encoded;
@@ -529,6 +530,18 @@ impl BlockChainClient for TestBlockChainClient {
     }
 }
 
+impl TimeoutHandler for TestBlockChainClient {
+    fn on_timeout(&self, _token: TimerToken) {}
+}
+
+impl ResealTimer for TestBlockChainClient {
+    fn register_timer(&self, _timer: TimerApi) {}
+
+    fn set_max_timer(&self) {}
+
+    fn set_min_timer(&self) {}
+}
+
 impl ChainTimeInfo for TestBlockChainClient {
     fn best_block_number(&self) -> u64 {
         0
diff --git a/core/src/miner/miner.rs b/core/src/miner/miner.rs
@@ -37,6 +37,7 @@ use crate::account_provider::{AccountProvider, SignError};
 use crate::block::{Block, ClosedBlock, IsBlock};
 use crate::client::{
     AccountData, BlockChain, BlockProducer, ImportSealedBlock, MiningBlockChainClient, RegularKey, RegularKeyOwner,
+    ResealTimer,
 };
 use crate::consensus::{CodeChainEngine, EngineType};
 use crate::error::Error;
@@ -177,8 +178,12 @@ impl Miner {
         self.map_pending_block(|b| b.header().clone(), latest_block_number)
     }
 
+    pub fn get_options(&self) -> &MinerOptions {
+        &self.options
+    }
+
     /// Check is reseal is allowed and necessary.
-    fn requires_reseal(&self, best_block: BlockNumber) -> bool {
+    fn requires_reseal<C: ResealTimer>(&self, client: &C, best_block: BlockNumber) -> bool {
         let has_local_parcels = self.mem_pool.read().has_local_pending_parcels();
         let mut sealing_work = self.sealing_work.lock();
         if sealing_work.enabled {
@@ -206,6 +211,7 @@ impl Miner {
             } else {
                 // sealing enabled and we don't want to sleep.
                 *self.next_allowed_reseal.lock() = Instant::now() + self.options.reseal_min_period;
+                client.set_min_timer();
                 true
             }
         } else {
@@ -343,53 +349,6 @@ impl Miner {
         })
     }
 
-    /// Returns true if we had to prepare new pending block.
-    fn prepare_work_sealing<C: AccountData + BlockChain + BlockProducer + RegularKeyOwner + ChainTimeInfo>(
-        &self,
-        client: &C,
-    ) -> bool {
-        ctrace!(MINER, "prepare_work_sealing: entering");
-        let prepare_new = {
-            let mut sealing_work = self.sealing_work.lock();
-            let have_work = sealing_work.queue.peek_last_ref().is_some();
-            ctrace!(MINER, "prepare_work_sealing: have_work={}", have_work);
-            if !have_work {
-                sealing_work.enabled = true;
-                true
-            } else {
-                false
-            }
-        };
-        if prepare_new {
-            // --------------------------------------------------------------------------
-            // | NOTE Code below requires transaction_queue and sealing_work locks.     |
-            // | Make sure to release the locks before calling that method.             |
-            // --------------------------------------------------------------------------
-            match self.prepare_block(client) {
-                Ok((block, original_work_hash)) => {
-                    self.prepare_work(block, original_work_hash);
-                }
-                Err(err) => {
-                    ctrace!(MINER, "prepare_work_sealing: cannot prepare block: {:?}", err);
-                }
-            }
-        }
-        let mut sealing_block_last_request = self.sealing_block_last_request.lock();
-        let best_number = client.chain_info().best_block_number;
-        if *sealing_block_last_request != best_number {
-            ctrace!(
-                MINER,
-                "prepare_work_sealing: Miner received request (was {}, now {}) - waking up.",
-                *sealing_block_last_request,
-                best_number
-            );
-            *sealing_block_last_request = best_number;
-        }
-
-        // Return if we restarted
-        prepare_new
-    }
-
     /// Prepares work which has to be done to seal.
     fn prepare_work(&self, block: ClosedBlock, original_work_hash: Option<H256>) {
         let (work, is_new) = {
@@ -704,12 +663,59 @@ impl MinerService for Miner {
         self.engine.engine_type()
     }
 
+    fn prepare_work_sealing<C: AccountData + BlockChain + BlockProducer + RegularKeyOwner + ChainTimeInfo>(
+        &self,
+        client: &C,
+    ) -> bool {
+        ctrace!(MINER, "prepare_work_sealing: entering");
+        let prepare_new = {
+            let mut sealing_work = self.sealing_work.lock();
+            let have_work = sealing_work.queue.peek_last_ref().is_some();
+            ctrace!(MINER, "prepare_work_sealing: have_work={}", have_work);
+            if !have_work {
+                sealing_work.enabled = true;
+                true
+            } else {
+                false
+            }
+        };
+        if prepare_new {
+            // --------------------------------------------------------------------------
+            // | NOTE Code below requires transaction_queue and sealing_work locks.     |
+            // | Make sure to release the locks before calling that method.             |
+            // --------------------------------------------------------------------------
+            match self.prepare_block(client) {
+                Ok((block, original_work_hash)) => {
+                    self.prepare_work(block, original_work_hash);
+                }
+                Err(err) => {
+                    ctrace!(MINER, "prepare_work_sealing: cannot prepare block: {:?}", err);
+                }
+            }
+        }
+        let mut sealing_block_last_request = self.sealing_block_last_request.lock();
+        let best_number = client.chain_info().best_block_number;
+        if *sealing_block_last_request != best_number {
+            ctrace!(
+                MINER,
+                "prepare_work_sealing: Miner received request (was {}, now {}) - waking up.",
+                *sealing_block_last_request,
+                best_number
+            );
+            *sealing_block_last_request = best_number;
+        }
+
+        // Return if we restarted
+        prepare_new
+    }
+
     fn update_sealing<C>(&self, chain: &C)
     where
-        C: AccountData + BlockChain + BlockProducer + ImportSealedBlock + RegularKeyOwner + ChainTimeInfo, {
+        C: AccountData + BlockChain + BlockProducer + ImportSealedBlock + RegularKeyOwner + ResealTimer + ChainTimeInfo,
+    {
         ctrace!(MINER, "update_sealing: preparing a block");
 
-        if self.requires_reseal(chain.chain_info().best_block_number) {
+        if self.requires_reseal(chain, chain.chain_info().best_block_number) {
             let (block, original_work_hash) = match self.prepare_block(chain) {
                 Ok((block, original_work_hash)) => (block, original_work_hash),
                 Err(err) => {
@@ -728,7 +734,10 @@ impl MinerService for Miner {
                 Some(false) => ctrace!(MINER, "update_sealing: engine is not keen to seal internally right now"),
                 None => {
                     ctrace!(MINER, "update_sealing: engine does not seal internally, preparing work");
-                    self.prepare_work(block, original_work_hash)
+                    self.prepare_work(block, original_work_hash);
+                    // Set the reseal max timer, for creating empty blocks every reseal_max_period
+                    // Not related to next_mandatory_reseal, which is used in seal_and_import_block_internally
+                    chain.set_max_timer();
                 }
             }
         }
diff --git a/core/src/miner/mod.rs b/core/src/miner/mod.rs
@@ -34,6 +34,7 @@ use crate::account_provider::{AccountProvider, SignError};
 use crate::block::ClosedBlock;
 use crate::client::{
     AccountData, BlockChain, BlockProducer, ImportSealedBlock, MiningBlockChainClient, RegularKey, RegularKeyOwner,
+    ResealTimer,
 };
 use crate::consensus::EngineType;
 use crate::error::Error;
@@ -79,10 +80,15 @@ pub trait MinerService: Send + Sync {
     /// Get the type of consensus engine.
     fn engine_type(&self) -> EngineType;
 
+    /// Returns true if we had to prepare new pending block.
+    fn prepare_work_sealing<C>(&self, &C) -> bool
+    where
+        C: AccountData + BlockChain + BlockProducer + RegularKeyOwner + ChainTimeInfo;
+
     /// New chain head event. Restart mining operation.
     fn update_sealing<C>(&self, chain: &C)
     where
-        C: AccountData + BlockChain + BlockProducer + ImportSealedBlock + RegularKeyOwner + ChainTimeInfo;
+        C: AccountData + BlockChain + BlockProducer + ImportSealedBlock + RegularKeyOwner + ResealTimer + ChainTimeInfo;
 
     /// Submit `seal` as a valid solution for the header of `pow_hash`.
     /// Will check the seal, but not actually insert the block into the chain.
