asimov_protocol/
peer_accept.rs

1// This is free and unencumbered software released into the public domain.
2
3#![allow(dead_code)]
4
5use crate::{
6    AcceptError, Message, MessageRecv, MessageSend, PeerConnection, PeerHello, RecvError,
7    SendError, peer_accept_state::*,
8};
9
10#[derive(Debug)]
11pub struct PeerAccept<State = Accepted>(State);
12
13impl From<iroh::endpoint::Connection> for PeerAccept {
14    fn from(inner: iroh::endpoint::Connection) -> Self {
15        Self(Accepted { inner })
16    }
17}
18
19impl PeerAccept<Accepted> {
20    pub async fn recv_hello(self) -> Result<PeerAccept<HelloReceived>, AcceptError> {
21        let Accepted { inner } = self.0;
22        let (send, recv) = inner.accept_bi().await?;
23        let connection = PeerAccept(HelloExpected { inner, send, recv });
24        Ok(connection.recv_hello().await?)
25    }
26}
27
28impl PeerAccept<HelloExpected> {
29    pub async fn recv_hello(mut self) -> Result<PeerAccept<HelloReceived>, AcceptError> {
30        let response = self.recv().await?;
31        let HelloExpected { inner, send, recv } = self.0;
32        let Message::Hello(hello) = response else {
33            return Err(AcceptError::InvalidMessage(response));
34        };
35        Ok(PeerAccept(HelloReceived {
36            inner,
37            send,
38            recv,
39            hello,
40        }))
41    }
42}
43
44impl PeerAccept<HelloReceived> {
45    pub async fn send_hello(mut self) -> Result<PeerAccept<HelloSent>, AcceptError> {
46        let HelloReceived { hello, .. } = &self.0;
47        let request = Message::Hello(hello.clone()); // TODO
48        let _ = self.send(request).await?;
49        let HelloReceived {
50            inner,
51            send,
52            recv,
53            hello,
54        } = self.0;
55        Ok(PeerAccept(HelloSent {
56            inner,
57            send,
58            recv,
59            hello,
60        }))
61    }
62}
63
64impl PeerAccept<HelloSent> {
65    pub fn hello(&self) -> &PeerHello {
66        return &self.0.hello;
67    }
68
69    pub fn into_connection(self) -> PeerConnection {
70        let HelloSent {
71            inner,
72            send,
73            recv,
74            hello,
75        } = self.0;
76        PeerConnection {
77            inner,
78            send,
79            recv,
80            hello,
81        }
82    }
83}
84
85impl MessageRecv for PeerAccept<HelloExpected> {
86    async fn read_exact(&mut self, buffer: &mut [u8]) -> Result<(), RecvError> {
87        Ok(self.0.recv.read_exact(buffer).await?)
88    }
89}
90
91impl MessageRecv for PeerAccept<HelloReceived> {
92    async fn read_exact(&mut self, buffer: &mut [u8]) -> Result<(), RecvError> {
93        Ok(self.0.recv.read_exact(buffer).await?)
94    }
95}
96
97impl MessageRecv for PeerAccept<HelloSent> {
98    async fn read_exact(&mut self, buffer: &mut [u8]) -> Result<(), RecvError> {
99        Ok(self.0.recv.read_exact(buffer).await?)
100    }
101}
102
103impl MessageSend for PeerAccept<HelloReceived> {
104    async fn write_all(&mut self, buffer: &[u8]) -> Result<(), SendError> {
105        Ok(self.0.send.write_all(buffer).await?)
106    }
107}
108
109impl MessageSend for PeerAccept<HelloSent> {
110    async fn write_all(&mut self, buffer: &[u8]) -> Result<(), SendError> {
111        Ok(self.0.send.write_all(buffer).await?)
112    }
113}
asimov_protocol/peer_accept.rs

asimov_protocol/
peer_accept.rs
