Update Rust crate dashmap to v6

Reviewed-on: #20

.gitea/workflows/ci.yml

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

.gitea/workflows/deploy.yaml

@@ -13,19 +13,19 @@ jobs:
     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@9780b0c442fbb1117ed29e0efdff1e18412f7567 # 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@ca052bb54ab0790a636c9b5f226502c73d547a25 # v5
         with:
           platforms: |
             linux/amd64

.gitea/workflows/renovate.yaml

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

.github/workflows/ci.yml

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

Cargo.toml

@@ -6,10 +6,10 @@ edition = "2021"
 license = "MIT"
 
 [dependencies]
-symphonia = { version = "0.5.2", features=["all"] }
+symphonia = { version = "0.5.2", features=["all", "opt-simd"] }
 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.7", features = [ "runtime-tokio", "sqlite", "chrono", "migrate"] }
+sqlx = { version = "0.8", features = [ "runtime-tokio", "sqlite", "chrono", "migrate"] }
 regex = { version = "1", features = ["unicode-case"] }
 futures = "0.3"
 reqwest = "0.11"
@@ -26,7 +26,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 url = "2.5.1"
 anyhow = "1.0.86"
-dashmap = "5.5.3"
+dashmap = "6.0.0"
 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:e94e2d2e0a9df48fdfcacb47d8b60d036abe60b7c6fa3ac3de1dd16a3d18f19a 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:33b7c2e071c29e618182ec872c471f39d2dde3d8904d95f5b7a61acf3a592e7b
 
-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 .

migrations/20240627193022_save_tracks.sql

@@ -1,5 +0,0 @@
-CREATE TABLE IF NOT EXISTS blobs
-(
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    data BLOB
-);

renovate.json

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

src/commands/join.rs

@@ -1,4 +1,5 @@
 use crate::state::State;
+use anyhow::Context;
 use std::error::Error;
 use tracing::debug;
 use twilight_model::{
@@ -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,12 +31,12 @@ 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

src/commands/play.rs

@@ -1,31 +1,39 @@
 use crate::commands::join::join_channel;
-use crate::db::track::{insert_blob, Blob};
 use crate::metadata::{Metadata, MetadataMap};
-use crate::state::{State, StateRef};
+use crate::state::State;
 use crate::{colors, db};
 
-use async_trait::async_trait;
+use anyhow::Context;
 use serde::{Deserialize, Serialize};
-use songbird::input::cached::Memory;
 use songbird::input::{Compose, YoutubeDl};
 use songbird::tracks::Track;
-use songbird::{Event, EventContext, EventHandler, TrackEvent};
-use std::io::{BufRead, BufReader, Read};
-use std::ops::Sub;
 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::channel::message::embed::{
     EmbedAuthor, EmbedField, EmbedFooter, EmbedThumbnail,
 };
-use twilight_model::channel::message::MessageFlags;
+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>,
@@ -35,6 +43,7 @@ struct YouTubeTrack {
     playlist: Option<String>,
     playlist_id: Option<String>,
     duration_string: String,
+    thumbnail: Option<String>,
 }
 
 fn build_playlist_url(playlist_id: &str) -> String {
@@ -49,12 +58,18 @@ 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) {
@@ -67,22 +82,210 @@ async fn get_tracks(
         }
         return Err("No tracks found".into());
     }
-    tracing::debug!("tracks: {:?}", tracks);
+    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: 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)
@@ -117,25 +320,10 @@ pub(crate) async fn play(
         query
     };
 
-    debug!("query: {:?}", query);
+    tracing::info!("query: {:?}", query);
 
-    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,
-    };
+    let tracks = get_tracks(query).await?;
+    tracing::info!("got tracks: {:?}", tracks);
 
     if tracks.len() > 1 {
         let first_track = tracks.first().unwrap();
@@ -161,20 +349,13 @@ pub(crate) async fn play(
             .interaction(interaction.application_id)
             .update_response(&interaction.token)
             .embeds(Some(&embeds))?
-            .await?;
+            .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()?;
-    }
-
-    struct TrackType {
-        url: String,
-        title: Option<String>,
-        duration_string: String,
-        channel: String,
-        thumbnail: Option<String>,
+        call.queue().resume().context("Could not resume playing")?;
     }
 
     let mut tracks_added = vec![];
@@ -184,51 +365,20 @@ pub(crate) async fn play(
             .original_url
             .clone()
             .or(yttrack.url.clone())
-            .ok_or("Could not find url")?;
+            .context("Could not find url")?;
 
-        let mut src = YoutubeDl::new(reqwest::Client::new(), url.clone());
-        let memory = Memory::new(src.clone().into()).await.unwrap();
-        let track: Track = memory.new_handle().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 {
+        match src.aux_metadata().await {
+            Ok(metadata) => {
                 debug!("metadata: {:?}", metadata);
 
-            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()))
+                persistence(interaction, yttrack, Arc::clone(&state))
                     .await
-                .expect("failed to insert guild: {e}");
-
-            db::track::insert_user(
-                &state.pool,
-                db::track::User::new(user_id.to_string(), author_name, author_global_name),
-            )
-            .await
-            .expect("failed to insert user: {e}");
-
-            let track_id = db::track::insert_track(
-                &state.pool,
-                db::track::Track::new(
-                    url.clone(),
-                    yttrack.title.clone(),
-                    yttrack.channel.clone(),
-                    yttrack.duration_string.clone(),
-                    metadata.thumbnail.clone().unwrap_or_default(),
-                ),
-            )
-            .await
-            .expect("failed to insert track: {e}");
-
-            db::track::insert_query(
-                &state.pool,
-                db::track::Query::new(user_id.to_string(), guild_id.to_string(), track_id),
-            )
-            .await
-            .expect("failed to insert track: {e}");
+                    .unwrap_or_else(|e| {
+                        tracing::error!("could not persist track: {:?}", e);
+                    });
 
                 tracks_added.push(TrackType {
                     url: url.clone(),
@@ -238,7 +388,8 @@ pub(crate) async fn play(
                     thumbnail: metadata.thumbnail.clone(),
                 });
 
-            if let Some(call_lock) = state.songbird.get(guild_id) {
+                match state.songbird.get(guild_id) {
+                    Some(call_lock) => {
                         let mut call = call_lock.lock().await;
                         let handle = call.enqueue_with_preload(
                             track,
@@ -257,137 +408,45 @@ pub(crate) async fn play(
                             url,
                             src,
                         });
-
-                handle
-                    .add_event(
-                        Event::Track(TrackEvent::Preparing),
-                        TrackPreparingNotifier {
-                            memory,
-                            track_id,
-                            state: Arc::clone(&state),
-                        },
-                    )
-                    .expect("could not add event");
+                    }
+                    None => tracing::error!("could not get call lock"),
                 }
             }
-    }
-    let mut content = String::new();
-    let num_tracks_added = tracks_added.len();
-    let embeds = match num_tracks_added {
-        0 => {
-            vec![]
-        }
-        1 => {
-            let track = tracks_added.first().unwrap();
-
-            let host = Url::parse(&track.url)?;
-            let host = host
-                .host_str()
-                .unwrap_or_default()
-                .trim_start_matches("www.");
-            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(EmbedFooter {
-                    text: format!("Streaming from {}", host),
-                    icon_url: Some(format!(
-                        "https://www.google.com/s2/favicons?domain={}",
-                        host
-                    )),
-                    proxy_icon_url: None,
-                })
-                .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]
-        }
-        _ => {
-            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()
+            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::BLURPLE)
-                .build();
-            vec![embed]
-        }
-    };
-
+                        .color(colors::RED)
+                        .build()];
                     state
                         .http
                         .interaction(interaction.application_id)
                         .update_response(&interaction.token)
                         .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(())
 }
 
-struct TrackPreparingNotifier {
-    memory: Memory,
-    track_id: i64,
-    state: Arc<StateRef>,
-}
-
-#[async_trait]
-impl EventHandler for TrackPreparingNotifier {
-    async fn act(&self, _ctx: &EventContext<'_>) -> Option<Event> {
-        tracing::info!("Build buffer");
-        let mut reader = BufReader::new(self.memory.new_handle());
-        let mut bytes = Vec::new();
-        reader
-            .read_to_end(&mut bytes)
-            .expect("could not read track in memory");
-
-        tracing::info!("Saving track");
-        insert_blob(&self.state.pool, Blob::new(self.track_id, bytes))
-            .await
-            .expect("could not insert blob");
-        tracing::info!("Saved");
-        None
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

src/commands/queue.rs

@@ -59,7 +59,7 @@ pub(crate) async fn build_queue_embeds(queue: &[TrackHandle], page: usize) -> Ve
     }
     message.push('\n');
 
-    let n_pages = (queue.len() + TRACKS_PER_PAGE - 1) / TRACKS_PER_PAGE;
+    let n_pages = queue.len().div_ceil(TRACKS_PER_PAGE);
     if n_pages > 1 {
         message.push_str(&format!("page {}/{}", 1 + page, n_pages));
     }
@@ -146,7 +146,7 @@ pub(crate) async fn queue(
     }
 
     let embeds = build_queue_embeds(&queue, 0).await;
-    let n_pages = (queue.len() + TRACKS_PER_PAGE - 1) / TRACKS_PER_PAGE;
+    let n_pages = queue.len().div_ceil(TRACKS_PER_PAGE);
     let action_row = build_action_row(0, n_pages);
 
     state

src/db/track.rs

@@ -36,18 +36,29 @@ pub(crate) async fn insert_track(
     pool: &sqlx::SqlitePool,
     track: Track,
 ) -> Result<i64, sqlx::Error> {
-    let query =
-        "INSERT OR REPLACE INTO tracks (url, title, channel, duration, thumbnail, updated) VALUES ($1, $2, $3, $4, $5, $6)";
-    let res = sqlx::query(query)
-        .bind(track.url)
+    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)
-        .execute(pool)
+        .fetch_one(pool)
         .await?;
-    Ok(res.last_insert_rowid())
+
+    Ok(id)
 }
 
 #[derive(Debug, FromRow)]
@@ -70,8 +81,14 @@ impl User {
 }
 
 pub(crate) async fn insert_user(pool: &sqlx::SqlitePool, user: User) -> Result<(), sqlx::Error> {
-    let query =
-        "INSERT OR REPLACE INTO users (id, name, global_name, updated) VALUES ($1, $2, $3, $4)";
+    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)
@@ -105,8 +122,10 @@ impl Query {
 }
 
 pub(crate) async fn insert_query(pool: &sqlx::SqlitePool, q: Query) -> Result<i64, sqlx::Error> {
-    let query =
-        "INSERT OR REPLACE INTO queries (user_id, guild_id, track_id, updated) VALUES ($1, $2, $3, $4)";
+    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)
@@ -132,37 +151,17 @@ impl Guild {
     }
 }
 
-pub(crate) async fn insert_guild(
-    pool: &sqlx::SqlitePool,
-    guild: Guild,
-) -> Result<i64, sqlx::Error> {
-    let query = "INSERT OR REPLACE INTO guilds (id, updated) VALUES ($1, $2)";
-    let res = sqlx::query(query)
+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(res.last_insert_rowid())
-}
-
-#[derive(Debug, FromRow)]
-pub(crate) struct Blob {
-    pub(crate) id: i64,
-    pub(crate) data: Vec<u8>,
-}
-
-impl Blob {
-    pub(crate) fn new(id: i64, data: Vec<u8>) -> Self {
-        Self { id, data }
-    }
-}
-
-pub(crate) async fn insert_blob(pool: &sqlx::SqlitePool, blob: Blob) -> Result<(), sqlx::Error> {
-    let query = "INSERT OR REPLACE INTO blobs (id, data) VALUES ($1, $2)";
-    sqlx::query(query)
-        .bind(blob.id)
-        .bind(blob.data)
-        .execute(pool)
-        .await?;
     Ok(())
 }

src/handler.rs

@@ -112,7 +112,7 @@ impl Handler {
                 let call = call_lock.lock().await;
                 queue = call.queue().current_queue();
             }
-            let n_pages = (queue.len() + TRACKS_PER_PAGE - 1) / TRACKS_PER_PAGE;
+            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);

src/main.rs

@@ -16,7 +16,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};
+use std::{env, error::Error, str::FromStr, sync::Arc, time::Duration};
 use tokio::select;
 use tracing::{debug, info};
 use twilight_cache_inmemory::InMemoryCache;
@@ -34,7 +34,6 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
 
     println!("Starting up...");
 
-    // Initialize the tracing subscriber.
     tracing_subscriber::fmt::init();
 
     info!("Starting up...");
@@ -83,6 +82,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,
@@ -93,6 +97,7 @@ async fn main() -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
                 standby: Standby::new(),
                 guild_settings: Default::default(),
                 pool,
+                client,
             }),
         )
     };

src/state.rs

@@ -33,4 +33,5 @@ pub(crate) struct StateRef {
     pub(crate) standby: Standby,
     pub(crate) guild_settings: DashMap<Id<GuildMarker>, Settings>,
     pub(crate) pool: sqlx::SqlitePool,
+    pub(crate) client: reqwest::Client,
 }