Update rust:slim-bullseye Docker digest to f635d98

Reviewed-on: #31

.dockerignore

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

.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@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
+      with:
+        python-version: '3.13'
+    - 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@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
+      with:
+        python-version: '3.13'
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+      with:
+        components: rustfmt
+    - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1

.gitea/workflows/deploy.yaml

@@ -1,31 +1,35 @@
-name: release
+name: deploy
 
 on:
   push:
     branches:
       - main
 
+paths-ignore:
+- 'README.md'
+
 jobs:
   release-image:
     runs-on: ubuntu-latest
     steps:
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
+        uses: docker/setup-qemu-action@29109295f81e9208d7d86ff1c6c12d2833863392 # v3
 
       - name: Set up Docker BuildX
-        uses: docker/setup-buildx-action@v3
+        uses: docker/setup-buildx-action@b5ca514318bd6ebac0fb2aedd5d36ec1b5c232a2 # v3
 
       - name: Login to DockerHub
-        uses: docker/login-action@v3
+        uses: docker/login-action@74a5d142397b4f367a81961eba4e8cd7edddf772 # v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       - name: Build and push
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@471d1dc4e07e5cdedd4c2171150001c434f0b7a4 # v6
         with:
           platforms: |
             linux/amd64
-            linux/arm64
           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@c21017a4a2fc9f42953bcc907e375a5a544557ec  # v41.0.18
+        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"

.gitea/workflows/rust.yml

@@ -1,67 +0,0 @@
-name: Rust
-
-on:
-  push:
-  pull_request:
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-    - name: Build
-      run: cargo build --verbose
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - 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@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        components: clippy
-    - name: Run clippy
-      run: cargo clippy
-
-  fmt:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        components: rustfmt
-    - name: Rustfmt Check
-      uses: actions-rust-lang/rustfmt@v1
-
-  pre-commit:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        components: rustfmt
-    - uses: pre-commit/action@v3.0.1

.github/workflows/ci.yml

@@ -0,0 +1,73 @@
+name: tests
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+
+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@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
+      with:
+        python-version: '3.13'
+    - 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@8d9ed9ac5c53483de85588cdf95a591a75ab9f55 # v5
+      with:
+        python-version: '3.13'
+    - uses: actions-rust-lang/setup-rust-toolchain@9399c7bb15d4c7d47b27263d024f0a4978346ba4 # v1
+      with:
+        components: rustfmt
+    - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1

.github/workflows/rust.yml

@@ -1,68 +0,0 @@
-name: Rust
-
-on:
-  push:
-    branches: [ "main" ]
-  pull_request:
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-    - name: Build
-      run: cargo build --verbose
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - 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@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        components: clippy
-    - name: Run clippy
-      run: cargo clippy
-
-  fmt:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        components: rustfmt
-    - name: Rustfmt Check
-      uses: actions-rust-lang/rustfmt@v1
-
-  pre-commit:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - run: sudo apt-get update
-    - run: sudo apt-get install -y cmake
-    - uses: actions/setup-python@v5
-      with:
-        python-version: '3.12'
-    - uses: actions-rust-lang/setup-rust-toolchain@v1
-      with:
-        components: rustfmt
-    - uses: pre-commit/action@v3.0.1

.gitignore

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

Cargo.toml

@@ -6,20 +6,27 @@ edition = "2021"
 license = "MIT"
 
 [dependencies]
-symphonia = { version = "0.5.2", features=["all"] }
-songbird = { version = "0.4.0", features = ["driver", "gateway", "twilight", "rustls", "builtin-queue"] }
+symphonia = { version = "0.5.2", features=["all", "opt-simd"] }
+songbird = { version = "0.5.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"
+reqwest = "0.12"
 tracing = "0.1"
-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"] }
+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"] }
 dotenv = "0.15.0"
+serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-url = "2.5.0"
+url = "2.5.1"
+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 as build
+FROM rust:slim-bullseye@sha256:f635d98d781930be4ab1a5135fd8e2f7b2bdf43c741c99e420d794d0777ead4d 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
+FROM debian:bullseye-slim@sha256:e4b93db6aad977a95aa103917f3de8a2b16ead91cf255c3ccdb300c5d20f3015
 
-RUN apt-get update && apt-get install -y python3-pip ffmpeg
+RUN apt-get update && apt-get install -y python3-pip
 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](https://hub.docker.com/r/jheuel/ohrwurm) image:
+To deploy Ohrwurm with Docker, you can use the [provided Docker image](https://hub.docker.com/r/jheuel/ohrwurm):
 ```bash
 docker run -d \
   --name ohrwurm \

build.rs

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

migrations/20240620151940_init.sql

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

@@ -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/colors.rs

@@ -0,0 +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/delete.rs

@@ -9,14 +9,14 @@ pub(crate) async fn delete(
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     let admin = env::var("ADMIN")?.parse::<u64>()?;
-    if msg.author.id != Id::from(NonZeroU64::new(admin).unwrap()) {
+    if msg.author.id != Id::from(NonZeroU64::new(admin).expect("Could not get author id")) {
         return Ok(());
     }
     let n = msg
         .content
         .split(' ')
         .last()
-        .unwrap()
+        .unwrap_or("1")
         .parse::<u16>()
         .unwrap_or(1);
     if n > 100 {
@@ -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/join.rs

@@ -1,9 +1,10 @@
 use crate::state::State;
+use anyhow::Context;
 use std::error::Error;
 use tracing::debug;
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
     id::{
         marker::{GuildMarker, UserMarker},
@@ -22,7 +23,7 @@ pub(crate) async fn join_channel(
     let channel_id = state
         .cache
         .voice_state(user_id, guild_id)
-        .ok_or("Cannot get voice state for user")?
+        .context("Could not get voice state for user")?
         .channel_id();
 
     // join the voice channel
@@ -30,19 +31,22 @@ pub(crate) async fn join_channel(
         .songbird
         .join(guild_id.cast(), channel_id)
         .await
-        .map_err(|e| format!("Could not join voice channel: {:?}", e))?;
+        .context("Could not join voice channel")?;
 
     // 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?;
+        call.deafen(true).await.context("Could not deafen")?;
     }
 
+    // create guild config
+    state.guild_settings.entry(guild_id).or_default();
+
     Ok(())
 }
 
 pub(crate) async fn join(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     debug!(

src/commands/leave.rs

@@ -1,9 +1,59 @@
-use crate::state::State;
-use std::error::Error;
-use twilight_model::application::interaction::Interaction;
+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(())
+}
 
 pub(crate) async fn leave(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(
@@ -16,6 +66,8 @@ pub(crate) async fn leave(
     let Some(guild_id) = interaction.guild_id else {
         return Ok(());
     };
-    state.songbird.leave(guild_id).await?;
+
+    leave_channel(guild_id, Arc::clone(&state)).await?;
+
     Ok(())
 }

src/commands/loop_queue.rs

@@ -0,0 +1,119 @@
+use crate::metadata::Metadata;
+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;
+use std::{error::Error, sync::Arc};
+use twilight_model::{
+    gateway::payload::incoming::InteractionCreate,
+    http::interaction::{InteractionResponse, InteractionResponseType},
+    id::{marker::GuildMarker, Id},
+};
+use twilight_util::builder::InteractionResponseDataBuilder;
+
+pub(crate) async fn loop_queue(
+    interaction: Box<InteractionCreate>,
+    state: State,
+) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    tracing::debug!(
+        "loop command in guild {:?} in channel {:?} by {:?}",
+        interaction.guild_id,
+        interaction.channel,
+        interaction.author(),
+    );
+
+    let guild_id: Id<GuildMarker> = if let Some(guild_id) = interaction.guild_id {
+        guild_id
+    } else {
+        return Ok(());
+    };
+
+    state.guild_settings.entry(guild_id).and_modify(|settings| {
+        settings.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;
+        call.add_global_event(
+            Event::Track(TrackEvent::End),
+            TrackEndNotifier {
+                guild_id,
+                state: Arc::clone(&state),
+            },
+        );
+    }
+
+    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)
+        .build();
+
+    let response = InteractionResponse {
+        kind: InteractionResponseType::ChannelMessageWithSource,
+        data: Some(interaction_response_data),
+    };
+
+    state
+        .http
+        .interaction(interaction.application_id)
+        .create_response(interaction.id, &interaction.token, &response)
+        .await?;
+
+    Ok(())
+}
+
+struct TrackEndNotifier {
+    guild_id: Id<GuildMarker>,
+    state: Arc<StateRef>,
+}
+
+#[async_trait]
+impl EventHandler for TrackEndNotifier {
+    async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
+        if !self
+            .state
+            .guild_settings
+            .get(&self.guild_id)
+            .unwrap()
+            .loop_queue
+        {
+            return None;
+        }
+        let EventContext::Track(track_list) = ctx else {
+            return None;
+        };
+        let (_, track_handle) = track_list.first()?;
+        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_metadata = track_handle.data::<Metadata>();
+            // enqueue track
+            let track = Track::new_with_data(old_metadata.src.clone().into(), old_metadata.clone());
+            let _handle = call.enqueue_with_preload(
+                track,
+                old_metadata.duration.map(|duration| -> Duration {
+                    if duration.as_secs() > 5 {
+                        duration.sub(Duration::from_secs(5))
+                    } else {
+                        duration
+                    }
+                }),
+            );
+        }
+        None
+    }
+}

src/commands/mod.rs

@@ -3,14 +3,21 @@ 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;
 
+mod skip;
+pub(crate) use skip::skip;
+
+mod loop_queue;
+pub(crate) use loop_queue::loop_queue;
+
 mod play;
 pub(crate) use play::play;
 
-mod queue;
+pub(crate) mod queue;
 pub(crate) use queue::queue;
 
 mod resume;
@@ -29,12 +36,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/pause.rs

@@ -1,14 +1,14 @@
 use crate::state::State;
 use std::error::Error;
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
 };
 use twilight_util::builder::InteractionResponseDataBuilder;
 
 pub(crate) async fn pause(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(

src/commands/play.rs

@@ -1,33 +1,301 @@
 use crate::commands::join::join_channel;
-use crate::metadata::{Metadata, MetadataMap};
+use crate::metadata::Metadata;
 use crate::state::State;
-use serde_json::Value;
+use crate::{colors, db};
+
+use anyhow::Context;
+use serde::{Deserialize, Serialize};
 use songbird::input::{Compose, YoutubeDl};
-use std::io::{BufRead, BufReader};
-use std::{error::Error, ops::Sub, time::Duration};
+use songbird::tracks::Track;
+use std::sync::Arc;
+use std::{error::Error, time::Duration};
+use std::{
+    io::{BufRead, BufReader},
+    ops::Sub,
+};
 use tokio::process::Command;
 use tracing::debug;
-use twilight_model::application::interaction::Interaction;
+use twilight_model::channel::message::embed::{
+    EmbedAuthor, EmbedField, EmbedFooter, EmbedThumbnail,
+};
+use twilight_model::channel::message::{Embed, 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>,
+    original_url: Option<String>,
+    title: String,
+    channel: String,
+    playlist: Option<String>,
+    playlist_id: Option<String>,
+    duration_string: String,
+    thumbnail: Option<String>,
+}
+
+fn build_playlist_url(playlist_id: &str) -> String {
+    format!("https://www.youtube.com/playlist?list={}", playlist_id)
+}
+
+async fn get_tracks(
+    url: String,
+) -> Result<Vec<YouTubeTrack>, Box<dyn Error + Send + Sync + 'static>> {
+    let output = Command::new("yt-dlp")
+        .args(vec![&url, "--flat-playlist", "-j"])
+        .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) {
+            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::info!("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: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
     query: String,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    debug!(
+    tracing::info!(
         "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)
+        .build()];
     let interaction_response_data = InteractionResponseDataBuilder::new()
-        .content(format!("Adding track(s) to queue: {}", query))
+        .flags(MessageFlags::LOADING)
+        .embeds(embeds)
         .build();
     let response = InteractionResponse {
-        kind: InteractionResponseType::ChannelMessageWithSource,
+        kind: InteractionResponseType::DeferredChannelMessageWithSource,
         data: Some(interaction_response_data),
     };
     state
@@ -52,31 +320,88 @@ pub(crate) async fn play(
         query
     };
 
-    debug!("query: {:?}", query);
+    tracing::info!("query: {:?}", query);
 
-    // handle playlist links
-    let urls = if query.contains("list=") {
-        get_playlist_urls(query).await?
-    } else {
-        vec![query]
-    };
+    let tracks = get_tracks(query).await?;
+    tracing::info!("got tracks: {:?}", tracks);
+
+    if tracks.len() > 1 {
+        let first_track = tracks.first().unwrap();
+        let content = format!(
+            "Adding playlist [{}]({})",
+            first_track
+                .playlist
+                .clone()
+                .unwrap_or("Unknown".to_string()),
+            build_playlist_url(
+                &first_track
+                    .playlist_id
+                    .clone()
+                    .unwrap_or("Unknown".to_string())
+            )
+        );
+        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 playlist loading message")?;
+    }
 
     if let Some(call_lock) = state.songbird.get(guild_id) {
         let call = call_lock.lock().await;
-        call.queue().resume()?;
+        call.queue().resume().context("Could not resume playing")?;
     }
 
     let mut tracks_added = vec![];
-    for url in urls {
-        let mut src = YoutubeDl::new(reqwest::Client::new(), url.to_string());
-        if let Ok(metadata) = src.aux_metadata().await {
-            debug!("metadata: {:?}", metadata);
-            tracks_added.push(metadata.title.clone());
+    for yttrack in &tracks {
+        tracing::debug!("track: {:?}", yttrack);
+        let url = yttrack
+            .original_url
+            .clone()
+            .or(yttrack.url.clone())
+            .context("Could not find url")?;
 
-            if let Some(call_lock) = state.songbird.get(guild_id) {
+        let mut src = YoutubeDl::new(state.client.clone(), url.clone());
+
+        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| {
+                        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(),
+                });
+
+                match state.songbird.get(guild_id) {
+                    Some(call_lock) => {
                         let mut call = call_lock.lock().await;
-                let handle = call.enqueue_with_preload(
-                    src.into(),
+                        let _handle = call.enqueue_with_preload(
+                            track,
                             metadata.duration.map(|duration| -> Duration {
                                 if duration.as_secs() > 5 {
                                     duration.sub(Duration::from_secs(5))
@@ -85,64 +410,91 @@ pub(crate) async fn play(
                                 }
                             }),
                         );
-                let mut x = handle.typemap().write().await;
-                x.insert::<MetadataMap>(Metadata {
-                    title: metadata.title,
-                    duration: metadata.duration,
-                });
-            }
-        }
-    }
-    let mut content = String::new();
-    let num_tracks_added = tracks_added.len();
-    match num_tracks_added {
-        0 => {}
-        1 => {
-            content = format!(
-                "Added \"{}\" to queue",
-                tracks_added.first().unwrap().clone().unwrap()
-            );
-        }
-        _ => {
-            content = format!("Added {} tracks to queue:\n", num_tracks_added);
-            for track in tracks_added.into_iter().take(num_tracks_added.min(3)) {
-                content.push_str(&format!("  \"{}\"\n", track.unwrap()));
-            }
+                    }
+                    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)
-        .content(Some(&content))
-        .unwrap()
+                        .embeds(Some(&embeds))
                         .await?;
+                    return Ok(());
+                }
+            }
+        }
+    }
+
+    let embeds = build_embeds(&tracks, &tracks_added);
+    state
+        .http
+        .interaction(interaction.application_id)
+        .update_response(&interaction.token)
+        .embeds(Some(&embeds))
+        .await
+        .context("Could not send final play message")?;
 
     Ok(())
 }
 
-async fn get_playlist_urls(
-    url: String,
-) -> Result<Vec<String>, Box<dyn Error + Send + Sync + 'static>> {
-    let output = Command::new("yt-dlp")
-        .args(vec![&url, "--flat-playlist", "-j"])
-        .output()
-        .await?;
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    let reader = BufReader::new(output.stdout.as_slice());
-    let urls = reader
-        .lines()
-        .map_while(Result::ok)
-        .map(|line| {
-            let entry: Value = serde_json::from_str(&line).unwrap();
-            entry
-                .get("webpage_url")
-                .unwrap()
-                .as_str()
+    #[tokio::test]
+    async fn test_get_tracks() {
+        let urls = [
+            "https://www.youtube.com/playlist?list=PLFxxhcEeloYa1OlnWD6UgxlVQKJH5i_0p",
+            "https://music.youtube.com/watch?v=RO75ZzqUOJw",
+            "https://www.youtube.com/watch?v=qVHyl0P_P-M",
+            "https://www.youtube.com/watch?v=34CZjsEI1yU",
+        ];
+        for url in urls.iter() {
+            println!("url: {:?}", url);
+            let tracks = get_tracks(url.to_string()).await.unwrap();
+            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()
-        })
-        .collect();
+                .contains("This video is only available to Music Premium members"));
+        }
+    }
 
-    Ok(urls)
+    #[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/queue.rs

@@ -1,15 +1,114 @@
+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::gateway::payload::incoming::InteractionCreate;
+use twilight_model::http::interaction::InteractionResponse;
 use twilight_model::http::interaction::InteractionResponseType;
-use twilight_model::{
-    application::interaction::Interaction, channel::message::MessageFlags,
-    http::interaction::InteractionResponse,
-};
+use twilight_util::builder::embed::EmbedBuilder;
 use twilight_util::builder::InteractionResponseDataBuilder;
 
-use crate::{metadata::MetadataMap, state::State};
+use crate::colors;
+use crate::metadata::Metadata;
+use crate::state::State;
 use std::error::Error;
 
+pub(crate) const TRACKS_PER_PAGE: usize = 5;
+
+fn format_duration(duration: std::time::Duration) -> String {
+    let res = duration.as_secs();
+    let hours = res / (60 * 60);
+    let res = res - hours * 60 * 60;
+    let minutes = res / 60;
+    let res = res - minutes * 60;
+    let seconds = res;
+    let mut s = String::new();
+    if hours > 0 {
+        s.push_str(format!("{:02}:", hours).as_str());
+    }
+    s.push_str(format!("{:02}:{:02}", minutes, seconds).as_str());
+    s
+}
+
+pub(crate) async fn build_queue_embeds(queue: &[TrackHandle], page: usize) -> Vec<Embed> {
+    let mut message = String::new();
+    if queue.is_empty() {
+        message.push_str("There are no tracks in the queue.\n");
+    }
+    for track in queue
+        .iter()
+        .skip(TRACKS_PER_PAGE * page)
+        .take(TRACKS_PER_PAGE)
+    {
+        let metadata = track.data::<Metadata>();
+        message.push_str(
+            format!(
+                "* [{}]({})",
+                metadata.title.clone().unwrap_or("Unknown".to_string()),
+                metadata.url,
+            )
+            .as_str(),
+        );
+        if let Some(duration) = metadata.duration {
+            message.push_str(" (");
+            message.push_str(&format_duration(duration));
+            message.push(')');
+        }
+        message.push('\n');
+    }
+    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));
+    }
+    vec![EmbedBuilder::new()
+        .description(&message)
+        .color(colors::BLURPLE)
+        .build()]
+}
+
+pub(crate) fn build_action_row(page: usize, n_pages: usize) -> Vec<Component> {
+    vec![Component::ActionRow(ActionRow {
+        components: vec![
+            Component::Button(Button {
+                custom_id: Some(format!("page:{}", page as i32 - 1)),
+                style: ButtonStyle::Primary,
+                label: Some("Previous page".to_string()),
+                emoji: Some(EmojiReactionType::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 {
+                    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 {
+                    name: "➡️".to_string(),
+                }),
+                url: None,
+                disabled: page >= n_pages - 1,
+                sku_id: None,
+            }),
+        ],
+    })]
+}
+
 pub(crate) async fn queue(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(
@@ -21,57 +120,43 @@ pub(crate) async fn queue(
     let Some(guild_id) = interaction.guild_id else {
         return Ok(());
     };
-    if let Some(call_lock) = state.songbird.get(guild_id) {
-        let call = call_lock.lock().await;
-        let queue = call.queue().current_queue();
-        let mut message = String::new();
-        if queue.is_empty() {
-            message.push_str("There are no tracks in the queue.\n");
-        } else {
-            message.push_str("Next songs are:\n");
-        }
-        for track in queue.iter().take(5) {
-            let map = track.typemap().read().await;
-            let metadata = map.get::<MetadataMap>().unwrap();
-            message.push_str(
-                format!(
-                    "* `{}",
-                    metadata.title.clone().unwrap_or("Unknown".to_string()),
-                )
-                .as_str(),
-            );
-            if let Some(duration) = metadata.duration {
-                let res = duration.as_secs();
-                let hours = res / (60 * 60);
-                let res = res - hours * 60 * 60;
-                let minutes = res / 60;
-                let res = res - minutes * 60;
-                let seconds = res;
-                message.push_str(" (");
-                if hours > 0 {
-                    message.push_str(format!("{:02}:", hours).as_str());
-                }
-                message.push_str(format!("{:02}:{:02}", minutes, seconds).as_str());
-                message.push(')');
-            }
-            message.push_str("`\n");
-        }
 
+    let content = "Fetching queue".to_string();
+    let embeds = vec![EmbedBuilder::new()
+        .description(content)
+        .color(colors::YELLOW)
+        .build()];
     let interaction_response_data = InteractionResponseDataBuilder::new()
-            .content(&message)
-            .flags(MessageFlags::EPHEMERAL)
+        .embeds(embeds)
+        .flags(MessageFlags::LOADING)
         .build();
-
     let response = InteractionResponse {
-            kind: InteractionResponseType::ChannelMessageWithSource,
+        kind: InteractionResponseType::DeferredChannelMessageWithSource,
         data: Some(interaction_response_data),
     };
-
     state
         .http
         .interaction(interaction.application_id)
         .create_response(interaction.id, &interaction.token, &response)
         .await?;
+
+    let mut queue = Vec::new();
+    if let Some(call_lock) = state.songbird.get(guild_id) {
+        let call = call_lock.lock().await;
+        queue = call.queue().current_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);
+
+    state
+        .http
+        .interaction(interaction.application_id)
+        .update_response(&interaction.token)
+        .embeds(Some(&embeds))
+        .components(Some(&action_row))
+        .await?;
+
     Ok(())
 }

src/commands/resume.rs

@@ -1,14 +1,14 @@
 use crate::state::State;
 use std::error::Error;
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
 };
 use twilight_util::builder::InteractionResponseDataBuilder;
 
 pub(crate) async fn resume(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(

src/commands/skip.rs

@@ -0,0 +1,45 @@
+use crate::state::State;
+use std::error::Error;
+use twilight_model::{
+    gateway::payload::incoming::InteractionCreate,
+    http::interaction::{InteractionResponse, InteractionResponseType},
+};
+use twilight_util::builder::InteractionResponseDataBuilder;
+
+pub(crate) async fn skip(
+    interaction: Box<InteractionCreate>,
+    state: State,
+) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
+    tracing::debug!(
+        "skip command in guild {:?} in channel {:?} by {:?}",
+        interaction.guild_id,
+        interaction.channel,
+        interaction.author(),
+    );
+
+    let Some(guild_id) = interaction.guild_id else {
+        return Ok(());
+    };
+
+    if let Some(call_lock) = state.songbird.get(guild_id) {
+        let call = call_lock.lock().await;
+        call.queue().skip()?;
+    }
+
+    let interaction_response_data = InteractionResponseDataBuilder::new()
+        .content("Skipped a track")
+        .build();
+
+    let response = InteractionResponse {
+        kind: InteractionResponseType::ChannelMessageWithSource,
+        data: Some(interaction_response_data),
+    };
+
+    state
+        .http
+        .interaction(interaction.application_id)
+        .create_response(interaction.id, &interaction.token, &response)
+        .await?;
+
+    Ok(())
+}

src/commands/stop.rs

@@ -1,6 +1,6 @@
 use twilight_model::{
-    application::interaction::Interaction,
     channel::message::MessageFlags,
+    gateway::payload::incoming::InteractionCreate,
     http::interaction::{InteractionResponse, InteractionResponseType},
 };
 use twilight_util::builder::InteractionResponseDataBuilder;
@@ -9,7 +9,7 @@ use crate::state::State;
 use std::error::Error;
 
 pub(crate) async fn stop(
-    interaction: Interaction,
+    interaction: Box<InteractionCreate>,
     state: State,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     tracing::debug!(
@@ -23,6 +23,10 @@ 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

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

src/db/track.rs

@@ -0,0 +1,167 @@
+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,72 +1,20 @@
-use crate::commands::{delete, join, leave, pause, play, queue, resume, stop};
+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::state::State;
-use futures::Future;
-use std::error::Error;
+use crate::utils::spawn;
+use anyhow::Context;
 use std::sync::Arc;
-use tracing::debug;
 use twilight_gateway::Event;
-use twilight_model::application::interaction::application_command::CommandOptionValue;
-use twilight_model::application::interaction::{Interaction, InteractionData};
-use twilight_model::gateway::payload::incoming::VoiceStateUpdate;
-
-#[derive(Debug)]
-enum InteractionCommand {
-    Play(Interaction, String),
-    Stop(Interaction),
-    Pause(Interaction),
-    Resume(Interaction),
-    Leave(Interaction),
-    Join(Interaction),
-    Queue(Interaction),
-    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(())
-}
+use twilight_model::application::interaction::message_component::MessageComponentInteractionData;
+use twilight_model::application::interaction::InteractionData;
+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,
 }
@@ -75,80 +23,117 @@ impl Handler {
     pub(crate) fn new(state: State) -> Self {
         Self { state }
     }
-    pub(crate) async fn act(&self, event: Event) {
-        match &event {
+    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") {
                     spawn(delete(message.0.clone(), Arc::clone(&self.state)));
                 }
+                Ok(())
             }
-            Event::VoiceStateUpdate(update) => {
-                spawn(leave_if_alone(*update.clone(), Arc::clone(&self.state)))
+            _ => Ok(()),
         }
-            _ => {}
     }
 
-        let interaction_command = match event {
-            Event::InteractionCreate(interaction) => {
-                debug!("interaction: {:?}", &interaction);
-                match &interaction.data {
+    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)));
+                Ok(())
+            }
+            _ => Ok(()),
+        }
+    }
+
+    async fn handle_interaction(&self, event: &Event) -> anyhow::Result<()> {
+        match event {
+            Event::InteractionCreate(interaction) => match &interaction.data {
                 Some(InteractionData::ApplicationCommand(command)) => {
-                        debug!("command: {:?}", command);
-                        match command.name.as_str() {
-                            "play" => {
-                                if let Some(query_option) =
-                                    command.options.iter().find(|opt| opt.name == "query")
+                    self.handle_application_command(command.clone().into(), interaction.clone())
+                }
+                Some(InteractionData::MessageComponent(data)) => {
+                    self.handle_message_component(data, interaction.clone())
+                        .await
+                }
+                _ => Ok(()),
+            },
+            _ => Ok(()),
+        }
+    }
+
+    fn handle_application_command(
+        &self,
+        command: InteractionCommand,
+        interaction: Box<InteractionCreate>,
+    ) -> anyhow::Result<()> {
         {
-                                    if let CommandOptionValue::String(query) = &query_option.value {
-                                        InteractionCommand::Play(
-                                            interaction.0.clone(),
-                                            query.clone(),
-                                        )
-                                    } else {
-                                        InteractionCommand::NotImplemented
-                                    }
-                                } else {
-                                    InteractionCommand::NotImplemented
-                                }
-                            }
-                            "stop" => InteractionCommand::Stop(interaction.0.clone()),
-                            "pause" => InteractionCommand::Pause(interaction.0.clone()),
-                            "resume" => InteractionCommand::Resume(interaction.0.clone()),
-                            "leave" => InteractionCommand::Leave(interaction.0.clone()),
-                            "join" => InteractionCommand::Join(interaction.0.clone()),
-                            "queue" => InteractionCommand::Queue(interaction.0.clone()),
-                            _ => InteractionCommand::NotImplemented,
-                        }
-                    }
-                    _ => InteractionCommand::NotImplemented,
-                }
-            }
-            _ => InteractionCommand::NotImplemented,
-        };
-        debug!("{:?}", interaction_command);
-        match interaction_command {
-            InteractionCommand::Play(interaction, query) => {
+            match command {
+                InteractionCommand::Play(query) => {
                     spawn(play(interaction, Arc::clone(&self.state), query))
                 }
-            InteractionCommand::Stop(interaction) => {
-                spawn(stop(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Pause(interaction) => {
-                spawn(pause(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Resume(interaction) => {
-                spawn(resume(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Leave(interaction) => {
-                spawn(leave(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Join(interaction) => {
-                spawn(join(interaction, Arc::clone(&self.state)))
-            }
-            InteractionCommand::Queue(interaction) => {
-                spawn(queue(interaction, Arc::clone(&self.state)))
-            }
+                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();
+            }
+            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(())
+        }
     }
 }

src/interaction_commands.rs

@@ -0,0 +1,44 @@
+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,23 +1,23 @@
 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;
-use futures::StreamExt;
-use signal::signal_handler;
 use songbird::{shards::TwilightMap, Songbird};
 use state::StateRef;
-use std::{env, error::Error, sync::Arc};
-use tokio::select;
+use std::{env, error::Error, str::FromStr, sync::Arc, time::Duration};
 use tracing::{debug, info};
 use twilight_cache_inmemory::InMemoryCache;
-use twilight_gateway::{
-    stream::{self, ShardEventStream},
-    Intents, Shard,
-};
+use twilight_gateway::{Event, EventTypeFlags, Intents, Shard, StreamExt as _};
 use twilight_http::Client as HttpClient;
 use twilight_model::id::Id;
 use twilight_standby::Standby;
@@ -28,12 +28,21 @@ 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 (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")?
@@ -56,7 +65,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> =
-            stream::create_recommended(&http, config, |_, builder| builder.build())
+            twilight_gateway::create_recommended(&http, config, |_, builder| builder.build())
                 .await?
                 .collect();
         let senders = TwilightMap::new(
@@ -67,6 +76,11 @@ 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,
@@ -75,6 +89,9 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 cache,
                 songbird,
                 standby: Standby::new(),
+                guild_settings: Default::default(),
+                pool,
+                client,
             }),
         )
     };
@@ -82,45 +99,55 @@ 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 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?;
+    // let mut stop_rx = signal_handler();
+    let mut set = tokio::task::JoinSet::new();
+
+    for shard in shards {
+        set.spawn(tokio::spawn(runner(shard, handler.clone(), state.clone())));
     }
-                    }
-                }
-                // 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))) => {
+    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");
-                        if source.is_fatal() {
-                            break;
-                        }
+
                 continue;
             }
-                    None => break,
         };
+
+        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;
-            }
-        }
-    }
+    handler.act(event).await?;
     Ok(())
 }

src/metadata.rs

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

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
+// }

src/state.rs

@@ -1,15 +1,37 @@
+use dashmap::DashMap;
 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;
 
 pub(crate) type State = Arc<StateRef>;
 
+#[derive(Debug)]
+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,
     pub(crate) cache: InMemoryCache,
     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

@@ -0,0 +1,12 @@
+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);
+        }
+    });
+}