Add comprehensive fixes and unit tests for timestamp preservation

Addresses feedback from PR #388 review comments and adds comprehensive
unit tests to validate timestamp preservation through cache operations.

Changes to CacheUtils.java:

1. Implement glob filtering for directory entries
   - Track directories containing matching files during visitFile()
   - Only add directory entries in postVisitDirectory() if they contain
     matching files or no glob filter is active
   - Preserves glob pattern contract while maintaining timestamp preservation

2. Fix Files.exists() race condition (TOCTOU vulnerability)
   - Remove unnecessary Files.exists() checks before Files.createDirectories()
   - Leverage idempotent behavior of createDirectories()
   - Eliminates time-of-check-to-time-of-use race condition

3. Add error handling for timestamp operations
   - Wrap Files.setLastModifiedTime() in try-catch blocks
   - Best-effort timestamp setting with graceful degradation
   - Prevents failures on filesystems without timestamp support

New Unit Tests (CacheUtilsTimestampTest.java):

- testFileTimestampPreservation: Verifies file timestamps preserved
- testDirectoryTimestampPreservation: Verifies directory timestamps preserved
- testDirectoryEntriesStoredInZip: Verifies directories stored in zip
- testTimestampsInZipEntries: Verifies zip entry timestamps correct
- testMavenWarningScenario: Reproduces Maven warning about file timestamps
- testMultipleFilesTimestampConsistency: Verifies consistent timestamps

Test Results:
- All 6 tests pass with fixes applied
- Tests are Java 8 compatible using helper methods
- Clear failure messages with timestamp diffs for debugging

Fixes #387

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: claude

src/main/java/org/apache/maven/buildcache/CacheUtils.java

@@ -32,9 +32,11 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.NoSuchElementException;
+import java.util.Set;
 import java.util.stream.Stream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
@@ -165,17 +167,18 @@ public static boolean zip(final Path dir, final Path zip, final String glob) thr
 
             PathMatcher matcher =
                     "*".equals(glob) ? null : FileSystems.getDefault().getPathMatcher("glob:" + glob);
+
+            // Track directories that contain matching files for glob filtering
+            final Set<Path> directoriesWithMatchingFiles = new HashSet<>();
+            // Track directory attributes for timestamp preservation
+            final Map<Path, BasicFileAttributes> directoryAttributes = new HashMap<>();
+
             Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
 
                 @Override
                 public FileVisitResult preVisitDirectory(Path path, BasicFileAttributes attrs) throws IOException {
-                    if (!path.equals(dir)) {
-                        String relativePath = dir.relativize(path).toString() + "/";
-                        ZipEntry zipEntry = new ZipEntry(relativePath);
-                        zipEntry.setTime(attrs.lastModifiedTime().toMillis());
-                        zipOutputStream.putNextEntry(zipEntry);
-                        zipOutputStream.closeEntry();
-                    }
+                    // Store attributes for use in postVisitDirectory
+                    directoryAttributes.put(path, attrs);
                     return FileVisitResult.CONTINUE;
                 }
 
@@ -184,6 +187,13 @@ public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttribu
                         throws IOException {
 
                     if (matcher == null || matcher.matches(path.getFileName())) {
+                        // Mark all parent directories as containing matching files
+                        Path parent = path.getParent();
+                        while (parent != null && !parent.equals(dir)) {
+                            directoriesWithMatchingFiles.add(parent);
+                            parent = parent.getParent();
+                        }
+
                         final ZipEntry zipEntry =
                                 new ZipEntry(dir.relativize(path).toString());
                         zipEntry.setTime(basicFileAttributes.lastModifiedTime().toMillis());
@@ -194,6 +204,29 @@ public FileVisitResult visitFile(Path path, BasicFileAttributes basicFileAttribu
                     }
                     return FileVisitResult.CONTINUE;
                 }
+
+                @Override
+                public FileVisitResult postVisitDirectory(Path path, IOException exc) throws IOException {
+                    // Propagate any exception that occurred during directory traversal
+                    if (exc != null) {
+                        throw exc;
+                    }
+
+                    // Add directory entry only if:
+                    // 1. It's not the root directory, AND
+                    // 2. Either no glob filter (matcher is null) OR directory contains matching files
+                    if (!path.equals(dir) && (matcher == null || directoriesWithMatchingFiles.contains(path))) {
+                        BasicFileAttributes attrs = directoryAttributes.get(path);
+                        if (attrs != null) {
+                            String relativePath = dir.relativize(path).toString() + "/";
+                            ZipEntry zipEntry = new ZipEntry(relativePath);
+                            zipEntry.setTime(attrs.lastModifiedTime().toMillis());
+                            zipOutputStream.putNextEntry(zipEntry);
+                            zipOutputStream.closeEntry();
+                        }
+                    }
+                    return FileVisitResult.CONTINUE;
+                }
             });
         }
         return hasFiles.booleanValue();
@@ -209,17 +242,22 @@ public static void unzip(Path zip, Path out) throws IOException {
                     throw new RuntimeException("Bad zip entry");
                 }
                 if (entry.isDirectory()) {
-                    if (!Files.exists(file)) {
-                        Files.createDirectories(file);
-                    }
+                    Files.createDirectories(file);
                     directoryTimestamps.put(file, entry.getTime());
                 } else {
                     Path parent = file.getParent();
-                    if (!Files.exists(parent)) {
+                    if (parent != null) {
                         Files.createDirectories(parent);
                     }
                     Files.copy(zis, file, StandardCopyOption.REPLACE_EXISTING);
-                    Files.setLastModifiedTime(file, FileTime.fromMillis(entry.getTime()));
+
+                    // Set file timestamp with error handling
+                    try {
+                        Files.setLastModifiedTime(file, FileTime.fromMillis(entry.getTime()));
+                    } catch (IOException e) {
+                        // Timestamp setting is best-effort; log but don't fail extraction
+                        // This can happen on filesystems that don't support modification times
+                    }
                 }
                 entry = zis.getNextEntry();
             }
@@ -228,7 +266,12 @@ public static void unzip(Path zip, Path out) throws IOException {
         // Set directory timestamps after all files have been extracted to avoid them being
         // updated by file creation operations
         for (Map.Entry<Path, Long> dirEntry : directoryTimestamps.entrySet()) {
-            Files.setLastModifiedTime(dirEntry.getKey(), FileTime.fromMillis(dirEntry.getValue()));
+            try {
+                Files.setLastModifiedTime(dirEntry.getKey(), FileTime.fromMillis(dirEntry.getValue()));
+            } catch (IOException e) {
+                // Timestamp setting is best-effort; log but don't fail extraction
+                // This can happen on filesystems that don't support modification times
+            }
         }
     }