Reflect recent changes in the readme

.gitignore

@@ -4,4 +4,5 @@
 /test/
 *.json
 *.txt
-nb*.xml
+nb*.xml
+dockerfile

README.md

@@ -1,5 +1,75 @@
 <img align="right" src="https://i.imgur.com/zrE80HY.png" height="200" width="200">
 
+# This fork
+
+Essentially, this is just a merge of three pull requests:
+
+### Support for logging into your (burner) youtube account:
+
+[PR-1670](https://github.com/jagrosh/MusicBot/pull/1670)
+
+### To allow building the project from source
+[PR-1703](https://github.com/jagrosh/MusicBot/pull/1703)
+
+### Add YouTube PO token & IP rotation
+https://github.com/jagrosh/MusicBot/pull/1772
+
+And I've now bumped the versions up to the newest [lavaplayer](https://mvnrepository.com/artifact/dev.arbjerg/lavaplayer)/[lavalink](https://maven.lavalink.dev/#/releases/dev/lavalink/youtube/common) versions. I will try to update this automatically in the future.
+
+
+### For PO_Tokens: In your bot folder, edit "config.txt" and add
+```
+ytpotoken = "PO_TOKEN_HERE"
+ytvisitordata = "VISITOR_DATA_HERE"
+```
+
+To get po_token and visitor_data, use [youtube-trusted-session-generator](https://github.com/iv-org/youtube-trusted-session-generator)
+
+
+If you have problems with this fork, you could also check out [this other fork](https://github.com/SeVile/MusicBot).
+
+## Easy deployment via docker
+
+Additionally, i thought a corresponding docker image would make things better:
+
+The image can be found on [dockerhub](https://hub.docker.com/repository/docker/chrisb09/jmusicbot/general)
+
+Docker-compose:
+
+```yaml
+version: '2.2'
+
+services:
+  jmusicbot:
+    image: chrisb09/jmusicbot:latest
+    container_name: jmusicbot
+    restart: unless-stopped
+    volumes:
+     - ./config:/jmb/config
+```
+
+although, obviously you should change `./config` to whatever path is right for your setup.
+Source code for the docker image is also on [Github](https://github.com/chrisb09/jmb-container).
+
+
+## YouTube-Login
+
+Obviously you still need to log in if you want to use youtube properly, hence you need to enable this in the config.
+If you are using a pre-existing config, simply add:
+```
+/ If you set this to true, the bot will use a Google account to play YouTube tracks.
+// This is only needed if you are experiencing issues with YouTube playback.
+// Once enabled, instructions for login will be written to the console and DMs.
+// DO NOT use your main Google account! Use an alternative account.
+
+youtubeoauth2=true
+```
+
+If you start with a clean slate this line should already be present, albeit with `false` being the default.
+As the author of the PR reiterates multiple times, do not use your main google account as using your account for a bot is most certainly against the ToS and thus you are endangering said account.
+
+To add the account you simply have to follow the very basic instructions printed either in the console or sent to you from the bot via discord after you have started it, open the linked google page and paste the code.
+
 # JMusicBot
 
 [![Downloads](https://img.shields.io/github/downloads/jagrosh/MusicBot/total.svg)](https://github.com/jagrosh/MusicBot/releases/latest)

pom.xml

@@ -3,7 +3,7 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.jagrosh</groupId>
     <artifactId>JMusicBot</artifactId>
-    <version>Snapshot</version>
+    <version>0.4.7</version>
     <packaging>jar</packaging>
 
     <repositories>
@@ -44,23 +44,27 @@
             <artifactId>JDA</artifactId>
             <version>4.4.1_353</version>
         </dependency>
-        <dependency>
-            <groupId>com.jagrosh</groupId>
-            <artifactId>jda-utilities</artifactId>
-            <version>3.0.5</version>
-            <type>pom</type>
-        </dependency>
+	<dependency>
+		<groupId>com.github.Nagami-Yukki</groupId>
+		<artifactId>JDA-Utilities</artifactId>
+		<version>1.0</version>
+	</dependency>
 
         <!-- Music Dependencies -->
         <dependency>
             <groupId>dev.arbjerg</groupId>
             <artifactId>lavaplayer</artifactId>
-            <version>2.2.1</version>
+            <version>2.2.2</version>
+        </dependency>
+        <dependency>
+            <groupId>dev.arbjerg</groupId>
+            <artifactId>lavaplayer-ext-youtube-rotator</artifactId>
+            <version>2.2.2</version>
         </dependency>
         <dependency>
             <groupId>dev.lavalink.youtube</groupId>
             <artifactId>common</artifactId>
-            <version>1.5.1</version>
+            <version>1.11.3</version>
         </dependency>
 	<dependency>
 	    <groupId>com.github.jagrosh</groupId>
@@ -89,6 +93,33 @@
             <artifactId>jsoup</artifactId>
             <version>1.15.3</version>
         </dependency>
+        <dependency>
+            <groupId>org.seleniumhq.selenium</groupId>
+            <artifactId>selenium-java</artifactId>
+            <version>4.27.0</version>
+            <!-- https://github.com/SeleniumHQ/selenium/issues/13791 -->
+            <exclusions>
+                <exclusion>
+                    <groupId>org.seleniumhq.selenium</groupId>
+                    <artifactId>selenium-devtools-v85</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.seleniumhq.selenium</groupId>
+                    <artifactId>selenium-devtools-v129</artifactId>
+                </exclusion>
+                <exclusion>
+                    <groupId>org.seleniumhq.selenium</groupId>
+                    <artifactId>selenium-devtools-v130</artifactId>
+                </exclusion>
+            </exclusions>
+        </dependency>
+        <dependency>
+            <groupId>io.github.bonigarcia</groupId>
+            <artifactId>webdrivermanager</artifactId>
+            <version>5.9.2</version>
+        </dependency>
+
+
 
         <!-- Testing Dependencies -->
         <dependency>

src/main/java/com/jagrosh/jmusicbot/Bot.java

@@ -26,6 +26,7 @@ import com.jagrosh.jmusicbot.gui.GUI;
 import com.jagrosh.jmusicbot.playlist.PlaylistLoader;
 import com.jagrosh.jmusicbot.settings.SettingsManager;
 import java.util.Objects;
+import com.jagrosh.jmusicbot.utils.YoutubeOauth2TokenHandler;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.entities.Activity;
 import net.dv8tion.jda.api.entities.Guild;
@@ -44,6 +45,7 @@ public class Bot
     private final PlaylistLoader playlists;
     private final NowplayingHandler nowplaying;
     private final AloneInVoiceHandler aloneInVoiceHandler;
+    private final YoutubeOauth2TokenHandler youTubeOauth2TokenHandler;
     
     private boolean shuttingDown = false;
     private JDA jda;
@@ -56,7 +58,9 @@ public class Bot
         this.settings = settings;
         this.playlists = new PlaylistLoader(config);
         this.threadpool = Executors.newSingleThreadScheduledExecutor();
-        this.players = new PlayerManager(this);
+        this.youTubeOauth2TokenHandler = new YoutubeOauth2TokenHandler();
+        this.youTubeOauth2TokenHandler.init();
+        this.players = new PlayerManager(this, config);
         this.players.init();
         this.nowplaying = new NowplayingHandler(this);
         this.nowplaying.init();
@@ -103,6 +107,11 @@ public class Bot
     {
         return aloneInVoiceHandler;
     }
+
+    public YoutubeOauth2TokenHandler getYouTubeOauth2Handler()
+    {
+        return youTubeOauth2TokenHandler;
+    }
     
     public JDA getJDA()
     {

src/main/java/com/jagrosh/jmusicbot/BotConfig.java

@@ -18,11 +18,16 @@ package com.jagrosh.jmusicbot;
 import com.jagrosh.jmusicbot.entities.Prompt;
 import com.jagrosh.jmusicbot.utils.OtherUtil;
 import com.jagrosh.jmusicbot.utils.TimeUtil;
+import com.jagrosh.jmusicbot.utils.YouTubeUtil;
 import com.sedmelluq.discord.lavaplayer.track.AudioTrack;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.IpBlock;
 import com.typesafe.config.*;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Collectors;
+
 import net.dv8tion.jda.api.OnlineStatus;
 import net.dv8tion.jda.api.entities.Activity;
 
@@ -41,8 +46,10 @@ public class BotConfig
     private Path path = null;
     private String token, prefix, altprefix, helpWord, playlistsFolder, logLevel,
             successEmoji, warningEmoji, errorEmoji, loadingEmoji, searchingEmoji,
-            evalEngine;
-    private boolean stayInChannel, songInGame, npImages, updatealerts, useEval, dbots;
+            chromePath, chromeDriverPath, evalEngine;
+    private YouTubeUtil.RoutingPlanner ytRoutingPlanner;
+    private List<IpBlock> ytIpBlocks;
+    private boolean youtubeOauth2, stayInChannel, songInGame, npImages, updatealerts, chromeHeadless, useEval, dbots;
     private long owner, maxSeconds, aloneTimeUntilStop;
     private int maxYTPlaylistPages;
     private double skipratio;
@@ -84,6 +91,7 @@ public class BotConfig
             searchingEmoji = config.getString("searching");
             game = OtherUtil.parseGame(config.getString("game"));
             status = OtherUtil.parseStatus(config.getString("status"));
+            youtubeOauth2 = config.getBoolean("youtubeoauth2");
             stayInChannel = config.getBoolean("stayinchannel");
             songInGame = config.getBoolean("songinstatus");
             npImages = config.getBoolean("npimages");
@@ -96,6 +104,11 @@ public class BotConfig
             aloneTimeUntilStop = config.getLong("alonetimeuntilstop");
             playlistsFolder = config.getString("playlistsfolder");
             aliases = config.getConfig("aliases");
+            chromePath = config.getString("chromepath");
+            chromeDriverPath = config.getString("chromedriverpath");
+            chromeHeadless = config.getBoolean("chromeheadless");
+            ytRoutingPlanner = config.getEnum(YouTubeUtil.RoutingPlanner.class, "ytroutingplanner");
+            ytIpBlocks = config.getStringList("ytipblocks").stream().map(YouTubeUtil::parseIpBlock).collect(Collectors.toList());
             transforms = config.getConfig("transforms");
             skipratio = config.getDouble("skipratio");
             dbots = owner == 113156185389092864L;
@@ -293,6 +306,11 @@ public class BotConfig
         return helpWord;
     }
     
+    public boolean useYoutubeOauth2()
+    {
+        return youtubeOauth2;
+    }
+    
     public boolean getStay()
     {
         return stayInChannel;
@@ -323,6 +341,31 @@ public class BotConfig
         return logLevel;
     }
 
+    public String getChromePath()
+    {
+        return chromePath.equals("AUTO") ? null : chromePath;
+    }
+
+    public String getChromeDriverPath()
+    {
+        return chromeDriverPath.equals("AUTO") ? null : chromeDriverPath;
+    }
+    
+    public boolean getChromeHeadless()
+    {
+        return chromeHeadless;
+    }
+
+    public YouTubeUtil.RoutingPlanner getYTRoutingPlanner()
+    {
+        return ytRoutingPlanner;
+    }
+    
+    public List<IpBlock> getYTIpBlocks()
+    {
+        return ytIpBlocks;
+    }
+    
     public boolean useEval()
     {
         return useEval;

src/main/java/com/jagrosh/jmusicbot/JMusicBot.java

@@ -40,6 +40,8 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import ch.qos.logback.classic.Level;
 
+import static com.jagrosh.jmusicbot.utils.YouTubeUtil.GetPoTokenAndVisitorData;
+
 /**
  *
  * @author John Grosh (jagrosh)
@@ -166,6 +168,8 @@ public class JMusicBot
                     + "attempting to connect, please make sure you're connected to the internet");
             System.exit(1);
         }
+
+        GetPoTokenAndVisitorData(config.getChromePath(), config.getChromeDriverPath(), config.getChromeHeadless());
     }
     
     private static CommandClient createCommandClient(BotConfig config, SettingsManager settings, Bot bot)

src/main/java/com/jagrosh/jmusicbot/Listener.java

@@ -17,8 +17,10 @@ package com.jagrosh.jmusicbot;
 
 import com.jagrosh.jmusicbot.utils.OtherUtil;
 import java.util.concurrent.TimeUnit;
+import com.jagrosh.jmusicbot.utils.YoutubeOauth2TokenHandler;
 import net.dv8tion.jda.api.JDA;
 import net.dv8tion.jda.api.entities.Guild;
+import net.dv8tion.jda.api.entities.PrivateChannel;
 import net.dv8tion.jda.api.entities.User;
 import net.dv8tion.jda.api.entities.VoiceChannel;
 import net.dv8tion.jda.api.events.ReadyEvent;
@@ -85,6 +87,22 @@ public class Listener extends ListenerAdapter
                 catch(Exception ignored) {} // ignored
             }, 0, 24, TimeUnit.HOURS);
         }
+        if (bot.getConfig().useYoutubeOauth2())
+        {
+            YoutubeOauth2TokenHandler.Data data = bot.getYouTubeOauth2Handler().getData();
+            if (data != null)
+            {
+                PrivateChannel channel = bot.getJDA().openPrivateChannelById(bot.getConfig().getOwnerId()).complete();
+                channel
+                   .sendMessage(
+                       "# DO NOT AUTHORISE THIS WITH YOUR MAIN GOOGLE ACCOUNT!!!\n"
+                       + "## Create or use an alternative/burner Google account!\n"
+                       + "To give JMusicBot access to your Google account, go to "
+                       + data.getAuthorisationUrl()
+                       + " and enter the code **" + data.getCode() + "**")
+                   .queue();
+            }
+        }
     }
     
     @Override

src/main/java/com/jagrosh/jmusicbot/audio/AudioHandler.java

@@ -41,6 +41,7 @@ import net.dv8tion.jda.api.audio.AudioSendHandler;
 import net.dv8tion.jda.api.entities.Guild;
 import net.dv8tion.jda.api.entities.Message;
 import net.dv8tion.jda.api.entities.User;
+import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 /**
@@ -53,6 +54,7 @@ public class AudioHandler extends AudioEventAdapter implements AudioSendHandler
     public final static String PAUSE_EMOJI = "\u23F8"; // ⏸
     public final static String STOP_EMOJI  = "\u23F9"; // ⏹
 
+    private final static Logger LOGGER = LoggerFactory.getLogger(AudioHandler.class);
 
     private final List<AudioTrack> defaultQueue = new LinkedList<>();
     private final Set<String> votes = new HashSet<>();
@@ -202,8 +204,20 @@ public class AudioHandler extends AudioEventAdapter implements AudioSendHandler
     }
 
     @Override
-    public void onTrackException(AudioPlayer player, AudioTrack track, FriendlyException exception) {
-        LoggerFactory.getLogger("AudioHandler").error("Track " + track.getIdentifier() + " has failed to play", exception);
+    public void onTrackException(AudioPlayer player, AudioTrack track, FriendlyException exception)
+    {
+        if (
+            exception.getMessage().equals("Sign in to confirm you're not a bot")
+            || exception.getMessage().equals("Please sign in")
+        )
+            LOGGER.error(
+                "Track {} has failed to play: {}"
+                + "You will need to sign in to Google to play YouTube tracks. More info: https://jmusicbot.com/youtube-oauth2",
+                track.getIdentifier(),
+                exception.getMessage()
+            );
+        else
+            LOGGER.error("Track {} has failed to play", track.getIdentifier(), exception);
     }
 
     @Override

src/main/java/com/jagrosh/jmusicbot/audio/PlayerManager.java

@@ -17,6 +17,9 @@ package com.jagrosh.jmusicbot.audio;
 
 import com.dunctebot.sourcemanagers.DuncteBotSources;
 import com.jagrosh.jmusicbot.Bot;
+import com.jagrosh.jmusicbot.BotConfig;
+import com.jagrosh.jmusicbot.utils.OtherUtil;
+import com.jagrosh.jmusicbot.utils.YouTubeUtil;
 import com.sedmelluq.discord.lavaplayer.container.MediaContainerRegistry;
 import com.sedmelluq.discord.lavaplayer.player.AudioPlayer;
 import com.sedmelluq.discord.lavaplayer.player.DefaultAudioPlayerManager;
@@ -29,8 +32,21 @@ import com.sedmelluq.discord.lavaplayer.source.nico.NicoAudioSourceManager;
 import com.sedmelluq.discord.lavaplayer.source.soundcloud.SoundCloudAudioSourceManager;
 import com.sedmelluq.discord.lavaplayer.source.twitch.TwitchStreamAudioSourceManager;
 import com.sedmelluq.discord.lavaplayer.source.vimeo.VimeoAudioSourceManager;
+import com.sedmelluq.lava.extensions.youtuberotator.YoutubeIpRotatorSetup;
+import com.sedmelluq.lava.extensions.youtuberotator.planner.AbstractRoutePlanner;
+import com.sedmelluq.lava.extensions.youtuberotator.planner.BalancingIpRoutePlanner;
+import com.sedmelluq.lava.extensions.youtuberotator.planner.NanoIpRoutePlanner;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.IpBlock;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.Ipv4Block;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.Ipv6Block;
 import dev.lavalink.youtube.YoutubeAudioSourceManager;
+import dev.lavalink.youtube.clients.Web;
 import net.dv8tion.jda.api.entities.Guild;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
 
 /**
  *
@@ -38,18 +54,31 @@ import net.dv8tion.jda.api.entities.Guild;
  */
 public class PlayerManager extends DefaultAudioPlayerManager
 {
+    private final static Logger LOGGER = LoggerFactory.getLogger(PlayerManager.class);
     private final Bot bot;
-    
-    public PlayerManager(Bot bot)
+    private final BotConfig config;
+
+    public PlayerManager(Bot bot, BotConfig config)
     {
         this.bot = bot;
+        this.config = config;
     }
     
     public void init()
     {
         TransformativeAudioSourceManager.createTransforms(bot.getConfig().getTransforms()).forEach(t -> registerSourceManager(t));
-
+        
         YoutubeAudioSourceManager yt = new YoutubeAudioSourceManager(true);
+        if (config.getYTRoutingPlanner() != YouTubeUtil.RoutingPlanner.NONE)
+        {
+            AbstractRoutePlanner routePlanner = YouTubeUtil.createRouterPlanner(config.getYTRoutingPlanner(), config.getYTIpBlocks());
+            YoutubeIpRotatorSetup rotator = new YoutubeIpRotatorSetup(routePlanner);
+            
+            rotator.forConfiguration(yt.getHttpInterfaceManager(), false)
+                    .withMainDelegateFilter(yt.getContextFilter())
+                    .setup();
+        }
+
         yt.setPlaylistPageCount(bot.getConfig().getMaxYTPlaylistPages());
         registerSourceManager(yt);
 
@@ -66,7 +95,42 @@ public class PlayerManager extends DefaultAudioPlayerManager
 
         DuncteBotSources.registerAll(this, "en-US");
     }
-    
+
+    private YoutubeAudioSourceManager setupYoutubeAudioSourceManager()
+    {
+        YoutubeAudioSourceManager yt = new YoutubeAudioSourceManager(true);
+        yt.setPlaylistPageCount(bot.getConfig().getMaxYTPlaylistPages());
+
+        // OAuth2 setup
+        if (bot.getConfig().useYoutubeOauth2())
+        {
+            String token = null;
+            try
+            {
+                token = Files.readString(OtherUtil.getPath("youtubetoken.txt"));
+            }
+            catch (NoSuchFileException e)
+            {
+                /* ignored */
+            }
+            catch (IOException e)
+            {
+                LOGGER.warn("Failed to read YouTube OAuth2 token file: {}", e.getMessage());
+                return yt;
+            }
+            LOGGER.debug("Read YouTube OAuth2 refresh token from youtubetoken.txt");
+            try
+            {
+                yt.useOauth2(token, false);
+            }
+            catch (Exception e)
+            {
+                LOGGER.warn("Failed to authorise with YouTube. If this issue persists, delete the youtubetoken.txt file to reauthorise.", e);
+            }
+        }
+        return yt;
+    }
+
     public Bot getBot()
     {
         return bot;

src/main/java/com/jagrosh/jmusicbot/utils/FormatUtil.java

@@ -94,7 +94,7 @@ public class FormatUtil {
     
     public static String listOfRoles(List<Role> list, String query)
     {
-        String out = " Multiple text channels found matching \""+query+"\":";
+        String out = " Multiple roles found matching \""+query+"\":";
         for(int i=0; i<6 && i<list.size(); i++)
             out+="\n - "+list.get(i).getName()+" (ID:"+list.get(i).getId()+")";
         if(list.size()>6)

src/main/java/com/jagrosh/jmusicbot/utils/OtherUtil.java

@@ -43,7 +43,11 @@ public class OtherUtil
     public final static String NEW_VERSION_AVAILABLE = "There is a new version of JMusicBot available!\n"
                     + "Current version: %s\n"
                     + "New Version: %s\n\n"
-                    + "Please visit https://github.com/jagrosh/MusicBot/releases/latest to get the latest release.";
+                    + "Please visit https://github.com/chrisb09/MusicBot/releases to get the latest release."
+                    + "If you are using docker (or docker-compose), please pull the new image with:"
+                    + "Docker: docker pull chrisb09/jmusicbot"
+                    + "Docker-compose: docker-compose pull"+
+                    " and don't forget to restart the container.";
     private final static String WINDOWS_INVALID_PATH = "c:\\windows\\system32\\";
     
     /**
@@ -188,7 +192,7 @@ public class OtherUtil
         try
         {
             Response response = new OkHttpClient.Builder().build()
-                    .newCall(new Request.Builder().get().url("https://api.github.com/repos/jagrosh/MusicBot/releases/latest").build())
+                    .newCall(new Request.Builder().get().url("https://api.github.com/repos/chrisb09/MusicBot/releases/latest").build())
                     .execute();
             ResponseBody body = response.body();
             if(body != null)

src/main/java/com/jagrosh/jmusicbot/utils/YouTubeUtil.java

@@ -0,0 +1,193 @@
+package com.jagrosh.jmusicbot.utils;
+
+import com.sedmelluq.lava.extensions.youtuberotator.planner.*;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.IpBlock;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.Ipv4Block;
+import com.sedmelluq.lava.extensions.youtuberotator.tools.ip.Ipv6Block;
+import dev.lavalink.youtube.clients.Web;
+import org.json.JSONObject;
+import org.openqa.selenium.By;
+import org.openqa.selenium.WebDriver;
+import org.openqa.selenium.WebElement;
+import org.openqa.selenium.chrome.ChromeDriver;
+import org.openqa.selenium.chrome.ChromeDriverService;
+import org.openqa.selenium.chrome.ChromeOptions;
+import org.openqa.selenium.chromium.ChromiumDriverLogLevel;
+import org.openqa.selenium.devtools.NetworkInterceptor;
+import org.openqa.selenium.os.ExecutableFinder;
+import org.openqa.selenium.remote.http.Contents;
+import org.openqa.selenium.remote.http.Filter;
+import org.openqa.selenium.remote.http.HttpMethod;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import io.github.bonigarcia.wdm.WebDriverManager;
+
+public class YouTubeUtil {
+    private final static Logger LOGGER = LoggerFactory.getLogger(YouTubeUtil.class);
+    
+    public enum RoutingPlanner {
+        NONE,
+        ROTATE_ON_BAN,
+        LOAD_BALANCE,
+        NANO_SWITCH,
+        ROTATING_NANO_SWITCH
+    }
+    
+    public static IpBlock parseIpBlock(String cidr) {
+        if (Ipv6Block.isIpv6CidrBlock(cidr))
+            return new Ipv6Block(cidr);
+
+        if (Ipv4Block.isIpv4CidrBlock(cidr))
+            return new Ipv4Block(cidr);
+        
+        throw new IllegalArgumentException("Could not parse CIDR " + cidr);
+    }
+    
+    public static AbstractRoutePlanner createRouterPlanner(RoutingPlanner routingPlanner, List<IpBlock> ipBlocks) {
+        
+        switch (routingPlanner) {
+            case NONE:
+                return null;
+            case ROTATE_ON_BAN:
+                return new RotatingIpRoutePlanner(ipBlocks);
+            case LOAD_BALANCE:
+                return new BalancingIpRoutePlanner(ipBlocks);
+            case NANO_SWITCH:
+                return new NanoIpRoutePlanner(ipBlocks, true);
+            case ROTATING_NANO_SWITCH:
+                return new RotatingNanoIpRoutePlanner(ipBlocks);
+            default:
+                throw new IllegalArgumentException("Unknown RoutingPlanner value provided");
+        }
+    }
+
+    public static void GetPoTokenAndVisitorData(String userChromePath, String userChromeDriverPath, boolean headless)
+    {
+        //
+        // 1. Find a Chrome install & launch the WebDriver
+        //
+        WebDriverManager wdm = WebDriverManager.chromedriver();
+        if (userChromePath != null) {
+            wdm.browserVersionDetectionCommand(userChromePath + " --version");
+        }
+        else if (wdm.getBrowserPath().isEmpty())
+        {
+            // try finding a Chromium browser instead (Linux users usually install Chromium instead of Google Chrome)
+            wdm = WebDriverManager.chromiumdriver();
+            if (wdm.getBrowserPath().isEmpty()) {
+                LOGGER.error("Could not obtain a PO token for YouTube playback, because no Chrome browser could be found. Please install Google Chrome or Chromium!");
+                return;
+            }
+        }
+        if (userChromeDriverPath == null)
+            // Automatically download & set up ChromeDriver for the Chrome/Chromium version that the user has installed
+            wdm.setup();
+        else {
+            // Find & use the ChromeDriver executable the user provided
+            String path = new ExecutableFinder().find(userChromeDriverPath);
+            if (path == null) {
+                LOGGER.error("Could not obtain a PO token for YouTube playback, because the specified ChromeDriver could not be found. " +
+                        "Please check your config's value of the chromedriverpath, or set it to \"AUTO\" to have JMusicBot automatically download ChromeDriver");
+                return;
+            }
+            LOGGER.info("Using ChromeDriver at {}", path);
+            System.setProperty("webdriver.chrome.driver", path);
+        }
+
+        ChromeOptions chromeOptions = new ChromeOptions();
+
+        chromeOptions.setBinary(userChromePath != null ? userChromePath : wdm.getBrowserPath().get().toString());
+
+        if (!headless)
+            chromeOptions.addArguments("--auto-open-devtools-for-tabs");
+        else
+            chromeOptions.addArguments("--headless=new");
+
+        ChromeDriverService.Builder chromeDriverBuilder = new ChromeDriverService.Builder();
+        if (LOGGER.isDebugEnabled())
+            chromeDriverBuilder.withLogLevel(ChromiumDriverLogLevel.DEBUG);
+
+        WebDriver driver = new ChromeDriver(chromeDriverBuilder.build(), chromeOptions);
+
+        //
+        // 2. Setup a network interceptor to intercept the player API request & obtain po token and visitor data
+        //
+
+        // as the network interceptor below runs on a different thread, we'll have it notify us on this/current thread
+        // whether retrieving the data failed (completes with the Exception) or succeeded (completes with null)
+        CompletableFuture<Exception> interceptorFuture = new CompletableFuture<>();
+
+        NetworkInterceptor interceptor = new NetworkInterceptor(driver,
+                (Filter) next -> req -> {
+            
+            if (req.getMethod() != HttpMethod.POST || !req.getUri().contains("/youtubei/v1/player"))
+                return next.execute(req);
+    
+            try {
+                String rawBody = Contents.string(req);
+                JSONObject body = new JSONObject(rawBody);
+
+                String visitorData = body
+                        .getJSONObject("context")
+                        .getJSONObject("client")
+                        .getString("visitorData");
+
+                String poToken = body
+                        .getJSONObject("serviceIntegrityDimensions")
+                        .getString("poToken");
+
+
+                LOGGER.info("Successfully retrieved PO token & visitor data for YouTube playback.");
+                LOGGER.debug("PO token: {}", poToken);
+                LOGGER.debug("Visitor Data: {}", visitorData);
+
+                if (poToken.length() < 160)
+                    LOGGER.warn("There is a high chance that the retrieved PO token will not work. Try on a different network.");
+
+                Web.setPoTokenAndVisitorData(poToken, visitorData);
+
+                interceptorFuture.complete(null);
+            } catch (Exception e) {
+                interceptorFuture.complete(e);
+            }
+
+            return next.execute(req);
+        });
+
+        //
+        // 3. Navigate to YouTube & start the player
+        //
+        try {
+            driver.get("https://www.youtube.com/embed/aqz-KE-bpKQ");
+            driver.manage().timeouts().implicitlyWait(Duration.ofSeconds(15));
+            WebElement moviePlayer = driver.findElement(By.cssSelector("#movie_player"));
+            moviePlayer.click();
+
+            try {
+                // Wait for the network interceptor to tell us if it got the data
+                Exception result = interceptorFuture.get(20, TimeUnit.SECONDS);
+                if (result != null)
+                    throw new Exception("Failed to read YouTube player request body", result);
+            } catch (TimeoutException e) {
+                throw new Exception("Timed out waiting for YouTube player request");
+            }
+
+
+        } catch (Exception e) {
+            LOGGER.error("Failed to obtain PO token for YouTube playback: {}", e.getMessage());
+            LOGGER.debug("Exception:", e);
+        } finally {
+            interceptor.close();
+            // Only quit the browser when not in headless mode. Helps with troubleshooting.
+            if (headless)
+                driver.quit();
+        }
+    }
+}

src/main/java/com/jagrosh/jmusicbot/utils/YoutubeOauth2TokenHandler.java

@@ -0,0 +1,91 @@
+package com.jagrosh.jmusicbot.utils;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.turbo.TurboFilter;
+import ch.qos.logback.core.spi.FilterReply;
+import org.slf4j.LoggerFactory;
+import org.slf4j.Marker;
+
+import java.nio.file.Files;
+
+/**
+ * A logback turbo filter, used retrieve the YouTube OAuth2 refresh token that gets logged once authorized with YouTube.
+ *
+ * @author Michaili K. <git@michaili.dev>
+ */
+public class YoutubeOauth2TokenHandler extends TurboFilter {
+    public final static org.slf4j.Logger LOGGER = LoggerFactory.getLogger(YoutubeOauth2TokenHandler.class);
+    private Data data;
+
+
+    public void init()
+    {
+        LoggerContext context = (LoggerContext) LoggerFactory.getILoggerFactory();
+        context.addTurboFilter(this);
+    }
+
+    public Data getData()
+    {
+        return data;
+    }
+
+    @Override
+    public FilterReply decide(Marker marker, Logger logger, Level level, String format, Object[] params, Throwable t)
+    {
+        if (!logger.getName().equals("dev.lavalink.youtube.http.YoutubeOauth2Handler"))
+            return FilterReply.NEUTRAL;
+
+        if (format.equals("OAUTH INTEGRATION: To give youtube-source access to your account, go to {} and enter code {}"))
+        {
+            this.data = new Data((String) params[0], (String) params[1]);
+            return FilterReply.NEUTRAL;
+        }
+        if (format.equals("OAUTH INTEGRATION: Token retrieved successfully. Store your refresh token as this can be reused. ({})"))
+        {
+            LOGGER.info(
+                "Authorization successful & retrieved token! Storing the token in {}",
+                OtherUtil.getPath("youtubetoken.txt").toAbsolutePath()
+            );
+
+            try
+            {
+                Files.write(OtherUtil.getPath("youtubetoken.txt"), params[0].toString().getBytes());
+            }
+            catch (Exception e)
+            {
+                LOGGER.error(
+                    "Failed to write the YouTube OAuth2 refresh token to storage! You will need to authorize again on the next reboot",
+                    e
+                );
+            }
+            return FilterReply.DENY;
+        }
+
+        return FilterReply.NEUTRAL;
+    }
+
+    public static class Data
+    {
+        private final String authorisationUrl;
+        private final String code;
+
+        private Data(String authorisationUrl, String code)
+        {
+            this.authorisationUrl = authorisationUrl;
+            this.code = code;
+        }
+
+        public String getCode()
+        {
+            return code;
+        }
+
+        public String getAuthorisationUrl()
+        {
+            return authorisationUrl;
+        }
+    }
+
+}

src/main/resources/reference.conf

@@ -48,6 +48,14 @@ game = "DEFAULT"
 status = ONLINE
 
 
+// If you set this to true, the bot will use a Google account to play YouTube tracks.
+// This is only needed if you are experiencing issues with YouTube playback.
+// Once enabled, instructions for login will be written to the console and DMs.
+// DO NOT use your main Google account! Use an alternative account.
+
+youtubeoauth2=false
+
+
 // If you set this to true, the bot will list the title of the song it is currently playing in its
 // "Playing" status. Note that this will ONLY work if the bot is playing music on ONE guild;
 // if the bot is playing on multiple guilds, this will not work.
@@ -200,6 +208,49 @@ aliases {
 loglevel = info
 
 
+// This sets the executable path of where a Chrome or Chromium installation is located JMusicBot can use.
+// JMusicBot may launch a web browser to get around anti-bot checks.
+// Set this to "AUTO" to make JMusicBot attempt to find a Chrome/Chromium installation itself.
+
+chromepath = "AUTO"
+
+
+// This sets the executable path of where a ChromeDriver installation is located JMusicBot can use.
+// Set this to "AUTO" to make JMusicBot automatically download the ChromeDriver version
+// which matches the installed Chrome version.
+
+chromedriverpath = "AUTO"
+
+
+// This sets whether JMusicBot should launch Chrome/Chromium instances without a GUI.
+// It is recommended to leave this set to true.
+// If set to false, JMusicBot will not close the browser automatically (even when finished)
+// and will automatically open DevTools for troubleshooting purposes.
+
+chromeheadless = true
+
+
+// This configures the routing planner to use for IP rotation on YouTube.
+// When set, you need to also set an IP block below.
+// The following routing strategies are available:
+// NONE = Disable
+// ROTATE_ON_BAN = Switch IP when currently used address gets banned.
+// LOAD_BALANCE = Selects random IP for each track playback.
+// NANO_SWITCH = Selects IPv6 address based on current nanosecond. Recommended for one /64 IPv6 blocks.
+// ROTATING_NANO_SWITCH = Same as above, but uses the next /64 IPv6 block in the list in case of a ban.
+
+ytroutingplanner = NONE
+
+
+// The IPv4 and IPv6 blocks to use when using the above routing planner.
+// This does nothing when ytroutingplanner is set to none.
+// The list accepts a list of IPv4 or IPv6 CIDR blocks (not a mix of them however)
+// IPv4 example: [ "192.0.2.183", "198.51.100.153/29" ]
+// IPv6 example: [ "2a02:1234:5678:9abc::/64" ]
+
+ytipblocks = [  ]
+
+
 // Transforms are used to modify specific play inputs and convert them to different kinds of inputs
 // These are quite complicated to use, and have limited use-cases, but in theory allow for rough
 // whitelists or blacklists, roundabout loading from some sources, and customization of how things are