1
use crate::{
2
    context::Context,
3
    server::{Server, ServerCodec},
4
    version::VersionFrame,
5
    Error, Frame, Protocol, Rversion, Version,
6
};
7
use async_trait::async_trait;
8
use futures::SinkExt;
9
use futures::StreamExt;
10
use jetstream_error::IntoError;
11
use std::{collections::HashMap, str::FromStr, sync::Arc};
12
use tokio::{
13
    io::{AsyncRead, AsyncWrite},
14
    sync::mpsc,
15
};
16
use tokio_util::codec::{FramedRead, FramedWrite};
17
use tracing::{error, instrument};
18

            
19
pub trait Incoming: AsyncRead + AsyncWrite + Send + Sync {}
20

            
21
#[async_trait]
22
pub trait Handler: Send + Sync {
23
    async fn handle(
24
        &self,
25
        ctx: Context,
26
        reader: Box<dyn AsyncRead + Send + Sync + Unpin>,
27
        writer: Box<dyn AsyncWrite + Send + Sync + Unpin>,
28
    ) -> Result<(), Error>;
29
}
30

            
31
#[derive(Clone)]
32
pub struct Router {
33
    handlers: HashMap<String, Arc<Box<dyn Handler>>>,
34
}
35

            
36
impl std::fmt::Debug for Router {
37
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
38
        f.debug_struct("Router")
39
            .field("handlers", &self.handlers.keys().collect::<Vec<_>>())
40
            .finish()
41
    }
42
}
43

            
44
impl Router {
45
28
    pub fn new() -> Self {
46
28
        Self {
47
28
            handlers: HashMap::new(),
48
28
        }
49
28
    }
50

            
51
    /// Register a handler for a protocol name.
52
    /// The name should match the protocol name portion from
53
    /// `rs.jetstream.proto/{name}/{version}`, or `9P2000`/`9P2000.L` for legacy protocols.
54
1
    pub fn with_handler(
55
1
        mut self,
56
1
        name: &str,
57
1
        handler: impl Handler + 'static,
58
1
    ) -> Self {
59
1
        self.handlers
60
1
            .insert(name.to_string(), Arc::new(Box::new(handler)));
61
1
        self
62
1
    }
63
}
64

            
65
impl Default for Router {
66
    fn default() -> Self {
67
        Self::new()
68
    }
69
}
70

            
71
struct VersionProtocol {}
72

            
73
impl Protocol for VersionProtocol {
74
    type Request = crate::version::VersionFrame;
75

            
76
    type Response = crate::version::VersionFrame;
77

            
78
    type Error = Error;
79

            
80
    const VERSION: &'static str = "";
81

            
82
    const NAME: &'static str = "";
83
}
84

            
85
impl Router {
86
    #[instrument(skip_all)]
87
28
    pub async fn accept(
88
28
        &self,
89
28
        ctx: Context,
90
28
        reader: Box<dyn AsyncRead + Send + Sync + Unpin>,
91
28
        writer: Box<dyn AsyncWrite + Send + Sync + Unpin>,
92
28
    ) -> Result<(), Error> {
93
        let mut framed_read =
94
            FramedRead::new(reader, ServerCodec::<VersionProtocol>::new());
95
        let mut framed_write =
96
            FramedWrite::new(writer, ServerCodec::<VersionProtocol>::new());
97

            
98
        let version = framed_read.next().await;
99

            
100
        let Some(frame) = version else {
101
            return Err(Error::with_code(
102
                "connection closed before version negotiation",
103
                "jetstream_rpc::error::no_version",
104
            ));
105
        };
106

            
107
        let frame = frame?;
108
        {
109
            match frame.msg {
110
                VersionFrame::Tversion(tversion) => {
111
                    let version: Version = Version::from_str(&tversion.version)
112
                        .map_err(|e| {
113
                            Error::with_code(
114
                                e,
115
                                "jetstream_rpc::error::version_negotiation",
116
                            )
117
                        })?;
118
                    let (handler, version) = match version {
119
                        Version::V9P2000L => {
120
                            if let Some(handler) = self
121
                                .handlers
122
                                .get(&Version::V9P2000L.to_string())
123
                            {
124
                                (handler, version)
125
                            } else {
126
                                return Err(
127
                                    Error::with_code(
128
                                        "handler not found",
129
                                        "jetstream_rpc::error::jetstream_handler_not_found",
130
                                    )
131
                                );
132
                            }
133
                        }
134
                        Version::V9P2000 => {
135
                            if let Some(handler) =
136
                                self.handlers.get(&Version::V9P2000.to_string())
137
                            {
138
                                (handler, version)
139
                            } else {
140
                                return Err(
141
                                    Error::with_code(
142
                                        "handler not found",
143
                                        "jetstream_rpc::error::jetstream_handler_not_found",
144
                                    )
145
                                );
146
                            }
147
                        }
148
                        Version::JetStream { ref name, .. } => {
149
                            if let Some(handler) = self.handlers.get(name) {
150
                                (handler, version)
151
                            } else {
152
                                return Err(
153
                                    Error::with_code(
154
                                        "handler not found",
155
                                        "jetstream_rpc::error::jetstream_handler_not_found",
156
                                    )
157
                                );
158
                            }
159
                        }
160
                    };
161
                    framed_write
162
                        .send(Frame {
163
                            tag: frame.tag,
164
                            msg: VersionFrame::Rversion(Rversion {
165
                                msize: tversion.msize,
166
                                version: version.to_string(),
167
                            }),
168
                        })
169
                        .await?;
170

            
171
                    let reader = framed_read.into_inner();
172
                    let writer = framed_write.into_inner();
173
                    handler.handle(ctx, reader, writer).await?;
174
                }
175
                VersionFrame::Rversion(_) => {
176
                    return Err(Error::with_code(
177
                        "Client sent Rversion instead of Tversion",
178
                        "jetstream_rpc::error::unexpected_rversion",
179
                    ))
180
                }
181
            }
182
        }
183
        Ok(())
184
26
    }
185
}
186

            
187
#[async_trait]
188
impl<T: Server + Clone + 'static> Handler for T {
189
    async fn handle(
190
        &self,
191
        ctx: Context,
192
        reader: Box<dyn AsyncRead + Send + Sync + Unpin>,
193
        writer: Box<dyn AsyncWrite + Send + Sync + Unpin>,
194
1
    ) -> Result<(), Error> {
195
        let server = self.clone();
196
1
        tokio::spawn(async move {
197
1
            let mut reader = FramedRead::new(reader, ServerCodec::<T>::new());
198
1
            let mut writer = FramedWrite::new(writer, ServerCodec::<T>::new());
199

            
200
            // Channel for sending responses back to the writer
201
            let (resp_tx, mut resp_rx) =
202
1
                mpsc::channel::<Frame<T::Response>>(256);
203

            
204
            // Spawn a task to write responses as they complete
205
1
            let writer_task = tokio::spawn(async move {
206
101
                while let Some(resp) = resp_rx.recv().await {
207
100
                    if writer.send(resp).await.is_err() {
208
                        break;
209
100
                    }
210
                }
211
            });
212

            
213
            // Process requests concurrently
214
101
            while let Some(req) = reader.next().await {
215
100
                let ctx = ctx.clone();
216
100
                match req {
217
                    Ok(req) => {
218
100
                        let mut handler = server.clone();
219
100
                        let resp_tx = resp_tx.clone();
220
100
                        tokio::spawn(async move {
221
100
                            match handler.rpc(ctx, req).await {
222
                                Ok(resp) => {
223
100
                                    let _ = resp_tx.send(resp).await;
224
                                }
225
                                Err(err) => {
226
                                    let error = err.into_error();
227
                                    eprintln!(
228
                                        "Error processing request: {}",
229
                                        error
230
                                    );
231
                                }
232
                            }
233
100
                        });
234
                    }
235
                    Err(err) => {
236
                        error!("Error decoding request frame: {}", err);
237
                    }
238
                };
239
            }
240

            
241
            // Drop the sender so the writer task knows to finish
242
            drop(resp_tx);
243
            let _ = writer_task.await;
244
        });
245
        Ok(())
246
1
    }
247
}