Struct SocketAppState

Source

pub struct SocketAppState {
    pub handle: SocketServerHandle,
    pub verifier: Arc<dyn RealtimeTokenVerifier>,
}

Expand description

Shared application state for realtime HTTP integration.

This bundles:

handle: transport runtime and messaging API.
verifier: token verification used during websocket upgrade.

Use state.handle for send/subscribe operations.

Fields§

§handle: SocketServerHandle§verifier: Arc<dyn RealtimeTokenVerifier>

Implementations§

Source §

impl SocketAppState

Source

pub fn new<V>(handle: SocketServerHandle, verifier: V) -> Self
where V: RealtimeTokenVerifier,

Create runtime state from a realtime handle and concrete verifier.

Examples found in repository ?

examples/chat_demo.rs (line 78)

68async fn main() -> Result<(), Box<dyn std::error::Error>> {
69    let users = demo_users();
70    let verifier = StaticTokenVerifier::new(&users);
71
72    let server_handle = SocketServerHandle::spawn(Default::default());
73
74    server_handle.on_message("room:lobby", |payload| {
75        println!("Got the payload: {}", payload)
76    });
77
78    let socket_app_state = Arc::new(SocketAppState::new(server_handle, verifier));
79
80    let app = Router::new()
81        .route("/", get(index))
82        .route("/demo/users", get(demo_users_handler))
83        .nest("/api/v1", realtime::server::axum::router(socket_app_state));
84
85    let addr = demo_addr();
86    println!("realtime demo listening on http://{addr}");
87    println!("open http://{addr} in your browser");
88
89    let listener = tokio::net::TcpListener::bind(addr).await?;
90    axum::serve(listener, app).await?;
91    Ok(())
92}

More examples

Hide additional examples

examples/drawing_demo.rs (line 167)

107async fn main() -> Result<(), Box<dyn std::error::Error>> {
108    let users = demo_users();
109    let verifier = StaticTokenVerifier::new(&users);
110    let socket_server_handle = SocketServerHandle::spawn(Default::default());
111    let board_store = BoardStore::default();
112
113    {
114        let server = socket_server_handle.clone();
115        let board_store = board_store.clone();
116        socket_server_handle.on_events(move |channel, event, payload| {
117            if !channel.starts_with("board:") {
118                return;
119            }
120
121            match event.as_str() {
122                STROKE_EVENT => {
123                    board_store.append_chunk(&channel, payload);
124                }
125                BOARD_CLEARED_EVENT => {
126                    board_store.clear_board(&channel);
127                }
128                SYNC_REQUEST_EVENT => {
129                    let Some(requester_user_id) = payload
130                        .get("requester_user_id")
131                        .and_then(Value::as_str)
132                        .map(str::trim)
133                        .filter(|value| !value.is_empty())
134                        .map(|value| value.to_string())
135                    else {
136                        return;
137                    };
138
139                    let chunks = board_store.snapshot(&channel);
140                    let chunk_count = chunks.len();
141                    let snapshot_payload = json!({
142                        "board_channel": channel,
143                        "snapshot_version": 1,
144                        "chunk_count": chunk_count,
145                        "chunks": chunks,
146                    });
147
148                    let server = server.clone();
149                    tokio::spawn(async move {
150                        if let Err(err) = server
151                            .send_event_to_user(
152                                requester_user_id,
153                                SYNC_SNAPSHOT_EVENT,
154                                snapshot_payload,
155                            )
156                            .await
157                        {
158                            eprintln!("failed to send board snapshot: {err}");
159                        }
160                    });
161                }
162                _ => {}
163            }
164        });
165    }
166
167    let socket_app_state = Arc::new(SocketAppState::new(socket_server_handle, verifier));
168
169    let app = Router::new()
170        .route("/", get(index))
171        .route("/demo/users", get(demo_users_handler))
172        .nest("/api/v1", realtime::server::axum::router(socket_app_state));
173
174    let addr = demo_addr();
175    println!("realtime drawing demo listening on http://{addr}");
176    println!("open http://{addr} in your browser");
177
178    let listener = tokio::net::TcpListener::bind(addr).await?;
179    axum::serve(listener, app).await?;
180    Ok(())
181}