disable arm target

Reviewed-on: #6

.gitea/workflows/deploy.yaml

@@ -26,6 +26,6 @@ jobs:
         with:
           platforms: |
             linux/amd64
-            linux/arm64
+            # linux/arm64
           push: true
           tags: jheuel/ohrwurm:latest

src/colors.rs

@@ -1,2 +1,20 @@
+#[allow(dead_code)]
 pub(crate) const BLURPLE: u32 = 0x58_65_F2;
+#[allow(dead_code)]
 pub(crate) const YELLOW: u32 = 0xFE_E7_5C;
+#[allow(dead_code)]
+pub(crate) const WHITE: u32 = 0xFF_FF_FF;
+#[allow(dead_code)]
+pub(crate) const GREYPLE: u32 = 0x99_AA_B5;
+#[allow(dead_code)]
+pub(crate) const BLACK: u32 = 0x23_27_2A;
+#[allow(dead_code)]
+pub(crate) const DARK_BUT_NOT_BLACK: u32 = 0x2C_2F_33;
+#[allow(dead_code)]
+pub(crate) const NOT_QUITE_BLACK: u32 = 0x23_27_2A;
+#[allow(dead_code)]
+pub(crate) const GREEN: u32 = 0x57_F2_87;
+#[allow(dead_code)]
+pub(crate) const FUCHSIA: u32 = 0xEB_45_9E;
+#[allow(dead_code)]
+pub(crate) const RED: u32 = 0xED_42_45;

src/commands/loop_queue.rs

@@ -1,6 +1,6 @@
-use crate::state::{State, StateRef};
+use crate::metadata::MetadataMap;
+use crate::state::{Settings, State, StateRef};
 use async_trait::async_trait;
-use songbird::input::Compose;
 use songbird::{Event, EventContext, EventHandler, TrackEvent};
 use std::ops::Sub;
 use std::time::Duration;
@@ -29,12 +29,21 @@ pub(crate) async fn loop_queue(
         return Ok(());
     };
 
-    let looping = if let Some(mut settings) = state.guild_settings.get_mut(&guild_id) {
+    state
+        .guild_settings
+        .entry(guild_id)
+        .or_insert_with(|| Settings { loop_queue: false });
+
+    state.guild_settings.entry(guild_id).and_modify(|settings| {
         settings.loop_queue = !settings.loop_queue;
-        settings.loop_queue
-    } else {
-        false
-    };
+        println!("loop_queue: {}", settings.loop_queue);
+    });
+
+    let looping = state
+        .guild_settings
+        .get(&guild_id)
+        .expect("Cannot get loop state")
+        .loop_queue;
 
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let mut call = call_lock.lock().await;
@@ -47,10 +56,11 @@ pub(crate) async fn loop_queue(
         );
     }
 
-    let mut message = "I'm not looping anymore!".to_string();
-    if looping {
-        message = "I'm now looping the current queue!".to_string();
-    }
+    let message = if looping {
+        "I'm now looping the current queue!".to_string()
+    } else {
+        "I'm not looping anymore!".to_string()
+    };
 
     let interaction_response_data = InteractionResponseDataBuilder::new()
         .content(message)
@@ -91,29 +101,28 @@ impl EventHandler for TrackEndNotifier {
             return None;
         };
         let (_, track_handle) = track_list.first()?;
-        if let Some(yt) = self
-            .state
-            .tracks
-            .get(&self.guild_id)
-            .unwrap()
-            .get(&track_handle.uuid())
-        {
-            let mut src = yt.clone();
-            if let Ok(metadata) = src.aux_metadata().await {
-                if let Some(call_lock) = self.state.songbird.get(self.guild_id) {
-                    let mut call = call_lock.lock().await;
-                    call.enqueue_with_preload(
-                        src.into(),
-                        metadata.duration.map(|duration| -> Duration {
-                            if duration.as_secs() > 5 {
-                                duration.sub(Duration::from_secs(5))
-                            } else {
-                                duration
-                            }
-                        }),
-                    );
-                }
-            }
+        if let Some(call_lock) = self.state.songbird.get(self.guild_id) {
+            let mut call = call_lock.lock().await;
+
+            // get metadata from finished track
+            let old_typemap_lock = track_handle.typemap().read().await;
+            let old_metadata = old_typemap_lock.get::<MetadataMap>().unwrap();
+
+            // enqueue track
+            let handle = call.enqueue_with_preload(
+                old_metadata.src.clone().into(),
+                old_metadata.duration.map(|duration| -> Duration {
+                    if duration.as_secs() > 5 {
+                        duration.sub(Duration::from_secs(5))
+                    } else {
+                        duration
+                    }
+                }),
+            );
+
+            // insert metadata into new track
+            let mut new_typemap = handle.typemap().write().await;
+            new_typemap.insert::<MetadataMap>(old_metadata.clone());
         }
         None
     }

src/commands/mod.rs

@@ -35,12 +35,14 @@ pub(crate) fn get_chat_commands() -> Vec<twilight_model::application::command::C
     vec![
         CommandBuilder::new("join", "Join the channel", CommandType::ChatInput).build(),
         CommandBuilder::new("leave", "Leave the channel", CommandType::ChatInput).build(),
+        CommandBuilder::new("loop", "Loop queue", CommandType::ChatInput).build(),
+        CommandBuilder::new("skip", "Skip track", CommandType::ChatInput).build(),
+        CommandBuilder::new("queue", "Print track queue", CommandType::ChatInput).build(),
+        CommandBuilder::new("stop", "Stop playing", CommandType::ChatInput).build(),
         CommandBuilder::new("pause", "Pause playing", CommandType::ChatInput).build(),
+        CommandBuilder::new("resume", "Resume playing", CommandType::ChatInput).build(),
         CommandBuilder::new("play", "Add a song to the queue", CommandType::ChatInput)
             .option(StringBuilder::new("query", "URL of a song").required(true))
             .build(),
-        CommandBuilder::new("queue", "Print track queue", CommandType::ChatInput).build(),
-        CommandBuilder::new("resume", "Resume playing", CommandType::ChatInput).build(),
-        CommandBuilder::new("stop", "Stop playing", CommandType::ChatInput).build(),
     ]
 }

src/commands/play.rs

@@ -47,6 +47,18 @@ async fn get_tracks(
         .map_while(Result::ok)
         .flat_map(|line| serde_json::from_str(&line))
         .collect();
+
+    if tracks.is_empty() {
+        if let Ok(stderr) = String::from_utf8(output.stderr) {
+            if stderr.contains("This video is only available to Music Premium members") {
+                return Err("This video is only available to Music Premium members".into());
+            }
+            if stderr.contains("YouTube said: The playlist does not exist.") {
+                return Err("YouTube said: The playlist does not exist.".into());
+            }
+        }
+        return Err("No tracks found".into());
+    }
     tracing::debug!("tracks: {:?}", tracks);
     Ok(tracks)
 }
@@ -99,7 +111,23 @@ pub(crate) async fn play(
 
     debug!("query: {:?}", query);
 
-    let tracks = get_tracks(query).await?;
+    let tracks = match get_tracks(query).await {
+        Err(e) => {
+            let content = format!("{}", e);
+            let embeds = vec![EmbedBuilder::new()
+                .description(content)
+                .color(colors::RED)
+                .build()];
+            state
+                .http
+                .interaction(interaction.application_id)
+                .update_response(&interaction.token)
+                .embeds(Some(&embeds))?
+                .await?;
+            return Ok(());
+        }
+        Ok(tracks) => tracks,
+    };
 
     if tracks.len() > 1 {
         let first_track = tracks.first().unwrap();
@@ -138,13 +166,8 @@ pub(crate) async fn play(
         tracing::debug!("track: {:?}", track);
         let url = track.url.clone().or(track.original_url.clone()).ok_or("")?;
         let mut src = YoutubeDl::new(reqwest::Client::new(), url.clone());
-        let s = src.clone();
-        let track: Track = src.clone().into();
-        state
-            .tracks
-            .entry(guild_id)
-            .or_default()
-            .insert(track.uuid, s);
+        let src_copy = src.clone();
+        let track: Track = src_copy.into();
 
         if let Ok(metadata) = src.aux_metadata().await {
             debug!("metadata: {:?}", metadata);
@@ -167,6 +190,7 @@ pub(crate) async fn play(
                     title: metadata.title,
                     duration: metadata.duration,
                     url,
+                    src,
                 });
             }
         }
@@ -238,4 +262,34 @@ mod tests {
             assert!(!tracks.is_empty());
         }
     }
+
+    #[tokio::test]
+    async fn test_premium_tracks() {
+        let urls = ["https://www.youtube.com/watch?v=QgMZRmxQ0Dc"];
+        for url in urls.iter() {
+            println!("url: {:?}", url);
+            let tracks = get_tracks(url.to_string()).await;
+            assert!(tracks.is_err());
+            assert!(tracks
+                .err()
+                .unwrap()
+                .to_string()
+                .contains("This video is only available to Music Premium members"));
+        }
+    }
+
+    #[tokio::test]
+    async fn test_playlist_does_not_exist_tracks() {
+        let urls = ["https://www.youtube.com/playlist?list=PLox0oG0uy8Lc1IaIfGyrvtuRItuEyJiyG"];
+        for url in urls.iter() {
+            println!("url: {:?}", url);
+            let tracks = get_tracks(url.to_string()).await;
+            assert!(tracks.is_err());
+            assert!(tracks
+                .err()
+                .unwrap()
+                .to_string()
+                .contains("YouTube said: The playlist does not exist."));
+        }
+    }
 }

src/commands/skip.rs

@@ -27,7 +27,7 @@ pub(crate) async fn skip(
     }
 
     let interaction_response_data = InteractionResponseDataBuilder::new()
-        .content("Skipped the next track")
+        .content("Skipped a track")
         .build();
 
     let response = InteractionResponse {

src/main.rs

@@ -78,7 +78,6 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 songbird,
                 standby: Standby::new(),
                 guild_settings: Default::default(),
-                tracks: Default::default(),
             }),
         )
     };

src/metadata.rs

@@ -1,10 +1,12 @@
-use songbird::typemap::TypeMapKey;
+use songbird::{input::YoutubeDl, typemap::TypeMapKey};
 use std::time::Duration;
 
+#[derive(Clone)]
 pub(crate) struct Metadata {
     pub(crate) title: Option<String>,
     pub(crate) duration: Option<Duration>,
     pub(crate) url: String,
+    pub(crate) src: YoutubeDl,
 }
 
 pub(crate) struct MetadataMap;

src/state.rs

@@ -1,11 +1,10 @@
 use dashmap::DashMap;
-use songbird::{input::YoutubeDl, Songbird};
+use songbird::Songbird;
 use std::sync::Arc;
 use twilight_cache_inmemory::InMemoryCache;
 use twilight_http::Client as HttpClient;
 use twilight_model::id::{marker::GuildMarker, Id};
 use twilight_standby::Standby;
-use uuid::Uuid;
 
 pub(crate) type State = Arc<StateRef>;
 
@@ -21,5 +20,4 @@ pub(crate) struct StateRef {
     pub(crate) songbird: Songbird,
     pub(crate) standby: Standby,
     pub(crate) guild_settings: DashMap<Id<GuildMarker>, Settings>,
-    pub(crate) tracks: DashMap<Id<GuildMarker>, DashMap<Uuid, YoutubeDl>>,
 }