smalltalk 0.3.0

Utilities for speeding up development of simple networked applications
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

use std::net::SocketAddr;
use std::fmt::Debug;
use std::ops::{Deref, DerefMut};

use serde::{de::DeserializeOwned, Serialize};
use tokio::net::{TcpListener, ToSocketAddrs};

use crate::socket::{self, interface::SocketUtils};

pub mod error {
    #[derive(thiserror::Error, Debug)]
    pub enum BindServerError {
        #[error("Failed to bind listener!\n{0}")]
        ListenerBindError(#[from] std::io::Error),
    }

    #[derive(thiserror::Error, Debug)]
    #[error("Error while accpeting a connection!")]
    pub struct AcceptConnectionError {
        #[source]
        #[from]
        source: std::io::Error,
    }
}

/// A connection to a client.
/// 
/// produced by the servers accept method
pub struct ClientConnection<H, M, O>
where
    H: crate::header::IsHeader + Debug + Clone,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    sock_interface: SocketUtils<H, M, O>
}

impl<H, M, O> ClientConnection<H, M, O>
where
    H: crate::header::IsHeader + Debug + Clone,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    pub(crate) fn new(addr: SocketAddr, reader: socket::Reader<H, M, O>, writer: socket::Writer<H, M, O>) -> Self {
        Self {
            sock_interface: SocketUtils::new(reader, writer, addr)
        }
    }
}

impl<H, M, O> Deref for ClientConnection<H, M, O>
where
    H: crate::header::IsHeader + Debug + Clone,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    type Target = SocketUtils<H, M, O>;
    fn deref(&self) -> &Self::Target {
        &self.sock_interface
    }
}

impl<H, M, O> DerefMut for ClientConnection<H, M, O>
where
    H: crate::header::IsHeader + Debug + Clone,
    M: Serialize + DeserializeOwned,
    O: bincode::Options + Clone,
{
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.sock_interface
    }
}

/// A Server wrapping a TcpListener,
/// with utils for accepting new clients.
pub struct Server<O>
where
    O: bincode::Options + Clone,
{
    listener: TcpListener,
    bincode_options: O,
}

impl<O> Server<O>
where
    O: bincode::Options + Clone + Send,
{
    /// Binds the server to the provided adress.
    /// The server does not listen for new connections imediataly, for that you need `.listen()`
    ///
    /// The provided callback will be used when running the server,
    /// it is run in a new task, so it can be asynchronously blocking, although should not be non async blocking
    ///
    /// # Errors
    /// if it could not sucessfully bind to the provided adress
    pub async fn bind<A: ToSocketAddrs>(
        addr: A,
        bincode_opts: O,
    ) -> Result<Server<O>, error::BindServerError> {
        let listener = TcpListener::bind(addr).await?;
        Ok(Self {
            listener,
            bincode_options: bincode_opts,
        })
    }

    pub async fn accept<H, M>(
        &mut self,
    ) -> Result<
        ClientConnection<H, M, O>,
        error::AcceptConnectionError,
    >
    where
        H: crate::header::IsHeader + Clone + Send + Debug,
        M: Serialize + DeserializeOwned + Send,
    {
        let conn = self.listener.accept().await?;
        let (read_half, write_half) = socket::split_stream(conn.0, self.bincode_options.clone());
        Ok(ClientConnection::new(conn.1, read_half, write_half))
    }

    pub fn as_listener(&self) -> &TcpListener {
        &self.listener
    }

    pub fn as_listener_mut(&mut self) -> &mut TcpListener {
        &mut self.listener
    }

    pub fn into_listener(self) -> TcpListener {
        self.listener
    }
}