refactor(gateway)!: remove create_* set of functions

.github/workflows/check.yml

@@ -205,7 +205,7 @@ jobs:
 
     steps:
       - name: Checkout sources
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3
 
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@stable

README.md

@@ -121,7 +121,7 @@ bot's token. You must also depend on `futures`, `tokio`,
 ```rust,no_run
 use std::{env, error::Error, sync::Arc};
 use twilight_cache_inmemory::{InMemoryCache, ResourceType};
-use twilight_gateway::{Event, Shard, ShardId};
+use twilight_gateway::{Config, Event, Shard, ShardId};
 use twilight_http::Client as HttpClient;
 use twilight_model::gateway::Intents;
 
@@ -133,11 +133,8 @@ async fn main() -> anyhow::Result<()> {
     let token = env::var("DISCORD_TOKEN")?;
 
     // Use intents to only receive guild message events.
-    let mut shard = Shard::new(
-        ShardId::ONE,
-        token.clone(),
-        Intents::GUILD_MESSAGES | Intents::MESSAGE_CONTENT,
-    );
+    let config = Config::new(token.clone(), Intents::GUILD_MESSAGES | Intents::MESSAGE_CONTENT);
+    let mut shard = Shard::new(ShardId::ONE, config);
 
     // HTTP is separate from the gateway, so create a new client.
     let http = Arc::new(HttpClient::new(token));

book/src/chapter_1_crates/section_3_gateway.md

@@ -89,16 +89,16 @@ Starting a `Shard` and printing the contents of new messages as they come in:
 
 ```rust,no_run
 use std::{env, error::Error};
-use twilight_gateway::{Intents, Shard, ShardId};
+use twilight_gateway::{Config, Intents, Shard, ShardId};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // Initialize the tracing subscriber.
     tracing_subscriber::fmt::init();
 
     let token = env::var("DISCORD_TOKEN")?;
-    let intents = Intents::GUILD_MESSAGES;
-    let mut shard = Shard::new(ShardId::ONE, token, intents);
+    let config = Config::new(token, Intents::GUILD_MESSAGES);
+    let mut shard = Shard::new(ShardId::ONE, config);
     tracing::info!("created shard");
 
     loop {

book/src/chapter_1_crates/section_4_cache_inmemory.md

@@ -13,11 +13,12 @@ Process new messages that come over a shard into the cache:
 # async fn main() -> Result<(), Box<dyn std::error::Error>> {
 use std::env;
 use twilight_cache_inmemory::InMemoryCache;
-use twilight_gateway::{Intents, Shard, ShardId};
+use twilight_gateway::{Config, Intents, Shard, ShardId};
 
 let token = env::var("DISCORD_TOKEN")?;
 
-let mut shard = Shard::new(ShardId::ONE, token, Intents::GUILD_MESSAGES);
+let config = Config::new(token, Intents::GUILD_MESSAGES);
+let mut shard = Shard::new(ShardId::ONE, config);
 
 let cache = InMemoryCache::new();
 

book/src/chapter_1_crates/section_7_first_party/section_3_lavalink.md

@@ -48,7 +48,7 @@ use std::{
     net::SocketAddr,
     str::FromStr,
 };
-use twilight_gateway::{Intents, Shard, ShardId};
+use twilight_gateway::{Config, Intents, Shard, ShardId};
 use twilight_http::Client as HttpClient;
 use twilight_lavalink::Lavalink;
 
@@ -65,8 +65,8 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let lavalink = Lavalink::new(user_id, shard_count);
     lavalink.add(lavalink_host, lavalink_auth).await?;
 
-    let intents = Intents::GUILD_MESSAGES | Intents::GUILD_VOICE_STATES;
-    let mut shard = Shard::new(ShardId::ONE, token, intents);
+    let config = Config::new(token, Intents::GUILD_MESSAGES | Intents::GUILD_VOICE_STATES);
+    let mut shard = Shard::new(ShardId::ONE, config);
 
     loop {
         let event = match shard.next_event().await {

book/src/overview.md

@@ -48,7 +48,7 @@ in from a channel:
 ```rust,no_run
 use std::{env, error::Error, sync::Arc};
 use twilight_cache_inmemory::{InMemoryCache, ResourceType};
-use twilight_gateway::{Event, Intents, Shard, ShardId};
+use twilight_gateway::{Config, Event, Intents, Shard, ShardId};
 use twilight_http::Client as HttpClient;
 
 #[tokio::main]
@@ -58,9 +58,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
     // Specify intents requesting events about things like new and updated
     // messages in a guild and direct messages.
     let intents = Intents::GUILD_MESSAGES | Intents::DIRECT_MESSAGES | Intents::MESSAGE_CONTENT;
-
+    let config = Config::new(token.clone(), intents);
     // Create a single shard.
-    let mut shard = Shard::new(ShardId::ONE, token.clone(), intents);
+    let mut shard = Shard::new(ShardId::ONE, config);
 
     // The http client is separate from the gateway, so startup a new
     // one, also use Arc such that it can be cloned to other threads.

examples/Cargo.toml

@@ -24,10 +24,6 @@ twilight-lavalink = { path = "../twilight-lavalink" }
 twilight-model = { path = "../twilight-model" }
 twilight-standby = { path = "../twilight-standby" }
 
-[[example]]
-name = "gateway-intents"
-path = "gateway-intents.rs"
-
 [[example]]
 name = "gateway-parallel"
 path = "gateway-parallel.rs"
@@ -40,10 +36,6 @@ path = "gateway-reshard.rs"
 name = "gateway-request-members"
 path = "gateway-request-members.rs"
 
-[[example]]
-name = "gateway-shard"
-path = "gateway-shard.rs"
-
 [[example]]
 name = "http-allowed-mentions"
 path = "http-allowed-mentions.rs"

examples/gateway-parallel.rs

@@ -5,13 +5,9 @@
 //! [`ShardMessageStream`]: twilight_gateway::stream::ShardMessageStream
 
 use futures_util::{future::join_all, StreamExt};
-use std::{env, iter, sync::Arc, thread};
+use std::{env, iter, thread};
 use tokio::{signal, sync::watch, task::JoinSet};
-use twilight_gateway::{
-    queue::LocalQueue,
-    stream::{self, ShardEventStream},
-    CloseFrame, Config, Intents, Shard,
-};
+use twilight_gateway::{stream::ShardEventStream, CloseFrame, Config, Intents, Shard, ShardId};
 use twilight_http::Client;
 
 #[tokio::main]
@@ -21,29 +17,24 @@ async fn main() -> anyhow::Result<()> {
     let token = env::var("DISCORD_TOKEN")?;
     let client = Client::new(token.clone());
 
-    let queue = Arc::new(LocalQueue::new());
-    // callback to create a config for each shard, useful for when not all
-    // shards have the same configuration, such as for per-shard presences
-    let config_callback = |_| {
-        Config::builder(token.clone(), Intents::GUILDS)
-            .queue(queue.clone())
-            .build()
+    let config = Config::new(token, Intents::GUILDS);
+    let recommended_shards = client.gateway().authed().await?.model().await?.shards;
+    let shards = {
+        let tasks = thread::available_parallelism()?.get();
+
+        // Split shards into a vec of `tasks` vecs of shards.
+        let init = iter::repeat_with(Vec::new)
+            .take(tasks)
+            .collect::<Vec<Vec<_>>>();
+        (0..recommended_shards)
+            .map(|id| Shard::new(ShardId::new(id, recommended_shards), config.clone()))
+            .enumerate()
+            .fold(init, |mut fold, (idx, shard)| {
+                fold[idx % tasks].push(shard);
+                fold
+            })
     };
 
-    let tasks = thread::available_parallelism()?.get();
-
-    // Split shards into a vec of `tasks` vecs of shards.
-    let init = iter::repeat_with(Vec::new)
-        .take(tasks)
-        .collect::<Vec<Vec<_>>>();
-    let shards = stream::create_recommended(&client, config_callback)
-        .await?
-        .enumerate()
-        .fold(init, |mut fold, (idx, shard)| {
-            fold[idx % tasks].push(shard);
-            fold
-        });
-
     let (tx, rx) = watch::channel(false);
 
     let mut set = JoinSet::new();

examples/gateway-request-members.rs

@@ -1,17 +1,16 @@
 use std::env;
-use twilight_gateway::{Event, Intents, Shard, ShardId};
+use twilight_gateway::{Config, Event, Intents, Shard, ShardId};
 use twilight_model::{gateway::payload::outgoing::RequestGuildMembers, id::Id};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     // Initialize the tracing subscriber.
     tracing_subscriber::fmt::init();
 
-    let mut shard = Shard::new(
-        ShardId::ONE,
-        env::var("DISCORD_TOKEN")?,
-        Intents::GUILD_MEMBERS | Intents::GUILDS,
-    );
+    let token = env::var("DISCORD_TOKEN")?;
+
+    let config = Config::new(token, Intents::GUILD_MEMBERS | Intents::GUILDS);
+    let mut shard = Shard::new(ShardId::ONE, config);
 
     loop {
         let event = match shard.next_event().await {

examples/gateway-reshard.rs

@@ -2,8 +2,7 @@ use futures_util::StreamExt;
 use std::{env, sync::Arc, time::Duration};
 use tokio::time;
 use twilight_gateway::{
-    queue::{LocalQueue, Queue},
-    stream::{self, ShardEventStream, ShardMessageStream},
+    stream::{ShardEventStream, ShardMessageStream},
     Config, Event, Intents, Shard, ShardId,
 };
 use twilight_http::Client;
@@ -15,21 +14,12 @@ async fn main() -> anyhow::Result<()> {
 
     let token = env::var("DISCORD_TOKEN")?;
     let client = Arc::new(Client::new(token.clone()));
-    let queue: Arc<dyn Queue> = Arc::new(LocalQueue::new());
-
-    let config_callback = |_| {
-        // A queue must be specified in the builder for the shards to reuse the
-        // same one, which is necessary to not hit any gateway queue ratelimit.
-        Config::builder(
-            token.clone(),
-            Intents::GUILD_MESSAGES | Intents::MESSAGE_CONTENT,
-        )
-        .queue(Arc::clone(&queue))
-        .build()
-    };
-    let mut shards = stream::create_recommended(&client, &config_callback)
-        .await?
-        .collect::<Vec<_>>();
+
+    let config = Config::new(token, Intents::GUILD_MESSAGES | Intents::MESSAGE_CONTENT);
+    let recommended_shards = client.gateway().authed().await?.model().await?.shards;
+    let mut shards = (0..recommended_shards)
+        .map(|id| Shard::new(ShardId::new(id, recommended_shards), config.clone()))
+        .collect();
 
     loop {
         // Run `gateway_runner` and `reshard` concurrently until the first one
@@ -40,7 +30,7 @@ async fn main() -> anyhow::Result<()> {
             _ = gateway_runner(Arc::clone(&client), shards) => break,
             // Resharding complete! Time to run `gateway_runner` with the new
             // list of shards.
-            Ok(Some(new_shards)) = reshard(&client, config_callback) => {
+            Ok(Some(new_shards)) = reshard(&client, config.clone()) => {
                     // Assign the new list of shards to `shards`, dropping the
                     // old list.
                     shards = new_shards;
@@ -92,17 +82,15 @@ async fn event_handler(client: Arc<Client>, event: Event) -> anyhow::Result<()>
 // Instrument to differentiate between the logs produced here and
 // in `gateway_runner`.
 #[tracing::instrument(skip_all)]
-async fn reshard(
-    client: &Client,
-    config_callback: impl Fn(ShardId) -> Config,
-) -> anyhow::Result<Option<Vec<Shard>>> {
+async fn reshard(client: &Client, config: Config) -> anyhow::Result<Option<Vec<Shard>>> {
     const RESHARD_DURATION: Duration = Duration::from_secs(60 * 60 * 8);
 
     // Reshard every eight hours.
     time::sleep(RESHARD_DURATION).await;
 
-    let mut shards = stream::create_recommended(client, config_callback)
-        .await?
+    let recommended_shards = client.gateway().authed().await?.model().await?.shards;
+    let mut shards = (0..recommended_shards)
+        .map(|id| Shard::new(ShardId::new(id, recommended_shards), config.clone()))
         .collect::<Vec<_>>();
 
     let mut identified = vec![false; shards.len()];

examples/lavalink-basic-bot.rs

@@ -3,7 +3,7 @@ use hyper::{
     Body, Request,
 };
 use std::{env, future::Future, net::SocketAddr, str::FromStr, sync::Arc};
-use twilight_gateway::{Event, Intents, MessageSender, Shard, ShardId};
+use twilight_gateway::{Config, Event, Intents, MessageSender, Shard, ShardId};
 use twilight_http::Client as HttpClient;
 use twilight_lavalink::{
     http::LoadedTracks,
@@ -54,7 +54,8 @@ async fn main() -> anyhow::Result<()> {
 
         let intents =
             Intents::GUILD_MESSAGES | Intents::GUILD_VOICE_STATES | Intents::MESSAGE_CONTENT;
-        let shard = Shard::new(ShardId::ONE, token, intents);
+        let config = Config::new(token, intents);
+        let shard = Shard::new(ShardId::ONE, config);
         let sender = shard.sender();
 
         (

twilight-cache-inmemory/README.md

@@ -35,15 +35,16 @@ Update a cache with events that come in through the gateway:
 ```rust,no_run
 use std::{env, error::Error};
 use twilight_cache_inmemory::InMemoryCache;
-use twilight_gateway::{Intents, Shard, ShardId};
+use twilight_gateway::{Config, Intents, Shard, ShardId};
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     // Initialize the tracing subscriber.
     tracing_subscriber::fmt::init();
 
     let token = env::var("DISCORD_TOKEN")?;
-    let mut shard = Shard::new(ShardId::ONE, token, Intents::GUILD_MESSAGES);
+    let config = Config::new(token, Intents::GUILD_MESSAGES);
+    let mut shard = Shard::new(ShardId::ONE, config);
 
     // Create a cache, caching up to 10 messages per channel:
     let cache = InMemoryCache::builder().message_cache_size(10).build();