Start implementing serenity 0.6

src/main.rs

@@ -11,8 +11,24 @@ mod confighandler;
 mod macros;
 mod player;
 
-use serenity::client::Client;
+use serenity::{
-use serenity::framework::StandardFramework;
+    framework::standard::{
+        help_commands,
+        macros::{check, command, group, help},
+        Args, CheckResult, CommandGroup, CommandOptions, CommandResult, DispatchError, HelpOptions,
+        StandardFramework,
+    },
+    model::{
+        channel::{Channel, Message},
+        gateway::Ready,
+        id::UserId,
+    },
+    utils::{content_safe, ContentSafeOptions},
+};
+
+// This imports `typemap`'s `Key` as `TypeMapKey`.
+use serenity::prelude::*;
+
 use std::sync::Arc;
 
 use confighandler::*;
@@ -32,6 +48,12 @@ impl Default for Config {
     }
 }
 
+group!({
+    name: "general",
+    options: {},
+    commands: [ip]
+});
+
 fn main() {
     // read config file
     let config_file = check_result_return!(read_config("bot.conf"));
@@ -71,13 +93,15 @@ fn main() {
     // voice manager into it. This allows the voice manager to be accessible by
     // event handlers and framework commands.
     {
-        let mut data = client.data.lock();
+        let mut data = client.data.write();
         data.insert::<VoiceManager>(Arc::clone(&client.voice_manager));
     }
 
     let media_data =
         Arc::new(MediaData::new("Penis1").expect("failed to create media data handle"));
 
+    /*
+
     client.with_framework(
         StandardFramework::new()
             .configure(|c| c.prefix(&config.prefix).on_mention(true))
@@ -109,4 +133,6 @@ fn main() {
     let _ = client
         .start()
         .map_err(|why| println!("Client ended: {:?}", why));
+
+    */
 }

src/player/commands/help.rs

@@ -1,37 +0,0 @@
-use serenity;
-
-pub struct Help {
-    prefix: String,
-    commands: Vec<String>,
-}
-
-impl Help {
-    pub fn new(prefix: &String, commands: Vec<String>) -> Help {
-        Help {
-            prefix: prefix.clone(),
-            commands: commands,
-        }
-    }
-}
-
-impl serenity::framework::standard::Command for Help {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        _: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        _: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
-        let mut output = String::new();
-
-        output += "Available commands:\n";
-
-        for command in &self.commands {
-            output += &format!("\t{}{}\n", self.prefix, command);
-        }
-
-        print_error!(msg.channel_id.say(output));
-
-        Ok(())
-    }
-}

src/player/commands/ip.rs

@@ -1,24 +1,16 @@
-use serenity;
+use serenity::{
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
+
+// This imports `typemap`'s `Key` as `TypeMapKey`.
+use serenity::prelude::*;
 
 use std::process::{Command, Stdio};
 use std::str::from_utf8;
 
-pub struct IP {}
+#[command]
-
+fn ip(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {
-impl IP {
-    pub fn new() -> IP {
-        IP {}
-    }
-}
-
-impl serenity::framework::standard::Command for IP {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        _: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        _: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
     let args = ["ifconfig.me"];
 
     let out = match Command::new("curl")
@@ -40,5 +32,4 @@ impl serenity::framework::standard::Command for IP {
     };
 
     Ok(())
-    }
 }

src/player/commands/list.rs

@@ -1,27 +1,13 @@
-use serenity;
-
-use std::sync::Arc;
-
 use super::super::prelude::*;
 
-pub struct List {
+use serenity::prelude::*;
-    media: Arc<MediaData>,
+use serenity::{
-}
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
 
-impl List {
+#[command]
-    pub fn new(media_data: Arc<MediaData>) -> List {
+fn list(ctx: &mut Context, msg: &Message, _: Args) -> CommandResult {
-        List { media: media_data }
-    }
-}
-
-impl serenity::framework::standard::Command for List {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        ctx: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        _: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
     if !channel_contains_author(ctx, msg) {
         println!(
             "user {} is not in the same voice channel as the bot",
@@ -32,9 +18,16 @@ impl serenity::framework::standard::Command for List {
 
     let mut output = String::new();
 
-        {
+    let data = ctx.data.read();
-            let playlist_mutex = self.media.playlist_mut()?;
+    let media = match data.get::<MediaData>() {
-            let playlist = playlist_mutex.borrow();
+        Ok(media) => media,
+        Err(_) => {
+            msg.channel_id.say("could not find media data");
+            return Ok(());
+        }
+    };
+
+    let playlist = media.playlist();
 
     output += &format!(
         "{} {} queued\n",
@@ -52,10 +45,8 @@ impl serenity::framework::standard::Command for List {
             break;
         }
     }
-        }
 
     print_error!(msg.channel_id.say(output));
 
     Ok(())
-    }
 }

src/player/commands/mod.rs

@@ -1,4 +1,3 @@
-pub mod help;
 pub mod ip;
 pub mod list;
 pub mod pause;

src/player/commands/pause.rs

@@ -1,28 +1,15 @@
 use serenity;
 
-use std::ops::DerefMut;
-use std::sync::Arc;
-
 use super::super::prelude::*;
 
-pub struct Pause {
+use serenity::prelude::*;
-    media: Arc<MediaData>,
+use serenity::{
-}
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
 
-impl Pause {
+#[command]
-    pub fn new(media_data: Arc<MediaData>) -> Pause {
+fn pause(ctx: &mut Context, msg: &Message, _: Args) -> CommandResult {
-        Pause { media: media_data }
-    }
-}
-
-impl serenity::framework::standard::Command for Pause {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        ctx: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        _: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
     if !channel_contains_author(ctx, msg) {
         println!(
             "user {} is not in the same voice channel as the bot",
@@ -31,15 +18,16 @@ impl serenity::framework::standard::Command for Pause {
         return Ok(());
     }
 
-        let song_lock = self.media.song_mut()?;
+    let data = ctx.data.read();
-
+    let media = match data.get::<MediaData>() {
-        if let Some(song) = song_lock.borrow_mut().deref_mut() {
+        Ok(media) => media,
-            let song_clone = song.clone();
+        Err(_) => {
-            let mut audio_lock = song_clone.lock();
+            msg.channel_id.say("could not find media data");
-
+            return Ok(());
-            audio_lock.pause();
         }
+    };
+
+    media.song().pause();
 
     Ok(())
-    }
 }

src/player/commands/play.rs

@@ -1,8 +1,5 @@
 use parking_lot;
 
-use serenity;
-use serenity::voice::LockedAudio;
-
 use std::cell::RefCell;
 use std::ops::{Deref, DerefMut};
 use std::sync::{Arc, MutexGuard};
@@ -13,16 +10,58 @@ use super::super::prelude::*;
 
 use rusqlite::params;
 
-pub struct Play {
+use serenity::prelude::*;
-    media: Arc<MediaData>,
+use serenity::voice::LockedAudio;
-}
+use serenity::{
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
 
-impl Play {
+#[command]
-    pub fn new(media_data: Arc<MediaData>) -> Play {
+fn play(ctx: &mut Context, msg: &Message, args: Args) -> CommandResult {
-        Play { media: media_data }
+    if !channel_contains_author(ctx, msg) {
+        println!(
+            "user {} is not in the same voice channel as the bot",
+            msg.author.name
+        );
+        return Ok(());
     }
 
-    fn check_for_continue(song_lock: MutexGuard<RefCell<Option<LockedAudio>>>) -> bool {
+    let data = ctx.data.read();
+    let mut media = match data.get_mut::<MediaData>() {
+        Ok(media) => media,
+        Err(_) => {
+            msg.channel_id.say("could not find media data");
+            return Ok(());
+        }
+    };
+
+    if args.len() == 0 {
+        if !Self::check_for_continue(self.media.song_mut()?) {
+            print_error!(msg.channel_id.say("Must provide a URL to a video or audio"));
+        }
+    } else if args.len() == 1 {
+        let arg = match args.single::<String>() {
+            Ok(arg) => arg,
+            // can't happen, since we tested for length == 1
+            Err(_) => return Ok(()),
+        };
+
+        if arg == "--local" {
+            self.handle_local_request(ctx, msg)?;
+        } else if arg.starts_with("http") {
+            self.handle_http_request(ctx, msg, &arg)?;
+        } else {
+            self.handle_song_request(ctx, msg, &arg)?;
+        }
+    } else {
+        print_error!(msg.channel_id.say("Unsupported argument list"));
+    }
+
+    Ok(())
+}
+
+fn check_for_continue(song_lock: MutexGuard<RefCell<Option<LockedAudio>>>) -> bool {
     match song_lock.borrow_mut().deref_mut() {
         Some(song) => {
             let song_clone = song.clone();
@@ -33,12 +72,12 @@ impl Play {
         }
         None => false,
     }
-    }
+}
 
-    fn check_join_channel(
+fn check_join_channel(
     manager_lock: &Arc<parking_lot::Mutex<serenity::client::bridge::voice::ClientVoiceManager>>,
     msg: &serenity::model::channel::Message,
-    ) {
+) {
     let guild = match msg.guild() {
         Some(guild) => guild,
         None => {
@@ -68,14 +107,14 @@ impl Play {
     let mut manager = manager_lock.lock();
 
     manager.join(guild_id, connect_to);
-    }
+}
 
-    fn append_songs(
+fn append_songs(
-        &self,
+    media: &mut MediaData,
     ctx: &mut serenity::client::Context,
     msg: &serenity::model::channel::Message,
     mut source: Vec<Song>,
-    ) -> Result<(), String> {
+) -> Result<(), String> {
     {
         let playlist_mutex = self.media.playlist_mut()?;
         playlist_mutex.borrow_mut().append(&mut source);
@@ -106,14 +145,14 @@ impl Play {
     }
 
     Ok(())
-    }
+}
 
-    fn handle_http_request(
+fn handle_http_request(
-        &self,
+    media: &mut MediaData,
     ctx: &mut serenity::client::Context,
     msg: &serenity::model::channel::Message,
     url: &String,
-    ) -> Result<(), String> {
+) -> Result<(), String> {
     let sql = self.media.lock_db()?;
 
     let mut stmt = match sql.prepare("SELECT name FROM Vulva3 WHERE link = ?") {
@@ -187,13 +226,13 @@ impl Play {
     self.append_songs(ctx, msg, source)?;
 
     Ok(())
-    }
+}
 
-    fn handle_local_request(
+fn handle_local_request(
-        &self,
+    media: &mut MediaData,
     ctx: &mut serenity::client::Context,
     msg: &serenity::model::channel::Message,
-    ) -> Result<(), String> {
+) -> Result<(), String> {
     let sql = self.media.lock_db()?;
 
     let mut stmt = match sql.prepare("SELECT name FROM Vulva3") {
@@ -222,14 +261,14 @@ impl Play {
     self.append_songs(ctx, msg, songs)?;
 
     Ok(())
-    }
+}
 
-    fn handle_song_request(
+fn handle_song_request(
-        &self,
+    media: &mut MediaData,
     ctx: &mut serenity::client::Context,
     msg: &serenity::model::channel::Message,
     pattern: &str,
-    ) -> Result<(), String> {
+) -> Result<(), String> {
     let sql = self.media.lock_db()?;
 
     let mut stmt = match sql.prepare(&format!(
@@ -267,47 +306,4 @@ impl Play {
     }
 
     Ok(())
-    }
-}
-
-impl serenity::framework::standard::Command for Play {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        mut ctx: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        mut args: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
-        if !channel_contains_author(ctx, msg) {
-            println!(
-                "user {} is not in the same voice channel as the bot",
-                msg.author.name
-            );
-            return Ok(());
-        }
-
-        if args.len() == 0 {
-            if !Self::check_for_continue(self.media.song_mut()?) {
-                print_error!(msg.channel_id.say("Must provide a URL to a video or audio"));
-            }
-        } else if args.len() == 1 {
-            let arg = match args.single::<String>() {
-                Ok(arg) => arg,
-                // can't happen, since we tested for length == 1
-                Err(_) => return Ok(()),
-            };
-
-            if arg == "--local" {
-                self.handle_local_request(ctx, msg)?;
-            } else if arg.starts_with("http") {
-                self.handle_http_request(ctx, msg, &arg)?;
-            } else {
-                self.handle_song_request(ctx, msg, &arg)?;
-            }
-        } else {
-            print_error!(msg.channel_id.say("Unsupported argument list"));
-        }
-
-        Ok(())
-    }
 }

src/player/commands/remove.rs

@@ -1,56 +1,50 @@
 use serenity;
 
 use std::fs;
-use std::sync::Arc;
 
 use super::super::prelude::*;
 
 use rusqlite::params;
 
-pub struct Remove {
+use serenity::prelude::*;
-    media: Arc<MediaData>,
+use serenity::{
-}
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
 
-impl Remove {
+#[command]
-    pub fn new(media_data: Arc<MediaData>) -> Remove {
+fn remove(ctx: &mut Context, msg: &Message, _: Args) -> CommandResult {
-        Remove { media: media_data }
+    let data = ctx.data.read();
+    let media = match data.get::<MediaData>() {
+        Ok(media) => media,
+        Err(_) => {
+            msg.channel_id.say("could not find media data");
+            return Ok(());
         }
-}
+    };
 
-impl serenity::framework::standard::Command for Remove {
+    let song_name = media.song_name();
-    #[allow(unreachable_code, unused_mut)]
+    let sql = media.db();
-    fn execute(
-        &self,
-        mut _ctx: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        mut _args: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
-        // (1)
 
-        let song_name = self.media.name_mut()?;
+    if let Err(_) = sql.execute("DELETE FROM Vulva3 WHERE name = ?", params![song_name]) {
-        let name: String = song_name.borrow().clone();
-
-        let sql = self.media.lock_db()?;
-
-        if let Err(_) = sql.execute("DELETE FROM Vulva3 WHERE name = ?", params![name]) {
         return Err(serenity::framework::standard::CommandError(
             "failed executing sql delete".to_string(),
         ));
     }
 
-        if !name.is_empty() {
+    if !song_name.is_empty() {
-            match fs::remove_file(&name) {
+        match fs::remove_file(&song_name) {
-                Ok(_) => print_error!(msg
+            Ok(_) => print_error!(msg.channel_id.say(format!(
-                    .channel_id
+                "Remove current song ({}) from local disk",
-                    .say(format!("Remove current song ({}) from local disk", name))),
+                song_name
+            ))),
             Err(err) => print_error!(msg.channel_id.say(format!(
                 "Error removing file ({}): {:?}",
-                    name,
+                song_name,
                 err.kind()
             ))),
         };
     }
 
     Ok(())
-    }
 }

src/player/commands/skip.rs

@@ -1,28 +1,16 @@
 use serenity;
 use serenity::voice::ffmpeg;
 
-use std::sync::Arc;
-
 use super::super::prelude::*;
 
-pub struct Skip {
+use serenity::prelude::*;
-    media: Arc<MediaData>,
+use serenity::{
-}
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
 
-impl Skip {
+#[command]
-    pub fn new(media_data: Arc<MediaData>) -> Skip {
+fn skip(ctx: &mut Context, msg: &Message, _: Args) -> CommandResult {
-        Skip { media: media_data }
-    }
-}
-
-impl serenity::framework::standard::Command for Skip {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        ctx: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        _: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
     if !channel_contains_author(ctx, msg) {
         println!(
             "user {} is not in the same voice channel as the bot",
@@ -45,12 +33,19 @@ impl serenity::framework::standard::Command for Skip {
         };
 
         if let Some(handler) = handler(guild_id, &mut manager) {
-                let playlist_mutex = self.media.playlist_mut()?;
+            let data = ctx.data.read();
-                let mut playlist = playlist_mutex.borrow_mut();
+            let mut media = match data.get_mut::<MediaData>() {
+                Ok(media) => media,
+                Err(_) => {
+                    msg.channel_id.say("could not find media data");
+                    return Ok(());
+                }
+            };
 
-                let song_mutex = self.media.song_mut()?;
+            let mut playlist = media.playlist_mut();
-                let mut song = song_mutex.borrow_mut();
+            let mut song = media.song_mut();
 
+            // if current song is the last song in this playlist, just return
             if playlist.is_empty() {
                 print_error!(msg
                     .channel_id
@@ -58,10 +53,13 @@ impl serenity::framework::standard::Command for Skip {
 
                 return Ok(());
             } else {
+                // remove the current song from the playlist
                 let first = playlist.remove(0);
 
+                // stop the current song from playing
                 handler.stop();
 
+                // load next song into memory
                 let source = match ffmpeg(first.name.clone()) {
                     Ok(mpeg) => mpeg,
                     Err(_) => {
@@ -72,10 +70,11 @@ impl serenity::framework::standard::Command for Skip {
                     }
                 };
 
+                // start the next song if possible
+                /*
                 match self.media.next_callback.borrow().as_ref() {
                     Some(callback) => {
-                            *song =
+                        *song = Some(handler.play_returning_and_callback(source, callback.clone()));
-                                Some(handler.play_returning_and_callback(source, callback.clone()));
                         let song_name = self.media.name_mut()?;
                         *song_name.borrow_mut() = first.name.clone();
 
@@ -85,10 +84,16 @@ impl serenity::framework::standard::Command for Skip {
                     }
                     None => println!("error getting callback from media"),
                 }
+                */
+                *song = Some(handler.play_returning(source));
+                *media.song_name_mut() = first.name.clone();
+
+                print_error!(msg
+                    .channel_id
+                    .say(format!("Skipped current song, now playing: {}", first.name)));
             }
         }
     }
 
     Ok(())
-    }
 }

src/player/commands/stop.rs

@@ -1,27 +1,13 @@
-use serenity;
-
-use std::sync::Arc;
-
 use super::super::prelude::*;
 
-pub struct Stop {
+use serenity::prelude::*;
-    media: Arc<MediaData>,
+use serenity::{
-}
+    framework::standard::{macros::command, Args, CommandResult},
+    model::channel::Message,
+};
 
-impl Stop {
+#[command]
-    pub fn new(media_data: Arc<MediaData>) -> Stop {
+fn stop(ctx: &mut Context, msg: &Message, _: Args) -> CommandResult {
-        Stop { media: media_data }
-    }
-}
-
-impl serenity::framework::standard::Command for Stop {
-    #[allow(unreachable_code, unused_mut)]
-    fn execute(
-        &self,
-        ctx: &mut serenity::client::Context,
-        msg: &serenity::model::channel::Message,
-        _: serenity::framework::standard::Args,
-    ) -> ::std::result::Result<(), serenity::framework::standard::CommandError> {
     if !channel_contains_author(ctx, msg) {
         println!(
             "user {} is not in the same voice channel as the bot",
@@ -30,8 +16,16 @@ impl serenity::framework::standard::Command for Stop {
         return Ok(());
     }
 
-        print_error!(self.media.reset(ctx, msg));
+    let data = ctx.data.read();
+    let mut media = match data.get_mut::<MediaData>() {
+        Ok(media) => media,
+        Err(_) => {
+            msg.channel_id.say("could not find media data");
+            return Ok(());
+        }
+    };
+
+    print_error!(data.reset(ctx, msg));
 
     Ok(())
-    }
 }

src/player/mediadata.rs

@@ -3,8 +3,7 @@ use serenity::model::id::ChannelId;
 use serenity::voice::ffmpeg;
 use serenity::voice::LockedAudio;
 
-use std::cell::RefCell;
+use std::sync::Arc;
-use std::sync::{Arc, Mutex, MutexGuard};
 
 use super::prelude::*;
 
@@ -15,12 +14,12 @@ pub struct Song {
 }
 
 pub struct MediaData {
-    playlist: Mutex<RefCell<Vec<Song>>>,
+    playlist: Vec<Song>,
-    current_song: Mutex<RefCell<Option<LockedAudio>>>,
+    current_song: Option<LockedAudio>,
-    song_name: Mutex<RefCell<String>>,
+    song_name: String,
-    pub next_callback: RefCell<Option<Arc<Fn() -> ()>>>,
+    pub next_callback: Option<Arc<Fn() -> ()>>,
 
-    sql_data_base: Mutex<Connection>,
+    sql_data_base: Connection,
 }
 
 impl MediaData {
@@ -45,38 +44,24 @@ impl MediaData {
         };
 
         Ok(MediaData {
-            playlist: Mutex::new(RefCell::new(Vec::new())),
+            playlist: Vec::new(),
-            current_song: Mutex::new(RefCell::new(None)),
+            current_song: None,
-            song_name: Mutex::new(RefCell::new(String::new())),
+            song_name: String::new(),
-            next_callback: RefCell::new(None),
+            next_callback: None,
 
-            sql_data_base: Mutex::new(connection),
+            sql_data_base: connection,
         })
     }
 
     pub fn reset(
-        &self,
+        &mut self,
         ctx: &mut serenity::client::Context,
         msg: &serenity::model::channel::Message,
     ) -> Result<(), String> {
-        {
+        self.playlist().clear();
-            let playlist = self.playlist_mut()?;
+        self.song = None;
-            playlist.borrow_mut().clear();
+        self.name = String::new();
-        }
+        self.next_callback = None();
-
-        {
-            let song = self.song_mut()?;
-            *song.borrow_mut() = None;
-        }
-
-        {
-            let name = self.name_mut()?;
-            *name.borrow_mut() = String::new();
-        }
-
-        {
-            *self.next_callback.borrow_mut() = None;
-        }
 
         if let Some(manager_lock) = ctx.data.lock().get::<VoiceManager>().cloned() {
             let mut manager = manager_lock.lock();
@@ -103,32 +88,32 @@ impl MediaData {
         Ok(())
     }
 
-    pub fn lock_db(&self) -> Result<MutexGuard<Connection>, String> {
+    pub fn db(&self) -> &Connection {
-        match self.sql_data_base.lock() {
+        &self.sql_data_base
-            Ok(sql) => Ok(sql),
-            Err(_) => Err("failed locking db".to_string()),
-        }
     }
 
-    pub fn song_mut(&self) -> Result<MutexGuard<RefCell<Option<LockedAudio>>>, String> {
+    pub fn song(&self) -> &Option<LockedAudio> {
-        match self.current_song.lock() {
+        &self.current_song
-            Ok(sql) => Ok(sql),
-            Err(_) => Err("failed locking current song".to_string()),
-        }
     }
 
-    pub fn playlist_mut(&self) -> Result<MutexGuard<RefCell<Vec<Song>>>, String> {
+    pub fn song_mut(&mut self) -> &mut Option<LockedAudio> {
-        match self.playlist.lock() {
+        &mut self.current_song
-            Ok(sql) => Ok(sql),
-            Err(_) => Err("failed locking playlist".to_string()),
-        }
     }
 
-    pub fn name_mut(&self) -> Result<MutexGuard<RefCell<String>>, String> {
+    pub fn playlist(&self) -> &Vec<Song> {
-        match self.song_name.lock() {
+        &self.playlist
-            Ok(sql) => Ok(sql),
-            Err(_) => Err("failed locking current song name".to_string()),
     }
+
+    pub fn playlist_mut(&mut self) -> &mut Vec<Song> {
+        &mut self.playlist
+    }
+
+    pub fn song_name(&self) -> &String {
+        &self.name
+    }
+
+    pub fn song_name_mut(&mut self) -> &mut String {
+        &mut self.name
     }
 
     pub fn start_playing(

src/player/player.rs

@@ -1,13 +1,12 @@
-use parking_lot;
+use parking_lot::MutexGuard;
-
 use serenity;
-use serenity::client::CACHE;
 use serenity::model::id::{ChannelId, GuildId};
 use serenity::voice::Handler;
 
 use super::prelude::*;
 
 pub fn guild_id(channel_id: ChannelId) -> Option<GuildId> {
+    /*
     match CACHE.read().guild_channel(channel_id) {
         Some(channel) => Some(channel.read().guild_id),
         None => {
@@ -15,14 +14,13 @@ pub fn guild_id(channel_id: ChannelId) -> Option<GuildId> {
             None
         }
     }
+    */
+    None
 }
 
 pub fn handler<'a>(
     guild_id: GuildId,
-    manager: &'a mut parking_lot::MutexGuard<
+    manager: &'a mut MutexGuard<'_, serenity::client::bridge::voice::ClientVoiceManager>,
-        '_,
-        serenity::client::bridge::voice::ClientVoiceManager,
-    >,
 ) -> Option<&'a mut Handler> {
     manager.get_mut(guild_id)
 }
@@ -32,7 +30,7 @@ pub fn channel_contains_author(
     msg: &serenity::model::channel::Message,
 ) -> bool {
     let (guild_id, voice_channel_id_bot) = {
-        match ctx.data.lock().get::<VoiceManager>().cloned() {
+        match ctx.data.read().get::<VoiceManager>().cloned() {
             Some(manager_lock) => {
                 let mut manager = manager_lock.lock();
                 let guild_id = match guild_id(msg.channel_id) {
@@ -68,7 +66,7 @@ pub fn channel_contains_author(
 
     let author = &msg.author;
 
-    let guild = match guild_id.to_guild_cached() {
+    let guild = match guild_id.to_guild_cached(&ctx) {
         Some(guild) => guild,
         None => {
             println!("error getting guild from cache");

src/player/prelude.rs

@@ -1,13 +1,12 @@
 pub use super::mediadata::{MediaData, Song};
 
-pub use super::commands::help::Help;
+pub use super::commands::ip::*;
-pub use super::commands::ip::IP;
+pub use super::commands::list::*;
-pub use super::commands::list::List;
+pub use super::commands::pause::*;
-pub use super::commands::pause::Pause;
+pub use super::commands::play::*;
-pub use super::commands::play::Play;
+pub use super::commands::remove::*;
-pub use super::commands::remove::Remove;
+pub use super::commands::skip::*;
-pub use super::commands::skip::Skip;
+pub use super::commands::stop::*;
-pub use super::commands::stop::Stop;
 
 pub use super::eventhandler::Handler;
 pub use super::voicemanager::VoiceManager;

src/player/voicemanager.rs

@@ -1,5 +1,5 @@
+use parking_lot::Mutex;
 use serenity::client::bridge::voice::ClientVoiceManager;
-use serenity::prelude::Mutex;
 use std::sync::Arc;
 use typemap::Key;