personal/q3k/minecraft/plugin/hscloud/Main.java

package hscloud.personal.q3k.minecraft.plugin.hscloud;

import java.io.IOException;
import java.util.concurrent.TimeUnit;
import java.util.ArrayList;
import java.util.logging.Logger;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.protobuf.services.ProtoReflectionService;
import io.grpc.stub.StreamObserver;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitScheduler;

import hscloud.personal.q3k.minecraft.plugin.hscloud.proto.IntrospectorGrpc;
import hscloud.personal.q3k.minecraft.plugin.hscloud.proto.Proto;


public class Main extends JavaPlugin {
    private Server server_;
    private static final Logger logger_ = Logger.getLogger(Main.class.getName());
    private static final int port_ = 2137;

    public StateSynchronizer synchronizer_;

    public Main() {
        synchronizer_ = new StateSynchronizer();
        server_ = ServerBuilder
            .forPort(port_)
            .addService(new IntrospectorService(synchronizer_))
            .addService(ProtoReflectionService.newInstance())
            .build();
    }

    @Override
    public void onEnable() {

        BukkitScheduler scheduler = getServer().getScheduler();
        scheduler.scheduleSyncRepeatingTask(this, new Runnable() {
            @Override
            public void run() {
                ArrayList<StateSynchronizer.Player> players = new ArrayList<StateSynchronizer.Player>();
                for (Player p : Bukkit.getOnlinePlayers()) {
                    StateSynchronizer.Player pp = new StateSynchronizer.Player(p.getPlayerListName(), p.getUniqueId().toString());
                    players.add(pp);
                }
                synchronizer_.setPlayers(players.toArray(new StateSynchronizer.Player[0]));

                World world = Bukkit.getWorld("world");
                if (world != null) {
                    synchronizer_.setTime(world.getTime());
                }
            }
        }, 0, 20L);

        try {
            server_.start();
        } catch (IOException e) {
            logger_.severe("could not start gRPC");
            e.printStackTrace(System.err);
            return;
        }
        logger_.info("gRPC started, listening on " + port_);
    }

    @Override
    public void onDisable() {
        if (server_ != null) {
            try {
                server_.shutdown().awaitTermination(30, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                logger_.severe("could not stop gRPC");
                e.printStackTrace(System.err);
            }
        }
        server_ = null;
    }

    public static class IntrospectorService extends IntrospectorGrpc.IntrospectorImplBase {
        private StateSynchronizer synchronizer_;

        public IntrospectorService(StateSynchronizer synchronizer) {
            synchronizer_ = synchronizer;
        }

        @Override
        public void status(Proto.StatusRequest request, StreamObserver<Proto.StatusResponse> responseObserver) {
            StateSynchronizer.Player[] players = synchronizer_.getPlayers();

            Proto.StatusResponse.Builder builder = Proto.StatusResponse.newBuilder();
            builder.setTime(synchronizer_.getTime());
            for (StateSynchronizer.Player p : players) {
                builder.addPlayers(Proto.Player.newBuilder()
                    .setUsername(p.getName())
                    .setUuid(p.getUUID())
                    .build());


            }
            responseObserver.onNext(builder.build());
            responseObserver.onCompleted();
        }
    }
}