Struct ShardManager

pub struct ShardManager {
    pub token: String,
    pub total_shards: usize,
    pub shards: Arc<RwLock<ShardMap>>,
    /* private fields */
}

The central hub for all shards, where shards are spawned and maintained.

Fields

token: String

The token used by this manager to spawn shards.

total_shards: usize

The total amount of shards that this manager will attempt to spawn.

shards: Arc<RwLock<ShardMap>>

A collection of shards that have been spawned.

Implementations

impl ShardManager

pub fn new( token: String, strategy: ShardStrategy, ) -> impl Future<Item = ShardManager, Error = Error>

Creates a new cluster, with the provided Discord API token.

Examples found in repository

examples/sharder.rs (line 12)

fn main() {
    let token = var("DISCORD_TOKEN").expect("Failed to parse Discord token");

    // Here, we initialize a new shard manager, with the provided Discord token and strategy.
    // We use the recommended sharding strategy, but a fixed shard strategy may also be chosen.
    tokio::run(ShardManager::new(token, ShardStrategy::Recommended)
        .map(|mut manager| {
            // The start_spawn() method returns a tuple of streams: One for handling spawned shards, the other for handling shard events.
            let (spawner, events) = manager.start_spawn();
            // As demonstrated below, we consume the streams concurrently between threads.
            tokio::spawn(spawner.for_each(|shard| {
                println!("Shard {:?} has successfully spawned.", shard.lock().info);

                Ok(())
            }));
            tokio::spawn(events.for_each(|event| {
                if let Some(evt) = event.packet.t {
                    println!("Received event from Shard {:?}: {:?}", event.shard.lock().info, evt);
                };

                Ok(())
            }));
        })
        .map_err(|err| {
            eprintln!("Error occured: {:?}", err);
        })
    );
}

pub fn start_spawn(&mut self) -> (Spawner, EventHandler)

Spawns shards up to the specified amount and identifies them with Discord.

Examples found in repository

examples/sharder.rs (line 15)

fn main() {
    let token = var("DISCORD_TOKEN").expect("Failed to parse Discord token");

    // Here, we initialize a new shard manager, with the provided Discord token and strategy.
    // We use the recommended sharding strategy, but a fixed shard strategy may also be chosen.
    tokio::run(ShardManager::new(token, ShardStrategy::Recommended)
        .map(|mut manager| {
            // The start_spawn() method returns a tuple of streams: One for handling spawned shards, the other for handling shard events.
            let (spawner, events) = manager.start_spawn();
            // As demonstrated below, we consume the streams concurrently between threads.
            tokio::spawn(spawner.for_each(|shard| {
                println!("Shard {:?} has successfully spawned.", shard.lock().info);

                Ok(())
            }));
            tokio::spawn(events.for_each(|event| {
                if let Some(evt) = event.packet.t {
                    println!("Received event from Shard {:?}: {:?}", event.shard.lock().info, evt);
                };

                Ok(())
            }));
        })
        .map_err(|err| {
            eprintln!("Error occured: {:?}", err);
        })
    );
}