Refactor Timer

codechain/run_node.rs

@@ -92,11 +92,10 @@ fn client_start(
     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)
+    let reseal_timer = timer_loop.new_timer("Client reseal timer");
+    let service = ClientService::start(&client_config, &scheme, &client_path, miner, reseal_timer.clone())
         .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);
+    reseal_timer.set_handler(&service.client());
 
     Ok(service)
 }

core/src/client/client.rs

@@ -84,7 +84,7 @@ pub struct Client {
     importer: Importer,
 
     /// Timer for reseal_min_period/reseal_max_period on miner client
-    reseal_timer: RwLock<Option<TimerApi>>,
+    reseal_timer: TimerApi,
 }
 
 impl Client {
@@ -94,6 +94,7 @@ impl Client {
         db: Arc<KeyValueDB>,
         miner: Arc<Miner>,
         message_channel: IoChannel<ClientIoMessage>,
+        reseal_timer: TimerApi,
     ) -> Result<Arc<Client>, Error> {
         let journal_db = journaldb::new(Arc::clone(&db), journaldb::Algorithm::Archive, ::db::COL_STATE);
         let mut state_db = StateDB::new(journal_db);
@@ -127,18 +128,14 @@ impl Client {
             queue_transactions: AtomicUsize::new(0),
             genesis_accounts,
             importer,
-            reseal_timer: RwLock::new(None),
+            reseal_timer,
         });
 
         // ensure buffered changes are flushed.
         client.db.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
@@ -279,38 +276,32 @@ impl TimeoutHandler for Client {
 }
 
 impl ResealTimer for Client {
-    fn register_timer(&self, timer: TimerApi) {
-        *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");
-            match reseal_timer
-                .schedule_once(self.importer.miner.get_options().reseal_max_period, RESEAL_MAX_TIMER_TOKEN)
-            {
-                Ok(_) => {}
-                Err(TimerScheduleError::TokenAlreadyScheduled) => {
-                    // Since set_max_timer could be called in multi thread, ignore the TokenAlreadyScheduled error
-                }
-                Err(err) => unreachable!("Reseal max timer should not fail but failed with {:?}", err),
+        self.reseal_timer.cancel(RESEAL_MAX_TIMER_TOKEN).expect("Reseal max timer clear succeeds");
+        match self
+            .reseal_timer
+            .schedule_once(self.importer.miner.get_options().reseal_max_period, RESEAL_MAX_TIMER_TOKEN)
+        {
+            Ok(_) => {}
+            Err(TimerScheduleError::TokenAlreadyScheduled) => {
+                // Since set_max_timer could be called in multi thread, ignore the TokenAlreadyScheduled error
             }
-        };
+            Err(err) => unreachable!("Reseal max timer should not fail but failed with {:?}", err),
+        }
     }
 
     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");
-            match reseal_timer
-                .schedule_once(self.importer.miner.get_options().reseal_min_period, RESEAL_MIN_TIMER_TOKEN)
-            {
-                Ok(_) => {}
-                Err(TimerScheduleError::TokenAlreadyScheduled) => {
-                    // Since set_min_timer could be called in multi thread, ignore the TokenAlreadyScheduled error
-                }
-                Err(err) => unreachable!("Reseal min timer should not fail but failed with {:?}", err),
+        self.reseal_timer.cancel(RESEAL_MIN_TIMER_TOKEN).expect("Reseal min timer clear succeeds");
+        match self
+            .reseal_timer
+            .schedule_once(self.importer.miner.get_options().reseal_min_period, RESEAL_MIN_TIMER_TOKEN)
+        {
+            Ok(_) => {}
+            Err(TimerScheduleError::TokenAlreadyScheduled) => {
+                // Since set_min_timer could be called in multi thread, ignore the TokenAlreadyScheduled error
             }
-        };
+            Err(err) => unreachable!("Reseal min timer should not fail but failed with {:?}", err),
+        }
     }
 }
 

core/src/client/mod.rs

@@ -35,7 +35,6 @@ use ckey::{Address, PlatformAddress, Public};
 use cmerkle::Result as TrieResult;
 use cnetwork::NodeId;
 use cstate::{AssetScheme, AssetSchemeAddress, FindActionHandler, OwnedAsset, Text, TopLevelState, TopStateView};
-use ctimer::TimerApi;
 use ctypes::invoice::Invoice;
 use ctypes::transaction::{AssetTransferInput, PartialHashing, ShardTransaction};
 use ctypes::{BlockNumber, ShardId};
@@ -188,8 +187,6 @@ pub trait Shard {
 
 /// 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 transactions 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

core/src/client/test_client.rs

@@ -39,7 +39,7 @@ use ckey::{public_to_address, Address, Generator, NetworkId, PlatformAddress, Ra
 use cmerkle::skewed_merkle_root;
 use cnetwork::NodeId;
 use cstate::{FindActionHandler, StateDB};
-use ctimer::{TimeoutHandler, TimerApi, TimerToken};
+use ctimer::{TimeoutHandler, TimerToken};
 use ctypes::invoice::Invoice;
 use ctypes::transaction::{Action, Transaction};
 use ctypes::BlockNumber;
@@ -532,8 +532,6 @@ impl TimeoutHandler for TestBlockChainClient {
 }
 
 impl ResealTimer for TestBlockChainClient {
-    fn register_timer(&self, _timer: TimerApi) {}
-
     fn set_max_timer(&self) {}
 
     fn set_min_timer(&self) {}

core/src/service.rs

@@ -19,6 +19,7 @@ use std::sync::Arc;
 
 use cio::{IoContext, IoHandler, IoHandlerResult, IoService};
 use cnetwork::NodeId;
+use ctimer::TimerApi;
 use kvdb_rocksdb::{Database, DatabaseConfig};
 use primitives::Bytes;
 
@@ -40,6 +41,7 @@ impl ClientService {
         scheme: &Scheme,
         client_path: &Path,
         miner: Arc<Miner>,
+        reseal_timer: TimerApi,
     ) -> Result<ClientService, Error> {
         let io_service = IoService::<ClientIoMessage>::start("Client")?;
 
@@ -54,7 +56,7 @@ impl ClientService {
                 .map_err(::client::Error::Database)?,
         );
 
-        let client = Client::try_new(config, &scheme, db, miner, io_service.channel())?;
+        let client = Client::try_new(config, &scheme, db, miner, io_service.channel(), reseal_timer)?;
 
         let client_io = Arc::new(ClientIoHandler {
             client: client.clone(),

network/src/client.rs

@@ -124,12 +124,13 @@ impl Client {
         let name = extension.name();
         let mut extensions = self.extensions.write();
         let p2p_channel = self.p2p_channel.clone();
-        let timer = self.timer_loop.new_timer(name, Arc::clone(&extension));
+        let timer = self.timer_loop.new_timer(name);
         let api: Arc<Api> = Arc::new(ClientApi {
             extension: Arc::downgrade(&extension) as Weak<NetworkExtension>,
             p2p_channel,
-            timer,
+            timer: timer.clone(),
         });
+        timer.set_handler(&extension);
         extension.on_initialize(api);
         if extensions.insert(name, extension).is_some() {
             unreachable!("Duplicated extension name : {}", name)

util/logger/src/macros.rs

@@ -85,6 +85,9 @@ macro_rules! log_target {
     (TEST_SCRIPT) => {
         "test_script"
     };
+    (TIMER) => {
+        "timer"
+    };
     (TRIE) => {
         "trie"
     };

util/timer/Cargo.toml

@@ -7,3 +7,5 @@ authors = ["CodeChain Team <codechain@kodebox.io>"]
 
 [dependencies]
 parking_lot = "0.6.0"
+log = "0.4.6"
+codechain-logger = { path = "../logger" }

util/timer/src/lib.rs

@@ -15,6 +15,10 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 extern crate parking_lot;
+#[macro_use]
+extern crate log;
+#[macro_use]
+extern crate codechain_logger as clogger;
 
 mod timer;