anneal 0.3.4

A testing framework for Iron
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use hyper::{
    error::Result as HyperResult,
    net::{
        NetworkConnector,
        NetworkStream,
    },
};
use std::{
    collections::VecDeque,
    io::{
        Result,
        Read,
        Write,
    },
    net::{
        Shutdown,
        SocketAddr,
    },
    sync::{
        Arc,
        Mutex,
    },
    time::Duration,
};

#[derive(Clone)]
pub struct TransferConnector {
    buffer: Arc<Mutex<VecDeque<u8>>>,
    pub client_address: SocketAddr,
    pub scheme: Arc<Mutex<Option<String>>>,
    pub server_address: Arc<Mutex<Option<SocketAddr>>>,
}

impl TransferConnector {
    pub fn new(client_address: SocketAddr) -> TransferConnector {
        TransferConnector {
            buffer: Arc::new(Mutex::new(VecDeque::new())),
            client_address,
            scheme: Arc::new(Mutex::new(None)),
            server_address: Arc::new(Mutex::new(None)),
        }
    }

    pub fn server_stream(&self) -> ServerStream {
        ServerStream {
            buffer: self.buffer.clone(),
            peer_address: self.client_address.clone(), 
        }
    }
}

impl NetworkConnector for TransferConnector {
    type Stream = ClientStream;

    fn connect(&self, host: &str, port: u16, scheme: &str) -> HyperResult<Self::Stream> {
        let addr : SocketAddr = format!("{}:{}", host, port).parse().expect("connect address parse");
        *self.server_address.lock().expect("connect server address lock") 
            = Some(addr.clone()); 
        *self.scheme.lock().expect("connect scheme lock") 
            = Some(scheme.to_string());

        Ok(ClientStream { 
            buffer: self.buffer.clone(), 
            peer_address: addr, 
        })
    }
}


pub struct ClientStream {
    buffer: Arc<Mutex<VecDeque<u8>>>,
    peer_address: SocketAddr,
}

impl NetworkStream for ClientStream {
    fn peer_addr(&mut self) -> Result<SocketAddr> { 
        Ok(self.peer_address.clone())
    }

    fn set_read_timeout(&self, _: Option<Duration>) -> Result<()> {
        Ok(())
    }

    fn set_write_timeout(&self, _: Option<Duration>) -> Result<()> {
        Ok(())
    }
}

impl Write for ClientStream {
    fn write(&mut self, buf: &[u8]) -> Result<usize> {
        let mut own_buffer = self.buffer.lock().expect("client stream write");

        for b in buf {
            own_buffer.push_back(*b);
        }
        Ok(buf.len())
    }
    
    // intermediate buffers! what kind of an operation do you think we're running here????
    fn flush(&mut self) -> Result<()> {
        Ok(())
    }
}

impl Read for ClientStream {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        Err(std::io::Error::new(std::io::ErrorKind::Other, "boop"))
    }
}

pub struct ServerStream {
    buffer: Arc<Mutex<VecDeque<u8>>>,
    peer_address: SocketAddr,
}

impl NetworkStream for ServerStream {
    fn peer_addr(&mut self) -> Result<SocketAddr> {
        Ok(self.peer_address.clone())
    }

    fn set_read_timeout(&self, _: Option<Duration>) -> Result<()> {
        Ok(())
    }

    fn set_write_timeout(&self, _: Option<Duration>) -> Result<()> {
        Ok(())
    }
}

impl Write for ServerStream {
    fn write(&mut self, _: &[u8]) -> Result<usize> {
        Err(std::io::Error::new(std::io::ErrorKind::Other, "boop"))
    }
    
    fn flush(&mut self) -> Result<()> {
        Ok(())
    }
}

impl Read for ServerStream {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        let mut own_buffer = self.buffer.lock().expect("server stream read");

        let mut i = 0;
        while own_buffer.len() != 0 {
            if i >= buf.len() { break; }
            buf[i] = own_buffer.pop_front().unwrap();
            i += 1;
        }

        Ok(i)
    }
}