feat(lavalink)!: Lavalink refactor to v4 API

examples/lavalink-basic-bot.rs

@@ -9,6 +9,10 @@ use twilight_gateway::{
     Event, EventTypeFlags, Intents, MessageSender, Shard, ShardId, StreamExt as _,
 };
 use twilight_http::Client as HttpClient;
+use twilight_lavalink::{
+    http::LoadResultData::{Playlist, Search, Track},
+    model::{Equalizer, EqualizerBand},
+};
 use twilight_lavalink::{
     http::LoadedTracks,
     model::{Destroy, Pause, Play, Seek, Stop, Volume},
@@ -53,6 +57,7 @@ async fn main() -> anyhow::Result<()> {
         let http = HttpClient::new(token.clone());
         let user_id = http.current_user().await?.model().await?.id;
 
+        // The client is [`Lavalink`](crate::client::Lavalink) that forwards the required events from Discord.
         let lavalink = Lavalink::new(user_id, shard_count);
         lavalink.add(lavalink_host, lavalink_auth).await?;
 
@@ -81,6 +86,10 @@ async fn main() -> anyhow::Result<()> {
         };
 
         state.standby.process(&event);
+
+        // We read the [Voice State and Voice Server Updates](https://discord.com/developers/docs/topics/gateway-events#voice) from discord to format the data to send to a Lavalink `VoiceUpdate` Event.
+        // There is a lower level [node](crate::node) that processes this for you. It isn't recommended to use this but rather the lavalink struct with the players. If you don't find functionality please open up and issue to expose what you need.
+        // See the command functions for where we use the players.
         state.lavalink.process(&event).await?;
 
         if let Event::MessageCreate(msg) = event {
@@ -96,6 +105,7 @@ async fn main() -> anyhow::Result<()> {
                 Some("!seek") => spawn(seek(msg.0, Arc::clone(&state))),
                 Some("!stop") => spawn(stop(msg.0, Arc::clone(&state))),
                 Some("!volume") => spawn(volume(msg.0, Arc::clone(&state))),
+                Some("!equalize") => spawn(equalize(msg.0, Arc::clone(&state))),
                 _ => continue,
             }
         }
@@ -194,13 +204,21 @@ async fn play(msg: Message, state: State) -> anyhow::Result<()> {
 
     let loaded = serde_json::from_slice::<LoadedTracks>(&response_bytes)?;
 
-    if let Some(track) = loaded.tracks.first() {
-        player.send(Play::from((guild_id, &track.track)))?;
+    let track = match loaded.data {
+        Track(track) => Some(track),
+        Playlist(top_track) => top_track.tracks.first().cloned(),
+        Search(result) => result.first().cloned(),
+        _ => None,
+    };
+
+    if let Some(track) = track {
+        player.send(Play::from((guild_id, &track.encoded)))?;
 
         let content = format!(
             "Playing **{:?}** by **{:?}**",
             track.info.title, track.info.author
         );
+
         state
             .http
             .create_message(msg.channel_id)
@@ -274,6 +292,57 @@ async fn seek(msg: Message, state: State) -> anyhow::Result<()> {
     Ok(())
 }
 
+async fn equalize(msg: Message, state: State) -> anyhow::Result<()> {
+    tracing::debug!(
+        "equalize command in channel {} by {}",
+        msg.channel_id,
+        msg.author.name
+    );
+    state
+        .http
+        .create_message(msg.channel_id)
+        .content("What band do you want to equalize (0-14)?")
+        .await?;
+
+    let author_id = msg.author.id;
+    let band_msg = state
+        .standby
+        .wait_for_message(msg.channel_id, move |new_msg: &MessageCreate| {
+            new_msg.author.id == author_id
+        })
+        .await?;
+    let guild_id = msg.guild_id.unwrap();
+    let band = band_msg.content.parse::<i64>()?;
+
+    state
+        .http
+        .create_message(msg.channel_id)
+        .content("What gain do you want to equalize (-0.25 to 1.0)?")
+        .await?;
+
+    let gain_msg = state
+        .standby
+        .wait_for_message(msg.channel_id, move |new_msg: &MessageCreate| {
+            new_msg.author.id == author_id
+        })
+        .await?;
+    let gain = gain_msg.content.parse::<f64>()?;
+
+    let player = state.lavalink.player(guild_id).await.unwrap();
+    player.send(Equalizer::from((
+        guild_id,
+        vec![EqualizerBand::new(band, gain)],
+    )))?;
+
+    state
+        .http
+        .create_message(msg.channel_id)
+        .content(&format!("Changed gain level to {gain} on band {band}."))
+        .await?;
+
+    Ok(())
+}
+
 async fn stop(msg: Message, state: State) -> anyhow::Result<()> {
     tracing::debug!(
         "stop command in channel {} by {}",

twilight-lavalink/Cargo.toml

@@ -17,15 +17,16 @@ version = "0.16.0-rc.1"
 dashmap = { default-features = false, version = "5.3" }
 futures-util = { default-features = false, features = ["bilock", "sink", "std", "unstable"], version = "0.3" }
 http = { default-features = false, version = "1" }
+hyper = { default-features = false, features = ["client", "http1"], version = "1" }
+hyper-util = { default-features = false, features = ["client-legacy", "client", "http1", "tokio"], version = "0.1" }
+http-body-util = "0.1"
 serde = { default-features = false, features = ["derive", "std"], version = "1" }
 serde_json = { default-features = false, features = ["std"], version = "1" }
 tokio = { default-features = false, features = ["macros", "net", "rt", "sync", "time"], version = "1.0" }
 tokio-websockets = { default-features = false, features = ["client", "fastrand", "sha1_smol", "simd"], version = "0.7" }
 tracing = { default-features = false, features = ["std", "attributes"], version = "0.1" }
 twilight-model = { default-features = false, path = "../twilight-model", version = "0.16.0-rc.1" }
-
-# Optional dependencies.
-percent-encoding = { default-features = false, optional = true, version = "2" }
+percent-encoding = { default-features = false, version = "2" }
 
 [dev-dependencies]
 anyhow = { default-features = false, features = ["std"], version = "1" }
@@ -37,8 +38,8 @@ twilight-gateway = { default-features = false, features = ["rustls-native-roots"
 twilight-http = { default-features = false, features = ["rustls-native-roots"], path = "../twilight-http", version = "0.16.0-rc.1" }
 
 [features]
-default = ["http-support", "rustls-native-roots"]
-http-support = ["dep:percent-encoding"]
+default = ["http2", "rustls-native-roots"]
+http2 = ["hyper/http2", "hyper-util/http2"]
 native-tls = ["tokio-websockets/native-tls", "tokio-websockets/openssl"]
 rustls-native-roots = ["tokio-websockets/ring", "tokio-websockets/rustls-native-roots"]
 rustls-webpki-roots = ["tokio-websockets/ring", "tokio-websockets/rustls-webpki-roots"]

twilight-lavalink/README.md

@@ -13,12 +13,19 @@ handle sending voice channel updates to Lavalink by processing events via
 the [client's `process` method][`Lavalink::process`], which you must call
 with every Voice State Update and Voice Server Update you receive.
 
+Currently some [Filters](crate::model::outgoing::Filters) are not yet supported.
+Some endpoints such as [Lavalink Info] and [Update Session] have also not yet
+been implemented. Please reach out and open an issue for any missing feature you
+would like to use. The Lavalink V4 port did not add support for any new features
+not previously found in V3.
+
 ## Features
 
-### `http-support`
+### `http2`
 
-The `http-support` feature adds support for the `http` module to return
-request types from the [`http`] crate. This is enabled by default.
+The `http2` feature enables support for communicating with the Lavalink server
+over HTTP/2. You will also need to enable http2 support in your Lavalink server
+configuration as it is disabled by default.
 
 ### TLS
 
@@ -104,6 +111,8 @@ There is also an example of a basic bot located in the [root of the
 `twilight` repository][github examples link].
 
 [Lavalink]: https://github.com/freyacodes/Lavalink
+[Lavalink Info]: https://lavalink.dev/api/rest.html#get-lavalink-version
+[Update Session]: https://lavalink.dev/api/rest#update-session
 [`http`]: https://crates.io/crates/http
 [`rustls`]: https://crates.io/crates/rustls
 [`rustls-native-certs`]: https://crates.io/crates/rustls-native-certs

twilight-lavalink/src/client.rs

@@ -103,7 +103,7 @@ pub struct Lavalink {
     shard_count: u32,
     user_id: Id<UserMarker>,
     server_updates: DashMap<Id<GuildMarker>, VoiceServerUpdate>,
-    sessions: DashMap<Id<GuildMarker>, Box<str>>,
+    discord_sessions: DashMap<Id<GuildMarker>, Box<str>>,
 }
 
 impl Lavalink {
@@ -145,7 +145,7 @@ impl Lavalink {
             shard_count,
             user_id,
             server_updates: DashMap::new(),
-            sessions: DashMap::new(),
+            discord_sessions: DashMap::new(),
         }
     }
 
@@ -199,10 +199,10 @@ impl Lavalink {
                     }
 
                     if e.channel_id.is_none() {
-                        self.sessions.remove(&guild_id);
+                        self.discord_sessions.remove(&guild_id);
                         self.server_updates.remove(&guild_id);
                     } else {
-                        self.sessions
+                        self.discord_sessions
                             .insert(guild_id, e.session_id.clone().into_boxed_str());
                     }
                     guild_id
@@ -218,7 +218,7 @@ impl Lavalink {
 
         let update = {
             let server = self.server_updates.get(&guild_id);
-            let session = self.sessions.get(&guild_id);
+            let session = self.discord_sessions.get(&guild_id);
             match (server, session) {
                 (Some(server), Some(session)) => {
                     let server = server.value();
@@ -386,7 +386,7 @@ impl Lavalink {
 
         self.server_updates
             .retain(|k, _| (k.get() >> 22) % shard_count != u64::from(shard_id));
-        self.sessions
+        self.discord_sessions
             .retain(|k, _| (k.get() >> 22) % shard_count != u64::from(shard_id));
     }
 }