110 lines
2.4 KiB
Rust
110 lines
2.4 KiB
Rust
use std::net;
|
|
use std::ops::{Deref, DerefMut};
|
|
|
|
use nakamoto::LocalTime;
|
|
use nakamoto_net as nakamoto;
|
|
use nakamoto_net::{Io, Link};
|
|
|
|
use crate::address;
|
|
use crate::collections::HashMap;
|
|
use crate::crypto;
|
|
use crate::service::routing;
|
|
use crate::service::{Command, DisconnectReason, Event, Service};
|
|
use crate::storage::WriteStorage;
|
|
use crate::wire::Wire;
|
|
|
|
#[derive(Debug)]
|
|
struct Peer {
|
|
_addr: net::SocketAddr,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct Transport<R, S, T, G> {
|
|
_peers: HashMap<net::IpAddr, Peer>,
|
|
inner: Wire<R, S, T, G>,
|
|
}
|
|
|
|
impl<R, S, T, G> Transport<R, S, T, G> {
|
|
pub fn new(inner: Wire<R, S, T, G>) -> Self {
|
|
Self {
|
|
_peers: HashMap::default(),
|
|
inner,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<R, S, T, G> nakamoto::Protocol for Transport<R, S, T, G>
|
|
where
|
|
R: routing::Store,
|
|
T: WriteStorage + 'static,
|
|
S: address::Store,
|
|
G: crypto::Signer,
|
|
{
|
|
type Event = Event;
|
|
type Command = Command;
|
|
type DisconnectReason = DisconnectReason;
|
|
|
|
fn initialize(&mut self, time: LocalTime) {
|
|
self.inner.initialize(time)
|
|
}
|
|
|
|
fn tick(&mut self, now: nakamoto::LocalTime) {
|
|
self.inner.tick(now)
|
|
}
|
|
|
|
fn wake(&mut self) {
|
|
self.inner.wake()
|
|
}
|
|
|
|
fn command(&mut self, cmd: Self::Command) {
|
|
self.inner.command(cmd)
|
|
}
|
|
|
|
fn attempted(&mut self, addr: &std::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::DisconnectReason>,
|
|
) {
|
|
self.inner.disconnected(addr, reason)
|
|
}
|
|
|
|
fn received_bytes(&mut self, addr: &std::net::SocketAddr, bytes: &[u8]) {
|
|
self.inner.received_bytes(addr, bytes)
|
|
}
|
|
}
|
|
|
|
impl<R, S, T, G> Iterator for Transport<R, S, T, G> {
|
|
type Item = Io<Event, DisconnectReason>;
|
|
|
|
fn next(&mut self) -> Option<Self::Item> {
|
|
self.inner.next()
|
|
}
|
|
}
|
|
|
|
impl<R, S, T, G> Deref for Transport<R, S, T, G> {
|
|
type Target = Service<R, S, T, G>;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.inner
|
|
}
|
|
}
|
|
|
|
impl<R, S, T, G> DerefMut for Transport<R, S, T, G> {
|
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
|
&mut self.inner
|
|
}
|
|
}
|