org.duracloud.sync.walker.DirWalker Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of synctool Show documentation
There is a newer version: 8.1.0
/*
 * The contents of this file are subject to the license and copyright
 * detailed in the LICENSE and NOTICE files at the root of the source
 * tree and available online at
 *
 *     http://duracloud.org/license/
 */
package org.duracloud.sync.walker;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.apache.commons.io.DirectoryWalker;
import org.duracloud.sync.mgmt.ChangedList;
import org.duracloud.sync.mgmt.FileExclusionManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Handles the walking of a set of directory trees. Each file found in the
 * tree is added to the changed file list. Any files found among the listed
 * directories will also be added to the changed file list. This is the
 * starting point for synchronization.
 *
 * @author: Bill Branan
 * Date: Mar 17, 2010
 */
public class DirWalker extends DirectoryWalker implements Runnable {

    private final Logger logger = LoggerFactory.getLogger(DirWalker.class);

    private static DirWalker dirWalker;
    private boolean continueWalk;

    private List filesAndDirs;

    protected final ChangedList changedList;
    private int files = 0;
    private boolean complete = false;
    protected FileExclusionManager fileExclusionManager;

    protected DirWalker(List filesAndDirs, FileExclusionManager fileExclusionManager) {
        super();
        this.filesAndDirs = filesAndDirs;
        this.changedList = ChangedList.getInstance();
        this.fileExclusionManager = fileExclusionManager;
    }

    public void run() {
        walkDirs();
    }

    public void stopWalk() {
        continueWalk = false;
    }

    protected void walkDirs() {
        try {
            continueWalk = true;
            for (File item : filesAndDirs) {
                if (null != item && item.exists() && continueWalk) {

                    if (item.isDirectory()) { // Directory
                        try {
                            List results = new ArrayList();
                            walk(item, results);
                        } catch (IOException e) {
                            throw new RuntimeException("Error walking directory " +
                                                       item.getAbsolutePath() + ":" + e.getMessage(), e);
                        }
                    } else { // File
                        handleFile(item, 0, null);
                    }
                } else {
                    String filename = "null";
                    if (item != null) {
                        filename = item.getAbsolutePath();
                    }

                    if (!continueWalk) {
                        logger.info("Walk discontinued. Exiting walkDirs routine...");
                        break;
                    }

                    logger.warn("Skipping " + filename +
                                ", as it does not exist");
                }
            }
            logger.info("Found " + files +
                        " files to sync in initial directory walk");

        } catch (Exception e) {
            logger.error("dir walker failed: " + e.getMessage(), e);
        }

        complete = true;
    }

    @Override
    protected boolean handleDirectory(File directory,
                                      int depth,
                                      Collection results)
        throws IOException {
        return !this.fileExclusionManager.isExcluded(directory);
    }

    @Override
    protected void handleFile(File file, int depth, Collection results) {
        if (null == file) {
            logger.warn("The file parameter is unexpectedly null. Ignoring...");
        } else if (!this.fileExclusionManager.isExcluded(file)) {
            if (changedList.addChangedFile(file)) {
                ++files;
            }
        }
    }

    @Override
    protected boolean handleIsCancelled(File file,
                                        int depth,
                                        Collection results) throws IOException {
        return !continueWalk;
    }

    public static DirWalker start(List topDirs, FileExclusionManager fileExclusionManager) {
        dirWalker = new DirWalker(topDirs, fileExclusionManager);
        (new Thread(dirWalker)).start();
        return dirWalker;
    }

    public boolean walkComplete() {
        return complete;
    }

    public int getFilesCount() {
        return files;
    }

}