Refactor part of core.legacy to core.networking

2016-07-11 22:54:24 +01:00
parent 0a000884e0
commit 7868c742a5
42 changed files with 531 additions and 27 deletions
--- a/java/core.networking/build.gradle
+++ b/java/core.networking/build.gradle
@@ -0,0 +1,3 @@
+dependencies {
+	compile project(':core.legacy')
+}
--- a/java/core.networking/src/main/java/base/exception/LoaderException.java
+++ b/java/core.networking/src/main/java/base/exception/LoaderException.java
@@ -0,0 +1,9 @@
+package base.exception;
+
+public class LoaderException extends Exception {
+    protected static final long serialVersionUID = 1L;
+
+    public LoaderException(String message) {
+        super(message);
+    }
+}
--- a/java/core.networking/src/main/java/base/loader/AbstractLoader.java
+++ b/java/core.networking/src/main/java/base/loader/AbstractLoader.java
@@ -0,0 +1,146 @@
+package base.loader;
+
+import java.io.IOException;
+import java.util.Properties;
+
+import org.picocontainer.DefaultPicoContainer;
+import org.picocontainer.MutablePicoContainer;
+import org.picocontainer.Parameter;
+import org.picocontainer.parameters.ConstantParameter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Duplex;
+import base.Forwarder;
+import base.Sender;
+import base.exception.LoaderException;
+import base.server.datagram.UdpSender;
+import base.server.forwarder.UdpDuplexClientForwarder;
+import base.server.forwarder.UdpDuplexServerForwarder;
+
+public class AbstractLoader<T> {
+    protected static final String PROPERTIES_FILE = "loader.properties";
+    protected static final Properties SERVER = null;
+
+    protected Logger logger = LoggerFactory.getLogger(AbstractLoader.class);
+    protected MutablePicoContainer pico;
+    
+    public AbstractLoader() {
+        /* Initialise container */
+        pico = new DefaultPicoContainer();
+    }
+
+    public AbstractLoader(Properties properties) {
+        this();
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    public static <T> T getLoader() throws LoaderException {
+        return (T) new AbstractLoader(readProperties(PROPERTIES_FILE));
+    }
+
+    public static Properties readProperties(String propertiesFile) throws LoaderException {
+        /* Read properties file */
+        Properties properties = new Properties();        
+        try {
+            properties.load(AbstractLoader.class.getClassLoader().getResourceAsStream(propertiesFile));
+        } catch (IOException e) {
+            throw new LoaderException("Faield to read properties file: " + PROPERTIES_FILE);
+        }        
+        return properties;
+    }
+
+    protected Class<?> getSenderClass(String protocol, String implementation) throws LoaderException {
+        switch (protocol) {
+            case "tcp":
+                switch (implementation) {
+                    case "channel":
+                        return base.server.channel.TcpClient.class; 
+                    default:
+                    case "socket":
+                        return base.server.socket.TcpClient.class; 
+                    }
+                case "udp":
+                    return UdpSender.class;
+        }
+        throw new LoaderException("Failed to determine <Sender>");
+    }
+
+    protected Class<?> getClientForwarderClass(String protocol, String implementation) throws LoaderException {
+        switch (protocol) {
+            case "tcp":
+                switch (implementation) {
+                    case "channel":
+                        return base.server.forwarder.TcpClientChannelForwarder.class;
+                    default:
+                    case "socket":
+                        return base.server.forwarder.TcpClientSocketForwarder.class;
+                }
+            case "udp":
+                return UdpDuplexClientForwarder.class;
+        }
+        throw new LoaderException("Failed to determine <Forwarder>");
+    }
+
+    protected Class<?> getServerForwarderClass(String protocol, String implementation) throws LoaderException {
+        switch (protocol) {
+            case "tcp":
+                switch (implementation) {
+                    case "channel":
+                        return base.server.forwarder.TcpChannelServerForwarder.class;
+                    default:
+                    case "socket":
+                        return base.server.forwarder.TcpSocketServerForwarder.class;
+                }
+            case "udp":
+                return UdpDuplexServerForwarder.class;
+        }
+        throw new LoaderException("Failed to determine <Forwarder>");
+    }
+
+    protected void addClientSender(String protocol, String implementation, String host, int port) throws LoaderException {
+        Class<?> senderClass = getSenderClass(protocol, implementation);
+        logger.debug("Adding " + senderClass);
+        pico.addComponent(Sender.class, senderClass, new Parameter[]{
+            new ConstantParameter(host),
+            new ConstantParameter(port)});
+    }
+
+    protected void addServerSender(String protocol, String implementation, int port) throws LoaderException {
+        Class<?> senderClass = getSenderClass(protocol, implementation);
+        logger.debug("Adding " + senderClass);
+        pico.addComponent(Sender.class, senderClass, new Parameter[]{
+            new ConstantParameter(port)});
+    }
+
+    protected void addClientForwarder(String protocol, String implementation, String host, int port) throws LoaderException {
+        Class<?> forwarderClass = getClientForwarderClass(protocol, implementation);
+        logger.debug("Adding " + forwarderClass);
+        pico.addComponent(Forwarder.class, forwarderClass, new Parameter[]{
+            new ConstantParameter(host),
+            new ConstantParameter(port)});
+    }
+
+    protected void addClientDuplex(String protocol, String implementation, String host, int port) throws LoaderException {
+        Class<?> duplexClass = getClientForwarderClass(protocol, implementation);
+        logger.debug("Adding " + duplexClass);
+        pico.addComponent(Duplex.class, duplexClass, new Parameter[]{
+            new ConstantParameter(host),
+            new ConstantParameter(port)});
+        
+    }
+
+    protected void addServerForwarder(String protocol, String implementation, int port) throws LoaderException {
+        Class<?> forwarderClass = getServerForwarderClass(protocol, implementation);
+        logger.debug("Adding " + forwarderClass);
+        pico.addComponent(Forwarder.class, forwarderClass, new Parameter[]{
+            new ConstantParameter(port)});        
+    }
+
+    protected void addServerDuplex(String protocol, String implementation, int port) throws LoaderException {
+        Class<?> duplexClass = getServerForwarderClass(protocol, implementation);
+        logger.debug("Adding " + duplexClass);
+        pico.addComponent(Duplex.class, duplexClass, new Parameter[]{
+            new ConstantParameter(port)});        
+    }
+}
--- a/java/core.networking/src/main/java/base/server/channel/TcpClient.java
+++ b/java/core.networking/src/main/java/base/server/channel/TcpClient.java
@@ -0,0 +1,137 @@
+package base.server.channel;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.SocketChannel;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Set;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Listen;
+import base.work.Work;
+import base.worker.Worker;
+
+public class TcpClient extends Work implements Sender {
+    protected static final String HOST = "localhost";
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected String host;
+    protected int port;
+    protected int bufferSize;
+    protected SocketChannel socketChannel;
+    protected Selector selector;
+    protected ArrayList<Listen<byte[]>> listenList = new ArrayList<Listen<byte[]>>();
+
+    public TcpClient(int port) {
+        this(HOST, port);
+    }
+
+    public TcpClient(String host, int port) {
+        this(host, port, BUFFER_SIZE);
+    }
+
+    public TcpClient(String host, int port, int bufferSize) {
+        this.host = host;
+        this.port = port;
+        this.bufferSize = bufferSize;
+    }
+
+    public void activate() throws ActivateException {
+        System.out.println("Client: Activate!");
+        try {
+            InetSocketAddress hostAddress = new InetSocketAddress(host, port);
+            socketChannel = SocketChannel.open(hostAddress);
+            socketChannel.configureBlocking(false);
+            while (!socketChannel.finishConnect()) {
+                sleep(Worker.SLEEP);
+            }
+            selector = Selector.open();
+            socketChannel.register(selector, SelectionKey.OP_READ);
+            synchronized (host) {
+                host.notifyAll();
+            }
+        } catch (Exception e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        System.out.println("Client: Deactivate!");
+        try {
+            selector.close();
+            socketChannel.close();
+        } catch (IOException e) {
+            throw new DeactivateException();
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        if (selector != null) {
+            selector.wakeup();
+        }
+    }
+
+    public final void work() {
+        try {
+            logger.debug("Client: Waiting for select... ");    
+            logger.debug("Client: Number of selected keys: " + selector.select());
+            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
+            Iterator<SelectionKey> selectionKeyIterator = selectionKeySet.iterator();
+
+            while (selectionKeyIterator.hasNext()) {    
+                SelectionKey selectionKey = selectionKeyIterator.next();
+                if (selectionKey.isReadable()) {
+                    ByteBuffer byteBuffer = ByteBuffer.allocate(bufferSize);
+                    socketChannel.read(byteBuffer);
+                    byte[] buffer = byteBuffer.array();
+                    input(buffer);
+                } else if (selectionKey.isWritable()) {
+                    byte[] buffer;
+                    buffer = (byte[]) selectionKey.attachment();
+                    ByteBuffer byteBuffer = ByteBuffer.wrap(buffer);
+                    socketChannel.write(byteBuffer);
+                    //selectionKey.cancel();
+                    socketChannel.register(selector, SelectionKey.OP_READ);
+                }
+                selectionKeyIterator.remove();
+            }
+        } catch (Exception e) {
+            logger.error("", e);
+        }
+    }
+
+    protected void input(byte[] buffer) {}
+
+    public void send(byte[] buffer) throws IOException {
+        if (selector == null) {
+            try {
+                synchronized (host) {
+                    host.wait();
+                }
+            } catch (InterruptedException e) {}
+        }
+        selector.wakeup();
+        socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE, buffer);
+    }
+
+    public void close() throws IOException {
+        socketChannel.close();        
+    }
+
+    /*public void register(Listen<byte[]> listen) {
+        listenList.add(listen);
+    }
+
+    public void remove(Listen<byte[]> listen) {
+        listenList.remove(listen);
+    }*/
+}
--- a/java/core.networking/src/main/java/base/server/channel/TcpServer.java
+++ b/java/core.networking/src/main/java/base/server/channel/TcpServer.java
@@ -0,0 +1,158 @@
+package base.server.channel;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.net.BindException;
+import java.net.InetSocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
+import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Set;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.server.channel.TcpServerClient;
+import base.work.Work;
+
+public class TcpServer extends Work implements Sender {
+    protected static final Class<?> CLIENT_CLASS = TcpServerClient.class;
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected int port;
+    protected int bufferSize;
+    protected Constructor<?> clientConstructor;
+    protected Selector selector;
+    protected ServerSocketChannel serverSocket;
+    protected ArrayList<TcpServerClient> clientList;
+
+    public TcpServer(int port) {
+        this(port, CLIENT_CLASS);
+    }
+
+    public TcpServer(int port, Class<?> clientClass) {
+        this(port, clientClass, BUFFER_SIZE);
+    }
+
+    public TcpServer(int port, Class<?> clientClass, int bufferSize) {
+        this.port = port;
+        this.bufferSize = bufferSize;
+        try {
+            // Allow dependency injection, constructor arguments
+            clientConstructor = Class.forName(clientClass.getName()).getConstructor(TcpServer.class, SocketChannel.class, Integer.class);
+        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
+            logger.error("Failed to initialise client constructor", e);
+        }
+        clientList = new ArrayList<TcpServerClient>();
+    }
+
+    public void activate() throws ActivateException {
+        System.out.println("Server: Activate!");    
+        try {
+            // Get selector
+            selector = Selector.open();
+
+            // Get server socket channel and register with selector
+            serverSocket = ServerSocketChannel.open();
+            InetSocketAddress hostAddress = new InetSocketAddress(port);
+            serverSocket.bind(hostAddress);
+            serverSocket.configureBlocking(false);
+            serverSocket.register(selector, SelectionKey.OP_ACCEPT);
+            synchronized (clientConstructor) {
+                clientConstructor.notifyAll();
+            }
+            return;
+        } catch (BindException e) {
+            logger.error("Address already in use", e);
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+        throw new ActivateException();
+    }
+
+    public void deactivate() throws DeactivateException {
+        System.out.println("Server: Deactivate!");
+        try {
+            selector.close();
+            serverSocket.close();
+        } catch (IOException e) {
+            throw new DeactivateException();
+        } finally {
+            for (TcpServerClient client : clientList) {
+                client.stop();
+            }
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        if (selector != null) {
+            selector.wakeup();
+        }
+    }
+
+    public void work() {
+        try {
+            System.out.println("Server: Waiting for select... ");    
+            System.out.println("Server: Number of selected keys: " + selector.select());
+    
+            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
+            Iterator<SelectionKey> selectionKeyIterator = selectionKeySet.iterator();
+    
+            while (selectionKeyIterator.hasNext()) {    
+                SelectionKey selectionKey = selectionKeyIterator.next();    
+                if (selectionKey.isAcceptable()) {    
+                    // Accept the new client connection
+                    SocketChannel socketChannel = serverSocket.accept();
+                    socketChannel.configureBlocking(false);
+
+                    // Add the new connection to the selector
+                    TcpServerClient client = (TcpServerClient) clientConstructor.newInstance(this, socketChannel, bufferSize);
+                    clientList.add(client);
+                    socketChannel.register(selector, SelectionKey.OP_READ, client);
+                    //initClient(client);
+                    System.out.println("Accepted new connection from client: " + socketChannel);
+                } else if (selectionKey.isReadable()) {    
+                    // Read the data from client
+                    TcpServerClient serverClient = (TcpServerClient) selectionKey.attachment();
+                    serverClient.readable();    
+                } else if (selectionKey.isWritable()) {
+                    // Write to client?
+                }
+                selectionKeyIterator.remove();
+            }
+        }/* catch (IOException e) {} catch (InstantiationException e) {
+            logger.error("", e);
+        } catch (IllegalAccessException e) {
+            logger.error("", e);
+        } catch (IllegalArgumentException e) {
+            logger.error("", e);
+        } catch (InvocationTargetException e) {
+            logger.error("", e);
+        } */catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    protected void initClient(TcpServerClient client) {
+        try {
+            client.write(ByteBuffer.wrap(new String("Hi there!").getBytes()));
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        logger.debug("Number of clients = " + clientList.size());
+        for (TcpServerClient client : clientList) {
+            // Should be dealt with in clients own thread
+            client.send(buffer);
+        }        
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {}
+}
--- a/java/core.networking/src/main/java/base/server/channel/TcpServerClient.java
+++ b/java/core.networking/src/main/java/base/server/channel/TcpServerClient.java
@@ -0,0 +1,54 @@
+package base.server.channel;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.SocketChannel;
+
+import base.Sender;
+import base.work.Listen;
+
+public class TcpServerClient extends Listen<byte[]> implements Sender {
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected TcpServer server;
+    protected SocketChannel socketChannel;
+    protected int bufferSize;
+    protected ByteBuffer byteBuffer;
+
+    public TcpServerClient(TcpServer server, SocketChannel socketChannel) {
+        this(server, socketChannel, BUFFER_SIZE);
+    }
+
+    public TcpServerClient(TcpServer server, SocketChannel socketChannel, Integer bufferSize) {
+        super();
+        this.server = server;
+        this.socketChannel = socketChannel;
+        this.bufferSize = bufferSize;
+        byteBuffer = ByteBuffer.allocate(bufferSize);
+    }
+
+    public void write(ByteBuffer byteBuffer) throws IOException {
+         socketChannel.write(byteBuffer);
+    }
+
+    public void readable() throws IOException {
+        int read;        
+        while (( read = socketChannel.read(byteBuffer)) > 0) {
+            byteBuffer.flip();
+            byte[] buffer = byteBuffer.array();
+            input(buffer);
+            byteBuffer.clear();
+        }
+        if (read < 0) {
+            socketChannel.close();
+        }
+    }
+
+    public void input(byte[] buffer) {
+        server.input(this, buffer);        
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        write(ByteBuffer.wrap(buffer));        
+    }
+}
--- a/java/core.networking/src/main/java/base/server/datagram/AbstractUdpClient.java
+++ b/java/core.networking/src/main/java/base/server/datagram/AbstractUdpClient.java
@@ -0,0 +1,46 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.MulticastSocket;
+
+import base.work.Work;
+
+public abstract class AbstractUdpClient extends Work {
+    protected static final int BUFFER_SIZE = 2048;
+
+    protected int bufferSize;
+    protected MulticastSocket socket;
+    protected DatagramPacket datagramPacket;
+
+    public AbstractUdpClient() {}
+
+    public AbstractUdpClient(MulticastSocket socket) {
+        this(socket, BUFFER_SIZE);
+    }
+
+    public AbstractUdpClient(MulticastSocket socket, int bufferSize) {
+        this.socket = socket;
+        this.bufferSize = bufferSize;
+        byte[] buffer = new byte[bufferSize];
+        datagramPacket = new DatagramPacket(buffer, buffer.length);
+    }
+
+    public void work() {        
+        try {
+            byte[] buffer = new byte[bufferSize];
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+            socket.receive(packet);
+            System.out.println("iets ontvangen!!!!!");
+            buffer = packet.getData();
+            input(buffer);
+        } catch (IOException e) {}
+    }
+
+    public void stop() {
+        socket.close();
+        super.stop();
+    }
+
+    protected abstract void input(byte[] buffer);
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpDuplexAutoClient.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpDuplexAutoClient.java
@@ -0,0 +1,17 @@
+package base.server.datagram;
+
+import java.net.UnknownHostException;
+
+public class UdpDuplexAutoClient extends UdpDuplexClient {
+    public UdpDuplexAutoClient(int bindPort, int sendPort) throws UnknownHostException {
+        super(HOST, bindPort, null, sendPort);
+    }
+
+    public UdpDuplexAutoClient(String bindHost, int bindPort, int sendPort) throws UnknownHostException {
+        super(bindHost, bindPort, null, sendPort);
+    }
+
+    public UdpDuplexAutoClient(String bindHost, int bindPort, int sendPort, int bufferSize) throws UnknownHostException {
+        super(bindHost, bindPort, null, sendPort, bufferSize);
+    }
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpDuplexClient.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpDuplexClient.java
@@ -0,0 +1,51 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.UnknownHostException;
+
+import base.Sender;
+
+public class UdpDuplexClient extends UdpMulticastClient implements Sender {
+    protected int sendPort;
+    protected Sender sender;
+
+    public UdpDuplexClient(int bindPort, String sendHost, int sendPort) throws UnknownHostException {
+        this(HOST, bindPort, sendHost, sendPort);
+    }
+
+    public UdpDuplexClient(String bindHost, int bindPort, String sendHost, int sendPort) throws UnknownHostException {
+        this(bindHost, bindPort, sendHost, sendPort, BUFFER_SIZE);
+    }
+
+    public UdpDuplexClient(String bindHost, int bindPort, String sendHost, int sendPort, int bufferSize) throws UnknownHostException {
+        super(bindHost, bindPort, bufferSize);
+        this.sendPort = sendPort;
+        if (sendHost != null) {
+            sender = new UdpSender(sendHost, sendPort);
+        }
+    }
+
+    public void work() {        
+        try {
+            byte[] buffer = new byte[bufferSize];
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
+            socket.receive(packet);
+            buffer = packet.getData();
+            System.out.println("Receive from " + packet.getAddress().getHostAddress());
+            if (sender == null) {
+                String sendHost = packet.getAddress().getHostAddress();
+                sender = new UdpSender(sendHost, sendPort);
+            }
+            input(buffer);
+        } catch (IOException e) {}
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        if (sender != null) {
+            sender.send(buffer);
+        }
+    }
+
+    public void input(byte[] buffer) {}
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpDuplexHelper.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpDuplexHelper.java
@@ -0,0 +1,19 @@
+package base.server.datagram;
+
+import java.net.MulticastSocket;
+
+import base.work.Listen;
+
+public class UdpDuplexHelper extends AbstractUdpClient {
+    protected Listen<byte[]> listen;
+
+    public UdpDuplexHelper(Listen<byte[]> listen, MulticastSocket socket) {
+        super(socket);
+        this.listen = listen;
+    }
+
+    public void input(byte[] buffer) {
+        System.out.println("jajajaja");
+        listen.add(buffer);
+    }
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpDuplexServer.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpDuplexServer.java
@@ -0,0 +1,59 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+
+public class UdpDuplexServer extends UdpMulticastServer {
+    protected int bindPort;
+    protected UdpDuplexHelper helper;
+
+    public UdpDuplexServer(int sendPort, int bindPort) {
+        super(sendPort);
+        this.bindPort = bindPort;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new MulticastSocket(bindPort);
+            synchronized (this) {
+                notifyAll();
+            }
+            helper = new UdpDuplexHelper(this, socket);
+            helper.start();
+        } catch (IOException e) {
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        helper.stop();
+        super.deactivate();
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        if (socket == null) {
+            synchronized (this) {
+                try {
+                    wait();
+                } catch (InterruptedException e) {
+                    return;
+                }
+            }
+        }
+        try {
+            InetAddress group = InetAddress.getByName(host);
+            System.out.println("Send to " + host + " " + port);
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
+            socket.send(packet);
+        }
+        catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpMulticastClient.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpMulticastClient.java
@@ -0,0 +1,42 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+
+import base.exception.worker.ActivateException;
+
+public class UdpMulticastClient extends AbstractUdpClient {
+    protected static final String HOST = "239.255.255.255";
+
+    protected String host;
+    protected int port;
+
+    public UdpMulticastClient(int port) {
+        this(HOST, port);
+    }
+
+    public UdpMulticastClient(String host, int port) {
+        this(host, port, BUFFER_SIZE);
+    }
+
+    public UdpMulticastClient(String host, int port, int bufferSize) {
+        this.host = host;
+        this.port = port;
+        this.bufferSize = BUFFER_SIZE;
+        System.out.println("Client bind: " + host + " " + port);
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new MulticastSocket(port);
+            InetAddress group = InetAddress.getByName(host);
+            socket.joinGroup(group);
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+    }
+
+    protected void input(byte[] buffer) {}
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpMulticastServer.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpMulticastServer.java
@@ -0,0 +1,61 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.InetAddress;
+import java.net.MulticastSocket;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Listen;
+import base.worker.Worker;
+
+public class UdpMulticastServer extends Listen<byte[]> implements Sender {
+    protected static final String HOST = "239.255.255.255";
+    protected static final int BUFFER_SIZE = 2048;
+
+    protected String host;
+    protected int port;
+    protected MulticastSocket socket;
+
+    public UdpMulticastServer(int port) {
+        this(HOST, port);
+    }
+
+    public UdpMulticastServer(String host, int port) {
+        super(Worker.Type.BACKGROUND);
+        this.host = host;
+        this.port = port;
+        System.out.println("Server send: " + host + " " + port);
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new MulticastSocket();
+        } catch (IOException e) {
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    public void deactivate() throws DeactivateException {
+        socket.close();
+        super.deactivate();
+    }
+
+    public void input(byte[] buffer) {
+        try {
+            InetAddress group = InetAddress.getByName(host);
+            DatagramPacket packet = new DatagramPacket(buffer, buffer.length, group, port);
+            socket.send(packet);
+        }
+        catch (IOException e) {
+            logger.error("", e);
+        }    
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        add(buffer);
+    }
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpSender.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpSender.java
@@ -0,0 +1,56 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.InetAddress;
+import java.net.SocketException;
+import java.net.UnknownHostException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Sender;
+
+public class UdpSender implements Sender {
+    protected static final String HOST = "localhost";
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+
+    protected DatagramSocket datagramSocket;
+    protected InetAddress inetAddress;
+    protected int port;
+
+    public UdpSender(int port) throws UnknownHostException {
+        this(HOST, port);
+    }
+
+    public UdpSender(String host, int port) throws UnknownHostException {
+        System.out.println("Sender use: " + host + " " + port);
+        inetAddress = InetAddress.getByName(host);
+        this.port = port;
+        try {
+            datagramSocket = new DatagramSocket();
+        } catch (SocketException e) {
+            logger.error("Failed to create socket", e);
+        }        
+    }
+
+    public void start() {}
+
+    public void stop() {
+        datagramSocket.close();
+    }
+
+    public void exit() {
+        stop();
+    }
+
+    public void send(byte[] buffer) {
+        try {
+            DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length, inetAddress, port);
+            datagramSocket.send(datagramPacket);
+        } catch (IOException e) {
+            logger.error("Failed to send buffer", e);
+        }        
+    }
+}
--- a/java/core.networking/src/main/java/base/server/datagram/UdpServer.java
+++ b/java/core.networking/src/main/java/base/server/datagram/UdpServer.java
@@ -0,0 +1,64 @@
+package base.server.datagram;
+
+import java.io.IOException;
+import java.net.DatagramPacket;
+import java.net.DatagramSocket;
+import java.net.SocketException;
+
+import base.exception.worker.ActivateException;
+import base.work.Work;
+
+public class UdpServer extends Work {
+    protected static final int BUFFER_SIZE = 1024;
+    protected static final int TIMEOUT = 1000;
+
+    protected int port;
+    protected int bufferSize;
+    protected DatagramSocket diagramSocket;
+
+    public UdpServer(int port) {
+        this(port, BUFFER_SIZE);
+    }
+
+    public UdpServer(int port, int bufferSize) {
+        super();
+        this.port = port;
+        this.bufferSize = bufferSize;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            logger.debug("Starting datagram socket on port " + port);
+            diagramSocket = new DatagramSocket(port);
+            diagramSocket.setSoTimeout(TIMEOUT);
+            super.activate();
+        } catch (SocketException e) {
+            logger.error("Failed to initialize socket", e);
+            throw new ActivateException();
+        }
+    }
+
+    public void stop() {
+        super.stop();
+        if (diagramSocket != null) {
+            diagramSocket.close();
+        }
+    }
+
+    public void work() {
+        byte[] buffer = new byte[bufferSize];        
+        DatagramPacket datagramPacket = new DatagramPacket(buffer, buffer.length);
+        try {
+            diagramSocket.receive(datagramPacket);
+        } catch (SocketException e) {
+            stop();
+        } catch (IOException e) {
+            logger.error("Failed to receive packet", e);
+            stop();
+            return;
+        }
+        input(buffer);
+    }
+
+    protected void input(byte[] buffer) {}
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/TcpChannelServerForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/TcpChannelServerForwarder.java
@@ -0,0 +1,31 @@
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.channel.TcpServer;
+import base.server.channel.TcpServerClient;
+
+public class TcpChannelServerForwarder extends TcpServer implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpChannelServerForwarder(int port) {
+         super(port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/TcpClientChannelForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/TcpClientChannelForwarder.java
@@ -0,0 +1,31 @@
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.socket.TcpClient;
+import base.server.socket.TcpServerClient;
+
+public class TcpClientChannelForwarder extends TcpClient implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpClientChannelForwarder(String host, int port) {
+         super(host, port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/TcpClientSocketForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/TcpClientSocketForwarder.java
@@ -0,0 +1,31 @@
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.channel.TcpClient;
+import base.server.channel.TcpServerClient;
+
+public class TcpClientSocketForwarder extends TcpClient implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpClientSocketForwarder(String host, int port) {
+         super(host, port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/TcpSocketServerForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/TcpSocketServerForwarder.java
@@ -0,0 +1,31 @@
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.socket.TcpServer;
+import base.server.socket.TcpServerClient;
+
+public class TcpSocketServerForwarder extends TcpServer implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public TcpSocketServerForwarder(int port) {
+         super(port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/UdpDuplexClientForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/UdpDuplexClientForwarder.java
@@ -0,0 +1,31 @@
+package base.server.forwarder;
+
+import java.net.UnknownHostException;
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.datagram.UdpDuplexClient;
+
+public class UdpDuplexClientForwarder extends UdpDuplexClient implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public UdpDuplexClientForwarder(String bindHost, int bindPort, String sendHost, int sendPort) throws UnknownHostException {
+        super(bindHost, bindPort, sendHost, sendPort);
+        receiverList = new ArrayList<Receiver>();
+    }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/UdpDuplexServerForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/UdpDuplexServerForwarder.java
@@ -0,0 +1,30 @@
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Duplex;
+import base.Receiver;
+import base.server.datagram.UdpDuplexServer;
+
+public class UdpDuplexServerForwarder extends UdpDuplexServer implements Duplex {
+    protected ArrayList<Receiver> receiverList;
+
+    public UdpDuplexServerForwarder(int port, int listenPort) {
+         super(port, listenPort);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/forwarder/UdpServerForwarder.java
+++ b/java/core.networking/src/main/java/base/server/forwarder/UdpServerForwarder.java
@@ -0,0 +1,30 @@
+package base.server.forwarder;
+
+import java.util.ArrayList;
+
+import base.Forwarder;
+import base.Receiver;
+import base.server.datagram.UdpServer;
+
+public class UdpServerForwarder extends UdpServer implements Forwarder {
+    protected ArrayList<Receiver> receiverList;
+
+    public UdpServerForwarder(int port) {
+         super(port);
+         receiverList = new ArrayList<Receiver>();
+     }
+
+    public void register(Receiver receiver) {
+        receiverList.add(receiver);
+    }
+
+    public void remove(Receiver receiver) {
+        receiverList.remove(receiver);
+    }
+
+    public void input(byte[] buffer) {
+        for (Receiver receiver: receiverList) {
+            receiver.receive(buffer);
+        }
+    }
+}
--- a/java/core.networking/src/main/java/base/server/receiver/AbstractReceiver.java
+++ b/java/core.networking/src/main/java/base/server/receiver/AbstractReceiver.java
@@ -0,0 +1,33 @@
+package base.server.receiver;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import base.Control;
+import base.Forwarder;
+import base.Receiver;
+
+public abstract class AbstractReceiver implements Receiver, Control {
+    protected Logger logger = LoggerFactory.getLogger(getClass());
+
+    protected Forwarder forwarder;
+
+    public AbstractReceiver(Forwarder forwarder) {
+        this.forwarder = forwarder;
+        forwarder.register(this);
+    }
+
+    public void start() {
+        forwarder.start();        
+    }
+
+    public void stop() {
+        forwarder.stop();        
+    }
+
+    public void exit() {
+        forwarder.exit();        
+    }
+
+    abstract public void receive(byte[] buffer);
+}
--- a/java/core.networking/src/main/java/base/server/socket/AbstractTcpClient.java
+++ b/java/core.networking/src/main/java/base/server/socket/AbstractTcpClient.java
@@ -0,0 +1,72 @@
+package base.server.socket;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import base.Sender;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public abstract class AbstractTcpClient extends Work implements Sender {
+    protected static final int BUFFER_SIZE = 1024;
+
+    protected Object object = new Object();
+    protected int bufferSize;
+    protected Socket socket;
+    protected InputStream inputStream;
+    protected OutputStream outputStream;
+
+    public AbstractTcpClient(Integer bufferSize) {
+        this.bufferSize = bufferSize;
+    }
+
+    public boolean active() {
+        return super.active() && socket.isConnected();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        try {
+            inputStream.close();
+            outputStream.close();
+            socket.close();
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void exit() {
+        super.exit();
+        try {
+            socket.close();
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void work() {
+        byte[] buffer = new byte[bufferSize];
+        try {
+            while (inputStream.read(buffer) > 0) {
+                input(buffer);
+            }
+        } catch (IOException e) {
+            stop();
+        }
+    }
+
+    protected abstract void input(byte[] buffer);
+
+    public void send(byte[] buffer) throws IOException {
+        if (outputStream == null) {
+            try {
+                synchronized (object) {
+                    object.wait();
+                }
+            } catch (InterruptedException e) {}
+        }
+        outputStream.write(buffer);
+    }
+}
--- a/java/core.networking/src/main/java/base/server/socket/TcpClient.java
+++ b/java/core.networking/src/main/java/base/server/socket/TcpClient.java
@@ -0,0 +1,49 @@
+package base.server.socket;
+
+import java.io.IOException;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+
+public class TcpClient extends AbstractTcpClient implements Sender {
+    protected static final String HOST = "localhost";
+
+    protected String host;
+    protected int port;
+
+    public TcpClient(int port) {
+        this(HOST, port);
+    }
+
+    public TcpClient(String host, int port) {
+        this(host, port, BUFFER_SIZE);
+    }
+
+    public TcpClient(String host, int port, int bufferSize) {
+        super(bufferSize);
+        this.host = host;
+        this.port = port;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            socket = new Socket(host, port);
+            inputStream = socket.getInputStream();
+            outputStream = socket.getOutputStream();
+            synchronized (object) {
+                object.notifyAll();
+            }
+        } catch (UnknownHostException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+        super.activate();
+    }
+
+    protected void input(byte[] buffer) {}
+}
--- a/java/core.networking/src/main/java/base/server/socket/TcpServer.java
+++ b/java/core.networking/src/main/java/base/server/socket/TcpServer.java
@@ -0,0 +1,86 @@
+package base.server.socket;
+
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.ArrayList;
+
+import base.Sender;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+public class TcpServer extends Work implements Sender {
+    protected static final Class<?> CLIENT_CLASS = TcpServerClient.class;
+
+    protected int port;
+    protected ServerSocket serverSocket;
+    protected Constructor<?> clientConstructor;
+    protected ArrayList<TcpServerClient> clientList;
+
+    public TcpServer(int port) {
+        this(port, CLIENT_CLASS);
+    }
+
+    public TcpServer(int port, Class<?> clientClass) {
+        this.port = port;
+        try {
+            clientConstructor = Class.forName(clientClass.getName()).getConstructor(TcpServer.class, Socket.class);
+        } catch (NoSuchMethodException | SecurityException | ClassNotFoundException e) {
+            logger.error("Failed to initialise client constructor");
+        }
+        clientList = new ArrayList<TcpServerClient>();
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            serverSocket = new ServerSocket(port);
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+    }
+
+    public void deactivate() throws DeactivateException {
+        for (TcpServerClient client : clientList) {
+            client.stop();
+        }
+    }
+
+    public void exit() {
+        super.exit();
+        try {
+            serverSocket.close();
+            for (TcpServerClient client : clientList) {
+                client.exit();
+            }
+        } catch (IOException e) {
+            logger.error("", e);
+        }
+    }
+
+    public void work() {
+        try {
+            Socket socket = serverSocket.accept();
+            TcpServerClient client = (TcpServerClient) clientConstructor.newInstance(this, socket);
+            clientList.add(client);
+            client.start();
+            System.out.println("Accepted new connection from client: " + socket);
+        } catch (IOException e) {
+            stop();
+        } catch (Exception e) {
+            logger.error("", e);
+        }
+    }
+
+    public void send(byte[] buffer) throws IOException {
+        logger.debug("Number of clients = " + clientList.size());
+        for (TcpServerClient client : clientList) {
+            // Should be dealt with in clients own thread?
+            client.send(buffer);
+        }        
+    }
+
+    public void input(TcpServerClient client, byte[] buffer) {}
+}
--- a/java/core.networking/src/main/java/base/server/socket/TcpServerClient.java
+++ b/java/core.networking/src/main/java/base/server/socket/TcpServerClient.java
@@ -0,0 +1,37 @@
+package base.server.socket;
+
+import java.io.IOException;
+import java.net.Socket;
+
+import base.exception.worker.ActivateException;
+
+public class TcpServerClient extends AbstractTcpClient {
+    private TcpServer server;
+
+    public TcpServerClient(TcpServer server, Socket socket) {
+        this(server, socket, BUFFER_SIZE);
+    }
+
+    public TcpServerClient(TcpServer server, Socket socket, Integer bufferSize) {
+        super(bufferSize);
+        this.server = server;
+        this.socket = socket;
+    }
+
+    public void activate() throws ActivateException {
+        try {
+            inputStream = socket.getInputStream();
+            outputStream = socket.getOutputStream();
+            synchronized (object) {
+                object.notifyAll();
+            }
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+    }
+
+    public void input(byte[] buffer) {
+        server.input(this, buffer);        
+    }
+}
--- a/java/core.networking/src/main/java/junit/AllTests.java
+++ b/java/core.networking/src/main/java/junit/AllTests.java
@@ -0,0 +1,20 @@
+package junit;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+import networking.TestUdpMulticastCommunication;
+import networking.TestUdpUnicastCommunication;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+    TestTcpSocketCommunication.class,
+    TestTcpChannelCommunication.class,
+    TestUdpUnicastCommunication.class,
+    TestUdpMulticastCommunication.class,
+    TestUdpDuplexCommunication.class
+})
+
+public class AllTests {}
+// Should test start()/stop() of components, check implementation
--- a/java/core.networking/src/main/java/junit/TestTcpChannelCommunication.java
+++ b/java/core.networking/src/main/java/junit/TestTcpChannelCommunication.java
@@ -0,0 +1,94 @@
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.channel.TcpClient;
+import base.server.channel.TcpServer;
+import base.server.channel.TcpServerClient;
+
+public class TestTcpChannelCommunication {
+    protected TestTcpServer server;
+    protected TestTcpClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestTcpServer(1234);
+        server.start();
+        client = new TestTcpClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(100);
+        }        
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        client.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testSendServerToClient() throws Exception {
+        // If client can send, connection has been established
+        client.send("init".getBytes());
+
+        String message = "test";
+        server.send(message.getBytes());
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestTcpServer extends TcpServer {
+        public byte[] buffer;
+
+        public TestTcpServer(int port) {
+            super(port);
+        }
+
+        public void input(TcpServerClient client, byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }                
+        }
+    }
+
+    class TestTcpClient extends TcpClient {
+        public byte[] buffer;
+
+        public TestTcpClient(int port) {
+            super(port);
+        }
+
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }                
+        }
+        
+    }
+}
--- a/java/core.networking/src/main/java/junit/TestTcpSocketCommunication.java
+++ b/java/core.networking/src/main/java/junit/TestTcpSocketCommunication.java
@@ -0,0 +1,93 @@
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.socket.TcpClient;
+import base.server.socket.TcpServer;
+import base.server.socket.TcpServerClient;
+
+public class TestTcpSocketCommunication {
+    protected TestTcpServer server;
+    protected TestTcpClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestTcpServer(1234);
+        server.start();
+        client = new TestTcpClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(100);
+        }
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        client.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testSendServerToClient() throws Exception {
+        // If client can send, connection has been established
+        client.send("init".getBytes());
+
+        String message = "test";
+        server.send(message.getBytes());
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestTcpServer extends TcpServer {
+        public byte[] buffer;
+
+        public TestTcpServer(int port) {
+            super(port);
+        }
+
+        public void input(TcpServerClient client, byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }
+        }
+    }
+
+    class TestTcpClient extends TcpClient {
+        public byte[] buffer;
+
+        public TestTcpClient(int port) {
+            super(port);
+        }
+
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }
+        }        
+    }
+}
--- a/java/core.networking/src/main/java/junit/TestUdpDuplexCommunication.java
+++ b/java/core.networking/src/main/java/junit/TestUdpDuplexCommunication.java
@@ -0,0 +1,96 @@
+package junit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.net.UnknownHostException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpDuplexAutoClient;
+import base.server.datagram.UdpDuplexServer;
+
+public class TestUdpDuplexCommunication {
+    protected TestUdpDuplexServer server;
+    protected TestUdpDuplexClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestUdpDuplexServer(1234, 1235);
+        server.start();
+        client = new TestUdpDuplexClient(1234, 1235);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(1000);
+        }
+    }
+
+    @Test
+    public void testServerToClientCommunication() throws Exception {
+        String message = "test";
+        server.send(message.getBytes());
+        System.err.println("send");
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testClientToServerCommunication() throws Exception {
+        // Let client discover server address
+        testServerToClientCommunication();
+
+        String message = "test";
+        client.send(message.getBytes());
+        System.err.println("send");
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    public class TestUdpDuplexServer extends UdpDuplexServer {
+        public byte[] buffer;
+
+        public TestUdpDuplexServer(int sendPort, int bindPort) {
+            super(sendPort, bindPort);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+
+    class TestUdpDuplexClient extends UdpDuplexAutoClient {
+        public byte[] buffer;
+
+        public TestUdpDuplexClient(int bindPort, int sendPort) throws UnknownHostException {
+            super(bindPort, sendPort);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}
--- a/java/core.networking/src/test/java/networking/AllTests.java
+++ b/java/core.networking/src/test/java/networking/AllTests.java
@@ -0,0 +1,17 @@
+package networking;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({
+    TestTcpSocketCommunication.class,
+    TestTcpChannelCommunication.class,
+    TestUdpUnicastCommunication.class,
+    TestUdpMulticastCommunication.class,
+    TestUdpDuplexCommunication.class
+})
+
+public class AllTests {}
+// Should test start()/stop() of components, check implementation
--- a/java/core.networking/src/test/java/networking/TestTcpChannelCommunication.java
+++ b/java/core.networking/src/test/java/networking/TestTcpChannelCommunication.java
@@ -0,0 +1,94 @@
+package networking;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.channel.TcpClient;
+import base.server.channel.TcpServer;
+import base.server.channel.TcpServerClient;
+
+public class TestTcpChannelCommunication {
+    protected TestTcpServer server;
+    protected TestTcpClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestTcpServer(1234);
+        server.start();
+        client = new TestTcpClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(100);
+        }        
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        client.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testSendServerToClient() throws Exception {
+        // If client can send, connection has been established
+        client.send("init".getBytes());
+
+        String message = "test";
+        server.send(message.getBytes());
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestTcpServer extends TcpServer {
+        public byte[] buffer;
+
+        public TestTcpServer(int port) {
+            super(port);
+        }
+
+        public void input(TcpServerClient client, byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }                
+        }
+    }
+
+    class TestTcpClient extends TcpClient {
+        public byte[] buffer;
+
+        public TestTcpClient(int port) {
+            super(port);
+        }
+
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }                
+        }
+        
+    }
+}
--- a/java/core.networking/src/test/java/networking/TestTcpSocketCommunication.java
+++ b/java/core.networking/src/test/java/networking/TestTcpSocketCommunication.java
@@ -0,0 +1,93 @@
+package networking;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.socket.TcpClient;
+import base.server.socket.TcpServer;
+import base.server.socket.TcpServerClient;
+
+public class TestTcpSocketCommunication {
+    protected TestTcpServer server;
+    protected TestTcpClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestTcpServer(1234);
+        server.start();
+        client = new TestTcpClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(100);
+        }
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        client.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testSendServerToClient() throws Exception {
+        // If client can send, connection has been established
+        client.send("init".getBytes());
+
+        String message = "test";
+        server.send(message.getBytes());
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestTcpServer extends TcpServer {
+        public byte[] buffer;
+
+        public TestTcpServer(int port) {
+            super(port);
+        }
+
+        public void input(TcpServerClient client, byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }
+        }
+    }
+
+    class TestTcpClient extends TcpClient {
+        public byte[] buffer;
+
+        public TestTcpClient(int port) {
+            super(port);
+        }
+
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }
+        }        
+    }
+}
--- a/java/core.networking/src/test/java/networking/TestUdpDuplexCommunication.java
+++ b/java/core.networking/src/test/java/networking/TestUdpDuplexCommunication.java
@@ -0,0 +1,96 @@
+package networking;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import java.net.UnknownHostException;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpDuplexAutoClient;
+import base.server.datagram.UdpDuplexServer;
+
+public class TestUdpDuplexCommunication {
+    protected TestUdpDuplexServer server;
+    protected TestUdpDuplexClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestUdpDuplexServer(1234, 1235);
+        server.start();
+        client = new TestUdpDuplexClient(1234, 1235);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(1000);
+        }
+    }
+
+    @Test
+    public void testServerToClientCommunication() throws Exception {
+        String message = "test";
+        server.send(message.getBytes());
+        System.err.println("send");
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    @Test
+    public void testClientToServerCommunication() throws Exception {
+        // Let client discover server address
+        testServerToClientCommunication();
+
+        String message = "test";
+        client.send(message.getBytes());
+        System.err.println("send");
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    public class TestUdpDuplexServer extends UdpDuplexServer {
+        public byte[] buffer;
+
+        public TestUdpDuplexServer(int sendPort, int bindPort) {
+            super(sendPort, bindPort);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+
+    class TestUdpDuplexClient extends UdpDuplexAutoClient {
+        public byte[] buffer;
+
+        public TestUdpDuplexClient(int bindPort, int sendPort) throws UnknownHostException {
+            super(bindPort, sendPort);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}
--- a/java/core.networking/src/test/java/networking/TestUdpMulticastCommunication.java
+++ b/java/core.networking/src/test/java/networking/TestUdpMulticastCommunication.java
@@ -0,0 +1,63 @@
+package networking;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpMulticastClient;
+import base.server.datagram.UdpMulticastServer;
+
+public class TestUdpMulticastCommunication {
+    protected UdpMulticastServer server;
+    protected TestUdpMulticastClient client;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new UdpMulticastServer(1234);
+        server.start();
+        client = new TestUdpMulticastClient(1234);
+        client.start();
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        client.exit();
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (client.active() || server.active()) {
+            Thread.sleep(1000);
+        }
+    }
+
+    @Test
+    public void testServerToClientCommunication() throws Exception {
+        String message = "test";
+        server.send(message.getBytes());
+        System.err.println("send");
+        synchronized (client) {
+            client.wait(2000);
+        }
+        byte[] buffer = client.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestUdpMulticastClient extends UdpMulticastClient {
+        public byte[] buffer;
+
+        public TestUdpMulticastClient(int port) {
+            super(port);
+        }
+
+        public void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}
--- a/java/core.networking/src/test/java/networking/TestUdpUnicastCommunication.java
+++ b/java/core.networking/src/test/java/networking/TestUdpUnicastCommunication.java
@@ -0,0 +1,61 @@
+package networking;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import base.server.datagram.UdpSender;
+import base.server.datagram.UdpServer;
+
+public class TestUdpUnicastCommunication {
+    protected TestUdpServer server;
+    protected UdpSender sender;
+
+    @Before
+    public void setUp() throws Exception {
+        server = new TestUdpServer(1234);
+        server.start();
+        sender = new UdpSender(1234);
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        server.exit();
+
+        // Should add blocking stop and exit to worker
+        while (server.active()) {
+            Thread.sleep(100);
+        }        
+    }
+
+    @Test
+    public void testSendClientToServer() throws Exception {
+        String message = "test";
+        sender.send(message.getBytes());
+        synchronized (server) {
+            server.wait(2000);
+        }
+        byte[] buffer = server.buffer;
+        assertNotNull("Received input", buffer);
+        assertEquals("Message intact", message, new String(buffer).trim());
+    }
+
+    class TestUdpServer extends UdpServer {
+        public byte[] buffer;
+
+        public TestUdpServer(int port) {
+            super(port);
+        }
+
+        @Override
+        protected void input(byte[] buffer) {
+            this.buffer = buffer;
+            synchronized (this) {
+                notifyAll();
+            }            
+        }
+    }
+}