View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.internal.impl;
20  
21  import java.io.File;
22  import java.io.IOException;
23  import java.net.URI;
24  import java.util.Arrays;
25  import java.util.Collection;
26  import java.util.HashMap;
27  import java.util.List;
28  import java.util.Set;
29  import java.util.concurrent.atomic.AtomicInteger;
30  
31  import org.eclipse.aether.DefaultRepositorySystemSession;
32  import org.eclipse.aether.RepositoryEvent;
33  import org.eclipse.aether.RepositoryEvent.EventType;
34  import org.eclipse.aether.SyncContext;
35  import org.eclipse.aether.artifact.Artifact;
36  import org.eclipse.aether.internal.impl.filter.DefaultRemoteRepositoryFilterManager;
37  import org.eclipse.aether.internal.impl.filter.Filters;
38  import org.eclipse.aether.internal.test.util.TestFileUtils;
39  import org.eclipse.aether.internal.test.util.TestLocalRepositoryManager;
40  import org.eclipse.aether.internal.test.util.TestUtils;
41  import org.eclipse.aether.metadata.DefaultMetadata;
42  import org.eclipse.aether.metadata.Metadata;
43  import org.eclipse.aether.repository.LocalMetadataRegistration;
44  import org.eclipse.aether.repository.RemoteRepository;
45  import org.eclipse.aether.repository.RepositoryPolicy;
46  import org.eclipse.aether.resolution.MetadataRequest;
47  import org.eclipse.aether.resolution.MetadataResult;
48  import org.eclipse.aether.spi.connector.ArtifactDownload;
49  import org.eclipse.aether.spi.connector.MetadataDownload;
50  import org.eclipse.aether.spi.connector.filter.RemoteRepositoryFilterSource;
51  import org.eclipse.aether.transfer.MetadataNotFoundException;
52  import org.junit.jupiter.api.AfterEach;
53  import org.junit.jupiter.api.BeforeEach;
54  import org.junit.jupiter.api.Test;
55  import org.junit.jupiter.api.io.TempDir;
56  
57  import static org.junit.jupiter.api.Assertions.assertEquals;
58  import static org.junit.jupiter.api.Assertions.assertFalse;
59  import static org.junit.jupiter.api.Assertions.assertInstanceOf;
60  import static org.junit.jupiter.api.Assertions.assertNotNull;
61  import static org.junit.jupiter.api.Assertions.assertNull;
62  import static org.junit.jupiter.api.Assertions.assertSame;
63  import static org.junit.jupiter.api.Assertions.assertTrue;
64  import static org.junit.jupiter.api.Assertions.fail;
65  
66  public class DefaultMetadataResolverTest {
67  
68      private DefaultMetadataResolver resolver;
69  
70      private StubRepositoryConnectorProvider connectorProvider;
71  
72      private RemoteRepository repository;
73  
74      private DefaultRepositorySystemSession session;
75  
76      private Metadata metadata;
77  
78      private RecordingRepositoryConnector connector;
79  
80      private TestLocalRepositoryManager lrm;
81  
82      private HashMap<String, RemoteRepositoryFilterSource> remoteRepositoryFilterSources;
83  
84      private DefaultRemoteRepositoryFilterManager remoteRepositoryFilterManager;
85  
86      private RecordingRepositoryListener listener;
87  
88      @TempDir
89      private File tempDirectory;
90  
91      @BeforeEach
92      void setup() throws Exception {
93          remoteRepositoryFilterSources = new HashMap<>();
94          remoteRepositoryFilterManager = new DefaultRemoteRepositoryFilterManager(remoteRepositoryFilterSources);
95  
96          session = TestUtils.newSession();
97          lrm = (TestLocalRepositoryManager) session.getLocalRepositoryManager();
98          connectorProvider = new StubRepositoryConnectorProvider();
99          resolver = new DefaultMetadataResolver(
100                 new StubRepositoryEventDispatcher(),
101                 new StaticUpdateCheckManager(true),
102                 connectorProvider,
103                 new StubRemoteRepositoryManager(),
104                 new StubSyncContextFactory(),
105                 new DefaultOfflineController(),
106                 remoteRepositoryFilterManager,
107                 new DefaultPathProcessor());
108         repository = new RemoteRepository.Builder(
109                         "test-DMRT", "default", tempDirectory.toURI().toURL().toString())
110                 .build();
111         metadata = new DefaultMetadata("gid", "aid", "ver", "maven-metadata.xml", Metadata.Nature.RELEASE_OR_SNAPSHOT);
112         connector = new RecordingRepositoryConnector();
113         connectorProvider.setConnector(connector);
114 
115         listener = new RecordingRepositoryListener();
116         session.setRepositoryListener(listener);
117     }
118 
119     @AfterEach
120     void teardown() throws Exception {
121         TestFileUtils.deleteFile(new File(new URI(repository.getUrl())));
122         TestFileUtils.deleteFile(session.getLocalRepository().getBasedir());
123     }
124 
125     @Test
126     void testNoRepositoryFailing() {
127         MetadataRequest request = new MetadataRequest(metadata, null, "");
128         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
129 
130         assertEquals(1, results.size());
131 
132         MetadataResult result = results.get(0);
133         assertSame(request, result.getRequest());
134         assertNotNull(result.getException());
135         assertEquals(MetadataNotFoundException.class, result.getException().getClass());
136         assertNull(result.getMetadata());
137     }
138 
139     @Test
140     void testResolve() throws IOException {
141         connector.setExpectGet(metadata);
142 
143         // prepare "download"
144         File file = new File(
145                 session.getLocalRepository().getBasedir(),
146                 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
147 
148         TestFileUtils.writeString(file, file.getAbsolutePath());
149 
150         MetadataRequest request = new MetadataRequest(metadata, repository, "");
151         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
152 
153         assertEquals(1, results.size());
154 
155         MetadataResult result = results.get(0);
156         assertSame(request, result.getRequest());
157         assertNull(result.getException());
158         assertNotNull(result.getMetadata());
159         assertNotNull(result.getMetadata().getFile());
160 
161         assertEquals(file, result.getMetadata().getFile());
162         assertEquals(metadata, result.getMetadata().setFile(null));
163 
164         connector.assertSeenExpected();
165         Set<Metadata> metadataRegistration =
166                 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
167         assertTrue(metadataRegistration.contains(metadata));
168         assertEquals(1, metadataRegistration.size());
169 
170         List<RepositoryEvent> events =
171                 listener.getEvents(EventType.METADATA_DOWNLOADING, EventType.METADATA_DOWNLOADED);
172         assertEquals(2, events.size());
173         assertSame(events.get(0).getTrace(), events.get(1).getTrace());
174 
175         RepositoryEvent event = events.get(0);
176         assertEquals(EventType.METADATA_DOWNLOADING, event.getType());
177         assertEquals(metadata, event.getMetadata());
178 
179         event = events.get(1);
180         assertEquals(EventType.METADATA_DOWNLOADED, event.getType());
181         assertEquals(metadata, event.getMetadata());
182         assertNull(event.getException());
183         assertNotNull(event.getFile());
184     }
185 
186     @Test
187     void testRemoveMetadataIfMissing() throws IOException {
188         connector = new RecordingRepositoryConnector() {
189 
190             @Override
191             public void get(
192                     Collection<? extends ArtifactDownload> artifactDownloads,
193                     Collection<? extends MetadataDownload> metadataDownloads) {
194                 super.get(artifactDownloads, metadataDownloads);
195                 for (MetadataDownload d : metadataDownloads) {
196                     d.setException(new MetadataNotFoundException(metadata, repository));
197                 }
198             }
199         };
200         connectorProvider.setConnector(connector);
201 
202         File file = new File(
203                 session.getLocalRepository().getBasedir(),
204                 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
205         TestFileUtils.writeString(file, file.getAbsolutePath());
206         metadata.setFile(file);
207 
208         MetadataRequest request = new MetadataRequest(metadata, repository, "");
209         request.setDeleteLocalCopyIfMissing(true);
210 
211         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
212         assertEquals(1, results.size());
213         MetadataResult result = results.get(0);
214 
215         assertNotNull(result.getException());
216         assertFalse(file.exists());
217     }
218 
219     @Test
220     void testOfflineSessionResolveMetadataMissing() {
221         session.setOffline(true);
222         MetadataRequest request = new MetadataRequest(metadata, repository, "");
223         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
224 
225         assertEquals(1, results.size());
226 
227         MetadataResult result = results.get(0);
228         assertSame(request, result.getRequest());
229         assertNotNull(result.getException());
230         assertNull(result.getMetadata());
231 
232         connector.assertSeenExpected();
233     }
234 
235     @Test
236     void testOfflineSessionResolveMetadata() throws IOException {
237         session.setOffline(true);
238 
239         String path = session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, "");
240         File file = new File(session.getLocalRepository().getBasedir(), path);
241         TestFileUtils.writeString(file, file.getAbsolutePath());
242 
243         // set file to use in TestLRM find()
244         metadata = metadata.setFile(file);
245 
246         MetadataRequest request = new MetadataRequest(metadata, repository, "");
247         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
248 
249         assertEquals(1, results.size());
250         MetadataResult result = results.get(0);
251         assertSame(request, result.getRequest());
252         assertNull(result.getException(), String.valueOf(result.getException()));
253         assertNotNull(result.getMetadata());
254         assertNotNull(result.getMetadata().getFile());
255 
256         assertEquals(file, result.getMetadata().getFile());
257         assertEquals(metadata.setFile(null), result.getMetadata().setFile(null));
258 
259         connector.assertSeenExpected();
260     }
261 
262     @Test
263     void testFavorLocal() throws IOException {
264         lrm.add(session, new LocalMetadataRegistration(metadata));
265         String path = session.getLocalRepositoryManager().getPathForLocalMetadata(metadata);
266         File file = new File(session.getLocalRepository().getBasedir(), path);
267         TestFileUtils.writeString(file, file.getAbsolutePath());
268 
269         MetadataRequest request = new MetadataRequest(metadata, repository, "");
270         request.setFavorLocalRepository(true);
271 
272         resolver = new DefaultMetadataResolver(
273                 new StubRepositoryEventDispatcher(),
274                 new StaticUpdateCheckManager(true, true),
275                 connectorProvider,
276                 new StubRemoteRepositoryManager(),
277                 new StubSyncContextFactory(),
278                 new DefaultOfflineController(),
279                 remoteRepositoryFilterManager,
280                 new DefaultPathProcessor());
281 
282         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
283 
284         assertEquals(1, results.size());
285         MetadataResult result = results.get(0);
286         assertSame(request, result.getRequest());
287         assertNull(result.getException(), String.valueOf(result.getException()));
288 
289         connector.assertSeenExpected();
290     }
291 
292     @Test
293     void testResolveAlwaysAcceptFilter() throws IOException {
294         remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
295         remoteRepositoryFilterSources.put("filter2", Filters.alwaysAccept());
296         connector.setExpectGet(metadata);
297 
298         // prepare "download"
299         File file = new File(
300                 session.getLocalRepository().getBasedir(),
301                 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
302 
303         TestFileUtils.writeString(file, file.getAbsolutePath());
304 
305         MetadataRequest request = new MetadataRequest(metadata, repository, "");
306         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
307 
308         assertEquals(1, results.size());
309 
310         MetadataResult result = results.get(0);
311         assertSame(request, result.getRequest());
312         assertNull(result.getException());
313         assertNotNull(result.getMetadata());
314         assertNotNull(result.getMetadata().getFile());
315 
316         assertEquals(file, result.getMetadata().getFile());
317         assertEquals(metadata, result.getMetadata().setFile(null));
318 
319         connector.assertSeenExpected();
320         Set<Metadata> metadataRegistration =
321                 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
322         assertTrue(metadataRegistration.contains(metadata));
323         assertEquals(1, metadataRegistration.size());
324     }
325 
326     @Test
327     void testResolveNeverAcceptFilter() throws IOException {
328         remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom("invalid repo id"));
329         remoteRepositoryFilterSources.put("filter2", Filters.neverAccept());
330         // connector.setExpectGet( metadata ); // should not see it
331 
332         // prepare "download"
333         File file = new File(
334                 session.getLocalRepository().getBasedir(),
335                 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
336 
337         TestFileUtils.writeString(file, file.getAbsolutePath());
338 
339         MetadataRequest request = new MetadataRequest(metadata, repository, "");
340         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
341 
342         assertEquals(1, results.size());
343 
344         MetadataResult result = results.get(0);
345         assertSame(request, result.getRequest());
346         assertNotNull(result.getException());
347         assertInstanceOf(MetadataNotFoundException.class, result.getException());
348         assertEquals("never-accept: never accept", result.getException().getMessage());
349         assertNull(result.getMetadata());
350 
351         connector.assertSeenExpected();
352     }
353 
354     @Test
355     void testResolveAlwaysAcceptFromRepoFilter() throws IOException {
356         remoteRepositoryFilterSources.put("filter1", Filters.alwaysAcceptFrom(repository.getId()));
357         connector.setExpectGet(metadata);
358 
359         // prepare "download"
360         File file = new File(
361                 session.getLocalRepository().getBasedir(),
362                 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
363 
364         TestFileUtils.writeString(file, file.getAbsolutePath());
365 
366         MetadataRequest request = new MetadataRequest(metadata, repository, "");
367         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
368 
369         assertEquals(1, results.size());
370 
371         MetadataResult result = results.get(0);
372         assertSame(request, result.getRequest());
373         assertNull(result.getException());
374         assertNotNull(result.getMetadata());
375         assertNotNull(result.getMetadata().getFile());
376 
377         assertEquals(file, result.getMetadata().getFile());
378         assertEquals(metadata, result.getMetadata().setFile(null));
379 
380         connector.assertSeenExpected();
381         Set<Metadata> metadataRegistration =
382                 ((TestLocalRepositoryManager) session.getLocalRepositoryManager()).getMetadataRegistration();
383         assertTrue(metadataRegistration.contains(metadata));
384         assertEquals(1, metadataRegistration.size());
385     }
386 
387     @Test
388     void testResolveNeverAcceptFromRepoFilter() throws IOException {
389         remoteRepositoryFilterSources.put("filter1", Filters.neverAcceptFrom(repository.getId()));
390         // connector.setExpectGet( metadata ); // should not see it
391 
392         // prepare "download"
393         File file = new File(
394                 session.getLocalRepository().getBasedir(),
395                 session.getLocalRepositoryManager().getPathForRemoteMetadata(metadata, repository, ""));
396 
397         TestFileUtils.writeString(file, file.getAbsolutePath());
398 
399         MetadataRequest request = new MetadataRequest(metadata, repository, "");
400         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
401 
402         assertEquals(1, results.size());
403 
404         MetadataResult result = results.get(0);
405         assertSame(request, result.getRequest());
406         assertNotNull(result.getException());
407         assertInstanceOf(MetadataNotFoundException.class, result.getException());
408         assertEquals(
409                 "never-accept-" + repository.getId() + ": matched",
410                 result.getException().getMessage());
411         assertNull(result.getMetadata());
412 
413         connector.assertSeenExpected();
414     }
415 
416     @Test
417     void testResolveSkipsFilterWhenRepositoryPoliciesAreDisabled() {
418         remoteRepositoryFilterSources.put("filter1", Filters.neverAccept());
419         RemoteRepository disabledRepository = new RemoteRepository.Builder(
420                         repository.getId(), "default", repository.getUrl())
421                 .setReleasePolicy(new RepositoryPolicy(
422                         false, RepositoryPolicy.UPDATE_POLICY_DAILY, RepositoryPolicy.CHECKSUM_POLICY_WARN))
423                 .setSnapshotPolicy(new RepositoryPolicy(
424                         false, RepositoryPolicy.UPDATE_POLICY_DAILY, RepositoryPolicy.CHECKSUM_POLICY_WARN))
425                 .build();
426 
427         MetadataRequest request = new MetadataRequest(metadata, disabledRepository, "");
428         List<MetadataResult> results = resolver.resolveMetadata(session, Arrays.asList(request));
429 
430         assertEquals(1, results.size());
431         assertNull(results.get(0).getException());
432         connector.assertSeenExpected();
433     }
434 
435     private static SyncContext countingSyncContext(AtomicInteger closeCount) {
436         return new SyncContext() {
437             @Override
438             public void acquire(Collection<? extends Artifact> artifacts, Collection<? extends Metadata> metadatas) {}
439 
440             @Override
441             public void close() {
442                 closeCount.incrementAndGet();
443             }
444         };
445     }
446 
447     @Test
448     void testSyncContextIsClosedExactlyOnce() throws Exception {
449         final AtomicInteger sharedCloses = new AtomicInteger(0);
450         final AtomicInteger exclusiveCloses = new AtomicInteger(0);
451         final SyncContext sharedContext = countingSyncContext(sharedCloses);
452         final SyncContext exclusiveContext = countingSyncContext(exclusiveCloses);
453 
454         resolver = new DefaultMetadataResolver(
455                 new StubRepositoryEventDispatcher(),
456                 new StaticUpdateCheckManager(true),
457                 connectorProvider,
458                 new StubRemoteRepositoryManager(),
459                 (s, shared) -> shared ? sharedContext : exclusiveContext,
460                 new DefaultOfflineController(),
461                 remoteRepositoryFilterManager,
462                 new DefaultPathProcessor());
463 
464         MetadataRequest request = new MetadataRequest(metadata, repository, "");
465         resolver.resolveMetadata(session, Arrays.asList(request));
466 
467         // distinct instances for the shared and the exclusive context: each must be closed exactly once
468         assertEquals(1, sharedCloses.get(), "Shared SyncContext should be closed exactly once");
469         assertEquals(1, exclusiveCloses.get(), "Exclusive SyncContext should be closed exactly once");
470     }
471 
472     @Test
473     void testSharedSyncContextIsClosedWhenExclusiveCannotBeCreated() throws Exception {
474         final AtomicInteger sharedCloses = new AtomicInteger(0);
475         final SyncContext sharedContext = countingSyncContext(sharedCloses);
476 
477         resolver = new DefaultMetadataResolver(
478                 new StubRepositoryEventDispatcher(),
479                 new StaticUpdateCheckManager(true),
480                 connectorProvider,
481                 new StubRemoteRepositoryManager(),
482                 (s, shared) -> {
483                     if (shared) {
484                         return sharedContext;
485                     }
486                     throw new IllegalStateException("no exclusive context");
487                 },
488                 new DefaultOfflineController(),
489                 remoteRepositoryFilterManager,
490                 new DefaultPathProcessor());
491 
492         MetadataRequest request = new MetadataRequest(metadata, repository, "");
493 
494         try {
495             resolver.resolveMetadata(session, Arrays.asList(request));
496             fail("Should throw IllegalStateException");
497         } catch (IllegalStateException ex) {
498             // expected
499         }
500 
501         assertEquals(
502                 1, sharedCloses.get(), "Shared SyncContext should be closed when the exclusive one cannot be created");
503     }
504 }