disable arm target

.dockerignore

@@ -12,6 +12,3 @@ README.md
 # Cargo files
 **/*.rs.bk
 /target/
-
-# Database files
-data

.gitea/workflows/ci.yml

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

.gitea/workflows/deploy.yaml

@@ -5,29 +5,27 @@ on:
     branches:
       - main
 
-paths-ignore:
-- 'README.md'
-
 jobs:
   release-image:
     runs-on: ubuntu-latest
     steps:
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@29109295f81e9208d7d86ff1c6c12d2833863392 # v3
+        uses: docker/setup-qemu-action@v3
 
       - name: Set up Docker BuildX
-        uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
+        uses: docker/setup-buildx-action@v3
 
       - name: Login to DockerHub
-        uses: docker/login-action@9780b0c442fbb1117ed29e0efdff1e18412f7567 # v3
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Build and push
-        uses: docker/build-push-action@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
+        uses: docker/build-push-action@v5
         with:
           platforms: |
             linux/amd64
+            # linux/arm64
           push: true
           tags: jheuel/ohrwurm:latest

.gitea/workflows/renovate.yaml

@@ -1,32 +0,0 @@
----
-# 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

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

.gitignore

@@ -1,6 +1,3 @@
 /target
 .env
 .vscode
-
-# Database files
-data

Cargo.toml

@@ -6,10 +6,9 @@ edition = "2021"
 license = "MIT"
 
 [dependencies]
-symphonia = { version = "0.5.2", features=["all", "opt-simd"] }
+symphonia = { version = "0.5.2", features=["all"] }
 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.11"
@@ -24,9 +23,8 @@ twilight-util = { version = "0.15", features=["builder"] }
 dotenv = "0.15.0"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-url = "2.5.1"
+url = "2.5.0"
 anyhow = "1.0.86"
 dashmap = "5.5.3"
 async-trait = "0.1.80"
 uuid = "1.8.0"
-chrono = "0.4.38"

Dockerfile

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

README.md

@@ -8,7 +8,7 @@
 Ohrwurm is a user-friendly bot designed to play music in Discord voice chats. Once added to your server, you can request a song using the command `/play {query}`, where query can be a URL to a YouTube video or playlist, or a simple search term. The bot will fetch the song and start playing it. You can pause the music with `/pause`, resume playback with `/resume`, and stop and clear the queue with `/stop`. If the bot is alone in a voice chat, it will automatically leave, but you can also manually make it leave with the `/leave` command.
 
 # Deployment
-To deploy Ohrwurm with Docker, you can use the [provided Docker image](https://hub.docker.com/r/jheuel/ohrwurm):
+To deploy Ohrwurm with Docker, you can use the [provided Docker](https://hub.docker.com/r/jheuel/ohrwurm) image:
 ```bash
 docker run -d \
   --name ohrwurm \

build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("cargo:rerun-if-changed=migrations");
-}

docker-compose.yml

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

migrations/20240620151940_init.sql

@@ -1,33 +0,0 @@
-CREATE TABLE IF NOT EXISTS tracks
-(
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    url TEXT NOT NULL UNIQUE,
-    title TEXT NOT NULL,
-    channel TEXT NOT NULL,
-    duration TEXT NOT NULL,
-    thumbnail TEXT NOT NULL,
-    updated DATETIME NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS queries
-(
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    user_id TEXT NOT NULL,
-    guild_id TEXT NOT NULL,
-    track_id NUMBER NOT NULL,
-    updated DATETIME NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS users
-(
-    id TEXT PRIMARY KEY,
-    name TEXT NOT NULL,
-    global_name TEXT,
-    updated DATETIME NOT NULL
-);
-
-CREATE TABLE IF NOT EXISTS guilds
-(
-    id TEXT PRIMARY KEY,
-    updated DATETIME NOT NULL
-);

renovate.json

@@ -1,25 +0,0 @@
-{
-    "$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/join.rs

@@ -1,5 +1,4 @@
 use crate::state::State;
-use anyhow::Context;
 use std::error::Error;
 use tracing::debug;
 use twilight_model::{
@@ -23,7 +22,7 @@ pub(crate) async fn join_channel(
     let channel_id = state
         .cache
         .voice_state(user_id, guild_id)
-        .context("Could not get voice state for user")?
+        .ok_or("Cannot get voice state for user")?
         .channel_id();
 
     // join the voice channel
@@ -31,17 +30,14 @@ pub(crate) async fn join_channel(
         .songbird
         .join(guild_id.cast(), channel_id)
         .await
-        .context("Could not join voice channel")?;
+        .map_err(|e| format!("Could not join voice channel: {:?}", e))?;
 
     // signal that we are not listening
     if let Some(call_lock) = state.songbird.get(guild_id.cast()) {
         let mut call = call_lock.lock().await;
-        call.deafen(true).await.context("Could not deafen")?;
+        call.deafen(true).await?;
     }
 
-    // create guild config
-    state.guild_settings.entry(guild_id).or_default();
-
     Ok(())
 }
 

src/commands/leave.rs

@@ -1,56 +1,6 @@
-use crate::state::{State, StateRef};
-use anyhow::Context;
-use std::{error::Error, sync::Arc};
-use twilight_model::{
-    gateway::payload::incoming::InteractionCreate,
-    id::{marker::GuildMarker, Id},
-};
-
-pub(crate) async fn leave_if_alone(
-    guild_id: Id<GuildMarker>,
-    state: State,
-) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    let user = state
-        .cache
-        .current_user()
-        .context("Cannot get current user")?;
-    let user_voice_state = state
-        .cache
-        .voice_state(user.id, guild_id)
-        .context("Cannot get voice state")?;
-    let channel = state
-        .cache
-        .channel(user_voice_state.channel_id())
-        .context("Cannot get channel")?;
-    let channel_voice_states = state
-        .cache
-        .voice_channel_states(channel.id)
-        .context("Cannot get voice channel")?;
-    let count = channel_voice_states.count();
-
-    // count is 1 if the bot is the only one in the channel
-    if count == 1 {
-        leave_channel(guild_id, Arc::clone(&state)).await?;
-    }
-    Ok(())
-}
-
-pub(crate) async fn leave_channel(
-    guild_id: Id<GuildMarker>,
-    state: Arc<StateRef>,
-) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    // stop playing
-    if let Some(call_lock) = state.songbird.get(guild_id) {
-        let call = call_lock.lock().await;
-        call.queue().stop();
-    }
-    // leave the voice channel
-    state.songbird.leave(guild_id).await?;
-
-    // reset guild settings
-    state.guild_settings.remove(&guild_id);
-    Ok(())
-}
+use crate::state::State;
+use std::error::Error;
+use twilight_model::gateway::payload::incoming::InteractionCreate;
 
 pub(crate) async fn leave(
     interaction: Box<InteractionCreate>,
@@ -66,8 +16,6 @@ pub(crate) async fn leave(
     let Some(guild_id) = interaction.guild_id else {
         return Ok(());
     };
-
-    leave_channel(guild_id, Arc::clone(&state)).await?;
-
+    state.songbird.leave(guild_id).await?;
     Ok(())
 }

src/commands/loop_queue.rs

@@ -1,5 +1,5 @@
 use crate::metadata::MetadataMap;
-use crate::state::{State, StateRef};
+use crate::state::{Settings, State, StateRef};
 use async_trait::async_trait;
 use songbird::{Event, EventContext, EventHandler, TrackEvent};
 use std::ops::Sub;
@@ -29,8 +29,14 @@ pub(crate) async fn loop_queue(
         return Ok(());
     };
 
+    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;
+        println!("loop_queue: {}", settings.loop_queue);
     });
 
     let looping = state

src/commands/mod.rs

@@ -3,7 +3,6 @@ pub(crate) use join::join;
 
 mod leave;
 pub(crate) use leave::leave;
-pub(crate) use leave::leave_if_alone;
 
 mod pause;
 pub(crate) use pause::pause;

src/commands/play.rs

@@ -1,39 +1,23 @@
+use crate::colors;
 use crate::commands::join::join_channel;
 use crate::metadata::{Metadata, MetadataMap};
 use crate::state::State;
-use crate::{colors, db};
 
-use anyhow::Context;
 use serde::{Deserialize, Serialize};
 use songbird::input::{Compose, YoutubeDl};
 use songbird::tracks::Track;
-use std::sync::Arc;
+use std::io::{BufRead, BufReader};
+use std::ops::Sub;
 use std::{error::Error, time::Duration};
-use std::{
-    io::{BufRead, BufReader},
-    ops::Sub,
-};
 use tokio::process::Command;
 use tracing::debug;
-use twilight_model::channel::message::embed::{
-    EmbedAuthor, EmbedField, EmbedFooter, EmbedThumbnail,
-};
-use twilight_model::channel::message::{Embed, MessageFlags};
+use twilight_model::channel::message::MessageFlags;
 use twilight_model::gateway::payload::incoming::InteractionCreate;
 use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
 use twilight_util::builder::embed::EmbedBuilder;
 use twilight_util::builder::InteractionResponseDataBuilder;
 use url::Url;
 
-#[derive(Debug)]
-struct TrackType {
-    url: String,
-    title: Option<String>,
-    duration_string: String,
-    channel: String,
-    thumbnail: Option<String>,
-}
-
 #[derive(Debug, Serialize, Deserialize)]
 struct YouTubeTrack {
     url: Option<String>,
@@ -43,7 +27,6 @@ struct YouTubeTrack {
     playlist: Option<String>,
     playlist_id: Option<String>,
     duration_string: String,
-    thumbnail: Option<String>,
 }
 
 fn build_playlist_url(playlist_id: &str) -> String {
@@ -58,18 +41,12 @@ async fn get_tracks(
         .output()
         .await?;
 
-    tracing::info!(
-        "yt-dlp output: {:?}",
-        String::from_utf8_lossy(&output.stdout)
-    );
-
     let reader = BufReader::new(output.stdout.as_slice());
     let tracks: Vec<YouTubeTrack> = reader
         .lines()
         .map_while(Result::ok)
         .flat_map(|line| serde_json::from_str(&line))
         .collect();
-    tracing::info!("yt-dlp tracks: {:?}", tracks);
 
     if tracks.is_empty() {
         if let Ok(stderr) = String::from_utf8(output.stderr) {
@@ -82,210 +59,22 @@ async fn get_tracks(
         }
         return Err("No tracks found".into());
     }
-    tracing::info!("tracks: {:?}", tracks);
+    tracing::debug!("tracks: {:?}", tracks);
     Ok(tracks)
 }
 
-async fn persistence(
-    interaction: &InteractionCreate,
-    track: &YouTubeTrack,
-    state: State,
-) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    let Some(guild_id) = interaction.guild_id else {
-        return Ok(());
-    };
-    let Some(user_id) = interaction.author_id() else {
-        return Ok(());
-    };
-    let url = track
-        .original_url
-        .clone()
-        .or(track.url.clone())
-        .ok_or("Could not find url")?;
-    let (author_name, author_global_name) = if let Some(author) = interaction.author() {
-        (author.name.clone(), author.global_name.clone())
-    } else {
-        ("".to_string(), None)
-    };
-
-    db::track::insert_guild(&state.pool, db::track::Guild::new(guild_id.to_string()))
-        .await
-        .context("failed to insert guild")?;
-
-    db::track::insert_user(
-        &state.pool,
-        db::track::User::new(user_id.to_string(), author_name, author_global_name),
-    )
-    .await
-    .context("failed to insert user")?;
-
-    let track_id = db::track::insert_track(
-        &state.pool,
-        db::track::Track::new(
-            url.clone(),
-            track.title.clone(),
-            track.channel.clone(),
-            track.duration_string.clone(),
-            track.thumbnail.clone().unwrap_or_default(),
-        ),
-    )
-    .await
-    .context("failed to insert track")?;
-
-    db::track::insert_query(
-        &state.pool,
-        db::track::Query::new(user_id.to_string(), guild_id.to_string(), track_id),
-    )
-    .await
-    .context("failed to insert query")?;
-    Ok(())
-}
-
-fn build_single_track_added_embeds(tracks_added: &[TrackType]) -> Vec<Embed> {
-    let track = tracks_added.first().unwrap();
-
-    let host = if let Ok(host) = Url::parse(&track.url) {
-        Some(
-            host.host_str()
-                .unwrap_or_default()
-                .trim_start_matches("www.")
-                .to_string(),
-        )
-    } else {
-        None
-    };
-
-    let footer = match host {
-        Some(host) => EmbedFooter {
-            text: format!("Streaming from {}", host),
-            icon_url: Some(format!(
-                "https://www.google.com/s2/favicons?domain={}",
-                host
-            )),
-            proxy_icon_url: None,
-        },
-        None => EmbedFooter {
-            text: String::new(),
-            icon_url: None,
-            proxy_icon_url: None,
-        },
-    };
-
-    let mut embed = EmbedBuilder::new()
-        .author(EmbedAuthor {
-            name: "🔊 Added to queue".to_string(),
-            icon_url: None,
-            proxy_icon_url: None,
-            url: None,
-        })
-        .title(track.title.clone().unwrap_or("Unknown".to_string()))
-        .url(track.url.clone())
-        .color(colors::BLURPLE)
-        .footer(footer)
-        .field(EmbedField {
-            inline: true,
-            name: "Duration".to_string(),
-            value: track.duration_string.clone(),
-        })
-        .field(EmbedField {
-            inline: true,
-            name: "Channel".to_string(),
-            value: track.channel.clone(),
-        })
-        .build();
-
-    if let Some(thumbnail) = &track.thumbnail {
-        embed.thumbnail = Some(EmbedThumbnail {
-            height: None,
-            proxy_url: None,
-            url: thumbnail.to_string(),
-            width: None,
-        });
-    }
-
-    vec![embed]
-}
-
-fn build_playlist_added_embeds(tracks: &[YouTubeTrack], num_tracks_added: usize) -> Vec<Embed> {
-    let mut content = String::new();
-    let first_track = tracks.first().unwrap();
-    content.push_str(&format!(
-        "Adding playlist: [{}]({})\n",
-        &first_track
-            .playlist
-            .clone()
-            .unwrap_or("Unknown".to_string()),
-        build_playlist_url(
-            &first_track
-                .playlist_id
-                .clone()
-                .unwrap_or("Unknown".to_string())
-        )
-    ));
-    content.push_str(&format!(
-        "Added {} tracks to the queue.\n",
-        num_tracks_added
-    ));
-    let embed = EmbedBuilder::new()
-        .description(content)
-        .color(colors::BLURPLE)
-        .build();
-    vec![embed]
-}
-
-fn build_embeds(tracks: &[YouTubeTrack], tracks_added: &[TrackType]) -> Vec<Embed> {
-    let num_tracks_added = tracks_added.len();
-    match num_tracks_added {
-        0 => vec![],
-        1 => build_single_track_added_embeds(tracks_added),
-        _ => build_playlist_added_embeds(tracks, num_tracks_added),
-    }
-}
-
 pub(crate) async fn play(
     interaction: Box<InteractionCreate>,
     state: State,
     query: String,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    tracing::info!(
+    debug!(
         "play command in channel {:?} by {:?}",
         interaction.channel,
         interaction.author(),
     );
-    match play_inner(&interaction, Arc::clone(&state), query).await {
-        Ok(_) => Ok(()),
-        Err(e) => {
-            tracing::debug!("Search did not result in any tracks: {}", e);
-            let content = "Search did not result in any tracks.".to_string();
-
-            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?;
-            Ok(())
-        }
-    }
-}
-
-pub(crate) async fn play_inner(
-    interaction: &InteractionCreate,
-    state: State,
-    query: String,
-) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    tracing::info!(
-        "play_inner in channel {:?} by {:?}",
-        interaction.channel,
-        interaction.author(),
-    );
 
     let content = format!("Adding track(s) to the queue: {}", query);
-    tracing::info!("content: {:?}", content);
     let embeds = vec![EmbedBuilder::new()
         .description(content)
         .color(colors::YELLOW)
@@ -320,10 +109,25 @@ pub(crate) async fn play_inner(
         query
     };
 
-    tracing::info!("query: {:?}", query);
+    debug!("query: {:?}", query);
 
-    let tracks = get_tracks(query).await?;
-    tracing::info!("got tracks: {:?}", tracks);
+    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();
@@ -349,100 +153,93 @@ pub(crate) async fn play_inner(
             .interaction(interaction.application_id)
             .update_response(&interaction.token)
             .embeds(Some(&embeds))?
-            .await
-            .context("Could not send playlist loading message")?;
+            .await?;
     }
 
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let call = call_lock.lock().await;
-        call.queue().resume().context("Could not resume playing")?;
+        call.queue().resume()?;
     }
 
     let mut tracks_added = vec![];
-    for yttrack in &tracks {
-        tracing::debug!("track: {:?}", yttrack);
-        let url = yttrack
-            .original_url
-            .clone()
-            .or(yttrack.url.clone())
-            .context("Could not find url")?;
+    for track in &tracks {
+        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 src_copy = src.clone();
+        let track: Track = src_copy.into();
 
-        let mut src = YoutubeDl::new(state.client.clone(), url.clone());
-        let track: Track = src.clone().into();
+        if let Ok(metadata) = src.aux_metadata().await {
+            debug!("metadata: {:?}", metadata);
+            tracks_added.push((url.clone(), metadata.title.clone()));
 
-        match src.aux_metadata().await {
-            Ok(metadata) => {
-                debug!("metadata: {:?}", metadata);
-
-                persistence(interaction, yttrack, Arc::clone(&state))
-                    .await
-                    .unwrap_or_else(|e| {
-                        tracing::error!("could not persist track: {:?}", e);
-                    });
-
-                tracks_added.push(TrackType {
-                    url: url.clone(),
-                    title: metadata.title.clone(),
-                    duration_string: yttrack.duration_string.clone(),
-                    channel: yttrack.channel.clone(),
-                    thumbnail: metadata.thumbnail.clone(),
+            if let Some(call_lock) = state.songbird.get(guild_id) {
+                let mut call = call_lock.lock().await;
+                let handle = call.enqueue_with_preload(
+                    track,
+                    metadata.duration.map(|duration| -> Duration {
+                        if duration.as_secs() > 5 {
+                            duration.sub(Duration::from_secs(5))
+                        } else {
+                            duration
+                        }
+                    }),
+                );
+                let mut x = handle.typemap().write().await;
+                x.insert::<MetadataMap>(Metadata {
+                    title: metadata.title,
+                    duration: metadata.duration,
+                    url,
+                    src,
                 });
-
-                match state.songbird.get(guild_id) {
-                    Some(call_lock) => {
-                        let mut call = call_lock.lock().await;
-                        let handle = call.enqueue_with_preload(
-                            track,
-                            metadata.duration.map(|duration| -> Duration {
-                                if duration.as_secs() > 5 {
-                                    duration.sub(Duration::from_secs(5))
-                                } else {
-                                    duration
-                                }
-                            }),
-                        );
-                        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"),
-                }
-            }
-            Err(e) => {
-                tracing::error!("could not get metadata: {:?}", e);
-                if e.to_string()
-                    .contains("Sign in to confirm you’re not a bot.")
-                {
-                    let content =
-                        "I seem to have been flagged by YouTube as a bot. :-(".to_string();
-                    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(());
-                }
             }
         }
     }
+    let mut content = String::new();
+    let num_tracks_added = tracks_added.len();
+    match num_tracks_added {
+        0 => {}
+        1 => {
+            let (title, url) = if let Some(track) = tracks_added.first() {
+                let track = track.clone();
+                (track.1.unwrap_or("Unknown".to_string()), track.0)
+            } else {
+                ("Unknown".to_string(), "".to_string())
+            };
+            content = format!("Added [{}]({}) to the queue", title, url);
+        }
+        _ => {
+            let first_track = tracks.first().unwrap();
+            content.push_str(&format!(
+                "Adding playlist: [{}]({})\n",
+                &first_track
+                    .playlist
+                    .clone()
+                    .unwrap_or("Unknown".to_string()),
+                build_playlist_url(
+                    &first_track
+                        .playlist_id
+                        .clone()
+                        .unwrap_or("Unknown".to_string())
+                )
+            ));
+            content.push_str(&format!(
+                "Added {} tracks to the queue:\n",
+                num_tracks_added
+            ));
+        }
+    }
 
-    let embeds = build_embeds(&tracks, &tracks_added);
+    let embeds = vec![EmbedBuilder::new()
+        .description(content)
+        .color(colors::BLURPLE)
+        .build()];
     state
         .http
         .interaction(interaction.application_id)
         .update_response(&interaction.token)
         .embeds(Some(&embeds))?
-        .await
-        .context("Could not send final play message")?;
+        .await?;
 
     Ok(())
 }

src/commands/queue.rs

@@ -59,9 +59,9 @@ pub(crate) async fn build_queue_embeds(queue: &[TrackHandle], page: usize) -> Ve
     }
     message.push('\n');
 
-    let n_pages = queue.len().div_ceil(TRACKS_PER_PAGE);
-    if n_pages > 1 {
-        message.push_str(&format!("page {}/{}", 1 + page, n_pages));
+    let max_pages = queue.len() / TRACKS_PER_PAGE;
+    if max_pages > 0 {
+        message.push_str(&format!("page {}/{}", 1 + page, 1 + max_pages));
     }
     vec![EmbedBuilder::new()
         .description(&message)
@@ -69,7 +69,10 @@ pub(crate) async fn build_queue_embeds(queue: &[TrackHandle], page: usize) -> Ve
         .build()]
 }
 
-pub(crate) fn build_action_row(page: usize, n_pages: usize) -> Vec<Component> {
+pub(crate) fn build_action_row(page: usize, max_pages: usize) -> Vec<Component> {
+    if max_pages == 0 {
+        return Vec::new();
+    }
     vec![Component::ActionRow(ActionRow {
         components: vec![
             Component::Button(Button {
@@ -82,16 +85,6 @@ pub(crate) fn build_action_row(page: usize, n_pages: usize) -> Vec<Component> {
                 url: None,
                 disabled: page == 0,
             }),
-            Component::Button(Button {
-                custom_id: Some(format!("page:{}", page)),
-                style: ButtonStyle::Primary,
-                label: Some("Refresh".to_string()),
-                emoji: Some(ReactionType::Unicode {
-                    name: "🔄".to_string(),
-                }),
-                url: None,
-                disabled: false,
-            }),
             Component::Button(Button {
                 custom_id: Some(format!("page:{}", page + 1)),
                 style: ButtonStyle::Primary,
@@ -100,7 +93,7 @@ pub(crate) fn build_action_row(page: usize, n_pages: usize) -> Vec<Component> {
                     name: "➡️".to_string(),
                 }),
                 url: None,
-                disabled: page >= n_pages - 1,
+                disabled: page >= max_pages,
             }),
         ],
     })]
@@ -146,8 +139,7 @@ pub(crate) async fn queue(
     }
 
     let embeds = build_queue_embeds(&queue, 0).await;
-    let n_pages = queue.len().div_ceil(TRACKS_PER_PAGE);
-    let action_row = build_action_row(0, n_pages);
+    let action_row = build_action_row(0, queue.len() / TRACKS_PER_PAGE);
 
     state
         .http

src/commands/stop.rs

@@ -23,10 +23,6 @@ pub(crate) async fn stop(
         return Ok(());
     };
 
-    state.guild_settings.entry(guild_id).and_modify(|settings| {
-        settings.loop_queue = false;
-    });
-
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let call = call_lock.lock().await;
         call.queue().stop();

src/db/mod.rs

@@ -1 +0,0 @@
-pub mod track;

src/db/track.rs

@@ -1,167 +0,0 @@
-use chrono::{DateTime, Utc};
-use sqlx::FromRow;
-
-#[derive(Debug, FromRow)]
-pub(crate) struct Track {
-    #[allow(dead_code)]
-    pub(crate) id: i64,
-    pub(crate) url: String,
-    pub(crate) title: String,
-    pub(crate) channel: String,
-    pub(crate) duration: String,
-    pub(crate) thumbnail: String,
-    pub(crate) updated: DateTime<Utc>,
-}
-impl Track {
-    pub(crate) fn new(
-        url: String,
-        title: String,
-        channel: String,
-        duration: String,
-        thumbnail: String,
-    ) -> Self {
-        Self {
-            id: 0,
-            url,
-            title,
-            channel,
-            duration,
-            thumbnail,
-            updated: chrono::offset::Utc::now(),
-        }
-    }
-}
-
-pub(crate) async fn insert_track(
-    pool: &sqlx::SqlitePool,
-    track: Track,
-) -> Result<i64, sqlx::Error> {
-    let query = r#"
-        INSERT INTO tracks (url, title, channel, duration, thumbnail, updated)
-        VALUES (?, ?, ?, ?, ?, ?)
-        ON CONFLICT (url) DO UPDATE SET
-            title = EXCLUDED.title,
-            channel = EXCLUDED.channel,
-            duration = EXCLUDED.duration,
-            thumbnail = EXCLUDED.thumbnail,
-            updated = EXCLUDED.updated
-        RETURNING id
-        "#;
-
-    let id = sqlx::query_scalar(query)
-        .bind(&track.url)
-        .bind(track.title)
-        .bind(track.channel)
-        .bind(track.duration)
-        .bind(track.thumbnail)
-        .bind(track.updated)
-        .fetch_one(pool)
-        .await?;
-
-    Ok(id)
-}
-
-#[derive(Debug, FromRow)]
-pub(crate) struct User {
-    pub(crate) id: String,
-    pub(crate) name: String,
-    pub(crate) global_name: Option<String>,
-    pub(crate) updated: DateTime<Utc>,
-}
-
-impl User {
-    pub(crate) fn new(id: String, name: String, global_name: Option<String>) -> Self {
-        Self {
-            id,
-            name,
-            global_name,
-            updated: chrono::offset::Utc::now(),
-        }
-    }
-}
-
-pub(crate) async fn insert_user(pool: &sqlx::SqlitePool, user: User) -> Result<(), sqlx::Error> {
-    let query = r#"
-        INSERT INTO users (id, name, global_name, updated)
-        VALUES (?, ?, ?, ?)
-        ON CONFLICT (id) DO UPDATE SET
-            name = EXCLUDED.name,
-            global_name = EXCLUDED.global_name,
-            updated = EXCLUDED.updated
-        "#;
-    sqlx::query(query)
-        .bind(user.id)
-        .bind(user.name)
-        .bind(user.global_name)
-        .bind(user.updated)
-        .execute(pool)
-        .await?;
-    Ok(())
-}
-
-#[derive(Debug, FromRow)]
-pub(crate) struct Query {
-    #[allow(dead_code)]
-    pub(crate) id: i64,
-    pub(crate) user_id: String,
-    pub(crate) guild_id: String,
-    pub(crate) track_id: i64,
-    pub(crate) updated: DateTime<Utc>,
-}
-
-impl Query {
-    pub(crate) fn new(user_id: String, guild_id: String, track_id: i64) -> Self {
-        Self {
-            id: 0,
-            user_id,
-            guild_id,
-            track_id,
-            updated: chrono::offset::Utc::now(),
-        }
-    }
-}
-
-pub(crate) async fn insert_query(pool: &sqlx::SqlitePool, q: Query) -> Result<i64, sqlx::Error> {
-    let query = r#"
-        INSERT INTO queries (user_id, guild_id, track_id, updated)
-        VALUES (?, ?, ?, ?)
-        "#;
-    let res = sqlx::query(query)
-        .bind(q.user_id)
-        .bind(q.guild_id)
-        .bind(q.track_id)
-        .bind(q.updated)
-        .execute(pool)
-        .await?;
-    Ok(res.last_insert_rowid())
-}
-
-#[derive(Debug, FromRow)]
-pub(crate) struct Guild {
-    pub(crate) id: String,
-    pub(crate) updated: DateTime<Utc>,
-}
-
-impl Guild {
-    pub(crate) fn new(id: String) -> Self {
-        Self {
-            id,
-            updated: chrono::offset::Utc::now(),
-        }
-    }
-}
-
-pub(crate) async fn insert_guild(pool: &sqlx::SqlitePool, guild: Guild) -> Result<(), sqlx::Error> {
-    let query = r#"
-        INSERT INTO guilds (id, updated)
-        VALUES (?, ?)
-        ON CONFLICT (id) DO UPDATE SET
-            updated = EXCLUDED.updated
-        "#;
-    sqlx::query(query)
-        .bind(guild.id)
-        .bind(guild.updated)
-        .execute(pool)
-        .await?;
-    Ok(())
-}

src/handler.rs

@@ -1,19 +1,79 @@
 use crate::commands::queue::{build_action_row, build_queue_embeds, TRACKS_PER_PAGE};
-use crate::commands::{
-    delete, join, leave, leave_if_alone, loop_queue, pause, play, queue, resume, skip, stop,
-};
-use crate::interaction_commands::InteractionCommand;
+use crate::commands::{delete, join, leave, loop_queue, pause, play, queue, resume, skip, stop};
 use crate::state::State;
-use crate::utils::spawn;
-use anyhow::Context;
+use futures::Future;
+use std::error::Error;
 use std::sync::Arc;
+use tracing::debug;
 use twilight_gateway::Event;
-use twilight_model::application::interaction::message_component::MessageComponentInteractionData;
+use twilight_model::application::interaction::application_command::{
+    CommandData, CommandOptionValue,
+};
 use twilight_model::application::interaction::InteractionData;
-use twilight_model::gateway::payload::incoming::InteractionCreate;
+use twilight_model::gateway::payload::incoming::VoiceStateUpdate;
 use twilight_model::http::interaction::{InteractionResponse, InteractionResponseType};
 use twilight_util::builder::InteractionResponseDataBuilder;
 
+#[derive(Debug)]
+enum InteractionCommand {
+    Play(String),
+    Stop,
+    Pause,
+    Skip,
+    Loop,
+    Resume,
+    Leave,
+    Join,
+    Queue,
+    NotImplemented,
+}
+
+fn spawn(
+    fut: impl Future<Output = Result<(), Box<dyn Error + Send + Sync + 'static>>> + Send + 'static,
+) {
+    tokio::spawn(async move {
+        if let Err(why) = fut.await {
+            tracing::debug!("handler error: {:?}", why);
+        }
+    });
+}
+
+pub(crate) async fn leave_if_alone(
+    update: VoiceStateUpdate,
+    state: State,
+) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    let guild_id = update.guild_id.ok_or("Guild ID not found")?;
+    let user = state
+        .cache
+        .current_user()
+        .ok_or("Cannot get current user")?;
+    let user_voice_state = state
+        .cache
+        .voice_state(user.id, guild_id)
+        .ok_or("Cannot get voice state")?;
+    let channel = state
+        .cache
+        .channel(user_voice_state.channel_id())
+        .ok_or("Cannot get channel")?;
+    let channel_voice_states = state
+        .cache
+        .voice_channel_states(channel.id)
+        .ok_or("Cannot get voice channel")?;
+    let count = channel_voice_states.count();
+
+    // count is 1 if the bot is the only one in the channel
+    if count == 1 {
+        // stop playing
+        if let Some(call_lock) = state.songbird.get(guild_id) {
+            let call = call_lock.lock().await;
+            call.queue().stop();
+        }
+        // leave the voice channel
+        state.songbird.leave(guild_id).await?;
+    }
+    Ok(())
+}
+
 pub(crate) struct Handler {
     state: State,
 }
@@ -23,13 +83,6 @@ impl Handler {
         Self { state }
     }
     pub(crate) async fn act(&self, event: Event) -> anyhow::Result<()> {
-        self.handle_messages(&event).await?;
-        self.handle_voice_state_update(&event).await?;
-        self.handle_interaction(&event).await?;
-        Ok(())
-    }
-
-    async fn handle_messages(&self, event: &Event) -> anyhow::Result<()> {
         match event {
             Event::MessageCreate(message) if message.content.starts_with('!') => {
                 if message.content.contains("!delete") {
@@ -37,102 +90,121 @@ impl Handler {
                 }
                 Ok(())
             }
-            _ => Ok(()),
-        }
-    }
-
-    async fn handle_voice_state_update(&self, event: &Event) -> anyhow::Result<()> {
-        match event {
             Event::VoiceStateUpdate(update) => {
-                let guild_id = update.guild_id.context("Guild ID not found")?;
-                spawn(leave_if_alone(guild_id, Arc::clone(&self.state)));
+                spawn(leave_if_alone(*update.clone(), Arc::clone(&self.state)));
                 Ok(())
             }
-            _ => Ok(()),
-        }
-    }
+            Event::InteractionCreate(interaction) => {
+                tracing::info!("interaction: {:?}", &interaction);
+                match &interaction.data {
+                    Some(InteractionData::ApplicationCommand(command)) => {
+                        let interaction_command = parse_interaction_command(command);
+                        debug!("{:?}", interaction_command);
+                        match interaction_command {
+                            InteractionCommand::Play(query) => {
+                                spawn(play(interaction, Arc::clone(&self.state), query))
+                            }
+                            InteractionCommand::Stop => {
+                                spawn(stop(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Pause => {
+                                spawn(pause(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Skip => {
+                                spawn(skip(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Loop => {
+                                spawn(loop_queue(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Resume => {
+                                spawn(resume(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Leave => {
+                                spawn(leave(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Join => {
+                                spawn(join(interaction, Arc::clone(&self.state)))
+                            }
+                            InteractionCommand::Queue => {
+                                spawn(queue(interaction, Arc::clone(&self.state)))
+                            }
+                            _ => {}
+                        }
+                        Ok(())
+                    }
+                    Some(InteractionData::MessageComponent(data)) => {
+                        tracing::info!("message component: {:?}", data);
 
-    async fn handle_interaction(&self, event: &Event) -> anyhow::Result<()> {
-        match event {
-            Event::InteractionCreate(interaction) => match &interaction.data {
-                Some(InteractionData::ApplicationCommand(command)) => {
-                    self.handle_application_command(command.clone().into(), interaction.clone())
-                }
-                Some(InteractionData::MessageComponent(data)) => {
-                    self.handle_message_component(data, interaction.clone())
-                        .await
-                }
-                _ => Ok(()),
-            },
-            _ => Ok(()),
-        }
-    }
+                        if !data.custom_id.starts_with("page:") {
+                            return Ok(());
+                        }
+                        let page = data
+                            .custom_id
+                            .trim_start_matches("page:")
+                            .parse::<usize>()
+                            .unwrap_or(0);
+                        tracing::info!("page: {:?}", page);
 
-    fn handle_application_command(
-        &self,
-        command: InteractionCommand,
-        interaction: Box<InteractionCreate>,
-    ) -> anyhow::Result<()> {
-        {
-            match command {
-                InteractionCommand::Play(query) => {
-                    spawn(play(interaction, Arc::clone(&self.state), query))
+                        if let Some(guild_id) = interaction.guild_id {
+                            let mut queue = Vec::new();
+                            if let Some(call_lock) = self.state.songbird.get(guild_id) {
+                                let call = call_lock.lock().await;
+                                queue = call.queue().current_queue();
+                            }
+                            let embeds = build_queue_embeds(&queue, page).await;
+                            let action_row = build_action_row(page, queue.len() / TRACKS_PER_PAGE);
+
+                            let interaction_response_data = InteractionResponseDataBuilder::new()
+                                .embeds(embeds)
+                                .components(action_row)
+                                .build();
+                            let response = InteractionResponse {
+                                kind: InteractionResponseType::UpdateMessage,
+                                data: Some(interaction_response_data),
+                            };
+                            self.state
+                                .http
+                                .interaction(interaction.application_id)
+                                .create_response(interaction.id, &interaction.token, &response)
+                                .await?;
+                            Ok(())
+                        } else {
+                            Ok(())
+                        }
+                    }
+                    _ => Ok(()),
                 }
-                InteractionCommand::Stop => spawn(stop(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Pause => spawn(pause(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Skip => spawn(skip(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Loop => spawn(loop_queue(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Resume => spawn(resume(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Leave => spawn(leave(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Join => spawn(join(interaction, Arc::clone(&self.state))),
-                InteractionCommand::Queue => spawn(queue(interaction, Arc::clone(&self.state))),
-                _ => {}
             }
-            Ok(())
-        }
-    }
-
-    async fn handle_message_component(
-        &self,
-        data: &MessageComponentInteractionData,
-        interaction: Box<InteractionCreate>,
-    ) -> anyhow::Result<()> {
-        if !data.custom_id.starts_with("page:") {
-            return Ok(());
-        }
-        let page = data
-            .custom_id
-            .trim_start_matches("page:")
-            .parse::<usize>()
-            .unwrap_or(0);
-
-        if let Some(guild_id) = interaction.guild_id {
-            let mut queue = Vec::new();
-            if let Some(call_lock) = self.state.songbird.get(guild_id) {
-                let call = call_lock.lock().await;
-                queue = call.queue().current_queue();
+            event => {
+                tracing::info!("unhandled event: {:?}", event);
+                Ok(())
             }
-            let n_pages = queue.len().div_ceil(TRACKS_PER_PAGE);
-            let page = page.min(n_pages - 1).max(0);
-            let embeds = build_queue_embeds(&queue, page).await;
-            let action_row = build_action_row(page, n_pages);
-
-            let interaction_response_data = InteractionResponseDataBuilder::new()
-                .embeds(embeds)
-                .components(action_row)
-                .build();
-            let response = InteractionResponse {
-                kind: InteractionResponseType::UpdateMessage,
-                data: Some(interaction_response_data),
-            };
-            self.state
-                .http
-                .interaction(interaction.application_id)
-                .create_response(interaction.id, &interaction.token, &response)
-                .await?;
-            Ok(())
-        } else {
-            Ok(())
         }
     }
 }
+
+fn parse_interaction_command(command: &CommandData) -> InteractionCommand {
+    debug!("command: {:?}", command);
+    match command.name.as_str() {
+        "play" => {
+            if let Some(query_option) = command.options.iter().find(|opt| opt.name == "query") {
+                if let CommandOptionValue::String(query) = &query_option.value {
+                    InteractionCommand::Play(query.clone())
+                } else {
+                    InteractionCommand::NotImplemented
+                }
+            } else {
+                InteractionCommand::NotImplemented
+            }
+        }
+        "stop" => InteractionCommand::Stop,
+        "pause" => InteractionCommand::Pause,
+        "skip" => InteractionCommand::Skip,
+        "loop" => InteractionCommand::Loop,
+        "resume" => InteractionCommand::Resume,
+        "leave" => InteractionCommand::Leave,
+        "join" => InteractionCommand::Join,
+        "queue" => InteractionCommand::Queue,
+        _ => InteractionCommand::NotImplemented,
+    }
+}

src/interaction_commands.rs

@@ -1,44 +0,0 @@
-use twilight_model::application::interaction::application_command::{
-    CommandData, CommandOptionValue,
-};
-
-#[derive(Debug)]
-pub(crate) enum InteractionCommand {
-    Play(String),
-    Stop,
-    Pause,
-    Skip,
-    Loop,
-    Resume,
-    Leave,
-    Join,
-    Queue,
-    NotImplemented,
-}
-
-impl From<Box<CommandData>> for InteractionCommand {
-    fn from(command: Box<CommandData>) -> InteractionCommand {
-        match command.name.as_str() {
-            "play" => {
-                if let Some(query_option) = command.options.iter().find(|opt| opt.name == "query") {
-                    if let CommandOptionValue::String(query) = &query_option.value {
-                        InteractionCommand::Play(query.clone())
-                    } else {
-                        InteractionCommand::NotImplemented
-                    }
-                } else {
-                    InteractionCommand::NotImplemented
-                }
-            }
-            "stop" => InteractionCommand::Stop,
-            "pause" => InteractionCommand::Pause,
-            "skip" => InteractionCommand::Skip,
-            "loop" => InteractionCommand::Loop,
-            "resume" => InteractionCommand::Resume,
-            "leave" => InteractionCommand::Leave,
-            "join" => InteractionCommand::Join,
-            "queue" => InteractionCommand::Queue,
-            _ => InteractionCommand::NotImplemented,
-        }
-    }
-}

src/main.rs

@@ -1,14 +1,10 @@
 mod handler;
 use handler::Handler;
-use sqlx::sqlite::{SqliteConnectOptions, SqlitePoolOptions};
 mod colors;
 mod commands;
-mod db;
-mod interaction_commands;
 mod metadata;
 mod signal;
 mod state;
-mod utils;
 
 use crate::commands::get_chat_commands;
 use dotenv::dotenv;
@@ -16,7 +12,7 @@ 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 std::{env, error::Error, sync::Arc};
 use tokio::select;
 use tracing::{debug, info};
 use twilight_cache_inmemory::InMemoryCache;
@@ -34,21 +30,12 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
 
     println!("Starting up...");
 
+    // Initialize the tracing subscriber.
     tracing_subscriber::fmt::init();
 
     info!("Starting up...");
 
     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")
-            .create_if_missing(true);
-        let pool = SqlitePoolOptions::new()
-            .max_connections(5)
-            .connect_with(options)
-            .await?;
-        sqlx::migrate!().run(&pool).await?;
-
         let token = env::var("DISCORD_TOKEN").map_err(|_| "DISCORD_TOKEN is not set")?;
         let app_id = env::var("DISCORD_APP_ID")
             .map_err(|_| "DISCORD_APP_ID is not set")?
@@ -82,11 +69,6 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
         );
         let songbird = Songbird::twilight(Arc::new(senders), user_id);
         let cache = InMemoryCache::new();
-        let client = reqwest::ClientBuilder::new()
-            .connect_timeout(Duration::from_secs(10))
-            .timeout(Duration::from_secs(3600))
-            .build()
-            .expect("could not build http client");
 
         (
             shards,
@@ -96,8 +78,6 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 songbird,
                 standby: Standby::new(),
                 guild_settings: Default::default(),
-                pool,
-                client,
             }),
         )
     };

src/state.rs

@@ -13,18 +13,6 @@ pub(crate) struct Settings {
     pub(crate) loop_queue: bool,
 }
 
-impl Settings {
-    pub(crate) fn new() -> Self {
-        Self { loop_queue: false }
-    }
-}
-
-impl Default for Settings {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 #[derive(Debug)]
 pub(crate) struct StateRef {
     pub(crate) http: HttpClient,
@@ -32,6 +20,4 @@ pub(crate) struct StateRef {
     pub(crate) songbird: Songbird,
     pub(crate) standby: Standby,
     pub(crate) guild_settings: DashMap<Id<GuildMarker>, Settings>,
-    pub(crate) pool: sqlx::SqlitePool,
-    pub(crate) client: reqwest::Client,
 }

src/utils.rs

@@ -1,12 +0,0 @@
-use futures::Future;
-use std::error::Error;
-
-pub(crate) fn spawn(
-    fut: impl Future<Output = Result<(), Box<dyn Error + Send + Sync + 'static>>> + Send + 'static,
-) {
-    tokio::spawn(async move {
-        if let Err(why) = fut.await {
-            tracing::debug!("handler error: {:?}", why);
-        }
-    });
-}