Merge branch 'master' into feature/do-not-precommit-past-future-block

Author: HoOngEe

Cargo.lock

@@ -23,7 +23,6 @@ codechain-key = { path = "key" }
 codechain-keystore = { path = "keystore" }
 codechain-merkle = { path = "util/merkle" }
 codechain-network = { path = "network" }
-codechain-reactor = { path = "util/reactor" }
 codechain-rpc = { path = "rpc" }
 codechain-state = { path = "state" }
 codechain-sync = { path = "sync" }

Cargo.toml

@@ -60,6 +60,11 @@ args:
         long: chain
         help: Set the blockchain type out of solo, simple_poa, tendermint, cuckoo, blake_pow, corgi, mainnet or a path to chain scheme file.
         takes_value: true
+    - base-path:
+        long: base-path
+        value_name: PATH
+        help: Specify the base directory path on which the "db" and "keys" directory will be created.
+        takes_value: true
     - db-path:
         long: db-path
         value_name: PATH

codechain/codechain.yml

@@ -202,6 +202,7 @@ pub struct Ipc {
 pub struct Operating {
     pub quiet: Option<bool>,
     pub instance_id: Option<usize>,
+    pub base_path: Option<String>,
     pub db_path: Option<String>,
     pub keys_path: Option<String>,
     pub password_path: Option<String>,
@@ -316,6 +317,9 @@ impl Operating {
         if other.instance_id.is_some() {
             self.instance_id = other.instance_id;
         }
+        if other.base_path.is_some() {
+            self.base_path = other.base_path.clone();
+        }
         if other.db_path.is_some() {
             self.db_path = other.db_path.clone();
         }
@@ -337,6 +341,9 @@ impl Operating {
         if let Some(instance_id) = matches.value_of("instance-id") {
             self.instance_id = Some(instance_id.parse().map_err(|e| format!("{}", e))?);
         }
+        if let Some(base_path) = matches.value_of("base-path") {
+            self.base_path = Some(base_path.to_string());
+        }
         if let Some(db_path) = matches.value_of("db-path") {
             self.db_path = Some(db_path.to_string());
         }

codechain/config/mod.rs

@@ -1,7 +1,6 @@
 [codechain]
 quiet = false
-db_path = "db"
-keys_path = "keys"
+base_path = "."
 chain = "solo"
 
 [mining]

codechain/config/presets/config.dev.toml

@@ -1,7 +1,6 @@
 [codechain]
 quiet = false
-db_path = "db"
-keys_path = "keys"
+base_path = "."
 chain = "mainnet"
 
 [mining]

codechain/config/presets/config.prod.toml

@@ -15,3 +15,4 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 pub const DEFAULT_KEYS_PATH: &str = "keys";
+pub const DEFAULT_DB_PATH: &str = "db";

codechain/constants.rs

@@ -36,7 +36,6 @@ extern crate codechain_keystore as ckeystore;
 extern crate codechain_logger as clogger;
 extern crate cidr;
 extern crate codechain_network as cnetwork;
-extern crate codechain_reactor as creactor;
 extern crate codechain_rpc as crpc;
 extern crate codechain_state as cstate;
 extern crate codechain_sync as csync;

codechain/main.rs

@@ -14,11 +14,10 @@
 // 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::env;
 use std::fs;
 use std::path::Path;
 use std::sync::{Arc, Weak};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 use ccore::{
     AccountProvider, AccountProviderError, ChainNotify, Client, ClientConfig, ClientService, EngineInfo, EngineType,
@@ -31,18 +30,16 @@ use ckeystore::KeyStore;
 use clap::ArgMatches;
 use clogger::{self, LoggerConfig};
 use cnetwork::{Filters, NetworkConfig, NetworkControl, NetworkService, RoutingTable, SocketAddr};
-use creactor::EventLoop;
 use csync::{BlockSyncExtension, BlockSyncSender, SnapshotService, TransactionSyncExtension};
 use ctimer::TimerLoop;
 use ctrlc::CtrlC;
 use fdlimit::raise_fd_limit;
-use finally_block::finally;
 use kvdb::KeyValueDB;
 use kvdb_rocksdb::{Database, DatabaseConfig};
 use parking_lot::{Condvar, Mutex};
 
 use crate::config::{self, load_config};
-use crate::constants::DEFAULT_KEYS_PATH;
+use crate::constants::{DEFAULT_DB_PATH, DEFAULT_KEYS_PATH};
 use crate::dummy_network_service::DummyNetworkService;
 use crate::json::PasswordFile;
 use crate::rpc::{rpc_http_start, rpc_ipc_start, rpc_ws_start};
@@ -203,8 +200,9 @@ fn unlock_accounts(ap: &AccountProvider, pf: &PasswordFile) -> Result<(), String
 }
 
 pub fn open_db(cfg: &config::Operating, client_config: &ClientConfig) -> Result<Arc<KeyValueDB>, String> {
-    let db_path = cfg.db_path.as_ref().map(String::as_str).unwrap();
-    let client_path = Path::new(db_path);
+    let base_path = cfg.base_path.as_ref().unwrap().clone();
+    let db_path = cfg.db_path.as_ref().map(String::clone).unwrap_or_else(|| base_path + "/" + DEFAULT_DB_PATH);
+    let client_path = Path::new(&db_path);
     let mut db_config = DatabaseConfig::with_columns(NUM_COLUMNS);
 
     db_config.memory_budget = client_config.db_cache_size;
@@ -223,24 +221,11 @@ pub fn run_node(matches: &ArgMatches) -> Result<(), String> {
     // increase max number of open files
     raise_fd_limit();
 
-    let _event_loop = EventLoop::spawn();
     let timer_loop = TimerLoop::new(2);
 
     let config = load_config(matches)?;
 
-    // FIXME: It is the hotfix for #348.
-    // Remove the below code if you find the proper way to solve #348.
-    let _wait = finally(|| {
-        const DEFAULT: u64 = 1;
-        let wait_before_shutdown = env::var_os("WAIT_BEFORE_SHUTDOWN")
-            .and_then(|sec| sec.into_string().ok())
-            .and_then(|sec| sec.parse().ok())
-            .unwrap_or(DEFAULT);
-        ::std::thread::sleep(Duration::from_secs(wait_before_shutdown));
-    });
-
     let time_gap_params = config.mining.create_time_gaps();
-
     let scheme = match &config.operating.chain {
         Some(chain) => chain.scheme()?,
         None => return Err("chain is not specified".to_string()),
@@ -256,11 +241,10 @@ pub fn run_node(matches: &ArgMatches) -> Result<(), String> {
     clogger::init(&LoggerConfig::new(instance_id)).expect("Logger must be successfully initialized");
 
     let pf = load_password_file(&config.operating.password_path)?;
-    let keys_path = match config.operating.keys_path {
-        Some(ref keys_path) => keys_path,
-        None => DEFAULT_KEYS_PATH,
-    };
-    let ap = prepare_account_provider(keys_path)?;
+    let base_path = config.operating.base_path.as_ref().unwrap().clone();
+    let keys_path =
+        config.operating.keys_path.as_ref().map(String::clone).unwrap_or_else(|| base_path + "/" + DEFAULT_KEYS_PATH);
+    let ap = prepare_account_provider(&keys_path)?;
     unlock_accounts(&*ap, &pf)?;
 
     let client_config: ClientConfig = Default::default();

codechain/run_node.rs

@@ -285,8 +285,16 @@ impl HeaderChain {
     ///
     /// Used in BlockChain::update_best_as_committed().
     pub fn update_best_as_committed(&self, batch: &mut DBTransaction, block_hash: H256) {
-        ctrace!(HEADERCHAIN, "Update the best block to {}", block_hash);
         assert!(self.pending_best_header_hash.read().is_none());
+
+        let prev_best_header_number = self.best_header().number();
+        let committed_header_number =
+            self.block_header_data(&block_hash).expect("The given hash should exist").number();
+        if prev_best_header_number > committed_header_number {
+            return
+        }
+
+        ctrace!(HEADERCHAIN, "Update the best block to {}", block_hash);
         let block_detail = self.block_details(&block_hash).expect("The given hash should exist");
         let mut new_hashes = HashMap::new();
         new_hashes.insert(block_detail.number, block_hash);