source: java/main/src/main/java/com/framsticks/hosting/Server.java @ 100

package com.framsticks.hosting;

import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import com.framsticks.core.Tree;
import com.framsticks.params.annotations.AutoAppendAnnotation;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.Joinable;
import com.framsticks.util.dispatching.JoinableCollection;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;
import com.framsticks.util.dispatching.RunAt;
import com.framsticks.util.dispatching.Task;
import com.framsticks.util.dispatching.ThrowExceptionHandler;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import com.framsticks.util.dispatching.Thread;

@FramsClassAnnotation
public class Server extends AbstractJoinable implements JoinableParent {

        private final static Logger log = LogManager.getLogger(Server.class);

        protected int port;

        protected ServerSocket acceptSocket;
        protected Tree hosted;
        protected final JoinableCollection<ClientAtServer> clients = new JoinableCollection<ClientAtServer>();

        public static class Accept {
        };

        protected Thread<Accept> acceptThread = new Thread<>();

        /**
         *
         */
        public Server() {
                log.debug("created server");
                port = 9009;
        }

        /**
         * @return the port
         */
        @ParamAnnotation
        public int getPort() {
                return port;
        }

        /**
         * @param port the port to set
         */
        @ParamAnnotation
        public void setPort(int port) {
                this.port = port;
        }

        @Override
        protected void joinableInterrupt() {
                Dispatching.drop(acceptThread, this);
                Dispatching.drop(hosted, this);
                Dispatching.drop(clients, this);
                try {
                        acceptSocket.close();
                } catch (IOException e) {
                        log.debug("exception caught during socket closing: ", e);
                }
                finish();
        }

        /**
         * @return the hosted
         */
        public Tree getHosted() {
                return hosted;
        }

        @AutoAppendAnnotation
        public void setHosted(Tree hosted) {
                if (this.hosted != null) {
                        throw new FramsticksException().msg("hosted tree is already set").arg("current", this.hosted);
                }
                this.hosted = hosted;
                acceptThread.setName(hosted.getName() + " acceptor");
                clients.setObservableName(hosted.getName() + " clients");
        }

        @Override
        public void childChangedState(Joinable joinable, JoinableState state) {
                proceedToState(state);
        }

        @Override
        protected void joinableStart() {
                Dispatching.use(acceptThread, this);
                Dispatching.use(hosted, this);
                Dispatching.use(clients, this);
                try {
                        acceptSocket = new ServerSocket();
                } catch (IOException e) {
                        throw new FramsticksException().msg("failed to create server socket").cause(e);
                }
                tryBind(0);
        }

        @Override
        @ParamAnnotation
        public String getName() {
                return hosted != null ? hosted.getName() : "server";
        }

        protected void acceptNext() {
                if (!isRunning()) {
                        log.debug("server is not in running state, aborting accepting");
                        return;
                }
                acceptThread.dispatch(new RunAt<Accept>(hosted) {
                        @Override
                        protected void runAt() {
                                try {
                                        log.debug("accepting");
                                        final Socket socket = acceptSocket.accept();
                                        assert socket != null;
                                        log.debug("accepted socket: {}", socket.getInetAddress().getHostAddress());
                                        hosted.dispatch(new RunAt<Tree>(this) {
                                                @Override
                                                protected void runAt() {
                                                        ClientAtServer client = new ClientAtServer(Server.this, socket);
                                                        clients.add(client);
                                                        log.info("client connected: {}", client);
                                                }
                                        });
                                } catch (IOException e) {
                                        log.log((isRunning() ? Level.ERROR : Level.DEBUG), "failed to accept socket: {}", e);
                                }
                                acceptNext();
                        }
                });
        }

        protected void tryBind(int when) {
                acceptThread.dispatch(new Task<Accept>(ThrowExceptionHandler.getInstance(), when) {
                        @Override
                        protected void runAt() {
                                try {
                                        acceptSocket.bind(new InetSocketAddress(port));
                                        log.debug("started accepting on port {}", port);
                                        acceptNext();
                                        return;
                                } catch (IOException e) {
                                        log.warn("failed to accept on port {} (repeating): ", port, e);
                                }
                                tryBind(1000);
                        }
                });
        }

        @Override
        protected void joinableFinish() {

        }

        @Override
        protected void joinableJoin() throws InterruptedException {
                Dispatching.join(acceptThread);
                Dispatching.join(hosted);
                Dispatching.join(clients);
        }

        // @Override
        // public FramsClass getInfoFromCache(String id) {
        //      assert isActive();
        //      if (id == null) {
        //              return null;
        //      }
        //      FramsClass cached = registry.getFramsClass(id);
        //      if (cached != null) {
        //              return cached;
        //      }
        //      try {
        //              Class<?> nativeClass = Class.forName(id);
        //              FramsClass framsClass = FramsClass.build().forClass(nativeClass);

        //              if (!framsClass.getId().equals(id)) {
        //                      log.error("no matching id");
        //                      return null;
        //              }

        //              registry.registerReflectedClass(null, id, nativeClass);
        //              registry.putFramsClass(framsClass);
        //              return framsClass;
        //      } catch (ClassNotFoundException ignored) {
        //      } catch (ConstructionException e) {
        //              log.error("failed to use info from cache: {}", e);
        //      }

        //      return null;
        // }

        // @Override
        // protected void fetchInfo(Path path, Future<FramsClass> future) {
        //      assert isActive();

        //      FramsClass framsClass = getInfoFromCache(path.getTop().getObject().getClass().getCanonicalName());
        //      if (framsClass == null) {
        //              log.error("failed to create frams class for: {}", path.getTop().getObject().getClass());
        //              future.result(null, new Exception());
        //              return;
        //      }
        //      future.result(framsClass, null);
        // }
}