Add reseal timer to client

Author: Hyunsik Jeong

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());

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,60 @@ 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(true);
+                }
+            }
+            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");
+                };
+
+                // Checking self.ready_parcels() for efficiency
+                if !self.ready_parcels().is_empty() {
+                    self.update_sealing(false);
+                }
+            }
+            _ => 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())
@@ -367,8 +431,8 @@ impl EngineInfo for Client {
 
 impl EngineClient for Client {
     /// Make a new block and seal it.
-    fn update_sealing(&self) {
-        self.importer.miner.update_sealing(self)
+    fn update_sealing(&self, allow_empty_block: bool) {
+        self.importer.miner.update_sealing(self, allow_empty_block)
     }
 
     /// Submit a seal for a block in the mining queue.

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};
@@ -101,7 +102,7 @@ pub trait EngineInfo: Send + Sync {
 /// Client facilities used by internally sealing Engines.
 pub trait EngineClient: Sync + Send + ChainInfo + ImportBlock + BlockInfo {
     /// Make a new block and seal it.
-    fn update_sealing(&self);
+    fn update_sealing(&self, allow_empty_block: bool);
 
     /// Submit a seal for a block in the mining queue.
     fn submit_seal(&self, block_hash: H256, seal: Vec<Bytes>);
@@ -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;
 

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
@@ -548,8 +561,8 @@ impl ChainTimeInfo for TestBlockChainClient {
 }
 
 impl super::EngineClient for TestBlockChainClient {
-    fn update_sealing(&self) {
-        self.miner.update_sealing(self)
+    fn update_sealing(&self, allow_empty_block: bool) {
+        self.miner.update_sealing(self, allow_empty_block)
     }
 
     fn submit_seal(&self, block_hash: H256, seal: Vec<Bytes>) {

core/src/consensus/tendermint/mod.rs

@@ -256,7 +256,7 @@ impl Tendermint {
     fn update_sealing(&self) {
         if let Some(ref weak) = *self.client.read() {
             if let Some(c) = weak.upgrade() {
-                c.update_sealing();
+                c.update_sealing(true);
             }
         }
     }