Add new alias for delete queue and improve logic

src/main/java/netneutrality/NetNeutrality.java

@@ -38,6 +38,7 @@ public class NetNeutrality {
             options.setEnvironment(env);
             options.setTracesSampleRate(1.0);
             options.setDebug(env.equals("dev"));
+            options.setRelease("[email protected]");
         });
 
         if ("dev".equals(env)) {
@@ -49,7 +50,7 @@ public class NetNeutrality {
         CommandManager.init();
         MusicManager.initPlayerManager();
         jda.addEventListener(new MessageReceivedHandler(), new EditHandler(), new ServerJoinHandler());
-        new WebApi(9000);
+        new WebApi(Integer.parseInt(Settings.getInstance().get("API_PORT", "9000")));
         jda.getPresence().setActivity(Activity.watching("you"));
 
         Runtime.getRuntime().addShutdownHook(new BaseThreadFactory("shutdown").newThread(new ShutdownThread()));

src/main/java/netneutrality/command/music/DeleteQueueCommand.java

@@ -34,7 +34,7 @@ public class DeleteQueueCommand extends AbstractMusicCommand {
 
     @Override
     public String[] getAlias() {
-        return new String[] {"delq", "delqueue"};
+        return new String[] {"delq", "delqueue", "clear"};
     }
 
     @Override
@@ -67,8 +67,7 @@ public class DeleteQueueCommand extends AbstractMusicCommand {
             if (context.getArg(0).equals("all")) {
 
                 if (queueSize > 0) {
-                    player.leave();
-                    player.getScheduler().getQueueManager().getQueue().clear();
+                    player.getScheduler().getQueueManager().clearQueue();
                     context.reply(String.format("Removed %d track%s from the queue", queueSize--, (queueSize > 1 ? "s" : "")));
                 } else {
                     context.reply("Queue is empty!");

src/main/java/netneutrality/music/MusicManager.java

@@ -47,13 +47,14 @@ public class MusicManager {
     private final Guild guild;
     private final AudioPlayer player;
     private final TrackScheduler scheduler;
+    private TrackLoadingHandler lastLoadingHandler;
     private ScheduledFuture<?> autoDisconnectThread;
     private final int baseVolume;
 
     private MusicManager(Guild guild) {
         this.guild = guild;
         this.player = playerManager.createPlayer();
-        this.scheduler = new TrackScheduler(player, guild);
+        this.scheduler = new TrackScheduler(this);
         this.baseVolume = Integer.parseInt(GuildManager.getManager(guild).getSetting(GuildManager.Settings.MUSIC_VOLUME));
 
         guild.getAudioManager().setSendingHandler(new AudioPlayerSendHandler(player));
@@ -117,10 +118,18 @@ public class MusicManager {
         return info.getRequester();
     }
 
+    protected AudioPlayer getPlayer() {
+        return player;
+    }
+
     public Guild getGuild() {
         return guild;
     }
 
+    public TrackLoadingHandler getLastLoadingHandler() {
+        return lastLoadingHandler;
+    }
+
     public synchronized void leave() {
         if (isConnected()) {
             logger.debug("Guild {}: leaving voice channel {}", guild.getId(), guild.getAudioManager().getConnectedChannel().getId());
@@ -183,64 +192,8 @@ public class MusicManager {
         scheduler.getTopicManager().attachTextChannel(channel);
 
         if (identifier != null) {
-            playerManager.loadItemOrdered(this, identifier, new AudioLoadResultHandler() {
-
-                @Override
-                public void trackLoaded(AudioTrack audioTrack) {
-                    logger.debug("Guild {}: track loaded: {}", guild.getId(), identifier);
-                    context.deleteMessage();
-
-                    scheduler.getQueueManager().queue(audioTrack, member);
-
-                    if (!silent) {
-                        //context.replyToMessage("Added track to queue");
-                        context.reply(MessageFunction.buildAddingTrackMessage(audioTrack, member, identifier));
-                    }
-                }
-
-                @Override
-                public void playlistLoaded(AudioPlaylist audioPlaylist) {
-                    logger.debug("Guild {}: playlist loaded: {}", guild.getId(), identifier);
-                    context.deleteMessage();
-
-                    if (audioPlaylist.isSearchResult()) {
-                        AudioTrack track = audioPlaylist.getTracks().get(0);
-                        scheduler.getQueueManager().queue(track, member);
-
-                        if (!silent) {
-                            //context.replyToMessage(new MessageBuilder("Added track to queue: ").append(String.format("https://youtu.be/%s", track.getIdentifier())).build());
-                            context.reply(MessageFunction.buildAddingTrackMessage(track, member, String.format("https://youtu.be/%s", track.getIdentifier())));
-                        }
-
-                    } else {
-                        if (!silent) {
-                            //context.replyToMessage("Added playlist to queue");
-                            context.reply(MessageFunction.buildAddingPlaylistMessage(audioPlaylist, member, identifier));
-                        }
-
-                        for (AudioTrack track : audioPlaylist.getTracks()) {
-                            synchronized (scheduler.getQueueManager().getQueue()) {
-                                scheduler.getQueueManager().queue(track, member);
-                            }
-                        }
-                    }
-
-
-                }
-
-                @Override
-                public void noMatches() {
-                    logger.debug("Guild {}: no matches for identifier {}", guild.getId(), identifier);
-                    context.replyToMessage("No matches found");
-                }
-
-                @Override
-                public void loadFailed(FriendlyException e) {
-                    logger.debug("Guild {}: load failed for identifier {}", guild.getId(), identifier, e);
-                    context.replyToMessage("Failed to load track: " + e.getMessage());
-                }
-
-            });
+            lastLoadingHandler = new TrackLoadingHandler(identifier, silent, this, context);
+            playerManager.loadItemOrdered(this, identifier, lastLoadingHandler);
         } else {
             context.replyToMessage("No source found to play the given url");
         }

src/main/java/netneutrality/music/QueueManager.java

@@ -87,13 +87,16 @@ public class QueueManager {
     }
 
     private final Logger logger = LoggerFactory.getLogger(QueueManager.class);
+
+    private final TrackScheduler scheduler;
     private final AudioPlayer player;
     private final Guild guild;
     private final Deque<TrackInfo> queue;
 
-    public QueueManager(AudioPlayer player, Guild guild) {
-        this.player = player;
-        this.guild = guild;
+    public QueueManager(TrackScheduler scheduler) {
+        this.scheduler = scheduler;
+        this.player = scheduler.getPlayer();
+        this.guild = scheduler.getGuild();
 
         this.queue = new LinkedBlockingDeque<>();
     }
@@ -104,10 +107,23 @@ public class QueueManager {
         }
     }
 
+    public TrackScheduler getScheduler() {
+        return scheduler;
+    }
+
     public Guild getGuild() {
         return guild;
     }
 
+    public void clearQueue() {
+        scheduler.getMusicManager().leave();
+        scheduler.getMusicManager().getLastLoadingHandler().stopLoading();
+
+        synchronized (queue) {
+            queue.clear();
+        }
+    }
+
     public ArrayList<AudioTrack> getAllQueuedTrack() {
         synchronized (queue) {
             ArrayList<AudioTrack> tracks = new ArrayList<>();

src/main/java/netneutrality/music/TopicManager.java

@@ -15,12 +15,18 @@ import java.util.concurrent.TimeUnit;
 
 public class TopicManager {
 
+    private final TrackScheduler scheduler;
     private final Guild guild;
     private TextChannel channel;
     private String originalTopic;
 
-    public TopicManager(Guild guild) {
-        this.guild = guild;
+    public TopicManager(TrackScheduler scheduler) {
+        this.scheduler = scheduler;
+        this.guild = scheduler.getGuild();
+    }
+
+    public TrackScheduler getScheduler() {
+        return scheduler;
     }
 
     public Guild getGuild() {

src/main/java/netneutrality/music/TrackLoadingHandler.java

@@ -0,0 +1,105 @@
+package netneutrality.music;
+/*
+ * Copyright (c) anthorob
+ *
+ * https://xtremcommunity.com/
+ * https://discord.gg/CdFcyQ
+ */
+
+
+import com.sedmelluq.discord.lavaplayer.player.AudioLoadResultHandler;
+import com.sedmelluq.discord.lavaplayer.tools.FriendlyException;
+import com.sedmelluq.discord.lavaplayer.track.AudioPlaylist;
+import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
+import net.dv8tion.jda.api.entities.Guild;
+import netneutrality.core.context.CommandContext;
+import netneutrality.utils.MessageFunction;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TrackLoadingHandler implements AudioLoadResultHandler {
+    private final Logger logger = LoggerFactory.getLogger(TrackLoadingHandler.class);
+
+    private final String identifier;
+    private final boolean silent;
+    private boolean loadingDisabled = false;
+    private final Guild guild;
+    private final TrackScheduler scheduler;
+    private final CommandContext  context;
+
+    public TrackLoadingHandler(String identifier, boolean silent, MusicManager manager, CommandContext context) {
+        this.identifier = identifier;
+        this.silent = silent;
+        this.guild = manager.getGuild();
+        this.scheduler = manager.getScheduler();
+        this.context = context;
+    }
+
+    public synchronized void stopLoading() {
+        logger.debug("Guild {}: stopped loading of new tracks", guild.getId());
+        loadingDisabled = true;
+    }
+
+    @Override
+    public void trackLoaded(AudioTrack audioTrack) {
+        if (loadingDisabled) {
+            return;
+        }
+
+        logger.debug("Guild {}: track loaded: {}", guild.getId(), identifier);
+        context.deleteMessage();
+
+        scheduler.getQueueManager().queue(audioTrack, context.getGuildUser());
+
+        if (!silent) {
+            //context.replyToMessage("Added track to queue");
+            context.reply(MessageFunction.buildAddingTrackMessage(audioTrack, context.getGuildUser(), identifier));
+        }
+    }
+
+    @Override
+    public void playlistLoaded(AudioPlaylist audioPlaylist) {
+        if (loadingDisabled) {
+            return;
+        }
+
+        logger.debug("Guild {}: playlist loaded: {}", guild.getId(), identifier);
+        context.deleteMessage();
+
+        if (audioPlaylist.isSearchResult()) {
+            AudioTrack track = audioPlaylist.getTracks().get(0);
+            scheduler.getQueueManager().queue(track, context.getGuildUser());
+
+            if (!silent) {
+                //context.replyToMessage(new MessageBuilder("Added track to queue: ").append(String.format("https://youtu.be/%s", track.getIdentifier())).build());
+                context.reply(MessageFunction.buildAddingTrackMessage(track, context.getGuildUser(), String.format("https://youtu.be/%s", track.getIdentifier())));
+            }
+
+        } else {
+            if (!silent) {
+                //context.replyToMessage("Added playlist to queue");
+                context.reply(MessageFunction.buildAddingPlaylistMessage(audioPlaylist, context.getGuildUser(), identifier));
+            }
+
+            for (AudioTrack track : audioPlaylist.getTracks()) {
+                synchronized (scheduler.getQueueManager().getQueue()) {
+                    scheduler.getQueueManager().queue(track, context.getGuildUser());
+                }
+            }
+        }
+
+
+    }
+
+    @Override
+    public void noMatches() {
+        logger.debug("Guild {}: no matches for identifier {}", guild.getId(), identifier);
+        context.replyToMessage("No matches found");
+    }
+
+    @Override
+    public void loadFailed(FriendlyException e) {
+        logger.debug("Guild {}: load failed for identifier {}", guild.getId(), identifier, e);
+        context.replyToMessage("Failed to load track: " + e.getMessage());
+    }
+}

src/main/java/netneutrality/music/TrackScheduler.java

@@ -17,18 +17,20 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class TrackScheduler extends AudioEventAdapter {
-
     private final static Logger logger = LoggerFactory.getLogger(TrackScheduler.class);
+
     private final QueueManager queueManager;
     private final TopicManager topicManager;
+    private final MusicManager manager;
     private final AudioPlayer player;
     private final Guild guild;
 
-    public TrackScheduler(AudioPlayer player, Guild guild) {
-        this.player = player;
-        this.guild = guild;
-        this.queueManager = new QueueManager(player, guild);
-        this.topicManager = new TopicManager(guild);
+    public TrackScheduler(MusicManager manager) {
+        this.manager = manager;
+        this.player = manager.getPlayer();
+        this.guild = manager.getGuild();
+        this.queueManager = new QueueManager(this);
+        this.topicManager = new TopicManager(this);
     }
 
     public QueueManager getQueueManager() {
@@ -39,10 +41,18 @@ public class TrackScheduler extends AudioEventAdapter {
         return topicManager;
     }
 
+    public MusicManager getMusicManager() {
+        return manager;
+    }
+
     public AudioPlayer getPlayer() {
         return player;
     }
 
+    public Guild getGuild() {
+        return guild;
+    }
+
     @Override
     public void onPlayerPause(AudioPlayer player) {
         // Player was paused

src/main/resources/log4j2.properties

@@ -30,6 +30,14 @@ logger.jda.additivity = false
 logger.jda.appenderRef.rolling.ref = LogToRollingFile
 logger.jda.appenderRef.console.ref = consoleLogger
 
+logger.lavaplayer.name = com.sedmelluq.discord
+logger.lavaplayer.level = info
+logger.lavaplayer.additivity = false
+logger.lavaplayer.appenderRef.rolling.ref = LogToRollingFile
+logger.lavaplayer.appenderRef.console.ref = consoleLogger
+
+
+
 logger.app.name = netneutrality
 logger.app.level = debug
 logger.app.additivity = false