source: java/main/src/main/java/com/framsticks/remote/RecursiveFetcher.java @ 105

package com.framsticks.remote;


import com.framsticks.params.Access;
import com.framsticks.params.CompositeParam;
import com.framsticks.structure.Node;
import com.framsticks.structure.Path;
import com.framsticks.structure.Tree;
import com.framsticks.util.dispatching.FutureHandler;
import com.framsticks.util.dispatching.Future;
import com.framsticks.util.dispatching.ThrowExceptionHandler;
import com.framsticks.util.FramsticksException;
import com.framsticks.util.Logging;
import com.framsticks.util.Stopwatch;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.LogManager;

import static com.framsticks.structure.TreeOperations.*;
import static com.framsticks.util.lang.Containers.filterInstanceof;
import com.framsticks.util.dispatching.RunAt;

/**
 * @author Piotr Sniegowski
 */
public class RecursiveFetcher {

        private final static Logger log = LogManager.getLogger(RecursiveFetcher.class.getName());

        protected final Tree tree;
        protected final FutureHandler<Void> future;
        protected int dispatched;
        protected final Stopwatch stopwatch = new Stopwatch();

        public RecursiveFetcher(Tree tree, final Path path, FutureHandler<Void> future) {
                this.tree = tree;
                this.future = future;
                dispatched = 1;
                process(path);
        }

        protected void finished() {
                assert tree.isActive();
                log.info("recursively fetched in {}", stopwatch);
                future.pass(null);
        }

        protected void process(final Path path) {
                assert tree.isActive();
                if (path == null || !path.isResolved()) {
                        log.warn("path {} is not resolved - skipping", path);
                } else {
                        Access access = bindAccess(path);
                        for (CompositeParam p : filterInstanceof(access.getParams(), CompositeParam.class)) {
                                Object child = access.get(p, Object.class);
                                final Path childPath = path.appendNode(new Node(path.getTree(), p, child));
                                if (childPath.isResolved() && getInfoFromCache(childPath) != null) {
                                        ++dispatched;
                                        tree.dispatch(new RunAt<Tree>(ThrowExceptionHandler.getInstance()) {
                                                @Override
                                                protected void runAt() {
                                                        fetch(childPath);
                                                }
                                        });
                                        continue;
                                }
                                ++dispatched;
                                tree.get(childPath, new Future<Path>(Logging.logger(log, "resolve", RecursiveFetcher.this)) {
                                        @Override
                                        protected void result(Path result) {
                                                assert tree.isActive();
                                                fetch(result);
                                        }
                                });
                        }
                }
                --dispatched;
                if (dispatched == 0) {
                        finished();
                }
        }

        protected void fetch(final Path path) {
                tree.get(path, new FutureHandler<Path>() {

                        @Override
                        public void handle(FramsticksException e) {
                                log.error("failed to fetch values for {}: ", path, e);
                                process(null);
                        }

                        @Override
                        protected void result(Path result) {
                                process(result);
                        }
                });
        }

}