source: java/main/src/main/java/com/framsticks/experiment/SimulatorConnector.java @ 193

package com.framsticks.experiment;

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

import com.framsticks.communication.Address;
import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.remote.RemoteTree;
import com.framsticks.structure.Path;
import com.framsticks.util.Misc;
import com.framsticks.util.dispatching.Dispatcher;
import com.framsticks.util.dispatching.Dispatching;
import com.framsticks.util.dispatching.Future;
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.structure.TreeOperations.*;

@FramsClassAnnotation
public class SimulatorConnector extends SingleSimulatorProvider implements JoinableParent {
        private static final Logger log = LogManager.getLogger(SimulatorConnector.class);

        protected Experiment experiment;
        protected RemoteTree remoteTree;
        protected Simulator simulator;
        protected Address address;
        protected boolean provided = false;

        public boolean hasProvided() {
                return provided;
        }

        public void setAddress(Address address) {
                this.address = address;
        }

        public Address getAddress() {
                return address;
        }


        @Override
        public String getName() {
                return "simulator connector";
        }

        @Override
        protected void joinableStart() {

        }

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

        @Override
        protected void joinableFinish() {

        }

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

        @SuppressWarnings({ "rawtypes", "unchecked" })
        @Override
        public void provideSimulator(final SimulatorSpecification specification, final FutureHandler<Simulator> future) {
                if (hasProvided()) {
                        future.pass(null);
                        return;
                }
                provided = true;
                experiment = specification.getExperiment();

                Misc.throwIfNull(address);
                log.debug("connecting to simulator at {}", address);
                // experiment
                remoteTree = new RemoteTree();
                remoteTree.setAddress(address);
                remoteTree.setDispatcher((Dispatcher) experiment.getDispatcher());

                experiment.getSimulatorCandidates().add(remoteTree);
                Dispatching.use(remoteTree, this);

                Dispatching.dispatchLog(remoteTree, log, Level.DEBUG, "first task in remote tree");

                tryGet(remoteTree, "/simulator", new Future<Path>(experiment) {

                        @Override
                        protected void result(Path result) {
                                log.debug("resolved simulator path: {}", result);
                                Misc.checkEquals(specification.getDefinition(), bindAccess(result).get("expdef", String.class), "expdef mismatch in connected simulator", SimulatorConnector.this);

                                simulator = experiment.createSimulator(remoteTree, result);

                                future.pass(simulator);
                        }
                });
        }

        @Override
        public void childChangedState(Joinable joinable, JoinableState state) {
                log.debug("child {} changed state to {}", joinable, state);
        }
}