Rust SDK Examples
Production-ready examples showing how to use the OddSockets Rust SDK with async patterns and error handling
Basic Usage
Available
Simple example showing how to connect, subscribe to a channel, and publish messages using async/await patterns with proper error handling.
use oddsockets::{OddSocketsClient, OddSocketsConfig};
use tokio;
#[tokio::main]
async fn main() -> Result<(), Box> {
// Create a client
let config = OddSocketsConfig::new("ak_live_1234567890abcdef");
let client = OddSocketsClient::new(config).await?;
// Connect to OddSockets
client.connect().await?;
// Get a channel
let channel = client.channel("my-channel");
// Subscribe to messages
let mut message_stream = channel.subscribe(Default::default()).await?;
// Publish a message
channel.publish("Hello, Rust!", Default::default()).await?;
// Listen for messages
while let Some(message) = message_stream.recv().await {
println!("Received: {:?}", message);
}
Ok(())
} Async Patterns
Available
Advanced async patterns including concurrent message handling, graceful shutdown, and proper resource management with Tokio.
use tokio::{task, signal, select};
use futures::stream::StreamExt;
#[tokio::main]
async fn main() -> Result<(), Box> {
let client = OddSocketsClient::new(config).await?;
let channel = client.channel("events");
let mut message_stream = channel.subscribe(Default::default()).await?;
loop {
select! {
// Handle incoming messages
message = message_stream.next() => {
if let Some(msg) = message {
// Process each message concurrently
task::spawn(async move {
process_message(msg).await;
});
}
}
// Handle shutdown signal
_ = signal::ctrl_c() => {
println!("Shutting down gracefully...");
client.disconnect().await?;
break;
}
}
}
Ok(())
} Error Handling
Available
Comprehensive error handling patterns with structured error types, recovery suggestions, and retry logic for production applications.
use oddsockets::{OddSocketsError, OddSocketsResultExt};
async fn handle_messages() -> Result<(), OddSocketsError> {
let client = OddSocketsClient::new(config).await?;
let channel = client.channel("my-channel");
// Publish with comprehensive error handling
match channel.publish("Hello", Default::default()).await {
Ok(result) => println!("Published: {:?}", result),
Err(OddSocketsError::MessageTooLarge { size_kb, max_size_kb, message }) => {
eprintln!("Message too large: {}KB > {}KB", size_kb, max_size_kb);
eprintln!("Suggestion: {}", message);
}
Err(e) => {
eprintln!("Error: {}", e);
// Check if error is recoverable
if e.is_recoverable() {
println!("Retrying...");
// Implement retry logic
}
}
}
Ok(())
}Bulk Publishing
Available
Efficient bulk message publishing for high-throughput scenarios with batching, error handling, and performance optimization.
use oddsockets::{BulkMessage, message_types};
async fn bulk_publish_example() -> Result<(), Box> {
let client = OddSocketsClient::new(config).await?;
// Prepare bulk messages
let messages = vec![
BulkMessage::new(
"channel1",
message_types::chat_message("Hello", "user1", None),
None
),
BulkMessage::new(
"channel2",
message_types::notification_message(
"Alert",
"System update",
Some("system"),
Some("high"),
None
),
None
),
];
// Publish all messages efficiently
let results = client.publish_bulk(messages).await?;
for (i, result) in results.iter().enumerate() {
if result.is_successful() {
println!("Message {} published successfully", i);
} else {
eprintln!("Message {} failed: {:?}", i, result.error);
}
}
Ok(())
} Chat Application
Available
Complete chat application example with presence tracking, message history, and real-time user interactions using async streams.
use oddsockets::{SubscribeOptions, message_types};
use tokio::io::{self, AsyncBufReadExt, BufReader};
#[tokio::main]
async fn main() -> Result<(), Box> {
let client = OddSocketsClient::new(config).await?;
let channel = client.channel("chat-room");
// Subscribe with presence and history
let options = SubscribeOptions::chat_channel();
let mut message_stream = channel.subscribe(options).await?;
// Handle user input in a separate task
let channel_clone = channel.clone();
tokio::spawn(async move {
let stdin = io::stdin();
let reader = BufReader::new(stdin);
let mut lines = reader.lines();
while let Ok(Some(line)) = lines.next_line().await {
if !line.trim().is_empty() {
let message = message_types::chat_message(
&line,
"rust-user",
None
);
let _ = channel_clone.publish(message, Default::default()).await;
}
}
});
// Handle incoming messages
while let Some(message) = message_stream.recv().await {
println!("[{}] {}: {}",
message.timestamp,
message.user_id.unwrap_or_default(),
message.data["text"]
);
}
Ok(())
} Presence Tracking
Available
Real-time presence tracking example showing how to monitor user join/leave events and maintain active user lists with async streams.
use oddsockets::{SubscribeOptions, EventType};
use std::collections::HashSet;
#[tokio::main]
async fn main() -> Result<(), Box> {
let client = OddSocketsClient::new(config).await?;
let channel = client.channel("presence-demo");
// Subscribe with presence enabled
let options = SubscribeOptions::builder()
.enable_presence(true)
.build();
let mut message_stream = channel.subscribe(options).await?;
let mut active_users = HashSet::new();
while let Some(message) = message_stream.recv().await {
match message.event_type {
EventType::UserJoined => {
if let Some(user_id) = &message.user_id {
active_users.insert(user_id.clone());
println!("👋 {} joined (total: {})", user_id, active_users.len());
}
}
EventType::UserLeft => {
if let Some(user_id) = &message.user_id {
active_users.remove(user_id);
println!("👋 {} left (total: {})", user_id, active_users.len());
}
}
EventType::Message => {
println!("💬 Message from {}: {:?}",
message.user_id.unwrap_or_default(),
message.data
);
}
_ => {}
}
}
Ok(())
}