From 8e160f170c7dbfa9e603c509d1f401e487a5806d Mon Sep 17 00:00:00 2001 From: Alexis Sellier Date: Thu, 15 Sep 2022 21:37:28 +0200 Subject: [PATCH] node: Add wire protocol Signed-off-by: Alexis Sellier --- node/src/client.rs | 3 +- node/src/protocol/wire.rs | 90 ++++++++++++++++++++++++++++++++++++++- node/src/test/peer.rs | 5 ++- node/src/transport.rs | 29 +++++++------ 4 files changed, 108 insertions(+), 19 deletions(-) diff --git a/node/src/client.rs b/node/src/client.rs index ae833774..007b8953 100644 --- a/node/src/client.rs +++ b/node/src/client.rs @@ -8,6 +8,7 @@ use crate::clock::RefClock; use crate::collections::HashMap; use crate::crypto::Signer; use crate::protocol; +use crate::protocol::wire::Wire; use crate::storage::git::Storage; use crate::transport::Transport; @@ -97,7 +98,7 @@ impl Client { ); self.reactor.run( &config.listen, - Transport::new(protocol), + Transport::new(Wire::new(protocol)), self.events, self.commands, )?; diff --git a/node/src/protocol/wire.rs b/node/src/protocol/wire.rs index 6edc0de1..58ac52c3 100644 --- a/node/src/protocol/wire.rs +++ b/node/src/protocol/wire.rs @@ -1,17 +1,23 @@ use std::collections::BTreeMap; use std::convert::TryFrom; -use std::ops::Deref; +use std::net; +use std::ops::{Deref, DerefMut}; use std::string::FromUtf8Error; use std::{io, mem}; use byteorder::{NetworkEndian, ReadBytesExt, WriteBytesExt}; +use nakamoto_net as nakamoto; +use nakamoto_net::{Link, LocalTime}; -use crate::crypto::{PublicKey, Signature}; +use crate::address_book; +use crate::crypto::{PublicKey, Signature, Signer}; use crate::git; use crate::git::fmt; use crate::hash::Digest; use crate::identity::Id; +use crate::protocol; use crate::storage::refs::Refs; +use crate::storage::WriteStorage; /// The default type we use to represent sizes. /// Four bytes is more than enough for anything sent over the wire. @@ -379,6 +385,86 @@ impl Decode for Digest { } } +#[derive(Debug)] +pub struct Wire { + inner: protocol::Protocol, +} + +impl Wire { + pub fn new(inner: protocol::Protocol) -> Self { + Self { inner } + } +} + +impl<'r, S, T, G> Wire +where + S: address_book::Store, + T: WriteStorage<'r> + 'static, + G: Signer, +{ + fn initialize(&mut self, time: LocalTime) { + self.inner.initialize(time) + } + + fn tick(&mut self, now: LocalTime) { + self.inner.tick(now) + } + + fn wake(&mut self) { + self.inner.wake() + } + + fn command(&mut self, cmd: protocol::Command) { + self.inner.command(cmd) + } + + fn attempted(&mut self, addr: &net::SocketAddr) { + self.inner.attempted(addr) + } + + fn connected( + &mut self, + addr: std::net::SocketAddr, + local_addr: &std::net::SocketAddr, + link: Link, + ) { + self.inner.connected(addr, local_addr, link) + } + + fn disconnected( + &mut self, + addr: &std::net::SocketAddr, + reason: nakamoto::DisconnectReason, + ) { + self.inner.disconnected(addr, reason) + } + + fn received_bytes(&mut self, addr: &std::net::SocketAddr, bytes: &[u8]) { + self.inner.received_bytes(addr, bytes) + } +} + +impl Iterator for Wire { + type Item = nakamoto::Io; + + fn next(&mut self) -> Option { + self.inner.next() + } +} + +impl Deref for Wire { + type Target = protocol::Protocol; + + fn deref(&self) -> &Self::Target { + &self.inner + } +} +impl DerefMut for Wire { + fn deref_mut(&mut self) -> &mut Self::Target { + &mut self.inner + } +} + #[cfg(test)] mod tests { use super::*; diff --git a/node/src/test/peer.rs b/node/src/test/peer.rs index 180dcb58..9af3e483 100644 --- a/node/src/test/peer.rs +++ b/node/src/test/peer.rs @@ -12,6 +12,7 @@ use crate::collections::HashMap; use crate::decoder::Decoder; use crate::protocol::config::*; use crate::protocol::message::*; +use crate::protocol::wire::Wire; use crate::protocol::*; use crate::storage::WriteStorage; use crate::test::crypto::MockSigner; @@ -93,14 +94,14 @@ where let local_time = LocalTime::now(); let clock = RefClock::from(local_time); let signer = MockSigner::new(&mut rng); - let protocol = Transport::new(Protocol::new( + let protocol = Transport::new(Wire::new(Protocol::new( config, clock, storage, addrs, signer, rng.clone(), - )); + ))); let ip = ip.into(); let local_addr = net::SocketAddr::new(ip, rng.u16(..)); diff --git a/node/src/transport.rs b/node/src/transport.rs index f08c5b8b..8daddd68 100644 --- a/node/src/transport.rs +++ b/node/src/transport.rs @@ -8,6 +8,7 @@ use nakamoto_net::{Io, Link}; use crate::address_book; use crate::collections::HashMap; use crate::crypto; +use crate::protocol::wire::Wire; use crate::protocol::{Command, DisconnectReason, Event, Protocol}; use crate::storage::WriteStorage; @@ -19,14 +20,14 @@ struct Peer { #[derive(Debug)] pub struct Transport { peers: HashMap, - protocol: Protocol, + inner: Wire, } impl Transport { - pub fn new(protocol: Protocol) -> Self { + pub fn new(inner: Wire) -> Self { Self { peers: HashMap::default(), - protocol, + inner, } } } @@ -42,23 +43,23 @@ where type DisconnectReason = DisconnectReason; fn initialize(&mut self, time: LocalTime) { - self.protocol.initialize(time) + self.inner.initialize(time) } fn tick(&mut self, now: nakamoto::LocalTime) { - self.protocol.tick(now) + self.inner.tick(now) } fn wake(&mut self) { - self.protocol.wake() + self.inner.wake() } fn command(&mut self, cmd: Self::Command) { - self.protocol.command(cmd) + self.inner.command(cmd) } fn attempted(&mut self, addr: &std::net::SocketAddr) { - self.protocol.attempted(addr) + self.inner.attempted(addr) } fn connected( @@ -67,7 +68,7 @@ where local_addr: &std::net::SocketAddr, link: Link, ) { - self.protocol.connected(addr, local_addr, link) + self.inner.connected(addr, local_addr, link) } fn disconnected( @@ -75,11 +76,11 @@ where addr: &std::net::SocketAddr, reason: nakamoto::DisconnectReason, ) { - self.protocol.disconnected(addr, reason) + self.inner.disconnected(addr, reason) } fn received_bytes(&mut self, addr: &std::net::SocketAddr, bytes: &[u8]) { - self.protocol.received_bytes(addr, bytes) + self.inner.received_bytes(addr, bytes) } } @@ -87,7 +88,7 @@ impl Iterator for Transport { type Item = Io; fn next(&mut self) -> Option { - self.protocol.next() + self.inner.next() } } @@ -95,12 +96,12 @@ impl Deref for Transport { type Target = Protocol; fn deref(&self) -> &Self::Target { - &self.protocol + &self.inner } } impl DerefMut for Transport { fn deref_mut(&mut self) -> &mut Self::Target { - &mut self.protocol + &mut self.inner } }