refactor, cleanup

Cargo.toml

@@ -2,7 +2,7 @@
 name = "siren"
 version = "0.2.8"
 edition = "2021"
-authors = ["Ben Sherriff <hello@bensherriff.com>"]
+authors = ["Ben Sherriff <ben@bensherriff.com>"]
 description = "A Discord bot for playing music"
 repository = "https://github.com/bensherriff/siren"
 readme = "README.md"

docker-compose.yml

@@ -52,23 +52,10 @@ services:
       - backend
     restart: unless-stopped
 
-  redis:
-    image: redis:latest
-    container_name: siren-redis
-    volumes:
-      - redis:/data
-    ports:
-      - ${REDIS_PORT:-6379}:6379
-    networks:
-      - backend
-    profiles:
-      - backend
-    restart: unless-stopped
 
 volumes:
   postgres:
   postgres_logs:
-  redis:
 
 networks:
   frontend:

generate_keys.sh

@@ -1,26 +0,0 @@
-#! /bin/bash
-
-DIR="./keys"
-
-if [ "$#" -eq 1 ]; then
-  DIR=$1
-fi
-
-# Create the keys directory (if it doesn't exist)
-echo "Generating public/private keys in: $DIR"
-mkdir -p "$DIR"
-
-# Remove any existing keys
-rm -f $DIR/*_private_key.pem
-rm -f $DIR/*_public_key.pem
-
-# Generate Keys
-openssl genrsa -out $DIR/access_private_key.pem 4096
-openssl rsa -in $DIR/access_private_key.pem -pubout -outform PEM -out $DIR/access_public_key.pem
-chmod 600 $DIR/access_private_key.pem
-chmod 644 $DIR/access_public_key.pem
-
-openssl genrsa -out $DIR/refresh_private_key.pem 4096
-openssl rsa -in $DIR/refresh_private_key.pem -pubout -outform PEM -out $DIR/refresh_public_key.pem
-chmod 600 $DIR/refresh_private_key.pem
-chmod 644 $DIR/refresh_public_key.pem

src/bot/commands/audio/pause.rs

@@ -31,7 +31,7 @@ pub async fn run(ctx: &Context, command: &CommandInteraction) {
     let handler = handler_lock.lock().await;
     match handler.queue().pause() {
       Ok(_) => {
-        log::debug!("Paused the track");
+        log::debug!("<{guild_id}> Paused the track");
         edit_response(&ctx, &command, format!("Pausing the track")).await;
       }
       Err(err) => {

src/bot/commands/audio/play.rs

@@ -3,19 +3,17 @@ use std::sync::Arc;
 use serenity::all::{CommandInteraction, CommandOptionType, CreateCommand, CreateCommandOption};
 use serenity::model::prelude::GuildId;
 use serenity::{prelude::*, async_trait};
-use songbird::input::{AuxMetadata, Input, YoutubeDl};
+use songbird::input::{Input, YoutubeDl};
 use songbird::tracks::TrackHandle;
-use songbird::{Call, Event, EventHandler, Songbird, TrackEvent};
+use songbird::{Event, EventHandler, Songbird, TrackEvent};
 
-use crate::database::guilds::GuildCache;
+use crate::bot::commands::audio::leave_voice_channel;
+use crate::data::guilds::GuildCache;
 use crate::bot::ytdlp::{PlaylistItem, YtDlp};
 use crate::error::{SirenResult, Error as SirenError};
 use crate::HttpKey;
 
-use super::{
+use super::{create_response, edit_response, get_songbird, is_valid_url, join_voice_channel};
-  create_response, edit_response, get_songbird, is_valid_url, join_voice_channel,
-  leave_voice_channel,
-};
 
 pub async fn run(ctx: &Context, command: &CommandInteraction) {
   // Process the command options
@@ -87,10 +85,7 @@ pub async fn play_track(
 ) -> SirenResult<i32> {
   let mut track_count = 0;
   if let Some(handler_lock) = manager.get(guild_id) {
-    let is_queue_empty = {
+    let mut handler = handler_lock.lock().await;
-      let call_handler = handler_lock.lock().await;
-      call_handler.queue().is_empty()
-    };
     let guild = GuildCache::get_by_id(guild_id.get() as i64).await?.unwrap();
     let valid = is_valid_url(&track_url);
     // Check if the URL is valid
@@ -123,20 +118,36 @@ pub async fn play_track(
     }
     // Add each track to the queue
     for item in playlist_items {
-      match add_song(
+      let volume = guild.volume as f32 / 100.0;
-        ctx,
+      let http_client = {
-        handler_lock.clone(),
+        let data = ctx.data.read().await;
-        &item.url,
+        data
-        is_queue_empty,
+          .get::<HttpKey>()
-        guild.volume as f32 / 100.0,
+          .cloned()
-      )
+          .expect("Guaranteed to exist in the typemap.")
-      .await
+      };
-      {
+      let source = YoutubeDl::new(http_client, item.url.to_owned());
-        Ok(metadata) => {
+      let mut input: Input = source.into();
+      let metadata = match input.aux_metadata().await {
+        Ok(metadata) => metadata,
+        Err(err) => {
+          log::warn!("Failed to get metadata for track: {err}");
+          let _ = leave_voice_channel(&manager, &guild_id).await;
+          return Err(SirenError::new(422, err.to_string()));
+        }
+      };
+      let track_handle: TrackHandle;
+      let is_queue_empty = handler.queue().is_empty();
+      if is_queue_empty {
+        track_handle = handler.play_input(input);
+      } else {
+        track_handle = handler.enqueue_input(input).await;
+      }
+      // Set the volume
+      let _ = track_handle.set_volume(volume);
       let track_title = metadata.title.unwrap();
-          log::debug!("Added track: {}", track_title);
+      log::debug!("<{guild_id}> Added track: {}", track_title);
-          let mut handler = handler_lock.lock().await;
+      handler.remove_all_global_events();
-          // handler.remove_all_global_events();
       handler.add_global_event(
         Event::Track(TrackEvent::End),
         TrackEndNotifier {
@@ -146,48 +157,10 @@ pub async fn play_track(
       );
       track_count += 1;
     }
-        Err(err) => {
-          log::warn!("Failed to add song: {}", err);
-          if let Err(why) = leave_voice_channel(&manager, &guild_id).await {
-            log::error!("Failed to leave voice channel: {}", why);
-          }
-          return Err(SirenError::new(422, err.to_string()));
-        }
-      }
-    }
   }
   Ok(track_count)
 }
 
-async fn add_song(
-  ctx: &Context,
-  call: Arc<Mutex<Call>>,
-  url: &str,
-  lazy: bool,
-  volume: f32,
-) -> SirenResult<AuxMetadata> {
-  let http_client = {
-    let data = ctx.data.read().await;
-    data
-      .get::<HttpKey>()
-      .cloned()
-      .expect("Guaranteed to exist in the typemap.")
-  };
-  let source = YoutubeDl::new(http_client, url.to_owned());
-  let mut handler = call.lock().await;
-  let mut input: Input = source.into();
-  let metadata = input.aux_metadata().await.unwrap();
-  let track_handle: TrackHandle;
-  if lazy {
-    track_handle = handler.play_input(input);
-  } else {
-    track_handle = handler.enqueue_input(input).await;
-  }
-  // Set the volume
-  let _ = track_handle.set_volume(volume);
-  Ok(metadata)
-}
-
 pub fn get_playlist_urls(url: &str) -> SirenResult<Vec<PlaylistItem>> {
   let output = YtDlp::new()
     .arg("--flat-playlist")

src/bot/commands/audio/resume.rs

@@ -31,7 +31,7 @@ pub async fn run(ctx: &Context, command: &CommandInteraction) {
     let handler = handler_lock.lock().await;
     match handler.queue().resume() {
       Ok(_) => {
-        log::debug!("Resumed the track");
+        log::debug!("<{guild_id}> Resumed the track");
         edit_response(&ctx, &command, format!("Resuming the track")).await;
       }
       Err(err) => {

src/bot/commands/audio/skip.rs

@@ -31,7 +31,7 @@ pub async fn run(ctx: &Context, command: &CommandInteraction) {
     let handler = handler_lock.lock().await;
     match handler.queue().skip() {
       Ok(_) => {
-        log::debug!("Skipped the track");
+        log::debug!("<{guild_id}> Skipped the track");
         edit_response(&ctx, &command, format!("Skipping the track")).await;
       }
       Err(err) => {

src/bot/commands/audio/stop.rs

@@ -30,7 +30,7 @@ pub async fn run(ctx: &Context, command: &CommandInteraction) {
   if let Some(handler_lock) = manager.get(guild_id) {
     let handler = handler_lock.lock().await;
     handler.queue().stop();
-    log::debug!("Stopped the track");
+    log::debug!("<{guild_id}> Stopped the track");
     edit_response(&ctx, &command, format!("Stopping the tracks")).await;
   }
 }

src/bot/commands/audio/volume.rs

@@ -7,7 +7,7 @@ use serenity::{
 };
 use songbird::Songbird;
 
-use crate::database::guilds::GuildCache;
+use crate::data::guilds::GuildCache;
 
 use super::{get_songbird, create_response, edit_response};
 
@@ -47,7 +47,12 @@ pub async fn run(ctx: &Context, command: &CommandInteraction) {
 
   // Set the volume
   set_volume(&manager, guild_id, volume).await;
-  edit_response(&ctx, &command, format!("Setting the volume to {}", volume)).await;
+  edit_response(
+    &ctx,
+    &command,
+    format!("<{guild_id}> Setting the volume to {}", volume),
+  )
+  .await;
 }
 
 pub async fn set_volume(manager: &Arc<Songbird>, guild_id: &GuildId, volume: i32) {

src/bot/commands/chat.rs

@@ -4,7 +4,7 @@ use serenity::model::channel::Message;
 use serenity::model::prelude::{ChannelType, PermissionOverwrite, PermissionOverwriteType};
 use serenity::prelude::*;
 
-use crate::database::messages::MessageCache;
+use crate::data::messages::MessageCache;
 use crate::bot::oai::{ChatCompletionMessage, ChatCompletionRequest, GPTRole, OAI};
 
 pub async fn generate_response(ctx: &Context, msg: &Message, oai: &OAI) {

src/bot/commands/event/schedule.rs

@@ -2,10 +2,10 @@ use chrono::{DateTime, NaiveDate, TimeZone, Utc};
 use regex::Regex;
 use serenity::all::{
   Color, CommandInteraction, CommandOptionType, Context, CreateCommand, CreateCommandOption,
-  CreateEmbed, CreateEmbedFooter, CreateScheduledEvent, EditInteractionResponse, Timestamp,
+  CreateEmbed, CreateEmbedFooter, EditInteractionResponse, Timestamp,
 };
 
-use crate::{bot::commands::audio::create_response, database::events::Event};
+use crate::{bot::commands::audio::create_response, data::events::Event};
 
 pub async fn run(ctx: &Context, command: &CommandInteraction) {
   // Create the initial response

src/bot/handler.rs

@@ -5,7 +5,7 @@ use serenity::model::gateway::Ready;
 use serenity::model::channel::Message;
 use serenity::prelude::*;
 
-use crate::database::guilds::GuildCache;
+use crate::data::guilds::GuildCache;
 use super::{commands, oai};
 use super::commands::audio::create_response;
 

src/data/events/model.rs

@@ -19,7 +19,7 @@ pub struct Event {
 
 impl Event {
   pub async fn insert(&self) -> SirenResult<()> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     sqlx::query(&format!(
       "INSERT INTO {} (
         id,
@@ -47,7 +47,7 @@ impl Event {
   }
 
   pub async fn get_by_id(id: i64) -> SirenResult<Option<Self>> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     let item = sqlx::query_as::<_, Self>(&format!("SELECT * FROM {} WHERE id = $1", TABLE_NAME))
       .bind(id)
       .fetch_optional(pool)

src/data/guilds/model.rs

@@ -12,7 +12,7 @@ pub struct GuildCache {
 
 impl GuildCache {
   pub async fn insert(&self) -> SirenResult<()> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     sqlx::query(&format!(
       "INSERT INTO {} (
         id,
@@ -32,7 +32,7 @@ impl GuildCache {
   }
 
   pub async fn get_by_id(id: i64) -> SirenResult<Option<Self>> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     let item = sqlx::query_as::<_, Self>(&format!("SELECT * FROM {} WHERE id = $1", TABLE_NAME))
       .bind(id)
       .fetch_optional(pool)
@@ -42,7 +42,7 @@ impl GuildCache {
   }
 
   pub async fn update(&self) -> SirenResult<()> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     sqlx::query(&format!(
       "UPDATE {} SET
         bot_id = $2,

src/data/messages/model.rs

@@ -19,7 +19,7 @@ pub struct MessageCache {
 
 impl MessageCache {
   pub async fn insert(&self) -> SirenResult<()> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     sqlx::query(&format!(
       "INSERT INTO {} (
         id,
@@ -58,9 +58,9 @@ impl MessageCache {
     author_id: i64,
     limit: i64,
   ) -> SirenResult<Vec<MessageCache>> {
-    let pool = crate::database::pool();
+    let pool = crate::data::pool();
     let messages = sqlx::query_as::<_, MessageCache>(&format!(
-      "SELECT * FROM {} WHERE guild_id = $1 AND channel_id = $2 AND author_id = $3 ORDER BY created DESC LIMIT $4",
+      "SELECT * FROM {} WHERE guild_id = $1 AND channel_id = $2 AND author_id = $3 ORDER BY created ASC LIMIT $4",
       TABLE_NAME
     ))
     .bind(guild_id)

src/main.rs

@@ -9,7 +9,7 @@ use reqwest::Client as HttpClient;
 use crate::bot::handler::Handler;
 
 mod bot;
-mod database;
+mod data;
 mod dnd;
 mod error;
 
@@ -23,7 +23,7 @@ impl TypeMapKey for HttpKey {
 async fn main() {
   dotenv::dotenv().ok();
   env_logger::init_from_env(env_logger::Env::default().filter_or("RUST_LOG", "warn,siren=info"));
-  if let Err(err) = database::initialize().await {
+  if let Err(err) = data::initialize().await {
     log::error!("Failed to initialize database: {err}");
     return;
   };