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

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

commit eee22960dc740aa285f6e2a3a445e258373c8c1a
Author: Torsten Liermann <[email protected]>
AuthorDate: Fri Oct 23 10:52:28 2026 +0200

    GH-2225: Preserve existing mirror selections
    
    Preserve mirrors already selected for build-supplied repositories while 
retaining session authentication, proxy and merge processing. Keep mirror 
selection for remote descriptor repositories. Document both API and SPI 
contracts and cover repeated selection, merging, blocking and session changes 
with regression tests.
---
 .../java/org/eclipse/aether/RepositorySystem.java  |   2 +
 .../aether/impl/RemoteRepositoryManager.java       |   4 +
 .../impl/DefaultRemoteRepositoryManager.java       |   4 +-
 .../impl/DefaultRemoteRepositoryManagerTest.java   | 123 +++++++++++++++++++++
 .../internal/impl/DefaultRepositorySystemTest.java |  55 +++++++++
 5 files changed, 187 insertions(+), 1 deletion(-)

diff --git 
a/maven-resolver-api/src/main/java/org/eclipse/aether/RepositorySystem.java 
b/maven-resolver-api/src/main/java/org/eclipse/aether/RepositorySystem.java
index 108d5e0ee..70c74e5c3 100644
--- a/maven-resolver-api/src/main/java/org/eclipse/aether/RepositorySystem.java
+++ b/maven-resolver-api/src/main/java/org/eclipse/aether/RepositorySystem.java
@@ -299,6 +299,8 @@ public interface RepositorySystem extends Closeable {
      * to already carry any required authentication or proxy configuration. 
This method can be used to apply the
      * authentication/proxy configuration from a session to a bare repository 
definition to obtain the complete
      * repository definition for use in the resolution request.
+     * Repositories that already list mirrored repositories are not subjected 
to mirror selection again, while proxy
+     * and authentication selection still apply.
      *
      * @param session      The repository system session from which to 
configure the repositories, must not be
      *                     {@code null}.
diff --git 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/impl/RemoteRepositoryManager.java
 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/impl/RemoteRepositoryManager.java
index 2371f517d..b18677bfe 100644
--- 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/impl/RemoteRepositoryManager.java
+++ 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/impl/RemoteRepositoryManager.java
@@ -43,6 +43,8 @@ public interface RemoteRepositoryManager {
      * @param recessiveRepositories The remote repositories to merge into the 
existing list, must not be {@code null}.
      * @param recessiveIsRaw {@code true} if the recessive repository 
definitions have not yet been subjected to mirror,
      *            proxy and authentication settings, {@code false} otherwise.
+     *            Repositories that already list mirrored repositories are not 
subjected to mirror selection again,
+     *            while proxy and authentication selection still apply.
      * @return The aggregated list of remote repositories, never {@code null}.
      * @see RepositorySystemSession#getMirrorSelector()
      * @see RepositorySystemSession#getProxySelector()
@@ -75,6 +77,8 @@ public interface RemoteRepositoryManager {
      * @param recessiveRepositories The remote repositories to merge into the 
existing list, must not be {@code null}.
      * @param recessiveIsRaw {@code true} if the recessive repository 
definitions have not yet been subjected to mirror,
      *            proxy and authentication settings, {@code false} otherwise.
+     *            Repositories that already list mirrored repositories are not 
subjected to mirror selection again
+     *            unless they are declared by a remote artifact descriptor; 
proxy and authentication selection still apply.
      * @param recessiveIsFromDescriptor {@code true} if the recessive 
repository definitions were declared by a remote
      *            artifact descriptor (POM) rather than by the build itself, 
{@code false} otherwise.
      * @return The aggregated list of remote repositories, never {@code null}.
diff --git 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManager.java
 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManager.java
index 2c310d179..18adb4fb9 100644
--- 
a/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManager.java
+++ 
b/maven-resolver-impl/src/main/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManager.java
@@ -138,7 +138,9 @@ public class DefaultRemoteRepositoryManager implements 
RemoteRepositoryManager {
             RemoteRepository repository = recessiveRepository;
             boolean mirrored = false;
 
-            if (recessiveIsRaw) {
+            if (recessiveIsRaw
+                    && (recessiveIsFromDescriptor
+                            || 
recessiveRepository.getMirroredRepositories().isEmpty())) {
                 RemoteRepository mirrorRepository = 
mirrorSelector.getMirror(recessiveRepository);
 
                 if (mirrorRepository != null) {
diff --git 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManagerTest.java
 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManagerTest.java
index b891266ba..344790cc0 100644
--- 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManagerTest.java
+++ 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRemoteRepositoryManagerTest.java
@@ -34,9 +34,12 @@ import org.eclipse.aether.repository.ProxySelector;
 import org.eclipse.aether.repository.RemoteRepository;
 import org.eclipse.aether.repository.RepositoryPolicy;
 import org.eclipse.aether.util.repository.AuthenticationBuilder;
+import org.eclipse.aether.util.repository.DefaultMirrorSelector;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static java.util.Objects.requireNonNull;
 import static org.junit.jupiter.api.Assertions.*;
@@ -213,6 +216,126 @@ public class DefaultRemoteRepositoryManagerTest {
         assertEqual(recessive1, result.get(1));
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {"external:*", "*"})
+    void testAggregateMirrorRepos_PreparedMirrorIsNotMirroredAgain(String 
corporatePattern) {
+        session.setMirrorSelector(new DefaultMirrorSelector()
+                .add("central-exception", 
"https://central-exception.invalid/";, "test", false, false, "central", "*")
+                .add("corporate", "https://corporate.invalid/";, "test", false, 
false, corporatePattern, "*"));
+        RemoteRepository central = newRepo(
+                        "central",
+                        "https://repo.maven.apache.org/maven2";,
+                        true,
+                        RepositoryPolicy.UPDATE_POLICY_DAILY,
+                        RepositoryPolicy.CHECKSUM_POLICY_WARN)
+                .build();
+        RemoteRepository other = newRepo(
+                        "other",
+                        "https://other.invalid/";,
+                        true,
+                        RepositoryPolicy.UPDATE_POLICY_DAILY,
+                        RepositoryPolicy.CHECKSUM_POLICY_WARN)
+                .build();
+        List<RemoteRepository> prepared =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(central), true);
+        assertEquals("central-exception", prepared.get(0).getId());
+
+        List<RemoteRepository> result = manager.aggregateRepositories(
+                session, Collections.emptyList(), 
Arrays.asList(prepared.get(0), other), true);
+
+        assertEquals(2, result.size());
+        assertEqual(prepared.get(0), result.get(0));
+        assertEquals(Arrays.asList(central), 
result.get(0).getMirroredRepositories());
+        assertEquals("corporate", result.get(1).getId());
+        assertEquals(Arrays.asList(other), 
result.get(1).getMirroredRepositories());
+    }
+
+    @Test
+    void testAggregateMirrorRepos_PreparedWildcardMirrorIsNotMirroredAgain() {
+        session.setMirrorSelector(
+                new DefaultMirrorSelector().add("corp", 
"https://corp.invalid/";, "test", false, false, "*", "*"));
+        RemoteRepository central = new RemoteRepository.Builder("central", 
"test", "https://central.invalid/";).build();
+        List<RemoteRepository> prepared =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(central), true);
+
+        List<RemoteRepository> result = manager.aggregateRepositories(session, 
Collections.emptyList(), prepared, true);
+
+        assertEquals("corp", result.get(0).getId());
+        assertEquals(Arrays.asList(central), 
result.get(0).getMirroredRepositories());
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void testAggregateMirrorRepos_PreparedMirrorsAreMerged(boolean 
prepareOther) {
+        session.setMirrorSelector(
+                new DefaultMirrorSelector().add("corp", 
"https://corp.invalid/";, "test", false, false, "*", "*"));
+        RemoteRepository central = new RemoteRepository.Builder("central", 
"test", "https://central.invalid/";).build();
+        RemoteRepository other = new RemoteRepository.Builder("other", "test", 
"https://other.invalid/";).build();
+        List<RemoteRepository> prepared =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(central), true);
+        RemoteRepository second = prepareOther
+                ? manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(other), true)
+                        .get(0)
+                : other;
+
+        List<RemoteRepository> result = manager.aggregateRepositories(
+                session, Collections.emptyList(), 
Arrays.asList(prepared.get(0), second), true);
+
+        assertEquals(1, result.size());
+        assertEquals("corp", result.get(0).getId());
+        assertEquals(Arrays.asList(central, other), 
result.get(0).getMirroredRepositories());
+    }
+
+    @Test
+    void testAggregateMirrorRepos_PreparedHttpMirrorIsNotBlockedAgain() {
+        session.setMirrorSelector(new DefaultMirrorSelector()
+                .add("corp-http", "http://corp.invalid/";, "test", false, 
false, "central", "*")
+                .add("maven-default-http-blocker", "http://0.0.0.0/";, "test", 
false, true, "external:http:*", "*"));
+        RemoteRepository central = new RemoteRepository.Builder("central", 
"test", "https://central.invalid/";).build();
+        List<RemoteRepository> prepared =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(central), true);
+
+        List<RemoteRepository> result = manager.aggregateRepositories(session, 
Collections.emptyList(), prepared, true);
+
+        assertEquals("corp-http", result.get(0).getId());
+        assertFalse(result.get(0).isBlocked());
+        assertEquals(Arrays.asList(central), 
result.get(0).getMirroredRepositories());
+    }
+
+    @Test
+    void testAggregateMirrorRepos_PreparedBlockedMirrorRemainsBlocked() {
+        session.setMirrorSelector(new DefaultMirrorSelector()
+                .add("corp", "https://corp.invalid/";, "test", false, false, 
"external:*,!foo", "*")
+                .add("maven-default-http-blocker", "http://0.0.0.0/";, "test", 
false, true, "external:http:*", "*"));
+        RemoteRepository foo = new RemoteRepository.Builder("foo", "test", 
"http://foo.invalid/";).build();
+        List<RemoteRepository> prepared =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(foo), true);
+        assertTrue(prepared.get(0).isBlocked());
+
+        List<RemoteRepository> result = manager.aggregateRepositories(session, 
Collections.emptyList(), prepared, true);
+
+        assertTrue(result.get(0).isBlocked());
+        assertEquals("maven-default-http-blocker", result.get(0).getId());
+        assertEquals(Arrays.asList(foo), 
result.get(0).getMirroredRepositories());
+    }
+
+    @Test
+    void testAggregateMirrorRepos_DescriptorMirrorStillUsesSessionMirrors() {
+        session.setMirrorSelector(
+                new DefaultMirrorSelector().add("corp", 
"https://corp.invalid/";, "test", false, false, "*", "*"));
+        RemoteRepository central = new RemoteRepository.Builder("central", 
"test", "https://central.invalid/";).build();
+        List<RemoteRepository> prepared =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), Arrays.asList(central), true);
+        session.setMirrorSelector(
+                new DefaultMirrorSelector().add("blocked", "http://0.0.0.0/";, 
"test", false, true, "*", "*"));
+
+        List<RemoteRepository> result =
+                manager.aggregateRepositories(session, 
Collections.emptyList(), prepared, true, true);
+
+        assertEquals("blocked", result.get(0).getId());
+        assertTrue(result.get(0).isBlocked());
+    }
+
     @Test
     void testAggregateMirrorRepos_DominantMirrorComplete() {
         RemoteRepository dominant1 = newRepo("a", "http://";, false, "", 
"").build();
diff --git 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRepositorySystemTest.java
 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRepositorySystemTest.java
index ff033e0b6..71857f7ca 100644
--- 
a/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRepositorySystemTest.java
+++ 
b/maven-resolver-impl/src/test/java/org/eclipse/aether/internal/impl/DefaultRepositorySystemTest.java
@@ -40,6 +40,8 @@ import 
org.eclipse.aether.util.repository.DefaultMirrorSelector;
 import org.eclipse.aether.util.repository.DefaultProxySelector;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.*;
 import static org.mockito.Mockito.mock;
@@ -108,6 +110,59 @@ public class DefaultRepositorySystemTest {
         assertSame(auth, resolveRepo.getAuthentication());
     }
 
+    @ParameterizedTest
+    @ValueSource(strings = {"external:*", "*"})
+    void testNewResolutionRepositories_PreparedMirrorIsNotMirroredAgain(String 
corporatePattern) {
+        session.setMirrorSelector(new DefaultMirrorSelector()
+                .add("central-exception", 
"https://central-exception.invalid/";, "default", false, false, "central", "*")
+                .add("corporate", "https://corporate.invalid/";, "default", 
false, false, corporatePattern, "*"));
+        Authentication auth = new 
AuthenticationBuilder().addUsername("user").build();
+        session.setAuthenticationSelector(new 
DefaultAuthenticationSelector().add("central-exception", auth));
+        Proxy proxy = new Proxy("http", "localhost", 8080);
+        session.setProxySelector(new DefaultProxySelector().add(proxy, null));
+        RemoteRepository central =
+                new RemoteRepository.Builder("central", "default", 
"https://repo.maven.apache.org/maven2";).build();
+        List<RemoteRepository> prepared = 
system.newResolutionRepositories(session, Collections.singletonList(central));
+        assertEquals("central-exception", prepared.get(0).getId());
+
+        List<RemoteRepository> result = 
system.newResolutionRepositories(session, prepared);
+
+        assertEquals(prepared, result);
+        assertEquals(Collections.singletonList(central), 
result.get(0).getMirroredRepositories());
+        assertSame(auth, result.get(0).getAuthentication());
+        assertSame(proxy, result.get(0).getProxy());
+    }
+
+    @Test
+    void 
testNewResolutionRepositories_PreparedMirrorKeepsSelectionAfterSessionChange() {
+        session.setMirrorSelector(new DefaultMirrorSelector()
+                .add("corp", "https://corp.invalid/";, "default", true, false, 
"central", "*"));
+        RemoteRepository central =
+                new RemoteRepository.Builder("central", "default", 
"https://central.invalid/";).build();
+        List<RemoteRepository> prepared = 
system.newResolutionRepositories(session, Collections.singletonList(central));
+        DefaultRepositorySystemSession changedSession = new 
DefaultRepositorySystemSession(session);
+        changedSession.setMirrorSelector(
+                new DefaultMirrorSelector().add("blocked", "http://0.0.0.0/";, 
"default", false, true, "*", "*"));
+        Authentication auth =
+                new AuthenticationBuilder().addUsername("new-user").build();
+        changedSession.setAuthenticationSelector(new 
DefaultAuthenticationSelector().add("corp", auth));
+        Proxy proxy = new Proxy("http", "new-proxy.invalid", 8080);
+        changedSession.setProxySelector(new DefaultProxySelector().add(proxy, 
null));
+
+        List<RemoteRepository> result = 
system.newResolutionRepositories(changedSession, prepared);
+
+        assertEquals(1, result.size());
+        assertEquals("corp", result.get(0).getId());
+        assertEquals("https://corp.invalid/";, result.get(0).getUrl());
+        assertTrue(result.get(0).isRepositoryManager());
+        assertFalse(result.get(0).isBlocked());
+        assertEquals(Collections.singletonList(central), 
result.get(0).getMirroredRepositories());
+        assertSame(auth, result.get(0).getAuthentication());
+        assertSame(proxy, result.get(0).getProxy());
+        assertNull(prepared.get(0).getAuthentication());
+        assertNull(prepared.get(0).getProxy());
+    }
+
     @Test
     void testNewDeploymentRepository() {
         Proxy proxy = new Proxy("http", "localhost", 8080);

Reply via email to