Struct SocketServerHandle

Source

pub struct SocketServerHandle { /* private fields */ }

Implementations§

Source §

impl SocketServerHandle

Source

pub fn spawn(config: RealtimeConfig) -> Self

Examples found in repository ?

examples/chat_demo.rs (line 72)

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 110)

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}

Source

pub fn spawn_with_policy( config: RealtimeConfig, policy: Arc<dyn ChannelPolicy>, ) -> Self

Source

pub async fn send( &self, channel_name: impl Into<Channel>, message: Payload, ) -> Result<(), RealtimeError>

Source

pub async fn send_to_user( &self, user_id: impl Into<UserId>, message: Payload, ) -> Result<(), RealtimeError>

Source

pub async fn send_event( &self, channel_name: impl Into<Channel>, event: impl Into<Event>, payload: Payload, ) -> Result<(), RealtimeError>

Source

pub async fn send_event_to_user( &self, user_id: impl Into<UserId>, event: impl Into<Event>, payload: Payload, ) -> Result<(), RealtimeError>

Examples found in repository ?

examples/drawing_demo.rs (lines 151-155)

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}

Source

pub async fn emit_to_user( &self, user_id: impl Into<UserId>, event: impl Into<Event>, payload: Payload, ) -> Result<(), RealtimeError>

Source

pub fn on_message<F>(&self, channel: &str, handler: F) -> SubscriptionId
where F: Fn(Payload) + Send + Sync + 'static,

Examples found in repository ?

examples/chat_demo.rs (lines 74-76)

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}

Source

pub fn on_messages<F>(&self, handler: F) -> SubscriptionId
where F: Fn(Channel, Payload) + Send + Sync + 'static,

Source

pub fn on_channel_event<F>(&self, channel: &str, handler: F) -> SubscriptionId
where F: Fn(Event, Payload) + Send + Sync + 'static,

Source

pub fn on_events<F>(&self, handler: F) -> SubscriptionId
where F: Fn(Channel, Event, Payload) + Send + Sync + 'static,

Examples found in repository ?

examples/drawing_demo.rs (lines 116-164)

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}