Initial autoupdater

src/main/java/kcauldron/updater/CommandSenderUpdateCallback.java

@@ -0,0 +1,59 @@
+package kcauldron.updater;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+
+import kcauldron.updater.KVersionRetriever.IVersionCheckCallback;
+
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+public class CommandSenderUpdateCallback implements IVersionCheckCallback {
+	private Reference<CommandSender> mSender;
+
+	public CommandSenderUpdateCallback(CommandSender sender) {
+		mSender = new WeakReference<CommandSender>(sender);
+	}
+	
+	protected CommandSender getSender() {
+		return mSender.get();
+	}
+
+	@Override
+	public void upToDate(String version) {
+		CommandSender sender = mSender.get();
+		if (sender != null) {
+			sender.sendMessage(ChatColor.GREEN
+					+ "Running version of KCauldron is up-to-date: " + version);
+		}
+		DefaultUpdateCallback.INSTANCE.upToDate(version);
+	}
+
+	@Override
+	public void newVersion(String currentVersion, String newVersion) {
+		CommandSender sender = mSender.get();
+		if (sender != null) {
+			newVersion(sender, currentVersion, newVersion);
+		}
+		DefaultUpdateCallback.INSTANCE.newVersion(currentVersion, newVersion);
+	}
+
+	public static void newVersion(CommandSender sender, String currentVersion, String newVersion) {
+		sender.sendMessage(new String[] {
+				ChatColor.YELLOW + "Found new version of KCauldron: "
+						+ newVersion,
+				ChatColor.YELLOW + "Current is " + currentVersion,
+				ChatColor.YELLOW + "Type '" + ChatColor.BLUE
+						+ "/kc update" + ChatColor.YELLOW
+						+ "' to update" });
+	}
+
+	@Override
+	public void error(Throwable t) {
+		CommandSender sender = mSender.get();
+		if (sender != null) {
+			sender.sendMessage(ChatColor.RED
+					+ "Error ocurred durring version check, see details in server log");
+		}
+	}
+}

src/main/java/kcauldron/updater/DefaultUpdateCallback.java

@@ -0,0 +1,74 @@
+package kcauldron.updater;
+
+import kcauldron.KCauldron;
+import kcauldron.KCauldronCommand;
+import kcauldron.updater.KVersionRetriever.IVersionCheckCallback;
+import net.minecraft.server.MinecraftServer;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerJoinEvent;
+
+public class DefaultUpdateCallback implements IVersionCheckCallback {
+	public static DefaultUpdateCallback INSTANCE;
+
+	static {
+		INSTANCE = new DefaultUpdateCallback();
+	}
+
+	public void onPlayerJoin(PlayerJoinEvent event) {
+		Player player = event.getPlayer();
+		if (mHasUpdate && hasPermission(player)) {
+			sendUpdate(player);
+		}
+	}
+
+	private boolean hasPermission(CommandSender player) {
+		return player.hasPermission(KCauldronCommand.UPDATE);
+	}
+
+	private void sendUpdate(CommandSender player) {
+		CommandSenderUpdateCallback.newVersion(player, mCurrentVersion,
+				mNewVersion);
+	}
+
+	private boolean mHasUpdate;
+	private String mCurrentVersion;
+	private String mNewVersion;
+
+	private DefaultUpdateCallback() {
+	}
+
+	@Override
+	public void upToDate(String version) {
+		mHasUpdate = false;
+		mCurrentVersion = version;
+		mNewVersion = null;
+	}
+
+	@Override
+	public void newVersion(String currentVersion, String newVersion) {
+		mCurrentVersion = currentVersion;
+		mNewVersion = newVersion;
+		if (!mHasUpdate) {
+			for (Player player : Bukkit.getOnlinePlayers()) {
+				if (hasPermission(player)) {
+					sendUpdate(player);
+				}
+			}
+		}
+		mHasUpdate = true;
+		if (MinecraftServer.kcauldronConfig.updatecheckerAutoinstall.getValue()
+				&& !mNewVersion.equals(KCauldron.sNewServerVersion)
+				&& !KCauldron.sUpdateInProgress) {
+			Bukkit.getConsoleSender().sendMessage("Triggering auto update");
+			KCauldronUpdater.initUpdate(Bukkit.getConsoleSender(), newVersion);
+		}
+	}
+
+	@Override
+	public void error(Throwable t) {
+
+	}
+}

src/main/java/kcauldron/updater/KCauldronUpdater.java

@@ -0,0 +1,186 @@
+package kcauldron.updater;
+
+import java.io.File;
+import java.io.InputStream;
+import java.nio.file.Files;
+
+import kcauldron.KCauldron;
+import net.minecraft.server.MinecraftServer;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.client.methods.RequestBuilder;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+
+import com.google.common.base.Splitter;
+
+public class KCauldronUpdater implements Runnable {
+	private static final class LatestVersionCallback extends
+			CommandSenderUpdateCallback {
+		public LatestVersionCallback(CommandSender sender) {
+			super(sender);
+		}
+
+		@Override
+		public void newVersion(String currentVersion, String newVersion) {
+			startUpdate(getSender(), newVersion);
+		}
+
+		@Override
+		public void upToDate(String version) {
+			CommandSender sender = getSender();
+			if (sender != null) {
+				sender.sendMessage(ChatColor.DARK_PURPLE + "Current version ("
+						+ version + ") is up to date");
+			}
+		}
+	}
+
+	public static void initUpdate(CommandSender sender, String version) {
+		if (KCauldron.sUpdateInProgress) {
+			sender.sendMessage(ChatColor.RED
+					+ "Update stopped: another update in progress");
+			return;
+		}
+		KCauldron.sUpdateInProgress = true;
+		if (version == null) {
+			sender.sendMessage(ChatColor.DARK_PURPLE
+					+ "Fetching latest version...");
+			new KVersionRetriever(new LatestVersionCallback(sender), false);
+		} else {
+			startUpdate(sender, version);
+		}
+	}
+
+	private static void startUpdate(CommandSender sender, String version) {
+		if (sender != null) {
+			sender.sendMessage(ChatColor.DARK_PURPLE + "Starting update to "
+					+ version + "...");
+		}
+		new KCauldronUpdater(sender, version);
+	}
+
+	private final CommandSender mSender;
+	private final String mVersion;
+	private final Thread mThread;
+
+	public KCauldronUpdater(CommandSender sender, String version) {
+		mSender = sender;
+		mVersion = version;
+		mThread = new Thread(this);
+		mThread.setName("KCauldron updater");
+		mThread.setPriority(Thread.MIN_PRIORITY);
+		mThread.start();
+	}
+
+	@Override
+	public void run() {
+		try {
+			boolean quite = MinecraftServer.kcauldronConfig.updatecheckerQuite
+					.getValue();
+			MinecraftServer server = MinecraftServer.getServer();
+			final String filename = "KCauldron-" + mVersion + "-server.jar";
+			File path = KCauldron.getServerLocation();
+			File newPath = new File(path.getParentFile(),
+					getInstallAs(filename));
+			if (mSender != null) {
+				if (!quite) {
+					mSender.sendMessage(ChatColor.DARK_PURPLE
+							+ "Current version is located in " + ChatColor.GOLD
+							+ path.getAbsolutePath());
+					mSender.sendMessage(ChatColor.DARK_PURPLE
+							+ "Installing new version in " + ChatColor.GOLD
+							+ newPath.getAbsolutePath());
+				}
+				if (newPath.exists()) {
+					Bukkit.getConsoleSender().sendMessage(
+							"ERROR: Install location already exists: "
+									+ newPath.getAbsolutePath());
+					mSender.sendMessage(ChatColor.RED
+							+ "ERROR: Install location already exists");
+					return;
+				}
+				if (!quite) {
+					mSender.sendMessage(ChatColor.DARK_PURPLE
+							+ "Downloading new version...");
+				}
+			}
+			HttpUriRequest request = RequestBuilder
+					.get()
+					.setUri("https://prok.pw/repo/pw/prok/KCauldron/"
+							+ mVersion + "/" + filename)
+					.addParameter("hostname", server.getHostname())
+					.addParameter("port", "" + server.getPort()).build();
+			HttpResponse response = HttpClientBuilder.create()
+					.setUserAgent("KCauldron Updater").build().execute(request);
+			InputStream is = response.getEntity().getContent();
+			Files.copy(is, newPath.toPath());
+			if (mSender != null && !quite) {
+				mSender.sendMessage(ChatColor.DARK_PURPLE
+						+ "Download completed");
+			}
+			makeSymlinks(newPath);
+			if (MinecraftServer.kcauldronConfig.updatecheckerDeleteOld
+					.getValue()) {
+				if (mSender != null && !quite) {
+					mSender.sendMessage(ChatColor.DARK_PURPLE
+							+ "Mark old version for deletion");
+				}
+				path.deleteOnExit();
+				if (KCauldron.sNewServerLocation != null) {
+					KCauldron.sNewServerLocation.deleteOnExit();
+				}
+			}
+			if (mSender != null) {
+				mSender.sendMessage(ChatColor.DARK_PURPLE + "Update completed");
+			}
+			KCauldron.sNewServerLocation = newPath;
+			KCauldron.sNewServerVersion = mVersion;
+		} catch (Exception e) {
+			e.printStackTrace();
+			if (mSender != null) {
+				mSender.sendMessage(ChatColor.RED + "Failed update to "
+						+ mVersion);
+			}
+		} finally {
+			KCauldron.sUpdateInProgress = false;
+		}
+	}
+
+	private String getInstallAs(String filename) {
+		String path = MinecraftServer.kcauldronConfig.updatecheckerInstallAs
+				.getValue().trim();
+		if (path.length() > 0) {
+			return path.replace("%version%", mVersion);
+		}
+		return filename;
+	}
+
+	private void makeSymlinks(File newPath) {
+		try {
+			for (String symlink : Splitter.on(File.pathSeparatorChar).split(
+					MinecraftServer.kcauldronConfig.updatecheckerSymlinks
+							.getValue())) {
+				symlink = symlink.trim();
+				if (symlink.length() == 0)
+					continue;
+				File symlinkPath = new File(symlink);
+				if (mSender != null
+						&& !MinecraftServer.kcauldronConfig.updatecheckerQuite
+								.getValue()) {
+					mSender.sendMessage(ChatColor.RED + "Create symlink "
+							+ ChatColor.GOLD + symlinkPath.getAbsolutePath());
+				}
+				if (symlinkPath.exists()) {
+					symlinkPath.delete();
+				}
+				Files.createSymbolicLink(symlinkPath.toPath(), newPath.toPath());
+			}
+		} catch (Exception e) {
+
+		}
+	}
+}

src/main/java/kcauldron/updater/KVersionRetriever.java

@@ -0,0 +1,113 @@
+package kcauldron.updater;
+
+import java.io.InputStreamReader;
+import java.lang.Thread.UncaughtExceptionHandler;
+
+import kcauldron.KCauldron;
+import kcauldron.KLog;
+import net.minecraft.server.MinecraftServer;
+
+import org.apache.http.HttpResponse;
+import org.apache.http.client.methods.HttpUriRequest;
+import org.apache.http.client.methods.RequestBuilder;
+import org.apache.http.impl.client.HttpClientBuilder;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+
+public class KVersionRetriever implements Runnable, UncaughtExceptionHandler {
+	private static final boolean DEBUG;
+	private static final KLog sLogger;
+	private static final JSONParser sParser;
+	private static final String sCurrentVersion;
+	private static MinecraftServer sServer;
+
+	static {
+		DEBUG = false;
+		sLogger = KLog.get(KVersionRetriever.class.getSimpleName());
+
+		sCurrentVersion = KCauldron.getCurrentVersion();
+		sParser = new JSONParser();
+	}
+
+	public static void init(MinecraftServer server) {
+		sServer = server;
+		if (MinecraftServer.kcauldronConfig.updatecheckerEnable.getValue()) {
+			new KVersionRetriever(DefaultUpdateCallback.INSTANCE, true);
+		}
+	}
+
+	private final IVersionCheckCallback mCallback;
+	private final boolean mLoop;
+	private final Thread mThread;
+
+	public KVersionRetriever(IVersionCheckCallback callback, boolean loop) {
+		if (DEBUG)
+			sLogger.info("Created new version retrivier");
+		mCallback = callback;
+		mLoop = loop;
+		mThread = new Thread(this);
+		mThread.setName("KCauldron version retrievier");
+		mThread.setPriority(Thread.MIN_PRIORITY);
+		mThread.setDaemon(true);
+		mThread.setUncaughtExceptionHandler(this);
+		mThread.start();
+	}
+
+	@Override
+	public void run() {
+		while (!mThread.isInterrupted()) {
+			check();
+			if (!mLoop)
+				break;
+			try {
+				Thread.sleep(1000 * 60 * 10);// Sleep ten minutes
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+		}
+	}
+
+	private void check() {
+		if (DEBUG)
+			sLogger.info("Requesting for new version...");
+		try {
+			HttpUriRequest request = RequestBuilder.get()
+					.setUri("https://prok.pw/version/pw.prok/KCauldron")
+					.addParameter("hostname", sServer.getHostname())
+					.addParameter("port", "" + sServer.getPort()).build();
+			HttpResponse response = HttpClientBuilder.create()
+					.setUserAgent("KCauldron Version Retriever").build()
+					.execute(request);
+			JSONObject json = (JSONObject) sParser.parse(new InputStreamReader(
+					response.getEntity().getContent()));
+			String version = (String) json.get("version");
+			if (DEBUG) {
+				sLogger.info("Got the latest version: %s", version);
+				sLogger.info("Current version is %s", sCurrentVersion);
+			}
+			if (!sCurrentVersion.equals(version)) {
+				mCallback.newVersion(sCurrentVersion, version);
+			} else {
+				mCallback.upToDate(version);
+			}
+		} catch (Exception e) {
+			uncaughtException(null, e);
+		}
+	}
+
+	@Override
+	public void uncaughtException(Thread t, Throwable e) {
+		sLogger.warning(e, "Error occured during retriving version");
+		if (mCallback != null) {
+			mCallback.error(e);
+		}
+	}
+
+	public interface IVersionCheckCallback {
+		void upToDate(String version);
+
+		void newVersion(String currentVersion, String newVersion);
+
+		void error(Throwable t);
+	}
+}