source: java/main/src/main/java/com/framsticks/hosting/ClientAtServer.java @ 97

package com.framsticks.hosting;

import static com.framsticks.util.lang.Strings.assureNotEmpty;

import com.framsticks.communication.*;
import com.framsticks.communication.queries.ApplicationRequest;
import com.framsticks.communication.queries.CallRequest;
import com.framsticks.communication.queries.GetRequest;
import com.framsticks.communication.queries.InfoRequest;
import com.framsticks.communication.queries.SetRequest;
import com.framsticks.core.Mode;
import com.framsticks.core.Tree;
import com.framsticks.core.Path;
import com.framsticks.params.*;
import com.framsticks.params.types.ProcedureParam;
import com.framsticks.parsers.Savers;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.dispatching.AbstractJoinable;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.FutureHandler;
import com.framsticks.util.dispatching.Joinable;
import com.framsticks.util.dispatching.JoinableParent;
import com.framsticks.util.dispatching.JoinableState;
import static com.framsticks.core.TreeOperations.*;

import java.net.Socket;
import java.util.LinkedList;
import java.util.List;

/**
 * @author Piotr Sniegowski
 */
public class ClientAtServer extends AbstractJoinable implements RequestHandler, JoinableParent {

        protected final Server server;
        protected final Tree tree;
        protected final ServerSideManagedConnection connection;

        public ClientAtServer(Server server, Socket socket) {
                this.server = server;
                this.tree = server.hosted;
                this.connection = new ServerSideManagedConnection(socket, this);
        }

        @Override
        public String getName() {
                return connection + " to " + server;
        }

        @Override
        public void handle(final ApplicationRequest request, final ServerSideResponseFuture responseCallback) {
                assureNotEmpty(request.getPath());

                resolve(tree, request.getPath(), new FutureHandler<Path>(responseCallback) {
                        @Override
                        protected void result(final Path path) {

                                // final AccessInterface access = tree.prepareAccess(path);
                                final AccessInterface access = bindAccess(path);

                                if (request instanceof SetRequest) {
                                        SetRequest setRequest = (SetRequest) request;
                                        //TODO Primitive Param?
                                        tree.set(path, access.getFramsClass().getParamEntry(setRequest.getField(), PrimitiveParam.class), setRequest.getValue(), new FutureHandler<Integer>(responseCallback) {
                                                @Override
                                                protected void result(Integer flag) {
                                                        responseCallback.pass(new Response(true, Flags.write(flag, null), null));

                                                }
                                        });
                                        return;
                                }

                                if (request instanceof GetRequest) {
                                        tree.get(path, Mode.FETCH, new FutureHandler<Object>(responseCallback) {

                                                @Override
                                                protected void result(Object result) {
                                                        if (result != access.getSelected()) {
                                                                throw new FramsticksException().msg("mismatch objects during fetch").arg("path", path);
                                                        }
                                                        // TODO Auto-generated method stub
                                                        List<File> files = new LinkedList<File>();
                                                        ListSink sink = new ListSink();
                                                        access.save(sink);
                                                        files.add(new File(path.getTextual(), new ListSource(sink.getOut())));
                                                        responseCallback.pass(new Response(true, "", files));
                                                }
                                        });

                                        return;
                                }
                                if (request instanceof CallRequest) {
                                        final CallRequest callRequest = (CallRequest) request;
                                        tree.call(path, access.getFramsClass().getParamEntry(callRequest.getProcedure(), ProcedureParam.class), callRequest.getArguments().toArray(), new FutureHandler<Object>(responseCallback) {
                                                @Override
                                                protected void result(Object result) {
                                                        ListSink sink = new ListSink();
                                                        sink.print("Result:").breakLine();
                                                        sink.print("value:").print("[");
                                                        if (result != null) {
                                                                sink.print(result);
                                                        }
                                                        sink.print("]");

                                                        responseCallback.pass(new Response(true, "", File.single(new File("", new ListSource(sink.getOut())))));
                                                }
                                        });
                                        return;
                                }
                                if (request instanceof InfoRequest) {
                                        FramsClass framsClass = getInfo(path);
                                        if (framsClass == null) {
                                                throw new FramsticksException().msg("info should be available");
                                        }
                                        responseCallback.pass(new Response(true, null, File.single(new File(path.getTextual(), new ListSource(Savers.saveFramsClass(new ListSink(), framsClass).getOut())))));
                                        return;
                                }

                                throw new FramsticksException().msg("invalid request type: " + request.getCommand());
                        }
                });

        }

        @Override
        protected void joinableStart() {
                Dispatching.use(connection, this);
        }

        @Override
        protected void joinableInterrupt() {
                Dispatching.drop(connection, this);
        }

        @Override
        protected void joinableFinish() {
        }

        @Override
        protected void joinableJoin() throws InterruptedException {
                Dispatching.join(connection);
        }

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


}