Remove the cli optional argument "no-miner"

Now the default value of mining.disable is true and could be
set to false not through the no-miner option but through not
giving both author and engine signer options.

Author: Seonpyo Kim

codechain/codechain.yml

@@ -155,14 +155,10 @@ args:
         long: author
         help: Specify the block author (aka "coinbase") address for sending block rewards from sealed blocks.
         takes_value: true
-        conflicts_with:
-            - no-miner
     - engine-signer:
         long: engine-signer
         help: Specify the address which should be used to sign consensus messages and issue blocks.
         takes_value: true
-        conflicts_with:
-            -  no-miner
     - password-path:
         long: password-path
         help: Specify the password file path.

codechain/config/mod.rs

@@ -215,7 +215,6 @@ pub struct Operating {
 #[derive(Deserialize)]
 #[serde(deny_unknown_fields)]
 pub struct Mining {
-    pub disable: Option<bool>,
     pub author: Option<PlatformAddress>,
     pub engine_signer: Option<PlatformAddress>,
     pub mem_pool_size: Option<usize>,
@@ -374,9 +373,6 @@ impl Operating {
 
 impl Mining {
     pub fn merge(&mut self, other: &Mining) {
-        if other.disable.is_some() {
-            self.disable = other.disable;
-        }
         if other.author.is_some() {
             self.author = other.author;
         }
@@ -416,16 +412,17 @@ impl Mining {
     }
 
     pub fn overwrite_with(&mut self, matches: &clap::ArgMatches) -> Result<(), String> {
-        if matches.is_present("no-miner") {
-            self.disable = Some(true);
-        }
-
         if let Some(author) = matches.value_of("author") {
             self.author = Some(author.parse().map_err(|_| "Invalid address format")?);
         }
         if let Some(engine_signer) = matches.value_of("engine-signer") {
             self.engine_signer = Some(engine_signer.parse().map_err(|_| "Invalid address format")?);
         }
+        if matches.is_present("no-miner") {
+            self.author = None;
+            self.engine_signer = None;
+            println!("This option was deprecated. PoW type engine with no engine signer and PBFT or PoA type engine with no author implicitly means no-miner.");
+        }
         if let Some(mem_pool_fee_bump_shift) = matches.value_of("mem-pool-fee-bump-shift") {
             self.mem_pool_mem_limit =
                 Some(mem_pool_fee_bump_shift.parse().map_err(|_| "Invalid mem pool fee bump shift")?);

codechain/config/presets/config.dev.toml

@@ -4,7 +4,6 @@ base_path = "."
 chain = "solo"
 
 [mining]
-disable = false
 mem_pool_mem_limit = 4 # MB
 mem_pool_size = 32768
 mem_pool_fee_bump_shift = 3 # 12.5%

codechain/config/presets/config.prod.toml

@@ -4,7 +4,6 @@ base_path = "."
 chain = "mainnet"
 
 [mining]
-disable = false
 mem_pool_mem_limit = 512 # MB
 mem_pool_size = 524288
 mem_pool_fee_bump_shift = 3 # 12.5%

codechain/run_node.rs

@@ -126,34 +126,34 @@ fn new_miner(
 ) -> Result<Arc<Miner>, String> {
     let miner = Miner::new(config.miner_options()?, scheme, Some(ap), db);
 
-    if !config.mining.disable.unwrap() {
-        match miner.engine_type() {
-            EngineType::PoW => match &config.mining.author {
-                Some(ref author) => {
-                    miner.set_author((*author).into_address()).expect("set_author never fails when PoW is used")
-                }
-                None => return Err("The author is missing. Specify the author using --author option.".to_string()),
-            },
-            EngineType::PBFT | EngineType::PoA => match &config.mining.engine_signer {
-                Some(ref engine_signer) => match miner.set_author((*engine_signer).into_address()) {
-                    Err(AccountProviderError::NotUnlocked) => {
-                        return Err(
-                            "The account is not unlocked. Specify the password path using --password-path option."
-                                .to_string(),
-                        )
-                    }
-                    Err(e) => return Err(format!("{}", e)),
-                    _ => (),
-                },
-                None => {
-                    return Err("The engine signer is missing. Specify the engine signer using --engine-signer option."
-                        .to_string())
+    match miner.engine_type() {
+        EngineType::PoW => match &config.mining.author {
+            Some(ref author) => {
+                miner.set_author((*author).into_address()).expect("set_author never fails when PoW is used")
+            }
+            None if config.mining.engine_signer.is_some() => return Err("PoW type engine needs not an engine-signer but an author for mining. Specify the author using --author option.".to_string()),
+            None => (),
+        },
+        EngineType::PBFT | EngineType::PoA => match &config.mining.engine_signer {
+            Some(ref engine_signer) => match miner.set_author((*engine_signer).into_address()) {
+                Err(AccountProviderError::NotUnlocked) => {
+                    return Err(
+                        "The account is not unlocked. Specify the password path using --password-path option."
+                            .to_string(),
+                    )
                 }
+                Err(e) => return Err(format!("{}", e)),
+                _ => (),
             },
-            EngineType::Solo => miner
-                .set_author(config.mining.author.map_or(Address::default(), PlatformAddress::into_address))
-                .expect("set_author never fails when Solo is used"),
-        }
+            None if config.mining.author.is_some() => {
+                return Err("PBFT or PoA type engine needs not an author but an engine signer for mining. Specify the engine signer using --engine-signer option."
+                    .to_string())
+            }
+            None => (),
+        },
+        EngineType::Solo => miner
+            .set_author(config.mining.author.map_or(Address::default(), PlatformAddress::into_address))
+            .expect("set_author never fails when Solo is used"),
     }
 
     Ok(miner)