feat: add uncles_count to Header

zhangsoledad · doitian · commit 324488c9b145 · 2018-11-19T22:24:54.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/chain/Cargo.toml b/chain/Cargo.toml
@@ -12,7 +12,6 @@ log = "0.4"
 ckb-core = { path = "../core" }
 ckb-shared = { path = "../shared" }
 ckb-chain-spec = { path = "../spec" }
-ckb-util = { path = "../util" }
 ckb-db = { path = "../db" }
 ckb-time = { path = "../util/time" }
 ckb-notify = { path = "../notify" }
diff --git a/chain/src/chain.rs b/chain/src/chain.rs
@@ -16,7 +16,6 @@ use std::cmp;
 use std::sync::Arc;
 use std::thread::{self, JoinHandle};
 use time::now_ms;
-use util::RwLockUpgradableReadGuard;
 use verification::{BlockVerifier, Verifier};
 
 pub struct ChainService<CI> {
@@ -136,7 +135,7 @@ impl<CI: ChainIndex + 'static> ChainService<CI> {
         let mut old_cumulative_blks = Vec::new();
         let mut new_cumulative_blks = Vec::new();
 
-        let tip_header = self.shared.tip_header().upgradable_read();
+        let mut tip_header = self.shared.tip_header().write();
         let tip_number = tip_header.number();
         self.shared.store().save_with_batch(|batch| {
             let root = self.check_transactions(batch, block)?;
@@ -180,7 +179,6 @@ impl<CI: ChainIndex + 'static> ChainService<CI> {
 
         if new_best_block {
             debug!(target: "chain", "update index");
-            let mut guard = RwLockUpgradableReadGuard::upgrade(tip_header);
             let new_tip_header =
                 TipHeader::new(block.header().clone(), total_difficulty, output_root);
             self.shared.store().save_with_batch(|batch| {
@@ -197,7 +195,7 @@ impl<CI: ChainIndex + 'static> ChainService<CI> {
                 self.shared.store().rebuild_tree(output_root);
                 Ok(())
             })?;
-            *guard = new_tip_header;
+            *tip_header = new_tip_header;
             debug!(target: "chain", "update index release");
         }
 
diff --git a/chain/src/lib.rs b/chain/src/lib.rs
@@ -19,7 +19,6 @@ extern crate ckb_verification as verification;
 extern crate log;
 #[macro_use]
 extern crate crossbeam_channel as channel;
-extern crate ckb_util as util;
 
 #[cfg(test)]
 extern crate rand;
diff --git a/core/src/block.rs b/core/src/block.rs
@@ -32,6 +32,10 @@ impl Block {
         &self.header
     }
 
+    pub fn mut_header(&mut self) -> &mut Header {
+        &mut self.header
+    }
+
     pub fn is_genesis(&self) -> bool {
         self.header.is_genesis()
     }
@@ -98,11 +102,15 @@ impl BlockBuilder {
     }
 
     pub fn uncle(mut self, uncle: UncleBlock) -> Self {
+        *self.inner.mut_header().mut_raw().mut_uncles_count() =
+            self.inner.header().raw().uncles_count() + 1;
         self.inner.uncles.push(uncle);
         self
     }
 
     pub fn uncles(mut self, uncles: Vec<UncleBlock>) -> Self {
+        *self.inner.mut_header().mut_raw().mut_uncles_count() =
+            self.inner.header().raw().uncles_count() + uncles.len() as u32;
         self.inner.uncles.extend(uncles);
         self
     }
@@ -156,6 +164,7 @@ impl BlockBuilder {
             .txs_commit(&txs_commit)
             .txs_proposal(&txs_proposal)
             .uncles_hash(&uncles_hash)
+            .uncles_count(self.inner.uncles.len() as u32)
             .build();
         self.inner
     }
diff --git a/core/src/header.rs b/core/src/header.rs
@@ -35,6 +35,8 @@ pub struct RawHeader {
     cellbase_id: H256,
     /// Hash of the uncles
     uncles_hash: H256,
+    /// Hash of the uncles
+    uncles_count: u32,
 }
 
 impl RawHeader {
@@ -60,6 +62,14 @@ impl RawHeader {
     pub fn difficulty(&self) -> U256 {
         self.difficulty
     }
+
+    pub fn uncles_count(&self) -> u32 {
+        self.uncles_count
+    }
+
+    pub fn mut_uncles_count(&mut self) -> &mut u32 {
+        &mut self.uncles_count
+    }
 }
 
 #[derive(Clone, Serialize, Deserialize, Debug, Default, PartialEq, Eq)]
@@ -128,9 +138,21 @@ impl Header {
         self.raw.uncles_hash
     }
 
-    pub fn raw(self) -> RawHeader {
+    pub fn raw(&self) -> &RawHeader {
+        &self.raw
+    }
+
+    pub fn into_raw(self) -> RawHeader {
         self.raw
     }
+
+    pub fn mut_raw(&mut self) -> &mut RawHeader {
+        &mut self.raw
+    }
+
+    pub fn uncles_count(&self) -> u32 {
+        self.raw.uncles_count
+    }
 }
 
 #[derive(Default)]
@@ -205,6 +227,11 @@ impl HeaderBuilder {
         self
     }
 
+    pub fn uncles_count(mut self, uncles_count: u32) -> Self {
+        self.inner.raw.uncles_count = uncles_count;
+        self
+    }
+
     pub fn build(self) -> Header {
         let hash = H256::from_slice(&sha3_256(serialize(&self.inner).unwrap()));
         self.with_hash(&hash)
diff --git a/network/src/network.rs b/network/src/network.rs
@@ -597,11 +597,11 @@ impl Network {
                 swarm_controller.clone(),
                 basic_transport.clone(),
             ),
-            discovery_service.start_protocol(
-                Arc::clone(&network),
-                swarm_controller.clone(),
-                basic_transport.clone(),
-            ),
+            // discovery_service.start_protocol(
+            //     Arc::clone(&network),
+            //     swarm_controller.clone(),
+            //     basic_transport.clone(),
+            // ),
             identify_service.start_protocol(
                 Arc::clone(&network),
                 swarm_controller.clone(),
diff --git a/protocol/src/builder.rs b/protocol/src/builder.rs
@@ -51,6 +51,7 @@ impl<'a> FbsHeader<'a> {
         builder.add_proof(proof);
         builder.add_cellbase_id(cellbase_id);
         builder.add_uncles_hash(uncles_hash);
+        builder.add_uncles_count(header.uncles_count());
         builder.finish()
     }
 }
diff --git a/protocol/src/convert.rs b/protocol/src/convert.rs
@@ -65,6 +65,7 @@ impl<'a> From<ckb_protocol::Header<'a>> for ckb_core::header::Header {
                 header.uncles_hash().and_then(|b| b.seq()).unwrap(),
             )).nonce(header.nonce())
             .proof(header.proof().and_then(|b| b.seq()).unwrap())
+            .uncles_count(header.uncles_count())
             .build()
     }
 }
diff --git a/protocol/src/protocol.fbs b/protocol/src/protocol.fbs
@@ -41,6 +41,7 @@ table Header {
     proof:          Bytes;
     cellbase_id:    Bytes;
     uncles_hash:    Bytes;
+    uncles_count:   uint32;
 }
 
 table Block {
diff --git a/protocol/src/protocol_generated.rs b/protocol/src/protocol_generated.rs
@@ -2,8 +2,10 @@
 #![cfg_attr(rustfmt, rustfmt_skip)]
 // automatically generated by the FlatBuffers compiler, do not modify
 
+
 #![allow(dead_code)]
 #![allow(unused_imports)]
+extern crate flatbuffers;
 
 pub mod ckb {
   #![allow(dead_code)]
@@ -658,6 +660,7 @@ impl<'a> Header<'a> {
       builder.add_nonce(args.nonce);
       builder.add_number(args.number);
       builder.add_timestamp(args.timestamp);
+      builder.add_uncles_count(args.uncles_count);
       if let Some(x) = args.uncles_hash { builder.add_uncles_hash(x); }
       if let Some(x) = args.cellbase_id { builder.add_cellbase_id(x); }
       if let Some(x) = args.proof { builder.add_proof(x); }
@@ -680,6 +683,7 @@ impl<'a> Header<'a> {
     pub const VT_PROOF: flatbuffers::VOffsetT = 20;
     pub const VT_CELLBASE_ID: flatbuffers::VOffsetT = 22;
     pub const VT_UNCLES_HASH: flatbuffers::VOffsetT = 24;
+    pub const VT_UNCLES_COUNT: flatbuffers::VOffsetT = 26;
 
   #[inline]
   pub fn version(&self) -> u32 {
@@ -725,6 +729,10 @@ impl<'a> Header<'a> {
   pub fn uncles_hash(&self) -> Option<Bytes<'a>> {
     self._tab.get::<flatbuffers::ForwardsUOffset<Bytes<'a>>>(Header::VT_UNCLES_HASH, None)
   }
+  #[inline]
+  pub fn uncles_count(&self) -> u32 {
+    self._tab.get::<u32>(Header::VT_UNCLES_COUNT, Some(0)).unwrap()
+  }
 }
 
 pub struct HeaderArgs<'a> {
@@ -739,6 +747,7 @@ pub struct HeaderArgs<'a> {
     pub proof: Option<flatbuffers::WIPOffset<Bytes<'a >>>,
     pub cellbase_id: Option<flatbuffers::WIPOffset<Bytes<'a >>>,
     pub uncles_hash: Option<flatbuffers::WIPOffset<Bytes<'a >>>,
+    pub uncles_count: u32,
 }
 impl<'a> Default for HeaderArgs<'a> {
     #[inline]
@@ -755,6 +764,7 @@ impl<'a> Default for HeaderArgs<'a> {
             proof: None,
             cellbase_id: None,
             uncles_hash: None,
+            uncles_count: 0,
         }
     }
 }
@@ -808,6 +818,10 @@ impl<'a: 'b, 'b> HeaderBuilder<'a, 'b> {
     self.fbb_.push_slot_always::<flatbuffers::WIPOffset<Bytes>>(Header::VT_UNCLES_HASH, uncles_hash);
   }
   #[inline]
+  pub fn add_uncles_count(&mut self, uncles_count: u32) {
+    self.fbb_.push_slot::<u32>(Header::VT_UNCLES_COUNT, uncles_count, 0);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HeaderBuilder<'a, 'b> {
     let start = _fbb.start_table();
     HeaderBuilder {
@@ -2305,4 +2319,3 @@ pub fn finish_size_prefixed_sync_message_buffer<'a, 'b>(fbb: &'b mut flatbuffers
 }
 }  // pub mod Protocol
 }  // pub mod Ckb
-
diff --git a/rpc/src/service.rs b/rpc/src/service.rs
@@ -172,7 +172,7 @@ impl<CI: ChainIndex + 'static> RpcService<CI> {
             .with_header_builder(header_builder);
 
         Ok(BlockTemplate {
-            raw_header: block.header().clone().raw(),
+            raw_header: block.header().clone().into_raw(),
             uncles: block.uncles().to_vec(),
             commit_transactions: block.commit_transactions().to_vec(),
             proposal_transactions: block.proposal_transactions().to_vec(),
diff --git a/shared/src/shared.rs b/shared/src/shared.rs
@@ -280,19 +280,18 @@ impl<CI: ChainIndex> ChainProvider for Shared<CI> {
     }
 
     fn get_ancestor(&self, base: &H256, number: BlockNumber) -> Option<Header> {
-        {
-            if let Some(n_number) = self.block_number(base) {
-                if number > n_number {
-                    return None;
-                } else if number == n_number {
-                    return Some(self.tip_header.read().inner().clone());
-                } else {
-                    return self
-                        .block_hash(number)
-                        .and_then(|hash| self.block_header(&hash));
-                }
+        // if base in the main chain
+        if let Some(n_number) = self.block_number(base) {
+            if number > n_number {
+                return None;
+            } else {
+                return self
+                    .block_hash(number)
+                    .and_then(|hash| self.block_header(&hash));
             }
         }
+
+        // if base in the fork
         if let Some(header) = self.block_header(base) {
             let mut n_number = header.number();
             let mut index_walk = header;
diff --git a/sync/Cargo.toml b/sync/Cargo.toml
@@ -23,11 +23,11 @@ ckb-verification = { path = "../verification" }
 serde = "1.0"
 serde_derive = "1.0"
 flatbuffers = "0.5.0"
+ckb-chain-spec = { path = "../spec" }
 
 [dev-dependencies]
 ckb-notify = { path = "../notify" }
 ckb-db = { path = "../db" }
 ckb-time = { path = "../util/time", features = ["mock_timer"] }
 env_logger = "0.5"
 crossbeam-channel = "0.2"
-ckb-chain-spec = { path = "../spec" }
diff --git a/sync/src/lib.rs b/sync/src/lib.rs
@@ -22,9 +22,8 @@ extern crate ckb_verification;
 extern crate bitflags;
 #[macro_use]
 extern crate serde_derive;
-
-#[cfg(test)]
 extern crate ckb_chain_spec as chain_spec;
+
 #[cfg(test)]
 extern crate ckb_db as db;
 #[cfg(test)]
diff --git a/sync/src/synchronizer/header_view.rs b/sync/src/synchronizer/header_view.rs
@@ -1,18 +1,19 @@
 use bigint::{H256, U256};
 use core::header::{BlockNumber, Header};
-use std::cmp::Ordering;
 
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct HeaderView {
     inner: Header,
     total_difficulty: U256,
+    total_uncles_count: u64,
 }
 
 impl HeaderView {
-    pub fn new(inner: Header, total_difficulty: U256) -> Self {
+    pub fn new(inner: Header, total_difficulty: U256, total_uncles_count: u64) -> Self {
         HeaderView {
             inner,
             total_difficulty,
+            total_uncles_count,
         }
     }
 
@@ -24,23 +25,19 @@ impl HeaderView {
         self.inner.hash()
     }
 
+    pub fn total_uncles_count(&self) -> u64 {
+        self.total_uncles_count
+    }
+
     pub fn total_difficulty(&self) -> U256 {
         self.total_difficulty
     }
 
     pub fn inner(&self) -> &Header {
         &self.inner
     }
-}
-
-impl Ord for HeaderView {
-    fn cmp(&self, other: &HeaderView) -> Ordering {
-        self.total_difficulty.cmp(&other.total_difficulty)
-    }
-}
 
-impl PartialOrd for HeaderView {
-    fn partial_cmp(&self, other: &HeaderView) -> Option<Ordering> {
-        Some(self.cmp(other))
+    pub fn into_inner(self) -> Header {
+        self.inner
     }
 }
diff --git a/sync/src/synchronizer/headers_process.rs b/sync/src/synchronizer/headers_process.rs
diff --git a/sync/src/synchronizer/mod.rs b/sync/src/synchronizer/mod.rs
diff --git a/verification/src/block_verifier.rs b/verification/src/block_verifier.rs
diff --git a/verification/src/error.rs b/verification/src/error.rs
diff --git a/verification/src/tests/uncle_verifier.rs b/verification/src/tests/uncle_verifier.rs

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,10 @@ impl Block {`
`32`	`32`	`&self.header`
`33`	`33`	`}`
`34`	`34`
	`35`	`+ pub fn mut_header(&mut self) -> &mut Header {`
	`36`	`+ &mut self.header`
	`37`	`+ }`
	`38`	`+`
`35`	`39`	`pub fn is_genesis(&self) -> bool {`
`36`	`40`	`self.header.is_genesis()`
`37`	`41`	`}`
`@@ -98,11 +102,15 @@ impl BlockBuilder {`
`98`	`102`	`}`
`99`	`103`
`100`	`104`	`pub fn uncle(mut self, uncle: UncleBlock) -> Self {`
	`105`	`+ *self.inner.mut_header().mut_raw().mut_uncles_count() =`
	`106`	`+ self.inner.header().raw().uncles_count() + 1;`
`101`	`107`	`self.inner.uncles.push(uncle);`
`102`	`108`	`self`
`103`	`109`	`}`
`104`	`110`
`105`	`111`	`pub fn uncles(mut self, uncles: Vec<UncleBlock>) -> Self {`
	`112`	`+ *self.inner.mut_header().mut_raw().mut_uncles_count() =`
	`113`	`+ self.inner.header().raw().uncles_count() + uncles.len() as u32;`
`106`	`114`	`self.inner.uncles.extend(uncles);`
`107`	`115`	`self`
`108`	`116`	`}`
`@@ -156,6 +164,7 @@ impl BlockBuilder {`
`156`	`164`	`.txs_commit(&txs_commit)`
`157`	`165`	`.txs_proposal(&txs_proposal)`
`158`	`166`	`.uncles_hash(&uncles_hash)`
	`167`	`+ .uncles_count(self.inner.uncles.len() as u32)`
`159`	`168`	`.build();`
`160`	`169`	`self.inner`
`161`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,7 @@ impl<'a> FbsHeader<'a> {`
`51`	`51`	`builder.add_proof(proof);`
`52`	`52`	`builder.add_cellbase_id(cellbase_id);`
`53`	`53`	`builder.add_uncles_hash(uncles_hash);`
	`54`	`+ builder.add_uncles_count(header.uncles_count());`
`54`	`55`	`builder.finish()`
`55`	`56`	`}`
`56`	`57`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,7 @@ impl<'a> From<ckb_protocol::Header<'a>> for ckb_core::header::Header {`
`65`	`65`	`header.uncles_hash().and_then(\|b\| b.seq()).unwrap(),`
`66`	`66`	`)).nonce(header.nonce())`
`67`	`67`	`.proof(header.proof().and_then(\|b\| b.seq()).unwrap())`
	`68`	`+ .uncles_count(header.uncles_count())`
`68`	`69`	`.build()`
`69`	`70`	`}`
`70`	`71`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,7 @@ table Header {`
`41`	`41`	`proof: Bytes;`
`42`	`42`	`cellbase_id: Bytes;`
`43`	`43`	`uncles_hash: Bytes;`
	`44`	`+ uncles_count: uint32;`
`44`	`45`	`}`
`45`	`46`
`46`	`47`	`table Block {`