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

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

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

    GH-2225: Preserve existing mirror selections
    
    Backport mirror preservation and regression tests to the 1.9.x line using 
JUnit 4. Retain mirror selection for remote descriptor repositories, 
authentication and proxy processing. Document the API and SPI contracts.
---
 .../java/org/eclipse/aether/RepositorySystem.java  |   2 +
 .../aether/impl/RemoteRepositoryManager.java       |   4 +
 .../impl/DefaultRemoteRepositoryManager.java       |   4 +-
 .../impl/DefaultRemoteRepositoryManagerTest.java   | 132 +++++++++++++++++++++
 .../internal/impl/DefaultRepositorySystemTest.java |  67 +++++++++++
 5 files changed, 208 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 61a612e21..8141b644f 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
@@ -245,6 +245,8 @@ public interface RepositorySystem {
      * 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 f5b21fa31..1bac51439 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()
@@ -73,6 +75,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 ced4a7fd2..b48a73788 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
@@ -167,7 +167,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 92624f07e..846b24da6 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,12 +34,14 @@ 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.After;
 import org.junit.Before;
 import org.junit.Test;
 
 import static java.util.Objects.requireNonNull;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
@@ -140,6 +142,136 @@ public class DefaultRemoteRepositoryManagerTest {
         assertEqual(recessive1, result.get(1));
     }
 
+    @Test
+    public void testAggregateMirrorReposPreparedMirrorIsNotMirroredAgain() {
+        for (String corporatePattern : Arrays.asList("external:*", "*")) {
+            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
+    public void 
testAggregateMirrorReposPreparedWildcardMirrorIsNotMirroredAgain() {
+        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());
+    }
+
+    @Test
+    public void testAggregateMirrorReposPreparedMirrorsAreMerged() {
+        for (boolean prepareOther : new boolean[] {false, true}) {
+            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
+    public void testAggregateMirrorReposPreparedHttpMirrorIsNotBlockedAgain() {
+        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
+    public void testAggregateMirrorReposPreparedBlockedMirrorRemainsBlocked() {
+        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
+    public void 
testAggregateMirrorReposDescriptorMirrorStillUsesSessionMirrors() {
+        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
     public void testAggregateMirrorReposDominantMirrorComplete() {
         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 f1510f8e8..627a449df 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
@@ -19,6 +19,7 @@
 package org.eclipse.aether.internal.impl;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 
 import org.eclipse.aether.DefaultRepositorySystemSession;
@@ -34,8 +35,11 @@ import org.junit.Before;
 import org.junit.Test;
 
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
 
 public class DefaultRepositorySystemTest {
 
@@ -86,6 +90,69 @@ public class DefaultRepositorySystemTest {
         assertSame(auth, resolveRepo.getAuthentication());
     }
 
+    @Test
+    public void 
testNewResolutionRepositoriesPreparedMirrorIsNotMirroredAgain() {
+        for (String corporatePattern : Arrays.asList("external:*", "*")) {
+            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
+    public void 
testNewResolutionRepositoriesPreparedMirrorKeepsSelectionAfterSessionChange() {
+        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
     public void testNewDeploymentRepository() {
         Proxy proxy = new Proxy("http", "localhost", 8080);

Reply via email to