This is an automated email from the ASF dual-hosted git repository.

cstamas pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven-resolver.git


The following commit(s) were added to refs/heads/master by this push:
     new 8920b5beb Fix several origin tracking bugs in enhanced LRM (#2238)
8920b5beb is described below

commit 8920b5beb21082a0c8f4ec2da8ec4fe96d188bc0
Author: Tamas Cservenak <[email protected]>
AuthorDate: Tue Nov 3 20:34:11 2026 +0100

    Fix several origin tracking bugs in enhanced LRM (#2238)
    
    Four cases where the enhanced local repository manager accepted a
    cached artifact it should not have:
    
    - The same-id-different-URL fallback in applyTracking matched any
      tracking entry starting with "<id>-". An artifact tracked for
      "central-snapshots" (ID-only or URL-qualified) was accepted for a
      request to "central". The rest of the key must now be exactly one
      SHA-1 hash.
    - add() with a remote repository and null/empty contexts wrote no
      tracking entry. The untracked file was then accepted as locally
      installed. It now records the entry under an empty context.
    - NamedLocksTrackingFileManager.update truncated the tracking file
      before rewriting it. A crash mid-write left an empty file, and every
      artifact in that directory then looked untracked. It now writes a
      collocated temp file and atomically moves it into place.
    - LegacyTrackingFileManager.read treated an unreadable tracking file
      as missing, so the artifact looked untracked. It now checks only
      for existence, so an access error throws.
    
    Each case has a test that fails without the fix.
---
 .../impl/EnhancedLocalRepositoryManager.java       | 19 +++++++++---
 .../internal/impl/LegacyTrackingFileManager.java   |  3 +-
 .../impl/NamedLocksTrackingFileManager.java        | 15 ++++++---
 .../impl/EnhancedLocalRepositoryManagerTest.java   | 36 ++++++++++++++++++++++
 .../impl/LegacyTrackingFileManagerTest.java        | 24 +++++++++++++++
 5 files changed, 87 insertions(+), 10 deletions(-)

diff --git 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManager.java
 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManager.java
index bb6a70535..e26179917 100644
--- 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManager.java
+++ 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManager.java
@@ -29,6 +29,7 @@ import java.util.Map;
 import java.util.Objects;
 import java.util.Properties;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.regex.Pattern;
 
 import org.eclipse.aether.RepositorySystemSession;
 import org.eclipse.aether.artifact.Artifact;
@@ -77,6 +78,8 @@ class EnhancedLocalRepositoryManager extends 
SimpleLocalRepositoryManager {
 
     private static final String LOCAL_REPO_ID = "";
 
+    private static final Pattern SHA1_HEX = Pattern.compile("[0-9a-f]{40}");
+
     /**
      * Shared sentinel for "no tracking data". Mutation is forbidden: the 
instance is shared
      * across threads via {@link #trackingFileCache} and returned directly 
from {@link #readRepos}.
@@ -345,11 +348,12 @@ class EnhancedLocalRepositoryManager extends 
SimpleLocalRepositoryManager {
                 // "central-<sha1(realUrl)>=" but the current build overrides 
central to "file:target/null"),
                 // the exact lookup misses because sha1(realUrl) != 
sha1(file:target/null). Match by repo-ID
                 // prefix: any entry starting with "filename>repoId-" is 
accepted as originating from the same
-                // logical repository.
+                // logical repository. The remainder must be exactly one SHA-1 
hash, otherwise a different repository
+                // whose ID merely starts with "repoId-" (e.g. 
"central-snapshots") would be accepted as well.
                 String repoIdPrefix = getKey(path, legacyKey + "-");
                 for (Object key : props.keySet()) {
                     String k = key.toString();
-                    if (k.startsWith(repoIdPrefix) && !k.equals(getKey(path, 
trackingKey))) {
+                    if (k.startsWith(repoIdPrefix) && 
isSha1(k.substring(repoIdPrefix.length()))) {
                         LOGGER.debug(
                                 "Accepting locally cached artifact {} via 
same-id tracking entry '{}'"
                                         + " (current URL-qualified key would 
be '{}')",
@@ -366,18 +370,25 @@ class EnhancedLocalRepositoryManager extends 
SimpleLocalRepositoryManager {
         return false;
     }
 
+    private static boolean isSha1(String s) {
+        return SHA1_HEX.matcher(s).matches();
+    }
+
     @Override
     public void add(RepositorySystemSession session, LocalArtifactRegistration 
request) {
         Collection<String> repositories;
+        // no contexts would record nothing, leaving the artifact untracked, 
hence later accepted as locally installed
+        Collection<String> contexts =
+                request.getContexts().isEmpty() ? Collections.singleton("") : 
request.getContexts();
         if (request.getRepository() == null) {
             repositories = Collections.singleton(LOCAL_REPO_ID);
         } else {
-            repositories = getRepositoryKeys(request.getRepository(), 
request.getContexts());
+            repositories = getRepositoryKeys(request.getRepository(), 
contexts);
         }
         if (request.getRepository() == null) {
             addArtifact(request.getArtifact(), repositories, null, null);
         } else {
-            for (String context : request.getContexts()) {
+            for (String context : contexts) {
                 addArtifact(request.getArtifact(), repositories, 
request.getRepository(), context);
             }
         }
diff --git 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManager.java
 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManager.java
index f1af28b60..160b5f72c 100644
--- 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManager.java
+++ 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManager.java
@@ -63,7 +63,8 @@ public final class LegacyTrackingFileManager implements 
TrackingFileManager {
 
     @Override
     public Properties read(Path path) {
-        if (Files.isReadable(path)) {
+        // existence, not readability: an unreadable tracking file must fail, 
not read as "untracked"
+        if (Files.exists(path)) {
             synchronized (mutex(path)) {
                 try (FileChannel fileChannel = FileChannel.open(path, 
StandardOpenOption.READ);
                         FileLock unused = fileLock(fileChannel, true)) {
diff --git 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/NamedLocksTrackingFileManager.java
 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/NamedLocksTrackingFileManager.java
index 8eaa5a004..60c3ce460 100644
--- 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/NamedLocksTrackingFileManager.java
+++ 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/NamedLocksTrackingFileManager.java
@@ -34,6 +34,7 @@ import java.util.concurrent.TimeUnit;
 import org.eclipse.aether.named.NamedLock;
 import org.eclipse.aether.named.NamedLockFactory;
 import org.eclipse.aether.named.NamedLockKey;
+import org.eclipse.aether.util.FileUtils;
 import org.eclipse.aether.util.StringDigestUtil;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -128,11 +129,15 @@ public final class NamedLocksTrackingFileManager 
implements TrackingFileManager
                         }
                     }
                     LOGGER.debug("Writing tracking file '{}'", path);
-                    try (OutputStream out = Files.newOutputStream(path)) {
-                        props.store(
-                                out,
-                                "NOTE: This is a Maven Resolver internal 
implementation file"
-                                        + ", its format can be changed without 
prior notice.");
+                    // write atomically: a truncated tracking file would make 
artifacts look untracked
+                    try (FileUtils.CollocatedTempFile tempFile = 
FileUtils.newTempFile(path)) {
+                        try (OutputStream out = 
Files.newOutputStream(tempFile.getPath())) {
+                            props.store(
+                                    out,
+                                    "NOTE: This is a Maven Resolver internal 
implementation file"
+                                            + ", its format can be changed 
without prior notice.");
+                        }
+                        tempFile.move();
                     }
                     return props;
                 } catch (IOException e) {
diff --git 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManagerTest.java
 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManagerTest.java
index 4e71f6ebe..7f7604e52 100644
--- 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManagerTest.java
+++ 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/EnhancedLocalRepositoryManagerTest.java
@@ -26,6 +26,8 @@ import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.eclipse.aether.DefaultRepositorySystemSession;
 import org.eclipse.aether.artifact.Artifact;
@@ -41,6 +43,7 @@ import org.eclipse.aether.repository.LocalArtifactResult;
 import org.eclipse.aether.repository.LocalMetadataRequest;
 import org.eclipse.aether.repository.LocalMetadataResult;
 import org.eclipse.aether.repository.RemoteRepository;
+import org.eclipse.aether.util.StringDigestUtil;
 import org.eclipse.aether.util.repository.RepositoryIdHelper;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -481,4 +484,37 @@ public class EnhancedLocalRepositoryManagerTest {
                 new LocalArtifactRequest(artifact, 
Collections.singletonList(repository), testContext);
         assertFalse(manager.find(session, request).isAvailable());
     }
+
+    @Test
+    void testUrlQualifiedTrackingRejectsEntriesOfRepoIdSharingPrefix() throws 
Exception {
+        manager = newUrlQualifiedTrackingManager();
+        // plain (non repository manager) repository: its legacy key is the 
bare id
+        RemoteRepository central = new RemoteRepository.Builder("central", 
"default", "https://repo.example/";).build();
+
+        // artifact tracked only for repositories whose id merely starts with 
"central-"
+        copy(artifact, manager.getPathForLocalArtifact(artifact));
+        File file = new File(basedir, 
manager.getPathForLocalArtifact(artifact));
+        Map<String, String> entries = new HashMap<>();
+        entries.put(file.getName() + ">central-snapshots", "");
+        entries.put(file.getName() + ">central-snapshots-" + 
StringDigestUtil.sha1("x"), "");
+        trackingFileManager.update(new File(file.getParentFile(), 
"_remote.repositories").toPath(), entries);
+
+        LocalArtifactRequest request =
+                new LocalArtifactRequest(artifact, 
Collections.singletonList(central), testContext);
+        assertFalse(manager.find(session, request).isAvailable());
+    }
+
+    @Test
+    void testAddRemoteWithoutContextsIsTracked() throws Exception {
+        copy(artifact, manager.getPathForRemoteArtifact(artifact, repository, 
testContext));
+        manager.add(session, new LocalArtifactRegistration(artifact, 
repository, null));
+
+        // tracked for "repository" only: must not be accepted as locally 
installed for an unrelated repository
+        RemoteRepository other = new RemoteRepository.Builder("other", 
"default", "https://other.example/";).build();
+        LocalArtifactRequest request = new LocalArtifactRequest(artifact, 
Collections.singletonList(other), null);
+        assertFalse(manager.find(session, request).isAvailable());
+
+        request = new LocalArtifactRequest(artifact, 
Collections.singletonList(repository), null);
+        assertTrue(manager.find(session, request).isAvailable());
+    }
 }
diff --git 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManagerTest.java
 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManagerTest.java
index 1fe55fb8b..e0b41eca5 100644
--- 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManagerTest.java
+++ 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/LegacyTrackingFileManagerTest.java
@@ -18,9 +18,33 @@
  */
 package org.eclipse.aether.internal.impl;
 
+import java.io.UncheckedIOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.attribute.PosixFilePermissions;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
 public class LegacyTrackingFileManagerTest extends 
TrackingFileManagerTestSupport {
     @Override
     protected TrackingFileManager createTrackingFileManager(FS fs) {
         return new LegacyTrackingFileManager();
     }
+
+    @Test
+    void testReadUnreadableFails(@TempDir Path dir) throws Exception {
+        Path file = Files.createFile(dir.resolve("file.properties"));
+        try {
+            Files.setPosixFilePermissions(file, 
PosixFilePermissions.fromString("---------"));
+        } catch (UnsupportedOperationException e) {
+            assumeTrue(false, "POSIX permissions not supported");
+        }
+        assumeTrue(!Files.isReadable(file), "file still readable (running as 
root?)");
+        // an unreadable tracking file must not be reported as missing (i.e. 
"untracked")
+        assertThrows(UncheckedIOException.class, () -> new 
LegacyTrackingFileManager().read(file));
+    }
 }

Reply via email to