1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.repository.internal;
20
21 import javax.inject.Inject;
22 import javax.inject.Named;
23 import javax.inject.Singleton;
24
25 import java.util.Collections;
26 import java.util.LinkedHashMap;
27 import java.util.LinkedHashSet;
28 import java.util.List;
29 import java.util.Map;
30 import java.util.Objects;
31 import java.util.Properties;
32 import java.util.Set;
33
34 import org.apache.maven.model.Model;
35 import org.apache.maven.model.building.DefaultModelBuildingRequest;
36 import org.apache.maven.model.building.FileModelSource;
37 import org.apache.maven.model.building.ModelBuilder;
38 import org.apache.maven.model.building.ModelBuildingException;
39 import org.apache.maven.model.building.ModelBuildingRequest;
40 import org.apache.maven.model.building.ModelBuildingResult;
41 import org.apache.maven.model.building.ModelProblem;
42 import org.apache.maven.model.building.ModelProblemUtils;
43 import org.apache.maven.model.resolution.UnresolvableModelException;
44 import org.apache.maven.repository.internal.relocation.DistributionManagementArtifactRelocationSource;
45 import org.apache.maven.repository.internal.relocation.UserPropertiesArtifactRelocationSource;
46 import org.codehaus.plexus.util.StringUtils;
47 import org.eclipse.aether.RepositoryEvent;
48 import org.eclipse.aether.RepositoryEvent.EventType;
49 import org.eclipse.aether.RepositoryException;
50 import org.eclipse.aether.RepositorySystemSession;
51 import org.eclipse.aether.RequestTrace;
52 import org.eclipse.aether.artifact.Artifact;
53 import org.eclipse.aether.impl.ArtifactDescriptorReader;
54 import org.eclipse.aether.impl.ArtifactResolver;
55 import org.eclipse.aether.impl.RemoteRepositoryManager;
56 import org.eclipse.aether.impl.RepositoryEventDispatcher;
57 import org.eclipse.aether.impl.VersionRangeResolver;
58 import org.eclipse.aether.impl.VersionResolver;
59 import org.eclipse.aether.repository.WorkspaceReader;
60 import org.eclipse.aether.repository.WorkspaceRepository;
61 import org.eclipse.aether.resolution.ArtifactDescriptorException;
62 import org.eclipse.aether.resolution.ArtifactDescriptorPolicy;
63 import org.eclipse.aether.resolution.ArtifactDescriptorPolicyRequest;
64 import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
65 import org.eclipse.aether.resolution.ArtifactDescriptorResult;
66 import org.eclipse.aether.resolution.ArtifactRequest;
67 import org.eclipse.aether.resolution.ArtifactResolutionException;
68 import org.eclipse.aether.resolution.ArtifactResult;
69 import org.eclipse.aether.resolution.VersionRequest;
70 import org.eclipse.aether.resolution.VersionResolutionException;
71 import org.eclipse.aether.resolution.VersionResult;
72 import org.eclipse.aether.transfer.ArtifactNotFoundException;
73 import org.slf4j.Logger;
74 import org.slf4j.LoggerFactory;
75
76
77
78
79 @Named
80 @Singleton
81 public class DefaultArtifactDescriptorReader implements ArtifactDescriptorReader {
82 private RemoteRepositoryManager remoteRepositoryManager;
83
84 private VersionResolver versionResolver;
85
86 private VersionRangeResolver versionRangeResolver;
87
88 private ArtifactResolver artifactResolver;
89
90 private RepositoryEventDispatcher repositoryEventDispatcher;
91
92 private ModelBuilder modelBuilder;
93
94 private ModelCacheFactory modelCacheFactory;
95
96 private Map<String, MavenArtifactRelocationSource> artifactRelocationSources = Collections.emptyMap();
97
98 private Map<String, ArtifactDescriptorDecorator> artifactDescriptorDecorators = Collections.emptyMap();
99
100 private final ArtifactDescriptorReaderDelegate artifactDescriptorReaderDelegate =
101 new ArtifactDescriptorReaderDelegate();
102
103 private final Logger logger = LoggerFactory.getLogger(getClass());
104
105
106
107
108 @Deprecated
109 public DefaultArtifactDescriptorReader() {
110
111 }
112
113
114
115
116 @Deprecated
117 public DefaultArtifactDescriptorReader(
118 RemoteRepositoryManager remoteRepositoryManager,
119 VersionResolver versionResolver,
120 VersionRangeResolver versionRangeResolver,
121 ArtifactResolver artifactResolver,
122 ModelBuilder modelBuilder,
123 RepositoryEventDispatcher repositoryEventDispatcher,
124 ModelCacheFactory modelCacheFactory) {
125 setRemoteRepositoryManager(remoteRepositoryManager);
126 setVersionResolver(versionResolver);
127 setVersionRangeResolver(versionRangeResolver);
128 setArtifactResolver(artifactResolver);
129 setModelBuilder(modelBuilder);
130 setRepositoryEventDispatcher(repositoryEventDispatcher);
131 setModelCacheFactory(modelCacheFactory);
132 Map<String, MavenArtifactRelocationSource> artifactRelocationSources = new LinkedHashMap<>();
133 artifactRelocationSources.put(
134 UserPropertiesArtifactRelocationSource.NAME, new UserPropertiesArtifactRelocationSource());
135 artifactRelocationSources.put(
136 DistributionManagementArtifactRelocationSource.NAME,
137 new DistributionManagementArtifactRelocationSource());
138 setArtifactRelocationSources(artifactRelocationSources);
139 }
140
141
142
143
144 @SuppressWarnings("checkstyle:parameternumber")
145 @Deprecated
146 public DefaultArtifactDescriptorReader(
147 RemoteRepositoryManager remoteRepositoryManager,
148 VersionResolver versionResolver,
149 VersionRangeResolver versionRangeResolver,
150 ArtifactResolver artifactResolver,
151 ModelBuilder modelBuilder,
152 RepositoryEventDispatcher repositoryEventDispatcher,
153 ModelCacheFactory modelCacheFactory,
154 Map<String, MavenArtifactRelocationSource> artifactRelocationSources) {
155 setRemoteRepositoryManager(remoteRepositoryManager);
156 setVersionResolver(versionResolver);
157 setVersionRangeResolver(versionRangeResolver);
158 setArtifactResolver(artifactResolver);
159 setModelBuilder(modelBuilder);
160 setRepositoryEventDispatcher(repositoryEventDispatcher);
161 setModelCacheFactory(modelCacheFactory);
162 setArtifactRelocationSources(artifactRelocationSources);
163 }
164
165 @SuppressWarnings("checkstyle:parameternumber")
166 @Inject
167 public DefaultArtifactDescriptorReader(
168 RemoteRepositoryManager remoteRepositoryManager,
169 VersionResolver versionResolver,
170 VersionRangeResolver versionRangeResolver,
171 ArtifactResolver artifactResolver,
172 ModelBuilder modelBuilder,
173 RepositoryEventDispatcher repositoryEventDispatcher,
174 ModelCacheFactory modelCacheFactory,
175 Map<String, MavenArtifactRelocationSource> artifactRelocationSources,
176 Map<String, ArtifactDescriptorDecorator> artifactDescriptorDecorators) {
177 setRemoteRepositoryManager(remoteRepositoryManager);
178 setVersionResolver(versionResolver);
179 setVersionRangeResolver(versionRangeResolver);
180 setArtifactResolver(artifactResolver);
181 setModelBuilder(modelBuilder);
182 setRepositoryEventDispatcher(repositoryEventDispatcher);
183 setModelCacheFactory(modelCacheFactory);
184 setArtifactRelocationSources(artifactRelocationSources);
185 setArtifactDescriptorDecorators(artifactDescriptorDecorators);
186 }
187
188 public DefaultArtifactDescriptorReader setRemoteRepositoryManager(RemoteRepositoryManager remoteRepositoryManager) {
189 this.remoteRepositoryManager =
190 Objects.requireNonNull(remoteRepositoryManager, "remoteRepositoryManager cannot be null");
191 return this;
192 }
193
194 public DefaultArtifactDescriptorReader setVersionResolver(VersionResolver versionResolver) {
195 this.versionResolver = Objects.requireNonNull(versionResolver, "versionResolver cannot be null");
196 return this;
197 }
198
199
200 public DefaultArtifactDescriptorReader setVersionRangeResolver(VersionRangeResolver versionRangeResolver) {
201 this.versionRangeResolver = Objects.requireNonNull(versionRangeResolver, "versionRangeResolver cannot be null");
202 return this;
203 }
204
205 public DefaultArtifactDescriptorReader setArtifactResolver(ArtifactResolver artifactResolver) {
206 this.artifactResolver = Objects.requireNonNull(artifactResolver, "artifactResolver cannot be null");
207 return this;
208 }
209
210 public DefaultArtifactDescriptorReader setRepositoryEventDispatcher(
211 RepositoryEventDispatcher repositoryEventDispatcher) {
212 this.repositoryEventDispatcher =
213 Objects.requireNonNull(repositoryEventDispatcher, "repositoryEventDispatcher cannot be null");
214 return this;
215 }
216
217 public DefaultArtifactDescriptorReader setModelBuilder(ModelBuilder modelBuilder) {
218 this.modelBuilder = Objects.requireNonNull(modelBuilder, "modelBuilder cannot be null");
219 return this;
220 }
221
222 public DefaultArtifactDescriptorReader setModelCacheFactory(ModelCacheFactory modelCacheFactory) {
223 this.modelCacheFactory = Objects.requireNonNull(modelCacheFactory, "modelCacheFactory cannot be null");
224 return this;
225 }
226
227 public DefaultArtifactDescriptorReader setArtifactRelocationSources(
228 Map<String, MavenArtifactRelocationSource> artifactRelocationSources) {
229 this.artifactRelocationSources =
230 Objects.requireNonNull(artifactRelocationSources, "artifactRelocationSources cannot be null");
231 return this;
232 }
233
234 public DefaultArtifactDescriptorReader setArtifactDescriptorDecorators(
235 Map<String, ArtifactDescriptorDecorator> artifactDescriptorDecorators) {
236 this.artifactDescriptorDecorators =
237 Objects.requireNonNull(artifactDescriptorDecorators, "artifactDescriptorDecorators cannot be null");
238 return this;
239 }
240
241 @Override
242 public ArtifactDescriptorResult readArtifactDescriptor(
243 RepositorySystemSession session, ArtifactDescriptorRequest request) throws ArtifactDescriptorException {
244 ArtifactDescriptorResult result = new ArtifactDescriptorResult(request);
245
246 Model model = loadPom(session, request, result);
247 if (model != null) {
248 Map<String, Object> config = session.getConfigProperties();
249 ArtifactDescriptorReaderDelegate delegate =
250 (ArtifactDescriptorReaderDelegate) config.get(ArtifactDescriptorReaderDelegate.class.getName());
251
252 if (delegate == null) {
253 delegate = artifactDescriptorReaderDelegate;
254 }
255
256 delegate.populateResult(session, result, model);
257
258 for (ArtifactDescriptorDecorator decorator : artifactDescriptorDecorators.values()) {
259 decorator.populateArtifactDescriptor(session, result, model);
260 }
261 }
262
263 return result;
264 }
265
266 @SuppressWarnings("MethodLength")
267 private Model loadPom(
268 RepositorySystemSession session, ArtifactDescriptorRequest request, ArtifactDescriptorResult result)
269 throws ArtifactDescriptorException {
270 RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
271
272 Set<String> visited = new LinkedHashSet<>();
273 for (Artifact a = request.getArtifact(); ; ) {
274 Artifact pomArtifact = ArtifactDescriptorUtils.toPomArtifact(a);
275 try {
276 VersionRequest versionRequest =
277 new VersionRequest(a, request.getRepositories(), request.getRequestContext());
278 versionRequest.setTrace(trace);
279 VersionResult versionResult = versionResolver.resolveVersion(session, versionRequest);
280
281 a = a.setVersion(versionResult.getVersion());
282
283 versionRequest =
284 new VersionRequest(pomArtifact, request.getRepositories(), request.getRequestContext());
285 versionRequest.setTrace(trace);
286 versionResult = versionResolver.resolveVersion(session, versionRequest);
287
288 pomArtifact = pomArtifact.setVersion(versionResult.getVersion());
289 } catch (VersionResolutionException e) {
290 result.addException(e);
291 throw new ArtifactDescriptorException(result);
292 }
293
294 if (!visited.add(a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getBaseVersion())) {
295 RepositoryException exception =
296 new RepositoryException("Artifact relocations form a cycle: " + visited);
297 invalidDescriptor(session, trace, a, exception);
298 if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_INVALID) != 0) {
299 return null;
300 }
301 result.addException(exception);
302 throw new ArtifactDescriptorException(result);
303 }
304
305 ArtifactResult resolveResult;
306 try {
307 ArtifactRequest resolveRequest =
308 new ArtifactRequest(pomArtifact, request.getRepositories(), request.getRequestContext());
309 resolveRequest.setTrace(trace);
310 resolveResult = artifactResolver.resolveArtifact(session, resolveRequest);
311 pomArtifact = resolveResult.getArtifact();
312 result.setRepository(resolveResult.getRepository());
313 } catch (ArtifactResolutionException e) {
314 if (e.getCause() instanceof ArtifactNotFoundException) {
315 missingDescriptor(session, trace, a, (Exception) e.getCause());
316 if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_MISSING) != 0) {
317 return null;
318 }
319 }
320 result.addException(e);
321 throw new ArtifactDescriptorException(result);
322 }
323
324 Model model;
325
326
327 final WorkspaceReader workspace = session.getWorkspaceReader();
328 if (workspace instanceof MavenWorkspaceReader) {
329 model = ((MavenWorkspaceReader) workspace).findModel(pomArtifact);
330 if (model != null) {
331 return model;
332 }
333 }
334
335 try {
336 ModelBuildingRequest modelRequest = new DefaultModelBuildingRequest();
337 modelRequest.setValidationLevel(ModelBuildingRequest.VALIDATION_LEVEL_MINIMAL);
338 modelRequest.setProcessPlugins(false);
339 modelRequest.setTwoPhaseBuilding(false);
340
341
342 modelRequest.setSystemProperties(
343 toProperties(session.getUserProperties(), session.getSystemProperties()));
344 modelRequest.setUserProperties(new Properties());
345 modelRequest.setModelCache(modelCacheFactory.createCache(session));
346 modelRequest.setModelResolver(new DefaultModelResolver(
347 session,
348 trace.newChild(modelRequest),
349 request.getRequestContext(),
350 artifactResolver,
351 versionRangeResolver,
352 remoteRepositoryManager,
353 request.getRepositories()));
354 if (resolveResult.getRepository() instanceof WorkspaceRepository) {
355 modelRequest.setPomFile(pomArtifact.getFile());
356 } else {
357 modelRequest.setModelSource(new FileModelSource(pomArtifact.getFile()));
358 }
359
360 ModelBuildingResult modelResult = modelBuilder.build(modelRequest);
361
362
363 if (!modelResult.getProblems().isEmpty()) {
364 List<ModelProblem> problems = modelResult.getProblems();
365 if (logger.isDebugEnabled()) {
366 String problem = (problems.size() == 1) ? "problem" : "problems";
367 String problemPredicate = problem + ((problems.size() == 1) ? " was" : " were");
368 String message = String.format(
369 "%s %s encountered while building the effective model for %s during %s\n",
370 problems.size(),
371 problemPredicate,
372 request.getArtifact(),
373 RequestTraceHelper.interpretTrace(true, request.getTrace()));
374 message += StringUtils.capitalizeFirstLetter(problem);
375 for (ModelProblem modelProblem : problems) {
376 message += String.format(
377 "\n* %s @ %s",
378 modelProblem.getMessage(), ModelProblemUtils.formatLocation(modelProblem, null));
379 }
380 logger.warn(message);
381 } else {
382 logger.warn(
383 "{} {} encountered while building the effective model for {} during {} (use -X to see details)",
384 problems.size(),
385 (problems.size() == 1) ? "problem was" : "problems were",
386 request.getArtifact(),
387 RequestTraceHelper.interpretTrace(false, request.getTrace()));
388 }
389 }
390 model = modelResult.getEffectiveModel();
391 } catch (ModelBuildingException e) {
392 for (ModelProblem problem : e.getProblems()) {
393 if (problem.getException() instanceof UnresolvableModelException) {
394 result.addException(problem.getException());
395 throw new ArtifactDescriptorException(result);
396 }
397 }
398 invalidDescriptor(session, trace, a, e);
399 if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_INVALID) != 0) {
400 return null;
401 }
402 result.addException(e);
403 throw new ArtifactDescriptorException(result);
404 }
405
406 Artifact relocatedArtifact = getRelocation(session, result, model);
407 if (relocatedArtifact != null) {
408 if (withinSameGav(relocatedArtifact, a)) {
409 result.setArtifact(relocatedArtifact);
410 return model;
411 } else {
412 result.addRelocation(a);
413 a = relocatedArtifact;
414 result.setArtifact(a);
415 }
416 } else {
417 return model;
418 }
419 }
420 }
421
422 private boolean withinSameGav(Artifact a1, Artifact a2) {
423 return Objects.equals(a1.getGroupId(), a2.getGroupId())
424 && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
425 && Objects.equals(a1.getVersion(), a2.getVersion());
426 }
427
428 private Properties toProperties(Map<String, String> dominant, Map<String, String> recessive) {
429 Properties props = new Properties();
430 if (recessive != null) {
431 props.putAll(recessive);
432 }
433 if (dominant != null) {
434 props.putAll(dominant);
435 }
436 return props;
437 }
438
439 private Artifact getRelocation(
440 RepositorySystemSession session, ArtifactDescriptorResult artifactDescriptorResult, Model model)
441 throws ArtifactDescriptorException {
442 Artifact result = null;
443 for (MavenArtifactRelocationSource source : artifactRelocationSources.values()) {
444 result = source.relocatedTarget(session, artifactDescriptorResult, model);
445 if (result != null) {
446 break;
447 }
448 }
449 return result;
450 }
451
452 private void missingDescriptor(
453 RepositorySystemSession session, RequestTrace trace, Artifact artifact, Exception exception) {
454 RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DESCRIPTOR_MISSING);
455 event.setTrace(trace);
456 event.setArtifact(artifact);
457 event.setException(exception);
458
459 repositoryEventDispatcher.dispatch(event.build());
460 }
461
462 private void invalidDescriptor(
463 RepositorySystemSession session, RequestTrace trace, Artifact artifact, Exception exception) {
464 RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DESCRIPTOR_INVALID);
465 event.setTrace(trace);
466 event.setArtifact(artifact);
467 event.setException(exception);
468
469 repositoryEventDispatcher.dispatch(event.build());
470 }
471
472 private int getPolicy(RepositorySystemSession session, Artifact a, ArtifactDescriptorRequest request) {
473 ArtifactDescriptorPolicy policy = session.getArtifactDescriptorPolicy();
474 if (policy == null) {
475 return ArtifactDescriptorPolicy.STRICT;
476 }
477 return policy.getPolicy(session, new ArtifactDescriptorPolicyRequest(a, request.getRequestContext()));
478 }
479 }