add pibd receive messages to network, and basic calls to desegmenter from each (#3686)

chain/src/txhashset/desegmenter.rs

@@ -43,10 +43,10 @@ pub struct Desegmenter {
 	store: Arc<store::ChainStore>,
 
 	bitmap_accumulator: BitmapAccumulator,
-	bitmap_segments: Vec<Segment<BitmapChunk>>,
+	_bitmap_segments: Vec<Segment<BitmapChunk>>,
-	output_segments: Vec<Segment<OutputIdentifier>>,
+	_output_segments: Vec<Segment<OutputIdentifier>>,
-	rangeproof_segments: Vec<Segment<RangeProof>>,
+	_rangeproof_segments: Vec<Segment<RangeProof>>,
-	kernel_segments: Vec<Segment<TxKernel>>,
+	_kernel_segments: Vec<Segment<TxKernel>>,
 
 	bitmap_mmr_leaf_count: u64,
 	bitmap_mmr_size: u64,
@@ -68,10 +68,10 @@ impl Desegmenter {
 			archive_header,
 			store,
 			bitmap_accumulator: BitmapAccumulator::new(),
-			bitmap_segments: vec![],
+			_bitmap_segments: vec![],
-			output_segments: vec![],
+			_output_segments: vec![],
-			rangeproof_segments: vec![],
+			_rangeproof_segments: vec![],
-			kernel_segments: vec![],
+			_kernel_segments: vec![],
 
 			bitmap_mmr_leaf_count: 0,
 			bitmap_mmr_size: 0,
@@ -177,8 +177,13 @@ impl Desegmenter {
 
 	/// Adds a output segment
 	/// TODO: Still experimenting, expects chunks received to be in order
-	pub fn add_output_segment(&self, segment: Segment<OutputIdentifier>) -> Result<(), Error> {
+	pub fn add_output_segment(
+		&self,
+		segment: Segment<OutputIdentifier>,
+		_bitmap_root: Option<Hash>,
+	) -> Result<(), Error> {
 		debug!("pibd_desegmenter: add output segment");
+		// TODO: check bitmap root matches what we already have
 		segment.validate_with(
 			self.archive_header.output_mmr_size, // Last MMR pos at the height being validated
 			self.bitmap_cache.as_ref(),

chain/tests/test_pibd_copy.rs

@@ -159,7 +159,7 @@ fn test_pibd_copy_impl(is_test_chain: bool, src_root_dir: &str, dest_root_dir: &
 				bitmap_root_hash
 			);
 			// Add segment to desegmenter / validate
-			if let Err(e) = desegmenter.add_output_segment(output_segment) {
+			if let Err(e) = desegmenter.add_output_segment(output_segment, None) {
 				panic!("Unable to add output segment: {}", e);
 			}
 		}

p2p/src/peer.rs

@@ -612,6 +612,32 @@ impl ChainAdapter for TrackingAdapter {
 		self.adapter
 			.receive_bitmap_segment(block_hash, output_root, segment)
 	}
+
+	fn receive_output_segment(
+		&self,
+		block_hash: Hash,
+		bitmap_root: Hash,
+		segment: Segment<OutputIdentifier>,
+	) -> Result<bool, chain::Error> {
+		self.adapter
+			.receive_output_segment(block_hash, bitmap_root, segment)
+	}
+
+	fn receive_rangeproof_segment(
+		&self,
+		block_hash: Hash,
+		segment: Segment<RangeProof>,
+	) -> Result<bool, chain::Error> {
+		self.adapter.receive_rangeproof_segment(block_hash, segment)
+	}
+
+	fn receive_kernel_segment(
+		&self,
+		block_hash: Hash,
+		segment: Segment<TxKernel>,
+	) -> Result<bool, chain::Error> {
+		self.adapter.receive_kernel_segment(block_hash, segment)
+	}
 }
 
 impl NetAdapter for TrackingAdapter {

p2p/src/peers.rs

@@ -679,6 +679,32 @@ impl ChainAdapter for Peers {
 		self.adapter
 			.receive_bitmap_segment(block_hash, output_root, segment)
 	}
+
+	fn receive_output_segment(
+		&self,
+		block_hash: Hash,
+		bitmap_root: Hash,
+		segment: Segment<OutputIdentifier>,
+	) -> Result<bool, chain::Error> {
+		self.adapter
+			.receive_output_segment(block_hash, bitmap_root, segment)
+	}
+
+	fn receive_rangeproof_segment(
+		&self,
+		block_hash: Hash,
+		segment: Segment<RangeProof>,
+	) -> Result<bool, chain::Error> {
+		self.adapter.receive_rangeproof_segment(block_hash, segment)
+	}
+
+	fn receive_kernel_segment(
+		&self,
+		block_hash: Hash,
+		segment: Segment<TxKernel>,
+	) -> Result<bool, chain::Error> {
+		self.adapter.receive_kernel_segment(block_hash, segment)
+	}
 }
 
 impl NetAdapter for Peers {

p2p/src/serv.rs

@@ -413,9 +413,34 @@ impl ChainAdapter for DummyAdapter {
 
 	fn receive_bitmap_segment(
 		&self,
-		block_hash: Hash,
+		_block_hash: Hash,
-		output_root: Hash,
+		_output_root: Hash,
-		segment: Segment<BitmapChunk>,
+		_segment: Segment<BitmapChunk>,
+	) -> Result<bool, chain::Error> {
+		unimplemented!()
+	}
+
+	fn receive_output_segment(
+		&self,
+		_block_hash: Hash,
+		_bitmap_root: Hash,
+		_segment: Segment<OutputIdentifier>,
+	) -> Result<bool, chain::Error> {
+		unimplemented!()
+	}
+
+	fn receive_rangeproof_segment(
+		&self,
+		_block_hash: Hash,
+		_segment: Segment<RangeProof>,
+	) -> Result<bool, chain::Error> {
+		unimplemented!()
+	}
+
+	fn receive_kernel_segment(
+		&self,
+		_block_hash: Hash,
+		_segment: Segment<TxKernel>,
 	) -> Result<bool, chain::Error> {
 		unimplemented!()
 	}

p2p/src/types.rs

@@ -674,6 +674,25 @@ pub trait ChainAdapter: Sync + Send {
 		output_root: Hash,
 		segment: Segment<BitmapChunk>,
 	) -> Result<bool, chain::Error>;
+
+	fn receive_output_segment(
+		&self,
+		block_hash: Hash,
+		bitmap_root: Hash,
+		segment: Segment<OutputIdentifier>,
+	) -> Result<bool, chain::Error>;
+
+	fn receive_rangeproof_segment(
+		&self,
+		block_hash: Hash,
+		segment: Segment<RangeProof>,
+	) -> Result<bool, chain::Error>;
+
+	fn receive_kernel_segment(
+		&self,
+		block_hash: Hash,
+		segment: Segment<TxKernel>,
+	) -> Result<bool, chain::Error>;
 }
 
 /// Additional methods required by the protocol that don't need to be

servers/src/common/adapters.rs

@@ -576,12 +576,46 @@ where
 			block_hash, output_root
 		);
 		// TODO: Entire process needs to be restarted if the horizon block
-		// has changed (perhaps not here, NB for somewhere)
+		// has changed (perhaps not here, NB this has to go somewhere)
 		let archive_header = self.chain().txhashset_archive_header_header_only()?;
 		let mut desegmenter = self.chain().desegmenter(&archive_header)?;
 		desegmenter.add_bitmap_segment(segment, output_root)?;
 		Ok(true)
 	}
+
+	fn receive_output_segment(
+		&self,
+		_block_hash: Hash,
+		bitmap_root: Hash,
+		segment: Segment<OutputIdentifier>,
+	) -> Result<bool, chain::Error> {
+		let archive_header = self.chain().txhashset_archive_header_header_only()?;
+		let desegmenter = self.chain().desegmenter(&archive_header)?;
+		desegmenter.add_output_segment(segment, Some(bitmap_root))?;
+		Ok(true)
+	}
+
+	fn receive_rangeproof_segment(
+		&self,
+		_block_hash: Hash,
+		segment: Segment<RangeProof>,
+	) -> Result<bool, chain::Error> {
+		let archive_header = self.chain().txhashset_archive_header_header_only()?;
+		let desegmenter = self.chain().desegmenter(&archive_header)?;
+		desegmenter.add_rangeproof_segment(segment)?;
+		Ok(true)
+	}
+
+	fn receive_kernel_segment(
+		&self,
+		_block_hash: Hash,
+		segment: Segment<TxKernel>,
+	) -> Result<bool, chain::Error> {
+		let archive_header = self.chain().txhashset_archive_header_header_only()?;
+		let desegmenter = self.chain().desegmenter(&archive_header)?;
+		desegmenter.add_kernel_segment(segment)?;
+		Ok(true)
+	}
 }
 
 impl<B, P> NetToChainAdapter<B, P>