Nodemon Project

Nodemon.java

package me.zking.nodemon;

import lombok.Getter;
import lombok.SneakyThrows;
import me.zking.future.Core;
import me.zking.future.entity.obs.Observer;
import me.zking.future.reader.IFile;
import org.bukkit.Bukkit;
import org.bukkit.Server;
import org.bukkit.plugin.java.JavaPlugin;

import java.nio.file.WatchEvent;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.logging.Logger;

@Getter
public class Nodemon extends JavaPlugin {

    List<NodeQueue> watchers = new ArrayList<>();
    IFile setup;
    List<String> paths;
    Core core;
    Map mappedObjects;
    NodeQueue queue;

    private boolean isUpdated = false;

    @Override @SneakyThrows
    public void onEnable() {
        Server server = getServer();
        core = server.getServicesManager().load(Core.class);
        Logger console = core.getConsole();
        setup = new IFile(core,"nodemon.json", true)
                .load(this);

        mappedObjects = setup.getMappedObjects();
        paths = (List<String>) mappedObjects.get("paths");

        queue = new NodeQueue(this).setup();
        Observer observer = core.getObserver();

        observer.<WatchEvent>subscribe("nodemon:entry-update", event -> {
            if(isUpdated) return;

            queue.getService().submit(core.getLambda().run(() -> {
                console.info("Attemping changes...");
                Thread.sleep(2500);
                console.info("Reloading.");
                Bukkit.getScheduler().runTask(core, Bukkit::reload);
            }));

            isUpdated = true;
        });
    }

    @Override
    public void onDisable() {
        queue.getService().shutdownNow();
    }
}

NodeQueue.java

package me.zking.nodemon;

import lombok.Getter;
import lombok.RequiredArgsConstructor;
import me.zking.future.Core;
import me.zking.nodemon.watch.Watcher;

import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.stream.Collectors;

@RequiredArgsConstructor @Getter
public class NodeQueue {

    final Nodemon nodemon;
    List<File> files = new ArrayList<>();
    ScheduledExecutorService service;

    public NodeQueue setup(){
        Core core = nodemon.getCore();
        File dataFolder = core.getPluginsFolder();

        service = Executors.newScheduledThreadPool(4);
        files = nodemon.getPaths()
                .stream()
                .map(r -> new File(dataFolder, r))
                .collect(Collectors.toList());

        Watcher watcher = new Watcher(this).setup();
        service.submit(watcher);
        return this;
    }
}

Watcher.java

package me.zking.nodemon.watch;

import lombok.RequiredArgsConstructor;
import lombok.SneakyThrows;
import me.zking.future.Core;
import me.zking.future.entity.fun.OwnFun;
import me.zking.future.entity.obs.Observer;
import me.zking.nodemon.NodeQueue;
import me.zking.nodemon.Nodemon;

import java.io.File;
import java.nio.file.*;

@RequiredArgsConstructor
public class Watcher implements Runnable {

    OwnFun lambda;
    final NodeQueue queue;
    WatchService watchService;
    Observer observer;

    @SneakyThrows
    public Watcher setup() {
        Nodemon nodemon = queue.getNodemon();
        Core core = nodemon.getCore();
        observer = core.getObserver();

        //Logger console = core.getConsole();
        lambda = core.getLambda();

        watchService = FileSystems.getDefault().newWatchService();

        queue.getFiles()
                .stream()
                .filter(File::exists)
                .map(File::getAbsolutePath)
                .forEach(this::watcherFactory);

        return this;
    }

    @SneakyThrows
    public void watcherFactory(String parentPath) {
        Path path = Paths.get(parentPath);
        path.register(watchService, StandardWatchEventKinds.ENTRY_MODIFY);
    }

    @SneakyThrows @Override
    public void run() {
        WatchKey key;
        while((key = watchService.take()) != null) {
            Thread.sleep(50);

            key.pollEvents()
                    .forEach(b -> observer.notifyAll("nodemon:entry-update", b));

            key.reset();
        }
    }
}