Updater.java

/**
 * This file is part of LWC (https://github.com/Hidendra/LWC)
 *
 * This program 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.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package com.griefcraft.util;


import com.griefcraft.lwc.LWC;
import com.griefcraft.lwc.LWCInfo;
import com.griefcraft.scripting.ModuleLoader;
import com.griefcraft.sql.Database;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Updater {

    public enum UpdateMethod {

        /**
         * Updating will be performed automatically by LWC
         */
        AUTOMATIC,

        /**
         * Updating will be performed manually by the admin
         */
        MANUAL

    }

    public enum UpdateScheme {

        /**
         * Long release schedules and is recommended on any server that wishes to have stable LWC features
         * but does not necessarily want the very latest LWC has to offer in features, bug fixes, and
         * performance.
         */
        STABLE("stable"),

        /**
         * The best middle-ground between getting the newest features and having a stable build. Builds received
         * from the CURRENT branch should never totally break LWC, but the possibility still exists. Builds in
         * this scheme will almost always display -alphaX or -betaX in /lwc admin version but may also display -rcX
         * for builds that are nearing a full release.
         */
        CURRENT("current"),

        /**
         * The most volatile scheme. Should not be used on production servers but offers the most up to date features
         * but testing may not have been performed all around. Performance may also not have been rounded out and
         * any features may be removed at any time. Versioning for this scheme is based off of the current and latest
         * build number.
         */
        BLEEDING_EDGE("bleeding");

        /**
         * The branch name to use on the update site
         */
        private String branch;

        UpdateScheme(String branch) {
            this.branch = branch;
        }

        /**
         * @return
         */
        public String getBranch() {
            return branch;
        }

    }

    /**
     * The logging object for this class
     */
    private final Logger logger = Logger.getLogger("LWC");

    /**
     * URL to the base update site
     */
    public final static String UPDATE_SITE = "http://griefcraft.com/lwc/";

    /**
     * URL to the Jenkins job for LWC
     */
    public final static String JENKINS = "http://ci.griefcraft.com/job/LWC/";

    /**
     * The folder where libraries are stored
     */
    public final static String DEST_LIBRARY_FOLDER = "plugins/LWC/lib/";

    /**
     * The queue of files that need to be downloaded
     */
    private final Queue<UpdaterFile> fileQueue = new ConcurrentLinkedQueue<UpdaterFile>();

    /**
     * The update scheme to use
     */
    private UpdateScheme updateScheme;

    /**
     * The update method to use
     */
    private UpdateMethod updateMethod;

    /**
     * The latest plugin version
     */
    private Version latestVersion;

    public void init() {
        // some vars that will probably be removed later, testing purposes at the moment
        LWC lwc = LWC.getInstance();
        updateScheme = UpdateScheme.valueOf(lwc.getConfiguration().getString("core.updateScheme", "BLEEDING_EDGE"));
        updateMethod = UpdateMethod.valueOf(lwc.getConfiguration().getString("core.updateMethod", "MANUAL"));
        logger.info("LWC: Update scheme: " + updateScheme);
        logger.info("LWC: Update method: " + updateMethod);

        this.loadVersions(true, new Runnable() {

            public void run() {
                tryAutoUpdate(false);
                logger.info("LWC: Latest version: " + latestVersion);
            }

        });

        // verify we have local files (e.g sqlite.jar, etc)
        this.verifyFiles();
        this.downloadFiles();
    }

    /**
     * Download all the files in the queue
     */
    public void downloadFiles() {
        synchronized (fileQueue) {
            UpdaterFile updaterFile = null;

            while ((updaterFile = fileQueue.poll()) != null) {
                try {
                    File local = new File(updaterFile.getLocalLocation());
                    String remote = updaterFile.getRemoteLocation();

                    logger.info("LWC: Downloading file " + local.getName());

                    // check for LWC folder
                    File folder = new File("plugins/LWC/");
                    if (!folder.exists()) {
                        folder.mkdir();
                    }

                    // check native folders
                    folder = new File(getOSSpecificFolder());
                    if (!folder.exists()) {
                        folder.mkdirs();
                    }

                    if (local.exists()) {
                        local.delete();
                    }

                    // create the local file
                    local.createNewFile();

                    // open the file
                    OutputStream outputStream = new FileOutputStream(local);

                    // Connect to the server
                    URL url = new URL(remote);
                    URLConnection connection = url.openConnection();

                    InputStream inputStream = connection.getInputStream();

                    // hopefully, the content length provided isn't -1
                    int contentLength = connection.getContentLength();

                    // Keep a running tally
                    int bytesTransffered = 0;
                    long lastUpdate = 0L;

                    // begin transferring
                    byte[] buffer = new byte[1024];
                    int read = 0;

                    while ((read = inputStream.read(buffer)) > 0) {
                        outputStream.write(buffer, 0, read);
                        bytesTransffered += read;

                        if (contentLength > 0) {
                            if (System.currentTimeMillis() - lastUpdate > 500L) {
                                int percentTransferred = (int) (((float) bytesTransffered / contentLength) * 100);
                                lastUpdate = System.currentTimeMillis();

                                // omit 100% ..
                                if (percentTransferred != 100) {
                                    logger.info(percentTransferred + "%");
                                }
                            }
                        }
                    }

                    // ok!
                    outputStream.close();
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * Try and automatically update, if automatic updating is enabled.
     *
     * @param forceUpdate
     * @return true if LWC was updated
     */
    public boolean tryAutoUpdate(boolean forceUpdate) {
        if (!forceUpdate) {
            // do we qualify for an automatic update?
            if (!shouldAutoUpdate()) {
                return false;
            }
        }

        // we shouldn't update if the current version is equal to the latest
        if (LWCInfo.FULL_VERSION.equals(latestVersion)) {
            return false;
        }

        logger.info("LWC: Updating found!");

        // update_site/download/LWC.jar
        UpdaterFile file = new UpdaterFile("plugins/LWC.jar", getLatestDownloadURL());

        // queue it
        fileQueue.offer(file);

        // immediately download
        downloadFiles();
        return true;
    }

    /**
     * Verify all required files exist
     */
    private void verifyFiles() {
        // SQLite libraries
        if (Database.DefaultType == Database.Type.SQLite) {
            // sqlite.jar
            this.verifyFile(new UpdaterFile(DEST_LIBRARY_FOLDER + "sqlite.jar", "http://griefcraft.com/bukkit/shared/lib/sqlite.jar"));

            // Native library
            this.verifyFile(new UpdaterFile(getFullNativeLibraryPath(), "http://griefcraft.com/bukkit/shared/" + getFullNativeLibraryPath().replaceAll(DEST_LIBRARY_FOLDER, "")));
        }
    }

    /**
     * Verify a file and if it does not exist, download it
     *
     * @param updaterFile
     * @return true if the file was queued to be downloaded
     */
    private boolean verifyFile(UpdaterFile updaterFile) {
        if (updaterFile == null) {
            return false;
        }

        File file = new File(updaterFile.getLocalLocation());

        // Does it exist on the FS?
        if (file.exists()) {
            // So it does!
            return false;
        }

        // It does not exist ..
        fileQueue.offer(updaterFile);
        return true;
    }

    public void downloadConfig(String config) {
        File file = new File(ModuleLoader.ROOT_PATH + config); // where to save to
        UpdaterFile updaterFile = new UpdaterFile(file.getPath(), "http://griefcraft.com/bukkit/lwc/skel/" + config);

        this.verifyFile(updaterFile);
        this.downloadFiles();
    }

    /**
     * Get the latest download URL. Could vary depending upon which update scheme is used
     *
     * @return
     */
    public String getLatestDownloadURL() {
        if (updateScheme == null) {
            return "";
        }

        switch(updateScheme) {
            case BLEEDING_EDGE:
                return JENKINS + latestVersion.getBuildNumber() + "/artifact/build/LWC.jar";

            default:
                return UPDATE_SITE + "branch/" + updateScheme.getBranch() + "/download/LWC.jar";
        }
    }

    /**
     * Check if we should try to automatically update
     *
     * @return
     */
    public boolean shouldAutoUpdate() {
        if (updateScheme == null) {
            return false;
        }

        if (updateMethod != UpdateMethod.AUTOMATIC) {
            return false;
        }

        Version current = LWCInfo.FULL_VERSION;

        switch (updateScheme) {
            // We only want to compare the build number for bleeding edge
            case BLEEDING_EDGE:
                return latestVersion.getBuildNumber() > current.getBuildNumber() && (latestVersion.getBuildNumber() > 0 && current.getBuildNumber() > 0);

            // For everything else, we are fine with the default routine
            default:
                return latestVersion.newerThan(current);
        }
    }

    /**
     * Load the latest version
     *
     * @param background
     */
    public void loadVersions(boolean background) {
        this.loadVersions(background, null);
    }

    /**
     * Load the latest version
     *
     * @param background if true, will be run in the background
     * @param callback   The callback will be ran after the version is loaded
     */
    public void loadVersions(boolean background, final Runnable callback) {
        class Background_Check_Thread implements Runnable {
            public void run() {

                switch (updateScheme) {
                    /**
                     * The bleeding edge scheme instead reads the latest build number from Jenkins and relies
                     * upon that. The nature of bleeding edge is to stay up to the latest build.
                     */
                    case BLEEDING_EDGE:
                        try {
                            URL url = new URL(JENKINS + "lastSuccessfulBuild/");
                            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
                            Pattern pattern = Pattern.compile(".*<title>.* #(\\d+) .*");

                            // begin parsing
                            String line;

                            while ((line = reader.readLine()) != null) {
                                Matcher matcher = pattern.matcher(line);

                                if (!matcher.matches()) {
                                    continue;
                                }

                                // We found the build number!
                                int buildNumber = Integer.parseInt(matcher.group(1));

                                // parse the version
                                latestVersion = new Version("b" + buildNumber);
                            }
                        } catch (MalformedURLException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        break;


                    default:
                        // by default, use the LATEST file
                        try {
                            URL url = new URL(UPDATE_SITE + updateScheme.getBranch() + "/LATEST");
                            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));

                            // read in the first line
                            String line = reader.readLine();
                            reader.close();

                            // parse it and we are done
                            latestVersion = new Version(line);
                        } catch (MalformedURLException e) {
                            e.printStackTrace();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        break;
                }

                // run the callback
                if (callback != null) {
                    callback.run();
                }

            }
        }

        Background_Check_Thread worker = new Background_Check_Thread();

        if (background) {
            new Thread(worker).start();
        } else {
            worker.run();
        }
    }

    /**
     * @return the full path to the native library for sqlite
     */
    public String getFullNativeLibraryPath() {
        return getOSSpecificFolder() + getOSSpecificFileName();
    }

    /**
     * @return the latest plugin version
     */
    public Version getLatestVersion() {
        return latestVersion;
    }

    /**
     * @return the update scheme that is being used
     */
    public UpdateScheme getUpdateScheme() {
        return updateScheme;
    }

    /**
     * @return the os/arch specific file name for sqlite's native library
     */
    public String getOSSpecificFileName() {
        String osname = System.getProperty("os.name").toLowerCase();

        if (osname.contains("windows")) {
            return "sqlitejdbc.dll";
        } else if (osname.contains("mac")) {
            return "libsqlitejdbc.jnilib";
        } else { /* We assume linux/unix */
            return "libsqlitejdbc.so";
        }
    }

    /**
     * @return the os/arch specific folder location for SQLite's native library
     */
    public String getOSSpecificFolder() {
        String osname = System.getProperty("os.name").toLowerCase();
        String arch = System.getProperty("os.arch").toLowerCase();

        if (osname.contains("windows")) {
            return DEST_LIBRARY_FOLDER + "lib/native/Windows/" + arch + "/";
        } else if (osname.contains("mac")) {
            return DEST_LIBRARY_FOLDER + "lib/native/Mac/" + arch + "/";
        } else { /* We assume linux/unix */
            return DEST_LIBRARY_FOLDER + "lib/native/Linux/" + arch + "/";
        }
    }

}