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));
+ }
}