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

@@ -14,9 +14,9 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrdering};
+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering as AtomicOrdering};
 use std::sync::{Arc, Weak};
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use cio::IoChannel;
 use ckey::{Address, PlatformAddress, Public};
@@ -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,10 @@ pub struct Client {
     genesis_accounts: Vec<Address>,
 
     importer: Importer,
+
+    reseal_timer: RwLock<Option<TimerApi>>,
+
+    timer_set: AtomicBool,
 }
 
 impl Client {
@@ -121,13 +127,19 @@ impl Client {
             queue_parcels: AtomicUsize::new(0),
             genesis_accounts,
             importer,
+            reseal_timer: RwLock::new(None),
+            timer_set: AtomicBool::new(false),
         });
 
         // 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 +272,40 @@ impl Client {
     }
 }
 
+const RESEAL_TIMER_TOKEN: TimerToken = 0;
+
+impl TimeoutHandler for Client {
+    fn on_timeout(&self, token: TimerToken) {
+        match token {
+            RESEAL_TIMER_TOKEN => {
+                self.timer_set.store(false, AtomicOrdering::Relaxed);
+                if !self.ready_parcels().is_empty() {
+                    self.update_sealing();
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl ResealTimer for Client {
+    fn register_timer(&self, timer: TimerApi) {
+        *self.reseal_timer.write() = Some(timer);
+    }
+
+    fn set_timer(&self, duration: Duration) {
+        if let Some(reseal_timer) = self.reseal_timer.read().as_ref() {
+            reseal_timer.cancel(RESEAL_TIMER_TOKEN).expect("Timer clear succeeds");
+            reseal_timer.schedule_once(duration, RESEAL_TIMER_TOKEN).expect("Timer set succeeds");
+            self.timer_set.store(true, AtomicOrdering::Relaxed);
+        };
+    }
+
+    fn is_timer_set(&self) -> bool {
+        self.timer_set.load(AtomicOrdering::Relaxed)
+    }
+}
+
 impl DatabaseClient for Client {
     fn database(&self) -> Arc<KeyValueDB> {
         Arc::clone(&self.db())

core/src/client/mod.rs

@@ -30,11 +30,13 @@ pub use self::error::Error;
 pub use self::test_client::TestBlockChainClient;
 
 use std::sync::Arc;
+use std::time::Duration;
 
 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 +185,12 @@ pub trait Shard {
     fn shard_root(&self, shard_id: ShardId, state: StateOrBlock) -> Option<H256>;
 }
 
+pub trait ResealTimer {
+    fn register_timer(&self, timer: TimerApi);
+    fn set_timer(&self, duration: Duration);
+    fn is_timer_set(&self) -> bool;
+}
+
 /// Provides methods to access account info
 pub trait AccountData: Seq + Balance {}
 
@@ -200,7 +208,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

@@ -34,11 +34,13 @@ use std::collections::HashMap;
 use std::mem;
 use std::sync::atomic::{AtomicUsize, Ordering as AtomicOrder};
 use std::sync::Arc;
+use std::time::Duration;
 
 use ckey::{public_to_address, Address, Generator, NetworkId, PlatformAddress, Random};
 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 +57,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 +531,20 @@ 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_timer(&self, _duration: Duration) {}
+
+    fn is_timer_set(&self) -> bool {
+        false
+    }
+}
+
 impl ChainTimeInfo for TestBlockChainClient {
     fn best_block_number(&self) -> u64 {
         0

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;
@@ -178,7 +179,7 @@ impl Miner {
     }
 
     /// Check is reseal is allowed and necessary.
-    fn requires_reseal(&self, best_block: BlockNumber) -> bool {
+    fn requires_reseal<C: ResealTimer>(&self, reseal_timer: &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 {
@@ -205,6 +206,7 @@ impl Miner {
                 false
             } else {
                 // sealing enabled and we don't want to sleep.
+                reseal_timer.set_timer(self.options.reseal_max_period);
                 *self.next_allowed_reseal.lock() = Instant::now() + self.options.reseal_min_period;
                 true
             }
@@ -706,10 +708,11 @@ impl MinerService for Miner {
 
     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) => {
@@ -791,6 +794,8 @@ impl MinerService for Miner {
             // | Make sure to release the locks before calling that method.     |
             // ------------------------------------------------------------------
             self.update_sealing(client);
+        } else if self.parcel_reseal_allowed() && !client.is_timer_set() {
+            client.set_timer(self.options.reseal_max_period);
         }
         results
     }
@@ -836,6 +841,8 @@ impl MinerService for Miner {
             // or Engine might be able to seal internally,
             // we need to update sealing.
             self.update_sealing(chain);
+        } else if self.parcel_reseal_allowed() && !chain.is_timer_set() {
+            chain.set_timer(self.options.reseal_max_period);
         }
         imported
     }

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;
@@ -82,7 +83,7 @@ pub trait MinerService: Send + Sync {
     /// 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.