Support for ignoring paths

jjlauer · jjlauer · commit aaedc8823512 · 2025-11-26T23:34:41.000-05:00
diff --git a/jsync-engine/src/main/java/com/fizzed/jsync/engine/DefaultJsyncEventHandler.java b/jsync-engine/src/main/java/com/fizzed/jsync/engine/DefaultJsyncEventHandler.java
@@ -25,8 +25,13 @@ public void willEnd(VirtualFileSystem sourceVfs, VirtualPath sourcePath, Virtual
     }
 
     @Override
-    public void willExcludePath(VirtualPath targetPath) {
-        log.debug("Excluding path {}", targetPath);
+    public void willExcludePath(VirtualPath sourcePath) {
+        log.debug("Excluding path {}", sourcePath);
+    }
+
+    @Override
+    public void willIgnorePath(VirtualPath sourcePath) {
+        log.debug("Ignoring path {}", sourcePath);
     }
 
     @Override
diff --git a/jsync-engine/src/main/java/com/fizzed/jsync/engine/JsyncEngine.java b/jsync-engine/src/main/java/com/fizzed/jsync/engine/JsyncEngine.java
@@ -28,8 +28,12 @@ public class JsyncEngine {
     private boolean skipPermissions;
     private int maxFilesMaybeModifiedLimit;
     private List<String> excludes;
+    private List<String> ignores;
     // when running a sync
     private Checksum negotiatedChecksum;
+    private List<VirtualPath> excludePaths;
+    private List<VirtualPath> ignoreSourcePaths;
+    private List<VirtualPath> ignoreTargetPaths;
 
     public JsyncEngine() {
         this.eventHandler = new DefaultJsyncEventHandler();
@@ -40,7 +44,6 @@ public JsyncEngine() {
         this.skipPermissions = false;
         this.preferredChecksums = new ArrayList<>(asList(Checksum.CK, Checksum.MD5));
         this.maxFilesMaybeModifiedLimit = 256;
-        this.excludes = null;
     }
 
     public JsyncEventHandler getEventHandler() {
@@ -134,6 +137,23 @@ public JsyncEngine addExclude(String exclude) {
         return this;
     }
 
+    public List<String> getIgnores() {
+        return ignores;
+    }
+
+    public JsyncEngine setIgnores(List<String> ignores) {
+        this.ignores = ignores;
+        return this;
+    }
+
+    public JsyncEngine addIgnore(String ignore) {
+        if (this.ignores == null) {
+            this.ignores = new ArrayList<>();
+        }
+        this.ignores.add(ignore);
+        return this;
+    }
+
     public JsyncResult sync(Path sourcePath, Path targetPath, JsyncMode mode) throws IOException {
         // local -> local
         final LocalVirtualFileSystem localVfs = LocalVirtualFileSystem.open();
@@ -213,6 +233,30 @@ public JsyncResult sync(VirtualFileSystem sourceVfs, String sourcePath, VirtualF
         // find the best common checksum
         this.negotiatedChecksum = this.negotiateChecksum(sourceVfs, targetVfs);
 
+        // build exclude and ignore paths
+        if (this.excludes != null) {
+            this.excludePaths = this.excludes.stream()
+                .map(VirtualPath::parse)
+                .map(sourcePathAbsFinal::resolve)
+                .collect(toList());
+        } else {
+            this.excludePaths = Collections.emptyList();
+        }
+
+        if (this.ignores != null) {
+            this.ignoreSourcePaths = this.ignores.stream()
+                .map(VirtualPath::parse)
+                .map(sourcePathAbsFinal::resolve)
+                .collect(toList());
+            this.ignoreTargetPaths = this.ignores.stream()
+                .map(VirtualPath::parse)
+                .map(targetPathAbsFinal::resolve)
+                .collect(toList());
+        } else {
+            this.ignoreSourcePaths = Collections.emptyList();
+            this.ignoreTargetPaths = Collections.emptyList();
+        }
+
 
         final long now = System.currentTimeMillis();
 
@@ -239,7 +283,7 @@ public JsyncResult sync(VirtualFileSystem sourceVfs, String sourcePath, VirtualF
             // as we process files, only a subset may require more advanced methods of detecting whether they were modified
             // since that process could be "expensive", we keep a list of files on source/target that we will defer processing
             // until we have a chance to do some bulk processing of checksums, etc.
-            this.syncDirectory(0, result, excludePaths, deferredFiles, sourceVfs, sourcePathAbsFinal, targetVfs, targetPathAbsFinal);
+            this.syncDirectory(0, result, deferredFiles, sourceVfs, sourcePathAbsFinal, targetVfs, targetPathAbsFinal);
         } else {
             // we are only syncing a file, we may need to do some more expensive checks to determine if it needs to be updated
             this.syncFile(result, deferredFiles, sourceVfs, sourcePathAbsFinal, targetVfs, targetPathAbsFinal);
@@ -322,7 +366,7 @@ protected void syncDeferredFiles(JsyncResult result, List<VirtualPathPair> defer
         deferredFiles.clear();
     }
 
-    protected void syncDirectory(int level, JsyncResult result, List<VirtualPath> excludePaths, List<VirtualPathPair> deferredFiles, VirtualFileSystem sourceVfs, VirtualPath sourcePath, VirtualFileSystem targetVfs, VirtualPath targetPath) throws IOException {
+    protected void syncDirectory(int level, JsyncResult result, List<VirtualPathPair> deferredFiles, VirtualFileSystem sourceVfs, VirtualPath sourcePath, VirtualFileSystem targetVfs, VirtualPath targetPath) throws IOException {
 
         // source needs to be a directory
         if (!sourcePath.isDirectory()) {
@@ -365,15 +409,23 @@ protected void syncDirectory(int level, JsyncResult result, List<VirtualPath> ex
         List<VirtualPath> sourceChildPaths = sourceVfs.ls(sourcePath).stream()
             // apply filter to source files if they are on the exclude list
             .filter(v -> {
-                //log.info("Checking for exlcude of path {} with excludes {}", v, excludePaths);
-                for (VirtualPath excludePath : excludePaths) {
-                    if (v.startsWith(excludePath)) {
+                for (VirtualPath p : this.excludePaths) {
+                    if (v.startsWith(p)) {
                         this.eventHandler.willExcludePath(v);
                         return false;
                     }
                 }
                 return true;
             })
+            .filter(v -> {
+                for (VirtualPath p : this.ignoreSourcePaths) {
+                    if (v.startsWith(p)) {
+                        this.eventHandler.willIgnorePath(v);
+                        return false;
+                    }
+                }
+                return true;
+            })
             // apply filter to excluding non-regular files (such as symlinks)
             .filter(v -> {
                 switch (v.getStat().getType()) {
@@ -389,7 +441,16 @@ protected void syncDirectory(int level, JsyncResult result, List<VirtualPath> ex
             })
             .collect(toList());
 
-        final List<VirtualPath> targetChildPaths = targetVfs.ls(targetPath);
+        final List<VirtualPath> targetChildPaths = targetVfs.ls(targetPath).stream()
+            .filter(v -> {
+                for (VirtualPath p : this.ignoreTargetPaths) {
+                    if (v.startsWith(p)) {
+                        return false;
+                    }
+                }
+                return true;
+            })
+            .collect(toList());
 
         // its better to work with all dirs first, then files, so we sort the files before we process them
         this.sortPaths(sourceChildPaths);
@@ -411,7 +472,7 @@ protected void syncDirectory(int level, JsyncResult result, List<VirtualPath> ex
             }
 
             if (sourceChildPath.isDirectory()) {
-                this.syncDirectory(level+1, result, excludePaths, deferredFiles, sourceVfs, sourceChildPath, targetVfs, targetChildPath);
+                this.syncDirectory(level+1, result, deferredFiles, sourceVfs, sourceChildPath, targetVfs, targetChildPath);
             } else {
                 // NOTE: it's possible syncFile will "defer" processing if a checksum is required
                 this.syncFile(result, deferredFiles, sourceVfs, sourceChildPath, targetVfs, targetChildPath);
diff --git a/jsync-engine/src/main/java/com/fizzed/jsync/engine/JsyncEventHandler.java b/jsync-engine/src/main/java/com/fizzed/jsync/engine/JsyncEventHandler.java
@@ -15,6 +15,8 @@ public interface JsyncEventHandler {
 
     void willExcludePath(VirtualPath targetPath);
 
+    void willIgnorePath(VirtualPath targetPath);
+
     void willCreateDirectory(VirtualPath targetPath, boolean recursively);
 
     void willDeleteDirectory(VirtualPath targetPath, boolean recursively);
diff --git a/jsync-engine/src/test/java/com/fizzed/jsync/engine/JsyncEngineTest.java b/jsync-engine/src/test/java/com/fizzed/jsync/engine/JsyncEngineTest.java
@@ -4,6 +4,7 @@
 import com.fizzed.crux.util.Resources;
 import com.fizzed.jsync.vfs.ParentDirectoryMissingException;
 import com.fizzed.jsync.vfs.PathOverwriteException;
+import com.fizzed.jsync.vfs.util.Permissions;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
@@ -19,6 +20,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.within;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 class JsyncEngineTest {
     static private final Logger log = LoggerFactory.getLogger(JsyncEngineTest.class);
@@ -502,6 +504,53 @@ public void syncDirTimestamp() throws Exception {
         assertThat(modifiedTime(targetADir)).isCloseTo(ts, within(2, ChronoUnit.SECONDS));
     }
 
+    @Test
+    public void syncFilePermission() throws Exception {
+        assumeTrue(Permissions.isPosix());
+
+        Path sourceAFile = this.syncSourceDir.resolve("a.txt");
+        Files.write(sourceAFile, "hello".getBytes());
+
+        Path targetAFile = this.syncTargetDir.resolve("a.txt");
+        Files.write(targetAFile, "hello".getBytes());
+
+        Permissions.setPosixInt(sourceAFile, 0755);
+        Permissions.setPosixInt(targetAFile, 0644);
+
+        JsyncResult result = new JsyncEngine()
+            .sync(sourceAFile, this.syncTargetDir, JsyncMode.NEST);
+
+        assertThat(Permissions.getPosixInt(targetAFile)).isEqualTo(0755);
+        assertThat(result.getStatsUpdated()).isEqualTo(1);
+        assertThat(result.getFilesCreated()).isEqualTo(0);
+        assertThat(result.getFilesDeleted()).isEqualTo(0);
+        assertThat(result.getFilesUpdated()).isEqualTo(0);
+    }
+
+    @Test
+    public void syncFileSkipPermissions() throws Exception {
+        assumeTrue(Permissions.isPosix());
+
+        Path sourceAFile = this.syncSourceDir.resolve("a.txt");
+        Files.write(sourceAFile, "hello".getBytes());
+
+        Path targetAFile = this.syncTargetDir.resolve("a.txt");
+        Files.write(targetAFile, "hello".getBytes());
+
+        Permissions.setPosixInt(sourceAFile, 0755);
+        Permissions.setPosixInt(targetAFile, 0644);
+
+        JsyncResult result = new JsyncEngine()
+            .setSkipPermissions(true)
+            .sync(sourceAFile, this.syncTargetDir, JsyncMode.NEST);
+
+        assertThat(Permissions.getPosixInt(targetAFile)).isEqualTo(0644);
+        assertThat(result.getStatsUpdated()).isEqualTo(0);
+        assertThat(result.getFilesCreated()).isEqualTo(0);
+        assertThat(result.getFilesDeleted()).isEqualTo(0);
+        assertThat(result.getFilesUpdated()).isEqualTo(0);
+    }
+
     @Test
     public void syncExcludeDir() throws Exception {
         Path sourceADir = this.syncSourceDir.resolve("a");
@@ -547,4 +596,36 @@ public void syncExcludeNonRegularFiles() throws Exception {
         assertThat(this.syncTargetDir.resolve("a/b.txt")).hasContent("hello");
     }
 
+    @Test
+    public void syncIgnoreDir() throws Exception {
+        Path sourceADir = this.syncSourceDir.resolve("a");
+        Path sourceBFile = this.syncSourceDir.resolve("a/b.txt");
+        this.writeFile(sourceBFile, "hello");
+
+        Path sourceBDir = this.syncSourceDir.resolve("b");
+        Path sourceCFile = this.syncSourceDir.resolve("b/c.txt");
+        Path sourceDFile = this.syncSourceDir.resolve("b/d.txt");
+        this.writeFile(sourceCFile, "hello");
+        this.writeFile(sourceDFile, "hello");
+
+        // with directory "a" fully excluded, it actually should be deleted with --exclude
+        Path targetADir = this.syncTargetDir.resolve("a");
+        Path targetBFile = this.syncTargetDir.resolve("a/b.txt");
+        this.writeFile(targetBFile, "hello");
+        Path targetBDir = this.syncTargetDir.resolve("b");
+        Path targetCDir = this.syncTargetDir.resolve("c");
+        Path targetEFile = this.syncTargetDir.resolve("c/e.txt");
+        this.writeFile(targetEFile, "hello");
+
+        final JsyncResult result = new JsyncEngine()
+            .addIgnore("c")
+            .addIgnore("b")
+            .setDelete(true)
+            .sync(this.syncSourceDir, this.syncTargetDir, JsyncMode.MERGE);
+
+        assertThat(targetADir).isDirectory();
+        assertThat(targetBDir).doesNotExist();
+        assertThat(targetEFile).isRegularFile();
+    }
+
 }
diff --git a/jsync-vfs/src/main/java/com/fizzed/jsync/vfs/LocalVirtualFileSystem.java b/jsync-vfs/src/main/java/com/fizzed/jsync/vfs/LocalVirtualFileSystem.java
@@ -39,18 +39,11 @@ static public LocalVirtualFileSystem open(Path workingDir) {
 
         final VirtualPath pwd = VirtualPath.parse(currentWorkingDir.toString(), true);
 
-        final boolean isPosixAttributes = FileSystems.getDefault()
-            .supportedFileAttributeViews()
-            .contains("posix");
+        final boolean posix = Permissions.isPosix();
 
-        log.debug("Detected filesystem {} has pwd={}, posix={}", name, pwd, isPosixAttributes);
+        log.debug("Detected filesystem {} with pwd={}, posix={}, caseSensitive={}", name, pwd, posix, posix);
 
-        // everything is case-sensitive except windows
-        final boolean caseSensitive = !System.getProperty("os.name").toLowerCase().contains("windows");
-
-        log.debug("Detected filesystem {} is case-sensitive={}", name, caseSensitive);
-
-        return new LocalVirtualFileSystem(name, pwd, caseSensitive, isPosixAttributes);
+        return new LocalVirtualFileSystem(name, pwd, posix, posix);
     }
 
     @Override
@@ -127,17 +120,15 @@ protected VirtualPath withStat(VirtualPath path) throws IOException {
             perms = Permissions.toPosixInt(posixAttrs.permissions());
         } else {
             // use basic permissions, usually ends up being 700 from what I can gather
-            final Set<PosixFilePermission> simulatedPosixPermissions = Permissions.toBasicPermissions(nativePath);
-            perms = Permissions.toPosixInt(simulatedPosixPermissions);
+            final Set<PosixFilePermission> basicPermissions = Permissions.toBasicPermissions(nativePath);
+            perms = Permissions.toPosixInt(basicPermissions);
         }
 
         final VirtualFileStat stat = new VirtualFileStat(type, size, modifiedTime, accessedTime, perms);
 
         return new VirtualPath(path.getParentPath(), path.getName(), type == VirtualFileType.DIR, stat);
     }
 
-
-
     @Override
     public VirtualPath stat(VirtualPath path) throws IOException {
         return this.withStat(path);
diff --git a/jsync-vfs/src/main/java/com/fizzed/jsync/vfs/util/Permissions.java b/jsync-vfs/src/main/java/com/fizzed/jsync/vfs/util/Permissions.java
@@ -2,6 +2,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.attribute.PosixFilePermission;
@@ -11,6 +12,22 @@
 
 public class Permissions {
 
+    static public boolean isPosix() {
+        return FileSystems.getDefault()
+            .supportedFileAttributeViews()
+            .contains("posix");
+    }
+
+    static public int getPosixInt(Path path) throws IOException {
+        final Set<PosixFilePermission> permissions = Files.getPosixFilePermissions(path);
+        return toPosixInt(permissions);
+    }
+
+    static public void setPosixInt(Path path, int perms) throws IOException {
+        final Set<PosixFilePermission> permissions = toPosixFilePermissions(perms);
+        Files.setPosixFilePermissions(path, permissions);
+    }
+
     /**
      * Converts a set of {@link PosixFilePermission} to its corresponding POSIX integer representation.
      * The resulting integer is a bitmask representing the file permission mode.

Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,13 @@ public void willEnd(VirtualFileSystem sourceVfs, VirtualPath sourcePath, Virtual`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Override`
`28`		`- public void willExcludePath(VirtualPath targetPath) {`
`29`		`- log.debug("Excluding path {}", targetPath);`
	`28`	`+ public void willExcludePath(VirtualPath sourcePath) {`
	`29`	`+ log.debug("Excluding path {}", sourcePath);`
	`30`	`+ }`
	`31`	`+`
	`32`	`+ @Override`
	`33`	`+ public void willIgnorePath(VirtualPath sourcePath) {`
	`34`	`+ log.debug("Ignoring path {}", sourcePath);`
`30`	`35`	`}`
`31`	`36`
`32`	`37`	`@Override`