Exclude CODEOWNERS from language statistics

Untested, but should fix #321 since this is the only component of the plugin that explicitly demands the server thread

.gitattributes

@@ -0,0 +1 @@
+.gitea/CODEOWNERS linguist-detectable=false

.gitea/CODEOWNERS

@@ -0,0 +1,3 @@
+# Pull requests request review from the eligible staff team(s).
+# One approval from either an Admin or Developer satisfies branch protection.
+*   @trueog/Admins @trueog/Developers

.gitignore

@@ -7,17 +7,32 @@
 # netbeans
 /nbproject
 
+# eclipse
+api/.classpath
+api/.project
+api/.settings/
+bukkit/.classpath
+bukkit/.project
+bukkit/.settings/
+common/.classpath
+common/.project
+common/.settings/
+universal/.classpath
+universal/.project
+universal/.settings/
+
 # we use maven!
 /build.xml
 
 # maven
-/target
+/*/target/
+dependency-reduced-pom.xml
 
 # vim
 .*.sw[a-p]
 
 # various other potential build files
-/build
+build/
 /bin
 /dist
 /manifest.mf
@@ -42,3 +57,10 @@ debug.log
 # Doxygen
 /docs/html
 debug.txt
+
+# gradle stuff
+.gradle/
+.gradletasknamecache
+
+# fabric
+fabric/run/

.travis.yml

@@ -1,11 +0,0 @@
-sudo: false
-language: java
-jdk:
-- oraclejdk8
-deploy:
-  provider: releases
-  api_key:
-    secure: j8y4qeDOXAYjmf6WU6EbpUA6AKTz26yJ4zNb6oAuB4h9Y3PpBRjFjCIBL6jJQnMxZMLjdgk72/3uqS7+//jJ8/iiY/OJhO2L+2us8TJDcQhH5EI1USe/lcZKf60iJjmd9Q9pjh1eHNYhxr6kyNLnpa6fw5b/hIBT6CvNZAJV1qbhRpHwtzbgdlMFaHGnpX192vJNw7E3uuJuSwue5XNK2ybDp81oTrM0Q16JCq/UsQhGq4Ba3JffOhdBhpfg4EI2jJfe3vN8CFqojCYKNSp7eL6DPFPaV4x8Ly8cRIOZ5Zb60m5SyWAcagPKJuUq3ZOTHfeVTjkI9ymZMHe1pla2Mq6eitIBwZIGnonjyMxcTdkR9EJgq9jo+1PzdStR/NlGLakBiwPzk8Ov0DZ+iOwpYUkISUkMU0UgKWwoFoRu18CHtp+ALEsoYZhBQGlcShq+4EGv9VMNBYk9vN3KXNRMVGKqXd6O3T6shvSQgoUn/3mvksOTAuhS5J4U3woHecDrXwl/RfP2aqiHhX/S7p7yY4hVcHu8kiSYpNQMbay+rNd6HxFcRe/U9HOUt6kW8/yo1ROyCxs3ze+N6LtGDHspgzkFaay6I6wMHYNDnzzRP4MC3Zc73zxViXol6dGBk4Tawsm16VaI6b1uyWLBGKvuU23azkmMTHUmGFXl2/BTaYw=
-  file: universal/target/nuvotifier-universal-2.3.2.2.jar
-  on:
-    tags: true

README.markdown

@@ -1,112 +0,0 @@
-# NuVotifier
-
-NuVotifier is a Bukkit plugin whose purpose is to be notified (aka *votified*) when a vote is made on a Minecraft server top list for the server.  NuVotifier creates a *lightweight* server that waits for connections by Minecraft server lists and uses a simple protocol to get the required information.  NuVotifier is *secure*, and makes sure that all vote notifications are delivered by authentic top lists.
-
-[![Build Status](https://travis-ci.org/NuVotifier/NuVotifier.svg?branch=master)](https://travis-ci.org/NuVotifier/NuVotifier)
-
-## Why fork Votifier?
-
-Votifier has lagged in activity, has severe security flaws in its protocol, and is vulnerable to denial of service attacks.
-
-### Is NuVotifier a drop-in replacement for Votifier?
-
-Yes. NuVotifier is compatible with Votifier server lists and Votifier listeners, with some differences:
-
-* The `Vote` object's setters are deprecated.
-* Support for standalone vote listeners (`.class` files) has been removed, as handling `VotifierEvent` is more flexible.
-
-### Why a new protocol?
-
-The old Votifier protocol has three major flaws, which we feel are corrected in the new protocol.
-
-* The data is encrypted (with RSA) but not hashed to verify its integrity. The new protocol utilizes HMAC with SHA256 (but no encryption, given that the data sent is eventually revealed in some form or another).
-* The canonical Votifier protocol is vulnerable to replay attacks.
-* The canonical Votifier is one key for all clients, which is weak. While NuVotifier still supports a default key (for the less paranoid), this ability can be disabled and force per-server keys.
-
-## Configuring NuVotifier
-
-NuVotifier configures itself the first time it is run. If you have an existing Votifier configuration, NuVotifier will copy it over and use it.
-
-If you want to customize NuVotifier, simply the edit `./plugins/(Nu)Votifier/config.yml` file.
-
-An in-depth configuration guide is located in the [usage](https://github.com/NuVotifier/NuVotifier/blob/master/usage.md) document.
-
-### Tokens
-
-In `config.yml`, you will notice a `tokens` section. NuVotifier has a new protocol version that requires tokens. The `tokens` section can be used to easily grant or revoke access to a server list based on the keys it uses.
-
-### RSA Keys
-
-RSA keys for use with the old Votifier protocol are available under the `plugins/(Nu)Votifier/rsa` directory.
-
-### Vote Forwarding
-
-Starting from NuVotifier 2.2, there is a feature to forward votes from NuVotifier running on BungeeCord to your Bukkit servers without complicated setup.
-
-You must enable the feature on both your Bukkit and BungeeCord servers. This feature is still in beta but is stable.
-
-## Building NuVotifier
-
-NuVotifier can be built by running `mvn clean package` from within the root directory of NuVotifier. A universal Bukkit/Spigot & BungeeCord plugin will be built to `universal/target/nuvotifier-universal-{version}.jar`
-
-## Protocol Documentation
-
-This documentation is for server lists that wish to add NuVotifier support.
-
-There are two versions of the NuVotifier protocol.
-
-### Handshake
-
-A connection is made to the NuVotifier server by the server list, and immediately NuVotifier will send its version in the following packet:
-
-	"VOTIFIER <version> <challenge>"
-
-The challenge will not be present in version 1.x servers.
-
-### Protocol v2
-
-NuVotifier expects a message composed of `0x733A` (16-bit big-endian integer) and the length of the following JSON message (as a 16-bit big-endian integer) sent plus the message.
-
-The message is JSON-encoded containing the following data:
-
-* `payload` contains the fully encoded vote. It is a JSON message containing the `serviceName` (string), `username` (string), `address` (string, but must be a valid IPv4 or IPv6 address), `timestamp` (a long with the time this vote was taken in _milliseconds_), and `challenge` (from the handshake). It is optional, but recommended to supply a `uuid` field with the player's UUID (with dashes, e.g. `652a2bc4-e8cd-405d-b7b6-98156ee2dc09`).
-* `signature` is a HMAC-SHA256 digest of the payload with a owner-provided key.
-
-A response is given after the vote has been received and parsed, but not yet processed.
-
-For your convenience, the NuVotifier team has provided client libraries in [JavaScript](https://github.com/NuVotifier/votifier2-js) and [PHP](https://github.com/NuVotifier/votifier2-php). If you are stuck, these libraries may help you.
-
-### Protocol v1 (deprecated)
-
-For better compatibility, NuVotifier supports the old Votifier protocol as well.
-
-NuVotifier expects a 256 byte RSA encrypted block (the public key should be obtained by the NuVotifier user), with the following format:
-
-<table>
-  <tr>
-	<th>Type</th>
-	<th>Value</th>
-  </tr>
-  <tr>
-	<td>string</td>
-	<td>VOTE</td>
-  </tr>
-  <tr>
-	<td>string</td>
-	<td>serviceName</td>
-  </tr>
-  <tr>
-	<td>string</td>
-	<td>username</td>
-  </tr>
-  <tr>
-	<td>string</td>
-	<td>address</td>
-  </tr>
-  <tr>
-	<td>string</td>
-	<td>timeStamp</td>
-  </tr>
-</table>
-
-The first string of value "VOTE" is an opcode check to ensure that RSA was encoded and decoded properly, if this value is wrong then NuVotifier assumes that there was a problem with encryption and drops the connection. `serviceName` is the name of the top list service, `username` is the username (entered by the voter) of the person who voted, `address` is the IP address of the voter, and `timeStamp` is the time stamp of the vote.  Each string is delimited by the newline character `\n` (byte value 10).  The `space` block is the empty space that is left over, **the block must be exactly 256 bytes** regardless of how much information it holds.

README.md

@@ -0,0 +1,11 @@
+# Votifier-OG
+
+Votifier-OG is a 1.19.4 fork of NuVotifier, which is a secure alternative to using the original Votifier project.
+Votifier-OG will work in place of NuVotifier, and will work in place of Votifier - any vote listener that supports
+Votifier will also support NuVotifier and Votifier-OG.
+
+Votifier-OG supports Purpur 1.19.4. It is maintained by [TrueOG Network](https://trueog.net/)
+
+# License
+
+NuVotifier is GNU GPLv3 licensed. This project's license can be viewed [here](LICENSE).

api/README.md

@@ -0,0 +1,4 @@
+# nuvotifier-api
+
+Files in this directory have a strong API promise - they really shouldn't
+change over time. Feel free to depend against it!

api/src/main/java/com/vexsoftware/votifier/model/Vote.java

@@ -18,7 +18,10 @@
 
 package com.vexsoftware.votifier.model;
 
-import org.json.JSONObject;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import java.util.Arrays;
+import java.util.Base64;
 
 /**
  * A model for a vote.
@@ -47,33 +50,66 @@ public class Vote {
      */
     private String timeStamp;
 
+    private byte[] additionalData;
+
     @Deprecated
-    public Vote() {
-    }
+    public Vote() {}
 
     public Vote(String serviceName, String username, String address, String timeStamp) {
         this.serviceName = serviceName;
         this.username = username;
         this.address = address;
         this.timeStamp = timeStamp;
+        this.additionalData = null;
     }
 
-    private static String getTimestamp(JSONObject object) {
+    public Vote(String serviceName, String username, String address, String timeStamp, byte[] additionalData) {
+        this.serviceName = serviceName;
+        this.username = username;
+        this.address = address;
+        this.timeStamp = timeStamp;
+        this.additionalData = additionalData == null ? null : additionalData.clone();
+    }
+
+    public Vote(Vote vote) {
+        this(
+                vote.getServiceName(),
+                vote.getUsername(),
+                vote.getAddress(),
+                vote.getTimeStamp(),
+                vote.getAdditionalData() == null
+                        ? null
+                        : vote.getAdditionalData().clone());
+    }
+
+    private static String getTimestamp(JsonElement object) {
         try {
-            return Long.toString(object.getLong("timestamp"));
+            return Long.toString(object.getAsLong());
         } catch (Exception e) {
-            return object.getString("timestamp");
+            return object.getAsString();
         }
     }
 
-    public Vote(JSONObject jsonObject) {
-        this(jsonObject.getString("serviceName"), jsonObject.getString("username"), jsonObject.getString("address"), getTimestamp(jsonObject));
+    public Vote(JsonObject jsonObject) {
+        this(
+                jsonObject.get("serviceName").getAsString(),
+                jsonObject.get("username").getAsString(),
+                jsonObject.get("address").getAsString(),
+                getTimestamp(jsonObject.get("timestamp")));
+        if (jsonObject.has("additionalData"))
+            additionalData =
+                    Base64.getDecoder().decode(jsonObject.get("additionalData").getAsString());
     }
 
     @Override
     public String toString() {
+        String data;
+        if (additionalData == null) data = "null";
+        else data = Base64.getEncoder().encodeToString(additionalData);
+
         return "Vote (from:" + serviceName + " username:" + username
-                + " address:" + address + " timeStamp:" + timeStamp + ")";
+                + " address:" + address + " timeStamp:" + timeStamp
+                + " additionalData:" + data + ")";
     }
 
     /**
@@ -152,27 +188,38 @@ public class Vote {
         return timeStamp;
     }
 
-    public JSONObject serialize() {
-        JSONObject ret = new JSONObject();
-        ret.put("serviceName", serviceName);
-        ret.put("username", username);
-        ret.put("address", address);
-        ret.put("timestamp", timeStamp);
+    /**
+     * Returns additional data sent with the vote, if it exists.
+     *
+     * @return Additional data sent with the vote
+     */
+    public byte[] getAdditionalData() {
+        return additionalData == null ? null : additionalData.clone();
+    }
+
+    public JsonObject serialize() {
+        JsonObject ret = new JsonObject();
+        ret.addProperty("serviceName", serviceName);
+        ret.addProperty("username", username);
+        ret.addProperty("address", address);
+        ret.addProperty("timestamp", timeStamp);
+        if (additionalData != null)
+            ret.addProperty("additionalData", Base64.getEncoder().encodeToString(additionalData));
         return ret;
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
+        if (!(o instanceof Vote)) return false;
 
         Vote vote = (Vote) o;
 
         if (!serviceName.equals(vote.serviceName)) return false;
         if (!username.equals(vote.username)) return false;
         if (!address.equals(vote.address)) return false;
-        return timeStamp.equals(vote.timeStamp);
-
+        if (!timeStamp.equals(vote.timeStamp)) return false;
+        return Arrays.equals(additionalData, vote.additionalData);
     }
 
     @Override

bootstrap.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/bash
+
+# Fetch all submodule content.
+git submodule update --force --recursive --init

build.gradle.kts

@@ -0,0 +1,218 @@
+import org.gradle.kotlin.dsl.provideDelegate
+
+/* ------------------------------ Plugins ------------------------------ */
+plugins {
+    id("java") // Import Java plugin.
+    id("java-library") // Import Java Library plugin.
+    id("com.diffplug.spotless") version "8.1.0" // Import Spotless plugin.
+    id("com.gradleup.shadow") version "8.3.9" // Import Shadow plugin.
+    id("checkstyle") // Import Checkstyle plugin.
+    eclipse // Import Eclipse plugin.
+    kotlin("jvm") version "2.1.21" // Import Kotlin JVM plugin.
+}
+
+extra["kotlinAttribute"] = Attribute.of("kotlin-tag", Boolean::class.javaObjectType)
+
+val kotlinAttribute: Attribute<Boolean> by rootProject.extra
+
+/* --------------------------- JDK / Kotlin ---------------------------- */
+java {
+    sourceCompatibility = JavaVersion.VERSION_17 // Compile with JDK 17 compatibility.
+    toolchain { // Select Java toolchain.
+        languageVersion.set(JavaLanguageVersion.of(17)) // Use JDK 17.
+        vendor.set(JvmVendorSpec.GRAAL_VM) // Use GraalVM CE.
+    }
+}
+
+kotlin { jvmToolchain(17) }
+
+/* ----------------------------- Metadata ------------------------------ */
+group = "net.trueog.votifier-og" // Declare bundle identifier.
+
+version = "1.0.2" // Declare plugin version (will be in .jar).
+
+val apiVersion = "1.19" // Declare minecraft server target version.
+
+/* ----------------------------- Resources ----------------------------- */
+tasks.named<ProcessResources>("processResources") {
+    val props = mapOf("version" to version, "apiVersion" to apiVersion)
+    inputs.properties(props) // Indicates to rerun if version changes.
+    filesMatching("plugin.yml") { expand(props) }
+    from("LICENSE") { into("/") } // Bundle licenses into jarfiles.
+}
+
+/* ---------------------------- Repos ---------------------------------- */
+allprojects {
+    repositories {
+        mavenCentral() // Import the Maven Central Maven Repository.
+        gradlePluginPortal() // Import the Gradle Plugin Portal Maven Repository.
+        maven { url = uri("https://repo.purpurmc.org/snapshots") } // Import the PurpurMC Maven Repository.
+        maven { url = uri("file://${System.getProperty("user.home")}/.m2/repository") }
+        System.getProperty("SELF_MAVEN_LOCAL_REPO")?.let { // TrueOG Bootstrap mavenLocal().
+            val dir = file(it)
+            if (dir.isDirectory) {
+                println("Using SELF_MAVEN_LOCAL_REPO at: $it")
+                maven { url = uri("file://${dir.absolutePath}") }
+            } else {
+                logger.error("TrueOG Bootstrap not found, defaulting to ~/.m2 for mavenLocal()")
+                mavenLocal()
+            }
+        }
+            ?: run {
+                logger.error("TrueOG Bootstrap not found, defaulting to ~/.m2 for mavenLocal()")
+                mavenLocal()
+            }
+    }
+}
+
+/* ---------------------- Java project deps ---------------------------- */
+configurations.create("shadeOnly")
+
+dependencies { implementation(project(":nuvotifier-bukkit")) }
+
+apply(from = "eclipse.gradle.kts") // Import eclipse classpath support script.
+
+/* ---------------------- Reproducible jars ---------------------------- */
+allprojects {
+    tasks.withType<AbstractArchiveTask>().configureEach { // Ensure reproducible .jars
+        isPreserveFileTimestamps = false
+        isReproducibleFileOrder = true
+    }
+}
+
+/* ----------------------------- Shadow -------------------------------- */
+tasks.shadowJar {
+    exclude("io.github.miniplaceholders.*") // Exclude the MiniPlaceholders package from being shadowed.
+    isEnableRelocation = true
+    relocationPrefix = "${project.group}.shadow"
+    archiveClassifier.set("") // Use empty string instead of null.
+}
+
+tasks.jar { archiveClassifier.set("part") } // Applies to root jarfile only.
+
+val copyBukkitJarToRoot by tasks.registering(Copy::class)
+
+project(":nuvotifier-bukkit").pluginManager.withPlugin("com.gradleup.shadow") {
+    val bukkitShadowJarProvider = project(":nuvotifier-bukkit").tasks.named<Jar>("shadowJar")
+    copyBukkitJarToRoot.configure {
+        dependsOn(bukkitShadowJarProvider)
+        from(bukkitShadowJarProvider.flatMap { it.archiveFile })
+        into(layout.buildDirectory.dir("libs"))
+        rename { "Votifier-OG-${project.version}.jar" }
+    }
+}
+
+tasks.build {
+    dependsOn(tasks.spotlessApply, tasks.shadowJar, copyBukkitJarToRoot)
+} // Build depends on spotless and shadow.
+
+tasks.shadowJar { finalizedBy(copyBukkitJarToRoot) }
+
+/* --------------------------- Javac opts ------------------------------- */
+allprojects {
+    tasks.withType<JavaCompile>().configureEach {
+        options.compilerArgs.add("-parameters") // Enable reflection for java code.
+        options.isFork = true // Run javac in its own process.
+        options.compilerArgs.add("-Xlint:deprecation") // Trigger deprecation warning messages.
+        options.encoding = "UTF-8" // Use UTF-8 file encoding.
+    }
+}
+
+/* ----------------------------- Auto Formatting ------------------------ */
+spotless {
+    java {
+        eclipse().configFile("config/formatter/eclipse-java-formatter.xml") // Eclipse java formatting.
+        leadingTabsToSpaces() // Convert leftover leading tabs to spaces.
+        removeUnusedImports() // Remove imports that aren't being called.
+    }
+    kotlinGradle {
+        ktfmt().kotlinlangStyle().configure { it.setMaxWidth(120) } // JetBrains Kotlin formatting.
+        target("build.gradle.kts", "settings.gradle.kts") // Gradle files to format.
+    }
+}
+
+checkstyle {
+    toolVersion = "10.18.1" // Declare checkstyle version to use.
+    configFile = file("config/checkstyle/checkstyle.xml") // Point checkstyle to config file.
+    isIgnoreFailures = true // Don't fail the build if checkstyle does not pass.
+    isShowViolations = true // Show the violations in any IDE with the checkstyle plugin.
+}
+
+tasks.named("compileJava") {
+    dependsOn("spotlessApply") // Run spotless before compiling with the JDK.
+}
+
+tasks.named("spotlessCheck") {
+    dependsOn("spotlessApply") // Run spotless before checking if spotless ran.
+}
+
+/* ------------------------------ Eclipse SHIM ------------------------- */
+
+// This can't be put in eclipse.gradle.kts because Gradle is weird.
+subprojects {
+    apply(plugin = "java-library")
+    apply(plugin = "eclipse")
+    eclipse.project.name = "${project.name}-${rootProject.name}"
+    tasks.withType<Jar>().configureEach { archiveBaseName.set("${project.name}-${rootProject.name}") }
+}
+
+/* ----------------------- Subproject configuration -------------------- */
+
+subprojects {
+    java {
+        sourceCompatibility = JavaVersion.VERSION_17
+        toolchain {
+            languageVersion.set(JavaLanguageVersion.of(17))
+            vendor.set(JvmVendorSpec.GRAAL_VM)
+        }
+    }
+}
+
+project(":nuvotifier-api") {
+    dependencies {
+        implementation("com.google.code.gson:gson:2.10.1")
+        testImplementation("junit:junit:4.13.2")
+    }
+    tasks.test { useJUnit() }
+}
+
+project(":nuvotifier-common") {
+    dependencies {
+        api(project(":nuvotifier-api"))
+        implementation(platform("io.netty:netty-bom:4.1.110.Final"))
+        implementation("io.netty:netty-handler")
+        implementation("io.netty:netty-transport-native-epoll:4.1.110.Final:linux-x86_64")
+        implementation("com.google.code.gson:gson:2.10.1")
+    }
+}
+
+project(":nuvotifier-bukkit") {
+    apply(plugin = "com.gradleup.shadow")
+
+    dependencies {
+        compileOnly("org.purpurmc.purpur:purpur-api:1.19.4-R0.1-SNAPSHOT")
+        implementation(project(":nuvotifier-api"))
+        implementation(project(":nuvotifier-common"))
+    }
+
+    tasks.named<ProcessResources>("processResources") {
+        duplicatesStrategy = DuplicatesStrategy.INCLUDE
+        val props =
+            mapOf(
+                "version" to rootProject.version,
+                "apiVersion" to apiVersion,
+                "internalVersion" to rootProject.version,
+            )
+        inputs.properties(props)
+        filesMatching("plugin.yml") { expand(props) }
+        from(rootProject.file("LICENSE")) { into("/") }
+    }
+
+    tasks.named<Jar>("jar") { manifest { attributes("Implementation-Version" to project.version) } }
+
+    tasks.named<Jar>("shadowJar") {
+        archiveBaseName.set("Votifier-OG")
+        archiveVersion.set(rootProject.version.toString())
+        archiveClassifier.set("")
+    }
+}

buildSrc/src/main/kotlin/ArtifactoryConfig.kt

@@ -0,0 +1,56 @@
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.kotlin.dsl.*
+import org.jfrog.gradle.plugin.artifactory.dsl.ArtifactoryPluginConvention
+import org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask
+
+private const val ARTIFACTORY_CONTEXT_URL = "artifactory_contextUrl"
+private const val ARTIFACTORY_USER = "artifactory_user"
+private const val ARTIFACTORY_PASSWORD = "artifactory_password"
+
+fun Project.applyRootArtifactoryConfig() {
+    if (!project.hasProperty(ARTIFACTORY_CONTEXT_URL)) ext[ARTIFACTORY_CONTEXT_URL] = "http://localhost"
+    if (!project.hasProperty(ARTIFACTORY_USER)) ext[ARTIFACTORY_USER] = "guest"
+    if (!project.hasProperty(ARTIFACTORY_PASSWORD)) ext[ARTIFACTORY_PASSWORD] = ""
+
+    apply(plugin = "com.jfrog.artifactory")
+    configure<ArtifactoryPluginConvention> {
+        setContextUrl("${project.property(ARTIFACTORY_CONTEXT_URL)}")
+        clientConfig.publisher.run {
+            repoKey = when {
+                "${project.version}".contains("SNAPSHOT") -> "private"
+                else -> "public"
+            }
+            username = "${project.property(ARTIFACTORY_USER)}"
+            password = "${project.property(ARTIFACTORY_PASSWORD)}"
+            isMaven = true
+            isIvy = false
+        }
+    }
+    tasks.named<ArtifactoryTask>("artifactoryPublish") {
+        isSkip = true
+    }
+}
+
+fun Project.applyCommonArtifactoryConfig() {
+    configure<PublishingExtension> {
+        publications {
+            register<MavenPublication>("maven") {
+                from(components["java"])
+                versionMapping {
+                    usage("java-api") {
+                        fromResolutionOf("runtimeClasspath")
+                    }
+                    usage("java-runtime") {
+                        fromResolutionResult()
+                    }
+                }
+            }
+        }
+    }
+
+    tasks.named<ArtifactoryTask>("artifactoryPublish") {
+        publications("maven")
+    }
+}

buildSrc/src/main/kotlin/CommonConfig.kt

@@ -0,0 +1,33 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.repositories
+import org.gradle.kotlin.dsl.the
+
+fun Project.applyCommonConfiguration() {
+    group = rootProject.group
+    version = rootProject.version
+
+    repositories {
+        mavenCentral()
+        maven { url = uri("https://oss.sonatype.org/content/repositories/snapshots/") }
+        maven {
+            name = "Fabric"
+            url = uri("https://maven.fabricmc.net/")
+        }
+    }
+
+    configurations.all {
+        resolutionStrategy {
+            cacheChangingModulesFor(5, "MINUTES")
+        }
+    }
+
+    plugins.withId("java") {
+        the<JavaPluginExtension>().toolchain {
+            languageVersion.set(JavaLanguageVersion.of(17))
+        }
+    }
+}

buildSrc/src/main/kotlin/CommonJavaConfig.kt

@@ -0,0 +1,75 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.compile.JavaCompile
+import org.gradle.api.tasks.javadoc.Javadoc
+import org.gradle.api.tasks.testing.Test
+import org.gradle.external.javadoc.StandardJavadocDocletOptions
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.withType
+
+fun Project.applyCommonJavaConfiguration(sourcesJar: Boolean, javaRelease: Int = 8, banSlf4j: Boolean = true) {
+    applyCommonConfiguration()
+    apply(plugin = "eclipse")
+    apply(plugin = "idea")
+
+    tasks
+        .withType<JavaCompile>()
+        .matching { it.name == "compileJava" || it.name == "compileTestJava" }
+        .configureEach {
+            val disabledLint = listOf(
+                "processing", "path", "fallthrough", "serial"
+            )
+            options.release.set(javaRelease)
+            options.compilerArgs.addAll(listOf("-Xlint:all") + disabledLint.map { "-Xlint:-$it" })
+            options.isDeprecation = true
+            options.encoding = "UTF-8"
+            options.compilerArgs.add("-parameters")
+        }
+
+    tasks.withType<Test>().configureEach {
+        useJUnitPlatform()
+    }
+
+    dependencies {
+        "compileOnly"("com.google.code.findbugs:jsr305:${Versions.FINDBUGS}")
+        "testImplementation"("org.junit.jupiter:junit-jupiter-api:${Versions.JUNIT}")
+        "testImplementation"("org.junit.jupiter:junit-jupiter-params:${Versions.JUNIT}")
+        "testImplementation"("org.mockito:mockito-core:${Versions.MOCKITO}")
+        "testImplementation"("org.mockito:mockito-junit-jupiter:${Versions.MOCKITO}")
+        "testRuntimeOnly"("org.junit.jupiter:junit-jupiter-engine:${Versions.JUNIT}")
+    }
+
+    // Java 8 turns on doclint which we fail
+    tasks.withType<Javadoc>().configureEach {
+        options.encoding = "UTF-8"
+        (options as StandardJavadocDocletOptions).apply {
+            addStringOption("Xdoclint:none", "-quiet")
+            tags(
+                "apiNote:a:API Note:",
+                "implSpec:a:Implementation Requirements:",
+                "implNote:a:Implementation Note:"
+            )
+        }
+    }
+
+    configure<JavaPluginExtension> {
+        disableAutoTargetJvm()
+        withJavadocJar()
+        if (sourcesJar) {
+            withSourcesJar()
+        }
+    }
+
+    if (banSlf4j) {
+        configurations["compileClasspath"].apply {
+            resolutionStrategy.componentSelection {
+                withModule("org.slf4j:slf4j-api") {
+                    reject("No SLF4J allowed on compile classpath")
+                }
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/GradleExtras.kt

@@ -0,0 +1,12 @@
+import org.gradle.api.Project
+import org.gradle.api.plugins.ExtraPropertiesExtension
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.the
+
+val Project.ext: ExtraPropertiesExtension
+    get() = extensions.getByType()
+
+val Project.sourceSets: SourceSetContainer
+    get() = the<JavaPluginExtension>().sourceSets

buildSrc/src/main/kotlin/PlatformConfig.kt

@@ -0,0 +1,42 @@
+import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
+import org.gradle.api.Project
+import org.gradle.api.component.AdhocComponentWithVariants
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.named
+
+fun Project.applyPlatformAndCoreConfiguration(javaRelease: Int = 8) {
+    applyCommonConfiguration()
+    apply(plugin = "java")
+    apply(plugin = "maven-publish")
+    apply(plugin = "com.jfrog.artifactory")
+    applyCommonJavaConfiguration(
+        sourcesJar = true,
+        javaRelease = javaRelease,
+        banSlf4j = false
+    )
+
+    ext["internalVersion"] = "$version+${rootProject.ext["gitCommitHash"]}"
+}
+
+fun Project.applyShadowConfiguration() {
+    apply(plugin = "com.github.johnrengelman.shadow")
+    tasks.named<ShadowJar>("shadowJar") {
+        archiveClassifier.set("dist")
+        dependencies {
+            include(project(":nuvotifier-api"))
+            include(project(":nuvotifier-common"))
+
+            exclude("com.google.code.findbugs:jsr305")
+        }
+        exclude("GradleStart**")
+        exclude(".cache")
+        exclude("LICENSE*")
+        exclude("META-INF/maven/**")
+    }
+    val javaComponent = components["java"] as AdhocComponentWithVariants
+    // I don't think we want this published (it's the shadow jar)
+    javaComponent.withVariantsFromConfiguration(configurations["shadowRuntimeElements"]) {
+        skip()
+    }
+}

buildSrc/src/main/kotlin/Versions.kt

@@ -0,0 +1,8 @@
+object Versions {
+    const val JUNIT = "5.8.1"
+    const val MOCKITO = "4.3.1"
+    const val FINDBUGS = "3.0.2"
+    const val NETTYIO = "4.1.72.Final"
+    const val GSON = "2.9.0"
+    const val VELOCITY = "3.1.0"
+}

bukkit/.gitignore

@@ -0,0 +1 @@
+/bin/

bukkit/pom.xml

@@ -1,66 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>nuvotifier</artifactId>
-        <groupId>com.vexsoftware</groupId>
-        <version>2.3.2.2</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>nuvotifier-bukkit</artifactId>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>com.google.code.maven-replacer-plugin</groupId>
-                <artifactId>maven-replacer-plugin</artifactId>
-                <version>1.3.8</version>
-                <executions>
-                    <execution>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>replace</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <file>target/classes/plugin.yml</file>
-                    <replacements>
-                        <replacement>
-                            <token>maven-version-number</token>
-                            <value>${project.version}</value>
-                        </replacement>
-                    </replacements>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>2.3.1</version>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-javadoc-plugin</artifactId>
-                <version>2.9</version>
-            </plugin>
-        </plugins>
-    </build>
-
-    <dependencies>
-        <dependency>
-            <groupId>com.vexsoftware</groupId>
-            <artifactId>nuvotifier-common</artifactId>
-            <version>${project.parent.version}</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.bukkit</groupId>
-            <artifactId>bukkit</artifactId>
-            <version>1.7.2-R0.1</version>
-            <type>jar</type>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-</project>

bukkit/src/main/java/com/vexsoftware/votifier/BukkitScheduler.java

@@ -0,0 +1,44 @@
+package com.vexsoftware.votifier;
+
+import com.vexsoftware.votifier.platform.scheduler.ScheduledVotifierTask;
+import com.vexsoftware.votifier.platform.scheduler.VotifierScheduler;
+import java.util.concurrent.TimeUnit;
+import org.bukkit.scheduler.BukkitTask;
+
+class BukkitScheduler implements VotifierScheduler {
+    private final NuVotifierBukkit plugin;
+
+    public BukkitScheduler(NuVotifierBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    private int toTicks(int time, TimeUnit unit) {
+        return (int) (unit.toMillis(time) / 50);
+    }
+
+    @Override
+    public ScheduledVotifierTask delayedOnPool(Runnable runnable, int delay, TimeUnit unit) {
+        return new BukkitTaskWrapper(
+                plugin.getServer().getScheduler().runTaskLaterAsynchronously(plugin, runnable, toTicks(delay, unit)));
+    }
+
+    @Override
+    public ScheduledVotifierTask repeatOnPool(Runnable runnable, int delay, int repeat, TimeUnit unit) {
+        return new BukkitTaskWrapper(plugin.getServer()
+                .getScheduler()
+                .runTaskTimerAsynchronously(plugin, runnable, toTicks(delay, unit), toTicks(repeat, unit)));
+    }
+
+    private static class BukkitTaskWrapper implements ScheduledVotifierTask {
+        private final BukkitTask task;
+
+        private BukkitTaskWrapper(BukkitTask task) {
+            this.task = task;
+        }
+
+        @Override
+        public void cancel() {
+            task.cancel();
+        }
+    }
+}

bukkit/src/main/java/com/vexsoftware/votifier/NuVotifierBukkit.java

@@ -18,44 +18,39 @@
 
 package com.vexsoftware.votifier;
 
-import com.google.common.io.ByteStreams;
-import com.google.common.io.Files;
+import com.vexsoftware.votifier.cmd.NVReloadCmd;
+import com.vexsoftware.votifier.cmd.TestVoteCmd;
 import com.vexsoftware.votifier.forwarding.BukkitPluginMessagingForwardingSink;
-import com.vexsoftware.votifier.forwarding.ForwardedVoteListener;
-import com.vexsoftware.votifier.forwarding.ForwardingVoteSink;
 import com.vexsoftware.votifier.model.Vote;
 import com.vexsoftware.votifier.model.VotifierEvent;
+import com.vexsoftware.votifier.net.VotifierServerBootstrap;
 import com.vexsoftware.votifier.net.VotifierSession;
-import com.vexsoftware.votifier.net.protocol.VoteInboundHandler;
-import com.vexsoftware.votifier.net.protocol.VotifierGreetingHandler;
-import com.vexsoftware.votifier.net.protocol.VotifierProtocolDifferentiator;
 import com.vexsoftware.votifier.net.protocol.v1crypto.RSAIO;
 import com.vexsoftware.votifier.net.protocol.v1crypto.RSAKeygen;
+import com.vexsoftware.votifier.platform.JavaUtilLogger;
+import com.vexsoftware.votifier.platform.LoggingAdapter;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.platform.scheduler.VotifierScheduler;
+import com.vexsoftware.votifier.support.forwarding.ForwardedVoteListener;
+import com.vexsoftware.votifier.support.forwarding.ForwardingVoteSink;
+import com.vexsoftware.votifier.util.IOUtil;
 import com.vexsoftware.votifier.util.KeyCreator;
 import com.vexsoftware.votifier.util.TokenUtil;
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import org.bukkit.Bukkit;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.plugin.java.JavaPlugin;
-
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.IOException;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
 import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
 import java.security.Key;
 import java.security.KeyPair;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.logging.Level;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.java.JavaPlugin;
 
 /**
  * The main Votifier plugin class.
@@ -66,24 +61,9 @@ import java.util.logging.Level;
 public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, VotifierPlugin, ForwardedVoteListener {
 
     /**
-     * The Votifier instance.
+     * The server bootstrap.
      */
-    private static NuVotifierBukkit instance;
-
-    /**
-     * The current Votifier version.
-     */
-    private String version;
-
-    /**
-     * The server channel.
-     */
-    private Channel serverChannel;
-
-    /**
-     * The event group handling the channel.
-     */
-    private NioEventLoopGroup serverGroup;
+    private VotifierServerBootstrap bootstrap;
 
     /**
      * The RSA key pair.
@@ -101,22 +81,30 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
     private Map<String, Key> tokens = new HashMap<>();
 
     private ForwardingVoteSink forwardingMethod;
+    private VotifierScheduler scheduler;
+    private LoggingAdapter pluginLogger;
+    private boolean isFolia;
 
-    @Override
-    public void onEnable() {
-        NuVotifierBukkit.instance = this;
+    private boolean loadAndBind() {
+        try {
+            Class.forName("io.papermc.paper.threadedregions.scheduler.AsyncScheduler");
+            isFolia = true;
 
-        // Set the plugin version.
-        version = getDescription().getVersion();
+            getLogger().info("Using Folia; VotifierEvent will be fired asynchronously.");
+        } catch (ClassNotFoundException e) {
+            isFolia = false;
+        }
 
+        scheduler = new BukkitScheduler(this);
+        pluginLogger = new JavaUtilLogger(getLogger());
         if (!getDataFolder().exists()) {
-            getDataFolder().mkdir();
+            if (!getDataFolder().mkdir()) {
+                throw new RuntimeException("Unable to create the plugin data folder " + getDataFolder());
+            }
         }
 
         // Handle configuration.
-        File config = new File(getDataFolder() + "/config.yml");
-        YamlConfiguration cfg;
-        File rsaDirectory = new File(getDataFolder() + "/rsa");
+        File config = new File(getDataFolder(), "config.yml");
 
         /*
          * Use IP address from server.properties as a default for
@@ -125,8 +113,7 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
          * assigned to the server.
          */
         String hostAddr = Bukkit.getServer().getIp();
-        if (hostAddr == null || hostAddr.length() == 0)
-            hostAddr = "0.0.0.0";
+        if (hostAddr == null || hostAddr.length() == 0) hostAddr = "0.0.0.0";
 
         /*
          * Create configuration file if it does not exists; otherwise, load it
@@ -137,13 +124,19 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
                 getLogger().info("Configuring Votifier for the first time...");
 
                 // Initialize the configuration file.
-                config.createNewFile();
+                if (!config.createNewFile()) {
+                    throw new IOException("Unable to create the config file at " + config);
+                }
 
                 // Load and manually replace variables in the configuration.
-                String cfgStr = new String(ByteStreams.toByteArray(getResource("bukkitConfig.yml")), StandardCharsets.UTF_8);
+                String cfgStr =
+                        new String(IOUtil.readAllBytes(getResource("bukkitConfig.yml")), StandardCharsets.UTF_8);
                 String token = TokenUtil.newToken();
                 cfgStr = cfgStr.replace("%default_token%", token).replace("%ip%", hostAddr);
-                Files.write(cfgStr, config, StandardCharsets.UTF_8);
+                Files.copy(
+                        new ByteArrayInputStream(cfgStr.getBytes(StandardCharsets.UTF_8)),
+                        config.toPath(),
+                        StandardCopyOption.REPLACE_EXISTING);
 
                 /*
                  * Remind hosted server admins to be sure they have the right
@@ -161,11 +154,13 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
                 getLogger().info("------------------------------------------------------------------------------");
             } catch (Exception ex) {
                 getLogger().log(Level.SEVERE, "Error creating configuration file", ex);
-                gracefulExit();
-                return;
+                return false;
             }
         }
 
+        YamlConfiguration cfg;
+        File rsaDirectory = new File(getDataFolder(), "rsa");
+
         // Load configuration.
         cfg = YamlConfiguration.loadConfiguration(config);
 
@@ -175,60 +170,63 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
          */
         try {
             if (!rsaDirectory.exists()) {
-                rsaDirectory.mkdir();
+                if (!rsaDirectory.mkdir()) {
+                    throw new RuntimeException("Unable to create the RSA key folder " + rsaDirectory);
+                }
                 keyPair = RSAKeygen.generate(2048);
                 RSAIO.save(rsaDirectory, keyPair);
             } else {
                 keyPair = RSAIO.load(rsaDirectory);
             }
         } catch (Exception ex) {
-            getLogger().log(Level.SEVERE,
-                    "Error reading configuration file or RSA tokens", ex);
-            gracefulExit();
-            return;
+            getLogger().log(Level.SEVERE, "Error reading configuration file or RSA tokens", ex);
+            return false;
         }
 
-        debug = cfg.getBoolean("debug", false);
+        // the quiet flag always runs priority to the debug flag
+        if (cfg.isBoolean("quiet")) {
+            debug = !cfg.getBoolean("quiet");
+        } else {
+            // otherwise, default to being noisy
+            debug = cfg.getBoolean("debug", true);
+        }
 
-        boolean setUpPort = cfg.getBoolean("enableExternal", true); //Always default to running the external port
+        // Load Votifier tokens.
+        ConfigurationSection tokenSection = cfg.getConfigurationSection("tokens");
 
-        if (setUpPort) {
-            // Load Votifier tokens.
-            ConfigurationSection tokenSection = cfg.getConfigurationSection("tokens");
-
-            if (tokenSection != null) {
-                Map<String, Object> websites = tokenSection.getValues(false);
-                for (Map.Entry<String, Object> website : websites.entrySet()) {
-                    tokens.put(website.getKey(), KeyCreator.createKeyFrom(website.getValue().toString()));
-                    getLogger().info("Loaded token for website: " + website.getKey());
-                }
-            } else {
-                String token = TokenUtil.newToken();
-                tokenSection = cfg.createSection("tokens");
-                tokenSection.set("default", token);
-                tokens.put("default", KeyCreator.createKeyFrom(token));
-                try {
-                    cfg.save(config);
-                } catch (IOException e) {
-                    getLogger().log(Level.SEVERE,
-                            "Error generating Votifier token", e);
-                    gracefulExit();
-                    return;
-                }
-                getLogger().info("------------------------------------------------------------------------------");
-                getLogger().info("No tokens were found in your configuration, so we've generated one for you.");
-                getLogger().info("Your default Votifier token is " + token + ".");
-                getLogger().info("You will need to provide this token when you submit your server to a voting");
-                getLogger().info("list.");
-                getLogger().info("------------------------------------------------------------------------------");
+        if (tokenSection != null) {
+            Map<String, Object> websites = tokenSection.getValues(false);
+            for (Map.Entry<String, Object> website : websites.entrySet()) {
+                tokens.put(
+                        website.getKey(),
+                        KeyCreator.createKeyFrom(website.getValue().toString()));
+                getLogger().info("Loaded token for website: " + website.getKey());
             }
+        } else {
+            String token = TokenUtil.newToken();
+            tokenSection = cfg.createSection("tokens");
+            tokenSection.set("default", token);
+            tokens.put("default", KeyCreator.createKeyFrom(token));
+            try {
+                cfg.save(config);
+            } catch (IOException e) {
+                getLogger().log(Level.SEVERE, "Error generating Votifier token", e);
+                return false;
+            }
+            getLogger().info("------------------------------------------------------------------------------");
+            getLogger().info("No tokens were found in your configuration, so we've generated one for you.");
+            getLogger().info("Your default Votifier token is " + token + ".");
+            getLogger().info("You will need to provide this token when you submit your server to a voting");
+            getLogger().info("list.");
+            getLogger().info("------------------------------------------------------------------------------");
+        }
 
-            // Initialize the receiver.
-            final String host = cfg.getString("host", hostAddr);
-            final int port = cfg.getInt("port", 8192);
-            if (debug)
-                getLogger().info("DEBUG mode enabled!");
+        // Initialize the receiver.
+        final String host = cfg.getString("host", hostAddr);
+        final int port = cfg.getInt("port", 8192);
+        if (!debug) getLogger().info("QUIET mode enabled!");
 
+        if (port >= 0) {
             final boolean disablev1 = cfg.getBoolean("disable-v1-protocol");
             if (disablev1) {
                 getLogger().info("------------------------------------------------------------------------------");
@@ -237,94 +235,111 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
                 getLogger().info("------------------------------------------------------------------------------");
             }
 
-            serverGroup = new NioEventLoopGroup(1);
-
-            new ServerBootstrap()
-                    .channel(NioServerSocketChannel.class)
-                    .group(serverGroup)
-                    .childHandler(new ChannelInitializer<NioSocketChannel>() {
-                        @Override
-                        protected void initChannel(NioSocketChannel channel) throws Exception {
-                            channel.attr(VotifierSession.KEY).set(new VotifierSession());
-                            channel.attr(VotifierPlugin.KEY).set(NuVotifierBukkit.this);
-                            channel.pipeline().addLast("greetingHandler", new VotifierGreetingHandler());
-                            channel.pipeline().addLast("protocolDifferentiator", new VotifierProtocolDifferentiator(false, !disablev1));
-                            channel.pipeline().addLast("voteHandler", new VoteInboundHandler(NuVotifierBukkit.this));
-                        }
-                    })
-                    .bind(host, port)
-                    .addListener(new ChannelFutureListener() {
-                        @Override
-                        public void operationComplete(ChannelFuture future) throws Exception {
-                            if (future.isSuccess()) {
-                                serverChannel = future.channel();
-                                getLogger().info("Votifier enabled on socket "+serverChannel.localAddress()+".");
-                            } else {
-                                SocketAddress socketAddress = future.channel().localAddress();
-                                if (socketAddress == null) {
-                                    socketAddress = new InetSocketAddress(host, port);
-                                }
-                                getLogger().log(Level.SEVERE, "Votifier was not able to bind to " + socketAddress, future.cause());
-                            }
-                        }
-                    });
+            this.bootstrap = new VotifierServerBootstrap(host, port, this, disablev1);
+            this.bootstrap.start(error -> {});
         } else {
-            getLogger().info("You have enableExternal set to false in your config.yml. NuVotifier will NOT listen to votes coming in from an external voting list.");
+            getLogger().info("------------------------------------------------------------------------------");
+            getLogger().info("Your Votifier port is less than 0, so we assume you do NOT want to start the");
+            getLogger().info("votifier port server! Votifier will not listen for votes over any port, and");
+            getLogger().info("will only listen for pluginMessaging forwarded votes!");
+            getLogger().info("------------------------------------------------------------------------------");
         }
 
         ConfigurationSection forwardingConfig = cfg.getConfigurationSection("forwarding");
         if (forwardingConfig != null) {
-            String method = forwardingConfig.getString("method", "none").toLowerCase(); //Default to lower case for case-insensitive searches
+            String method = forwardingConfig
+                    .getString("method", "none")
+                    .toLowerCase(); // Default to lower case for case-insensitive searches
             if ("none".equals(method)) {
-                getLogger().info("Method none selected for vote forwarding: Votes will not be received from a forwarder.");
+                getLogger()
+                        .info("Method none selected for vote forwarding: Votes will not be received from a forwarder.");
             } else if ("pluginmessaging".equals(method)) {
                 String channel = forwardingConfig.getString("pluginMessaging.channel", "NuVotifier");
                 try {
                     forwardingMethod = new BukkitPluginMessagingForwardingSink(this, channel, this);
                     getLogger().info("Receiving votes over PluginMessaging channel '" + channel + "'.");
                 } catch (RuntimeException e) {
-                    getLogger().log(Level.SEVERE, "NuVotifier could not set up PluginMessaging for vote forwarding!", e);
+                    getLogger()
+                            .log(Level.SEVERE, "NuVotifier could not set up PluginMessaging for vote forwarding!", e);
                 }
             } else {
-                getLogger().severe("No vote forwarding method '" + method + "' known. Defaulting to noop implementation.");
+                getLogger()
+                        .severe("No vote forwarding method '" + method + "' known. Defaulting to noop implementation.");
             }
         }
+        return true;
+    }
+
+    private void halt() {
+        // Shut down the network handlers.
+        if (bootstrap != null) {
+            bootstrap.shutdown();
+            bootstrap = null;
+        }
+
+        if (forwardingMethod != null) {
+            forwardingMethod.halt();
+            forwardingMethod = null;
+        }
+    }
+
+    @Override
+    public void onEnable() {
+        getCommand("nvreload").setExecutor(new NVReloadCmd(this));
+        getCommand("testvote").setExecutor(new TestVoteCmd(this));
+
+        if (!loadAndBind()) {
+            gracefulExit();
+            setEnabled(false); // safer to just bomb out
+        }
     }
 
     @Override
     public void onDisable() {
-        // Shut down the network handlers.
-        if (serverGroup != null) {
-            if (serverChannel != null)
-                serverChannel.close();
-            serverGroup.shutdownGracefully();
-        }
-        if (forwardingMethod != null) {
-            forwardingMethod.halt();
-        }
+        halt();
         getLogger().info("Votifier disabled.");
     }
 
+    public boolean reload() {
+        try {
+            halt();
+        } catch (Exception ex) {
+            getLogger().log(Level.SEVERE, "On halt, an exception was thrown. This may be fine!", ex);
+        }
+
+        if (loadAndBind()) {
+            getLogger().info("Reload was successful.");
+            return true;
+        } else {
+            try {
+                halt();
+                getLogger()
+                        .log(
+                                Level.SEVERE,
+                                "On reload, there was a problem with the configuration. Votifier currently does nothing!");
+            } catch (Exception ex) {
+                getLogger()
+                        .log(
+                                Level.SEVERE,
+                                "On reload, there was a problem loading, and we could not re-halt the server. Votifier is in an unstable state!",
+                                ex);
+            }
+            return false;
+        }
+    }
+
     private void gracefulExit() {
         getLogger().log(Level.SEVERE, "Votifier did not initialize properly!");
     }
 
-    /**
-     * Gets the instance.
-     *
-     * @return The instance
-     */
-    public static NuVotifierBukkit getInstance() {
-        return instance;
+    @Override
+    public LoggingAdapter getPluginLogger() {
+        return pluginLogger;
     }
 
-    /**
-     * Gets the version.
-     *
-     * @return The version
-     */
-    public String getVersion() {
-        return version;
+    @Override
+    public VotifierScheduler getScheduler() {
+        return scheduler;
     }
 
     public boolean isDebug() {
@@ -342,28 +357,29 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
     }
 
     @Override
-    public void onVoteReceived(final Vote vote, VotifierSession.ProtocolVersion protocolVersion) throws Exception {
+    public void onVoteReceived(final Vote vote, VotifierSession.ProtocolVersion protocolVersion, String remoteAddress) {
         if (debug) {
-            if (protocolVersion == VotifierSession.ProtocolVersion.ONE) {
-                getLogger().info("Got a protocol v1 vote record -> " + vote);
-            } else {
-                getLogger().info("Got a protocol v2 vote record -> " + vote);
-            }
+            getLogger()
+                    .info("Got a " + protocolVersion.humanReadable + " vote record from " + remoteAddress + " -> "
+                            + vote);
         }
-        Bukkit.getScheduler().runTask(this, new Runnable() {
-            @Override
-            public void run() {
-                Bukkit.getPluginManager().callEvent(new VotifierEvent(vote));
-            }
-        });
+        fireVotifierEvent(vote);
     }
 
     @Override
-    public void onError(Channel channel, Throwable throwable) {
+    public void onError(Throwable throwable, boolean alreadyHandledVote, String remoteAddress) {
         if (debug) {
-            getLogger().log(Level.SEVERE, "Unable to process vote from " + channel.remoteAddress(), throwable);
-        } else {
-            getLogger().log(Level.SEVERE, "Unable to process vote from " + channel.remoteAddress());
+            if (alreadyHandledVote) {
+                getLogger()
+                        .log(
+                                Level.WARNING,
+                                "Vote processed, however an exception " + "occurred with a vote from " + remoteAddress,
+                                throwable);
+            } else {
+                getLogger().log(Level.WARNING, "Unable to process vote from " + remoteAddress, throwable);
+            }
+        } else if (!alreadyHandledVote) {
+            getLogger().log(Level.WARNING, "Unable to process vote from " + remoteAddress);
         }
     }
 
@@ -372,11 +388,30 @@ public class NuVotifierBukkit extends JavaPlugin implements VoteHandler, Votifie
         if (debug) {
             getLogger().info("Got a forwarded vote -> " + v);
         }
-        Bukkit.getScheduler().runTask(this, new Runnable() {
-            @Override
-            public void run() {
-                Bukkit.getPluginManager().callEvent(new VotifierEvent(v));
-            }
-        });
+        fireVotifierEvent(v);
+    }
+
+    private void fireVotifierEvent(Vote vote) {
+        if (VotifierEvent.getHandlerList().getRegisteredListeners().length == 0) {
+            getLogger()
+                    .log(
+                            Level.SEVERE,
+                            "A vote was received, but you don't have any listeners available to listen for it.");
+            getLogger()
+                    .log(
+                            Level.SEVERE,
+                            "See https://github.com/NuVotifier/NuVotifier/wiki/Setup-Guide#vote-listeners for");
+            getLogger().log(Level.SEVERE, "a list of listeners you can configure.");
+        }
+
+        if (!isFolia) {
+            getServer()
+                    .getScheduler()
+                    .runTask(this, () -> getServer().getPluginManager().callEvent(new VotifierEvent(vote)));
+        } else {
+            getServer().getScheduler().runTaskAsynchronously(this, () -> getServer()
+                    .getPluginManager()
+                    .callEvent(new VotifierEvent(vote, true)));
+        }
     }
 }

bukkit/src/main/java/com/vexsoftware/votifier/cmd/NVReloadCmd.java

@@ -0,0 +1,36 @@
+package com.vexsoftware.votifier.cmd;
+
+import com.vexsoftware.votifier.NuVotifierBukkit;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class NVReloadCmd implements CommandExecutor {
+
+    private final NuVotifierBukkit plugin;
+
+    public NVReloadCmd(NuVotifierBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (sender.hasPermission("nuvotifier.reload")) {
+            sender.sendMessage(Component.text("Reloading NuVotifier...").color(NamedTextColor.GRAY));
+            if (plugin.reload()) {
+                sender.sendMessage(
+                        Component.text("NuVotifier has been reloaded!").color(NamedTextColor.DARK_GREEN));
+            } else {
+                sender.sendMessage(
+                        Component.text("Looks like there was a problem reloading NuVotifier, check the console!")
+                                .color(NamedTextColor.DARK_RED));
+            }
+        } else {
+            sender.sendMessage(
+                    Component.text("You do not have permission to do this!").color(NamedTextColor.DARK_RED));
+        }
+        return true;
+    }
+}

bukkit/src/main/java/com/vexsoftware/votifier/cmd/TestVoteCmd.java

@@ -0,0 +1,46 @@
+package com.vexsoftware.votifier.cmd;
+
+import com.vexsoftware.votifier.NuVotifierBukkit;
+import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.net.VotifierSession;
+import com.vexsoftware.votifier.util.ArgsToVote;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+public class TestVoteCmd implements CommandExecutor {
+
+    private final NuVotifierBukkit plugin;
+
+    public TestVoteCmd(NuVotifierBukkit plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (sender.hasPermission("nuvotifier.testvote")) {
+            Vote v;
+            try {
+                v = ArgsToVote.parse(args);
+            } catch (IllegalArgumentException e) {
+                sender.sendMessage(
+                        Component.text("Error while parsing arguments to create test vote: " + e.getMessage())
+                                .color(NamedTextColor.DARK_RED));
+                sender.sendMessage(Component.text(
+                                "Usage hint: /testvote [username] [serviceName=?] [username=?] [address=?] [localTimestamp=?] [timestamp=?]")
+                        .color(NamedTextColor.GRAY));
+                return true;
+            }
+
+            plugin.onVoteReceived(v, VotifierSession.ProtocolVersion.TEST, "localhost.test");
+            sender.sendMessage(
+                    Component.text("Test vote executed: " + v.toString()).color(NamedTextColor.GREEN));
+        } else {
+            sender.sendMessage(
+                    Component.text("You do not have permission to do this!").color(NamedTextColor.DARK_RED));
+        }
+        return true;
+    }
+}

bukkit/src/main/java/com/vexsoftware/votifier/forwarding/BukkitPluginMessagingForwardingSink.java

@@ -1,33 +1,27 @@
 package com.vexsoftware.votifier.forwarding;
 
-import com.vexsoftware.votifier.NuVotifierBukkit;
-import com.vexsoftware.votifier.model.Vote;
-import org.apache.commons.lang.Validate;
+import com.vexsoftware.votifier.support.forwarding.AbstractPluginMessagingForwardingSink;
+import com.vexsoftware.votifier.support.forwarding.ForwardedVoteListener;
+import java.util.Objects;
+import java.util.logging.Level;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.messaging.PluginMessageListener;
-import org.json.JSONObject;
 
-import java.nio.charset.StandardCharsets;
-import java.util.logging.Level;
-
-/**
- * Created by Joe Hirschfeld on 10/20/2015.
- */
-public class BukkitPluginMessagingForwardingSink implements ForwardingVoteSink, PluginMessageListener {
+public class BukkitPluginMessagingForwardingSink extends AbstractPluginMessagingForwardingSink
+        implements PluginMessageListener {
 
     public BukkitPluginMessagingForwardingSink(Plugin p, String channel, ForwardedVoteListener listener) {
-        Validate.notNull(channel, "Channel cannot be null.");
+        super(listener);
+        Objects.requireNonNull(channel, "Channel cannot be null."); // Replaced Validate.notNull
         this.channel = channel;
         Bukkit.getMessenger().registerIncomingPluginChannel(p, channel, this);
-        this.listener = listener;
         this.p = p;
     }
 
     private final Plugin p;
     private final String channel;
-    private final ForwardedVoteListener listener;
 
     @Override
     public void halt() {
@@ -37,12 +31,9 @@ public class BukkitPluginMessagingForwardingSink implements ForwardingVoteSink,
     @Override
     public void onPluginMessageReceived(String s, Player player, byte[] bytes) {
         try {
-            String message = new String(bytes, StandardCharsets.UTF_8);
-            JSONObject jsonObject = new JSONObject(message);
-            Vote v = new Vote(jsonObject);
-            listener.onForward(v);
+            this.handlePluginMessage(bytes);
         } catch (Exception e) {
-            NuVotifierBukkit.getInstance().getLogger().log(Level.SEVERE, "There was an unknown error when processing a forwarded vote.", e);
+            p.getLogger().log(Level.SEVERE, "There was an unknown error when processing a forwarded vote.", e);
         }
     }
 }

bukkit/src/main/java/com/vexsoftware/votifier/forwarding/ForwardedVoteListener.java

@@ -1,17 +0,0 @@
-package com.vexsoftware.votifier.forwarding;
-
-import com.vexsoftware.votifier.model.Vote;
-
-/**
- * Represents a method to call when a vote is forwarded through the {@link ForwardingVoteSink}.
- */
-public interface ForwardedVoteListener {
-
-    /**
-     * Called whenever a vote is forwarded from a {@link ForwardingVoteSink}
-     *
-     * @param v Vote that was forwarded
-     */
-    void onForward(Vote v);
-
-}

bukkit/src/main/java/com/vexsoftware/votifier/model/VotifierEvent.java

@@ -5,7 +5,7 @@ import org.bukkit.event.HandlerList;
 
 /**
  * {@code VotifierEvent} is a custom Bukkit event class that is sent
- * synchronously to CraftBukkit's main thread allowing other plugins to listener
+ * synchronously to CraftBukkit's main thread allowing other plugins to listen
  * for votes.
  *
  * @author frelling
@@ -30,6 +30,17 @@ public class VotifierEvent extends Event {
         this.vote = vote;
     }
 
+    /**
+     * Constructs a vote event that encapsulated the given vote record.
+     *
+     * @param vote vote record
+     * @param async whether the event will be fired asynchronously
+     */
+    public VotifierEvent(final Vote vote, final boolean async) {
+        super(async);
+        this.vote = vote;
+    }
+
     /**
      * Return the encapsulated vote record.
      *

bukkit/src/main/resources/bukkitConfig.yml

@@ -1,18 +1,10 @@
 # The IP to listen to. Use 0.0.0.0 if you wish to listen to all interfaces on your server. (All IP addresses)
 # This defaults to the IP you have configured your server to listen on, or 0.0.0.0 if you have not configured this.
-host: %ip%
+host: 0.0.0.0
 
 # Port to listen for new votes on
 port: 8192
 
-# Whether or not to print debug messages. In a production system, this should be set to false.
-# This is useful when initially setting up NuVotifier to ensure votes are being delivered.
-debug: false
-
-# Setting this value to false will turn off the votifier port listening for external votes. This is beneficial if the server
-# is only listening for votes coming from NuVotifier running on your BungeeCord.
-enableExternal: true
-
 # Setting this option to true will disable handling of Protocol v1 packets. While the old protocol is not secure, this
 # option is currently not recommended as most voting sites only support the old protocol at present. However, if you are
 # using NuVotifier's proxy forwarding mechanism, enabling this option will increase your server's security.
@@ -21,7 +13,7 @@ disable-v1-protocol: false
 # All tokens, labeled by the serviceName of each server list.
 tokens:
   # Default token for all server lists, if another isn't supplied.
-  default: %default_token%
+  default: "^{VOTIFIER_OG_TOKEN}"
 
 # Configuration section for all vote forwarding to NuVotifier
 forwarding:
@@ -30,4 +22,4 @@ forwarding:
   # - pluginMessaging - Sets up plugin messaging
   method: none
   pluginMessaging:
-    channel: NuVotifier
+    channel: nuvotifier:votes

bukkit/src/main/resources/plugin.yml

@@ -1,5 +1,26 @@
-name: Votifier
+name: Votifier-OG
 main: com.vexsoftware.votifier.NuVotifierBukkit
-version: maven-version-number
+version: "${version}"
 description: A plugin that gets notified when votes are made for the server on toplists.
-authors: [blakeman8192, Kramer, tuxed]
+authors: [Ichbinjoe, blakeman8192, Kramer, tuxed, NotAlexNoyle]
+api-version: 1.19
+
+commands:
+  nvreload:
+    description: Reloads the NuVotifier configuration
+    permission: nuvotifier.reload
+    permission-message: "You do not have permission to run this command."
+    usage: "/nvreload"
+  testvote:
+    description: Sends a test vote to the server
+    permission: nuvotifier.testvote
+    permission-message: "You do not have permission to run this command."
+    usage: "/testvote [username] [serviceName=?] [username=?] [address=?] [localTimestamp=?] [timestamp=?]"
+
+permissions:
+  nuvotifier.reload:
+    description: Allows you to reload the NuVotifier plugin
+    default: op
+  nuvotifier.testvote:
+    description: Allows you to send a test vote
+    default: op

bungeecord/pom.xml

@@ -1,65 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>nuvotifier</artifactId>
-        <groupId>com.vexsoftware</groupId>
-        <version>2.3.2.2</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>nuvotifier-bungeecord</artifactId>
-
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>com.google.code.maven-replacer-plugin</groupId>
-                <artifactId>maven-replacer-plugin</artifactId>
-                <version>1.3.8</version>
-                <executions>
-                    <execution>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>replace</goal>
-                        </goals>
-                    </execution>
-                </executions>
-                <configuration>
-                    <file>target/classes/bungee.yml</file>
-                    <replacements>
-                        <replacement>
-                            <token>maven-version-number</token>
-                            <value>${project.version}</value>
-                        </replacement>
-                    </replacements>
-                </configuration>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>2.3.1</version>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-javadoc-plugin</artifactId>
-                <version>2.9</version>
-            </plugin>
-        </plugins>
-    </build>
-
-    <dependencies>
-        <dependency>
-            <groupId>net.md-5</groupId>
-            <artifactId>bungeecord-api</artifactId>
-            <version>1.8-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.vexsoftware</groupId>
-            <artifactId>nuvotifier-common</artifactId>
-            <version>${project.parent.version}</version>
-            <scope>compile</scope>
-        </dependency>
-    </dependencies>
-</project>

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/NuVotifier.java

@@ -1,377 +0,0 @@
-package com.vexsoftware.votifier.bungee;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.io.ByteStreams;
-import com.google.common.io.Files;
-import com.vexsoftware.votifier.VoteHandler;
-import com.vexsoftware.votifier.VotifierPlugin;
-import com.vexsoftware.votifier.bungee.events.VotifierEvent;
-import com.vexsoftware.votifier.bungee.forwarding.ForwardingVoteSource;
-import com.vexsoftware.votifier.bungee.forwarding.OnlineForwardPluginMessagingForwardingSource;
-import com.vexsoftware.votifier.bungee.forwarding.PluginMessagingForwardingSource;
-import com.vexsoftware.votifier.bungee.forwarding.cache.FileVoteCache;
-import com.vexsoftware.votifier.bungee.forwarding.cache.MemoryVoteCache;
-import com.vexsoftware.votifier.bungee.forwarding.cache.VoteCache;
-import com.vexsoftware.votifier.bungee.forwarding.proxy.ProxyForwardingVoteSource;
-import com.vexsoftware.votifier.model.Vote;
-import com.vexsoftware.votifier.net.VotifierSession;
-import com.vexsoftware.votifier.net.protocol.VoteInboundHandler;
-import com.vexsoftware.votifier.net.protocol.VotifierGreetingHandler;
-import com.vexsoftware.votifier.net.protocol.VotifierProtocolDifferentiator;
-import com.vexsoftware.votifier.net.protocol.v1crypto.RSAIO;
-import com.vexsoftware.votifier.net.protocol.v1crypto.RSAKeygen;
-import com.vexsoftware.votifier.util.KeyCreator;
-import com.vexsoftware.votifier.util.TokenUtil;
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.plugin.Plugin;
-import net.md_5.bungee.config.Configuration;
-import net.md_5.bungee.config.ConfigurationProvider;
-import net.md_5.bungee.config.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.SocketAddress;
-import java.net.UnknownHostException;
-import java.nio.charset.StandardCharsets;
-import java.security.Key;
-import java.security.KeyPair;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executors;
-import java.util.concurrent.FutureTask;
-import java.util.logging.Level;
-
-public class NuVotifier extends Plugin implements VoteHandler, VotifierPlugin {
-
-    /**
-     * The server channel.
-     */
-    private Channel serverChannel;
-
-    /**
-     * The event group handling the channel.
-     */
-    private NioEventLoopGroup serverGroup;
-
-    /**
-     * The RSA key pair.
-     */
-    private KeyPair keyPair;
-
-    /**
-     * Debug mode flag
-     */
-    private boolean debug;
-
-    /**
-     * Keys used for websites.
-     */
-    private Map<String, Key> tokens = new HashMap<>();
-
-    /**
-     * Method used to forward votes to downstream servers
-     */
-    private ForwardingVoteSource forwardingMethod;
-
-    @Override
-    public void onEnable() {
-        if (!getDataFolder().exists()) {
-            getDataFolder().mkdir();
-        }
-
-        // Handle configuration.
-        File config = new File(getDataFolder() + "/config.yml");
-        File rsaDirectory = new File(getDataFolder() + "/rsa");
-        Configuration configuration;
-
-        if (!config.exists()) {
-            try {
-                // First time run - do some initialization.
-                getLogger().info("Configuring Votifier for the first time...");
-
-                // Initialize the configuration file.
-                config.createNewFile();
-
-                String cfgStr = new String(ByteStreams.toByteArray(getResourceAsStream("bungeeConfig.yml")), StandardCharsets.UTF_8);
-                String token = TokenUtil.newToken();
-                cfgStr = cfgStr.replace("%default_token%", token);
-                Files.write(cfgStr, config, StandardCharsets.UTF_8);
-
-                /*
-                 * Remind hosted server admins to be sure they have the right
-                 * port number.
-                 */
-                getLogger().info("------------------------------------------------------------------------------");
-                getLogger().info("Assigning NuVotifier to listen on port 8192. If you are hosting BungeeCord on a");
-                getLogger().info("shared server please check with your hosting provider to verify that this port");
-                getLogger().info("is available for your use. Chances are that your hosting provider will assign");
-                getLogger().info("a different port, which you need to specify in config.yml");
-                getLogger().info("------------------------------------------------------------------------------");
-                getLogger().info("Assigning NuVotifier to listen to interface 0.0.0.0. This is usually alright,");
-                getLogger().info("however, if you want NuVotifier to only listen to one interface for security ");
-                getLogger().info("reasons (or you use a shared host), you may change this in the config.yml.");
-                getLogger().info("------------------------------------------------------------------------------");
-                getLogger().info("Your default Votifier token is " + token + ".");
-                getLogger().info("You will need to provide this token when you submit your server to a voting");
-                getLogger().info("list.");
-                getLogger().info("------------------------------------------------------------------------------");
-            } catch (Exception ex) {
-                throw new RuntimeException("Unable to create configuration file", ex);
-            }
-        }
-
-        // Load the configuration.
-        try {
-            configuration = ConfigurationProvider.getProvider(YamlConfiguration.class).load(config);
-        } catch (IOException e) {
-            throw new RuntimeException("Unable to load configuration", e);
-        }
-
-        /*
-         * Create RSA directory and keys if it does not exist; otherwise, read
-         * keys.
-         */
-        try {
-            if (!rsaDirectory.exists()) {
-                rsaDirectory.mkdir();
-                keyPair = RSAKeygen.generate(2048);
-                RSAIO.save(rsaDirectory, keyPair);
-            } else {
-                keyPair = RSAIO.load(rsaDirectory);
-            }
-        } catch (Exception ex) {
-            throw new RuntimeException("Error reading RSA tokens", ex);
-        }
-
-        // Load Votifier tokens.
-        Configuration tokenSection = configuration.getSection("tokens");
-
-        if (configuration.get("tokens") != null) {
-            for (String s : tokenSection.getKeys()) {
-                tokens.put(s, KeyCreator.createKeyFrom(tokenSection.getString(s)));
-                getLogger().info("Loaded token for website: " + s);
-            }
-        } else {
-            String token = TokenUtil.newToken();
-            configuration.set("tokens", ImmutableMap.of("default", token));
-            tokens.put("default", KeyCreator.createKeyFrom(token));
-            try {
-                ConfigurationProvider.getProvider(YamlConfiguration.class).save(configuration, config);
-            } catch (IOException e) {
-                throw new RuntimeException("Error generating Votifier token", e);
-            }
-            getLogger().info("------------------------------------------------------------------------------");
-            getLogger().info("No tokens were found in your configuration, so we've generated one for you.");
-            getLogger().info("Your default Votifier token is " + token + ".");
-            getLogger().info("You will need to provide this token when you submit your server to a voting");
-            getLogger().info("list.");
-            getLogger().info("------------------------------------------------------------------------------");
-        }
-
-        // Initialize the receiver.
-        final String host = configuration.getString("host", "0.0.0.0");
-        final int port = configuration.getInt("port", 8192);
-        debug = configuration.getBoolean("debug", false);
-        if (debug)
-            getLogger().info("DEBUG mode enabled!");
-
-        final boolean disablev1 = configuration.getBoolean("disable-v1-protocol");
-        if (disablev1) {
-            getLogger().info("------------------------------------------------------------------------------");
-            getLogger().info("Votifier protocol v1 parsing has been disabled. Most voting websites do not");
-            getLogger().info("currently support the modern Votifier protocol in NuVotifier.");
-            getLogger().info("------------------------------------------------------------------------------");
-        }
-
-        // Must set up server asynchronously due to BungeeCord goofiness.
-        FutureTask<?> initTask = new FutureTask<>(Executors.callable(new Runnable() {
-            @Override
-            public void run() {
-                serverGroup = new NioEventLoopGroup(2);
-
-                new ServerBootstrap()
-                        .channel(NioServerSocketChannel.class)
-                        .group(serverGroup)
-                        .childHandler(new ChannelInitializer<NioSocketChannel>() {
-                            @Override
-                            protected void initChannel(NioSocketChannel channel) throws Exception {
-                                channel.attr(VotifierSession.KEY).set(new VotifierSession());
-                                channel.attr(VotifierPlugin.KEY).set(NuVotifier.this);
-                                channel.pipeline().addLast("greetingHandler", new VotifierGreetingHandler());
-                                channel.pipeline().addLast("protocolDifferentiator", new VotifierProtocolDifferentiator(false, !disablev1));
-                                channel.pipeline().addLast("voteHandler", new VoteInboundHandler(NuVotifier.this));
-                            }
-                        })
-                        .bind(host, port)
-                        .addListener(new ChannelFutureListener() {
-                            @Override
-                            public void operationComplete(ChannelFuture future) throws Exception {
-                                if (future.isSuccess()) {
-                                    serverChannel = future.channel();
-                                    getLogger().info("Votifier enabled on socket "+serverChannel.localAddress()+".");
-                                } else {
-                                    SocketAddress socketAddress = future.channel().localAddress();
-                                    if (socketAddress == null) {
-                                        socketAddress = new InetSocketAddress(host, port);
-                                    }
-                                    getLogger().log(Level.SEVERE, "Votifier was not able to bind to " + socketAddress, future.cause());
-                                }
-                            }
-                        });
-            }
-        }));
-        getProxy().getScheduler().runAsync(this, initTask);
-        try {
-            initTask.get();
-        } catch (InterruptedException | ExecutionException e) {
-            throw new RuntimeException("Unable to start server", e);
-        }
-
-        Configuration fwdCfg = configuration.getSection("forwarding");
-        String fwdMethod = fwdCfg.getString("method", "none").toLowerCase();
-        if ("none".equals(fwdMethod)) {
-            getLogger().info("Method none selected for vote forwarding: Votes will not be forwarded to backend servers.");
-        } else if ("pluginmessaging".equals(fwdMethod)) {
-            String channel = fwdCfg.getString("pluginMessaging.channel", "NuVotifier");
-            String cacheMethod = fwdCfg.getString("pluginMessaging.cache", "file").toLowerCase();
-            VoteCache voteCache = null;
-            if ("none".equals(cacheMethod)) {
-                getLogger().info("Vote cache none selected for caching: votes that cannot be immediately delivered will be lost.");
-            } else if ("memory".equals(cacheMethod)) {
-                voteCache = new MemoryVoteCache(ProxyServer.getInstance().getServers().size());
-                getLogger().info("Using in-memory cache for votes that are not able to be delivered.");
-            } else if ("file".equals(cacheMethod)) {
-                try {
-                    voteCache = new FileVoteCache(ProxyServer.getInstance().getServers().size(), this, new File(getDataFolder(),
-                            fwdCfg.getString("pluginMessaging.file.name")));
-                } catch (IOException e) {
-                    getLogger().log(Level.SEVERE, "Unload to load file cache. Votes will be lost!", e);
-                }
-            }
-            if (!fwdCfg.getBoolean("pluginMessaging.onlySendToJoinedServer")) {
-
-                List<String> ignoredServers = fwdCfg.getStringList("pluginMessaging.excludedServers");
-
-                try {
-                    forwardingMethod = new PluginMessagingForwardingSource(channel, ignoredServers, this, voteCache);
-                    getLogger().info("Forwarding votes over PluginMessaging channel '" + channel + "' for vote forwarding!");
-                } catch (RuntimeException e) {
-                    getLogger().log(Level.SEVERE, "NuVotifier could not set up PluginMessaging for vote forwarding!", e);
-                }
-            } else {
-                try {
-                    String fallbackServer = fwdCfg.getString("pluginMessaging.joinedServerFallback", null);
-                    if (fallbackServer != null && fallbackServer.isEmpty()) fallbackServer = null;
-                    forwardingMethod = new OnlineForwardPluginMessagingForwardingSource(channel, this, voteCache, fallbackServer);
-                } catch (RuntimeException e) {
-                    getLogger().log(Level.SEVERE, "NuVotifier could not set up PluginMessaging for vote forwarding!", e);
-                }
-            }
-        } else if ("proxy".equals(fwdMethod)) {
-            Configuration serverSection = fwdCfg.getSection("proxy");
-            List<ProxyForwardingVoteSource.BackendServer> serverList = new ArrayList<>();
-            for (String s : serverSection.getKeys()) {
-                Configuration section = serverSection.getSection(s);
-                InetAddress address;
-                try {
-                    address = InetAddress.getByName(section.getString("address"));
-                } catch (UnknownHostException e) {
-                    getLogger().info("Address " + section.getString("address") + " couldn't be looked up. Ignoring!");
-                    continue;
-                }
-                ProxyForwardingVoteSource.BackendServer server = new ProxyForwardingVoteSource.BackendServer(s,
-                        new InetSocketAddress(address, section.getShort("port")),
-                        KeyCreator.createKeyFrom(section.getString("token",section.getString("key"))));
-                serverList.add(server);
-            }
-
-            forwardingMethod = new ProxyForwardingVoteSource(this, serverGroup, serverList, null);
-            getLogger().info("Forwarding votes from this NuVotifier instance to another NuVotifier server.");
-        } else {
-            getLogger().severe("No vote forwarding method '" + fwdMethod + "' known. Defaulting to noop implementation.");
-        }
-    }
-
-
-    @Override
-    public void onDisable() {
-        // Shut down the network handlers.
-        if (serverChannel != null)
-            serverChannel.close();
-        serverGroup.shutdownGracefully();
-
-        if (forwardingMethod != null) {
-            forwardingMethod.halt();
-        }
-
-        getLogger().info("Votifier disabled.");
-    }
-
-    @Override
-    public void onVoteReceived(final Vote vote, VotifierSession.ProtocolVersion protocolVersion) throws Exception {
-        if (debug) {
-            if (protocolVersion == VotifierSession.ProtocolVersion.ONE) {
-                getLogger().info("Got a protocol v1 vote record -> " + vote);
-            } else {
-                getLogger().info("Got a protocol v2 vote record -> " + vote);
-            }
-        }
-
-        getProxy().getScheduler().runAsync(this, new Runnable() {
-            @Override
-            public void run() {
-                getProxy().getPluginManager().callEvent(new VotifierEvent(vote));
-            }
-        });
-
-        if (forwardingMethod != null) {
-            getProxy().getScheduler().runAsync(this, new Runnable() {
-                @Override
-                public void run() {
-                    forwardingMethod.forward(vote);
-                }
-            });
-        }
-    }
-
-    @Override
-    public void onError(Channel channel, Throwable throwable) {
-        if (debug) {
-            getLogger().log(Level.SEVERE, "Unable to process vote from " + channel.remoteAddress(), throwable);
-        } else {
-            getLogger().log(Level.SEVERE, "Unable to process vote from " + channel.remoteAddress());
-        }
-    }
-
-    @Override
-    public Map<String, Key> getTokens() {
-        return tokens;
-    }
-
-    @Override
-    public KeyPair getProtocolV1Key() {
-        return keyPair;
-    }
-
-    @Override
-    public String getVersion() {
-        return getDescription().getVersion();
-    }
-
-    public boolean isDebug() {
-        return debug;
-    }
-}

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/events/VotifierEvent.java

@@ -1,23 +0,0 @@
-package com.vexsoftware.votifier.bungee.events;
-
-import com.vexsoftware.votifier.model.Vote;
-import net.md_5.bungee.api.plugin.Event;
-
-/**
- * {@code VotifierEvent} is a custom BungeeCord event class that is sent
- * asynchronously allowing other plugins to listen for votes.
- */
-public class VotifierEvent extends Event {
-    /**
-     * The vote.
-     **/
-    private final Vote vote;
-
-    public VotifierEvent(Vote vote) {
-        this.vote = vote;
-    }
-
-    public Vote getVote() {
-        return vote;
-    }
-}

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/forwarding/OnlineForwardPluginMessagingForwardingSource.java

@@ -1,47 +0,0 @@
-package com.vexsoftware.votifier.bungee.forwarding;
-
-import com.vexsoftware.votifier.bungee.NuVotifier;
-import com.vexsoftware.votifier.bungee.forwarding.cache.VoteCache;
-import com.vexsoftware.votifier.model.Vote;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.connection.ProxiedPlayer;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.api.event.ServerConnectedEvent;
-import net.md_5.bungee.event.EventHandler;
-
-/**
- * @author Joseph Hirschfeld
- * @date 12/31/2015
- */
-public final class OnlineForwardPluginMessagingForwardingSource extends PluginMessagingForwardingSource {
-    public OnlineForwardPluginMessagingForwardingSource(String channel, NuVotifier nuVotifier, VoteCache cache, String fallbackServer) {
-        super(channel, nuVotifier, cache);
-        this.fallbackServer = fallbackServer;
-    }
-
-    private final String fallbackServer;
-
-    @Override
-    public void forward(Vote v) {
-        ProxiedPlayer p = ProxyServer.getInstance().getPlayer(v.getUsername());
-        if (p == null || !forwardSpecific(p.getServer().getInfo(), v)) {
-            ServerInfo serverInfo = ProxyServer.getInstance().getServers().get(fallbackServer);
-            if (serverInfo == null || !forwardSpecific(serverInfo, v)) {
-                attemptToAddToCache(v, fallbackServer);
-            }
-        }
-    }
-
-    // The below is to allow us to share code since the event handlers from the parent class don't get
-    // picked up.
-    @EventHandler
-    public void onPluginMessage(PluginMessageEvent e) {
-        if (e.getTag().equals(channel)) e.setCancelled(true);
-    }
-
-    @EventHandler
-    public void onServerConnected(final ServerConnectedEvent e) { //Attempt to resend any votes that were previously cached.
-        handleServerConnected(e);
-    }
-}

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/forwarding/PluginMessagingForwardingSource.java

@@ -1,123 +0,0 @@
-package com.vexsoftware.votifier.bungee.forwarding;
-
-import com.vexsoftware.votifier.bungee.NuVotifier;
-import com.vexsoftware.votifier.bungee.forwarding.cache.FileVoteCache;
-import com.vexsoftware.votifier.bungee.forwarding.cache.VoteCache;
-import com.vexsoftware.votifier.model.Vote;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ServerInfo;
-import net.md_5.bungee.api.event.PluginMessageEvent;
-import net.md_5.bungee.api.event.ServerConnectedEvent;
-import net.md_5.bungee.api.plugin.Listener;
-import net.md_5.bungee.event.EventHandler;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.Collection;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-
-/**
- * Created by Joe Hirschfeld on 10/20/2015.
- */
-public class PluginMessagingForwardingSource implements ForwardingVoteSource, Listener {
-
-    public PluginMessagingForwardingSource(String channel, List<String> ignoredServers, NuVotifier nuVotifier, VoteCache cache) {
-        ProxyServer.getInstance().registerChannel(channel);
-        ProxyServer.getInstance().getPluginManager().registerListener(nuVotifier, this);
-        this.channel = channel;
-        this.nuVotifier = nuVotifier;
-        this.cache = cache;
-        this.ignoredServers = ignoredServers;
-    }
-
-    protected PluginMessagingForwardingSource(String channel, NuVotifier nuVotifier, VoteCache voteCache) {
-        this(channel, null, nuVotifier, voteCache);
-    }
-
-    protected final NuVotifier nuVotifier;
-    protected final String channel;
-    protected final VoteCache cache;
-    protected final List<String> ignoredServers;
-
-    @Override
-    public void forward(Vote v) {
-        byte[] rawData = v.serialize().toString().getBytes(StandardCharsets.UTF_8);
-        for (ServerInfo s : ProxyServer.getInstance().getServers().values()) {
-            if (ignoredServers != null && ignoredServers.contains(s.getName())) continue;
-            if (!forwardSpecific(s, rawData)) attemptToAddToCache(v, s.getName());
-        }
-    }
-
-    protected boolean forwardSpecific(ServerInfo connection, Vote vote) {
-        byte[] rawData = vote.serialize().toString().getBytes(StandardCharsets.UTF_8);
-        return connection.sendData(channel, rawData, false);
-    }
-
-    private boolean forwardSpecific(ServerInfo connection, byte[] data) {
-        return connection.sendData(channel, data, false);
-    }
-
-    @Override
-    public void halt() {
-        ProxyServer.getInstance().unregisterChannel(channel);
-
-        if (cache != null && cache instanceof FileVoteCache) {
-            try {
-                ((FileVoteCache) cache).halt();
-            } catch (IOException e) {
-                nuVotifier.getLogger().log(Level.SEVERE, "Unable to save cached votes, votes will be lost.", e);
-            }
-        }
-    }
-
-    @EventHandler
-    public void onPluginMessage(PluginMessageEvent e) {
-        if (e.getTag().equals(channel)) e.setCancelled(true);
-    }
-
-    @EventHandler
-    public void onServerConnected(final ServerConnectedEvent e) { //Attempt to resend any votes that were previously cached.
-        handleServerConnected(e);
-    }
-
-    protected void handleServerConnected(final ServerConnectedEvent e) {
-        if (cache == null) return;
-        final String serverName = e.getServer().getInfo().getName();
-        final Collection<Vote> cachedVotes = cache.evict(serverName);
-        if (!cachedVotes.isEmpty()) {
-            nuVotifier.getProxy().getScheduler().schedule(nuVotifier, new Runnable() {
-                @Override
-                public void run() {
-                    int evicted = 0;
-                    int unsuccessfulEvictions = 0;
-                    for (Vote v : cachedVotes) {
-                        if (forwardSpecific(e.getServer().getInfo(), v)) {
-                            evicted++;
-                        } else {
-                            // Re-add to cache to send later.
-                            cache.addToCache(v, serverName);
-                            unsuccessfulEvictions++;
-                        }
-                    }
-                    if (nuVotifier.isDebug()) {
-                        nuVotifier.getLogger().info("Successfully evicted " + evicted + " votes to server '" + serverName + "'.");
-                        if (unsuccessfulEvictions > 0) {
-                            nuVotifier.getLogger().info("Held " + unsuccessfulEvictions + " votes for server '" + serverName + "'.");
-                        }
-                    }
-                }
-            }, 1, TimeUnit.SECONDS);
-        }
-    }
-
-    protected void attemptToAddToCache(Vote v, String server) {
-        if (cache != null) {
-            cache.addToCache(v, server);
-            if (nuVotifier.isDebug())
-                nuVotifier.getLogger().info("Added to forwarding cache: " + v + " -> " + server);
-        } else if (nuVotifier.isDebug())
-            nuVotifier.getLogger().severe("Could not immediately send vote to backend, vote lost! " + v + " -> " + server);
-    }
-}

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/forwarding/cache/FileVoteCache.java

@@ -1,87 +0,0 @@
-package com.vexsoftware.votifier.bungee.forwarding.cache;
-
-import com.google.common.io.Files;
-import com.vexsoftware.votifier.model.Vote;
-import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.plugin.Plugin;
-import net.md_5.bungee.api.scheduler.ScheduledTask;
-import org.json.JSONArray;
-import org.json.JSONObject;
-
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-
-public class FileVoteCache extends MemoryVoteCache {
-
-    private final File cacheFile;
-    private final ScheduledTask saveTask;
-
-    public FileVoteCache(int initialMemorySize, final Plugin plugin, File cacheFile) throws IOException {
-        super(initialMemorySize);
-        this.cacheFile = cacheFile;
-        load();
-
-        saveTask = ProxyServer.getInstance().getScheduler().schedule(plugin, new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    save();
-                } catch (IOException e) {
-                    plugin.getLogger().log(Level.SEVERE, "Unable to save cached votes, votes will be lost if you restart.", e);
-                }
-            }
-        }, 3, 3, TimeUnit.MINUTES);
-    }
-
-    private void load() throws IOException {
-        if (cacheFile.exists()) {
-            // Load the cache from disk
-            JSONObject object = new JSONObject(Files.toString(cacheFile, StandardCharsets.UTF_8));
-
-            // Deserialize all votes contained
-            for (Object server : object.keySet()) {
-                JSONArray voteArray = object.optJSONArray(((String) server));
-                if (voteArray == null) continue;
-                Set<Vote> votes = new LinkedHashSet<>(voteArray.length());
-                for (int i = 0; i < voteArray.length(); i++) {
-                    votes.add(new Vote(voteArray.getJSONObject(i)));
-                }
-                voteCache.put(((String) server), votes);
-            }
-        } else {
-            cacheFile.createNewFile();
-        }
-    }
-
-    public void save() throws IOException {
-        cacheLock.lock();
-        // Create a copy of the votes.
-        JSONObject votesObject = new JSONObject();
-        for (Map.Entry<String, Collection<Vote>> entry : voteCache.entrySet()) {
-            JSONArray array = new JSONArray();
-            for (Vote vote : entry.getValue()) {
-                array.put(vote.serialize());
-            }
-            votesObject.put(entry.getKey(), array);
-        }
-        cacheLock.unlock();
-
-        try (BufferedWriter writer = Files.newWriter(cacheFile, StandardCharsets.UTF_8)) {
-            votesObject.write(writer);
-        }
-    }
-
-    public void halt() throws IOException {
-        saveTask.cancel();
-        save();
-    }
-
-}

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/forwarding/cache/MemoryVoteCache.java

@@ -1,49 +0,0 @@
-package com.vexsoftware.votifier.bungee.forwarding.cache;
-
-import com.google.common.collect.ImmutableSet;
-import com.vexsoftware.votifier.model.Vote;
-
-import java.util.*;
-import java.util.concurrent.locks.ReentrantLock;
-
-/**
- * Created by Joe Hirschfeld on 10/20/2015.
- */
-public class MemoryVoteCache implements VoteCache {
-
-    public MemoryVoteCache(int initialSize) {
-        voteCache = new HashMap<>(initialSize);
-    }
-
-    protected final Map<String, Collection<Vote>> voteCache;
-
-    protected final ReentrantLock cacheLock = new ReentrantLock();
-
-    @Override
-    public Collection<String> getCachedServers() {
-        cacheLock.lock();
-        Set<String> servers = ImmutableSet.copyOf(voteCache.keySet());
-        cacheLock.unlock();
-        return servers;
-    }
-
-    @Override
-    public void addToCache(Vote v, String server) {
-        cacheLock.lock();
-        Collection<Vote> voteCollection = voteCache.get(server);
-        if (voteCollection == null) {
-            voteCollection = new LinkedHashSet<>();
-            voteCache.put(server, voteCollection);
-        }
-        voteCollection.add(v);
-        cacheLock.unlock();
-    }
-
-    @Override
-    public Collection<Vote> evict(String server) {
-        cacheLock.lock();
-        Collection<Vote> fromCollection = voteCache.remove(server);
-        cacheLock.unlock();
-        return fromCollection != null ? ImmutableSet.copyOf(fromCollection) : ImmutableSet.<Vote>of();
-    }
-}

bungeecord/src/main/java/com/vexsoftware/votifier/bungee/forwarding/proxy/ProxyForwardingVoteSource.java

@@ -1,140 +0,0 @@
-package com.vexsoftware.votifier.bungee.forwarding.proxy;
-
-import com.vexsoftware.votifier.bungee.NuVotifier;
-import com.vexsoftware.votifier.bungee.forwarding.ForwardingVoteSource;
-import com.vexsoftware.votifier.bungee.forwarding.cache.VoteCache;
-import com.vexsoftware.votifier.bungee.forwarding.proxy.client.VotifierProtocol2Encoder;
-import com.vexsoftware.votifier.bungee.forwarding.proxy.client.VotifierProtocol2HandshakeHandler;
-import com.vexsoftware.votifier.bungee.forwarding.proxy.client.VotifierResponseHandler;
-import com.vexsoftware.votifier.model.Vote;
-import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelFutureListener;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.nio.NioSocketChannel;
-import io.netty.handler.codec.DelimiterBasedFrameDecoder;
-import io.netty.handler.codec.Delimiters;
-import io.netty.handler.codec.string.StringDecoder;
-import io.netty.handler.timeout.ReadTimeoutHandler;
-
-import java.net.InetSocketAddress;
-import java.nio.charset.StandardCharsets;
-import java.security.Key;
-import java.util.List;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Level;
-
-public class ProxyForwardingVoteSource implements ForwardingVoteSource {
-    private static final int MAX_RETRIES = 5;
-    private final NuVotifier plugin;
-    private final NioEventLoopGroup eventLoopGroup;
-    private final List<BackendServer> backendServers;
-    private final VoteCache voteCache;
-
-    private static final StringDecoder STRING_DECODER = new StringDecoder(StandardCharsets.US_ASCII);
-
-    public ProxyForwardingVoteSource(NuVotifier plugin, NioEventLoopGroup eventLoopGroup, List<BackendServer> backendServers, VoteCache voteCache) {
-        this.plugin = plugin;
-        this.eventLoopGroup = eventLoopGroup;
-        this.backendServers = backendServers;
-        this.voteCache = voteCache;
-    }
-
-    @Override
-    public void forward(Vote v) {
-        for (final BackendServer server : backendServers) {
-            forwardVote(server, v, 0);
-        }
-    }
-
-    private int fib(int t) {
-        if (t <= 1) return 1;
-        return fib(t - 2) + fib(t - 1);
-    }
-
-    private void forwardVote(final BackendServer server, final Vote v, final int tries) {
-        new Bootstrap()
-                .channel(NioSocketChannel.class)
-                .group(eventLoopGroup)
-                .handler(new ChannelInitializer<NioSocketChannel>() {
-                    @Override
-                    protected void initChannel(NioSocketChannel channel) throws Exception {
-                        channel.pipeline().addLast(new DelimiterBasedFrameDecoder(256, true, Delimiters.lineDelimiter()));
-                        channel.pipeline().addLast(new ReadTimeoutHandler(8, TimeUnit.SECONDS));
-                        channel.pipeline().addLast(STRING_DECODER);
-                        channel.pipeline().addLast(new VotifierProtocol2Encoder(server.key));
-                        channel.pipeline().addLast(new VotifierProtocol2HandshakeHandler(v, new VotifierResponseHandler() {
-                            @Override
-                            public void onSuccess() {
-                                if (plugin.isDebug()) {
-                                    plugin.getLogger().info("Successfully forwarded vote " + v + " to " + server.address + ".");
-                                }
-                            }
-
-                            @Override
-                            public void onFailure(Throwable error) {
-                                handleFailure(server, v, error, tries);
-                            }
-                        }, plugin));
-                    }
-                })
-                .connect(server.address)
-                .addListener(new ChannelFutureListener() {
-                    @Override
-                    public void operationComplete(ChannelFuture future) throws Exception {
-                        if (!future.isSuccess()) {
-                            handleFailure(server, v, future.cause(), tries);
-                        }
-                    }
-                });
-    }
-
-    private void handleFailure(final BackendServer server, final Vote v, Throwable cause, final int tries) {
-        int nextDelay = fib(tries + 1);
-        boolean willRetry = tries < MAX_RETRIES;
-
-        String msg = "Unable to send vote to " + server.address + ".";
-        if (willRetry) {
-            msg += " Will retry sending in " + nextDelay + " second(s).";
-        } else {
-            if (voteCache == null) {
-                msg += " This vote will be lost!";
-            } else {
-                voteCache.addToCache(v, server.name);
-            }
-        }
-
-        if (plugin.isDebug()) {
-            plugin.getLogger().log(Level.SEVERE, msg, cause);
-        } else {
-            plugin.getLogger().log(Level.SEVERE, msg);
-        }
-
-        if (willRetry) {
-            plugin.getProxy().getScheduler().schedule(plugin, new Runnable() {
-                @Override
-                public void run() {
-                    forwardVote(server, v, tries + 1);
-                }
-            }, nextDelay, TimeUnit.SECONDS);
-        }
-    }
-
-    @Override
-    public void halt() {
-
-    }
-
-    public static class BackendServer {
-        private final String name;
-        private final InetSocketAddress address;
-        private final Key key;
-
-        public BackendServer(String name, InetSocketAddress address, Key key) {
-            this.name = name;
-            this.address = address;
-            this.key = key;
-        }
-    }
-}

bungeecord/src/main/resources/bungee.yml

@@ -1,4 +0,0 @@
-name: NuVotifier
-main: com.vexsoftware.votifier.bungee.NuVotifier
-version: maven-version-number
-author: blakeman8192, Kramer, tuxed

bungeecord/src/main/resources/bungeeConfig.yml

@@ -1,65 +0,0 @@
-# The IP to listen to. Use 0.0.0.0 if you wish to listen to all interfaces on your server. (All IP addresses)
-# This defaults to the IP you have configured your server to listen on, or 0.0.0.0 if you have not configured this.
-host: 0.0.0.0
-
-# Port to listen for new votes on
-port: 8192
-
-# Whether or not to print debug messages. In a production system, this should be set to false.
-# This is useful when initially setting up NuVotifier to ensure votes are being delivered.
-debug: false
-
-# All tokens, labeled by the serviceName of each server list.
-tokens:
-  # Default token for all server lists, if another isn't supplied.
-  default: %default_token%
-
-# Setting this option to true will disable handling of Protocol v1 packets. While the old protocol is not secure, this
-# option is currently not recommended as most voting sites only support the old protocol at present.
-disable-v1-protocol: false
-
-# Configuration section for all vote forwarding to NuVotifier
-forwarding:
-  # Sets whether to set up a remote method for fowarding. Supported methods:
-  # - none - Does not set up a forwarding method.
-  # - pluginMessaging - Sets up plugin messaging.
-  # - proxy - Proxies votes to other NuVotifier servers from this server.
-  method: none
-  pluginMessaging:
-    channel: NuVotifier
-
-    #Only send votes to certain servers. If a server is present on excludedServers, then votes will NOT be forwarded
-    #to them. If excludedServers is not present, votes will be sent to all servers.
-    #If onlySendToJoinedServer is true, this option is ignored.
-
-    #excludedServers:
-    #- server1
-    #- server2
-
-
-    # Sets which cache to use if there are no players on the server that the vote is being sent to. Supported caches:
-    # - none - Votes will simply be lost when no players are present on the server.
-    # - memory - Votes will be cached in memory when no players are present. When Bungee is restarted, the votes will be lost.
-    #   This method is NOT recommended for production systems!
-    # - file - Votes will be saved to a local file every 3 minutes and on shutdown and reloaded when Bungee is restarted. This is suitable for
-    #   most set ups.
-    cache: file
-    # Only sends the vote to the server in which the player is currently joined.
-    onlySendToJoinedServer: false
-    #Sets which server to send the vote in the event the player is not online when the vote is cast
-    #If you do not want the vote forwarded to a fallback, set this value to empty ('')
-    #ONLY USED IF onlySendToJoinedServer is true!!
-    joinedServerFallback: 'Hub'
-    # Options for file caching.
-    file:
-      name: cached-votes.json
-  # Specify servers to proxy votes for.
-  proxy:
-    Hub:
-      address: 127.0.0.1
-      port: 8193
-      token: MyKeyHere
-    Hub2:
-      address: 127.0.0.1
-      port: 8194
-      token: AnotherKeyHere

common/.gitignore

@@ -0,0 +1 @@
+/bin/

common/pom.xml

@@ -1,39 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <parent>
-        <artifactId>nuvotifier</artifactId>
-        <groupId>com.vexsoftware</groupId>
-        <version>2.3.2.2</version>
-    </parent>
-    <modelVersion>4.0.0</modelVersion>
-
-    <artifactId>nuvotifier-common</artifactId>
-
-    <dependencies>
-        <!-- Netty Dependency -->
-        <dependency>
-            <groupId>io.netty</groupId>
-            <artifactId>netty-handler</artifactId>
-            <version>4.0.31.Final</version>
-            <type>jar</type>
-            <scope>compile</scope>
-        </dependency>
-        <!-- JSON Dependency -->
-        <dependency>
-            <groupId>org.json</groupId>
-            <artifactId>json</artifactId>
-            <version>20140107</version>
-            <type>jar</type>
-            <scope>compile</scope>
-        </dependency>
-        <!-- JUnit, for tests -->
-        <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
-            <version>4.12</version>
-            <scope>test</scope>
-        </dependency>
-    </dependencies>
-</project>

common/src/main/java/com/vexsoftware/votifier/VoteHandler.java

@@ -2,10 +2,13 @@ package com.vexsoftware.votifier;
 
 import com.vexsoftware.votifier.model.Vote;
 import com.vexsoftware.votifier.net.VotifierSession;
-import io.netty.channel.Channel;
 
 public interface VoteHandler {
-    void onVoteReceived(Vote vote, VotifierSession.ProtocolVersion protocolVersion) throws Exception;
 
-    void onError(Channel channel, Throwable throwable);
+    void onVoteReceived(Vote vote, VotifierSession.ProtocolVersion protocolVersion, String remoteAddress)
+            throws Exception;
+
+    default void onError(Throwable throwable, boolean voteAlreadyCompleted, String remoteAddress) {
+        throw new RuntimeException("Unimplemented onError handler");
+    }
 }

common/src/main/java/com/vexsoftware/votifier/VotifierPlugin.java

@@ -1,17 +0,0 @@
-package com.vexsoftware.votifier;
-
-import io.netty.util.AttributeKey;
-
-import java.security.Key;
-import java.security.KeyPair;
-import java.util.Map;
-
-public interface VotifierPlugin {
-    AttributeKey<VotifierPlugin> KEY = AttributeKey.valueOf("votifier_plugin");
-
-    Map<String, Key> getTokens();
-
-    KeyPair getProtocolV1Key();
-
-    String getVersion();
-}

common/src/main/java/com/vexsoftware/votifier/net/VotifierServerBootstrap.java

@@ -0,0 +1,137 @@
+package com.vexsoftware.votifier.net;
+
+import com.vexsoftware.votifier.net.protocol.VoteInboundHandler;
+import com.vexsoftware.votifier.net.protocol.VotifierGreetingHandler;
+import com.vexsoftware.votifier.net.protocol.VotifierProtocolDifferentiator;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.support.forwarding.cache.VoteCache;
+import com.vexsoftware.votifier.support.forwarding.proxy.ProxyForwardingVoteSource;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.epoll.Epoll;
+import io.netty.channel.epoll.EpollEventLoopGroup;
+import io.netty.channel.epoll.EpollServerSocketChannel;
+import io.netty.channel.epoll.EpollSocketChannel;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.util.concurrent.FastThreadLocalThread;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+public class VotifierServerBootstrap {
+    private static final boolean USE_EPOLL = Epoll.isAvailable();
+
+    private final String host;
+    private final int port;
+    private final EventLoopGroup bossLoopGroup;
+    private final EventLoopGroup eventLoopGroup;
+    private final VotifierPlugin plugin;
+    private final boolean v1Disable;
+
+    private Channel serverChannel;
+
+    public VotifierServerBootstrap(String host, int port, VotifierPlugin plugin, boolean v1Disable) {
+        this.host = host;
+        this.port = port;
+        this.plugin = plugin;
+        this.v1Disable = v1Disable;
+        if (USE_EPOLL) {
+            this.bossLoopGroup = new EpollEventLoopGroup(1, createThreadFactory("Votifier epoll boss"));
+            this.eventLoopGroup = new EpollEventLoopGroup(3, createThreadFactory("Votifier epoll worker"));
+            plugin.getPluginLogger().info("Using epoll transport to accept votes.");
+        } else {
+            this.bossLoopGroup = new NioEventLoopGroup(1, createThreadFactory("Votifier NIO boss"));
+            this.eventLoopGroup = new NioEventLoopGroup(3, createThreadFactory("Votifier NIO worker"));
+            plugin.getPluginLogger().info("Using NIO transport to accept votes.");
+        }
+    }
+
+    private static ThreadFactory createThreadFactory(String name) {
+        return runnable -> {
+            FastThreadLocalThread thread = new FastThreadLocalThread(runnable, name);
+            thread.setDaemon(true);
+            return thread;
+        };
+    }
+
+    public void start(Consumer<Throwable> error) {
+        Objects.requireNonNull(error, "error");
+
+        VoteInboundHandler voteInboundHandler = new VoteInboundHandler(plugin);
+
+        new ServerBootstrap()
+                .channel(USE_EPOLL ? EpollServerSocketChannel.class : NioServerSocketChannel.class)
+                .group(bossLoopGroup, eventLoopGroup)
+                .childHandler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel channel) {
+                        channel.attr(VotifierSession.KEY).set(new VotifierSession());
+                        channel.attr(VotifierPlugin.KEY).set(plugin);
+                        channel.pipeline().addLast("greetingHandler", VotifierGreetingHandler.INSTANCE);
+                        channel.pipeline()
+                                .addLast(
+                                        "protocolDifferentiator",
+                                        new VotifierProtocolDifferentiator(false, !v1Disable));
+                        channel.pipeline().addLast("voteHandler", voteInboundHandler);
+                    }
+                })
+                .bind(host, port)
+                .addListener((ChannelFutureListener) future -> {
+                    if (future.isSuccess()) {
+                        serverChannel = future.channel();
+                        plugin.getPluginLogger()
+                                .info("Votifier enabled on socket " + serverChannel.localAddress() + ".");
+                        error.accept(null);
+                    } else {
+                        SocketAddress socketAddress = future.channel().localAddress();
+                        if (socketAddress == null) {
+                            socketAddress = new InetSocketAddress(host, port);
+                        }
+                        plugin.getPluginLogger()
+                                .error("Votifier was not able to bind to " + socketAddress.toString(), future.cause());
+                        error.accept(future.cause());
+                    }
+                });
+    }
+
+    private Bootstrap client() {
+        return new Bootstrap()
+                .channel(USE_EPOLL ? EpollSocketChannel.class : NioSocketChannel.class)
+                .group(eventLoopGroup);
+    }
+
+    public ProxyForwardingVoteSource createForwardingSource(
+            List<ProxyForwardingVoteSource.BackendServer> backendServers, VoteCache voteCache) {
+        return new ProxyForwardingVoteSource(plugin, this::client, backendServers, voteCache);
+    }
+
+    public void shutdown() {
+        if (serverChannel != null) {
+            try {
+                serverChannel.close().syncUninterruptibly();
+            } catch (Exception e) {
+                plugin.getPluginLogger().error("Unable to shutdown server channel", e);
+            }
+        }
+        eventLoopGroup.shutdownGracefully();
+        bossLoopGroup.shutdownGracefully();
+
+        try {
+            bossLoopGroup.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
+            eventLoopGroup.awaitTermination(Long.MAX_VALUE, TimeUnit.MILLISECONDS);
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        }
+    }
+}

common/src/main/java/com/vexsoftware/votifier/net/VotifierSession.java

@@ -7,6 +7,7 @@ public class VotifierSession {
     public static final AttributeKey<VotifierSession> KEY = AttributeKey.valueOf("votifier_session");
     private ProtocolVersion version = ProtocolVersion.UNKNOWN;
     private final String challenge;
+    private boolean hasCompletedVote = false;
 
     public VotifierSession() {
         challenge = TokenUtil.newToken();
@@ -27,9 +28,26 @@ public class VotifierSession {
         return challenge;
     }
 
+    public void completeVote() {
+        if (hasCompletedVote) throw new IllegalStateException("Protocol completed vote twice!");
+
+        hasCompletedVote = true;
+    }
+
+    public boolean hasCompletedVote() {
+        return hasCompletedVote;
+    }
+
     public enum ProtocolVersion {
-        UNKNOWN,
-        ONE,
-        TWO
+        UNKNOWN("unknown"),
+        ONE("protocol v1"),
+        TWO("protocol v2"),
+        TEST("test");
+
+        public final String humanReadable;
+
+        ProtocolVersion(String hr) {
+            this.humanReadable = hr;
+        }
     }
 }

common/src/main/java/com/vexsoftware/votifier/net/protocol/VoteInboundHandler.java

@@ -1,49 +1,77 @@
 package com.vexsoftware.votifier.net.protocol;
 
+import com.google.gson.JsonObject;
 import com.vexsoftware.votifier.VoteHandler;
 import com.vexsoftware.votifier.model.Vote;
 import com.vexsoftware.votifier.net.VotifierSession;
+import com.vexsoftware.votifier.util.GsonInst;
 import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
-import org.json.JSONObject;
+import java.util.concurrent.atomic.AtomicLong;
 
+@ChannelHandler.Sharable
 public class VoteInboundHandler extends SimpleChannelInboundHandler<Vote> {
     private final VoteHandler handler;
+    private final AtomicLong lastError;
+    private final AtomicLong errorsSent;
 
     public VoteInboundHandler(VoteHandler handler) {
         this.handler = handler;
+        this.lastError = new AtomicLong();
+        this.errorsSent = new AtomicLong();
     }
 
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, final Vote vote) throws Exception {
         VotifierSession session = ctx.channel().attr(VotifierSession.KEY).get();
 
-        handler.onVoteReceived(vote, session.getVersion());
+        handler.onVoteReceived(
+                vote, session.getVersion(), ctx.channel().remoteAddress().toString());
+        session.completeVote();
 
         if (session.getVersion() == VotifierSession.ProtocolVersion.ONE) {
             ctx.close();
         } else {
-            JSONObject object = new JSONObject();
-            object.put("status", "ok");
-            ctx.writeAndFlush(object.toString() + "\r\n").addListener(ChannelFutureListener.CLOSE);
+            JsonObject object = new JsonObject();
+            object.addProperty("status", "ok");
+            ctx.writeAndFlush(GsonInst.gson.toJson(object) + "\r\n").addListener(ChannelFutureListener.CLOSE);
         }
     }
 
     @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         VotifierSession session = ctx.channel().attr(VotifierSession.KEY).get();
 
-        handler.onError(ctx.channel(), cause);
+        String remoteAddr = ctx.channel().remoteAddress().toString();
+        boolean hasCompletedVote = session.hasCompletedVote();
 
         if (session.getVersion() == VotifierSession.ProtocolVersion.TWO) {
-            JSONObject object = new JSONObject();
-            object.put("status", "error");
-            object.put("cause", cause.getClass().getSimpleName());
-            object.put("error", cause.getMessage());
-            ctx.writeAndFlush(object.toString() + "\r\n").addListener(ChannelFutureListener.CLOSE);
+            JsonObject object = new JsonObject();
+            object.addProperty("status", "error");
+            object.addProperty("cause", cause.getClass().getSimpleName());
+            object.addProperty("error", cause.getMessage());
+            ctx.writeAndFlush(GsonInst.gson.toJson(object) + "\r\n").addListener(ChannelFutureListener.CLOSE);
         } else {
             ctx.close();
         }
+
+        if (!willThrottleErrorLogging()) {
+            handler.onError(cause, hasCompletedVote, remoteAddr);
+        }
+    }
+
+    private boolean willThrottleErrorLogging() {
+        long lastErrorAt = this.lastError.get();
+        long now = System.currentTimeMillis();
+
+        if (lastErrorAt + 2000 >= now) {
+            return this.errorsSent.incrementAndGet() >= 5;
+        } else {
+            this.lastError.set(now);
+            this.errorsSent.set(0);
+            return false;
+        }
     }
 }

common/src/main/java/com/vexsoftware/votifier/net/protocol/VotifierGreetingHandler.java

@@ -1,24 +1,26 @@
 package com.vexsoftware.votifier.net.protocol;
 
-import com.vexsoftware.votifier.VotifierPlugin;
 import com.vexsoftware.votifier.net.VotifierSession;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
+import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
-
 import java.nio.charset.StandardCharsets;
 
 /**
  * Handles the Votifier greeting.
  */
+@ChannelHandler.Sharable
 public class VotifierGreetingHandler extends ChannelInboundHandlerAdapter {
-    @Override
-    public void channelActive(ChannelHandlerContext ctx) throws Exception {
-        VotifierSession session = ctx.channel().attr(VotifierSession.KEY).get();
-        VotifierPlugin plugin = ctx.channel().attr(VotifierPlugin.KEY).get();
+    public static final VotifierGreetingHandler INSTANCE = new VotifierGreetingHandler();
 
-        String version = "VOTIFIER " + plugin.getVersion() + " " + session.getChallenge() + "\n";
+    private VotifierGreetingHandler() {}
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) {
+        VotifierSession session = ctx.channel().attr(VotifierSession.KEY).get();
+        String version = "VOTIFIER 2 " + session.getChallenge() + "\n";
         ByteBuf versionBuf = Unpooled.copiedBuffer(version, StandardCharsets.UTF_8);
         ctx.writeAndFlush(versionBuf);
     }

common/src/main/java/com/vexsoftware/votifier/net/protocol/VotifierProtocol1Decoder.java

@@ -1,13 +1,14 @@
 package com.vexsoftware.votifier.net.protocol;
 
-import com.vexsoftware.votifier.VotifierPlugin;
 import com.vexsoftware.votifier.model.Vote;
 import com.vexsoftware.votifier.net.protocol.v1crypto.RSA;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.util.QuietException;
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufUtil;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
 import io.netty.handler.codec.CorruptedFrameException;
-
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 
@@ -17,32 +18,53 @@ import java.util.List;
 public class VotifierProtocol1Decoder extends ByteToMessageDecoder {
     @Override
     protected void decode(ChannelHandlerContext ctx, ByteBuf buf, List<Object> list) throws Exception {
-        if (buf.readableBytes() < 256) {
+        if (!ctx.channel().isActive()) {
+            buf.skipBytes(buf.readableBytes());
             return;
         }
 
-        byte[] block = new byte[buf.readableBytes()];
-        buf.getBytes(0, block);
-        // "Drain" the whole buffer
-        buf.readerIndex(buf.readableBytes());
+        if (buf.readableBytes() < 256) {
+            // The client might have not sent all the data yet, so don't eject the connection.
+            return;
+        }
+
+        if (buf.readableBytes() > 256) {
+            // They sent too much data - silently drop the connection.
+            buf.skipBytes(buf.readableBytes());
+            ctx.close();
+            return;
+        }
+
+        byte[] block = ByteBufUtil.getBytes(buf);
+        buf.skipBytes(buf.readableBytes());
 
         VotifierPlugin plugin = ctx.channel().attr(VotifierPlugin.KEY).get();
 
         try {
             block = RSA.decrypt(block, plugin.getProtocolV1Key().getPrivate());
         } catch (Exception e) {
-            throw new CorruptedFrameException("Could not decrypt data (is your key correct?)", e);
+            if (plugin.isDebug()) {
+                throw new CorruptedFrameException(
+                        "Could not decrypt data from " + ctx.channel().remoteAddress()
+                                + ". Make sure the public key on the list is correct.",
+                        e);
+            } else {
+                throw new QuietException("Could not decrypt data from "
+                        + ctx.channel().remoteAddress() + ". Make sure the public key on the list is correct.");
+            }
         }
 
         // Parse the string we received.
         String all = new String(block, StandardCharsets.US_ASCII);
         String[] split = all.split("\n");
         if (split.length < 5) {
-            throw new CorruptedFrameException("Not enough fields specified in vote.");
+            throw new QuietException("Not enough fields specified in vote. This is not a NuVotifier issue. Got "
+                    + split.length + " fields, but needed 5.");
         }
 
         if (!split[0].equals("VOTE")) {
-            throw new CorruptedFrameException("VOTE opcode not found");
+            throw new QuietException(
+                    "The VOTE opcode was not present. This is not a NuVotifier issue, but a bug with the server list.");
         }
 
         // Create the vote.

common/src/main/java/com/vexsoftware/votifier/net/protocol/VotifierProtocol2Decoder.java

@@ -1,24 +1,20 @@
 package com.vexsoftware.votifier.net.protocol;
 
-import com.vexsoftware.votifier.VotifierPlugin;
+import com.google.gson.JsonObject;
 import com.vexsoftware.votifier.model.Vote;
 import com.vexsoftware.votifier.net.VotifierSession;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.util.GsonInst;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.CorruptedFrameException;
 import io.netty.handler.codec.MessageToMessageDecoder;
-import org.json.JSONObject;
-
-import javax.crypto.Mac;
-import javax.crypto.spec.SecretKeySpec;
-import javax.xml.bind.DatatypeConverter;
 import java.nio.charset.StandardCharsets;
-import java.security.InvalidKeyException;
-import java.security.Key;
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
-import java.util.Arrays;
+import java.security.*;
+import java.util.Base64;
 import java.util.List;
 import java.util.UUID;
+import javax.crypto.Mac;
+import javax.crypto.spec.SecretKeySpec;
 
 /**
  * Decodes protocol 2 JSON votes.
@@ -28,42 +24,44 @@ public class VotifierProtocol2Decoder extends MessageToMessageDecoder<String> {
 
     @Override
     protected void decode(ChannelHandlerContext ctx, String s, List<Object> list) throws Exception {
-        JSONObject voteMessage = new JSONObject(s);
+        JsonObject voteMessage = GsonInst.gson.fromJson(s, JsonObject.class);
         VotifierSession session = ctx.channel().attr(VotifierSession.KEY).get();
 
         // Deserialize the payload.
-        JSONObject votePayload = new JSONObject(voteMessage.getString("payload"));
+        String payload = voteMessage.get("payload").getAsString();
+        JsonObject votePayload = GsonInst.gson.fromJson(payload, JsonObject.class);
 
         // Verify challenge.
-        if (!votePayload.getString("challenge").equals(session.getChallenge())) {
+        if (!votePayload.get("challenge").getAsString().equals(session.getChallenge())) {
             throw new CorruptedFrameException("Challenge is not valid");
         }
 
         // Verify that we have keys available.
         VotifierPlugin plugin = ctx.channel().attr(VotifierPlugin.KEY).get();
-        Key key = plugin.getTokens().get(votePayload.getString("serviceName"));
+        Key key = plugin.getTokens().get(votePayload.get("serviceName").getAsString());
 
         if (key == null) {
             key = plugin.getTokens().get("default");
             if (key == null) {
-                throw new RuntimeException("Unknown service '" + votePayload.getString("serviceName") + "'");
+                throw new RuntimeException(
+                        "Unknown service '" + votePayload.get("serviceName").getAsString() + "'");
             }
         }
 
         // Verify signature.
-        String sigHash = voteMessage.getString("signature");
-        byte[] sigBytes = DatatypeConverter.parseBase64Binary(sigHash);
+        String sigHash = voteMessage.get("signature").getAsString();
+        byte[] sigBytes = Base64.getDecoder().decode(sigHash);
 
-        if (!hmacEqual(sigBytes, voteMessage.getString("payload").getBytes(StandardCharsets.UTF_8), key)) {
+        if (!hmacEqual(sigBytes, payload.getBytes(StandardCharsets.UTF_8), key)) {
             throw new CorruptedFrameException("Signature is not valid (invalid token?)");
         }
 
         // Stopgap: verify the "uuid" field is valid, if provided.
         if (votePayload.has("uuid")) {
-            UUID.fromString(votePayload.getString("uuid"));
+            UUID.fromString(votePayload.get("uuid").getAsString());
         }
 
-        if (votePayload.getString("username").length() > 16) {
+        if (votePayload.get("username").getAsString().length() > 16) {
             throw new CorruptedFrameException("Username too long");
         }
 
@@ -74,7 +72,8 @@ public class VotifierProtocol2Decoder extends MessageToMessageDecoder<String> {
         ctx.pipeline().remove(this);
     }
 
-    private boolean hmacEqual(byte[] sig, byte[] message, Key key) throws NoSuchAlgorithmException, InvalidKeyException {
+    private boolean hmacEqual(byte[] sig, byte[] message, Key key)
+            throws NoSuchAlgorithmException, InvalidKeyException {
         // See https://www.nccgroup.trust/us/about-us/newsroom-and-events/blog/2011/february/double-hmac-verification/
         // This randomizes the byte order to make timing attacks more difficult.
         Mac mac = Mac.getInstance("HmacSHA256");
@@ -92,6 +91,6 @@ public class VotifierProtocol2Decoder extends MessageToMessageDecoder<String> {
         mac2.reset();
         byte[] realSig = mac2.doFinal(calculatedSig);
 
-        return Arrays.equals(clientSig, realSig);
+        return MessageDigest.isEqual(clientSig, realSig);
     }
 }

common/src/main/java/com/vexsoftware/votifier/net/protocol/VotifierProtocolDifferentiator.java

@@ -1,14 +1,13 @@
 package com.vexsoftware.votifier.net.protocol;
 
 import com.vexsoftware.votifier.net.VotifierSession;
+import com.vexsoftware.votifier.util.QuietException;
 import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
-import io.netty.handler.codec.CorruptedFrameException;
 import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
 import io.netty.handler.codec.string.StringDecoder;
 import io.netty.handler.codec.string.StringEncoder;
-
 import java.nio.charset.StandardCharsets;
 import java.util.List;
 
@@ -16,6 +15,9 @@ import java.util.List;
  * Attempts to determine if original protocol or protocol v2 is being used.
  */
 public class VotifierProtocolDifferentiator extends ByteToMessageDecoder {
+    private static final QuietException V2_ONLY =
+            new QuietException("This server only accepts well-formed Votifier v2 packets.");
+
     private static final short PROTOCOL_2_MAGIC = 0x733A;
     private final boolean testMode;
     private final boolean allowv1;
@@ -35,11 +37,7 @@ public class VotifierProtocolDifferentiator extends ByteToMessageDecoder {
             return;
         }
 
-        short readMagic = buf.readShort();
-
-        // Reset reader index again
-        buf.readerIndex(0);
-
+        short readMagic = buf.getShort(0);
         VotifierSession session = ctx.channel().attr(VotifierSession.KEY).get();
 
         if (readMagic == PROTOCOL_2_MAGIC) {
@@ -47,15 +45,28 @@ public class VotifierProtocolDifferentiator extends ByteToMessageDecoder {
             session.setVersion(VotifierSession.ProtocolVersion.TWO);
 
             if (!testMode) {
-                ctx.pipeline().addAfter("protocolDifferentiator", "protocol2LengthDecoder", new LengthFieldBasedFrameDecoder(1024, 2, 2, 0, 4));
-                ctx.pipeline().addAfter("protocol2LengthDecoder", "protocol2StringDecoder", new StringDecoder(StandardCharsets.UTF_8));
-                ctx.pipeline().addAfter("protocol2StringDecoder", "protocol2VoteDecoder", new VotifierProtocol2Decoder());
-                ctx.pipeline().addAfter("protocol2VoteDecoder", "protocol2StringEncoder", new StringEncoder(StandardCharsets.UTF_8));
+                ctx.pipeline()
+                        .addAfter(
+                                "protocolDifferentiator",
+                                "protocol2LengthDecoder",
+                                new LengthFieldBasedFrameDecoder(1024, 2, 2, 0, 4));
+                ctx.pipeline()
+                        .addAfter(
+                                "protocol2LengthDecoder",
+                                "protocol2StringDecoder",
+                                new StringDecoder(StandardCharsets.UTF_8));
+                ctx.pipeline()
+                        .addAfter("protocol2StringDecoder", "protocol2VoteDecoder", new VotifierProtocol2Decoder());
+                ctx.pipeline()
+                        .addAfter(
+                                "protocol2VoteDecoder",
+                                "protocol2StringEncoder",
+                                new StringEncoder(StandardCharsets.UTF_8));
                 ctx.pipeline().remove(this);
             }
         } else {
             if (!allowv1) {
-                throw new CorruptedFrameException("This server only accepts well-formed Votifier v2 packets.");
+                throw V2_ONLY;
             }
             // Probably Protocol v1 Vote Message
             session.setVersion(VotifierSession.ProtocolVersion.ONE);

common/src/main/java/com/vexsoftware/votifier/net/protocol/v1crypto/RSA.java

@@ -1,26 +1,26 @@
 /*
  * Copyright (C) 2011 Vex Software LLC
  * This file is part of Votifier.
- * 
+ *
  * Votifier is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * Votifier is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with Votifier.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package com.vexsoftware.votifier.net.protocol.v1crypto;
 
-import javax.crypto.Cipher;
 import java.security.PrivateKey;
 import java.security.PublicKey;
+import javax.crypto.Cipher;
 
 /**
  * Static RSA utility methods for encrypting and decrypting blocks of
@@ -57,5 +57,4 @@ public class RSA {
         cipher.init(Cipher.DECRYPT_MODE, key);
         return cipher.doFinal(data);
     }
-
 }

common/src/main/java/com/vexsoftware/votifier/net/protocol/v1crypto/RSAIO.java

@@ -1,26 +1,27 @@
 /*
  * Copyright (C) 2011 Vex Software LLC
  * This file is part of Votifier.
- * 
+ *
  * Votifier is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * Votifier is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with Votifier.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package com.vexsoftware.votifier.net.protocol.v1crypto;
 
-import javax.xml.bind.DatatypeConverter;
 import java.io.File;
 import java.io.FileOutputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.security.KeyFactory;
 import java.security.KeyPair;
@@ -28,6 +29,7 @@ import java.security.PrivateKey;
 import java.security.PublicKey;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.security.spec.X509EncodedKeySpec;
+import java.util.Base64;
 
 /**
  * Static utility methods for saving and loading RSA key pairs.
@@ -45,21 +47,31 @@ public class RSAIO {
         PrivateKey privateKey = keyPair.getPrivate();
         PublicKey publicKey = keyPair.getPublic();
 
-        // Store the public key.
-        X509EncodedKeySpec publicSpec = new X509EncodedKeySpec(
-                publicKey.getEncoded());
-        FileOutputStream out = new FileOutputStream(directory + "/public.key");
-        out.write(DatatypeConverter.printBase64Binary(publicSpec.getEncoded())
-                .getBytes());
-        out.close();
+        // Store the public and private keys.
+        X509EncodedKeySpec publicSpec = new X509EncodedKeySpec(publicKey.getEncoded());
+        PKCS8EncodedKeySpec privateSpec = new PKCS8EncodedKeySpec(privateKey.getEncoded());
+        try (FileOutputStream publicOut = new FileOutputStream(directory + "/public.key");
+                FileOutputStream privateOut = new FileOutputStream(directory + "/private.key")) {
 
-        // Store the private key.
-        PKCS8EncodedKeySpec privateSpec = new PKCS8EncodedKeySpec(
-                privateKey.getEncoded());
-        out = new FileOutputStream(directory + "/private.key");
-        out.write(DatatypeConverter.printBase64Binary(privateSpec.getEncoded())
-                .getBytes());
-        out.close();
+            publicOut.write(Base64.getEncoder().encode(publicSpec.getEncoded()));
+            privateOut.write(Base64.getEncoder().encode(privateSpec.getEncoded()));
+        }
+    }
+
+    public static byte[] readB64File(File directory, String name) throws IOException {
+        File f = new File(directory, name);
+        byte[] contents = Files.readAllBytes(f.toPath());
+        String strContents = new String(contents, StandardCharsets.US_ASCII);
+        strContents = strContents.trim();
+        try {
+            return Base64.getDecoder().decode(strContents);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException(
+                    "Base64 decoding exception: This is probably due to a corrupted file, "
+                            + "but in case it isn't, here is a b64 representation of what we read: "
+                            + new String(Base64.getEncoder().encode(contents), StandardCharsets.UTF_8),
+                    e);
+        }
     }
 
     /**
@@ -72,26 +84,17 @@ public class RSAIO {
      */
     public static KeyPair load(File directory) throws Exception {
         // Read the public key file.
-        File publicKeyFile = new File(directory + "/public.key");
-        byte[] encodedPublicKey = Files.readAllBytes(publicKeyFile.toPath());
-        encodedPublicKey = DatatypeConverter.parseBase64Binary(new String(
-                encodedPublicKey));
+        byte[] encodedPublicKey = readB64File(directory, "public.key");
 
         // Read the private key file.
-        File privateKeyFile = new File(directory + "/private.key");
-        byte[] encodedPrivateKey = Files.readAllBytes(privateKeyFile.toPath());
-        encodedPrivateKey = DatatypeConverter.parseBase64Binary(new String(
-                encodedPrivateKey));
+        byte[] encodedPrivateKey = readB64File(directory, "private.key");
 
         // Instantiate and return the key pair.
         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
-        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
-                encodedPublicKey);
+        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedPublicKey);
         PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
-        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
-                encodedPrivateKey);
+        PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(encodedPrivateKey);
         PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
         return new KeyPair(publicKey, privateKey);
     }
-
 }

common/src/main/java/com/vexsoftware/votifier/net/protocol/v1crypto/RSAKeygen.java

@@ -1,17 +1,17 @@
 /*
  * Copyright (C) 2011 Vex Software LLC
  * This file is part of Votifier.
- * 
+ *
  * Votifier is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- * 
+ *
  * Votifier is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU General Public License
  * along with Votifier.  If not, see <http://www.gnu.org/licenses/>.
  */
@@ -36,10 +36,8 @@ public class RSAKeygen {
      */
     public static KeyPair generate(int bits) throws Exception {
         KeyPairGenerator keygen = KeyPairGenerator.getInstance("RSA");
-        RSAKeyGenParameterSpec spec = new RSAKeyGenParameterSpec(bits,
-                RSAKeyGenParameterSpec.F4);
+        RSAKeyGenParameterSpec spec = new RSAKeyGenParameterSpec(bits, RSAKeyGenParameterSpec.F4);
         keygen.initialize(spec);
         return keygen.generateKeyPair();
     }
-
 }

common/src/main/java/com/vexsoftware/votifier/platform/BackendServer.java

@@ -0,0 +1,7 @@
+package com.vexsoftware.votifier.platform;
+
+public interface BackendServer {
+    String getName();
+
+    boolean sendPluginMessage(String channel, byte[] data);
+}

common/src/main/java/com/vexsoftware/votifier/platform/JavaUtilLogger.java

@@ -0,0 +1,52 @@
+package com.vexsoftware.votifier.platform;
+
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+
+public class JavaUtilLogger implements LoggingAdapter {
+
+    private final Logger logger;
+
+    public JavaUtilLogger(Logger logger) {
+        this.logger = logger;
+    }
+
+    @Override
+    public void error(String s) {
+        logger.severe(s);
+    }
+
+    @Override
+    public void error(String s, Object... o) {
+        logger.log(Level.SEVERE, s, o);
+    }
+
+    @Override
+    public void error(String s, Throwable e, Object... o) {
+        LogRecord lr = new LogRecord(Level.SEVERE, s);
+        lr.setParameters(o);
+        lr.setThrown(e);
+        logger.log(lr);
+    }
+
+    @Override
+    public void warn(String s) {
+        logger.warning(s);
+    }
+
+    @Override
+    public void warn(String s, Object... o) {
+        logger.log(Level.WARNING, s, o);
+    }
+
+    @Override
+    public void info(String s) {
+        logger.info(s);
+    }
+
+    @Override
+    public void info(String s, Object... o) {
+        logger.log(Level.INFO, s, o);
+    }
+}

common/src/main/java/com/vexsoftware/votifier/platform/LoggingAdapter.java

@@ -0,0 +1,17 @@
+package com.vexsoftware.votifier.platform;
+
+public interface LoggingAdapter {
+    void error(String s);
+
+    void error(String s, Object... o);
+
+    void error(String s, Throwable e, Object... o);
+
+    void warn(String s);
+
+    void warn(String s, Object... o);
+
+    void info(String s);
+
+    void info(String s, Object... o);
+}

common/src/main/java/com/vexsoftware/votifier/platform/ProxyVotifierPlugin.java

@@ -0,0 +1,10 @@
+package com.vexsoftware.votifier.platform;
+
+import java.util.Collection;
+import java.util.Optional;
+
+public interface ProxyVotifierPlugin extends VotifierPlugin {
+    Collection<BackendServer> getAllBackendServers();
+
+    Optional<BackendServer> getServer(String name);
+}

common/src/main/java/com/vexsoftware/votifier/platform/VotifierPlugin.java

@@ -0,0 +1,24 @@
+package com.vexsoftware.votifier.platform;
+
+import com.vexsoftware.votifier.VoteHandler;
+import com.vexsoftware.votifier.platform.scheduler.VotifierScheduler;
+import io.netty.util.AttributeKey;
+import java.security.Key;
+import java.security.KeyPair;
+import java.util.Map;
+
+public interface VotifierPlugin extends VoteHandler {
+    AttributeKey<VotifierPlugin> KEY = AttributeKey.valueOf("votifier_plugin");
+
+    Map<String, Key> getTokens();
+
+    KeyPair getProtocolV1Key();
+
+    LoggingAdapter getPluginLogger();
+
+    VotifierScheduler getScheduler();
+
+    default boolean isDebug() {
+        return false;
+    }
+}

common/src/main/java/com/vexsoftware/votifier/platform/scheduler/ScheduledExecutorServiceVotifierScheduler.java

@@ -0,0 +1,37 @@
+package com.vexsoftware.votifier.platform.scheduler;
+
+import java.util.Objects;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+public class ScheduledExecutorServiceVotifierScheduler implements VotifierScheduler {
+    private final ScheduledExecutorService service;
+
+    public ScheduledExecutorServiceVotifierScheduler(ScheduledExecutorService service) {
+        this.service = Objects.requireNonNull(service, "service");
+    }
+
+    @Override
+    public ScheduledVotifierTask delayedOnPool(Runnable runnable, int delay, TimeUnit unit) {
+        return new ScheduledVotifierTaskWrapper(service.schedule(runnable, delay, unit));
+    }
+
+    @Override
+    public ScheduledVotifierTask repeatOnPool(Runnable runnable, int delay, int repeat, TimeUnit unit) {
+        return new ScheduledVotifierTaskWrapper(service.scheduleAtFixedRate(runnable, delay, repeat, unit));
+    }
+
+    private static class ScheduledVotifierTaskWrapper implements ScheduledVotifierTask {
+        private final Future<?> future;
+
+        private ScheduledVotifierTaskWrapper(Future<?> future) {
+            this.future = future;
+        }
+
+        @Override
+        public void cancel() {
+            future.cancel(false);
+        }
+    }
+}

common/src/main/java/com/vexsoftware/votifier/platform/scheduler/ScheduledVotifierTask.java

@@ -0,0 +1,5 @@
+package com.vexsoftware.votifier.platform.scheduler;
+
+public interface ScheduledVotifierTask {
+    void cancel();
+}

common/src/main/java/com/vexsoftware/votifier/platform/scheduler/VotifierScheduler.java

@@ -0,0 +1,10 @@
+package com.vexsoftware.votifier.platform.scheduler;
+
+import java.util.concurrent.TimeUnit;
+
+public interface VotifierScheduler {
+
+    ScheduledVotifierTask delayedOnPool(Runnable runnable, int delay, TimeUnit unit);
+
+    ScheduledVotifierTask repeatOnPool(Runnable runnable, int delay, int repeat, TimeUnit unit);
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/AbstractPluginMessagingForwardingSink.java

@@ -0,0 +1,43 @@
+package com.vexsoftware.votifier.support.forwarding;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.vexsoftware.votifier.model.Vote;
+import java.io.CharArrayReader;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+
+public abstract class AbstractPluginMessagingForwardingSink implements ForwardingVoteSink {
+
+    public AbstractPluginMessagingForwardingSink(ForwardedVoteListener listener) {
+        this.listener = listener;
+    }
+
+    private final ForwardedVoteListener listener;
+
+    public void handlePluginMessage(byte[] message) {
+        String strMessage = new String(message, StandardCharsets.UTF_8);
+        try (CharArrayReader reader = new CharArrayReader(strMessage.toCharArray())) {
+            JsonReader r = new JsonReader(reader);
+            r.setLenient(true);
+            while (r.peek() != JsonToken.END_DOCUMENT) {
+                r.beginObject();
+                JsonObject o = new JsonObject();
+
+                while (r.hasNext()) {
+                    String name = r.nextName();
+                    if (r.peek() == JsonToken.NUMBER) o.add(name, new JsonPrimitive(r.nextLong()));
+                    else o.add(name, new JsonPrimitive(r.nextString()));
+                }
+                r.endObject();
+
+                Vote v = new Vote(o);
+                listener.onForward(v);
+            }
+        } catch (IOException e) {
+            e.printStackTrace(); // Should never happen.
+        }
+    }
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/AbstractPluginMessagingForwardingSource.java

@@ -0,0 +1,174 @@
+package com.vexsoftware.votifier.support.forwarding;
+
+import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.platform.BackendServer;
+import com.vexsoftware.votifier.platform.ProxyVotifierPlugin;
+import com.vexsoftware.votifier.support.forwarding.cache.FileVoteCache;
+import com.vexsoftware.votifier.support.forwarding.cache.VoteCache;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+public abstract class AbstractPluginMessagingForwardingSource implements ForwardingVoteSource {
+
+    public AbstractPluginMessagingForwardingSource(
+            String channel, ServerFilter serverFilter, ProxyVotifierPlugin plugin, VoteCache cache, int dumpRate) {
+        this.channel = channel;
+        this.plugin = plugin;
+        this.cache = cache;
+        this.serverFilter = serverFilter;
+        this.dumpRate = dumpRate;
+    }
+
+    protected AbstractPluginMessagingForwardingSource(
+            String channel, ProxyVotifierPlugin plugin, VoteCache voteCache, int dumpRate) {
+        this(channel, null, plugin, voteCache, dumpRate);
+    }
+
+    protected final ProxyVotifierPlugin plugin;
+    protected final String channel;
+    protected final VoteCache cache;
+    protected final ServerFilter serverFilter;
+    private final int dumpRate;
+
+    @Override
+    public void forward(Vote v) {
+        byte[] rawData = v.serialize().toString().getBytes(StandardCharsets.UTF_8);
+        for (BackendServer server : plugin.getAllBackendServers()) {
+            if (!serverFilter.isAllowed(server.getName())) continue;
+            if (!forwardSpecific(server, rawData)) {
+                attemptToAddToCache(v, server.getName());
+            } else if (plugin.isDebug()) {
+                plugin.getPluginLogger().info("Successfully forwarded vote " + v + " to server " + server.getName());
+            }
+        }
+    }
+
+    protected boolean forwardSpecific(BackendServer connection, Vote vote) {
+        byte[] rawData = vote.serialize().toString().getBytes(StandardCharsets.UTF_8);
+        return forwardSpecific(connection, rawData);
+    }
+
+    protected boolean forwardSpecific(BackendServer connection, Collection<Vote> votes) {
+        StringBuilder data = new StringBuilder();
+        for (Vote v : votes) {
+            data.append(v.serialize().toString());
+        }
+
+        return forwardSpecific(connection, data.toString().getBytes(StandardCharsets.UTF_8));
+    }
+
+    private boolean forwardSpecific(BackendServer connection, byte[] data) {
+        return connection.sendPluginMessage(channel, data);
+    }
+
+    @Override
+    public void halt() {
+        if (cache instanceof FileVoteCache) {
+            try {
+                ((FileVoteCache) cache).halt();
+            } catch (IOException e) {
+                plugin.getPluginLogger().error("Unable to save cached votes, votes will be lost.", e);
+            }
+        }
+    }
+
+    protected void onServerConnect(BackendServer server) {
+        if (cache == null) return;
+        final Collection<Vote> cachedVotes = cache.evict(server.getName());
+        dumpVotesToServer(cachedVotes, server, "server '" + server + "'", failedVotes -> {
+            for (Vote v : failedVotes) cache.addToCache(v, server.getName());
+        });
+    }
+
+    protected void attemptToAddToCache(Vote v, String server) {
+        if (cache != null) {
+            cache.addToCache(v, server);
+            if (plugin.isDebug()) plugin.getPluginLogger().info("Added to forwarding cache: " + v + " -> " + server);
+        } else if (plugin.isDebug())
+            plugin.getPluginLogger()
+                    .error("Could not immediately send vote to backend, vote lost! " + v + " -> " + server);
+    }
+
+    protected void attemptToAddToPlayerCache(Vote v, String player) {
+        if (cache != null) {
+            cache.addToCachePlayer(v, player);
+            if (plugin.isDebug())
+                plugin.getPluginLogger().info("Added to forwarding cache: " + v + " -> (player) " + player);
+        } else if (plugin.isDebug())
+            plugin.getPluginLogger()
+                    .error("Could not immediately send vote to backend, vote lost! " + v + " -> (player) " + player);
+    }
+
+    // returns a collection of failed votes
+    private void dumpVotesToServer(
+            Collection<Vote> cachedVotes, BackendServer target, String identifier, Consumer<Collection<Vote>> cb) {
+        dumpVotesToServer(cachedVotes, target, identifier, 0, cb);
+    }
+
+    private void dumpVotesToServer(
+            Collection<Vote> cachedVotes,
+            BackendServer target,
+            String identifier,
+            int evictedAlready,
+            Consumer<Collection<Vote>> cb) {
+        if (!cachedVotes.isEmpty()) {
+            plugin.getScheduler()
+                    .delayedOnPool(
+                            () -> {
+                                int evicted = 0;
+                                Iterator<Vote> vi = cachedVotes.iterator();
+                                Collection<Vote> chunk = new ArrayList<>(dumpRate);
+                                while (vi.hasNext() && evicted < dumpRate) {
+                                    chunk.add(vi.next());
+                                    vi.remove();
+                                }
+
+                                if (forwardSpecific(target, chunk)) {
+                                    evicted += chunk.size();
+
+                                    if (evicted >= dumpRate && !cachedVotes.isEmpty()) {
+                                        // if we evicted everything we could but still need to evict more
+                                        dumpVotesToServer(
+                                                cachedVotes, target, identifier, evictedAlready + evicted, cb);
+                                        return;
+                                    }
+                                } else {
+                                    // so since our forwarding failed, break like we are done
+                                    cachedVotes.addAll(chunk);
+                                }
+
+                                if (plugin.isDebug()) {
+                                    plugin.getPluginLogger()
+                                            .info("Successfully evicted " + (evictedAlready + evicted) + " votes to "
+                                                    + identifier + ".");
+                                    if (!cachedVotes.isEmpty()) {
+                                        plugin.getPluginLogger()
+                                                .info("Held " + cachedVotes.size() + " votes for " + identifier + ".");
+                                    }
+                                }
+
+                                // cachedVotes contains any votes which have yet to be evicted
+                                cb.accept(cachedVotes);
+                            },
+                            evictedAlready == 0 ? 3 : 1,
+                            TimeUnit.SECONDS);
+        } else {
+            cb.accept(cachedVotes);
+        }
+    }
+
+    protected void handlePlayerSwitch(BackendServer server, String playerName) {
+        if (cache == null) return;
+        if (!serverFilter.isAllowed(server.getName())) return;
+
+        final Collection<Vote> cachedVotes = cache.evictPlayer(playerName);
+        dumpVotesToServer(cachedVotes, server, "player '" + playerName + "'", failedVotes -> {
+            for (Vote v : failedVotes) cache.addToCachePlayer(v, playerName);
+        });
+    }
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/ForwardedVoteListener.java

@@ -1,4 +1,4 @@
-package com.vexsoftware.votifier.sponge.forwarding;
+package com.vexsoftware.votifier.support.forwarding;
 
 import com.vexsoftware.votifier.model.Vote;
 
@@ -13,5 +13,4 @@ public interface ForwardedVoteListener {
      * @param v Vote that was forwarded
      */
     void onForward(Vote v);
-
 }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/ForwardingVoteSink.java

@@ -1,4 +1,4 @@
-package com.vexsoftware.votifier.forwarding;
+package com.vexsoftware.votifier.support.forwarding;
 
 /**
  * Represents a method at which to receive forwarded votes.
@@ -9,5 +9,4 @@ public interface ForwardingVoteSink {
      * Stop or close any oustanding network interfaces. Occurs on the onDisable method of a plugin.
      */
     void halt();
-
 }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/ForwardingVoteSource.java

@@ -1,4 +1,4 @@
-package com.vexsoftware.votifier.bungee.forwarding;
+package com.vexsoftware.votifier.support.forwarding;
 
 import com.vexsoftware.votifier.model.Vote;
 
@@ -18,5 +18,4 @@ public interface ForwardingVoteSource {
      * Stop or close any oustanding network interfaces. Occurs on the onDisable method of a plugin.
      */
     void halt();
-
 }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/ServerFilter.java

@@ -0,0 +1,23 @@
+package com.vexsoftware.votifier.support.forwarding;
+
+import java.util.Collection;
+import java.util.Collections;
+
+public class ServerFilter {
+
+    public ServerFilter(Collection<String> names, boolean whitelist) {
+        this.names = names;
+        this.whitelist = whitelist;
+    }
+
+    public ServerFilter() {
+        this(Collections.emptySet(), true);
+    }
+
+    private final Collection<String> names;
+    private final boolean whitelist;
+
+    public boolean isAllowed(String name) {
+        return names.contains(name) == whitelist;
+    }
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/cache/FileVoteCache.java

@@ -0,0 +1,169 @@
+package com.vexsoftware.votifier.support.forwarding.cache;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.vexsoftware.votifier.platform.LoggingAdapter;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.platform.scheduler.ScheduledVotifierTask;
+import com.vexsoftware.votifier.util.GsonInst;
+import java.io.*;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.NoSuchFileException;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+public class FileVoteCache extends MemoryVoteCache {
+
+    private final LoggingAdapter l;
+    private final File cacheFile;
+    private final ScheduledVotifierTask saveTask;
+
+    public FileVoteCache(final VotifierPlugin plugin, File cacheFile, long voteTTL) throws IOException {
+        super(plugin, voteTTL);
+        this.cacheFile = cacheFile;
+        this.l = plugin.getPluginLogger();
+
+        load();
+
+        saveTask = plugin.getScheduler()
+                .repeatOnPool(
+                        () -> {
+                            try {
+                                save();
+                            } catch (IOException e) {
+                                l.error("Unable to save cached votes, votes will be lost if you restart.", e);
+                            }
+                        },
+                        3,
+                        3,
+                        TimeUnit.MINUTES);
+    }
+
+    private static Set<String> keySet(JsonObject object) {
+        Set<String> set = new HashSet<>();
+        for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
+            set.add(entry.getKey());
+        }
+        return set;
+    }
+
+    private void load() throws IOException {
+        // Load the cache from disk
+        JsonObject object;
+        try (BufferedReader reader = Files.newBufferedReader(cacheFile.toPath(), StandardCharsets.UTF_8)) {
+            object = GsonInst.gson.fromJson(reader, JsonObject.class);
+            if (object == null) {
+                // When the input is not malformed but instead empty, this returns null. Simply assume it is empty.
+                object = new JsonObject();
+            }
+        } catch (NoSuchFileException e) {
+            object = new JsonObject();
+        }
+
+        boolean resave = false;
+
+        // First, lets figure out if we are converting from a pre2.3.6 cache
+        if (!object.has("players") || !object.has("servers") || !object.has("version") || object.size() != 3) {
+            JsonObject oldObject = object;
+            object = new JsonObject();
+            object.add("servers", oldObject);
+            object.add("players", new JsonObject());
+            object.addProperty("version", 2);
+            resave = true;
+        }
+
+        if (object.get("version").getAsInt() != 2)
+            throw new IllegalStateException("Could not read cache file! Unknown version '"
+                    + object.get("version").getAsInt() + "' read.");
+
+        JsonObject players = object.getAsJsonObject("players");
+        JsonObject servers = object.getAsJsonObject("servers");
+
+        for (String player : keySet(players)) {
+            playerVoteCache.put(player, readVotes(players.getAsJsonArray(player)));
+        }
+
+        for (String server : keySet(servers)) {
+            voteCache.put(server, readVotes(servers.getAsJsonArray(server)));
+        }
+
+        if (resave) {
+            File replacementFile;
+            for (int i = 0; ; i++) {
+                replacementFile = new File(cacheFile.getParentFile(), cacheFile.getName() + ".bak." + i);
+                if (!replacementFile.exists()) break;
+            }
+
+            if (!cacheFile.renameTo(replacementFile)) {
+                l.error("Backup movement failed! Will not save.");
+                return;
+            }
+
+            l.warn("Saving new vote cache format to file - backup moved to " + replacementFile.getAbsolutePath());
+            save();
+        }
+    }
+
+    private Collection<VoteWithRecordedTimestamp> readVotes(JsonArray voteArray) {
+        Collection<VoteWithRecordedTimestamp> votes = new HashSet<>(voteArray.size());
+        for (int i = 0; i < voteArray.size(); i++) {
+            JsonObject voteObject = voteArray.get(i).getAsJsonObject();
+            VoteWithRecordedTimestamp v = new VoteWithRecordedTimestamp(voteObject);
+            if (hasTimedOut(v)) l.warn("Purging out of date vote.", v);
+            else votes.add(v);
+        }
+        return votes;
+    }
+
+    public void save() throws IOException {
+        JsonObject votesObject = new JsonObject();
+
+        cacheLock.lock();
+        try {
+            votesObject.addProperty("version", 2);
+            votesObject.add("players", serializeMap(playerVoteCache));
+            votesObject.add("servers", serializeMap(voteCache));
+        } finally {
+            cacheLock.unlock();
+        }
+
+        try (BufferedWriter writer = Files.newBufferedWriter(cacheFile.toPath(), StandardCharsets.UTF_8)) {
+            GsonInst.gson.toJson(votesObject, writer);
+        }
+    }
+
+    public JsonObject serializeMap(Map<String, Collection<VoteWithRecordedTimestamp>> map) {
+        JsonObject o = new JsonObject();
+
+        Iterator<Map.Entry<String, Collection<VoteWithRecordedTimestamp>>> entryItr =
+                map.entrySet().iterator();
+        while (entryItr.hasNext()) {
+            Map.Entry<String, Collection<VoteWithRecordedTimestamp>> entry = entryItr.next();
+            JsonArray array = new JsonArray();
+            Iterator<VoteWithRecordedTimestamp> voteItr = entry.getValue().iterator();
+            while (voteItr.hasNext()) {
+                VoteWithRecordedTimestamp vote = voteItr.next();
+
+                // if the vote is no longer valid, notify and remove
+                if (hasTimedOut(vote)) {
+                    l.warn("Purging out of date vote.", vote);
+                    voteItr.remove();
+                } else {
+                    array.add(vote.serialize());
+                }
+            }
+
+            // if, during our iteration, we TTL invalidated all of the votes
+            if (entry.getValue().isEmpty()) entryItr.remove();
+            o.add(entry.getKey(), array);
+        }
+        return o;
+    }
+
+    public void halt() throws IOException {
+        saveTask.cancel();
+        save();
+    }
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/cache/MemoryVoteCache.java

@@ -0,0 +1,174 @@
+package com.vexsoftware.votifier.support.forwarding.cache;
+
+import com.google.gson.JsonObject;
+import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.platform.LoggingAdapter;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.platform.scheduler.ScheduledVotifierTask;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReentrantLock;
+
+/**
+ * Created by Joe Hirschfeld on 10/20/2015.
+ */
+public class MemoryVoteCache implements VoteCache {
+
+    private final LoggingAdapter l;
+    private final long voteTTL;
+
+    protected final Map<String, Collection<VoteWithRecordedTimestamp>> voteCache;
+    protected final Map<String, Collection<VoteWithRecordedTimestamp>> playerVoteCache;
+
+    protected final ReentrantLock cacheLock = new ReentrantLock();
+
+    private final ScheduledVotifierTask sweepTask;
+
+    public MemoryVoteCache(VotifierPlugin p, long voteTTL) {
+        voteCache = new HashMap<>();
+        playerVoteCache = new HashMap<>();
+
+        this.voteTTL = voteTTL;
+
+        this.l = p.getPluginLogger();
+        this.sweepTask = p.getScheduler().repeatOnPool(this::sweep, 12, 12, TimeUnit.HOURS);
+    }
+
+    @Override
+    public Collection<String> getCachedServers() {
+        cacheLock.lock();
+        try {
+            return Collections.unmodifiableCollection(new ArrayList<>(voteCache.keySet()));
+        } finally {
+            cacheLock.unlock();
+        }
+    }
+
+    @Override
+    public void addToCache(Vote v, String server) {
+        if (server == null) throw new NullPointerException();
+        cacheLock.lock();
+        try {
+            voteCache.computeIfAbsent(server, k -> new HashSet<>()).add(new VoteWithRecordedTimestamp(v));
+        } finally {
+            cacheLock.unlock();
+        }
+    }
+
+    @Override
+    public void addToCachePlayer(Vote v, String player) {
+        if (player == null) throw new NullPointerException();
+        cacheLock.lock();
+        try {
+            playerVoteCache.computeIfAbsent(player, k -> new HashSet<>()).add(new VoteWithRecordedTimestamp(v));
+        } finally {
+            cacheLock.unlock();
+        }
+    }
+
+    @Override
+    public Collection<Vote> evictPlayer(String player) {
+        if (player == null) throw new NullPointerException();
+        cacheLock.lock();
+        try {
+            Collection<VoteWithRecordedTimestamp> playerVotes = playerVoteCache.remove(player);
+            if (playerVotes != null) {
+                return new HashSet<>(playerVotes);
+            } else {
+                return Collections.emptySet();
+            }
+        } finally {
+            cacheLock.unlock();
+        }
+    }
+
+    @Override
+    public Collection<Vote> evict(String server) {
+        if (server == null) throw new NullPointerException();
+        cacheLock.lock();
+        try {
+            Collection<VoteWithRecordedTimestamp> serverVotes = voteCache.remove(server);
+            if (serverVotes != null) {
+                return new HashSet<>(serverVotes);
+            } else {
+                return Collections.emptySet();
+            }
+        } finally {
+            cacheLock.unlock();
+        }
+    }
+
+    public void sweep() {
+        cacheLock.lock();
+        try {
+            sweep(voteCache);
+            sweep(playerVoteCache);
+        } finally {
+            cacheLock.unlock();
+        }
+    }
+
+    private void sweep(Map<String, Collection<VoteWithRecordedTimestamp>> m) {
+        for (Map.Entry<String, Collection<VoteWithRecordedTimestamp>> entry : m.entrySet()) {
+            Iterator<VoteWithRecordedTimestamp> vi = entry.getValue().iterator();
+            while (vi.hasNext()) {
+                VoteWithRecordedTimestamp v = vi.next();
+                if (hasTimedOut(v)) {
+                    l.warn("Purging out of date vote.", v);
+                    vi.remove();
+                }
+            }
+        }
+    }
+
+    protected boolean hasTimedOut(VoteWithRecordedTimestamp v) {
+        if (voteTTL == -1) return false;
+
+        long daysAsMillis = TimeUnit.DAYS.toMillis(voteTTL);
+        return v.recorded + daysAsMillis < System.currentTimeMillis();
+    }
+
+    static class VoteWithRecordedTimestamp extends Vote {
+        private final long recorded;
+
+        VoteWithRecordedTimestamp(Vote vote) {
+            super(vote);
+            this.recorded = System.currentTimeMillis();
+        }
+
+        VoteWithRecordedTimestamp(JsonObject object) {
+            super(object);
+            if (object.has("recorded")) {
+                this.recorded = object.get("recorded").getAsLong();
+            } else {
+                // Assign the current time, in the hope that the stale votes will eventually get purged.
+                this.recorded = System.currentTimeMillis();
+            }
+        }
+
+        @Override
+        public JsonObject serialize() {
+            JsonObject object = super.serialize();
+            object.addProperty("recorded", this.recorded);
+            return object;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o) return true;
+            if (o == null || getClass() != o.getClass()) return false;
+            if (!super.equals(o)) return false;
+
+            VoteWithRecordedTimestamp that = (VoteWithRecordedTimestamp) o;
+
+            return recorded == that.recorded;
+        }
+
+        @Override
+        public int hashCode() {
+            int result = super.hashCode();
+            result = 31 * result + (int) (recorded ^ (recorded >>> 32));
+            return result;
+        }
+    }
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/cache/VoteCache.java

@@ -1,8 +1,8 @@
-package com.vexsoftware.votifier.bungee.forwarding.cache;
+package com.vexsoftware.votifier.support.forwarding.cache;
 
 import com.vexsoftware.votifier.model.Vote;
-
 import java.util.Collection;
+import java.util.Collections;
 
 /**
  * Represents a method of caching votes for forwarding to a server that it was not previously capable of sending.
@@ -24,6 +24,15 @@ public interface VoteCache {
      */
     void addToCache(Vote v, String server);
 
+    /**
+     * Adds a vote to the vote cache for later sending, specifically keyed to a player. This is for the instance when the
+     * player is rewarded, however is not online any servers able to recieve said vote.
+     *
+     * @param v      Vote to add to the cache
+     * @param player Server to add vote under
+     */
+    default void addToCachePlayer(Vote v, String player) {}
+
     /**
      * Evicts all votes from the vote cache and returns a collection of vote objects
      *
@@ -31,4 +40,15 @@ public interface VoteCache {
      * @return A collection of all votes which were previously in the cache under the server
      */
     Collection<Vote> evict(String server);
+
+    /**
+     * Evicts all votes from the vote cache for a specific player not assigned to a server and returns a collection of
+     * vote objects
+     *
+     * @param player Player name of the votes to evict from the cache
+     * @return A collection of all votes which were previously in the cache under the player
+     */
+    default Collection<Vote> evictPlayer(String player) {
+        return Collections.emptyList();
+    }
 }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/proxy/ProxyForwardingVoteSource.java

@@ -0,0 +1,137 @@
+package com.vexsoftware.votifier.support.forwarding.proxy;
+
+import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.support.forwarding.ForwardingVoteSource;
+import com.vexsoftware.votifier.support.forwarding.cache.VoteCache;
+import com.vexsoftware.votifier.support.forwarding.proxy.client.VotifierProtocol2Encoder;
+import com.vexsoftware.votifier.support.forwarding.proxy.client.VotifierProtocol2HandshakeHandler;
+import com.vexsoftware.votifier.support.forwarding.proxy.client.VotifierResponseHandler;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.DelimiterBasedFrameDecoder;
+import io.netty.handler.codec.Delimiters;
+import io.netty.handler.codec.string.StringDecoder;
+import io.netty.handler.timeout.ReadTimeoutHandler;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.security.Key;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+
+public class ProxyForwardingVoteSource implements ForwardingVoteSource {
+    private static final int MAX_RETRIES = 5;
+    private final VotifierPlugin plugin;
+    private final Supplier<Bootstrap> nettyBootstrap;
+    private final List<BackendServer> backendServers;
+    private final VoteCache voteCache;
+
+    private static final StringDecoder STRING_DECODER = new StringDecoder(StandardCharsets.US_ASCII);
+
+    public ProxyForwardingVoteSource(
+            VotifierPlugin plugin,
+            Supplier<Bootstrap> nettyBootstrap,
+            List<BackendServer> backendServers,
+            VoteCache voteCache) {
+        this.plugin = plugin;
+        this.nettyBootstrap = nettyBootstrap;
+        this.backendServers = backendServers;
+        this.voteCache = voteCache;
+    }
+
+    @Override
+    public void forward(Vote v) {
+        for (final BackendServer server : backendServers) {
+            forwardVote(server, v, 0);
+        }
+    }
+
+    private int fib(int t) {
+        if (t <= 1) return 1;
+        return fib(t - 2) + fib(t - 1);
+    }
+
+    private void forwardVote(final BackendServer server, final Vote v, final int tries) {
+        nettyBootstrap
+                .get()
+                .handler(new ChannelInitializer<SocketChannel>() {
+                    @Override
+                    protected void initChannel(SocketChannel channel) {
+                        channel.pipeline()
+                                .addLast(new DelimiterBasedFrameDecoder(256, true, Delimiters.lineDelimiter()));
+                        channel.pipeline().addLast(new ReadTimeoutHandler(5, TimeUnit.SECONDS));
+                        channel.pipeline().addLast(STRING_DECODER);
+                        channel.pipeline().addLast(new VotifierProtocol2Encoder(server.key));
+                        channel.pipeline()
+                                .addLast(new VotifierProtocol2HandshakeHandler(
+                                        v,
+                                        new VotifierResponseHandler() {
+                                            @Override
+                                            public void onSuccess() {
+                                                if (plugin.isDebug()) {
+                                                    plugin.getPluginLogger()
+                                                            .info("Successfully forwarded vote " + v + " to "
+                                                                    + server.address + ".");
+                                                }
+                                            }
+
+                                            @Override
+                                            public void onFailure(Throwable error) {
+                                                handleFailure(server, v, error, tries);
+                                            }
+                                        },
+                                        plugin));
+                    }
+                })
+                .connect(server.address)
+                .addListener((ChannelFutureListener) future -> {
+                    if (!future.isSuccess()) {
+                        handleFailure(server, v, future.cause(), tries);
+                    }
+                });
+    }
+
+    private void handleFailure(final BackendServer server, final Vote v, Throwable cause, final int tries) {
+        int nextDelay = fib(tries + 1);
+        boolean willRetry = tries < MAX_RETRIES;
+
+        String msg = "Unable to send vote to " + server.address + ".";
+        if (willRetry) {
+            msg += " Will retry sending in " + nextDelay + " second(s).";
+        } else {
+            if (voteCache == null) {
+                msg += " This vote will be lost!";
+            } else {
+                voteCache.addToCache(v, server.name);
+            }
+        }
+
+        if (plugin.isDebug()) {
+            plugin.getPluginLogger().error(msg, cause);
+        } else {
+            plugin.getPluginLogger().error(msg);
+        }
+
+        if (willRetry) {
+            plugin.getScheduler().delayedOnPool(() -> forwardVote(server, v, tries + 1), nextDelay, TimeUnit.SECONDS);
+        }
+    }
+
+    @Override
+    public void halt() {}
+
+    public static class BackendServer {
+        private final String name;
+        private final InetSocketAddress address;
+        private final Key key;
+
+        public BackendServer(String name, InetSocketAddress address, Key key) {
+            this.name = name;
+            this.address = address;
+            this.key = key;
+        }
+    }
+}

common/src/main/java/com/vexsoftware/votifier/support/forwarding/proxy/client/VoteRequest.java

@@ -1,4 +1,4 @@
-package com.vexsoftware.votifier.bungee.forwarding.proxy.client;
+package com.vexsoftware.votifier.support.forwarding.proxy.client;
 
 import com.vexsoftware.votifier.model.Vote;
 
@@ -21,9 +21,6 @@ public class VoteRequest {
 
     @Override
     public String toString() {
-        return "VoteRequest{" +
-                "challenge='" + challenge + '\'' +
-                ", vote=" + vote +
-                '}';
+        return "VoteRequest{" + "challenge='" + challenge + '\'' + ", vote=" + vote + '}';
     }
 }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/proxy/client/VotifierProtocol2Encoder.java

@@ -1,15 +1,14 @@
-package com.vexsoftware.votifier.bungee.forwarding.proxy.client;
+package com.vexsoftware.votifier.support.forwarding.proxy.client;
 
+import com.google.gson.JsonObject;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.Unpooled;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.MessageToByteEncoder;
-import org.json.JSONObject;
-
-import javax.crypto.Mac;
-import javax.xml.bind.DatatypeConverter;
 import java.nio.charset.StandardCharsets;
 import java.security.Key;
+import java.util.Base64;
+import javax.crypto.Mac;
 
 public class VotifierProtocol2Encoder extends MessageToByteEncoder<VoteRequest> {
     private static final short MAGIC = 0x733A;
@@ -22,18 +21,18 @@ public class VotifierProtocol2Encoder extends MessageToByteEncoder<VoteRequest>
 
     @Override
     protected void encode(ChannelHandlerContext ctx, VoteRequest req, ByteBuf buf) throws Exception {
-        JSONObject object = new JSONObject();
-        JSONObject payloadObject = req.getVote().serialize();
-        payloadObject.put("challenge", req.getChallenge());
+        JsonObject object = new JsonObject();
+        JsonObject payloadObject = req.getVote().serialize();
+        payloadObject.addProperty("challenge", req.getChallenge());
         String payload = payloadObject.toString();
-        object.put("payload", payload);
+        object.addProperty("payload", payload);
 
         // Generate the MAC
         Mac mac = Mac.getInstance("HmacSHA256");
         mac.init(key);
         mac.update(payload.getBytes(StandardCharsets.UTF_8));
-        String computed = DatatypeConverter.printBase64Binary(mac.doFinal());
-        object.put("signature", computed);
+        String computed = Base64.getEncoder().encodeToString(mac.doFinal());
+        object.addProperty("signature", computed);
 
         // JSON message is ready for encoding.
         String finalMessage = object.toString();

common/src/main/java/com/vexsoftware/votifier/support/forwarding/proxy/client/VotifierProtocol2HandshakeHandler.java

@@ -1,7 +1,7 @@
-package com.vexsoftware.votifier.bungee.forwarding.proxy.client;
+package com.vexsoftware.votifier.support.forwarding.proxy.client;
 
-import com.vexsoftware.votifier.bungee.NuVotifier;
 import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
 import io.netty.handler.codec.CorruptedFrameException;
@@ -9,16 +9,17 @@ import io.netty.handler.codec.CorruptedFrameException;
 public class VotifierProtocol2HandshakeHandler extends SimpleChannelInboundHandler<String> {
     private final Vote toSend;
     private final VotifierResponseHandler responseHandler;
-    private final NuVotifier nuVotifier;
+    private final VotifierPlugin nuVotifier;
 
-    public VotifierProtocol2HandshakeHandler(Vote toSend, VotifierResponseHandler responseHandler, NuVotifier nuVotifier) {
+    public VotifierProtocol2HandshakeHandler(
+            Vote toSend, VotifierResponseHandler responseHandler, VotifierPlugin nuVotifier) {
         this.toSend = toSend;
         this.responseHandler = responseHandler;
         this.nuVotifier = nuVotifier;
     }
 
     @Override
-    protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
+    protected void channelRead0(ChannelHandlerContext ctx, String s) {
         String[] handshakeContents = s.split(" ");
         if (handshakeContents.length != 3) {
             throw new CorruptedFrameException("Handshake is not valid.");
@@ -26,16 +27,15 @@ public class VotifierProtocol2HandshakeHandler extends SimpleChannelInboundHandl
 
         VoteRequest request = new VoteRequest(handshakeContents[2], toSend);
         if (nuVotifier.isDebug()) {
-            nuVotifier.getLogger().info("Sent request: " + request.toString());
+            nuVotifier.getPluginLogger().info("Sent request: " + request.toString());
         }
         ctx.writeAndFlush(request);
         ctx.pipeline().addLast(new VotifierProtocol2ResponseHandler(responseHandler));
         ctx.pipeline().remove(this);
     }
 
-
     @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         responseHandler.onFailure(cause);
         ctx.close();
     }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/proxy/client/VotifierProtocol2ResponseHandler.java

@@ -1,8 +1,9 @@
-package com.vexsoftware.votifier.bungee.forwarding.proxy.client;
+package com.vexsoftware.votifier.support.forwarding.proxy.client;
 
+import com.google.gson.JsonObject;
+import com.vexsoftware.votifier.util.GsonInst;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.SimpleChannelInboundHandler;
-import org.json.JSONObject;
 
 public class VotifierProtocol2ResponseHandler extends SimpleChannelInboundHandler<String> {
     private final VotifierResponseHandler responseHandler;
@@ -12,19 +13,21 @@ public class VotifierProtocol2ResponseHandler extends SimpleChannelInboundHandle
     }
 
     @Override
-    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
-        JSONObject object = new JSONObject(msg);
-        String status = object.getString("status");
+    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
+        JsonObject object = GsonInst.gson.fromJson(msg, JsonObject.class);
+        String status = object.get("status").getAsString();
         if (status.equals("ok")) {
             responseHandler.onSuccess();
         } else {
-            responseHandler.onFailure(new Exception("Remote server error: " + object.getString("cause") + ": " + object.getString("error")));
+            responseHandler.onFailure(
+                    new Exception("Remote server error: " + object.get("cause").getAsString() + ": "
+                            + object.get("error").getAsString()));
         }
         ctx.close();
     }
 
     @Override
-    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
         responseHandler.onFailure(cause);
         ctx.close();
     }

common/src/main/java/com/vexsoftware/votifier/support/forwarding/proxy/client/VotifierResponseHandler.java

@@ -1,4 +1,4 @@
-package com.vexsoftware.votifier.bungee.forwarding.proxy.client;
+package com.vexsoftware.votifier.support.forwarding.proxy.client;
 
 public interface VotifierResponseHandler {
     void onSuccess();

common/src/main/java/com/vexsoftware/votifier/util/ArgsToVote.java

@@ -0,0 +1,60 @@
+package com.vexsoftware.votifier.util;
+
+import com.vexsoftware.votifier.model.Vote;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ArgsToVote {
+
+    private static final Pattern argumentPattern = Pattern.compile("([a-zA-Z]+)=(\\S*)");
+
+    public static Vote parse(String[] arguments) {
+        return parse(arguments, null);
+    }
+
+    public static Vote parse(String[] arguments, Map<String, String> additionalArgs) {
+        String serviceName = "TestVote";
+        String username = null;
+        String address = "127.0.0.1";
+        long localTimestamp = System.currentTimeMillis();
+        String timestamp = Long.toString(localTimestamp, 10);
+
+        for (String s : arguments) {
+            Matcher m = argumentPattern.matcher(s);
+            if (m.matches()) {
+                String key = m.group(1).toLowerCase();
+                String v = m.group(2);
+                switch (key) {
+                    case "servicename":
+                        serviceName = v;
+                        break;
+                    case "username":
+                        if (v.length() > 16)
+                            throw new IllegalArgumentException(
+                                    "Illegal username - must be less than 16 characters long.");
+                        username = v;
+                        break;
+                    case "address":
+                        address = v;
+                        break;
+                    case "timestamp":
+                        timestamp = v;
+                        break;
+                    default:
+                        if (additionalArgs != null) additionalArgs.put(key, v);
+                        break;
+                }
+
+            } else {
+                if (s.length() > 16)
+                    throw new IllegalArgumentException("Illegal username - must be less than 16 characters long.");
+                username = s; // ezpz
+            }
+        }
+
+        if (username == null) throw new IllegalArgumentException("Username not specified!");
+
+        return new Vote(serviceName, username, address, timestamp);
+    }
+}

common/src/main/java/com/vexsoftware/votifier/util/GsonInst.java

@@ -0,0 +1,9 @@
+package com.vexsoftware.votifier.util;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class GsonInst {
+
+    public static final Gson gson = new GsonBuilder().create();
+}

common/src/main/java/com/vexsoftware/votifier/util/IOUtil.java

@@ -0,0 +1,17 @@
+package com.vexsoftware.votifier.util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class IOUtil {
+    public static byte[] readAllBytes(InputStream from) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream(8192);
+        byte[] buf = new byte[8192];
+        int read;
+        while ((read = from.read(buf)) != -1) {
+            out.write(buf, 0, read);
+        }
+        return out.toByteArray();
+    }
+}

common/src/main/java/com/vexsoftware/votifier/util/KeyCreator.java

@@ -1,8 +1,8 @@
 package com.vexsoftware.votifier.util;
 
-import javax.crypto.spec.SecretKeySpec;
 import java.nio.charset.StandardCharsets;
 import java.security.Key;
+import javax.crypto.spec.SecretKeySpec;
 
 public class KeyCreator {
     public static Key createKeyFrom(String token) {

common/src/main/java/com/vexsoftware/votifier/util/QuietException.java

@@ -0,0 +1,14 @@
+package com.vexsoftware.votifier.util;
+
+public class QuietException extends Exception {
+    public QuietException() {}
+
+    public QuietException(String s) {
+        super(s);
+    }
+
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        return null;
+    }
+}

common/src/main/java/com/vexsoftware/votifier/util/TokenUtil.java

@@ -4,9 +4,7 @@ import java.math.BigInteger;
 import java.security.SecureRandom;
 
 public class TokenUtil {
-    private TokenUtil() {
-
-    }
+    private TokenUtil() {}
 
     private static final SecureRandom RANDOM = new SecureRandom();
 

common/src/main/java/com/vexsoftware/votifier/util/standalone/StandaloneVotifierPlugin.java

@@ -1,65 +1,50 @@
 package com.vexsoftware.votifier.util.standalone;
 
-import com.vexsoftware.votifier.VoteHandler;
-import com.vexsoftware.votifier.VotifierPlugin;
 import com.vexsoftware.votifier.model.Vote;
+import com.vexsoftware.votifier.net.VotifierServerBootstrap;
 import com.vexsoftware.votifier.net.VotifierSession;
-import com.vexsoftware.votifier.net.protocol.VoteInboundHandler;
-import com.vexsoftware.votifier.net.protocol.VotifierGreetingHandler;
-import com.vexsoftware.votifier.net.protocol.VotifierProtocolDifferentiator;
-import io.netty.bootstrap.ServerBootstrap;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.nio.NioEventLoopGroup;
-import io.netty.channel.socket.nio.NioServerSocketChannel;
-import io.netty.channel.socket.nio.NioSocketChannel;
-
+import com.vexsoftware.votifier.platform.JavaUtilLogger;
+import com.vexsoftware.votifier.platform.LoggingAdapter;
+import com.vexsoftware.votifier.platform.VotifierPlugin;
+import com.vexsoftware.votifier.platform.scheduler.ScheduledExecutorServiceVotifierScheduler;
+import com.vexsoftware.votifier.platform.scheduler.VotifierScheduler;
 import java.net.InetSocketAddress;
 import java.security.Key;
 import java.security.KeyPair;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.function.Consumer;
+import java.util.logging.Logger;
 
-public class StandaloneVotifierPlugin implements VotifierPlugin, VoteHandler {
+public class StandaloneVotifierPlugin implements VotifierPlugin {
     private final Map<String, Key> tokens;
     private final VoteReceiver receiver;
     private final KeyPair v1Key;
     private final InetSocketAddress bind;
-    private NioEventLoopGroup group;
+    private final VotifierScheduler scheduler;
+    private VotifierServerBootstrap bootstrap;
 
-    public StandaloneVotifierPlugin(Map<String, Key> tokens, VoteReceiver receiver, KeyPair v1Key, InetSocketAddress bind) {
+    public StandaloneVotifierPlugin(
+            Map<String, Key> tokens, VoteReceiver receiver, KeyPair v1Key, InetSocketAddress bind) {
         this.receiver = receiver;
         this.bind = bind;
         this.tokens = Collections.unmodifiableMap(new HashMap<>(tokens));
         this.v1Key = v1Key;
+        this.scheduler = new ScheduledExecutorServiceVotifierScheduler(Executors.newScheduledThreadPool(1));
     }
 
-    public Throwable start() throws Throwable {
-        group = new NioEventLoopGroup(2);
+    public void start() {
+        start(o -> {});
+    }
 
-        ChannelFuture future = new ServerBootstrap()
-                .channel(NioServerSocketChannel.class)
-                .group(group)
-                .childHandler(new ChannelInitializer<NioSocketChannel>() {
-                    @Override
-                    protected void initChannel(NioSocketChannel channel) throws Exception {
-                        channel.attr(VotifierSession.KEY).set(new VotifierSession());
-                        channel.attr(VotifierPlugin.KEY).set(StandaloneVotifierPlugin.this);
-                        channel.pipeline().addLast("greetingHandler", new VotifierGreetingHandler());
-                        channel.pipeline().addLast("protocolDifferentiator", new VotifierProtocolDifferentiator(false, v1Key != null));
-                        channel.pipeline().addLast("voteHandler", new VoteInboundHandler(StandaloneVotifierPlugin.this));
-                    }
-                })
-                .bind(bind)
-                .syncUninterruptibly();
-
-        if (!future.isSuccess()) {
-            return future.cause();
-        } else {
-            return null;
+    public void start(Consumer<Throwable> error) {
+        if (bootstrap != null) {
+            bootstrap.shutdown();
         }
+        this.bootstrap = new VotifierServerBootstrap(bind.getHostString(), bind.getPort(), this, v1Key == null);
+        this.bootstrap.start(error);
     }
 
     @Override
@@ -73,17 +58,23 @@ public class StandaloneVotifierPlugin implements VotifierPlugin, VoteHandler {
     }
 
     @Override
-    public String getVersion() {
-        return "2.3.2.2";
+    public LoggingAdapter getPluginLogger() {
+        return new JavaUtilLogger(Logger.getAnonymousLogger());
     }
 
     @Override
-    public void onVoteReceived(Vote vote, VotifierSession.ProtocolVersion protocolVersion) throws Exception {
+    public VotifierScheduler getScheduler() {
+        return scheduler;
+    }
+
+    @Override
+    public void onVoteReceived(Vote vote, VotifierSession.ProtocolVersion protocolVersion, String remoteAddress)
+            throws Exception {
         receiver.onVote(vote);
     }
 
     @Override
-    public void onError(Channel channel, Throwable throwable) {
+    public void onError(Throwable throwable, boolean alreadyHandledVote, String remoteAddress) {
         receiver.onException(throwable);
     }
 }

common/src/main/java/com/vexsoftware/votifier/util/standalone/VoteReceiver.java

@@ -4,5 +4,6 @@ import com.vexsoftware.votifier.model.Vote;
 
 public interface VoteReceiver {
     void onVote(Vote vote) throws Exception;
+
     void onException(Throwable throwable);
 }

common/src/main/java/com/vexsoftware/votifier/util/standalone/VotifierServerBuilder.java

@@ -2,11 +2,11 @@ package com.vexsoftware.votifier.util.standalone;
 
 import com.vexsoftware.votifier.net.protocol.v1crypto.RSAIO;
 import com.vexsoftware.votifier.util.KeyCreator;
-
 import java.io.File;
 import java.net.InetSocketAddress;
 import java.security.Key;
 import java.security.KeyPair;
+import java.security.interfaces.RSAKey;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -27,6 +27,9 @@ public class VotifierServerBuilder {
 
     public VotifierServerBuilder v1Key(KeyPair v1Key) {
         this.v1Key = Objects.requireNonNull(v1Key, "v1Key");
+        if (!(v1Key.getPrivate() instanceof RSAKey)) {
+            throw new IllegalArgumentException("Provided key is not an RSA key.");
+        }
         return this;
     }
 

common/src/test/java/com/vexsoftware/votifier/net/protocol/TestVotifierPlugin.java

@@ -1,87 +0,0 @@
-package com.vexsoftware.votifier.net.protocol;
-
-import com.vexsoftware.votifier.VotifierPlugin;
-import com.vexsoftware.votifier.util.KeyCreator;
-
-import javax.xml.bind.DatatypeConverter;
-import java.net.URL;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.security.*;
-import java.security.spec.PKCS8EncodedKeySpec;
-import java.security.spec.X509EncodedKeySpec;
-import java.util.HashMap;
-import java.util.Map;
-
-public class TestVotifierPlugin implements VotifierPlugin {
-    private static final byte[] PUBLIC_KEY;
-    private static final byte[] PRIVATE_KEY;
-
-    static byte[] r(String u) throws Exception {
-        URL resourceUrl = TestVotifierPlugin.class.getResource(u);
-        Path resourcePath = Paths.get(resourceUrl.toURI());
-
-        return DatatypeConverter.parseBase64Binary(new String(Files.readAllBytes(resourcePath), StandardCharsets.UTF_8));
-    }
-
-    static {
-        try {
-            PUBLIC_KEY = r("/public.key");
-            PRIVATE_KEY = r("/private.key");
-        } catch (Exception e) {
-            throw new AssertionError(e);
-        }
-    }
-
-    public static final TestVotifierPlugin I = new TestVotifierPlugin();
-
-    public static TestVotifierPlugin getI() {
-        return I;
-    }
-
-    private final Map<String, Key> keyMap = new HashMap<>();
-    private final KeyPair keyPair;
-
-    public TestVotifierPlugin() {
-        try {
-            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
-            X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(
-                    PUBLIC_KEY);
-            PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
-            PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
-                    PRIVATE_KEY);
-            PrivateKey privateKey = keyFactory.generatePrivate(privateKeySpec);
-            keyPair = new KeyPair(publicKey, privateKey);
-        } catch (Exception e) {
-            throw new AssertionError(e);
-        }
-        keyMap.put("default", KeyCreator.createKeyFrom("test"));
-    }
-
-    @Override
-    public Map<String, Key> getTokens() {
-        return keyMap;
-    }
-
-    @Override
-    public KeyPair getProtocolV1Key() {
-        return keyPair;
-    }
-
-    @Override
-    public String getVersion() {
-        return "2.3";
-    }
-
-    public void specificKeysOnly() {
-        keyMap.clear();
-        keyMap.put("Test", KeyCreator.createKeyFrom("test"));
-    }
-
-    public void restoreDefault() {
-        keyMap.clear();
-        keyMap.put("default", KeyCreator.createKeyFrom("test"));
-    }
-}

common/src/test/java/com/vexsoftware/votifier/net/protocol/VoteUtil.java

@@ -1,31 +0,0 @@
-package com.vexsoftware.votifier.net.protocol;
-
-import com.vexsoftware.votifier.model.Vote;
-import com.vexsoftware.votifier.net.protocol.v1crypto.RSA;
-
-import java.nio.charset.StandardCharsets;
-import java.security.PublicKey;
-import java.util.ArrayList;
-import java.util.List;
-
-public class VoteUtil {
-    public static byte[] encodePOJOv1(Vote vote) throws Exception {
-        return encodePOJOv1(vote, TestVotifierPlugin.getI().getProtocolV1Key().getPublic());
-    }
-
-    public static byte[] encodePOJOv1(Vote vote, PublicKey key) throws Exception {
-        List<String> ordered = new ArrayList<>();
-        ordered.add("VOTE");
-        ordered.add(vote.getServiceName());
-        ordered.add(vote.getUsername());
-        ordered.add(vote.getAddress());
-        ordered.add(vote.getTimeStamp());
-
-        StringBuilder builder = new StringBuilder();
-        for (String s : ordered) {
-            builder.append(s).append('\n'); // naive join needed!
-        }
-
-        return RSA.encrypt(builder.toString().getBytes(StandardCharsets.UTF_8), key);
-    }
-}

common/src/test/java/com/vexsoftware/votifier/net/protocol/VotifierProtocol1DecoderTest.java

@@ -1,89 +0,0 @@
-package com.vexsoftware.votifier.net.protocol;
-
-import com.vexsoftware.votifier.VotifierPlugin;
-import com.vexsoftware.votifier.model.Vote;
-import com.vexsoftware.votifier.net.VotifierSession;
-import com.vexsoftware.votifier.net.protocol.v1crypto.RSA;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.embedded.EmbeddedChannel;
-import io.netty.handler.codec.CorruptedFrameException;
-import org.junit.Test;
-
-import java.nio.charset.StandardCharsets;
-import java.security.KeyFactory;
-import java.security.PublicKey;
-import java.security.spec.X509EncodedKeySpec;
-
-import static org.junit.Assert.*;
-
-public class VotifierProtocol1DecoderTest {
-    private static final VotifierSession SESSION = new VotifierSession();
-
-    private EmbeddedChannel createChannel() {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocol1Decoder());
-        channel.attr(VotifierSession.KEY).set(SESSION);
-        channel.attr(VotifierPlugin.KEY).set(TestVotifierPlugin.getI());
-        return channel;
-    }
-
-    @Test
-    public void testSuccessfulDecode() throws Exception {
-        Vote votePojo = new Vote("Test", "test", "test", "test");
-
-        // Send the vote
-        EmbeddedChannel channel = createChannel();
-
-        byte[] encrypted = VoteUtil.encodePOJOv1(votePojo);
-        ByteBuf encryptedByteBuf = Unpooled.wrappedBuffer(encrypted);
-
-        assertTrue(channel.writeInbound(encryptedByteBuf));
-        Object presumedVote = channel.readInbound();
-        assertEquals(votePojo, presumedVote);
-        assertFalse(channel.finish());
-    }
-
-    private void verifyFailure(String bad) throws Exception {
-        // Send the bad vote
-        EmbeddedChannel channel = createChannel();
-
-        byte[] encrypted = RSA.encrypt(bad.getBytes(StandardCharsets.UTF_8), TestVotifierPlugin.getI().getProtocolV1Key().getPublic());
-        ByteBuf encryptedByteBuf = Unpooled.wrappedBuffer(encrypted);
-
-        try {
-            channel.writeInbound(encryptedByteBuf);
-        } finally {
-            channel.close();
-        }
-    }
-
-    @Test(expected = CorruptedFrameException.class)
-    public void testFailureDecodeMissingField() throws Exception {
-        verifyFailure("VOTE\nTest\ntest\ntest"); // missing field
-    }
-
-    @Test(expected = CorruptedFrameException.class)
-    public void testFailureDecodeBadOpcode() throws Exception {
-        verifyFailure("TEST\nTest\ntest\ntest\ntest\n");
-    }
-
-    @Test(expected = CorruptedFrameException.class)
-    public void testFailureDecodeBadRsa() throws Exception {
-        // Decode our bad RSA key
-        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
-        X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(TestVotifierPlugin.r("/bad_public.key"));
-        PublicKey badPublicKey = keyFactory.generatePublic(publicKeySpec);
-
-        // Send the bad vote
-        EmbeddedChannel channel = createChannel();
-
-        byte[] encrypted = VoteUtil.encodePOJOv1(new Vote("Test", "test", "test", "test"), badPublicKey);
-        ByteBuf encryptedByteBuf = Unpooled.wrappedBuffer(encrypted);
-
-        try {
-            channel.writeInbound(encryptedByteBuf);
-        } finally {
-            channel.close();
-        }
-    }
-}

common/src/test/java/com/vexsoftware/votifier/net/protocol/VotifierProtocol2DecoderTest.java

@@ -1,143 +0,0 @@
-package com.vexsoftware.votifier.net.protocol;
-
-import com.vexsoftware.votifier.VotifierPlugin;
-import com.vexsoftware.votifier.model.Vote;
-import com.vexsoftware.votifier.net.VotifierSession;
-import com.vexsoftware.votifier.util.KeyCreator;
-import io.netty.channel.embedded.EmbeddedChannel;
-import io.netty.handler.codec.CorruptedFrameException;
-import io.netty.handler.codec.DecoderException;
-import org.json.JSONObject;
-import org.junit.Test;
-
-import javax.crypto.Mac;
-import javax.xml.bind.DatatypeConverter;
-import java.nio.charset.StandardCharsets;
-import java.security.Key;
-
-import static org.junit.Assert.*;
-
-public class VotifierProtocol2DecoderTest {
-    private static final VotifierSession SESSION = new VotifierSession();
-
-    private EmbeddedChannel createChannel() {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocol2Decoder());
-        channel.attr(VotifierSession.KEY).set(SESSION);
-        channel.attr(VotifierPlugin.KEY).set(TestVotifierPlugin.getI());
-        return channel;
-    }
-
-    private void sendVote(Vote vote, Key key, boolean expectSuccess) throws Exception {
-        // Create a well-formed request
-        EmbeddedChannel channel = createChannel();
-
-        JSONObject object = new JSONObject();
-        JSONObject payload = vote.serialize();
-        payload.put("challenge", SESSION.getChallenge());
-        object.put("payload", payload.toString());
-        Mac mac = Mac.getInstance("HmacSHA256");
-        mac.init(key);
-        object.put("signature",
-                DatatypeConverter.printBase64Binary(mac.doFinal(payload.toString().getBytes(StandardCharsets.UTF_8))));
-
-        if (expectSuccess) {
-            assertTrue(channel.writeInbound(object.toString()));
-            assertEquals(vote, channel.readInbound());
-            assertFalse(channel.finish());
-        } else {
-            try {
-                channel.writeInbound(object.toString());
-            } finally {
-                channel.close();
-            }
-        }
-    }
-
-    @Test
-    public void testSuccessfulDecode() throws Exception {
-        sendVote(new Vote("Test", "test", "test", "0"), TestVotifierPlugin.getI().getTokens().get("default"), true);
-    }
-
-    @Test(expected = DecoderException.class)
-    public void testFailureDecodeBadPacket() throws Exception {
-        // Create a well-formed request
-        EmbeddedChannel channel = createChannel();
-
-        Vote vote = new Vote("Test", "test", "test", "0");
-        JSONObject object = new JSONObject();
-        JSONObject payload = vote.serialize();
-        payload.put("challenge", SESSION.getChallenge());
-        object.put("payload", payload.toString());
-        // We "forget" the signature.
-
-        try {
-            channel.writeInbound(object.toString());
-        } finally {
-            channel.close();
-        }
-    }
-
-    @Test(expected = DecoderException.class)
-    public void testFailureDecodeBadVoteField() throws Exception {
-        // Create a well-formed request
-        EmbeddedChannel channel = createChannel();
-
-        Vote vote = new Vote("Test", "test", "test", "0");
-        JSONObject object = new JSONObject();
-        JSONObject payload = vote.serialize();
-        // We "forget" the challenge.
-        object.put("payload", payload.toString());
-        Mac mac = Mac.getInstance("HmacSHA256");
-        mac.init(TestVotifierPlugin.getI().getTokens().get("default"));
-        object.put("signature",
-                DatatypeConverter.printBase64Binary(mac.doFinal(payload.toString().getBytes(StandardCharsets.UTF_8))));
-
-        try {
-            channel.writeInbound(object.toString());
-        } finally {
-            channel.close();
-        }
-    }
-
-    @Test(expected = DecoderException.class)
-    public void testFailureDecodeBadChallenge() throws Exception {
-        // Create a well-formed request
-        EmbeddedChannel channel = createChannel();
-
-        Vote vote = new Vote("Test", "test", "test", "0");
-        JSONObject object = new JSONObject();
-        JSONObject payload = vote.serialize();
-        // We provide the wrong challenge.
-        payload.put("challenge", "not a challenge for me");
-        object.put("payload", payload.toString());
-        Mac mac = Mac.getInstance("HmacSHA256");
-        mac.init(TestVotifierPlugin.getI().getTokens().get("default"));
-        object.put("signature",
-                DatatypeConverter.printBase64Binary(mac.doFinal(payload.toString().getBytes(StandardCharsets.UTF_8))));
-
-        try {
-            channel.writeInbound(object.toString());
-        } finally {
-            channel.close();
-        }
-    }
-
-    @Test(expected = DecoderException.class)
-    public void testFailureDecodeNonExistentKey() throws Exception {
-        TestVotifierPlugin.getI().specificKeysOnly();
-
-        Vote vote = new Vote("Bad Service", "test", "test", "0");
-
-        try {
-            sendVote(vote, TestVotifierPlugin.getI().getTokens().get("Test"), false);
-        } finally {
-            TestVotifierPlugin.getI().restoreDefault();
-        }
-    }
-
-    @Test(expected = CorruptedFrameException.class)
-    public void testFailureDecodeBadSignature() throws Exception {
-        Vote vote = new Vote("Bad Service", "test", "test", "0");
-        sendVote(vote, KeyCreator.createKeyFrom("BadKey"), false);
-    }
-}

common/src/test/java/com/vexsoftware/votifier/net/protocol/VotifierProtocolDifferentiatorTest.java

@@ -1,100 +0,0 @@
-package com.vexsoftware.votifier.net.protocol;
-
-import com.vexsoftware.votifier.model.Vote;
-import com.vexsoftware.votifier.net.VotifierSession;
-import io.netty.buffer.ByteBuf;
-import io.netty.buffer.Unpooled;
-import io.netty.channel.embedded.EmbeddedChannel;
-import io.netty.handler.codec.DecoderException;
-import org.junit.Test;
-
-import static org.junit.Assert.assertEquals;
-
-public class VotifierProtocolDifferentiatorTest {
-    @Test
-    public void v1Test() {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocolDifferentiator(true, true));
-
-        VotifierSession session = new VotifierSession();
-        channel.attr(VotifierSession.KEY).set(session);
-
-        ByteBuf test = Unpooled.buffer(256);
-        for (int i = 0; i < 256; i++) {
-            test.writeByte(0);
-        }
-        channel.writeInbound(test);
-
-        assertEquals(VotifierSession.ProtocolVersion.ONE, session.getVersion());
-        test.release();
-        channel.close();
-    }
-
-    @Test
-    public void v2Test() {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocolDifferentiator(true, false));
-
-        VotifierSession session = new VotifierSession();
-        channel.attr(VotifierSession.KEY).set(session);
-
-        ByteBuf test = Unpooled.buffer();
-        test.writeShort(0x733A);
-        channel.writeInbound(test);
-
-        assertEquals(VotifierSession.ProtocolVersion.TWO, session.getVersion());
-        test.release();
-        channel.close();
-    }
-
-    @Test(expected = DecoderException.class)
-    public void failIfv1NotSupported() {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocolDifferentiator(true, false));
-
-        VotifierSession session = new VotifierSession();
-        channel.attr(VotifierSession.KEY).set(session);
-
-        ByteBuf test = Unpooled.buffer(256);
-        for (int i = 0; i < 256; i++) {
-            test.writeByte(0);
-        }
-        channel.writeInbound(test);
-
-        assertEquals(VotifierSession.ProtocolVersion.ONE, session.getVersion());
-        test.release();
-        channel.close();
-    }
-
-    @Test(expected = DecoderException.class)
-    public void failOnBadPacketTest() {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocolDifferentiator(true, false));
-
-        ByteBuf buf = Unpooled.buffer();
-        for (int i = 0; i < 3; i++) {
-            buf.writeByte(0);
-        }
-
-        try {
-            channel.writeInbound(buf);
-        } finally {
-            buf.release();
-            channel.close();
-        }
-    }
-
-    @Test
-    public void tryIdentifyRealVotev1() throws Exception {
-        EmbeddedChannel channel = new EmbeddedChannel(new VotifierProtocolDifferentiator(true, true));
-
-        VotifierSession session = new VotifierSession();
-        channel.attr(VotifierSession.KEY).set(session);
-
-        Vote votePojo = new Vote("Test", "test", "test", "test");
-        byte[] encrypted = VoteUtil.encodePOJOv1(votePojo);
-        ByteBuf encryptedByteBuf = Unpooled.wrappedBuffer(encrypted);
-
-        channel.writeInbound(encryptedByteBuf);
-
-        assertEquals(VotifierSession.ProtocolVersion.ONE, session.getVersion());
-        encryptedByteBuf.release();
-        channel.close();
-    }
-}

common/src/test/resources/bad_public.key

@@ -1 +0,0 @@
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArrOsFuGPoHDZEFRHXriZRqrUXXjUOhVabC0Xu+WPtVbQrvNngN0igo0ZJIZELflhsFNBUJAnREo+wColfDg1rk2juEUYDt+gRzrN3WiqgzZolF3E4Dg4LrXh6cPuu4AeOZW9CtjXt2JwPBhlWLZb2RFhA6FziFLeMBa42/5VLFCQAmiuuU3OCiBskR3Jz/E5zqc7V/j247OMm+WRJ/k8OFTEFB+zFINOZY1ud3ltwkzQIPi1luGNW8Yt8+CEg/6hDiVlpFwgsazt4uKI/UfU5oP0kAKjQUfFGvNaBtJ0RlsBeJ7VDpOfIG6dDb8pe4IaA9aJLVcXWEn30pHsyYl2NwIDAQAB

common/src/test/resources/private.key

@@ -1 +0,0 @@
-MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCd5osoNvoLM52pN8U15QkRXpGVxk0WaoNLWgN24pnW30FIAO3bp8qD2FXJzX2hvw43LIwudVEbwmdzeytVWDNuigLqEsJJsXCHh9ORKjGVHvS240r6idfxJ139Jz2d3oSZG8acHdHgs/H/M98O8lz9Zb2KHtm+rxpiwsV2SdhMtfMDJmRx4p0JklgJ8TV1ZApoypbGtRKXHOirVSs6zfgaYaeglUNITAgsZZNZk+j9Pp572FxyYryxkUaWVn09RAD07XvWKJc3f7NBElA2LpuZXTYJh3BXaI/N05tdgPej5o99PXaA2UMhdqo778zoQoeWzOvbNMUqZROqGW5WDwhdAgMBAAECggEAM8xcXB3k2uXc05UrCaoP1nXadnKt+SuJ1J87wbVGWDm21aMQZF1fzu6Z/fB+RSBCzpC7j8YGjH+ypiyCo6WigaGeoSD0QW6HBr7lBZr81vlnt9NKVnP/tel/KLvFt9M2Vm/JMI+LuRXuzhQ7GVEidjH5AqVqMuaIVlukoVBKN6d20KihcHeCjOZLAoL727QYGrHNr0eH9wQpgMzj3A51ubi5ma3bDvnSvN4ZoP3BhmDTRVnHEh4hx/XFYELi3RDGN2SDjegNXlZ+e03BHCGRryOCuwY1eua78gkrWN8sr3QAdWhEN/Pdwq0BpVsdsbyPzmgoamAMmBbKyBnEJxuvlQKBgQDtLQIhFVYA7vNtpwnXV3ahyEPCNf+tLJYsLYjKWRpoTw6bI3FfgMAEPGbDXLsmLi37mvRmCJpoU9j4nfRd/umoEIW6xuaYDdGRpyaiOlkEXyJd0n3uv/3mF7VtyltrPK3Mt2Gb7kGaZqe07B4a5UC02CCvpKqpbFfC0XxHP32GkwKBgQCqbs2D/pNcdA9iHm+AhX/oylK+BfiruTvLx/c2wOFleQOiNZUZCC6zELIDzuQXPlk9mlNshnciIItcjnyLGkDr2lvJpt6Bi65Jx5hYhlWrms883/hRUSjgKtJ9PFWl8wUVTJJsrOg0fm2ZM+YXpO9AvziRTEPj2MeibQjjlfsbTwKBgHc1ZBiUzMFzWM8IYh3mTC5MpiH7WiMEggZ6bIKn/mnnMoQvcFB8OgbnBQ+0kCxEkcAgxi5yrIk7e5aabbTA51gd1dlnF4fdijQXO4fWo99aob9eiQVzYn4/9GTWjNR9jy2SDnF9c2PTrP92njsOd1NuPh+KOG0nk4TMHhcBhmoZAoGAF4ZPy8ZZ5MsITIzS6zSCIUm7/gqo9lsNC+XAE8iv0+fOPpeSyu+8Mm89gxUNmr+6Zaxlk3dD/mvrkI0CV9j52RQ80yq7T7pOBlUMjDuOm680p7xqdB71u2ttvmeTkuJmczgshd+f9Y715c2qFt1nQNKkJjoWrN6BP8Q5E+Dh1jUCgYEApBuFGwmcSob6rIzinM4nJRyMLXqIy6nKCy8bBLkWCFPGztjIxhKBA/pErADhkLaLyM5reeMPNBbxruAFJ3mzfOneKf9lt0oHq2/jq0vJvYUj9tZjD2Sw6dhj0JqQhKIkhux1rU1xAAedY21JGTS+Be0dFfSv5uDrErPJiN+Qyt0=

common/src/test/resources/public.key

@@ -1 +0,0 @@
-MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAneaLKDb6CzOdqTfFNeUJEV6RlcZNFmqDS1oDduKZ1t9BSADt26fKg9hVyc19ob8ONyyMLnVRG8Jnc3srVVgzbooC6hLCSbFwh4fTkSoxlR70tuNK+onX8Sdd/Sc9nd6EmRvGnB3R4LPx/zPfDvJc/WW9ih7Zvq8aYsLFdknYTLXzAyZkceKdCZJYCfE1dWQKaMqWxrUSlxzoq1UrOs34GmGnoJVDSEwILGWTWZPo/T6ee9hccmK8sZFGllZ9PUQA9O171iiXN3+zQRJQNi6bmV02CYdwV2iPzdObXYD3o+aPfT12gNlDIXaqO+/M6EKHlszr2zTFKmUTqhluVg8IXQIDAQAB

config/checkstyle/checkstyle.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC
+  "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+  "https://checkstyle.org/dtds/configuration_1_3.dtd">
+<module name="Checker">
+
+  <module name="FileTabCharacter">
+    <property name="eachLine" value="true"/>
+    <property name="severity" value="error"/>
+  </module>
+
+  <module name="TreeWalker">
+    <module name="FinalLocalVariable"/>
+    <module name="AvoidStarImport"/>
+    <module name="Indentation">
+      <property name="severity" value="ignore"/>
+    </module>
+  </module>
+
+  <module name="RegexpSingleline">
+    <property name="format" value="\borg\.junit\.jupiter\.api\.Assertions\.fail\s*\(\s*&quot;Not yet implemented&quot;\s*\)\s*;"/>
+    <property name="message" value="Remove placeholder fail() and implement the test."/>
+    <property name="ignoreCase" value="true"/>
+    <property name="severity" value="warning"/>
+  </module>
+
+  <module name="RegexpSingleline">
+    <property name="format" value="(?&lt;!\w)fail\s*\(\s*&quot;Not yet implemented&quot;\s*\)\s*;"/>
+    <property name="message" value="Remove placeholder fail() and implement the test."/>
+    <property name="severity" value="warning"/>
+  </module>
+
+</module>
+

config/formatter/eclipse-java-formatter.xml

@@ -0,0 +1,404 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="23">
+    <profile kind="CodeFormatterProfile" name="TrueOG Network Formatting" version="23">
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_with_spaces" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.enabling_tag" value="@formatter:on"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_record_components" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_logical_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_shift_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_parameters" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_loops" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_switch_case_arrow_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_enum_constant" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.text_block_indentation" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_module_statements" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_permitted_types" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_annotations" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_method_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines" value="2147483647"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_not_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_arguments" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_package" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_label" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_permitted_types_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.javadoc_do_not_separate_block_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_tag_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_constructor" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_string_concatenation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_additive_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case_after_arrow" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_lines_in_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.disabling_tag" value="@formatter:off"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_arrow" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_on_off_tags" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_method_body_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_additive_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_lambda_body" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_parameter" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_relational_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_arrows_in_switch_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_case_with_arrow_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_type" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_field" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_conditional_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_shift_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_code_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assignment_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_switch_case_with_arrow" value="20"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_method" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assertion_message" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_relational_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_logical_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_permitted_types" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="space"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_string_concatenation" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.lineSplit" value="120"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+    </profile>
+</profiles>

eclipse.gradle.kts

@@ -0,0 +1,151 @@
+/* This is free and unencumbered software released into the public domain */
+
+import org.gradle.plugins.ide.eclipse.model.EclipseModel
+import java.nio.file.Files
+import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.OutputKeys
+import javax.xml.transform.TransformerFactory
+import javax.xml.transform.dom.DOMSource
+import javax.xml.transform.stream.StreamResult
+
+val kotlinAttribute: Attribute<Boolean> by rootProject.extra
+
+val kotlinPluginProjects = configurations
+.getByName("compileClasspath")
+.allDependencies
+    .filterIsInstance<ProjectDependency>()
+    .filter { it -> it.attributes.getAttribute(kotlinAttribute) != null }
+    .map { it.path }
+kotlinPluginProjects.forEach { evaluationDependsOn(it) }
+
+val ideLibs: Configuration by
+configurations.creating {
+    isCanBeResolved = true
+    isCanBeConsumed = false
+}
+
+configure<EclipseModel> {
+    project {
+        name = "Template-OG-Plugin"
+    }
+    classpath {
+        plusConfigurations.add(ideLibs)
+    }
+}
+
+val ideLibDir = layout.buildDirectory.dir("ide-libs")
+val hashRegex = Regex("-[0-9a-fA-F]{10}(?=\\.jar$)") // Black magic.
+
+val copyTasks = mutableListOf<TaskProvider<Copy>>()
+
+kotlinPluginProjects.forEach { path ->
+    val sub = project(path)
+    val shadowJarProv = sub.tasks.named("shadowJar")
+    val copyTask =
+        tasks.register<Copy>("ideCopy${sub.name.replaceFirstChar(Char::titlecase)}") {
+            dependsOn(shadowJarProv)
+            from(shadowJarProv)
+            into(ideLibDir)
+            rename { it.replace(hashRegex, "") } // Remove git commit hash from jarfile.
+        }
+    copyTasks += copyTask
+}
+
+/* Ensure the jars exist before .classpath is generated */
+tasks.named("eclipseClasspath").configure { dependsOn(copyTasks) }
+
+/* Supply those jars to the ideLibs configuration (after evaluation) */
+afterEvaluate { dependencies { add("ideLibs", fileTree(ideLibDir) { include("*.jar") }) } }
+
+val injectIdeLibs =
+    tasks.register("injectIdeLibs") {
+        dependsOn("eclipse") // run after all eclipse files are generated
+        doLast {
+            val cpFile = file(".classpath")
+            if (!cpFile.exists()) return@doLast
+
+            val jars = fileTree(ideLibDir.get()) { include("*.jar") }.files.sortedBy { it.name }
+            if (jars.isEmpty()) return@doLast
+
+            // Parse DOM
+            val dbf = DocumentBuilderFactory.newInstance()
+            val doc = dbf.newDocumentBuilder().parse(cpFile)
+            val root = doc.documentElement
+
+            // Helper to see if an entry already exists
+            fun exists(path: String): Boolean =
+                root.getElementsByTagName("classpathentry").let { list ->
+                    (0 until list.length).any { i ->
+                        val n = list.item(i)
+                        val kind = n.attributes?.getNamedItem("kind")?.nodeValue
+                        val p = n.attributes?.getNamedItem("path")?.nodeValue
+                        kind == "lib" && p == path
+                    }
+                }
+
+            // Remove any entry that points to ide-libs dir (folder or jars) to avoid dupes
+            val toRemove = mutableListOf<org.w3c.dom.Node>()
+            val list = root.getElementsByTagName("classpathentry")
+            val dirPath = ideLibDir.get().asFile.absolutePath
+            for (i in 0 until list.length) {
+                val n = list.item(i)
+                val kind = n.attributes?.getNamedItem("kind")?.nodeValue
+                val p = n.attributes?.getNamedItem("path")?.nodeValue ?: ""
+                if (kind == "lib" && (p == dirPath || p.startsWith("$dirPath/"))) {
+                    toRemove += n
+                }
+            }
+            toRemove.forEach { root.removeChild(it) }
+
+            // Append our jar entries LAST
+            jars.forEach { f ->
+                val abs = f.absolutePath
+                if (!exists(abs)) {
+                    val entry = doc.createElement("classpathentry")
+                    entry.setAttribute("kind", "lib")
+                    entry.setAttribute("path", abs)
+                    root.appendChild(entry)
+                }
+            }
+
+            // Write back pretty
+            val tf =
+                TransformerFactory.newInstance().newTransformer().apply {
+                    setOutputProperty(OutputKeys.INDENT, "yes")
+                    setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "1")
+                    setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no")
+                    setOutputProperty(OutputKeys.ENCODING, "UTF-8")
+                }
+            Files.newBufferedWriter(cpFile.toPath()).use { w -> tf.transform(DOMSource(doc), StreamResult(w)) }
+        }
+    }
+
+tasks.named("eclipse").configure { finalizedBy(injectIdeLibs) }
+
+val eclipseModel = extensions.getByType<EclipseModel>()
+
+fun Project.addResolvableEclipseConfigs() {
+    val jarAttr =
+        objects.named(org.gradle.api.attributes.LibraryElements::class, org.gradle.api.attributes.LibraryElements.JAR)
+    val apiAttr = objects.named(org.gradle.api.attributes.Usage::class, org.gradle.api.attributes.Usage.JAVA_API)
+
+    val compileOnlyRes =
+        configurations.create("eclipseCompileOnly") {
+            extendsFrom(configurations.getByName("compileOnly"))
+            isCanBeResolved = true
+            isCanBeConsumed = false
+            attributes.attribute(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE, apiAttr)
+            attributes.attribute(org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, jarAttr)
+        }
+    val compileOnlyApiRes =
+        configurations.create("eclipseCompileOnlyApi") {
+            extendsFrom(configurations.getByName("compileOnlyApi"))
+            isCanBeResolved = true
+            isCanBeConsumed = false
+            attributes.attribute(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE, apiAttr)
+            attributes.attribute(org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, jarAttr)
+        }
+    eclipseModel.classpath.plusConfigurations.addAll(listOf(compileOnlyRes, compileOnlyApiRes))
+}
+
+addResolvableEclipseConfigs()

gradle.properties

@@ -0,0 +1,3 @@
+org.gradle.jvmargs=-Xmx4G
+group=net.trueog.votifier-og
+version=3.0.2

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pom.xml

@@ -1,57 +0,0 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-    <groupId>com.vexsoftware</groupId>
-    <artifactId>nuvotifier</artifactId>
-    <packaging>pom</packaging>
-    <version>2.3.2.2</version>
-    <modules>
-        <module>common</module>
-        <module>bukkit</module>
-        <module>bungeecord</module>
-        <module>universal</module>
-        <module>sponge</module>
-    </modules>
-    <name>NuVotifier</name>
-    <properties>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-    <repositories>
-        <repository>
-            <id>sonatype</id>
-            <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
-        </repository>
-        <repository>
-            <id>bukkit</id>
-            <url>http://repo.bukkit.org/content/groups/public/</url>
-        </repository>
-    </repositories>
-
-    <distributionManagement>
-        <repository>
-            <id>minimumio-repo</id>
-            <url>http://repo.minimum.io/content/repositories/releases/</url>
-        </repository>
-        <snapshotRepository>
-            <id>minimumio-repo-snapshots</id>
-            <url>http://repo.minimum.io/content/repositories/snapshots/</url>
-        </snapshotRepository>
-    </distributionManagement>
-
-    <build>
-        <defaultGoal>clean package</defaultGoal>
-        <plugins>
-            <!-- Compiler -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>2.3.2</version>
-                <configuration>
-                    <source>1.7</source>
-                    <target>1.7</target>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-</project>