Changeset 102 for java/main/src


Ignore:
Timestamp:
07/16/13 23:31:35 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGHTS:

for Joinables running

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.

Location:
java/main/src
Files:
20 added
1 deleted
65 edited

Legend:

Unmodified
Added
Removed

  • java/main/src/main/java/com/framsticks/communication/ClientSideManagedConnection.java

    r101 r102  
    132132
    133133        public void send(ProtocolRequest request, ClientSideResponseFuture callback) {
    134                 //TODO RunAt
    135134                sendImplementation(request, AtOnceDispatcher.getInstance(), callback);
    136135        }
    … …  
    466465
    467466                final String finalEventPath = eventPath;
    468                                 //TODO add arguments to the exception
     467                //TODO add arguments to the exception
    469468                send(new CallRequest().procedure("remove").path(eventPath), dispatcher, new ClientSideResponseFuture(future) {
    470469

  • java/main/src/main/java/com/framsticks/communication/Connection.java

    r101 r102  
    1818import java.io.PrintWriter;
    1919import java.net.Socket;
    20 import java.net.SocketTimeoutException;
    2120import java.util.Collection;
    2221import java.util.HashSet;
    … …  
    8786        public Connection setAddress(String address) {
    8887                return setAddress(new Address(address));
    89         }
    90 
    91         public synchronized boolean isConnected() {
    92                 return socket != null && socket.isConnected();
    9388        }
    9489
    … …  
    131126
    132127                                readChars = 0;
    133                                 while (readChars == 0) {
    134                                         try {
    135                                                 readChars = input.read(readBuffer);
    136                                         } catch (SocketTimeoutException ignored) {
    137                                                 //timeout - continue
    138                                         }
     128                                readChars = input.read(readBuffer);
     129                                if (readChars < 0) {
     130                                        throw new SocketClosedException().msg("socket is closed");
    139131                                }
    140132                                iterator = 0;
    … …  
    143135                        throw new InterruptedException();
    144136                } catch (Exception e) {
    145                         throw new FramsticksException().msg("failed to read line").cause(e);
     137                        log.debug("failed to read line (closing): {}", e.getMessage());
     138                        throw new SocketClosedException().msg("failed to read line").cause(e);
    146139                }
    147140        }
    … …  
    162155        protected abstract void processNextInputBatch();
    163156
     157
    164158        protected final void processInputBatchesUntilClosed() {
    165                 while (isRunning() && isConnected()) {
     159                while (isRunning() && !socket.isClosed()) {
    166160                        try {
    167161                                processNextInputBatch();
     162                        } catch (SocketClosedException e) {
     163                                log.log(isRunning() ? Level.ERROR : Level.DEBUG, "socket is closing: {}", e.getShortMessage(new StringBuilder()));
     164                                // log.log(isRunning() ? Level.ERROR : Level.DEBUG, "caught exception: ", e);
     165                                break;
    168166                        } catch (FramsticksException e) {
     167                                log.debug("{} caught exception in receiver thread {}", this, e.getMessage());
    169168                                handle(e);
    170169                        } catch (Exception e) {
    … …  
    173172                        }
    174173                }
     174                log.debug("{} finished processing input", this);
    175175        }
    176176
    … …  
    227227                Dispatching.use(threads, this);
    228228
    229                 senderThread.dispatch(new RunAt<Connection>(ThrowExceptionHandler.getInstance()) {
     229                senderThread.dispatch(new RunAt<Connection>(this) {
    230230                        @Override
    231231                        protected void runAt() {
    … …  
    238238                });
    239239
    240                 receiverThread.dispatch(new RunAt<Connection>(ThrowExceptionHandler.getInstance()) {
     240                receiverThread.dispatch(new RunAt<Connection>(this) {
    241241                        @Override
    242242                        protected void runAt() {
    243243                                receiverThreadRoutine();
    244244                                interruptJoinable();
    245                                 finishJoinable();
     245                                // finishJoinable();
    246246                        }
    247247                });
    … …  
    260260
    261261        protected static void startClientConnection(Connection connection) {
    262                 while (connection.isRunning() && !connection.isConnected()) {
     262                while (connection.isRunning() && connection.socket == null) {
    263263                        log.debug("connecting to {}", connection.address);
    264264                        try {
    265265                                connection.socket = new Socket(connection.getAddressObject().getHostName(), connection.getAddressObject().getPort());
    266266                        } catch (IOException e) {
    267                                 log.info("{} failed to connect (retrying): ", connection, e);
     267                                log.warn("{} failed to connect (retrying): {}", connection, e.getMessage());
    268268                                Dispatching.sleep(0.5);
    269269                        }
    … …  
    272272                log.debug("{} connected", connection);
    273273                try {
    274                         connection.socket.setSoTimeout(500);
     274                        // connection.socket.setSoTimeout(500);
    275275                        connection.setupStreams();
    276276                } catch (Exception e) {
    … …  
    319319        @Override
    320320        public void handle(FramsticksException exception) {
     321                log.debug("{} handling {}", this, exception.getMessage());
    321322                exceptionHandler.handle(exception);
    322323        }
    … …  
    358359        }
    359360
     361        public synchronized boolean isConnected() {
     362                return socket != null && socket.isConnected();
     363        }
     364
    360365}

  • java/main/src/main/java/com/framsticks/communication/ServerSideManagedConnection.java

    r101 r102  
    3232
    3333
    34         protected void processNextInputBatch() {
    35                 processNextRequest();
    36         }
    3734
    3835        @Override
    … …  
    9289
    9390
    94         protected void processNextRequest() {
     91        protected void processNextInputBatch() {
    9592                final Holder<Integer> id = new Holder<>();
    9693                final String line = getLine();
    … …  
    106103                        }
    107104
    108                         //TODO what to do here?
    109105                        handleRequest(request, new ServerSideResponseFuture() {
    110106                                @Override

  • java/main/src/main/java/com/framsticks/core/AbstractTree.java

    r101 r102  
    3434import com.framsticks.util.dispatching.JoinableState;
    3535import com.framsticks.util.dispatching.RunAt;
    36 import com.framsticks.util.dispatching.Thread;
    3736import com.framsticks.util.dispatching.ThrowExceptionHandler;
    3837import com.framsticks.util.lang.Pair;
    … …  
    4241 */
    4342@FramsClassAnnotation
    44 public abstract class AbstractTree extends AbstractJoinable implements Dispatcher<Tree>, Tree, JoinableParent, NeedFileAcceptor {
     43public abstract class AbstractTree extends AbstractJoinable implements Tree, JoinableParent, NeedFileAcceptor {
    4544
    4645        private static final Logger log = LogManager.getLogger(AbstractTree.class);
    … …  
    4948        private ExceptionResultHandler handler = ThrowExceptionHandler.getInstance();
    5049
    51         protected final BufferedDispatcher<Tree> bufferedDispatcher = new BufferedDispatcher<>();
     50        protected final BufferedDispatcher<Tree> bufferedDispatcher = new BufferedDispatcher<>(this);
    5251
    5352        protected final PriorityQueue<Pair<Integer, NeedFileAcceptor>> needFileAcceptors = new PriorityQueue<>(32, new Comparator<Pair<Integer, NeedFileAcceptor>>() {
    … …  
    7776        public void assignRootObject(Object object) {
    7877                if (root == null) {
    79                         throw new FramsticksException().msg("root is has no type specified");
     78                        throw new FramsticksException().msg("root has no type specified");
    8079                }
    8180                if (root.getObject() != null) {
    … …  
    8988        public @Nonnull Node getAssignedRoot() {
    9089                if (root == null) {
    91                         throw new FramsticksException().msg("root has no type specified yet");
     90                        throw new FramsticksException().msg("root has no type specified yet").arg("in", this);
    9291                }
    9392                return root;
    … …  
    173172        @Override
    174173        public Dispatcher<Tree> getDispatcher() {
    175                 return bufferedDispatcher.getTargetDispatcher();
     174                return bufferedDispatcher;
    176175        }
    177176
    … …  
    181180        @Override
    182181        public void setDispatcher(Dispatcher<Tree> dispatcher) {
    183                 if (bufferedDispatcher.getTargetDispatcher() != null) {
    184                         throw new FramsticksException().msg("dispatcher is already set").arg("tree", this).arg("dispatcher", bufferedDispatcher.getTargetDispatcher());
    185                 }
    186182                bufferedDispatcher.setTargetDispatcher(dispatcher);
    187183        }
    … …  
    213209        @Override
    214210        protected void joinableStart() {
    215                 if (bufferedDispatcher.getTargetDispatcher() == null) {
    216                         bufferedDispatcher.setTargetDispatcher(new Thread<Tree>());
    217                 }
    218                 Dispatching.use(bufferedDispatcher.getTargetDispatcher(), this);
     211                bufferedDispatcher.createThreadIfNeeded();
     212                Dispatching.use(bufferedDispatcher, this);
    219213        }
    220214
    221215        @Override
    222216        protected void joinableInterrupt() {
    223                 Dispatching.drop(bufferedDispatcher.getTargetDispatcher(), this);
     217                Dispatching.drop(bufferedDispatcher, this);
    224218        }
    225219
    … …  
    231225        @Override
    232226        protected void joinableJoin() throws InterruptedException {
    233                 Dispatching.join(bufferedDispatcher.getTargetDispatcher());
     227                Dispatching.join(bufferedDispatcher);
    234228        }
    235229
    236230        @Override
    237231        public void childChangedState(Joinable joinable, JoinableState state) {
    238                 if (joinable == bufferedDispatcher.getTargetDispatcher()) {
     232                if (joinable == bufferedDispatcher) {
    239233                        proceedToState(state);
    240234                }
    … …  
    333327                                        }
    334328                                }
    335                                 throw new FramsticksException().msg("failed to find need file acceptor in tree").arg("tree", AbstractTree.this);
     329                                throw new FramsticksException().msg("failed to find need file acceptor in tree").arg("tree", AbstractTree.this).arg("needfile", needFile);
    336330                        }
    337331                });

  • java/main/src/main/java/com/framsticks/core/ListChange.java

    r100 r102  
    11package com.framsticks.core;
     2
     3import java.util.Arrays;
     4import java.util.Set;
     5import java.util.TreeSet;
     6
     7import org.apache.commons.lang.StringUtils;
    28
    39import com.framsticks.params.annotations.FramsClassAnnotation;
    … …  
    915 * @author Piotr Sniegowski
    1016 */
    11 @FramsClassAnnotation(order = {"type", "pos", "id"})
     17@FramsClassAnnotation(order = {"type", "pos", "id", "hint"})
    1218public class ListChange {
    1319
     20        public static enum Action {
     21                Add,
     22                Remove,
     23                Modify
     24        }
    1425
    15         /**
    16          * @param action
    17          */
    18         public ListChange(Action action, Integer position, String identifier) {
     26
     27        public ListChange(Action action, Integer position, String identifier, Object... hints) {
    1928                this.action = action;
    2029                this.position = position;
    2130                this.identifier = identifier;
     31                if (hints.length != 0) {
     32                        this.hints = new TreeSet<>();
     33                        for (Object h : hints) {
     34                                this.hints.add(h.toString());
     35                        }
     36                }
    2237        }
    2338
    … …  
    4055        }
    4156
    42         public static enum Action {
    43                 Add,
    44                 Remove,
    45                 Modify
    46                 // Add(0),
    47                 // Remove(1),
    48                 // Modify(2);
    4957
    50                 // public final int value;
     58        public boolean hasHint(String hint) {
     59                if (hints == null) {
     60                        return false;
     61                }
     62                return hints.contains(hint);
     63        }
    5164
    52                 // /**
    53                 //  * @param value
    54                 //  */
    55                 // Action(int value) {
    56                 //      this.value = value;
    57                 // }
    58 
    59         }
    6065
    6166        public Action action = Action.Add;
    … …  
    6469        @ParamAnnotation(id = "id")
    6570        public String identifier;
     71
     72        protected Set<String> hints;
     73
     74        @ParamAnnotation
     75        public String getHints() {
     76                return StringUtils.join(hints, ",");
     77        }
     78
     79        @ParamAnnotation
     80        public void setHints(String hints) {
     81                if (!Strings.notEmpty(hints)) {
     82                        this.hints = null;
     83                        return;
     84                }
     85                this.hints = new TreeSet<>();
     86                this.hints.addAll(Arrays.asList(StringUtils.split(hints, ",")));
     87        }
    6688
    6789        @ParamAnnotation
    … …  
    79101        @Override
    80102        public String toString() {
    81                 return action + " " + identifier + " " + position;
     103                StringBuilder b = new StringBuilder();
     104                b.append(action).append(" ").append(identifier).append(" ").append(position);
     105                if (hints != null && !hints.isEmpty()) {
     106                        b.append(" ").append(getHints());
     107                }
     108                return b.toString();
    82109        }
    83110
    … …  
    86113                if (object instanceof ListChange) {
    87114                        ListChange r = (ListChange) object;
    88                         return Misc.equals(action, r.action) && Misc.equals(position, r.position) && Misc.equals(identifier, r.identifier);
     115                        return Misc.equals(action, r.action) && Misc.equals(position, r.position) && Misc.equals(identifier, r.identifier) && Misc.equals(hints, r.hints);
    89116                }
    90117                return false;

  • java/main/src/main/java/com/framsticks/core/LocalTree.java

    r101 r102  
    1515import com.framsticks.params.types.ProcedureParam;
    1616import com.framsticks.util.FramsticksException;
     17import com.framsticks.util.dispatching.Dispatcher;
     18import com.framsticks.util.dispatching.DispatcherSetable;
    1719import com.framsticks.util.dispatching.Dispatching;
    1820import com.framsticks.util.dispatching.Future;
    … …  
    3335        public LocalTree() {
    3436                super();
    35 
     37                bufferedDispatcher.setBuffer(false);
    3638        }
    3739
     40        @SuppressWarnings({ "rawtypes", "unchecked" })
    3841        @AutoAppendAnnotation
    3942        public void setRootObject(Object object) {
    … …  
    4952                        joinableRootObject = (Joinable) object;
    5053                }
     54                if (object instanceof DispatcherSetable) {
     55                        DispatcherSetable<?> setable = (DispatcherSetable<?>) object;
     56                        setable.setDispatcher((Dispatcher) this);
     57                }
    5158        }
    5259
    5360        public Object getRootObject() {
    54                 return getAssignedRoot().getObject();
     61                Object result = getAssignedRoot().getObject();
     62                if (result == null) {
     63                        throw new FramsticksException().msg("object tree is empty").arg("tree", this);
     64                }
     65                return result;
    5566        }
    5667
    5768        public <T> T getRootObject(Class<T> type) {
    5869                Object result = getRootObject();
    59                 if (result == null) {
    60                         throw new FramsticksException().msg("object tree is empty").arg("tree", this);
    61                 }
    6270                if (!type.isInstance(result)) {
    6371                        throw new FramsticksException().msg("object tree holds object of different kind").arg("object", result).arg("requested", type).arg("tree", this);
    … …  
    181189                }
    182190        }
     191
    183192}

  • java/main/src/main/java/com/framsticks/core/Tree.java

    r101 r102  
    1313import com.framsticks.params.types.ProcedureParam;
    1414import com.framsticks.util.dispatching.Dispatcher;
     15import com.framsticks.util.dispatching.DispatcherSetable;
    1516import com.framsticks.util.dispatching.ExceptionResultHandler;
    1617import com.framsticks.util.dispatching.Future;
    1718import com.framsticks.util.dispatching.Joinable;
    1819
    19 public interface Tree extends Dispatcher<Tree>, Joinable, ExceptionResultHandler {
     20public interface Tree extends Dispatcher<Tree>, DispatcherSetable<Tree>, Joinable, ExceptionResultHandler {
    2021
    2122        public @Nonnull Node getAssignedRoot();
    … …  
    5455        public ExceptionResultHandler getExceptionHandler();
    5556
    56         public void setDispatcher(Dispatcher<Tree> dispatcher);
     57        // public void setDispatcher(Dispatcher<Tree> dispatcher);
    5758
    58         public Dispatcher<Tree> getDispatcher();
     59        // public Dispatcher<Tree> getDispatcher();
    5960
    6061        public <A> void addListener(Path path, EventParam param, EventListener<A> listener, Class<A> argumentType, Future<Void> future);

  • java/main/src/main/java/com/framsticks/core/TreeOperations.java

    r101 r102  
    4444        public static final SideNoteKey<Boolean> FETCHED_MARK = SideNoteKey.make(Boolean.class);
    4545
    46         public static @Nonnull
    47         FramsClass processFetchedInfo(Tree tree, File file) {
     46        public static @Nonnull FramsClass processFetchedInfo(Tree tree, File file) {
    4847                assert tree.isActive();
    4948                FramsClass framsClass = Loaders.loadFramsClass(file.getContent());

  • java/main/src/main/java/com/framsticks/dumping/PrintWriterSink.java

    r84 r102  
    11package com.framsticks.dumping;
    22
    3 import com.framsticks.params.SinkInterface;
     3import com.framsticks.params.Sink;
    44
    55import java.io.PrintWriter;
    … …  
    88 * @author Piotr Sniegowski
    99 */
    10 public class PrintWriterSink implements SinkInterface {
     10public class PrintWriterSink implements Sink {
    1111
    1212    protected final PrintWriter stream;

  • java/main/src/main/java/com/framsticks/dumping/SaveStream.java

    r100 r102  
    22
    33import static com.framsticks.core.TreeOperations.*;
     4import static com.framsticks.params.AccessOperations.*;
    45import com.framsticks.core.Node;
    56import com.framsticks.core.Path;
    … …  
    89import com.framsticks.params.FramsClass;
    910import com.framsticks.params.ListAccess;
    10 import com.framsticks.params.SinkInterface;
     11import com.framsticks.params.Sink;
    1112import com.framsticks.parsers.Savers;
    1213import com.framsticks.core.Tree;
    … …  
    3031        private final static Logger log = LogManager.getLogger(SaveStream.class.getName());
    3132
    32         protected final SinkInterface sink;
     33        protected final Sink sink;
    3334        protected final Tree tree;
    3435        protected final Future<Void> future;
    … …  
    3839        private int dispatched = 0;
    3940
    40         public SaveStream(SinkInterface sink, Tree tree, Path root, Future<Void> future) {
     41        public SaveStream(Sink sink, Tree tree, Path root, Future<Void> future) {
    4142                assert Dispatching.isThreadSafe();
    4243                this.sink = sink;
    … …  
    8384                                sink.print("file").breakLine();
    8485                                //stream.print("#" + access.getSelected().getClass().getCanonicalName() + "\n");
    85                                 access.save(sink);
     86                                save(access, sink);
    8687                                sink.print("eof").breakLine();
    8788                                sink.print("ok").breakLine();

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

    r101 r102  
    22
    33import java.util.Map;
     4
     5import org.apache.logging.log4j.Level;
     6import org.apache.logging.log4j.Logger;
     7import org.apache.logging.log4j.LogManager;
    48
    59import com.framsticks.core.ListChange;
    610import com.framsticks.params.EventListener;
     11import com.framsticks.params.ParamFlags;
    712import com.framsticks.params.SimpleUniqueList;
    813import com.framsticks.params.annotations.AutoAppendAnnotation;
    914import com.framsticks.params.annotations.FramsClassAnnotation;
    1015import com.framsticks.params.annotations.ParamAnnotation;
     16import com.framsticks.params.types.ProcedureParam;
     17import com.framsticks.remote.RemoteTree;
     18import com.framsticks.util.FramsticksException;
     19import com.framsticks.util.dispatching.AbstractJoinable;
     20import com.framsticks.util.dispatching.BufferedDispatcher;
     21import com.framsticks.util.dispatching.Dispatcher;
     22import com.framsticks.util.dispatching.DispatcherSetable;
     23import com.framsticks.util.dispatching.Dispatching;
     24import com.framsticks.util.dispatching.ExceptionResultHandler;
     25import com.framsticks.util.dispatching.Joinable;
    1126import com.framsticks.util.dispatching.JoinableCollection;
     27import com.framsticks.util.dispatching.JoinableParent;
     28import com.framsticks.util.dispatching.JoinableState;
     29import com.framsticks.util.dispatching.RunAt;
    1230
    1331@FramsClassAnnotation
    14 public class Experiment extends JoinableCollection<Simulator> {
     32public class Experiment extends AbstractJoinable implements Dispatcher<Experiment>, DispatcherSetable<Experiment>, JoinableParent, ExceptionResultHandler {
     33        private static final Logger log = LogManager.getLogger(Experiment.class);
     34
     35        protected final JoinableCollection<Simulator> simulatorAsJoinables = new JoinableCollection<Simulator>().setObservableName("simulators");
     36
     37        protected final JoinableCollection<RemoteTree> simulatorCandidates = new JoinableCollection<RemoteTree>().setObservableName("candidates");
    1538
    1639        protected final SimpleUniqueList<Simulator> simulators = new SimpleUniqueList<>(Simulator.class, 's');
     40
     41        protected final SimpleUniqueList<Simulator> oldSimulators = new SimpleUniqueList<>(Simulator.class, 's');
     42
     43        protected final BufferedDispatcher<Experiment> bufferedDispatcher = new BufferedDispatcher<>(this);
     44
     45        protected String expdef;
     46
     47        /**
     48         *
     49         */
     50        public Experiment() {
     51                super();
     52                bufferedDispatcher.setBuffer(false);
     53
     54                Dispatching.dispatchLog(this, log, Level.DEBUG, "first task");
     55
     56
     57                simulators.addListener(new EventListener<ListChange>() {
     58                        @Override
     59                        public void action(ListChange argument) {
     60                                if (argument.getAction() == ListChange.Action.Add) {
     61                                        simulators.fireChildrenChange(argument, ListChange.Action.Modify, "ready");
     62                                }
     63                        }
     64                });
     65
     66        }
     67
     68        /**
     69         * @return the simulatorCandidates
     70         */
     71        public JoinableCollection<RemoteTree> getSimulatorCandidates() {
     72                return simulatorCandidates;
     73        }
    1774
    1875        @ParamAnnotation
    … …  
    2178        }
    2279
     80        @ParamAnnotation(id = "old_simulators")
     81        public Map<String, Simulator> getOldSimulators() {
     82                return oldSimulators.getView();
     83        }
     84
     85        /**
     86         * @return the dispatcher
     87         */
     88        @Override
     89        public Dispatcher<Experiment> getDispatcher() {
     90                return bufferedDispatcher;
     91        }
     92
     93        /**
     94         * @param dispatcher the dispatcher to set
     95         */
     96        @Override
     97        public void setDispatcher(Dispatcher<Experiment> dispatcher) {
     98                bufferedDispatcher.setTargetDispatcher(dispatcher);
     99        }
     100
     101        /**
     102         * @return the expdef
     103         */
     104        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
     105        public String getExpdef() {
     106                return expdef;
     107        }
     108
     109        /**
     110         * @param expdef the expdef to set
     111         */
     112        @ParamAnnotation
     113        public void setExpdef(String expdef) {
     114                this.expdef = expdef;
     115        }
     116
    23117        @ParamAnnotation(id = "simulators_changed")
    24118        public void addSimulatorsListener(EventListener<ListChange> listener) {
    … …  
    34128        public void addSimulator(Simulator simulator) {
    35129                simulators.add(simulator);
    36         }
     130                simulatorAsJoinables.add(simulator);
     131
     132
     133
     134
     135
     136        }
     137
     138        protected void removeSimulator(Simulator simulator) {
     139                simulatorAsJoinables.remove(simulator);
     140                simulators.remove(simulator);
     141                oldSimulators.add(simulator);
     142        }
     143
     144        @ParamAnnotation(id = "old_simulators_changed")
     145        public void addOldSimulatorsListener(EventListener<ListChange> listener) {
     146                oldSimulators.addListener(listener);
     147        }
     148
     149        @ParamAnnotation(id = "old_simulators_changed")
     150        public void removeOldSimulatorsListener(EventListener<ListChange> listener) {
     151                oldSimulators.removeListener(listener);
     152        }
     153
     154        @Override
     155        public String getName() {
     156                return "experiment";
     157        }
     158
     159        @Override
     160        public void childChangedState(Joinable joinable, JoinableState state) {
     161                proceedToState(state);
     162        }
     163
     164        @Override
     165        protected void joinableStart() {
     166                bufferedDispatcher.createThreadIfNeeded();
     167                Dispatching.use(bufferedDispatcher, this);
     168
     169                Dispatching.use(simulatorAsJoinables, this);
     170                Dispatching.use(simulatorCandidates, this);
     171        }
     172
     173        @Override
     174        protected void joinableInterrupt() {
     175
     176                Dispatching.drop(simulatorAsJoinables, this);
     177                Dispatching.drop(simulatorCandidates, this);
     178
     179                finishJoinable();
     180        }
     181
     182        @Override
     183        protected void joinableFinish() {
     184                log.debug("finishing experiment {}", this);
     185        }
     186
     187        @Override
     188        protected void joinableJoin() throws InterruptedException {
     189                Dispatching.drop(bufferedDispatcher, this);
     190
     191                Dispatching.join(simulatorAsJoinables);
     192                Dispatching.join(simulatorCandidates);
     193                Dispatching.join(bufferedDispatcher.getTargetDispatcher());
     194        }
     195
     196        @Override
     197        public void handle(FramsticksException exception) {
     198                log.error("caught exception: ", exception);
     199        }
     200
     201        @Override
     202        public boolean isActive() {
     203                return bufferedDispatcher.isActive();
     204        }
     205
     206        @Override
     207        public void dispatch(RunAt<? extends Experiment> runnable) {
     208                bufferedDispatcher.dispatch(runnable);
     209        }
     210
     211        @ParamAnnotation(paramType = ProcedureParam.class)
     212        public void connectToSimulator(String address) {
     213                SimulatorConnector connector = new SimulatorConnector();
     214                connector.setAddress(address);
     215                connector.attachTo(this);
     216        }
     217
    37218}

  • java/main/src/main/java/com/framsticks/experiment/Simulator.java

    r101 r102  
    11package com.framsticks.experiment;
    22
    3 import com.framsticks.params.ParamFlags;
     3import com.framsticks.communication.File;
     4import com.framsticks.communication.queries.NeedFile;
     5import com.framsticks.communication.queries.NeedFileAcceptor;
     6import com.framsticks.core.Path;
     7import com.framsticks.core.Tree;
     8import com.framsticks.core.ValueChange;
     9import com.framsticks.params.EventListener;
     10import com.framsticks.params.FramsClass;
    411import com.framsticks.params.UniqueObject;
    512import com.framsticks.params.annotations.FramsClassAnnotation;
    613import com.framsticks.params.annotations.ParamAnnotation;
     14import com.framsticks.params.types.EventParam;
    715import com.framsticks.params.types.ProcedureParam;
    816import com.framsticks.remote.RemoteTree;
     17import com.framsticks.util.FramsticksException;
    918import com.framsticks.util.dispatching.AbstractJoinable;
     19import com.framsticks.util.dispatching.Dispatcher;
    1020import com.framsticks.util.dispatching.Dispatching;
     21import com.framsticks.util.dispatching.ExceptionResultHandler;
     22import com.framsticks.util.dispatching.Future;
     23import com.framsticks.util.dispatching.FutureHandler;
    1124import com.framsticks.util.dispatching.Joinable;
    1225import com.framsticks.util.dispatching.JoinableParent;
    1326import com.framsticks.util.dispatching.JoinableState;
     27import com.framsticks.util.dispatching.RunAt;
     28import com.framsticks.util.dispatching.ThrowExceptionHandler;
     29import com.framsticks.util.lang.Holder;
     30import java.util.concurrent.atomic.AtomicInteger;
     31import org.apache.logging.log4j.LogManager;
     32import org.apache.logging.log4j.Logger;
     33import static com.framsticks.core.TreeOperations.*;
    1434
    1535@FramsClassAnnotation
    16 public class Simulator extends AbstractJoinable implements JoinableParent, UniqueObject {
     36public final class Simulator extends AbstractJoinable implements Dispatcher<Simulator>, JoinableParent, UniqueObject, ExceptionResultHandler {
     37
     38        private static final Logger log = LogManager.getLogger(Simulator.class);
     39
    1740        protected String uid;
    1841
    19         protected final RemoteTree remoteTree = new RemoteTree();
     42        protected final RemoteTree remoteTree;
     43        protected final Path simulatorPath;
     44        protected final FramsClass simulatorClass;
     45        protected final Experiment experiment;
     46        protected final EventListener<ValueChange> runningListener;
    2047
    2148        /**
    2249         *
    2350         */
    24         public Simulator() {
     51        public Simulator(Experiment experiment, RemoteTree remoteTree, Path simulatorPath) {
    2552                super();
    26         }
    27 
    28         @ParamAnnotation
    29         public void setAddress(String address) {
    30                 remoteTree.setAddress(address);
    31         }
    32 
    33         @ParamAnnotation(flags = ParamFlags.USERREADONLY)
     53                this.remoteTree = remoteTree;
     54                this.simulatorPath = simulatorPath.assureResolved();
     55                this.experiment = experiment;
     56                this.simulatorClass = getFramsClass(simulatorPath);
     57
     58                assert remoteTree.isActive();
     59                assert experiment.isActive();
     60
     61                log.debug("simulator ready {}", this);
     62
     63                runningListener = new EventListener<ValueChange>() {
     64                        @Override
     65                        public void action(ValueChange argument) {
     66                                log.debug("running state of {} changed: {}", this, argument);
     67                        }
     68                };
     69
     70                addListener(simulatorPath, simulatorClass.getParamEntry("running_changed", EventParam.class), runningListener, ValueChange.class, new FutureHandler<Void>(this) {
     71                        @Override
     72                        protected void result(Void result) {
     73                                log.debug("running listener for {} registered", this);
     74                        }
     75                });
     76        }
     77
     78        @ParamAnnotation
    3479        public String getAddress() {
    3580                return remoteTree.getAddress();
    … …  
    3984        @ParamAnnotation
    4085        public String getName() {
    41 
    42                 return "simulator " + uid + " " + getAddress();
     86                return getAddress();
    4387        }
    4488
    … …  
    62106        }
    63107
     108        /**
     109         * @return the simulatorPath
     110         */
     111        public Path getSimulatorPath() {
     112                return simulatorPath;
     113        }
     114
     115        /**
     116         * @return the simulatorClass
     117         */
     118        public FramsClass getSimulatorClass() {
     119                return simulatorClass;
     120        }
     121
    64122        @Override
    65123        protected void joinableStart() {
    66124                Dispatching.use(remoteTree, this);
    67 
    68125        }
    69126
    … …  
    96153        }
    97154
     155        @ParamAnnotation(paramType = ProcedureParam.class)
     156        public void abort() {
     157                assert isActive();
     158                log.debug("explicitly aborting {}", this);
     159                experiment.removeSimulator(this);
     160                interruptJoinable();
     161        }
     162
    98163        @Override
    99164        public void childChangedState(Joinable joinable, JoinableState state) {
    … …  
    101166        }
    102167
     168        @Override
     169        public void handle(FramsticksException exception) {
     170                experiment.handle(new FramsticksException().msg("exception caught in simulator").arg("simulator", this).cause(exception));
     171        }
     172
     173        @Override
     174        public boolean isActive() {
     175                return experiment.isActive();
     176        }
     177
     178        @SuppressWarnings({ "rawtypes", "unchecked" })
     179        @Override
     180        public void dispatch(RunAt<? extends Simulator> runnable) {
     181                experiment.dispatch((RunAt) runnable);
     182        }
     183
     184        protected final AtomicInteger netloadIdCounter = new AtomicInteger();
     185
     186        public void uploadNet(final File file, final Future<Object> future) {
     187                final String netloadId = "NetLoadSaveLogic" + netloadIdCounter.getAndIncrement();
     188
     189                log.debug("uploading file {} to {} identified by {}", file, simulatorPath, netloadId);
     190
     191                final Holder<NeedFileAcceptor> acceptor = new Holder<>();
     192                final Tree tree = simulatorPath.getTree();
     193
     194                acceptor.set(new NeedFileAcceptor() {
     195
     196                        @Override
     197                        public boolean acceptNeed(NeedFile needFile) {
     198                                if (!needFile.getDescription().equals(netloadId)) {
     199                                        return false;
     200                                }
     201                                log.debug("accepting netload {}", netloadId);
     202                                needFile.getFuture().pass(file);
     203                                tree.dispatch(new RunAt<Tree>(ThrowExceptionHandler.getInstance()) {
     204
     205                                        @Override
     206                                        protected void runAt() {
     207                                                tree.removeNeedFileAcceptor(acceptor.get());
     208                                        }
     209                                });
     210                                return true;
     211                        }
     212
     213                });
     214
     215                simulatorPath.getTree().addNeedFileAcceptor(Integer.MIN_VALUE, acceptor.get());
     216
     217                call(simulatorPath, getFramsClass(simulatorPath).getParamEntry("netload_id", ProcedureParam.class), new Object[] { netloadId }, new FutureHandler<Object>(future) {
     218
     219                        @Override
     220                        protected void result(Object result) {
     221                                log.debug("upload of {} done", file);
     222                                future.pass(result);
     223                        }
     224                });
     225
     226        }
    103227}

  • java/main/src/main/java/com/framsticks/gui/Browser.java

    r101 r102  
    66import com.framsticks.core.*;
    77import com.framsticks.gui.console.Console;
     8import com.framsticks.gui.console.DirectConsole;
     9import com.framsticks.gui.console.ManagedConsole;
    810import com.framsticks.gui.console.TrackConsole;
    911import com.framsticks.gui.table.ColumnsConfig;
    … …  
    5658        private static final Logger log = LogManager.getLogger(Browser.class);
    5759
    58         protected final JoinableCollection<Frame> frames = new JoinableCollection<Frame>().setObservableName("frames");
    59         protected final JoinableCollection<Tree> trees = new JoinableCollection<Tree>().setObservableName("trees");
    60         protected final JoinableCollection<Console> consoles = new JoinableCollection<Console>().setObservableName("consoles");
     60        protected final JoinableCollection<Frame> frames = new JoinableCollection<Frame>(JoinableCollection.FinishPolicy.OnAll).setObservableName("frames");
     61        protected final JoinableCollection<Tree> trees = new JoinableCollection<Tree>(JoinableCollection.FinishPolicy.Never).setObservableName("trees");
     62        protected final JoinableCollection<Console> consoles = new JoinableCollection<Console>(JoinableCollection.FinishPolicy.Never).setObservableName("consoles");
    6163
    6264        protected final List<PopupMenuEntryProvider> popupMenuEntryProviders = new LinkedList<>();
    … …  
    123125                                        }
    124126                                });
    125                         }
    126                 });
    127                 // addNodeActionToTreePopupMenu("", new NodeAction() )
     127                                menu.add(new AbstractAction("Open managed console") {
     128                                        @Override
     129                                        public void actionPerformed(ActionEvent e) {
     130                                                consoles.add(new ManagedConsole().setTree(remoteTree));
     131                                        }
     132                                });
     133                                menu.add(new AbstractAction("Open direct console") {
     134                                        @Override
     135                                        public void actionPerformed(ActionEvent e) {
     136                                                consoles.add(new DirectConsole().setAddress(remoteTree.getAddress()));
     137                                        }
     138                                });
     139                        }
     140                });
    128141
    129142        }

  • java/main/src/main/java/com/framsticks/gui/Frame.java

    r101 r102  
    9595
    9696        protected final Map<Tree, TreeAtFrame> treeAtFrames = new IdentityHashMap<>();
    97         protected JoinableCollection<Tree> trees = new JoinableCollection<>();
     97        protected JoinableCollection<Tree> trees = new JoinableCollection<Tree>().setObservableName("frame trees");
    9898
    9999        public Frame(Browser browser) {

  • java/main/src/main/java/com/framsticks/gui/MainFrame.java

    r101 r102  
    5151                                @Override
    5252                                public void actionPerformed(ActionEvent actionEvent) {
    53                                         browser.autoResolvePath("/simulator/genepools/groups/0", null);
     53                                        // browser.autoResolvePath("/simulator/genepools/groups/0", null);
    5454                                        // browser.autoResolvePath("/simulator/populations/groups/0", null;
    5555                                        // browser.autoResolvePath("/simulator/genepools/groups/0/genotypes", null);

  • java/main/src/main/java/com/framsticks/gui/console/DirectConsole.java

    r97 r102  
    44import java.util.List;
    55
     6import com.framsticks.communication.Address;
    67import com.framsticks.communication.ClientSideRawConnection;
    78import com.framsticks.communication.ConnectionListener;
    8 import com.framsticks.params.annotations.AutoAppendAnnotation;
    99import com.framsticks.params.annotations.FramsClassAnnotation;
     10import com.framsticks.params.annotations.ParamAnnotation;
    1011import com.framsticks.util.dispatching.ThrowExceptionHandler;
    1112
    … …  
    1920        }
    2021
    21         @AutoAppendAnnotation
    22         public DirectConsole setConnection(ClientSideRawConnection connection) {
    23                 this.connection = connection;
     22
     23        @ParamAnnotation
     24        public DirectConsole setAddress(String address) {
     25                return setAddress(new Address(address));
     26        }
     27
     28        public DirectConsole setAddress(Address address) {
     29                this.connection = new ClientSideRawConnection();
     30                this.connection.setAddress(address);
    2431                return this;
    2532        }

  • java/main/src/main/java/com/framsticks/gui/console/InteractiveConsole.java

    r98 r102  
    5454        @Override
    5555        protected void initializeGui() {
    56                 // TODO Auto-generated method stub
    5756                super.initializeGui();
    5857

  • java/main/src/main/java/com/framsticks/gui/console/ManagedConsole.java

    r99 r102  
    4646                return (ClientSideManagedConnection) connection;
    4747        }
     48
    4849
    4950        protected void sendImplementation(String line) {
    … …  
    159160
    160161        @AutoAppendAnnotation
    161         public void setTree(RemoteTree tree) {
     162        public ManagedConsole setTree(RemoteTree tree) {
    162163                this.tree = tree;
    163164                connection = tree.getConnection();
     165                return this;
    164166        }
    165167

  • java/main/src/main/java/com/framsticks/gui/controls/ProcedureControl.java

    r101 r102  
    66import com.framsticks.params.Param;
    77import com.framsticks.params.types.ProcedureParam;
    8 import com.framsticks.util.dispatching.ExceptionResultHandler;
    98import com.framsticks.util.dispatching.FutureHandler;
    10 import com.framsticks.util.dispatching.ThrowExceptionHandler;
    119
    1210import javax.swing.*;
    … …  
    6058                                        log.debug("argument {}: {}", arg, value);
    6159                                }
    62                                 //TODO FEH: make it show dialog
    63                                 callProcedure(path, getParam(), arguments.toArray());
     60                                callProcedure(path, getParam(), arguments.toArray(), getFrame());
    6461
    6562                        }
    … …  
    7269
    7370
    74         public static void callProcedure(final Path path, final ProcedureParam param, Object[] arguments) {
    75                 final ExceptionResultHandler handler = ThrowExceptionHandler.getInstance();
     71        public static void callProcedure(final Path path, final ProcedureParam param, Object[] arguments, Frame frame) {
    7672
    7773                assert path.getTree().isActive();
    7874
    79                 path.getTree().call(path, param, arguments, new FutureHandler<Object>(handler) {
     75                path.getTree().call(path, param, arguments, new FutureHandler<Object>(frame) {
    8076
    8177                        @Override
    … …  
    116112        @Override
    117113        protected void refreshTable() {
    118                 // TODO Auto-generated method stub
    119114
    120115        }
    … …  
    122117        @Override
    123118        protected void clearTable() {
    124                 // TODO Auto-generated method stub
    125119
    126120        }

  • java/main/src/main/java/com/framsticks/gui/controls/SliderControl.java

    r101 r102  
    3939        private final int div = 10;
    4040        private JComponent changing = null;
     41        public final static float LINE_HEIGHT_FACTOR = 1.2f;
    4142
    4243        private Class<? extends Number> valueType;
    … …  
    4647                text = new JTextField();
    4748
    48                 //TODO: that factor should be done as a constant
    49                 this.setMaximumSize(new Dimension(Integer.MAX_VALUE, (int)(LINE_HEIGHT * 1.2)));
     49                this.setMaximumSize(new Dimension(Integer.MAX_VALUE, (int)(LINE_HEIGHT * LINE_HEIGHT_FACTOR)));
    5050
    5151                // ComponentUI ui = UIManager.getUI(slider);

  • java/main/src/main/java/com/framsticks/gui/table/ProcedureColumn.java

    r100 r102  
    3838                        return 0;
    3939                }
    40                 ProcedureControl.callProcedure(path, getParam(), new Object[] {});
     40                ProcedureControl.callProcedure(path, getParam(), new Object[] {}, tableModel.getFrame());
    4141                return 0;
    4242        }

  • java/main/src/main/java/com/framsticks/gui/table/TableModel.java

    r101 r102  
    1313import org.apache.logging.log4j.LogManager;
    1414
     15import com.framsticks.gui.Frame;
    1516import com.framsticks.params.Access;
    1617import com.framsticks.params.ListAccess;
    … …  
    166167        }
    167168
     169        public Frame getFrame() {
     170                return listPanel.getFrame();
     171        }
     172
    168173}

  • java/main/src/main/java/com/framsticks/gui/tree/EmptyNode.java

    r100 r102  
    4242        @Override
    4343        public void render(TreeCellRenderer renderer) {
    44                 // TODO Auto-generated method stub
    4544
    4645                renderer.setToolTipText("?");

  • java/main/src/main/java/com/framsticks/gui/tree/TreeCellRenderer.java

    r100 r102  
    8989
    9090                }
    91 
    92 
    93                 return ImageProvider.SERVER;
     91                return ImageProvider.FOLDER_OPEN;
    9492        }
    9593

  • java/main/src/main/java/com/framsticks/hosting/ClientAtServer.java

    r100 r102  
    3030
    3131import static com.framsticks.core.TreeOperations.*;
     32import static com.framsticks.params.AccessOperations.*;
    3233
    3334import java.net.Socket;
    … …  
    6162                cliObject = new Cli(this);
    6263                rootTree = new LocalTree();
     64                rootTree.setName(server.getName() + " root tree");
    6365                // rootTree.setDispatcher(new AtOnceDispatcher<Tree>());
    6466                rootTree.setDispatcher(server.getHosted().getDispatcher());
    … …  
    114116        public static File printToFile(String path, Access access) {
    115117                ListSink sink = new ListSink();
    116                 access.save(sink);
     118                save(access, sink);
    117119                return new File(path, new ListSource(sink.getOut()));
    118120        }
    … …  
    143145                                if (request instanceof SetRequest) {
    144146                                        SetRequest setRequest = (SetRequest) request;
    145                                         //TODO Primitive Param?
    146147                                        tree.set(path, access.getFramsClass().getParamEntry(setRequest.getField(), PrimitiveParam.class), setRequest.getValue(), new FutureHandler<Integer>(responseCallback) {
    147148                                                @Override
    … …  
    198199        protected void joinableStart() {
    199200                Dispatching.use(connection, this);
     201                Dispatching.use(rootTree, this);
    200202        }
    201203
    202204        @Override
    203205        protected void joinableInterrupt() {
     206                Dispatching.drop(rootTree, this);
    204207                Dispatching.drop(connection, this);
    205208        }
    … …  
    207210        @Override
    208211        protected void joinableFinish() {
     212
    209213        }
    210214
    … …  
    212216        protected void joinableJoin() throws InterruptedException {
    213217                Dispatching.join(connection);
     218                Dispatching.join(rootTree);
    214219        }
    215220

  • java/main/src/main/java/com/framsticks/hosting/Server.java

    r101 r102  
    3737        protected ServerSocket acceptSocket;
    3838        protected Tree hosted;
    39         protected final JoinableCollection<ClientAtServer> clients = new JoinableCollection<ClientAtServer>();
     39        protected final JoinableCollection<ClientAtServer> clients = new JoinableCollection<ClientAtServer>(JoinableCollection.FinishPolicy.Never);
    4040
    4141        public static class Accept {
    … …  
    6868        }
    6969
    70         @Override
    71         protected void joinableInterrupt() {
    72                 Dispatching.drop(acceptThread, this);
    73                 Dispatching.drop(hosted, this);
    74                 Dispatching.drop(clients, this);
    75                 try {
    76                         acceptSocket.close();
    77                 } catch (IOException e) {
    78                         log.debug("exception caught during socket closing: ", e);
    79                 }
    80                 finishJoinable();
    81         }
    8270
    8371        /**
    … …  
    10189        public void childChangedState(Joinable joinable, JoinableState state) {
    10290                proceedToState(state);
    103         }
    104 
    105         @Override
    106         protected void joinableStart() {
    107                 Dispatching.use(acceptThread, this);
    108                 Dispatching.use(hosted, this);
    109                 Dispatching.use(clients, this);
    110                 try {
    111                         acceptSocket = new ServerSocket();
    112                 } catch (IOException e) {
    113                         throw new FramsticksException().msg("failed to create server socket").cause(e);
    114                 }
    115                 tryBind(0);
    11691        }
    11792
    … …  
    175150        }
    176151
     152
     153        @Override
     154        protected void joinableStart() {
     155                Dispatching.use(acceptThread, this);
     156                Dispatching.use(hosted, this);
     157                Dispatching.use(clients, this);
     158                try {
     159                        acceptSocket = new ServerSocket();
     160                        acceptSocket.setReuseAddress(true);
     161                } catch (IOException e) {
     162                        throw new FramsticksException().msg("failed to create server socket").cause(e);
     163                }
     164                tryBind(0);
     165        }
     166
     167        @Override
     168        protected void joinableInterrupt() {
     169                Dispatching.drop(acceptThread, this);
     170                Dispatching.drop(hosted, this);
     171                Dispatching.drop(clients, this);
     172
     173                try {
     174                        acceptSocket.close();
     175                } catch (IOException e) {
     176                        log.debug("exception caught during socket closing: ", e);
     177                }
     178
     179                finishJoinable();
     180        }
     181
    177182        @Override
    178183        protected void joinableFinish() {

  • java/main/src/main/java/com/framsticks/model/Model.java

    r100 r102  
    3737        public final List<NeuroConnection> neuroConnections = new ArrayList<NeuroConnection>();
    3838
    39         //TODO: why those methods returns and accepts doubles?
     39        /** Those methods accept doubles to keep consistency with Framsticks server.*/
    4040        @ParamAnnotation
    4141        public double getNumparts() { return (double)parts.size(); }

  • java/main/src/main/java/com/framsticks/params/Access.java

    r101 r102  
    4444        void regRemove(EventParam param, EventListener<?> listener);
    4545
    46         void save(SinkInterface sink);
    47 
    4846        /**
    4947         * Removes all the properties values.
    … …  
    7169        ParamBuilder buildParam(ParamBuilder builder);
    7270
    73 
    7471}

  • java/main/src/main/java/com/framsticks/params/AccessOperations.java

    r101 r102  
    1010
    1111import static com.framsticks.params.SetStateFlags.*;
     12import static com.framsticks.util.lang.Containers.filterInstanceof;
    1213
    1314public final class AccessOperations {
    … …  
    7475        }
    7576
     77        public static void save(Access access, Sink sink) {
     78                if (access instanceof ObjectAccess) {
     79                        ObjectAccess objectAccess = (ObjectAccess) access;
     80                        FramsClass framsClass = access.getFramsClass();
     81                        assert framsClass != null;
     82                        sink.print(framsClass.getId()).print(":").breakLine();
     83                        for (PrimitiveParam<?> p : filterInstanceof(framsClass.getParamEntries(), PrimitiveParam.class)) {
     84                                Object value = objectAccess.get(p, Object.class);
     85                                if ((value == null) || value.equals(p.getDef(Object.class))) {
     86                                        continue;
     87                                }
     88                                sink.print(p.getId()).print(":");
     89                                p.save(sink, value);
     90                                sink.breakLine();
     91                        }
     92                        sink.breakLine();
     93                        return;
     94
     95                }
     96                if (access instanceof ListAccess) {
     97                        ListAccess listAccess = (ListAccess) access;
     98                        for (CompositeParam p : filterInstanceof(listAccess.getParams(), CompositeParam.class)) {
     99                                Object child = listAccess.get(p, Object.class);
     100                                //this is probably an assertion
     101                                assert child != null;
     102                                save(listAccess.getElementAccess().select(child), sink);
     103                        }
     104                        return;
     105                }
     106                throw new FramsticksException().msg("unknown access category").arg("access", access);
     107        }
     108
    76109        public static void load(Access access, Source source) {
     110                if (!(access instanceof ObjectAccess)) {
     111                        throw new FramsticksException().msg("access is not an object access").arg("access", access);
     112                }
    77113                Entry entry;
    78114                while ((entry = readEntry(source)) != null) {

  • java/main/src/main/java/com/framsticks/params/ListAccess.java

    r101 r102  
    33
    44
    5 import static com.framsticks.util.lang.Containers.filterInstanceof;
    65
    76import com.framsticks.params.types.EventParam;
    … …  
    3029
    3130
    32         @Override
    33         public void save(SinkInterface sink) {
    34                 for (CompositeParam p : filterInstanceof(getParams(), CompositeParam.class)) {
    35                         Object child = get(p, Object.class);
    36                         //this is probably an assertion
    37                         assert child != null;
    38                         elementAccess.select(child);
    39                         elementAccess.save(sink);
    40                 }
    41         }
    42 
    4331        public Access getElementAccess() {
    4432                return elementAccess;
    … …  
    5745        }
    5846
    59         //TODO it could actually be used also
    6047        @Override
    6148        public void tryAutoAppend(Object object) {
    62                 throw new InvalidOperationException();
     49                throw new InvalidOperationException().msg("It could actually be used also, the Access.select could be used to check whether type is correct");
    6350        }
    6451

  • java/main/src/main/java/com/framsticks/params/ListSink.java

    r84 r102  
    77 * @author Piotr Sniegowski
    88 */
    9 public class ListSink implements SinkInterface {
     9public class ListSink implements Sink {
    1010        protected final List<String> out;
    1111        protected StringBuilder lineBuilder = new StringBuilder();
    … …  
    2525
    2626        @Override
    27         public SinkInterface print(String str) {
     27        public Sink print(String str) {
    2828                lineBuilder.append(str);
    2929                return this;
    … …  
    3131
    3232        @Override
    33         public SinkInterface print(Object obj) {
     33        public Sink print(Object obj) {
    3434                lineBuilder.append(obj);
    3535                return this;

  • java/main/src/main/java/com/framsticks/params/Param.java

    r101 r102  
    3535        protected final int flags;
    3636
    37         //TODO
    3837        /** The variable determining whether the parameter is an extra parameter. */
    3938        protected final int extra;

  • java/main/src/main/java/com/framsticks/params/ParamCandidate.java

    r101 r102  
    2525import com.framsticks.params.annotations.ParamAnnotation;
    2626import com.framsticks.params.types.ProcedureParam;
     27// import com.framsticks.util.FramsticksException;
    2728
    2829public class ParamCandidate {
    … …  
    477478                        Type rawType = p.getRawType();
    478479                        Type containedType = null;
    479                         //TODO make implementation here
    480480                        boolean map = false;
    481481                        StringBuilder b = new StringBuilder();
    … …  
    490490                                containedType = p.getActualTypeArguments()[0];
    491491                                b.append("e");
     492                        } else {
     493                                return induceParamType(builder, rawType);
     494                                // throw new FramsticksException().msg("unknown raw type").arg("raw type", rawType);
    492495                        }
    493496                        if (!(containedType instanceof Class)) {
    … …  
    503506                        dependantClasses.add(containedClass);
    504507                        b.append(FramsClassBuilder.getName(fca, containedClass));
    505                         //TODO parameterize this
    506508                        if (map) {
    507509                                b.append(" uid");
    … …  
    516518                        Class<?> cl = (Class<?>) type;
    517519
    518                         // TODO: future support for enum
     520                        // this is draft implementation of future support for enum
    519521                        // if (cl.isEnum()) {
    520522                        //      Class<? extends Enum<?>> enumType = (Class<? extends Enum<?>>) cl;

  • java/main/src/main/java/com/framsticks/params/PrimitiveParam.java

    r90 r102  
    3333        }
    3434
    35         public void save(SinkInterface sink, Object value) {
     35        public void save(Sink sink, Object value) {
    3636                sink.print(value);
    3737        }

  • java/main/src/main/java/com/framsticks/params/SimpleAbstractAccess.java

    r101 r102  
    22
    33
    4 import static com.framsticks.util.lang.Containers.filterInstanceof;
    54
    65
    … …  
    103102        }
    104103
    105         @Override
    106         public void save(SinkInterface sink) {
    107                 assert framsClass != null;
    108                 sink.print(framsClass.getId()).print(":").breakLine();
    109                 for (PrimitiveParam<?> p : filterInstanceof(framsClass.getParamEntries(), PrimitiveParam.class)) {
    110                         Object value = get(p, Object.class);
    111                         if ((value == null) || value.equals(p.getDef(Object.class))) {
    112                                 continue;
    113                         }
    114                         sink.print(p.getId()).print(":");
    115                         p.save(sink, value);
    116                         sink.breakLine();
    117                 }
    118                 sink.breakLine();
    119         }
    120104
    121105        protected abstract <T> void internalSet(ValueParam param, T value);

  • java/main/src/main/java/com/framsticks/params/SimpleUniqueList.java

    r101 r102  
    4646        }
    4747
    48         public void fireChildrenChange(T child, ListChange.Action action) {
    49                 ListChange change = new ListChange(action, UniqueListAccess.getNumberInMap(children, child), child.getUid());
     48        public void fireChildrenChange(ListChange original, ListChange.Action action, Object... hints) {
     49                listeners.actionForAll(new ListChange(action, original.getPosition(), original.getIdentifier(), hints));
     50
     51        }
     52
     53        public void fireChildrenChange(T child, ListChange.Action action, Object... hints) {
     54                ListChange change = new ListChange(action, UniqueListAccess.getNumberInMap(children, child), child.getUid(), hints);
    5055                listeners.actionForAll(change);
    5156        }

  • java/main/src/main/java/com/framsticks/params/types/BooleanParam.java

    r88 r102  
    77import com.framsticks.params.PrimitiveParam;
    88import com.framsticks.params.ReassignResult;
    9 import com.framsticks.params.SinkInterface;
     9import com.framsticks.params.Sink;
    1010import com.framsticks.util.lang.Numbers;
    1111
    … …  
    5858
    5959        @Override
    60         public void save(SinkInterface sink, Object value) {
     60        public void save(Sink sink, Object value) {
    6161                assert value instanceof Boolean;
    6262                sink.print(((Boolean)value) ? "1" : "0");

  • java/main/src/main/java/com/framsticks/params/types/StringParam.java

    r87 r102  
    55import com.framsticks.params.PrimitiveParam;
    66import com.framsticks.params.ReassignResult;
    7 import com.framsticks.params.SinkInterface;
     7import com.framsticks.params.Sink;
    88
    99import javax.annotation.concurrent.Immutable;
    … …  
    4949
    5050        @Override
    51         public void save(SinkInterface sink, Object value) {
     51        public void save(Sink sink, Object value) {
    5252                assert value instanceof String;
    5353                String s = (String)value;

  • java/main/src/main/java/com/framsticks/parsers/F0Writer.java

    r100 r102  
    1515
    1616        protected final Schema schema;
    17         protected final SinkInterface sink;
     17        protected final Sink sink;
    1818        protected final Model model;
    1919        protected boolean omitDefaults = true;
    2020
    21         public F0Writer(Schema schema, Model model, SinkInterface sink) {
     21        public F0Writer(Schema schema, Model model, Sink sink) {
    2222                this.schema = schema;
    2323                this.model = model;
    … …  
    3232        protected void write(Access access) {
    3333                if (access instanceof ListAccess) {
    34                         // TODO
    3534                        for (ValueParam p : Containers.filterInstanceof(access.getParams(), ValueParam.class)) {
    3635                                write(schema.getRegistry().prepareAccess((CompositeParam) p).select(access.get(p, Object.class)));

  • java/main/src/main/java/com/framsticks/parsers/MultiParamLoader.java

    r101 r102  
    2323        }
    2424
    25         /** TODO does it support multilines? */
    2625        /**
    2726         * Specifies the condition to break execution.

  • java/main/src/main/java/com/framsticks/parsers/Savers.java

    r100 r102  
    11package com.framsticks.parsers;
    22
    3 import com.framsticks.params.*;
    4 import com.framsticks.params.SinkInterface;
     3import com.framsticks.params.Access;
     4import com.framsticks.params.FramsClass;
     5import com.framsticks.params.Param;
     6import com.framsticks.params.ReflectionAccess;
     7import com.framsticks.params.Sink;
     8import static com.framsticks.params.AccessOperations.*;
    59
    610/**
    … …  
    812 */
    913public class Savers {
    10         public static <S extends SinkInterface> S saveFramsClass(S sink, FramsClass framsClass) {
     14        public static <S extends Sink> S saveFramsClass(S sink, FramsClass framsClass) {
    1115
    1216                Access framsClassAccess = new ReflectionAccess(FramsClass.class);
    1317                Access paramAccess = new ReflectionAccess(Param.class);
    1418                framsClassAccess.select(framsClass);
    15                 framsClassAccess.save(sink);
     19
     20                save(framsClassAccess, sink);
    1621                for (Param p : framsClass.getParamEntries()) {
    17                         paramAccess.select(p);
    18                         paramAccess.save(sink);
     22                        save(paramAccess.select(p), sink);
    1923                }
    2024                return sink;

  • java/main/src/main/java/com/framsticks/parsers/XmlLoader.java

    r101 r102  
    2323import com.framsticks.params.PrimitiveParam;
    2424import com.framsticks.params.Registry;
     25import com.framsticks.util.AutoAttacher;
    2526import com.framsticks.util.AutoBuilder;
    2627import com.framsticks.util.FramsticksException;
    … …  
    137138
    138139                        for (Object child : childrenObjects) {
    139                                 access.tryAutoAppend(child);
     140                                if (child instanceof AutoAttacher) {
     141                                        ((AutoAttacher) child).attachTo(access.getSelected());
     142                                } else {
     143                                        access.tryAutoAppend(child);
     144                                }
    140145                        }
    141146                }

  • java/main/src/main/java/com/framsticks/remote/RemoteTree.java

    r101 r102  
    5656        }
    5757
     58        public void setAddress(Address address) {
     59                this.connection = Connection.to(new ClientSideManagedConnection(), address);
     60                this.connection.setExceptionHandler(this);
     61                this.connection.setNeedFileAcceptor(this);
     62        }
     63
    5864        @ParamAnnotation
    5965        public void setAddress(String address) {
    60                 this.connection = Connection.to(new ClientSideManagedConnection(), new Address(address));
    61                 this.connection.setExceptionHandler(this);
    62                 this.connection.setNeedFileAcceptor(this);
     66                setAddress(new Address(address));
    6367        }
    6468
    … …  
    7276        }
    7377
     78
    7479        @Override
    7580        public String toString() {
    76                 assert Dispatching.isThreadSafe();
    77                 return "remote tree " + getName() + "(" + getAddress() + ")";
     81                return super.toString() + "[" + getAddress() + "]";
    7882        }
    7983
    … …  
    102106        //      assert param != null;
    103107        //      // assert path.isResolved();
    104         //      //TODO only do that if needed
    105108        //      connection.send(new GetRequest().field(param.getId()).path(path.getTextual()), this, new ClientSideResponseFuture(pathRemoveHandler(path, future)) {
    106109        //              @Override
    … …  
    116119
    117120
     121        /** Fetch information.
     122         *
     123         * This method does not check whether the info is already in the cache, it will always issue a request or join
     124         * with other already issued but returned info request. Too issue request only when needed, use TreeOperations.findInfo()
     125         *
     126         * */
    118127        @Override
    119128        public void info(final Path path, final Future<FramsClass> future) {
    … …  
    153162                });
    154163
    155                 //TODO: if the info is in the cache, then don't communicate
    156164                connection.send(new InfoRequest().path(path.getTextual()), AtOnceDispatcher.getInstance(), new ClientSideResponseFuture(compositeFuture) {
    157165                        @Override
    … …  
    203211
    204212                log.trace("storing value {} for {}", param, path);
    205                 //TODO break in passing exception handler is here
     213
    206214                connection.send(new SetRequest().value(value.toString()).field(param.getId()).path(path.getTextual()), this, new ClientSideResponseFuture(future) {
    207215                        @Override
    … …  
    224232                                        @Override
    225233                                        protected void processOk(Response response) {
    226                                                 FramsClass framsClass = processFetchedInfo(RemoteTree.this, response.getFiles().get(0));
     234                                                assert bufferedDispatcher.getTargetDispatcher().isActive();
     235                                                FramsClass framsClass = Loaders.loadFramsClass(response.getFiles().get(0).getContent());
     236                                                putInfoIntoCache(framsClass);
     237
    227238                                                assignRootParam(Param.build().name("Tree").id(RemoteTree.this.getName()).type("o " + framsClass.getId()).finish(CompositeParam.class));
    228239                                                bufferedDispatcher.setBuffer(false);

  • java/main/src/main/java/com/framsticks/running/ExternalProcess.java

    r101 r102  
    2222import com.framsticks.params.annotations.ParamAnnotation;
    2323import com.framsticks.util.FramsticksException;
    24 import com.framsticks.util.Misc;
    2524import com.framsticks.util.dispatching.AbstractJoinable;
    2625import com.framsticks.util.dispatching.Dispatching;
    … …  
    110109                                throw new FramsticksException().msg("failed to wait for process").cause(e);
    111110                        }
    112                         log.debug("process ended {}", this);
     111                        log.info("process ended {}", this);
    113112                        // process = null;
    114113                } catch (FramsticksException e) {
    … …  
    131130        @Override
    132131        protected void joinableStart() {
    133                 log.debug("running process with arguments: {}", arguments);
     132                log.debug("running process {}", this);
    134133                builder.command(arguments);
    135134                try {
    … …  
    160159        @Override
    161160        public String toString() {
    162                 return getName() + "[" + Misc.returnNotNull(getCommand(), "?") + "]";
     161                return getName() + arguments;
    163162        }
    164163

  • java/main/src/main/java/com/framsticks/running/FramsServer.java

    r90 r102  
    11package com.framsticks.running;
    22
     3
     4
     5import com.framsticks.params.ParamFlags;
    36import com.framsticks.params.annotations.FramsClassAnnotation;
    47import com.framsticks.params.annotations.ParamAnnotation;
     8import com.framsticks.util.lang.Strings;
    59
    610@FramsClassAnnotation
    … …  
    913        protected Integer port;
    1014        protected String path;
     15        protected String expdef;
    1116
    1217        /**
    … …  
    2328         * @return the port
    2429         */
    25         @ParamAnnotation
     30        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
    2631        public Integer getPort() {
    2732                return port;
    … …  
    3944         * @return the path
    4045         */
    41         @ParamAnnotation
     46        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
    4247        public String getPath() {
    4348                return path;
    … …  
    5459        }
    5560
     61        /**
     62         * @return the expdef
     63         */
     64        @ParamAnnotation(flags = ParamFlags.USERREADONLY)
     65        public String getExpdef() {
     66                return expdef;
     67        }
     68
     69        /**
     70         * @param expdef the expdef to set
     71         */
     72        @ParamAnnotation
     73        public void setExpdef(String expdef) {
     74                this.expdef = expdef;
     75        }
     76
    5677        @Override
    5778        protected void joinableStart() {
    … …  
    6081                        arguments.add("-p" + port);
    6182                }
     83                if (Strings.notEmpty(expdef)) {
     84                        arguments.add("Simulator.expdef=\"" + expdef + "\";");
     85                }
     86                // log.debug("running {} with arguments {}", getCommand(), arguments);
    6287                super.joinableStart();
    6388        }

  • java/main/src/main/java/com/framsticks/test/PrimeExperiment.java

    r101 r102  
    11package com.framsticks.test;
    22
     3import org.apache.logging.log4j.Logger;
     4import org.apache.logging.log4j.LogManager;
     5
    36import com.framsticks.experiment.Experiment;
     7import com.framsticks.experiment.WorkPackageLogic;
    48import com.framsticks.params.annotations.FramsClassAnnotation;
     9import com.framsticks.params.annotations.ParamAnnotation;
     10import com.framsticks.test.prime.PrimePackage;
     11import com.framsticks.util.dispatching.Future;
    512
    613@FramsClassAnnotation
    714public class PrimeExperiment extends Experiment {
     15        private static final Logger log = LogManager.getLogger(PrimeExperiment.class);
     16
     17        @ParamAnnotation
     18        public final WorkPackageLogic<PrimePackage> workPackageLogic;
     19
     20        protected int maxNumber = 3000;
     21        protected int step = 100;
     22        protected int numberCounter = 1;
     23
     24        /**
     25         *
     26         */
     27        public PrimeExperiment() {
     28                setExpdef("prime");
     29
     30                workPackageLogic = new WorkPackageLogic<PrimePackage>(this) {
     31
     32                        @Override
     33                        protected void generateNextPackage(Future<PrimePackage> future) {
     34                                assert isActive();
     35                                PrimePackage wp = new PrimePackage();
     36
     37                                log.debug("generated package: {}", wp);
     38                                wp.params.from_number = numberCounter;
     39                                numberCounter += step;
     40                                wp.params.to_number = numberCounter - 1;
     41                                wp.state.current_number = wp.params.from_number;
     42                                wp.state.getResultList().clear();
     43
     44                                future.pass(wp);
     45                        }
     46                };
     47        }
     48
     49        protected void processFile() {
     50        }
    851
    952}

  • java/main/src/main/java/com/framsticks/util/Misc.java

    r100 r102  
    5454                return value;
    5555        }
     56
     57        public static void checkEquals(Object expected, Object found, String message, Object context) {
     58                if (equals(expected, found)) {
     59                        return;
     60                }
     61                throw new FramsticksException().msg(message).arg("expected", expected).arg("found", found).arg("in", context);
     62        }
    5663}

  • java/main/src/main/java/com/framsticks/util/dispatching/AbstractJoinable.java

    r101 r102  
    1818
    1919        private static final Logger log = LogManager.getLogger(AbstractJoinable.class);
     20        private static final Logger reportLog = LogManager.getLogger(AbstractJoinable.class.getName() + ".Report");
    2021
    2122        protected final Set<JoinableParent> owners = new HashSet<JoinableParent>();
    … …  
    3536        }
    3637
     38
     39
    3740        public static void report() {
     41                if (!reportLog.isDebugEnabled()) {
     42                        return;
     43                }
    3844                StringBuilder b = new StringBuilder();
    3945                synchronized (joinablesRegistry) {
    … …  
    4248                        }
    4349                }
    44                 log.debug("state: {}", b);
     50                reportLog.debug("state: {}", b);
    4551        }
    4652
    … …  
    5359                }
    5460                this.state = state;
    55 
    56                 log.debug("{} is notifying {} parents", this, joinableListeners.size());
     61                log.debug("{} changed state to {}", this, state);
     62
    5763
    5864                List<JoinableParent> parents = new LinkedList<>();
    … …  
    6167                for (JoinableParent p : parents) {
    6268                        if (p != null) {
     69                                log.debug("{} is notifying parent {} about change to {}", this, p, state);
    6370                                Dispatching.childChangedState(p, this, state);
    6471                        }
    … …  
    110117                }
    111118                joinableJoin();
    112                 synchronized (this) {
    113                         this.state = JoinableState.JOINED;
    114                 }
     119                changeState(JoinableState.JOINED);
     120                // synchronized (this) {
     121                //      this.state = JoinableState.JOINED;
     122                // }
    115123        }
    116124
    … …  
    158166                synchronized (this) {
    159167                        if (!owners.contains(owner)) {
    160                                 return false;
    161                                 // throw new FramsticksException().msg("object is not owning that joinable").arg("joinable", this).arg("object", owner);
     168                                // log.error("owner {} is not owning that joinable {}", owner, this);
     169                                // return false;
     170                                throw new FramsticksException().msg("object is not owning that joinable").arg("joinable", this).arg("object", owner);
    162171                        }
    163172                        // assert owners.containsKey(owner);
    164                         log.debug("{} is droping {}", owner, this);
    165173                        owners.remove(owner);
    166174                        stop = owners.isEmpty();
     175                        log.debug("{} is droping {} (users remaining: {})", owner, this, owners);
    167176                }
    168177                if (stop) {
    … …  
    195204        @Override
    196205        public String toString() {
    197                 return getName();
     206                return getClass().getSimpleName() + "(" + getName() + ")";
    198207        }
    199208
    … …  
    203212        }
    204213
    205 
    206214}

  • java/main/src/main/java/com/framsticks/util/dispatching/BufferedDispatcher.java

    r101 r102  
    22
    33
    4 public class BufferedDispatcher<C> {
     4import org.apache.logging.log4j.Logger;
     5import org.apache.logging.log4j.LogManager;
     6
     7import com.framsticks.util.FramsticksException;
     8import com.framsticks.util.lang.Strings;
     9// import static com.framsticks.util.dispatching.AbstractJoinable.wrap;
     10
     11public class BufferedDispatcher<C> extends AbstractJoinable implements Dispatcher<C>, JoinableParent {
     12        private static final Logger log = LogManager.getLogger(BufferedDispatcher.class);
    513
    614        protected final RunnableQueue<C> queue = new RunnableQueue<>();
    … …  
    816        protected Dispatcher<C> targetDispatcher;
    917
    10         protected boolean buffer = false;
     18        protected boolean buffer = true;
     19        protected Dispatcher<C> parent;
     20
     21        /**
     22         * @param parent
     23         */
     24        public BufferedDispatcher(Dispatcher<C> parent) {
     25                this.parent = parent;
     26        }
    1127
    1228        /**
    … …  
    2137         */
    2238        public synchronized void setTargetDispatcher(Dispatcher<C> targetDispatcher) {
     39                if (this.targetDispatcher != null) {
     40                        throw new FramsticksException().msg("dispatcher is already set").arg("dispatcher", this.targetDispatcher).arg("in", this);
     41                }
     42                if (targetDispatcher == null) {
     43                        throw new FramsticksException().msg("trying to set empty target dispatcher").arg("in", this);
     44                }
     45                log.debug("setting {} to {}", this, targetDispatcher);
    2346                this.targetDispatcher = targetDispatcher;
     47                flushQueue();
    2448        }
    2549
    2650        public synchronized boolean isActive() {
    27                 if (targetDispatcher == null) {
     51                if (targetDispatcher == null || buffer) {
    2852                        return false;
    2953                        // throw new FramsticksException().msg("no dispatcher is set for tree yet").arg("tree", this);
    … …  
    4064        }
    4165
     66        protected void flushQueue() {
     67                if (this.buffer || targetDispatcher == null) {
     68                        return;
     69                }
     70                log.debug("flushing {} tasks in {}", queue.size(), this);
     71                while (!queue.isEmpty()) {
     72                        targetDispatcher.dispatch(queue.pollFirst());
     73                }
     74        }
     75
    4276        public synchronized void setBuffer(final boolean buffer) {
    4377                if (this.buffer == buffer) {
    … …  
    4983                }
    5084                this.buffer = false;
    51                 while (!queue.isEmpty()) {
    52                         targetDispatcher.dispatch(queue.pollFirst());
     85                flushQueue();
     86        }
     87
     88        @Override
     89        public String toString() {
     90                return parent + " -> " + Strings.toStringNullProof(targetDispatcher, "<null>");
     91        }
     92
     93        public void createThreadIfNeeded() {
     94                if (targetDispatcher != null) {
     95                        return;
    5396                }
     97                this.setTargetDispatcher(new Thread<C>().setName(parent.getName()));
     98        }
     99
     100        @Override
     101        public String getName() {
     102                return parent + " buffered dispatcher";
     103        }
     104
     105        @Override
     106        protected void joinableStart() {
     107                Dispatching.use(targetDispatcher, this);
     108        }
     109
     110        @Override
     111        protected void joinableInterrupt() {
     112                Dispatching.drop(targetDispatcher, this);
     113
     114                finishJoinable();
     115        }
     116
     117        @Override
     118        protected void joinableFinish() {
    54119
    55120        }
    56121
     122        @Override
     123        protected void joinableJoin() throws InterruptedException {
     124                Dispatching.join(targetDispatcher);
     125        }
    57126
     127        @Override
     128        public void childChangedState(Joinable joinable, JoinableState state) {
     129                proceedToState(state);
     130        }
    58131}

  • java/main/src/main/java/com/framsticks/util/dispatching/Dispatching.java

    r101 r102  
    33import java.util.Timer;
    44
     5import org.apache.logging.log4j.Level;
    56import org.apache.logging.log4j.Logger;
    67import org.apache.logging.log4j.LogManager;
    78
    89import com.framsticks.util.FramsticksException;
     10import com.framsticks.util.Misc;
    911
    1012/**
    … …  
    3234        }
    3335
     36        public static <C> void dispatch(Dispatcher<C> dispatcher, RunAt<? extends C> runnable) {
     37                dispatcher.dispatch(runnable);
     38        }
     39
    3440        // public static boolean assertInvokeLater(Dispatcher dispatcher, RunAt runnable) {
    3541        //      dispatcher.invokeLater(runnable);
    … …  
    6672
    6773        public static void use(final Joinable joinable, final JoinableParent owner) {
     74                Misc.throwIfNull(joinable);
    6875                log.debug("using {} by {}", joinable, owner);
    6976                if (joinable.use(owner)) {
    … …  
    7582
    7683        public static void drop(final Joinable joinable, final JoinableParent owner) {
     84                Misc.throwIfNull(joinable);
    7785                log.debug("droping {} by {}", joinable, owner);
    7886                if (joinable.drop(owner)) {
    … …  
    8492
    8593        public static void join(Joinable joinable) throws InterruptedException {
     94                Misc.throwIfNull(joinable);
    8695                log.debug("joining {}", joinable);
    8796                try {
    … …  
    95104
    96105        public static void childChangedState(final JoinableParent parent, final Joinable joinable, final JoinableState state) {
    97                 if (state.ordinal() <= JoinableState.RUNNING.ordinal()) {
     106                if (state.ordinal() < JoinableState.RUNNING.ordinal()) {
    98107                        return;
    99108                }
    … …  
    113122                        }
    114123                } catch (InterruptedException e) {
     124                        log.debug("failed to wait on {} because of: {}", object, e.getMessage());
    115125                }
    116126        }
    … …  
    123133                                return;
    124134                        } catch (InterruptedException e) {
     135                                log.debug("failed to join {} because of: {}", joinable, e.getMessage());
    125136                                // throw new FramsticksException().msg("failed to join").arg("dispatcher", dispatcher).cause(e);
    126137                        }
    … …  
    192203
    193204        // public static class DispatcherWaiter<C, T extends Dispatcher<C> & Joinable> implements Dispatcher<C> {
    194         //      // protected boolean done = false;
    195         //      protected final T dispatcher;
    196         //      protected RunAt<? extends C> runnable;
    197 
    198         //      /**
    199         //       * @param joinable
    200         //       */
    201         //      public DispatcherWaiter(T dispatcher) {
    202         //              this.dispatcher = dispatcher;
    203         //      }
    204 
    205         //      public synchronized void waitFor() {
    206         //              while ((runnable == null) && (dispatcher.getState().ordinal() <= JoinableState.RUNNING.ordinal())) {
    207         //                      try {
    208         //                              this.wait();
    209         //                      } catch (InterruptedException e) {
    210         //                      }
    211         //              }
    212         //              if (runnable != null) {
    213         //                      runnable.run();
    214         //              }
    215 
    216         //      }
    217 
    218         //      @Override
    219         //      public boolean isActive() {
    220         //              return dispatcher.isActive();
    221         //      }
    222 
    223         //      @Override
    224         //      public synchronized void dispatch(RunAt<? extends C> runnable) {
    225         //              this.runnable = runnable;
    226         //              this.notifyAll();
    227         //      }
     205        //      // protected boolean done = false;
     206        //      protected final T dispatcher;
     207        //      protected RunAt<? extends C> runnable;
     208
     209        //      /**
     210        //       * @param joinable
     211        //       */
     212        //      public DispatcherWaiter(T dispatcher) {
     213        //              this.dispatcher = dispatcher;
     214        //      }
     215
     216        //      public synchronized void waitFor() {
     217        //              while ((runnable == null) && (dispatcher.getState().ordinal() <= JoinableState.RUNNING.ordinal())) {
     218        //                      try {
     219        //                              this.wait();
     220        //                      } catch (InterruptedException e) {
     221        //                      }
     222        //              }
     223        //              if (runnable != null) {
     224        //                      runnable.run();
     225        //              }
     226
     227        //      }
     228
     229        //      @Override
     230        //      public boolean isActive() {
     231        //              return dispatcher.isActive();
     232        //      }
     233
     234        //      @Override
     235        //      public synchronized void dispatch(RunAt<? extends C> runnable) {
     236        //              this.runnable = runnable;
     237        //              this.notifyAll();
     238        //      }
    228239
    229240        // }
    … …  
    284295        }
    285296
     297        public static <C> void dispatchLog(final Dispatcher<C> dispatcher, final Logger logger, final Level level, final Object text) {
     298                dispatcher.dispatch(new RunAt<C>(ThrowExceptionHandler.getInstance()) {
     299
     300                        @Override
     301                        protected void runAt() {
     302                                logger.log(level, "message dispatched into {}: {}", dispatcher, text);
     303                        }
     304                });
     305
     306        }
     307
    286308}

  • java/main/src/main/java/com/framsticks/util/dispatching/JoinableCollection.java

    r101 r102  
    2121        protected final Set<T> joinables = new HashSet<T>();
    2222
    23         protected boolean finishIfOne;
     23        public static enum FinishPolicy {
     24                Never,
     25                OnFirst,
     26                OnAll
     27        };
     28
     29        protected final FinishPolicy finishPolicy;
    2430
    2531        protected String observableName;
    2632
    2733        public JoinableCollection() {
    28                 this(false);
    29         }
    30 
    31         public JoinableCollection(boolean finishIfOne) {
    32                 this.finishIfOne = finishIfOne;
     34                this(FinishPolicy.OnAll);
     35        }
     36
     37
     38        /**
     39         * @param finishPolicy
     40         */
     41        public JoinableCollection(FinishPolicy finishPolicy) {
     42                this.finishPolicy = finishPolicy;
    3343        }
    3444
    … …  
    95105
    96106        protected JoinableState getNextState() {
    97                 if (joinables.isEmpty()) {
     107                if ((finishPolicy == FinishPolicy.Never && state == JoinableState.RUNNING) || joinables.isEmpty()) {
    98108                        return state;
    99109                }
    100                 JoinableState result = finishIfOne ? JoinableState.INITILIAZED : JoinableState.JOINED;
     110                boolean oneIsEnough = (finishPolicy == FinishPolicy.OnFirst);
     111                JoinableState result = oneIsEnough ? JoinableState.INITILIAZED : JoinableState.JOINED;
    101112                for (Joinable j : joinables) {
    102113                        JoinableState s = j.getState();
    103                         if (finishIfOne) {
     114                        if (oneIsEnough) {
    104115                                if (s.ordinal() > result.ordinal()) {
    105116                                        result = s;

  • java/main/src/main/java/com/framsticks/util/dispatching/Monitor.java

    r100 r102  
    55import com.framsticks.util.dispatching.Dispatching;
    66import java.lang.Thread;
     7import java.util.concurrent.atomic.AtomicBoolean;
    78
    89public class Monitor implements JoinableParent {
    … …  
    1213        protected final Joinable joinable;
    1314        protected final Thread shutdownHook;
     15        protected final AtomicBoolean dropped = new AtomicBoolean(false);
     16        protected final AtomicBoolean joining = new AtomicBoolean(false);
    1417
    1518        /**
    … …  
    2225                        @Override
    2326                        public void run() {
    24                                 log.debug("running shutdown hook");
     27                                log.debug("droping and joining");
    2528                                Monitor.this.drop().join();
     29                                log.debug("droped and joined");
     30                                AbstractJoinable.report();
    2631                        }
    2732                });
    … …  
    5459
    5560        public Monitor drop() {
     61                if (!dropped.compareAndSet(false, true)) {
     62                        return this;
     63                }
    5664                log.debug("{} is droping", this);
    5765                Dispatching.drop(joinable, this);
    … …  
    6068
    6169        public Monitor join() {
     70                if (!joining.compareAndSet(false, true)) {
     71                        log.debug("not joining");
     72                        return this;
     73                }
     74
    6275                log.debug("{} is joining", this);
    6376                Dispatching.joinAbsolutely(joinable);
    … …  
    6982                        /** In case IllegalStateException is caught, it means that JVM is in finalization stage */
    7083                }
    71 
    7284                return this;
    7385        }

  • java/main/src/main/java/com/framsticks/util/dispatching/RunnableQueue.java

    r101 r102  
    1919        }
    2020
     21        public int size() {
     22                return queue.size();
     23        }
     24
    2125}

  • java/main/src/main/java/com/framsticks/util/dispatching/Thread.java

    r101 r102  
    106106
    107107        @ParamAnnotation
    108         public void setName(String name) {
     108        public Thread<C> setName(String name) {
    109109                thread.setName(name);
     110                return this;
    110111        }
    111112
    … …  
    119120        }
    120121
    121         @Override
    122         public String toString() {
    123                 return getName();
    124         }
     122        // @Override
     123        // public String toString() {
     124        //      return getName();
     125        // }
    125126
    126127        @Override

  • java/main/src/main/resources/common-columns.xml

    r101 r102  
    11<?xml version="1.0" encoding="UTF-8"?>
    22<AutoInjector>
     3        <import class="com.framsticks.gui.table.ColumnsConfig" />
    34        <ColumnsConfig className="Genotype" columnsNames="uid name mutate" />
    45        <ColumnsConfig className="Part" columnsNames="x y z" />
     6        <ColumnsConfig className="Simulator" columnsNames="name init stop start abort" />
    57</AutoInjector>

  • java/main/src/main/resources/log4j2.xml

    r101 r102  
    55                        <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    66                </Console>
    7                 <File name="File" fileName="framsticks.log">
    8                         <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
    9                 </File>
     7                <!-- <File name="File" fileName="framsticks.log"> -->
     8                <!--    <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/> -->
     9                <!-- </File> -->
    1010        </appenders>
    1111        <loggers>
    … …  
    1515                <!-- <logger name="com.framsticks.running.ExternalProcess" level="trace" /> -->
    1616                <!-- <logger name="com.framsticks.util.dispatching.AbstractJoinable" level="debug" /> -->
     17                <!-- <logger name="com.framsticks.util.dispatching.AbstractJoinable.Report" level="info" /> -->
     18                <!-- <logger name="com.framsticks.util.dispatching.Monitor" level="debug" /> -->
     19                <logger name="com.framsticks.util.dispatching.BufferedDispatcher" level="debug" />
     20                <!-- <logger name="com.framsticks.util.dispatching.Dispatching" level="debug" /> -->
     21                <logger name="com.framsticks.running" level="debug" />
     22                <!-- <logger name="com.framsticks.communication" level="debug" /> -->
     23                <logger name="com.framsticks.experiment" level="debug" />
     24                <logger name="com.framsticks.experiment.Simulator" level="debug" />
    1725                <root level="info">
    1826                        <appender-ref ref="Console"/>
    19                         <appender-ref ref="File"/>
     27                        <!-- <appender-ref ref="File"/> -->
    2028                </root>
    2129        </loggers>

  • java/main/src/main/resources/prime-gui.xml

    r101 r102  
    11<?xml version="1.0" encoding="UTF-8"?>
    22<Framsticks>
    3         <include resource="/prime.xml" />
    43
    54        <import class="com.framsticks.gui.Browser" />
    … …  
    87                <RemoteTree name="prime-experiment" address="localhost:9007" />
    98                <RemoteTree name="worker" address="localhost:9100" />
     9                <include resource="/common-columns.xml" />
    1010        </Browser>
    1111</Framsticks>

  • java/main/src/main/resources/prime.xml

    r101 r102  
    33        <import class="com.framsticks.hosting.Server" />
    44        <import class="com.framsticks.test.PrimeExperiment" />
    5         <import class="com.framsticks.experiment.Simulator" />
     5        <!-- <import class="com.framsticks.experiment.Simulator" /> -->
     6        <import class="com.framsticks.experiment.SimulatorConnector" />
    67        <import class="com.framsticks.core.LocalTree" />
    7         <import class="com.framsticks.running.LoggingOutputListener" />
    8         <import class="com.framsticks.running.FramsServer" />
    98        <Server port="9007">
    10                 <LocalTree name="test">
    11                         <PrimeExperiment name="prime">
    12                                 <Simulator address="localhost:9100"/>
    13                                 <Simulator address="localhost:9101"/>
    14                                 <Simulator address="localhost:9102"/>
     9                <LocalTree name="prime-local-tree">
     10                        <PrimeExperiment>
     11                                <SimulatorConnector address="localhost:9100" />
     12                                <SimulatorConnector address="localhost:9101" />
     13                                <SimulatorConnector address="localhost:9102" />
    1514                        </PrimeExperiment>
    1615                </LocalTree>
    1716        </Server>
    18         <FramsServer name="frams" port="9100">
    19                 <LoggingOutputListener />
    20         </FramsServer>
    21         <FramsServer name="frams" port="9101">
    22                 <LoggingOutputListener />
    23         </FramsServer>
    24         <FramsServer name="frams" port="9102">
    25                 <LoggingOutputListener />
    26         </FramsServer>
    2717</Framsticks>
    2818

  • java/main/src/test/java/com/framsticks/core/ListChangeTest.java

    r101 r102  
    77
    88import com.framsticks.core.ListChange.Action;
    9 import com.framsticks.params.AccessOperations;
     9import static com.framsticks.params.AccessOperations.*;
    1010import com.framsticks.params.FramsClass;
    1111import com.framsticks.params.ListSink;
    … …  
    4040        public void testFramsClass() {
    4141                framsClass = FramsClass.build().forClass(ListChange.class);
    42                 assertThat(framsClass.getParamCount()).isEqualTo(3);
     42                assertThat(framsClass.getParamCount()).isEqualTo(4);
    4343        }
    4444
    … …  
    6060
    6161        @Test(dependsOnMethods = "createReflectionAccess")
    62         public void load() throws Exception {
    63                 AccessOperations.load(access.select(listChange), ListSource.createFrom("type:2", "pos:0", "id:test"));
     62        public void loading() throws Exception {
     63                load(access.select(listChange), ListSource.createFrom("type:2", "pos:0", "id:test"));
    6464
    6565                assertThat(listChange.action).isEqualTo(Action.Modify);
    … …  
    6868
    6969                ListSink sink = new ListSink();
    70                 access.select(listChange).save(sink);
     70                save(access.select(listChange), sink);
    7171                assertThat(sink.getOut()).isEqualTo(Arrays.asList("ListChange:", "type:2", "pos:0", "id:test", ""));
    7272        }

  • java/main/src/test/java/com/framsticks/gui/console/DirectConsoleTest.java

    r97 r102  
    2020        protected Joinable createSubject() {
    2121
    22                 connection = new ClientSideRawConnection();
    23                 connection.setAddress(new Address("localhost:9009"));
    24 
    25                 console = new DirectConsole().setConnection(connection);
     22                console = new DirectConsole().setAddress(new Address("localhost:9009"));
    2623                joinables = new JoinableCollection<>();
    2724                joinables.setObservableName("connection and console");
    2825                joinables.add(console);
    29                 joinables.add(connection);
     26                joinables.add(console.getConnection());
    3027
    3128                return joinables;

  • java/main/src/test/java/com/framsticks/test/MonitorBasedTest.java

    r96 r102  
    3030        }
    3131
    32         @AfterClass(timeOut = 3000)
     32        @AfterClass(timeOut = 30000)
    3333        public void tearDown() {
    3434                monitor.drop().join();

  • java/main/src/test/java/com/framsticks/test/PrimeExperimentTest.java

    r101 r102  
    66
    77import com.framsticks.core.XmlBasedTest;
     8import com.framsticks.util.dispatching.Dispatching;
     9import com.framsticks.util.dispatching.StackedJoinable;
     10
     11import org.apache.logging.log4j.Logger;
     12import org.apache.logging.log4j.LogManager;
    813
    914@Test
    1015public class PrimeExperimentTest extends XmlBasedTest {
    1116
     17        private static final Logger log = LogManager.getLogger(PrimeExperimentTest.class);
     18
    1219        protected PrimeExperiment experiment;
     20
    1321
    1422        @Test
    1523        public void start() {
     24                log.debug("starting");
    1625                assertThat(framsticks).isNotNull();
    17                 assertThat(framsticks.get("prime")).isInstanceOf(PrimeExperiment.class);
    18                 experiment = (PrimeExperiment) framsticks.get("prime");
     26                assertThat(framsticks.size()).isEqualTo(1);
     27                assertThat(framsticks.get("stacked")).isInstanceOf(StackedJoinable.class);
     28                StackedJoinable stacked = (StackedJoinable) framsticks.get("stacked");
     29
     30                assertThat(stacked.size()).isEqualTo(2);
     31                assertThat(stacked.get(1)).isInstanceOf(PrimeExperiment.class);
     32                // assertThat(framsticks.get("prime")).isInstanceOf(PrimeExperiment.class);
     33                // experiment = (PrimeExperiment) framsticks.get("prime");
     34                //
     35                Dispatching.sleep(3);
    1936        }
     37
    2038}

  • java/main/src/test/resources/configs/PrimeExperimentTest.xml

    r101 r102  
    33        <import class="com.framsticks.test.PrimeExperiment" />
    44        <import class="com.framsticks.experiment.Simulator" />
    5         <PrimeExperiment name="prime">
    6         </PrimeExperiment>
     5        <import class="com.framsticks.util.dispatching.StackedJoinable" />
     6        <import class="com.framsticks.util.dispatching.JoinableCollection" />
     7        <import class="com.framsticks.running.LoggingOutputListener" />
     8        <import class="com.framsticks.running.FramsServer" />
     9        <import class="com.framsticks.experiment.SimulatorConnector" />
     10        <StackedJoinable interval="1">
     11                <JoinableCollection name="servers">
     12                        <FramsServer name="frams" port="9100" expdef="prime">
     13                                <LoggingOutputListener />
     14                        </FramsServer>
     15                        <FramsServer name="frams" port="9101" expdef="prime">
     16                                <LoggingOutputListener />
     17                        </FramsServer>
     18                </JoinableCollection>
     19                <PrimeExperiment>
     20                        <SimulatorConnector address="localhost:9100" />
     21                        <SimulatorConnector address="localhost:9101" />
     22                </PrimeExperiment>
     23        </StackedJoinable>
    724</Framsticks>

  • java/main/src/test/resources/configs/ServerTest.xml

    r101 r102  
    66        <import class="com.framsticks.test.TestClass" />
    77        <import class="com.framsticks.running.LoggingOutputListener" />
    8         <Server port="9007">
     8        <Server port="9006">
    99                <LocalTree name="test">
    1010                        <TestClass name="a test name" />
    1111                </LocalTree>
    1212        </Server>
    13         <RemoteTree name="remote" address="localhost:9007" />
     13        <RemoteTree name="remote" address="localhost:9006" />
    1414</Framsticks>

  • java/main/src/test/resources/log4j2.xml

    r100 r102  
    77        </appenders>
    88        <loggers>
    9                 <logger name="com.framsticks" level="warn" />
     9                <logger name="com.framsticks" level="info" />
     10                <logger name="com.framsticks.running.ExternalProcess" level="debug" />
    1011                <logger name="com.framsticks.test.TestConfiguration" level="info" />
     12                <logger name="com.framsticks.experiment" level="debug" />
     13                <logger name="com.framsticks.test.PrimeExperiment" level="debug" />
     14                <!-- <logger name="com.framsticks.util.dispatching.AbstractJoinable" level="debug" /> -->
     15                <!-- <logger name="com.framsticks.util.dispatching.AbstractJoinable.Report" level="info" /> -->
     16                <!-- <logger name="com.framsticks.util.dispatching.Monitor" level="debug" /> -->
     17                <!-- <logger name="com.framsticks.util.dispatching.StackedJoinable" level="debug" /> -->
    1118                <root level="info">
    1219                        <appender-ref ref="Console"/>
Note: See TracChangeset for help on using the changeset viewer.