Changeset 102 for java/main/src/main/java/com/framsticks/experiment/Experiment.java

Timestamp:

07/16/13 23:31:35 (11 years ago)

Author:

psniegowski

Message:

HIGHLIGHTS:

• add StackedJoinable? as a utility class to allow strict stack policy

for Joinables running

• add SimulatorConnector?
  • provide Experiment with single Simulator instance
  • checks loaded expdef
• fix bug with sockets closure
• improve task dispatching on startup (BufferedDispatcher?)
• draft Experiment implementation
• add NetLoadSaveLogic?
• add WorkPackageLogic?
• add PrimeExperiment? experiment class

CHANGELOG:
Add WorkPackageLogic? and classes representing prime experiment state.

Add classes for PrimeExperiment? state.

Extract single netload routine in Simulator.

Working netload with dummy content in PrimeExperiment?.

More development with NetLoadSaveLogic? and PrimeExperiment?.

Improvement around prime.

Improve BufferedDispatcher?.isActive logic.

Add prime-all.xml configuration.

Manual connecting to existing simulators from GUI.

Guard in SimulatorConnector? against expdef mismatch.

Guard against empty target dispatcher in BufferedDispatcher?.

Make BufferedDispatcher? a Dispatcher (and Joinable).

Minor improvements.

Done StackedJoinable?, improve Experiment.

Develop StackedJoinable?.

Add StackedJoinable? utility joinables controller.

Add dependency on apache-commons-lang.

Add ready ListChange? on Simulators.

Improve hints in ListChange?.

Several improvements.

Found bug with dispatching in Experiment.

Minor improvements.

Fix bug with early finishing Server.

Many changes in Dispatching.

Fix bug with connection.

Do not obfuscate log with socket related exceptions.

Add SocketClosedException?.

Add SimulatorConnector?.

Work out conception of experiment composing of logics building blocks.

Rename SinkInterface? to Sink.

Move saving of Accesses into AccessOperations?.

Some improvements to Experiment.

Improve joinables.

Fix issue with joinables closing.

Add direct and managed consoles to popup menu.

File:

• java/main/src/main/java/com/framsticks/experiment/Experiment.java (modified) (3 diffs)

java/main/src/main/java/com/framsticks/experiment/Experiment.java

@@ -2 +2 @@
 
 import java.util.Map;
+
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.LogManager;
 
 import com.framsticks.core.ListChange;
 import com.framsticks.params.EventListener;
+import com.framsticks.params.ParamFlags;
 import com.framsticks.params.SimpleUniqueList;
 import com.framsticks.params.annotations.AutoAppendAnnotation;
 import com.framsticks.params.annotations.FramsClassAnnotation;
 import com.framsticks.params.annotations.ParamAnnotation;
+import com.framsticks.params.types.ProcedureParam;
+import com.framsticks.remote.RemoteTree;
+import com.framsticks.util.FramsticksException;
+import com.framsticks.util.dispatching.AbstractJoinable;
+import com.framsticks.util.dispatching.BufferedDispatcher;
+import com.framsticks.util.dispatching.Dispatcher;
+import com.framsticks.util.dispatching.DispatcherSetable;
+import com.framsticks.util.dispatching.Dispatching;
+import com.framsticks.util.dispatching.ExceptionResultHandler;
+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;
 
 @FramsClassAnnotation
-public class Experiment extends JoinableCollection<Simulator> {
+public class Experiment extends AbstractJoinable implements Dispatcher<Experiment>, DispatcherSetable<Experiment>, JoinableParent, ExceptionResultHandler {
+        private static final Logger log = LogManager.getLogger(Experiment.class);
+
+        protected final JoinableCollection<Simulator> simulatorAsJoinables = new JoinableCollection<Simulator>().setObservableName("simulators");
+
+        protected final JoinableCollection<RemoteTree> simulatorCandidates = new JoinableCollection<RemoteTree>().setObservableName("candidates");
 
         protected final SimpleUniqueList<Simulator> simulators = new SimpleUniqueList<>(Simulator.class, 's');
+
+        protected final SimpleUniqueList<Simulator> oldSimulators = new SimpleUniqueList<>(Simulator.class, 's');
+
+        protected final BufferedDispatcher<Experiment> bufferedDispatcher = new BufferedDispatcher<>(this);
+
+        protected String expdef;
+
+        /**
+         *
+         */
+        public Experiment() {
+                super();
+                bufferedDispatcher.setBuffer(false);
+
+                Dispatching.dispatchLog(this, log, Level.DEBUG, "first task");
+
+
+                simulators.addListener(new EventListener<ListChange>() {
+                        @Override
+                        public void action(ListChange argument) {
+                                if (argument.getAction() == ListChange.Action.Add) {
+                                        simulators.fireChildrenChange(argument, ListChange.Action.Modify, "ready");
+                                }
+                        }
+                });
+
+        }
+
+        /**
+         * @return the simulatorCandidates
+         */
+        public JoinableCollection<RemoteTree> getSimulatorCandidates() {
+                return simulatorCandidates;
+        }
 
         @ParamAnnotation
@@ -21 +78 @@
         }
 
+        @ParamAnnotation(id = "old_simulators")
+        public Map<String, Simulator> getOldSimulators() {
+                return oldSimulators.getView();
+        }
+
+        /**
+         * @return the dispatcher
+         */
+        @Override
+        public Dispatcher<Experiment> getDispatcher() {
+                return bufferedDispatcher;
+        }
+
+        /**
+         * @param dispatcher the dispatcher to set
+         */
+        @Override
+        public void setDispatcher(Dispatcher<Experiment> dispatcher) {
+                bufferedDispatcher.setTargetDispatcher(dispatcher);
+        }
+
+        /**
+         * @return the expdef
+         */
+        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
+        public String getExpdef() {
+                return expdef;
+        }
+
+        /**
+         * @param expdef the expdef to set
+         */
+        @ParamAnnotation
+        public void setExpdef(String expdef) {
+                this.expdef = expdef;
+        }
+
         @ParamAnnotation(id = "simulators_changed")
         public void addSimulatorsListener(EventListener<ListChange> listener) {
@@ -34 +128 @@
         public void addSimulator(Simulator simulator) {
                 simulators.add(simulator);
-        }
+                simulatorAsJoinables.add(simulator);
+
+
+
+
+
+        }
+
+        protected void removeSimulator(Simulator simulator) {
+                simulatorAsJoinables.remove(simulator);
+                simulators.remove(simulator);
+                oldSimulators.add(simulator);
+        }
+
+        @ParamAnnotation(id = "old_simulators_changed")
+        public void addOldSimulatorsListener(EventListener<ListChange> listener) {
+                oldSimulators.addListener(listener);
+        }
+
+        @ParamAnnotation(id = "old_simulators_changed")
+        public void removeOldSimulatorsListener(EventListener<ListChange> listener) {
+                oldSimulators.removeListener(listener);
+        }
+
+        @Override
+        public String getName() {
+                return "experiment";
+        }
+
+        @Override
+        public void childChangedState(Joinable joinable, JoinableState state) {
+                proceedToState(state);
+        }
+
+        @Override
+        protected void joinableStart() {
+                bufferedDispatcher.createThreadIfNeeded();
+                Dispatching.use(bufferedDispatcher, this);
+
+                Dispatching.use(simulatorAsJoinables, this);
+                Dispatching.use(simulatorCandidates, this);
+        }
+
+        @Override
+        protected void joinableInterrupt() {
+
+                Dispatching.drop(simulatorAsJoinables, this);
+                Dispatching.drop(simulatorCandidates, this);
+
+                finishJoinable();
+        }
+
+        @Override
+        protected void joinableFinish() {
+                log.debug("finishing experiment {}", this);
+        }
+
+        @Override
+        protected void joinableJoin() throws InterruptedException {
+                Dispatching.drop(bufferedDispatcher, this);
+
+                Dispatching.join(simulatorAsJoinables);
+                Dispatching.join(simulatorCandidates);
+                Dispatching.join(bufferedDispatcher.getTargetDispatcher());
+        }
+
+        @Override
+        public void handle(FramsticksException exception) {
+                log.error("caught exception: ", exception);
+        }
+
+        @Override
+        public boolean isActive() {
+                return bufferedDispatcher.isActive();
+        }
+
+        @Override
+        public void dispatch(RunAt<? extends Experiment> runnable) {
+                bufferedDispatcher.dispatch(runnable);
+        }
+
+        @ParamAnnotation(paramType = ProcedureParam.class)
+        public void connectToSimulator(String address) {
+                SimulatorConnector connector = new SimulatorConnector();
+                connector.setAddress(address);
+                connector.attachTo(this);
+        }
+
 }