@Override public void execute() { // Might be nothing to do if (skip) { return; } // Make sure we are configured correctly Assert.notNull(requests, "requests is null"); // Show how many files we are copying logger.info("Copying {} files", requests.size()); // Perform the file system copy List<CopyFileResult> results = FileSystemUtils.copyFiles(requests); // Store the results in our internal member variable this.results = results; }
/** * Compare 2 directories on the file system and return an object containing the results. All of the files contained in either of the 2 directories get aggregated into 5 * categories. * * <pre> * 1 - Both - Files that exist in both directories * 2 - Different - Files that exist in both directories but who's MD5 checksums do not match * 3 - Identical - Files that exist in both directories with matching MD5 checksums * 4 - Source Dir Only - Files that exist only in the source directory * 5 - Target Dir Only - Files that exist only in the target directory * </pre> * * The 5 lists in <code>DirDiff</code> contain the relative paths to files for each category. */ public static DirDiff getMD5Diff(DirRequest request) { // Do a quick diff (just figures out what files are unique to each directory vs files that are in both) DirDiff diff = getQuickDiff(request); // Do a deep diff // This computes MD5 checksums for any files present in both directories fillInMD5Results(diff); // return the diff result return diff; }
/** * Return a recursive listing of all files in the directory ignoring <code>++/.svn/++</code> and <code>++/.git/++</code> * * @deprecated */ @Deprecated public static List<File> getAllNonScmFiles(File dir) { return getAllNonScmFiles(dir, DEFAULT_SCM_IGNORE_PATTERNS); }
public static SyncResult syncFiles(SyncRequest request) throws IOException { logger.info("Sync [{}] -> [{}]", request.getSrcDir(), request.getDstDir()); List<File> dstFiles = getAllNonScmFiles(request.getDstDir()); List<File> srcFiles = request.getSrcFiles(); List<String> dstPaths = getRelativePaths(request.getDstDir(), dstFiles); List<String> srcPaths = getRelativePaths(request.getSrcDir(), srcFiles); List<String> adds = new ArrayList<String>(); List<String> updates = new ArrayList<String>(); List<String> deletes = new ArrayList<String>(); for (String srcPath : srcPaths) { boolean existing = dstPaths.contains(srcPath); if (existing) { updates.add(srcPath); } else { adds.add(srcPath); } } for (String dstPath : dstPaths) { boolean extra = !srcPaths.contains(dstPath); if (extra) { deletes.add(dstPath); } } copyFiles(request.getSrcDir(), request.getSrcFiles(), request.getDstDir()); SyncResult result = new SyncResult(); result.setAdds(getFullPaths(request.getDstDir(), adds)); result.setUpdates(getFullPaths(request.getDstDir(), updates)); result.setDeletes(getFullPaths(request.getDstDir(), deletes)); return result; }
@Override public List<SyncResult> sync(List<DirRequest> requests) { logger.info("Synchronizing {} directories", requests.size()); for (DirRequest request : requests) { String src = FileSystemUtils.getRelativePathQuietly(request.getRelativeDir(), request.getSourceDir()); String dst = FileSystemUtils.getRelativePathQuietly(request.getRelativeDir(), request.getTargetDir()); logger.info(" [{}] -> [{}]", src, dst); } // Scan the file system and record the differences between the directories. // This does a deep, heavy, scan of both directories. // It recursively examines the contents of both directories. // Files that exist in both, are compared for equality using an MD5 checksum List<DirDiff> diffs = getDiffs(requests); // Use the diff info to generate a list of files to copy List<CopyFileRequest> copyRequests = getCopyFileRequests(diffs); // Show how many files we are copying if (copyRequests.size() > 0) { logger.info("Copying {} files", copyRequests.size()); } // Copy the files and record the results List<CopyFileResult> copyResults = FileSystemUtils.copyFiles(copyRequests); // Log the number of files copied logger.debug("Copied {} files", copyResults.size()); // Convert the diff information into sync information (adds, deletes, updates) List<SyncResult> results = getSyncResults(diffs); // return the sync info return results; }
protected static void fillInMD5Results(DirDiff diff) { List<File> sources = getFullPaths(diff.getSourceDir(), diff.getBoth()); List<File> targets = getFullPaths(diff.getTargetDir(), diff.getBoth()); List<MD5Result> results = getMD5Results(sources, targets); List<MD5Result> different = new ArrayList<MD5Result>(); List<MD5Result> identical = new ArrayList<MD5Result>(); for (MD5Result md5Result : results) { String sourceChecksum = md5Result.getSourceChecksum(); String targetChecksum = md5Result.getTargetChecksum(); Assert.notNull(sourceChecksum, "sourceChecksum is null"); Assert.notNull(targetChecksum, "targetChecksum is null"); if (StringUtils.equals(sourceChecksum, targetChecksum)) { identical.add(md5Result); } else { different.add(md5Result); } } // diff.setDifferent(different); diff.setIdentical(identical); }
public static DirDiff getQuickDiff(DirRequest request) { // Get a listing of files from both directories using the exact same includes/excludes List<File> sourceFiles = getFiles(request.getSourceDir(), request.getIncludes(), request.getExcludes()); List<File> targetFiles = getFiles(request.getTargetDir(), request.getIncludes(), request.getExcludes()); // Get the unique set of paths for each file relative to their parent directory Set<String> sourcePaths = new HashSet<String>(getRelativePaths(request.getSourceDir(), sourceFiles)); Set<String> targetPaths = new HashSet<String>(getRelativePaths(request.getTargetDir(), targetFiles)); // Paths that exist in both directories Set<String> both = SetUtils.intersection(sourcePaths, targetPaths); // Paths that exist in source but not target Set<String> sourceOnly = SetUtils.difference(sourcePaths, targetPaths); // Paths that exist in target but not source Set<String> targetOnly = SetUtils.difference(targetPaths, sourcePaths); logger.debug("source={}, sourceOnly.size()={}", request.getSourceDir(), sourceOnly.size()); logger.debug("target={}, targetOnly.size()={}", request.getTargetDir(), targetOnly.size()); // Store the information we've collected into a result object DirDiff result = new DirDiff(request.getSourceDir(), request.getTargetDir()); // Store the relative paths on the diff object result.setBoth(new ArrayList<String>(both)); result.setSourceDirOnly(new ArrayList<String>(sourceOnly)); result.setTargetDirOnly(new ArrayList<String>(targetOnly)); // Sort the relative paths Collections.sort(result.getBoth()); Collections.sort(result.getSourceDirOnly()); Collections.sort(result.getTargetDirOnly()); // return the diff return result; }
public static List<File> getSortedFullPaths(File dir, List<String> relativePaths) { List<File> files = getFullPaths(dir, relativePaths); Collections.sort(files); return files; }
@Deprecated public static DirectoryDiff getDiff(File dir1, File dir2, List<String> includes, List<String> excludes) { DirectoryDiffRequest request = new DirectoryDiffRequest(); request.setDir1(dir1); request.setDir2(dir2); request.setIncludes(includes); request.setExcludes(excludes); return getDiff(request); }
@Override public List<DirDiff> getDiffs(List<DirRequest> requests) { List<DirDiff> diffs = new ArrayList<DirDiff>(); for (DirRequest request : requests) { DirDiff diff = FileSystemUtils.getMD5Diff(request); diffs.add(diff); } return diffs; }
public static List<MD5Result> getMD5Results(List<File> sources, List<File> targets) { Assert.isTrue(sources.size() == targets.size(), "lists are not the same size"); List<MD5Result> results = new ArrayList<MD5Result>(); for (int i = 0; i < sources.size(); i++) { File source = sources.get(i); File target = targets.get(i); MD5Result md5Result = getMD5Result(source, target); results.add(md5Result); } return results; }
public static List<CopyFileResult> copyFiles(List<CopyFileRequest> requests) { List<CopyFileResult> results = new ArrayList<CopyFileResult>(); for (CopyFileRequest request : requests) { CopyFileResult result = copyFile(request.getSource(), request.getDestination()); results.add(result); } return results; }
public static List<File> getFullPaths(File dir, Set<String> relativePaths) { return getFullPaths(dir, new ArrayList<String>(relativePaths)); }
DirectoryDiff diff = getDiff(diffRequest);
protected SyncResult getSyncResult(DirDiff diff) { List<File> adds = FileSystemUtils.getFullPaths(diff.getTargetDir(), diff.getSourceDirOnly()); List<File> deletes = FileSystemUtils.getFullPaths(diff.getTargetDir(), diff.getTargetDirOnly()); List<File> updates = new ArrayList<File>(); for (MD5Result result : diff.getDifferent()) { updates.add(result.getTarget()); } SyncResult result = new SyncResult(); result.setAdds(adds); result.setDeletes(deletes); result.setUpdates(updates); return result; }