Update Rust crate sqlx to 0.8

.gitea/workflows/ci.yml

@@ -0,0 +1,74 @@
+name: tests
+
+on:
+  push:
+
+paths-ignore:
+- 'README.md'
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  fmt:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+    - run: sudo apt-get update
+    - run: sudo apt-get install -y cmake
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+      with:
+        components: rustfmt
+    - name: Rustfmt Check
+      uses: actions-rust-lang/rustfmt@559aa3035a47390ba96088dffa783b5d26da9326 # v1
+
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+    - run: sudo apt-get update
+    - run: sudo apt-get install -y cmake
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+    - name: Build
+      run: cargo build --verbose
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+    - run: sudo apt-get update
+    - run: sudo apt-get install -y cmake
+    - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      with:
+        python-version: '3.12'
+    - name: Install yt-dlp
+      run: pip install yt-dlp
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+    - name: Run tests
+      run: cargo test --verbose --all-features
+
+  clippy:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+    - run: sudo apt-get update
+    - run: sudo apt-get install -y cmake
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+      with:
+        components: clippy
+    - name: Run clippy
+      run: cargo clippy
+
+  pre-commit:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
+    - run: sudo apt-get update
+    - run: sudo apt-get install -y cmake
+    - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
+      with:
+        python-version: '3.12'
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+      with:
+        components: rustfmt
+    - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1

.gitea/workflows/deploy.yaml

@@ -5,9 +5,12 @@ on:
     branches:
       - main
 
+paths-ignore:
+- 'README.md'
+
 jobs:
   release-image:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     steps:
       - name: Set up QEMU
         uses: docker/setup-qemu-action@29109295f81e9208d7d86ff1c6c12d2833863392 # v3
@@ -16,17 +19,15 @@ jobs:
         uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
 
       - name: Login to DockerHub
-        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
+        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Build and push
-        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # v6
+        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
         with:
           platforms: |
             linux/amd64
           push: true
           tags: jheuel/ohrwurm:latest
-          cache-from: type=gha
-          cache-to: type=gha,mode=max

.gitea/workflows/renovate.yaml

@@ -0,0 +1,32 @@
+---
+# yamllint disable rule:line-length
+
+name: renovate
+
+on:  # yamllint disable-line rule:truthy
+  schedule:
+    - cron: "@daily"
+  push:
+    branches:
+      - main
+
+jobs:
+  renovate:
+    runs-on: [nas]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
+      - name: Self-hosted Renovate
+        uses: renovatebot/github-action@02f4fdeb479bbb229caa7ad82cb5e691c07e80b3  # v41.0.14
+        with:
+          token: ${{ secrets.RENOVATE_TOKEN }}
+          env-regex: "^(?:RENOVATE_\\w+|LOG_LEVEL|GITHUB_COM_TOKEN)$"
+        env:
+          LOG_LEVEL: "info"
+          GITHUB_COM_TOKEN: ${{ secrets.CI_GITHUB_TOKEN }}
+          RENOVATE_PLATFORM: "gitea"
+          RENOVATE_GIT_AUTHOR: "Renovate Bot <renovate@boosted.science>"
+          RENOVATE_GIT_EMAIL: "renovate@boosted.science"
+          RENOVATE_ENDPOINT: "https://gitea.jheuel.boosted.science/api/v1/"
+          RENOVATE_AUTODISCOVER: "true"
+          RENOVATE_OPTIMIZE_FOR_DISABLED: "true"

.github/workflows/ci.yml

@@ -10,7 +10,7 @@ env:
 
 jobs:
   fmt:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
     - run: sudo apt-get update
@@ -22,7 +22,7 @@ jobs:
       uses: actions-rust-lang/rustfmt@559aa3035a47390ba96088dffa783b5d26da9326 # v1
 
   build:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
     - run: sudo apt-get update
@@ -32,14 +32,14 @@ jobs:
       run: cargo build --verbose
 
   test:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
     - run: sudo apt-get update
     - run: sudo apt-get install -y cmake
-    - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
+    - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
       with:
-        python-version: '3.13'
+        python-version: '3.12'
     - name: Install yt-dlp
       run: pip install yt-dlp
     - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
@@ -47,7 +47,7 @@ jobs:
       run: cargo test --verbose --all-features
 
   clippy:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
     - run: sudo apt-get update
@@ -59,14 +59,14 @@ jobs:
       run: cargo clippy
 
   pre-commit:
-    runs-on: self-hosted
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4
     - run: sudo apt-get update
     - run: sudo apt-get install -y cmake
-    - uses: actions/setup-python@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
+    - uses: actions/setup-python@42375524e23c412d93fb67b49958b491fce71c38 # v5
       with:
-        python-version: '3.13'
+        python-version: '3.12'
     - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
       with:
         components: rustfmt

Cargo.toml

@@ -7,20 +7,20 @@ license = "MIT"
 
 [dependencies]
 symphonia = { version = "0.5.2", features=["all", "opt-simd"] }
-songbird = { version = "0.5.0", features = ["driver", "gateway", "twilight", "rustls", "builtin-queue"] }
+songbird = { version = "0.4.0", features = ["driver", "gateway", "twilight", "rustls", "builtin-queue"] }
 tokio = { features = ["macros", "rt-multi-thread", "signal", "sync"], version = "1" }
 sqlx = { version = "0.8", features = [ "runtime-tokio", "sqlite", "chrono", "migrate"] }
 regex = { version = "1", features = ["unicode-case"] }
 futures = "0.3"
-reqwest = "0.12"
+reqwest = "0.11"
 tracing = "0.1"
-tracing-subscriber = "0.3"
-twilight-gateway = "0.16"
-twilight-http = "0.16"
-twilight-model = "0.16"
-twilight-standby = "0.16"
-twilight-cache-inmemory = "0.16"
-twilight-util = { version = "0.16", features=["builder"] }
+tracing-subscriber = "0.2"
+twilight-gateway = "0.15"
+twilight-http = "0.15"
+twilight-model = "0.15"
+twilight-standby = "0.15"
+twilight-cache-inmemory = "0.15"
+twilight-util = { version = "0.15", features=["builder"] }
 dotenv = "0.15.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

Dockerfile

@@ -1,5 +1,5 @@
 # Build image
-FROM rust:slim-bullseye@sha256:f635d98d781930be4ab1a5135fd8e2f7b2bdf43c741c99e420d794d0777ead4d as build
+FROM rust:slim-bullseye@sha256:e94e2d2e0a9df48fdfcacb47d8b60d036abe60b7c6fa3ac3de1dd16a3d18f19a as build
 
 RUN apt-get update && apt-get install -y \
     build-essential autoconf automake cmake libtool libssl-dev pkg-config
@@ -18,7 +18,7 @@ RUN touch src/main.rs
 RUN cargo build --release --locked
 
 # Release image
-FROM debian:bullseye-slim@sha256:e4b93db6aad977a95aa103917f3de8a2b16ead91cf255c3ccdb300c5d20f3015
+FROM debian:bullseye-slim@sha256:33b7c2e071c29e618182ec872c471f39d2dde3d8904d95f5b7a61acf3a592e7b
 
 RUN apt-get update && apt-get install -y python3-pip
 RUN pip install -U yt-dlp

docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  ohrwurm:
+    container_name: ohrwurm
+    image: jheuel/ohrwurm:latest@sha256:b5e0fbc40ed86820eba8673bb5a97ad6ce53f27a1c557e46515cabce35199296
+    # build: .
+    restart: unless-stopped
+    volumes:
+      - ./data:/data
+    env_file:
+      - .env

renovate.json

@@ -0,0 +1,25 @@
+{
+    "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+    "timezone": "Europe/Berlin",
+    "extends": [
+        "config:recommended",
+        "helpers:pinGitHubActionDigests",
+        ":configMigration",
+        ":pinDevDependencies",
+        ":dependencyDashboard",
+        "docker:pinDigests",
+        "preview:dockerCompose",
+        "preview:dockerVersions"
+    ],
+    "packageRules": [
+        {
+            "matchUpdateTypes": [
+                "minor",
+                "patch",
+                "pin",
+                "digest"
+            ],
+            "automerge": true
+        }
+    ]
+}

src/commands/delete.rs

@@ -26,7 +26,7 @@ pub(crate) async fn delete(
         .http
         .channel_messages(msg.channel_id)
         .before(msg.id)
-        .limit(n)
+        .limit(n)?
         .await?
         .model()
         .await?;

src/commands/loop_queue.rs

@@ -1,7 +1,6 @@
-use crate::metadata::Metadata;
+use crate::metadata::MetadataMap;
 use crate::state::{State, StateRef};
 use async_trait::async_trait;
-use songbird::tracks::Track;
 use songbird::{Event, EventContext, EventHandler, TrackEvent};
 use std::ops::Sub;
 use std::time::Duration;
@@ -100,11 +99,12 @@ impl EventHandler for TrackEndNotifier {
             let mut call = call_lock.lock().await;
 
             // get metadata from finished track
-            let old_metadata = track_handle.data::<Metadata>();
+            let old_typemap_lock = track_handle.typemap().read().await;
+            let old_metadata = old_typemap_lock.get::<MetadataMap>().unwrap();
+
             // enqueue track
-            let track = Track::new_with_data(old_metadata.src.clone().into(), old_metadata.clone());
-            let _handle = call.enqueue_with_preload(
-                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))
@@ -113,6 +113,10 @@ impl EventHandler for TrackEndNotifier {
                     }
                 }),
             );
+
+            // insert metadata into new track
+            let mut new_typemap = handle.typemap().write().await;
+            new_typemap.insert::<MetadataMap>(old_metadata.clone());
         }
         None
     }

src/commands/play.rs

@@ -1,5 +1,5 @@
 use crate::commands::join::join_channel;
-use crate::metadata::Metadata;
+use crate::metadata::{Metadata, MetadataMap};
 use crate::state::State;
 use crate::{colors, db};
 
@@ -266,7 +266,7 @@ pub(crate) async fn play(
                 .http
                 .interaction(interaction.application_id)
                 .update_response(&interaction.token)
-                .embeds(Some(&embeds))
+                .embeds(Some(&embeds))?
                 .await?;
             Ok(())
         }
@@ -348,7 +348,7 @@ pub(crate) async fn play_inner(
             .http
             .interaction(interaction.application_id)
             .update_response(&interaction.token)
-            .embeds(Some(&embeds))
+            .embeds(Some(&embeds))?
             .await
             .context("Could not send playlist loading message")?;
     }
@@ -368,21 +368,12 @@ pub(crate) async fn play_inner(
             .context("Could not find url")?;
 
         let mut src = YoutubeDl::new(state.client.clone(), url.clone());
+        let track: Track = src.clone().into();
 
         match src.aux_metadata().await {
             Ok(metadata) => {
                 debug!("metadata: {:?}", metadata);
 
-                let track: Track = Track::new_with_data(
-                    src.clone().into(),
-                    Arc::new(Metadata {
-                        title: metadata.title.clone(),
-                        duration: metadata.duration,
-                        url: url.clone(),
-                        src,
-                    }),
-                );
-
                 persistence(interaction, yttrack, Arc::clone(&state))
                     .await
                     .unwrap_or_else(|e| {
@@ -400,7 +391,7 @@ pub(crate) async fn play_inner(
                 match state.songbird.get(guild_id) {
                     Some(call_lock) => {
                         let mut call = call_lock.lock().await;
-                        let _handle = call.enqueue_with_preload(
+                        let handle = call.enqueue_with_preload(
                             track,
                             metadata.duration.map(|duration| -> Duration {
                                 if duration.as_secs() > 5 {
@@ -410,6 +401,13 @@ pub(crate) async fn play_inner(
                                 }
                             }),
                         );
+                        let mut x = handle.typemap().write().await;
+                        x.insert::<MetadataMap>(Metadata {
+                            title: metadata.title,
+                            duration: metadata.duration,
+                            url,
+                            src,
+                        });
                     }
                     None => tracing::error!("could not get call lock"),
                 }
@@ -429,7 +427,7 @@ pub(crate) async fn play_inner(
                         .http
                         .interaction(interaction.application_id)
                         .update_response(&interaction.token)
-                        .embeds(Some(&embeds))
+                        .embeds(Some(&embeds))?
                         .await?;
                     return Ok(());
                 }
@@ -442,7 +440,7 @@ pub(crate) async fn play_inner(
         .http
         .interaction(interaction.application_id)
         .update_response(&interaction.token)
-        .embeds(Some(&embeds))
+        .embeds(Some(&embeds))?
         .await
         .context("Could not send final play message")?;
 

src/commands/queue.rs

@@ -1,6 +1,6 @@
 use songbird::tracks::TrackHandle;
 use twilight_model::channel::message::component::{ActionRow, Button, ButtonStyle};
-use twilight_model::channel::message::{Component, Embed, EmojiReactionType, MessageFlags};
+use twilight_model::channel::message::{Component, Embed, MessageFlags, ReactionType};
 use twilight_model::gateway::payload::incoming::InteractionCreate;
 use twilight_model::http::interaction::InteractionResponse;
 use twilight_model::http::interaction::InteractionResponseType;
@@ -8,8 +8,7 @@ use twilight_util::builder::embed::EmbedBuilder;
 use twilight_util::builder::InteractionResponseDataBuilder;
 
 use crate::colors;
-use crate::metadata::Metadata;
-use crate::state::State;
+use crate::{metadata::MetadataMap, state::State};
 use std::error::Error;
 
 pub(crate) const TRACKS_PER_PAGE: usize = 5;
@@ -39,7 +38,10 @@ pub(crate) async fn build_queue_embeds(queue: &[TrackHandle], page: usize) -> Ve
         .skip(TRACKS_PER_PAGE * page)
         .take(TRACKS_PER_PAGE)
     {
-        let metadata = track.data::<Metadata>();
+        let map = track.typemap().read().await;
+        let metadata = map
+            .get::<MetadataMap>()
+            .expect("Could not get metadata map");
         message.push_str(
             format!(
                 "* [{}]({})",
@@ -74,34 +76,31 @@ pub(crate) fn build_action_row(page: usize, n_pages: usize) -> Vec<Component> {
                 custom_id: Some(format!("page:{}", page as i32 - 1)),
                 style: ButtonStyle::Primary,
                 label: Some("Previous page".to_string()),
-                emoji: Some(EmojiReactionType::Unicode {
+                emoji: Some(ReactionType::Unicode {
                     name: "⬅️".to_string(),
                 }),
                 url: None,
                 disabled: page == 0,
-                sku_id: None,
             }),
             Component::Button(Button {
                 custom_id: Some(format!("page:{}", page)),
                 style: ButtonStyle::Primary,
                 label: Some("Refresh".to_string()),
-                emoji: Some(EmojiReactionType::Unicode {
+                emoji: Some(ReactionType::Unicode {
                     name: "🔄".to_string(),
                 }),
                 url: None,
                 disabled: false,
-                sku_id: None,
             }),
             Component::Button(Button {
                 custom_id: Some(format!("page:{}", page + 1)),
                 style: ButtonStyle::Primary,
                 label: Some("Next page".to_string()),
-                emoji: Some(EmojiReactionType::Unicode {
+                emoji: Some(ReactionType::Unicode {
                     name: "➡️".to_string(),
                 }),
                 url: None,
                 disabled: page >= n_pages - 1,
-                sku_id: None,
             }),
         ],
     })]
@@ -154,8 +153,8 @@ pub(crate) async fn queue(
         .http
         .interaction(interaction.application_id)
         .update_response(&interaction.token)
-        .embeds(Some(&embeds))
-        .components(Some(&action_row))
+        .embeds(Some(&embeds))?
+        .components(Some(&action_row))?
         .await?;
 
     Ok(())

src/handler.rs

@@ -14,7 +14,6 @@ use twilight_model::gateway::payload::incoming::InteractionCreate;
 use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
 use twilight_util::builder::InteractionResponseDataBuilder;
 
-#[derive(Debug, Clone)]
 pub(crate) struct Handler {
     state: State,
 }

src/main.rs

@@ -12,12 +12,18 @@ mod utils;
 
 use crate::commands::get_chat_commands;
 use dotenv::dotenv;
+use futures::StreamExt;
+use signal::signal_handler;
 use songbird::{shards::TwilightMap, Songbird};
 use state::StateRef;
 use std::{env, error::Error, str::FromStr, sync::Arc, time::Duration};
+use tokio::select;
 use tracing::{debug, info};
 use twilight_cache_inmemory::InMemoryCache;
-use twilight_gateway::{Event, EventTypeFlags, Intents, Shard, StreamExt as _};
+use twilight_gateway::{
+    stream::{self, ShardEventStream},
+    Intents, Shard,
+};
 use twilight_http::Client as HttpClient;
 use twilight_model::id::Id;
 use twilight_standby::Standby;
@@ -32,7 +38,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
 
     info!("Starting up...");
 
-    let (shards, state) = {
+    let (mut shards, state) = {
         let db = env::var("DATABASE_URL").map_err(|_| "DATABASE_URL is not set")?;
         let options = SqliteConnectOptions::from_str(&db)
             .expect("could not create options")
@@ -65,7 +71,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
             | Intents::MESSAGE_CONTENT;
         let config = twilight_gateway::Config::new(token.clone(), intents);
         let shards: Vec<Shard> =
-            twilight_gateway::create_recommended(&http, config, |_, builder| builder.build())
+            stream::create_recommended(&http, config, |_, builder| builder.build())
                 .await?
                 .collect();
         let senders = TwilightMap::new(
@@ -99,55 +105,45 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     info!("Ready to receive events");
 
     let handler = Handler::new(Arc::clone(&state));
-    // let mut stop_rx = signal_handler();
-    let mut set = tokio::task::JoinSet::new();
+    let mut stop_rx = signal_handler();
+    let mut stream = ShardEventStream::new(shards.iter_mut());
+    loop {
+        select! {
+            biased;
+            _ = stop_rx.changed() => {
+                for guild in state.cache.iter().guilds() {
+                    if let Some(user) = state.cache.current_user() {
+                        if state.cache.voice_state(user.id, guild.id()).is_some() {
+                            debug!("Leaving guild {:?}", guild.id());
+                            state.songbird.leave(guild.id()).await?;
+                        }
+                    }
+                }
+                // need to grab next event to properly leave voice channels
+                stream.next().await;
+                break;
+            },
+            next = stream.next() => {
+                let event = match next {
+                    Some((_, Ok(event))) => event,
+                    Some((_, Err(source))) => {
+                        tracing::warn!(?source, "error receiving event");
+                        if source.is_fatal() {
+                            break;
+                        }
+                        continue;
+                    }
+                    None => break,
+                };
+                debug!("Event: {:?}", &event);
 
-    for shard in shards {
-        set.spawn(tokio::spawn(runner(shard, handler.clone(), state.clone())));
+                state.cache.update(&event);
+                state.standby.process(&event);
+                state.songbird.process(&event).await;
+
+                handler.act(event).await?;
+            }
+        }
     }
-    set.join_next().await;
-
-    Ok(())
-}
-
-async fn runner(mut shard: Shard, handler: Handler, state: Arc<StateRef>) {
-    while let Some(item) = shard.next_event(EventTypeFlags::all()).await {
-        let event = match item {
-            Ok(event) => event,
-            Err(source) => {
-                tracing::warn!(?source, "error receiving event");
-
-                continue;
-            }
-        };
-
-        tokio::spawn({
-            let state = state.clone();
-            let handler = handler.clone();
-            async move {
-                handle_event(event, handler, state)
-                    .await
-                    .unwrap_or_else(|source| {
-                        tracing::warn!(?source, "error handling event");
-                    });
-            }
-        });
-    }
-}
-
-async fn handle_event(
-    event: Event,
-    handler: Handler,
-    state: Arc<StateRef>,
-) -> Result<(), Box<dyn Error>> {
-    state.standby.process(&event);
-    state.songbird.process(&event).await;
-    debug!("Event: {:?}", &event);
-
-    state.cache.update(&event);
-    state.standby.process(&event);
-    state.songbird.process(&event).await;
-
-    handler.act(event).await?;
     Ok(())
 }

src/metadata.rs

@@ -1,4 +1,4 @@
-use songbird::input::YoutubeDl;
+use songbird::{input::YoutubeDl, typemap::TypeMapKey};
 use std::time::Duration;
 
 #[derive(Clone)]
@@ -6,5 +6,10 @@ pub(crate) struct Metadata {
     pub(crate) title: Option<String>,
     pub(crate) duration: Option<Duration>,
     pub(crate) url: String,
-    pub(crate) src: YoutubeDl<'static>,
+    pub(crate) src: YoutubeDl,
+}
+
+pub(crate) struct MetadataMap;
+impl TypeMapKey for MetadataMap {
+    type Value = Metadata;
 }

src/signal.rs

@@ -1,21 +1,21 @@
-// use tokio::{
-//     select,
-//     signal::unix::{signal, SignalKind},
-//     sync::watch,
-// };
+use tokio::{
+    select,
+    signal::unix::{signal, SignalKind},
+    sync::watch,
+};
 
-// pub(crate) fn signal_handler() -> watch::Receiver<()> {
-//     let (stop_tx, stop_rx) = watch::channel(());
-//     tokio::spawn(async move {
-//         let mut sigterm = signal(SignalKind::terminate()).unwrap();
-//         let mut sigint = signal(SignalKind::interrupt()).unwrap();
-//         loop {
-//             select! {
-//                 _ = sigterm.recv() => println!("Receive SIGTERM"),
-//                 _ = sigint.recv() => println!("Receive SIGTERM"),
-//             };
-//             stop_tx.send(()).unwrap();
-//         }
-//     });
-//     stop_rx
-// }
+pub(crate) fn signal_handler() -> watch::Receiver<()> {
+    let (stop_tx, stop_rx) = watch::channel(());
+    tokio::spawn(async move {
+        let mut sigterm = signal(SignalKind::terminate()).unwrap();
+        let mut sigint = signal(SignalKind::interrupt()).unwrap();
+        loop {
+            select! {
+                _ = sigterm.recv() => println!("Receive SIGTERM"),
+                _ = sigint.recv() => println!("Receive SIGTERM"),
+            };
+            stop_tx.send(()).unwrap();
+        }
+    });
+    stop_rx
+}