Struct Cluster 

pub struct Cluster { /* private fields */ }

A Cluster manages multiple Gateway Shards.

The Cluster handles:

• Spawning and managing shard tasks
• Coordinating identify rate limiting across shards
• Aggregating events from all shards

Example

use titanium_gateway::{Cluster, ClusterConfig, ShardRange};
use titanium_model::Intents;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClusterConfig::new(
        "your-token",
        Intents::GUILDS | Intents::GUILD_MESSAGES,
        ShardRange::All { total: 1 },
    );

    let (cluster, mut events) = Cluster::new(config);
    cluster.start().await?;

    while let Ok((shard_id, event)) = events.recv_async().await {
        println!("Shard {}: {:?}", shard_id, event);
    }

    Ok(())
}

Implementations

impl Cluster

pub fn new(config: ClusterConfig) -> (Self, Receiver<(u16, Event<'static>)>)

Create a new Cluster.

Returns the Cluster and a receiver for events from all shards. Events are tagged with the shard ID they came from.

pub async fn start(&self) -> Result<(), GatewayError>

Start all shards.

This spawns a task for each shard and begins connecting to Discord. Shards will connect with proper rate limiting based on max_concurrency.

pub fn shard_state(&self, shard_id: u16) -> Option<ShardState>

Get the state of a specific shard.

pub fn shard_latency(&self, shard_id: u16) -> Option<Duration>

Get the last measured latency for a specific shard.

pub fn shard_ids(&self) -> Vec<u16>

Get all shard IDs managed by this cluster.

pub fn send(&self, shard_id: u16, payload: Value) -> Result<(), GatewayError>

Send a raw payload to a specific shard.

pub async fn shutdown(&self)

Shutdown all shards gracefully.