Ignore:
Timestamp:
07/18/13 23:52:25 (11 years ago)
Author:
psniegowski
Message:

HIGHLIGHTS:

  • add auto loading and saving algorithms between

frams files format and Java classes

  • respect ValueChange? events in GUI (do not reload object)
  • support results of procedures in Java server
  • make Experiment automatically convert between frams file and NetFile? object
  • add MessageLogger? (compatible with original frams server messages)
  • WorkPackageLogic? now validates results, is able to discard them, reschedule

whole package, or only uncomputed remainder

CHANGELOG:
Show just a short description in PrimeExperiment?.

Add primes_changed event to the PrimeExperiment?.

Make WorkPackageLogic? robust to frams server returning invalid results.

Add MessageLogger? to logics.

Add NetFile? interface. Support Messages from server.

Minor changes to connections.

Merge results in the PrimeExperiment?.

More netload class->file conversion to Simulator.

Move netsave parsing to Simulator.

Fix bug with inverted ordering of events firing in Experiment.

Minor changes.

Minor logging changes.

Use AccessOperations?.convert in NetLoadSaveLogic?

NetLoadSaveLogic? now encloses the conversion.

Use more generic AccessOperations? saveAll and loadAll in PrimePackage?.

Add Result class for enclosing of call invocations' results.

Improve feature request handling in Connections.

Use AccessOperations?.convert in RemoteTree? events parsing.

Minor change.

Add some information params to Java server root and CLI objects.

A draft implementation of loadAll algorithm.

That algorithm tries to load objects into a tree structure.

Add AccessOperationsTest? test.

Develop WorkPackageLogic?.

  • add state tracking fields
  • add work package generation

Add utility class SimplePrimitive?.

Meant for Java backend classes, enclose a single primitive value
and set of listeners.

Improve primitive value refresh in GUI.

When ValueChange? found in called event, do not reload whole
object, but only update GUI (no communication is performed).

Use ValueChange? in the TestClass? test.

Minor changes.

Sending all packages in PrimeExperiment? to the frams servers.

Develop AccessOperations?.loadComposites().

Remove addAccess from MultiParamLoader? interface.

There is now no default AccessProvider? in MultiParamLoader?.
User must explicitely set AccessStash? or Registry.

Improve saving algorithms in AccessOperations?.

Location:
java/main/src/main/java/com/framsticks/experiment
Files:
2 added
5 edited

Legend:

Unmodified
Added
Removed

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

    r102 r103  
    4545        protected String expdef;
    4646
     47
    4748        /**
    4849         *
    … …  
    5354
    5455                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 
    6656        }
    6757
    … …  
    114104                this.expdef = expdef;
    115105        }
     106
    116107
    117108        @ParamAnnotation(id = "simulators_changed")
    … …  
    129120                simulators.add(simulator);
    130121                simulatorAsJoinables.add(simulator);
    131 
    132 
    133 
    134 
     122                simulators.fireChildrenChange(simulator, ListChange.Action.Modify, "ready");
    135123
    136124        }

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

    r102 r103  
    55import org.apache.logging.log4j.LogManager;
    66
    7 import com.framsticks.communication.File;
    87import com.framsticks.core.ListChange;
     8import com.framsticks.core.Message;
    99import com.framsticks.params.EventListener;
     10import com.framsticks.params.MessageLogger;
    1011import com.framsticks.params.annotations.FramsClassAnnotation;
    1112import com.framsticks.params.annotations.ParamAnnotation;
    … …  
    1415
    1516@FramsClassAnnotation
    16 public abstract class NetLoadSaveLogic extends AbstractExperimentLogic {
     17public abstract class NetLoadSaveLogic<NF extends NetFile> extends AbstractExperimentLogic {
    1718        private static final Logger log = LogManager.getLogger(NetLoadSaveLogic.class);
    1819
     20        protected String option = "an option";
    1921
    20         protected String option = "an option";
     22        protected final Class<NF> netJavaClass;
     23
     24        protected final MessageLogger messages = new MessageLogger(NetLoadSaveLogic.class);
    2125
    2226        /**
    2327         * @param experiment
    2428         */
    25         public NetLoadSaveLogic(Experiment parentExperiment) {
     29        public NetLoadSaveLogic(Experiment parentExperiment, Class<NF> netJavaClassArg) {
    2630                super(parentExperiment);
     31                this.netJavaClass = netJavaClassArg;
    2732
    2833                experiment.addSimulatorsListener(new EventListener<ListChange>() {
    2934
    3035                        @Override
    31                         public void action(ListChange argument) {
     36                        public void action(final ListChange change) {
    3237                                assert experiment.isActive();
     38                                final Simulator simulator = experiment.getSimulators().get(change.getIdentifier());
     39                                log.debug("processing list change: {}", change);
    3340
    34                                 if (argument.hasHint("ready")) {
    35                                         final Simulator simulator = experiment.getSimulators().get(argument.getIdentifier());
    36                                         log.debug("simulator is ready: {}", simulator);
     41                                if (change.getAction() == ListChange.Action.Add) {
     42                                        log.debug("registering in {}", simulator);
     43                                        simulator.getRemoteTree().getRegistry().registerAndBuild(netJavaClass);
     44                                }
    3745
    38                                         netload(simulator, new FutureHandler<File>(simulator) {
     46                                if (!change.hasHint("stoped")) {
     47                                        issueNetloadIfReady(change, simulator);
     48                                        return;
     49                                }
    3950
    40                                                 @Override
    41                                                 protected void result(final File file) {
    42                                                         simulator.uploadNet(file, new FutureHandler<Object>(this) {
     51                                log.debug("issuing netsave to: {}", simulator);
     52                                simulator.netsave(netJavaClass, new FutureHandler<NF>(simulator) {
    4353
    44                                                                 @Override
    45                                                                 protected void result(Object result) {
    46                                                                         log.debug("netload of {} done", file);
    47                                                                 }
    48                                                         });
    49                                                 }
    50                                         });
    51                                 }
     54                                        @Override
     55                                        protected void result(NF net) {
     56                                                log.debug("netsave of {} done: {}", simulator, net.getShortDescription());
     57                                                netsave(simulator, net);
     58                                                issueNetloadIfReady(change, simulator);
     59                                        }
     60                                });
    5261                        }
    5362                });
    5463        }
    5564
    56         public abstract void netload(Simulator simulator, Future<File> net);
     65        protected void issueNetloadIfReady(ListChange change, final Simulator simulator) {
     66                if (!change.hasHint("ready")) {
     67                        return;
     68                }
     69                log.debug("issuing netload to: {}", simulator);
     70                netload(simulator, new FutureHandler<NF>(simulator) {
    5771
    58         public abstract void netsave(Simulator simulator, File net);
     72                        @Override
     73                        protected void result(final NF net) {
     74                                if (net == null) {
     75                                        log.debug("no file for upload provided - leaving simulator idle");
     76                                        return;
     77                                }
     78
     79                                simulator.netload(net, new FutureHandler<Object>(this) {
     80
     81                                        @Override
     82                                        protected void result(Object result) {
     83                                                NetLoadSaveLogic.this.messages.info("netload", "done " + net.getShortDescription());
     84                                                log.debug("netload of {} done", net.getShortDescription());
     85                                                simulator.start();
     86                                        }
     87                                });
     88                        }
     89                });
     90        }
     91
     92        public abstract void netload(Simulator simulator, Future<NF> net);
     93
     94        public abstract void netsave(Simulator simulator, NF net);
    5995
    6096        /**
    … …  
    74110        }
    75111
     112        /**
     113         * @return the netJavaClass
     114         */
     115        @ParamAnnotation(name = "Java class representing netfile")
     116        public String getNetJavaClassName() {
     117                return netJavaClass.getCanonicalName();
     118        }
     119
     120        @ParamAnnotation(id = "messages")
     121        public void addMessageListener(EventListener<Message> listener) {
     122                messages.add(listener);
     123        }
     124
     125        @ParamAnnotation(id = "messages")
     126        public void removeMessageListener(EventListener<Message> listener) {
     127                messages.remove(listener);
     128        }
     129
    76130}

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

    r102 r103  
    44import com.framsticks.communication.queries.NeedFile;
    55import com.framsticks.communication.queries.NeedFileAcceptor;
     6import com.framsticks.core.ListChange;
    67import com.framsticks.core.Path;
    78import com.framsticks.core.Tree;
    89import com.framsticks.core.ValueChange;
     10import com.framsticks.params.AccessOperations;
     11import com.framsticks.params.CastFailure;
    912import com.framsticks.params.EventListener;
    1013import com.framsticks.params.FramsClass;
    … …  
    1215import com.framsticks.params.annotations.FramsClassAnnotation;
    1316import com.framsticks.params.annotations.ParamAnnotation;
     17import com.framsticks.params.types.BooleanParam;
    1418import com.framsticks.params.types.EventParam;
    1519import com.framsticks.params.types.ProcedureParam;
    … …  
    5963                assert experiment.isActive();
    6064
    61                 log.debug("simulator ready {}", this);
     65                log.info("simulator ready {}", this);
    6266
    6367                runningListener = new EventListener<ValueChange>() {
    6468                        @Override
    6569                        public void action(ValueChange argument) {
    66                                 log.debug("running state of {} changed: {}", this, argument);
     70                                try {
     71                                        boolean running = simulatorClass.getParamEntry("running", BooleanParam.class).reassign(argument.value, null).getValue();
     72                                        log.debug("running state of {} changed: {}", Simulator.this, running);
     73                                        if (!running) {
     74                                                Simulator.this.experiment.simulators.fireChildrenChange(Simulator.this, ListChange.Action.Modify, "ready", "stoped");
     75                                        }
     76                                } catch (CastFailure e) {
     77                                        log.error("failure: ", e);
     78                                }
    6779                        }
    6880                };
    … …  
    147159        @ParamAnnotation(paramType = ProcedureParam.class)
    148160        public void start() {
     161                log.debug("starting simulator {}", this);
     162                call(simulatorPath, "start", new Object[] {}, Object.class, FutureHandler.doNothing(Object.class, this));
    149163        }
    150164
    151165        @ParamAnnotation(paramType = ProcedureParam.class)
    152166        public void stop() {
     167                log.debug("stoping simulator {}", this);
    153168        }
    154169
    … …  
    156171        public void abort() {
    157172                assert isActive();
    158                 log.debug("explicitly aborting {}", this);
     173                log.info("explicitly aborting {}", this);
    159174                experiment.removeSimulator(this);
    160175                interruptJoinable();
    … …  
    184199        protected final AtomicInteger netloadIdCounter = new AtomicInteger();
    185200
    186         public void uploadNet(final File file, final Future<Object> future) {
     201        public <N> void netload(final N net, final Future<Object> future) {
    187202                final String netloadId = "NetLoadSaveLogic" + netloadIdCounter.getAndIncrement();
    188203
     204                final File file = AccessOperations.convert(File.class, net, getRemoteTree().getRegistry());
    189205                log.debug("uploading file {} to {} identified by {}", file, simulatorPath, netloadId);
    190206
    … …  
    215231                simulatorPath.getTree().addNeedFileAcceptor(Integer.MIN_VALUE, acceptor.get());
    216232
    217                 call(simulatorPath, getFramsClass(simulatorPath).getParamEntry("netload_id", ProcedureParam.class), new Object[] { netloadId }, new FutureHandler<Object>(future) {
     233                call(simulatorPath, getFramsClass(simulatorPath).getParamEntry("netload_id", ProcedureParam.class), new Object[] { netloadId }, Object.class, new FutureHandler<Object>(future) {
    218234
    219235                        @Override
    … …  
    225241
    226242        }
     243
     244        public <N> void netsave(Class<N> netJavaClass, final Future<N> futureNet) {
     245                call(simulatorPath, getFramsClass(simulatorPath).getParamEntry("netsave", ProcedureParam.class), new Object[] { }, netJavaClass, new FutureHandler<N>(futureNet) {
     246
     247                        @Override
     248                        protected void result(N net) {
     249                                log.debug("download of {} done", net);
     250                                futureNet.pass(net);
     251                        }
     252                });
     253
     254        }
    227255}

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

    r102 r103  
    11package com.framsticks.experiment;
    22
    3 public interface WorkPackage {
     3public interface WorkPackage<S extends WorkPackage<S>> extends NetFile {
     4
     5        public String sumUpTask();
     6        public String sumUpResult();
     7
     8        S getRemainder(S result);
    49
    510}

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

    r102 r103  
    11package com.framsticks.experiment;
     2
     3import java.util.IdentityHashMap;
     4import java.util.LinkedList;
     5import java.util.Map;
    26
    37import org.apache.logging.log4j.Logger;
    48import org.apache.logging.log4j.LogManager;
    59
    6 import com.framsticks.communication.File;
    7 import com.framsticks.params.ListSource;
     10import com.framsticks.core.Message;
     11import com.framsticks.core.ValueChange;
     12import com.framsticks.params.EventListener;
     13import com.framsticks.params.MessageLogger;
     14import com.framsticks.params.SimplePrimitive;
    815import com.framsticks.params.annotations.FramsClassAnnotation;
    916import com.framsticks.params.annotations.ParamAnnotation;
    … …  
    1118import com.framsticks.util.dispatching.FutureHandler;
    1219
    13 @FramsClassAnnotation
    14 public abstract class WorkPackageLogic<WP extends WorkPackage> extends AbstractExperimentLogic {
     20@FramsClassAnnotation(order = {"netLoadSaveLogic", "newestTaskScheduled", "newestResultReceived"})
     21public abstract class WorkPackageLogic<WP extends WorkPackage<WP>> extends AbstractExperimentLogic {
    1522
    1623        private static final Logger log = LogManager.getLogger(WorkPackageLogic.class);
    1724
    1825        @ParamAnnotation
    19         public final NetLoadSaveLogic netLoadSaveLogic;
     26        public final NetLoadSaveLogic<WP> netLoadSaveLogic;
     27
     28        protected final Class<WP> packageJavaClass;
     29
     30        protected final MessageLogger messages = new MessageLogger(WorkPackageLogic.class);
     31
     32        protected final Map<Simulator, WP> sentPackages = new IdentityHashMap<>();
     33        protected final LinkedList<WP> queuedPackages = new LinkedList<>();
     34
     35        protected final SimplePrimitive<String> newestTaskSent = new SimplePrimitive<>();
     36        protected final SimplePrimitive<String> newestResultReceived = new SimplePrimitive<>();
     37
    2038
    2139        /**
    2240         * @param experiment
    2341         */
    24         public WorkPackageLogic(Experiment experiment) {
     42        public WorkPackageLogic(Experiment experiment, Class<WP> packageJavaClass) {
    2543                super(experiment);
     44                this.packageJavaClass = packageJavaClass;
    2645
    27                 netLoadSaveLogic = new NetLoadSaveLogic(experiment) {
     46                netLoadSaveLogic = new NetLoadSaveLogic<WP>(experiment, packageJavaClass) {
    2847
    2948                        @Override
    30                         public void netload(Simulator simulator, final Future<File> net) {
     49                        public void netload(final Simulator simulator, final Future<WP> netFuture) {
    3150                                assert experiment.isActive();
    3251                                log.debug("providing netload file for {}", simulator);
    3352
    34                                 generateNextPackage(new FutureHandler<WP> (net) {
     53                                findNextPackage(new FutureHandler<WP> (netFuture) {
    3554
    3655                                        @Override
    37                                         protected void result(WP result) {
    38                                                 log.debug("sending package: {}", result);
    39                                                 File file = new File("test-file", ListSource.createFrom("# a test"));
     56                                        protected void result(WP net) {
     57                                                assert experiment.isActive();
    4058
    41                                                 net.pass(file);
     59                                                if (net == null) {
     60                                                        log.debug("no more packages left");
     61                                                        return;
     62                                                }
     63                                                WorkPackageLogic.this.messages.info("netload", net.sumUpTask());
     64                                                log.debug("sending package: {}", net);
     65                                                newestTaskSent.set(net.sumUpTask());
     66                                                sentPackages.put(simulator, net);
     67
     68                                                netFuture.pass(net);
    4269                                        }
    4370                                });
    … …  
    4673
    4774                        @Override
    48                         public void netsave(Simulator simulator, File net) {
     75                        public void netsave(Simulator simulator, WP netResult) {
     76                                assert experiment.isActive();
     77
     78                                log.debug("received package from {}: {}", simulator, netResult);
     79                                WorkPackageLogic.this.messages.info("netsave", netResult.toString());
     80
     81                                WP netSent = sentPackages.get(simulator);
     82                                if (netSent == null) {
     83                                        log.error("no task found in {} for received result {}", simulator, netResult);
     84                                        return;
     85                                }
     86                                sentPackages.remove(simulator);
     87
     88                                try {
     89                                        WP netRemainder = netSent.getRemainder(netResult);
     90                                        if (netRemainder != null) {
     91                                                log.warn("queueing remainder: {}", netRemainder);
     92                                                queuedPackages.add(netRemainder);
     93                                        }
     94                                } catch (InvalidWorkPackage e) {
     95                                        log.error("in simulator {}, result {} is in no relation to task {} ({}), rescheduling", simulator, netResult, netSent, e.getShortMessage(new StringBuilder()));
     96                                        queuedPackages.add(netSent);
     97                                        return;
     98                                }
     99
     100                                returnPackage(netResult);
    49101                                // processFile();
    50102                        }
    … …  
    53105
    54106
     107
     108        protected void findNextPackage(final Future<WP> future) {
     109                if (!queuedPackages.isEmpty()) {
     110                        WP workPackage = queuedPackages.pollFirst();
     111                        future.pass(workPackage);
     112                        return;
     113                }
     114
     115                generateNextPackage(new FutureHandler<WP>(experiment) {
     116
     117                        @Override
     118                        protected void result(WP result) {
     119                                if (result == null) {
     120                                        log.info("no more packages left");
     121                                        future.pass(null);
     122                                        return;
     123                                }
     124                                future.pass(result);
     125                        }
     126                });
     127        }
     128
    55129        protected abstract void generateNextPackage(Future<WP> future);
     130        protected abstract void returnPackage(WP workPackage);
     131
     132        /**
     133         * @return the newestTaskScheduled
     134         */
     135        @ParamAnnotation(id = "newest_task_sent")
     136        public String getNewestTaskSent() {
     137                return newestTaskSent.get();
     138        }
     139
     140        /**
     141         * @return the newestResultReceived
     142         */
     143        @ParamAnnotation(id = "newest_result_received")
     144        public String getNewestResultReceived() {
     145                return newestResultReceived.get();
     146        }
     147
     148        @ParamAnnotation(id = "newest_task_sent_changed")
     149        public void addNewestTaskSentListener(EventListener<ValueChange> listener) {
     150                newestTaskSent.addListener(listener);
     151        }
     152
     153        @ParamAnnotation(id = "newest_task_sent_changed")
     154        public void removeNewestTaskSentListener(EventListener<ValueChange> listener) {
     155                newestTaskSent.removeListener(listener);
     156        }
     157
     158        @ParamAnnotation(id = "newest_result_received_changed")
     159        public void addNewestResultReceivedListener(EventListener<ValueChange> listener) {
     160                newestResultReceived.addListener(listener);
     161        }
     162
     163        @ParamAnnotation(id = "newest_result_received_changed")
     164        public void removeNewestResultReceivedListener(EventListener<ValueChange> listener) {
     165                newestResultReceived.removeListener(listener);
     166        }
     167
     168        @ParamAnnotation(id = "messages")
     169        public void addMessageListener(EventListener<Message> listener) {
     170                messages.add(listener);
     171        }
     172
     173        @ParamAnnotation(id = "messages")
     174        public void removeMessageListener(EventListener<Message> listener) {
     175                messages.remove(listener);
     176        }
     177
     178
    56179
    57180}
Note: See TracChangeset for help on using the changeset viewer.