citadel_sdk 0.14.0 

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

//! Internal kernel for serverless browser-to-browser connections.
//!
//! Adapts to whichever role (server/client) was assigned during signaling.
//! Used internally by [`BrowserConnection`](crate::net::BrowserConnection).

use crate::prefabs::ClientServerRemote;
use crate::prelude::*;
use crate::remote_ext::CitadelClientServerConnection;
use citadel_io::Mutex;
use citadel_proto::prelude::async_trait;

/// Internal kernel that adapts to the server or client role assigned
/// by the serverless signaling layer.
///
/// - **Client role** (`NodeType::Peer`): `on_start()` calls `remote.connect()`
///   with transient auth to the sentinel address `127.0.0.1:0`.
/// - **Server role** (`NodeType::Server`): `on_start()` returns `Ok(())`.
///   `on_node_event_received()` handles inbound `ConnectSuccess`.
///
/// In both cases, the established connection is sent through a oneshot channel
/// to the caller (typically `BrowserConnection::new()`).
pub(crate) struct ServerlessKernel<R: Ratchet> {
    conn_tx:
        Mutex<Option<citadel_io::tokio::sync::oneshot::Sender<CitadelClientServerConnection<R>>>>,
    node_remote: Option<NodeRemote<R>>,
}

impl<R: Ratchet> ServerlessKernel<R> {
    pub(crate) fn new(
        conn_tx: citadel_io::tokio::sync::oneshot::Sender<CitadelClientServerConnection<R>>,
    ) -> Self {
        Self {
            conn_tx: Mutex::new(Some(conn_tx)),
            node_remote: None,
        }
    }

    fn send_connection(&self, conn: CitadelClientServerConnection<R>) {
        if let Some(tx) = self.conn_tx.lock().take() {
            let _ = tx.send(conn);
        }
    }
}

#[async_trait]
impl<R: Ratchet> NetKernel<R> for ServerlessKernel<R> {
    fn load_remote(&mut self, server_remote: NodeRemote<R>) -> Result<(), NetworkError> {
        self.node_remote = Some(server_remote);
        Ok(())
    }

    async fn on_start(&self) -> Result<(), NetworkError> {
        let remote = self.node_remote.clone().unwrap();

        // Only the client role initiates a connect; the server role waits
        // for inbound connections via on_node_event_received.
        if *remote.local_node_type() == NodeType::Peer {
            let sentinel = std::net::SocketAddr::from(([127, 0, 0, 1], 0));
            let auth = AuthenticationRequest::transient(uuid::Uuid::new_v4(), sentinel);
            let connect_success = remote
                .connect(
                    auth,
                    Default::default(),
                    UdpMode::Disabled,
                    None,
                    Default::default(),
                    None,
                )
                .await?;

            let conn_type = VirtualTargetType::LocalGroupServer {
                session_cid: connect_success.cid,
            };
            let client_server_remote = ClientServerRemote::new(
                conn_type,
                remote,
                connect_success.session_security_settings,
                None,
                None,
            );

            self.send_connection(CitadelClientServerConnection {
                channel: connect_success.channel,
                remote: client_server_remote,
                udp_channel_rx: connect_success.udp_channel_rx,
                services: connect_success.services,
                cid: connect_success.cid,
                session_security_settings: connect_success.session_security_settings,
            });

            // Keep the kernel alive until the caller drops BrowserConnection.
            futures::future::pending::<()>().await;
        }

        Ok(())
    }

    async fn on_node_event_received(&self, message: NodeResult<R>) -> Result<(), NetworkError> {
        // Server role: handle inbound ConnectSuccess from the client peer.
        if let NodeResult::ConnectSuccess(ConnectSuccess {
            ticket: _,
            session_cid: cid,
            remote_addr: _,
            is_personal: _,
            v_conn_type: conn_type,
            services,
            welcome_message: _,
            channel,
            udp_rx_opt: udp_channel_rx,
            session_security_settings,
        }) = message
        {
            let client_server_remote = ClientServerRemote::new(
                conn_type,
                self.node_remote.clone().unwrap(),
                session_security_settings,
                None,
                None,
            );

            self.send_connection(CitadelClientServerConnection {
                remote: client_server_remote,
                channel: Some(*channel),
                udp_channel_rx,
                services,
                cid,
                session_security_settings,
            });
        } else {
            log::trace!(target: "citadel", "[ServerlessKernel] Unhandled event: {message:?}");
        }

        Ok(())
    }

    async fn on_stop(&mut self) -> Result<(), NetworkError> {
        Ok(())
    }
}