~A mostly finished networking system.

~Lots of other changes that I forgot about because it was spread over a bunch of time x)
~Almost lost this version!

Author: Exerosis

README.md

@@ -1,2 +1,5 @@
 BlockServer [![Build Status](https://travis-ci.org/BlockServerProject/BlockServer.svg?branch=master)](https://travis-ci.org/BlockServerProject/BlockServer)
 ===========
+BlockServer is an open source platform for Minecraft server software. It is very extensible and open source. This repository contains the core which is needed to run and load the extra modules which allow players to connect to the server.
+
+The BlockServer Project develops modules to support both PC and PE connections. Currently PC is lower priority as our goal is to support PE first.

src/main/java/org/blockserver/core/exceptions/BlockServerException.java

@@ -1,3 +1,19 @@
+/*
+ * This file is part of BlockServer.
+ *
+ * BlockServer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * BlockServer 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with BlockServer.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.blockserver.core.exceptions;
 
 import org.blockserver.core.exceptions.node.ExceptionBuilder;

src/main/java/org/blockserver/core/exceptions/node/ExceptionBuilder.java

@@ -1,3 +1,19 @@
+/*
+ * This file is part of BlockServer.
+ *
+ * BlockServer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * BlockServer 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with BlockServer.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.blockserver.core.exceptions.node;
 
 public class ExceptionBuilder {

src/main/java/org/blockserver/core/exceptions/node/ExceptionNode.java

@@ -1,3 +1,19 @@
+/*
+ * This file is part of BlockServer.
+ *
+ * BlockServer is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * BlockServer 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with BlockServer.  If not, see <http://www.gnu.org/licenses/>.
+ */
 package org.blockserver.core.exceptions.node;
 
 public class ExceptionNode {

src/main/java/org/blockserver/core/module/Enableable.java

@@ -18,6 +18,8 @@
 
 /**
  * Written by Exerosis!
+ *
+ * @author BlockServer Team
  */
 public interface Enableable {
     void onEnable();

src/main/java/org/blockserver/core/module/EnableableImplementation.java

@@ -19,6 +19,10 @@
 import java.util.Map;
 import java.util.WeakHashMap;
 
+/**
+ * @author BlockServer Team
+ * @see org.blockserver.core.module.Enableable
+ */
 public interface EnableableImplementation extends Enableable {
     Map<EnableableImplementation, Boolean> instances = new WeakHashMap<>();
 

src/main/java/org/blockserver/core/module/Module.java

@@ -20,9 +20,11 @@
 import org.blockserver.core.Server;
 
 /**
- * Base class for all modules.
+ * Base class for all modules. New modules should implement this class.
  *
  * @author BlockServer Team
+ * @see org.blockserver.core.modules
+ * @see org.blockserver.core.module.EnableableImplementation
  */
 public class Module implements EnableableImplementation {
     @Getter private final Server server;

src/main/java/org/blockserver/core/module/ModuleLoader.java

@@ -20,6 +20,10 @@
 
 import java.util.Collection;
 
+/**
+ * @author BlockServer Team
+ * @see org.blockserver.core.module.loaders
+ */
 public interface ModuleLoader {
     Collection<Module> setModules(Collection<Module> currentModules, Server server);
 }

src/main/java/org/blockserver/core/module/loaders/CoreModuleLoader.java

@@ -20,20 +20,24 @@
 import org.blockserver.core.module.Module;
 import org.blockserver.core.module.ModuleLoader;
 import org.blockserver.core.modules.logging.LoggingModule;
-import org.blockserver.core.modules.network.NetworkModule;
+import org.blockserver.core.modules.message.MessageModule;
 import org.blockserver.core.modules.player.PlayerModule;
 import org.blockserver.core.modules.scheduler.SchedulerModule;
 
 import java.util.Collection;
 
+/**
+ * @author BlockServer Team
+ * @see org.blockserver.core.module.ModuleLoader
+ */
 public class CoreModuleLoader implements ModuleLoader {
 
     @Override
     public Collection<Module> setModules(Collection<Module> currentModules, Server server) {
         LoggingModule loggingModule = new LoggingModule(server);
         SchedulerModule schedulerModule = new SchedulerModule(server);
         PlayerModule playerModule = new PlayerModule(server);
-        NetworkModule networkModule = new NetworkModule(server, schedulerModule);
+        NetworkModule networkModule = new MessageModule(server, schedulerModule);
 
         currentModules.add(loggingModule);
         currentModules.add(schedulerModule);

src/main/java/org/blockserver/core/module/loaders/JarModuleLoader.java

@@ -33,6 +33,9 @@
 
 /**
  * Module Loader that can load modules from JARs
+ *
+ * @author BlockServer Team
+ * @see org.blockserver.core.module.ModuleLoader
  */
 public class JarModuleLoader implements ModuleLoader {
     @Override

src/main/java/org/blockserver/core/modules/entity/Entity.java

@@ -20,6 +20,8 @@
 
 /**
  * Written by Exerosis!
+ *
+ * @author BlockServer Team
  */
 public class Entity {
     private float x;

src/main/java/org/blockserver/core/modules/logging/LoggingModule.java

@@ -20,9 +20,11 @@
 import org.blockserver.core.module.Module;
 
 /**
+ * Logging Module with different log levels. (debug, info, warn, error)
  * TODO: Implement SLF4j and/or log4j2
  *
  * @author BlockServer Team
+ * @see org.blockserver.core.module.Module
  */
 public class LoggingModule extends Module {
 

src/main/java/org/blockserver/core/modules/message/Message.java

@@ -24,9 +24,16 @@
  * Written by Exerosis!
  */
 public class Message {
+    @Getter final private boolean async;
     @Getter @Setter private Player player;
 
     public Message(Player player) {
         this.player = player;
+        async = false;
+    }
+
+    public Message(Player player, boolean async) {
+        this.player = player;
+        this.async = async;
     }
 }

src/main/java/org/blockserver/core/modules/network/test/testtwo/ProviderP.java renamed to src/main/java/org/blockserver/core/modules/network/Dispatcher.java

@@ -14,11 +14,11 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with BlockServer.  If not, see <http://www.gnu.org/licenses/>.
  */
-package org.blockserver.core.modules.network.test.testtwo;
+package org.blockserver.core.modules.network;
 
 /**
  * Written by Exerosis!
  */
-public class ProviderP {
-
-}
+public interface Dispatcher {
+    void dispatch(RawPacket packet);
+}

src/main/java/org/blockserver/core/modules/network/LinkedBlockingIOQueue.java

@@ -0,0 +1,41 @@
+package org.blockserver.core.modules.network;
+
+import org.blockserver.core.Server;
+import org.blockserver.core.event.Priority;
+import org.blockserver.core.event.ServerEventListener;
+import org.blockserver.core.events.messages.MessageReciveEvent;
+import org.blockserver.core.events.messages.MessageSendEvent;
+
+public class MessageManager extends PacketProvider implements Dispatcher {
+    private final ServerEventListener<MessageSendEvent> listener;
+    private final NetworkConverter converter;
+
+    public MessageManager(Server server, NetworkConverter converter) {
+        super(server);
+        this.converter = converter;
+        listener = new ServerEventListener<MessageSendEvent>() {
+            @Override
+            public void onEvent(MessageSendEvent event) {
+                if (!event.isCancelled())
+                    queuePacket(converter.toPacket(event.getMessage()));
+            }
+        }.priority(Priority.INTERNAL).post();
+    }
+
+    @Override
+    public void onEnable() {
+        listener.register(MessageSendEvent.class, getServer());
+        super.onEnable();
+    }
+
+    @Override
+    public void onDisable() {
+        listener.unregister(getServer());
+        super.onDisable();
+    }
+
+    @Override
+    public void dispatch(RawPacket packet) {
+        getServer().getExecutorService().execute(() -> getServer().getEventManager().fire(new MessageReciveEvent<>(converter.toMessage(packet))));
+    }
+}

src/main/java/org/blockserver/core/modules/network/MessageManager.java

@@ -25,5 +25,6 @@
 public interface NetworkConverter {
     RawPacket toPacket(Message message);
 
+    //As much as the player part might be helpful, I looked into it more and it will never actually be needed, also it makes for some huge problems. Sorry Jython buddy x)
     Message toMessage(RawPacket packet);
 }

src/main/java/org/blockserver/core/modules/network/NetworkConverter.java

@@ -0,0 +1,43 @@
+package org.blockserver.core.modules.network;
+
+
+import lombok.Getter;
+import org.blockserver.core.Server;
+import org.blockserver.core.module.Module;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+public class NetworkHandler extends Module {
+    @Getter private final Set<Provider> providers = Collections.synchronizedSet(new HashSet<>());
+    @Getter private final Set<Dispatcher> dispatchers = Collections.synchronizedSet(new HashSet<>());
+
+    public NetworkHandler(Server server) {
+        super(server);
+        getServer().getExecutorService().execute(() -> {
+            while (isEnabled()) {
+                providers.stream().filter(p -> p.peek() != null).forEach(p -> {
+                    for (Dispatcher dispatcher : dispatchers)
+                        dispatcher.dispatch(p.poll());
+                });
+            }
+        });
+    }
+
+    public void unregisterProvider(Provider provider) {
+        providers.remove(provider);
+    }
+
+    public void unregisterDispatcher(Dispatcher dispatcher) {
+        dispatchers.remove(dispatcher);
+    }
+
+    public void registerProvider(Provider provider) {
+        providers.add(provider);
+    }
+
+    public void registerDispatcher(Dispatcher dispatcher) {
+        dispatchers.add(dispatcher);
+    }
+}