wynd 0.11.1

A simple websocket library for Rust.
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

use std::fmt::Debug;
use std::sync::Arc;
use tokio::io::{AsyncRead, AsyncWrite};

use crate::{conn::Connection, handle::ConnectionHandle, wynd::BoxFuture};

pub type MiddlewareHandler<T> = Arc<
    dyn Fn(
            Arc<Connection<T>>,
            Arc<ConnectionHandle<T>>,
            Next<T>,
        ) -> BoxFuture<Result<(Arc<Connection<T>>, Arc<ConnectionHandle<T>>), String>>
        + Send
        + Sync
        + 'static,
>;

/// Middleware struct that wraps a middleware handler function.
///
/// # Type Parameters
/// - `T`: The type of the underlying connection stream (e.g., `TcpStream`).
///
/// `Middleware` enables users to implement custom logic for connections
/// by chaining asynchronous handler functions which receive the connection,
/// connection handle, and the next middleware in sequence.
pub struct Middleware<T>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug + Send + 'static,
{
    pub(crate) handler: MiddlewareHandler<T>,
}

impl<T> Clone for Middleware<T>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug + Send + 'static,
{
    fn clone(&self) -> Self {
        Self {
            handler: Arc::clone(&self.handler),
        }
    }
}

impl<T> Middleware<T>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug + Send + 'static,
{
    pub(crate) async fn handle<'a>(
        &self,
        conn: Arc<Connection<T>>,
        handle: Arc<ConnectionHandle<T>>,
        next: Next<T>,
    ) -> Result<(Arc<Connection<T>>, Arc<ConnectionHandle<T>>), String> {
        (self.handler)(conn, handle, next).await
    }
}

/// Represents the "next" middleware in the chain.
///
/// The `Next<T>` type encapsulates the mechanism for executing the next middleware
/// handler in the processing chain for a connection. It allows each middleware
/// to optionally call the next handler, or terminate the chain early.
///
/// # Type Parameters
/// - `T`: The type of the underlying connection stream (e.g., `TcpStream`).
pub struct Next<T>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug + Send + 'static,
{
    pub(crate) next_fn: Option<
        Arc<
            dyn Fn(
                    Arc<Connection<T>>,
                    Arc<ConnectionHandle<T>>,
                )
                    -> BoxFuture<Result<(Arc<Connection<T>>, Arc<ConnectionHandle<T>>), String>>
                + Send
                + Sync,
        >,
    >,
}

impl<T> Clone for Next<T>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug + Send + 'static,
{
    fn clone(&self) -> Self {
        Self {
            next_fn: self.next_fn.clone(),
        }
    }
}

impl<T> Next<T>
where
    T: AsyncRead + AsyncWrite + Unpin + Debug + Send + 'static,
{
    pub(crate) fn new(
        next_fn: Arc<
            dyn Fn(
                    Arc<Connection<T>>,
                    Arc<ConnectionHandle<T>>,
                )
                    -> BoxFuture<Result<(Arc<Connection<T>>, Arc<ConnectionHandle<T>>), String>>
                + Send
                + Sync,
        >,
    ) -> Self {
        Self {
            next_fn: Some(next_fn),
        }
    }

    pub(crate) fn finalize() -> Self {
        Self { next_fn: None }
    }

    /// Calls the next middleware function in the chain.
    ///
    /// This method invokes the stored middleware function (`next_fn`), passing the connection and handle forward.
    /// If `next_fn` is `None` (i.e., this is the end of the middleware chain), it simply returns the current connection and handle.
    ///
    /// # Arguments
    ///
    /// * `conn` - An [`Arc`] pointing to the current [`Connection<T>`].
    /// * `handle` - An [`Arc`] pointing to the current [`ConnectionHandle<T>`].
    ///
    /// # Returns
    ///
    /// * [`Ok((Arc<Connection<T>>, Arc<ConnectionHandle<T>>))`] on success, carrying the (possibly updated) connection and handle.
    /// * [`Err(String)`] if an error occurs within the middleware.
    pub async fn call(
        &self,
        conn: Arc<Connection<T>>,
        handle: Arc<ConnectionHandle<T>>,
    ) -> Result<(Arc<Connection<T>>, Arc<ConnectionHandle<T>>), String> {
        match &self.next_fn {
            Some(next) => {
                let result = next(conn, handle).await;
                result
            }
            None => Ok((conn, handle)),
        }
    }
}