Skip to content
322 changes: 263 additions & 59 deletions dash-spv/src/network/broker.rs

Large diffs are not rendered by default.

612 changes: 495 additions & 117 deletions dash-spv/src/network/manager.rs

Large diffs are not rendered by default.

70 changes: 67 additions & 3 deletions dash-spv/src/network/peer.rs
Original file line number Diff line number Diff line change
Expand Up @@ -17,7 +17,7 @@ use dashcore::{
use futures::lock::Mutex;
use rand::Rng;
use std::net::SocketAddr;
use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
use std::sync::Arc;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
#[cfg(test)]
Expand Down Expand Up @@ -137,6 +137,23 @@ impl Decoder for SizedCodec {
}
}

/// Frames messages and records whether the bytes of an unfinished one are buffered.
struct TrackedCodec {
codec: SizedCodec,
partial: Arc<AtomicBool>,
}

impl Decoder for TrackedCodec {
type Item = (RawNetworkMessage, u64);
type Error = encode::Error;

fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, Self::Error> {
let frame = self.codec.decode(src);
self.partial.store(!src.is_empty(), Ordering::Relaxed);
frame
}
}

/// The socket's write half, framing each message for the connection's transport.
struct PeerWriter {
half: OwnedWriteHalf,
Expand Down Expand Up @@ -172,7 +189,7 @@ impl PeerWriter {
/// the peer's version packet.
type LinkReader = Either<ProtocolSessionReader<OwnedReadHalf>, OwnedReadHalf>;

type PeerReader = FramedRead<CountingReader<LinkReader>, SizedCodec>;
type PeerReader = FramedRead<CountingReader<LinkReader>, TrackedCodec>;

/// A TCP connection with its transport negotiated, ready for the version handshake.
struct Link {
Expand Down Expand Up @@ -269,6 +286,10 @@ impl PeerHandle {
self.cap.load(Ordering::Relaxed)
}

pub(crate) fn is_closed(&self) -> bool {
self.token.is_cancelled()
}

pub async fn send(&self, msg: &NetworkMessage) -> NetworkResult<()> {
// The sync layer sends a plain `getheaders`, since it does not know the peer.
// The reader decompresses `Headers2` back to `Headers`.
Expand Down Expand Up @@ -300,6 +321,7 @@ pub struct ConnectedPeer {
version: VersionMessage,
lag_ms: AtomicU32,
bytes: Arc<AtomicU64>,
partial: Arc<AtomicBool>,
}

pub struct DisconnectedPeer {
Expand Down Expand Up @@ -342,6 +364,11 @@ impl ConnectedPeer {
self.bytes.load(Ordering::Relaxed)
}

/// Whether part of a message has arrived and the rest has not.
pub fn partial_message(&self) -> bool {
self.partial.load(Ordering::Relaxed)
}

pub fn in_flight_bytes(&self) -> u64 {
self.handle.in_flight_bytes()
}
Expand Down Expand Up @@ -385,8 +412,17 @@ impl ConnectedPeer {
version: build_version(id.addr(), "test"),
lag_ms: AtomicU32::new(1),
bytes: Arc::new(AtomicU64::new(0)),
partial: Arc::new(AtomicBool::new(false)),
}
}

/// Counts `n` bytes as read from the socket, as the reader does, leaving a message
/// unfinished if `partial`.
#[cfg(test)]
pub(crate) fn receive_for_test(&self, n: u64, partial: bool) {
self.bytes.fetch_add(n, Ordering::Relaxed);
self.partial.store(partial, Ordering::Relaxed);
}
}

impl DisconnectedPeer {
Expand Down Expand Up @@ -481,13 +517,17 @@ impl DisconnectedPeer {
1
};
let peer_bytes = Arc::new(AtomicU64::new(0));
let partial = Arc::new(AtomicBool::new(false));
let mut reader = FramedRead::new(
CountingReader {
inner: reader,
state: state.clone(),
peer_bytes: peer_bytes.clone(),
},
codec,
TrackedCodec {
codec,
partial: partial.clone(),
},
);

handshake_send(
Expand Down Expand Up @@ -610,6 +650,7 @@ impl DisconnectedPeer {
version,
lag_ms: AtomicU32::new(lag_ms),
bytes: peer_bytes,
partial,
})
}
}
Expand Down Expand Up @@ -752,6 +793,8 @@ async fn handshake_send(writer: &mut PeerWriter, payload: NetworkMessage) -> Net
mod tests {
use std::io::{Error as IoError, ErrorKind};

use test_case::test_case;

use super::*;

fn io_error(kind: ErrorKind) -> ProtocolError {
Expand Down Expand Up @@ -789,4 +832,25 @@ mod tests {
wire_agent(&format!("{}é{}", "a".repeat(MAX_USER_AGENT_LEN - 3), "b".repeat(10)));
assert_eq!(straddling, format!("/{}/", "a".repeat(MAX_USER_AGENT_LEN - 3)));
}

/// Whether the codec reports an unfinished message after the first `n` bytes of two
/// 32-byte pings arrive.
#[test_case(1 => true; "part of a header")]
#[test_case(24 => true; "a header without its payload")]
#[test_case(32 => false; "a whole ping")]
#[test_case(40 => true; "a whole ping and part of the next")]
fn the_codec_tracks_an_unfinished_message(n: usize) -> bool {
let magic = Network::Regtest.magic();
let ping = encode::serialize(&RawNetworkMessage {
magic,
payload: NetworkMessage::Ping(1),
});
let mut codec = TrackedCodec {
codec: SizedCodec::V1,
partial: Arc::new(AtomicBool::new(false)),
};
let mut src = BytesMut::from(&[ping.clone(), ping].concat()[..n]);
while codec.decode(&mut src).unwrap().is_some() {}
codec.partial.load(Ordering::Relaxed)
}
}
25 changes: 24 additions & 1 deletion dash-spv/src/sync/filter_headers/manager.rs
Original file line number Diff line number Diff line change
Expand Up @@ -388,7 +388,7 @@ impl<H: BlockHeaderStorage, FH: FilterHeaderStorage> std::fmt::Debug
#[cfg(test)]
mod tests {
use super::*;
use crate::network::MessageType;
use crate::network::{MessageType, RequestKey};
use crate::storage::{
DiskStorageManager, PersistentBlockHeaderStorage, PersistentFilterHeaderStorage,
StorageManager,
Expand Down Expand Up @@ -801,6 +801,29 @@ mod tests {
assert_eq!(filter_tip(&storage).await, Some(3999));
}

/// The broker settles a request when its reply arrives, so a reply the pipeline does
/// not take must still release the key or a later declaration of the batch sends nothing.
#[test_case(0, false; "an empty reply")]
#[test_case(2000, true; "a reply reaching a pipeline dropped by a disconnect")]
#[tokio::test]
async fn test_cfheaders_reply_matching_nothing_releases_its_key(
count: u32,
disconnected: bool,
) {
let storage = DiskStorageManager::with_temp_dir().await.unwrap();
let hashes = store_block_headers(&storage, 0, 2000).await;
let (mut manager, network) = start_sync(&storage, 1999).await;
if disconnected {
manager.on_disconnect();
}

let reply = cfheaders(FilterHeader::all_zeros(), hashes[1999], count);
let (stored, _) = deliver(&mut manager, &network, reply).await;

assert!(stored.is_empty());
assert_eq!(network.released_keys().await, vec![RequestKey::CfHeaders(hashes[1999])]);
}

#[tokio::test]
async fn test_buffered_cfheaders_batch_not_connecting_is_requeued_when_ready() {
let storage = DiskStorageManager::with_temp_dir().await.unwrap();
Expand Down
6 changes: 3 additions & 3 deletions dash-spv/src/sync/filter_headers/sync_manager.rs
Original file line number Diff line number Diff line change
Expand Up @@ -46,9 +46,11 @@ impl<H: BlockHeaderStorage, FH: FilterHeaderStorage> SyncManager for FilterHeade
msg: InboundMessage,
network: &Arc<dyn NetworkManager>,
) -> SyncResult<Vec<SyncEvent>> {
// Released whatever comes of the reply: a reply that matches nothing must not leave
// its key settled, and a batch still wanted is declared again.
if let NetworkMessage::CFHeaders(cfheaders) = &*msg {
network.release_request(RequestKey::CfHeaders(cfheaders.stop_hash)).await;
if self.pipeline.receive_below(cfheaders) {
network.release_request(RequestKey::CfHeaders(cfheaders.stop_hash)).await;
return self.store_lower_batches().await;
}
}
Expand All @@ -63,8 +65,6 @@ impl<H: BlockHeaderStorage, FH: FilterHeaderStorage> SyncManager for FilterHeade
return Ok(vec![]);
};

network.release_request(RequestKey::CfHeaders(cfheaders.stop_hash)).await;

let mut events = Vec::new();

// Try to receive (may buffer if out of order)
Expand Down
Loading
Loading