Remove NotifyWork

Author: Seulgi Kim

core/src/consensus/mod.rs

@@ -42,7 +42,7 @@ use ctypes::errors::SyntaxError;
 use ctypes::transaction::Action;
 use ctypes::util::unexpected::{Mismatch, OutOfBounds};
 use ctypes::{BlockHash, CommonParams, Header};
-use primitives::{Bytes, U256};
+use primitives::Bytes;
 
 use self::bit_set::BitSet;
 use crate::account_provider::AccountProvider;
@@ -221,10 +221,6 @@ pub trait ConsensusEngine: Sync + Send {
 
     fn register_time_gap_config_to_worker(&self, _time_gap_params: TimeGapParams) {}
 
-    fn score_to_target(&self, _score: &U256) -> U256 {
-        U256::zero()
-    }
-
     fn block_reward(&self, block_number: u64) -> u64;
 
     fn block_fee(&self, transactions: Box<dyn Iterator<Item = UnverifiedTransaction>>) -> u64 {

core/src/miner/miner.rs

@@ -36,7 +36,6 @@ use super::mem_pool::{Error as MemPoolError, MemPool};
 pub use super::mem_pool_types::MemPoolFees;
 use super::mem_pool_types::{AccountDetails, MemPoolInput, TxOrigin, TxTimelock};
 use super::sealing_queue::SealingQueue;
-use super::work_notify::{NotifyWork, WorkPoster};
 use super::{MinerService, MinerStatus, TransactionImportResult};
 use crate::account_provider::{AccountProvider, Error as AccountProviderError};
 use crate::block::{ClosedBlock, IsBlock};
@@ -54,8 +53,6 @@ use std::borrow::Borrow;
 /// Configures the behaviour of the miner.
 #[derive(Debug, PartialEq)]
 pub struct MinerOptions {
-    /// URLs to notify when there is new work.
-    pub new_work_notify: Vec<String>,
     /// Force the miner to reseal, even when nobody has asked for work.
     pub force_sealing: bool,
     /// Reseal on receipt of new external transactions.
@@ -85,7 +82,6 @@ pub struct MinerOptions {
 impl Default for MinerOptions {
     fn default() -> Self {
         MinerOptions {
-            new_work_notify: vec![],
             force_sealing: false,
             reseal_on_external_transaction: true,
             reseal_on_own_transaction: true,
@@ -128,17 +124,11 @@ pub struct Miner {
     sealing_enabled: AtomicBool,
 
     accounts: Option<Arc<AccountProvider>>,
-    notifiers: RwLock<Vec<Box<dyn NotifyWork>>>,
     malicious_users: RwLock<HashSet<Address>>,
     immune_users: RwLock<HashSet<Address>>,
 }
 
 impl Miner {
-    /// Push listener that will handle new jobs
-    pub fn add_work_listener(&self, notifier: Box<dyn NotifyWork>) {
-        self.notifiers.write().push(notifier);
-    }
-
     pub fn new(
         options: MinerOptions,
         scheme: &Scheme,
@@ -167,12 +157,6 @@ impl Miner {
             options.mem_pool_fees,
         )));
 
-        let notifiers: Vec<Box<dyn NotifyWork>> = if options.new_work_notify.is_empty() {
-            Vec::new()
-        } else {
-            vec![Box::new(WorkPoster::new(&options.new_work_notify))]
-        };
-
         Self {
             mem_pool,
             transaction_listener: RwLock::new(vec![]),
@@ -188,7 +172,6 @@ impl Miner {
             options,
             sealing_enabled: AtomicBool::new(true),
             accounts,
-            notifiers: RwLock::new(notifiers),
             malicious_users: RwLock::new(HashSet::new()),
             immune_users: RwLock::new(HashSet::new()),
         }
@@ -394,50 +377,29 @@ impl Miner {
 
     /// Prepares work which has to be done to seal.
     fn prepare_work(&self, block: ClosedBlock, original_work_hash: Option<H256>) {
-        let (work, is_new) = {
-            let mut sealing_work = self.sealing_work.lock();
-            let last_work_hash = sealing_work.queue.peek_last_ref().map(|pb| pb.block().header().hash());
+        let mut sealing_work = self.sealing_work.lock();
+        let last_work_hash = sealing_work.queue.peek_last_ref().map(|pb| pb.block().header().hash());
+        ctrace!(
+            MINER,
+            "prepare_work: Checking whether we need to reseal: orig={:?} last={:?}, this={:?}",
+            original_work_hash,
+            last_work_hash,
+            block.block().header().hash()
+        );
+        if last_work_hash.map_or(true, |h| h != block.block().header().hash()) {
             ctrace!(
                 MINER,
-                "prepare_work: Checking whether we need to reseal: orig={:?} last={:?}, this={:?}",
-                original_work_hash,
-                last_work_hash,
+                "prepare_work: Pushing a new, refreshed or borrowed pending {}...",
                 block.block().header().hash()
             );
-            let (work, is_new) = if last_work_hash.map_or(true, |h| h != block.block().header().hash()) {
-                ctrace!(
-                    MINER,
-                    "prepare_work: Pushing a new, refreshed or borrowed pending {}...",
-                    block.block().header().hash()
-                );
-                let pow_hash = *block.block().header().hash();
-                let number = block.block().header().number();
-                let score = *block.block().header().score();
-                let is_new = original_work_hash.map_or(true, |h| *block.block().header().hash() != h);
-                sealing_work.queue.push(block);
-                // If push notifications are enabled we assume all work items are used.
-                if !self.notifiers.read().is_empty() && is_new {
-                    sealing_work.queue.use_last_ref();
-                }
-                (Some((pow_hash, score, number)), is_new)
-            } else {
-                (None, false)
-            };
-            ctrace!(
-                MINER,
-                "prepare_work: leaving (last={:?})",
-                sealing_work.queue.peek_last_ref().map(|b| b.block().header().hash())
-            );
-            (work, is_new)
+            sealing_work.queue.push(block);
+            // If push notifications are enabled we assume all work items are used.
         };
-        if is_new {
-            if let Some((pow_hash, score, _number)) = work {
-                let target = self.engine.score_to_target(&score);
-                for notifier in self.notifiers.read().iter() {
-                    notifier.notify(pow_hash, target)
-                }
-            }
-        }
+        ctrace!(
+            MINER,
+            "prepare_work: leaving (last={:?})",
+            sealing_work.queue.peek_last_ref().map(|b| b.block().header().hash())
+        );
     }
 
     /// Prepares new block for sealing including top transactions from queue.

core/src/miner/mod.rs

@@ -20,7 +20,6 @@ mod mem_pool_types;
 #[cfg_attr(feature = "cargo-clippy", allow(clippy::module_inception))]
 mod miner;
 mod sealing_queue;
-mod work_notify;
 
 use std::ops::Range;
 

core/src/miner/sealing_queue.rs

@@ -42,7 +42,8 @@ impl SealingQueue {
     /// Return a reference to the item at the top of the queue (or `None` if the queue is empty);
     /// this constitutes using the item and will remain in the queue for at least another
     /// `max_size` invocations of `push()`.
-    pub fn use_last_ref(&mut self) -> Option<&ClosedBlock> {
+    #[cfg(test)]
+    fn use_last_ref(&mut self) -> Option<&ClosedBlock> {
         if let Some(x) = self.pending.take() {
             self.in_use.push(x);
         }

core/src/miner/work_notify.rs

@@ -98,7 +98,6 @@ impl Config {
             },
             mem_pool_fee_bump_shift: self.mining.mem_pool_fee_bump_shift.unwrap(),
             allow_create_shard: self.mining.allow_create_shard.unwrap_or(false),
-            new_work_notify: self.mining.notify_work.clone().unwrap(),
             force_sealing: self.mining.force_sealing.unwrap(),
             reseal_on_own_transaction,
             reseal_on_external_transaction,
@@ -225,7 +224,6 @@ pub struct Mining {
     pub mem_pool_mem_limit: Option<usize>,
     pub mem_pool_fee_bump_shift: Option<usize>,
     pub allow_create_shard: Option<bool>,
-    pub notify_work: Option<Vec<String>>,
     pub force_sealing: Option<bool>,
     pub reseal_on_txs: Option<String>,
     pub reseal_min_period: Option<u64>,
@@ -398,9 +396,6 @@ impl Mining {
         if other.allow_create_shard.is_some() {
             self.allow_create_shard = other.allow_create_shard;
         }
-        if other.notify_work.is_some() {
-            self.notify_work = other.notify_work.clone();
-        }
         if other.force_sealing.is_some() {
             self.force_sealing = other.force_sealing;
         }
@@ -485,9 +480,6 @@ impl Mining {
         if matches.is_present("allow-create-shard") {
             self.allow_create_shard = Some(true)
         }
-        if let Some(notify_work) = matches.values_of("notify-work") {
-            self.notify_work = Some(notify_work.map(|a| a.into()).collect());
-        }
         if matches.is_present("force-sealing") {
             self.force_sealing = Some(true);
         }

foundry/config/mod.rs

@@ -8,7 +8,6 @@ mem_pool_mem_limit = 4 # MB
 mem_pool_size = 32768
 mem_pool_fee_bump_shift = 3 # 12.5%
 allow_create_shard = false
-notify_work = []
 force_sealing = false
 reseal_on_txs = "all"
 reseal_min_period = 0

foundry/config/presets/config.dev.toml

@@ -8,7 +8,6 @@ mem_pool_mem_limit = 512 # MB
 mem_pool_size = 524288
 mem_pool_fee_bump_shift = 3 # 12.5%
 allow_create_shard = false
-notify_work = []
 force_sealing = true
 reseal_on_txs = "all"
 reseal_min_period = 4000

foundry/config/presets/config.prod.toml

@@ -183,14 +183,6 @@ args:
         long: allow-create-shard
         help: Make the miner allow CreateShard transactions
         takes_value: false
-    - notify-work:
-        long: notify-work
-        value_name: URLS
-        help: URLs to which work package notifications are pushed.
-        takes_value: true
-        multiple: true
-        conflicts_with:
-            - no-miner
     - force-sealing:
         long: force-sealing
         help: Force the node to author new blocks as if it were always sealing/mining.