1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.impl.resolver;
20
21 import java.util.HashMap;
22 import java.util.LinkedHashSet;
23 import java.util.List;
24 import java.util.Map;
25 import java.util.Objects;
26
27 import org.apache.maven.api.RemoteRepository;
28 import org.apache.maven.api.di.Inject;
29 import org.apache.maven.api.di.Named;
30 import org.apache.maven.api.di.Singleton;
31 import org.apache.maven.api.model.Model;
32 import org.apache.maven.api.services.ModelBuilder;
33 import org.apache.maven.api.services.ModelBuilderException;
34 import org.apache.maven.api.services.ModelBuilderRequest;
35 import org.apache.maven.api.services.ModelBuilderResult;
36 import org.apache.maven.api.services.ModelProblem;
37 import org.apache.maven.api.services.ProblemCollector;
38 import org.apache.maven.api.services.Sources;
39 import org.apache.maven.api.services.model.ModelResolverException;
40 import org.apache.maven.impl.InternalSession;
41 import org.apache.maven.impl.RequestTraceHelper;
42 import org.apache.maven.impl.model.ModelProblemUtils;
43 import org.eclipse.aether.RepositoryEvent;
44 import org.eclipse.aether.RepositoryEvent.EventType;
45 import org.eclipse.aether.RepositoryException;
46 import org.eclipse.aether.RepositorySystemSession;
47 import org.eclipse.aether.RequestTrace;
48 import org.eclipse.aether.artifact.Artifact;
49 import org.eclipse.aether.impl.ArtifactDescriptorReader;
50 import org.eclipse.aether.impl.ArtifactResolver;
51 import org.eclipse.aether.impl.RepositoryEventDispatcher;
52 import org.eclipse.aether.impl.VersionResolver;
53 import org.eclipse.aether.repository.WorkspaceReader;
54 import org.eclipse.aether.resolution.ArtifactDescriptorException;
55 import org.eclipse.aether.resolution.ArtifactDescriptorPolicy;
56 import org.eclipse.aether.resolution.ArtifactDescriptorPolicyRequest;
57 import org.eclipse.aether.resolution.ArtifactDescriptorRequest;
58 import org.eclipse.aether.resolution.ArtifactDescriptorResult;
59 import org.eclipse.aether.resolution.ArtifactRequest;
60 import org.eclipse.aether.resolution.ArtifactResolutionException;
61 import org.eclipse.aether.resolution.ArtifactResult;
62 import org.eclipse.aether.resolution.VersionRequest;
63 import org.eclipse.aether.resolution.VersionResolutionException;
64 import org.eclipse.aether.resolution.VersionResult;
65 import org.eclipse.aether.transfer.ArtifactNotFoundException;
66 import org.slf4j.Logger;
67 import org.slf4j.LoggerFactory;
68
69
70
71
72 @Named
73 @Singleton
74 public class DefaultArtifactDescriptorReader implements ArtifactDescriptorReader {
75 private final VersionResolver versionResolver;
76 private final ArtifactResolver artifactResolver;
77 private final RepositoryEventDispatcher repositoryEventDispatcher;
78 private final ModelBuilder modelBuilder;
79 private final Map<String, MavenArtifactRelocationSource> artifactRelocationSources;
80 private final ArtifactDescriptorReaderDelegate delegate;
81 private final Logger logger = LoggerFactory.getLogger(getClass());
82
83 @Inject
84 public DefaultArtifactDescriptorReader(
85 VersionResolver versionResolver,
86 ArtifactResolver artifactResolver,
87 ModelBuilder modelBuilder,
88 RepositoryEventDispatcher repositoryEventDispatcher,
89 Map<String, MavenArtifactRelocationSource> artifactRelocationSources) {
90 this.versionResolver = Objects.requireNonNull(versionResolver, "versionResolver cannot be null");
91 this.artifactResolver = Objects.requireNonNull(artifactResolver, "artifactResolver cannot be null");
92 this.modelBuilder = Objects.requireNonNull(modelBuilder, "modelBuilder cannot be null");
93 this.repositoryEventDispatcher =
94 Objects.requireNonNull(repositoryEventDispatcher, "repositoryEventDispatcher cannot be null");
95 this.artifactRelocationSources =
96 Objects.requireNonNull(artifactRelocationSources, "artifactRelocationSources cannot be null");
97 this.delegate = new ArtifactDescriptorReaderDelegate();
98 }
99
100 @Override
101 public ArtifactDescriptorResult readArtifactDescriptor(
102 RepositorySystemSession session, ArtifactDescriptorRequest request) throws ArtifactDescriptorException {
103 ArtifactDescriptorResult result = new ArtifactDescriptorResult(request);
104
105 Model model = loadPom(session, request, result);
106 if (model != null) {
107 Map<String, Object> config = session.getConfigProperties();
108 ArtifactDescriptorReaderDelegate delegate =
109 (ArtifactDescriptorReaderDelegate) config.get(ArtifactDescriptorReaderDelegate.class.getName());
110
111 if (delegate == null) {
112 delegate = this.delegate;
113 }
114
115 delegate.populateResult(InternalSession.from(session), result, model);
116 }
117
118 return result;
119 }
120
121 @SuppressWarnings("MethodLength")
122 private Model loadPom(
123 RepositorySystemSession session, ArtifactDescriptorRequest request, ArtifactDescriptorResult result)
124 throws ArtifactDescriptorException {
125 RequestTrace trace = RequestTrace.newChild(request.getTrace(), request);
126
127 LinkedHashSet<String> visited = new LinkedHashSet<>();
128 for (Artifact a = request.getArtifact(); ; ) {
129 Artifact pomArtifact = ArtifactDescriptorUtils.toPomArtifactUnconditionally(a);
130 try {
131 VersionRequest versionRequest =
132 new VersionRequest(a, request.getRepositories(), request.getRequestContext());
133 versionRequest.setTrace(trace);
134 VersionResult versionResult = versionResolver.resolveVersion(session, versionRequest);
135
136 a = a.setVersion(versionResult.getVersion());
137
138 versionRequest =
139 new VersionRequest(pomArtifact, request.getRepositories(), request.getRequestContext());
140 versionRequest.setTrace(trace);
141 versionResult = versionResolver.resolveVersion(session, versionRequest);
142
143 pomArtifact = pomArtifact.setVersion(versionResult.getVersion());
144 } catch (VersionResolutionException e) {
145 result.addException(e);
146 throw new ArtifactDescriptorException(result);
147 }
148
149 if (!visited.add(a.getGroupId() + ':' + a.getArtifactId() + ':' + a.getBaseVersion())) {
150 RepositoryException exception =
151 new RepositoryException("Artifact relocations form a cycle: " + visited);
152 invalidDescriptor(session, trace, a, exception);
153 if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_INVALID) != 0) {
154 return null;
155 }
156 result.addException(exception);
157 throw new ArtifactDescriptorException(result);
158 }
159
160 ArtifactResult resolveResult;
161 try {
162 ArtifactRequest resolveRequest =
163 new ArtifactRequest(pomArtifact, request.getRepositories(), request.getRequestContext());
164 resolveRequest.setTrace(trace);
165 resolveResult = artifactResolver.resolveArtifact(session, resolveRequest);
166 pomArtifact = resolveResult.getArtifact();
167 result.setRepository(resolveResult.getRepository());
168 } catch (ArtifactResolutionException e) {
169 if (e.getCause() instanceof ArtifactNotFoundException artifactNotFoundException) {
170 missingDescriptor(session, trace, a, artifactNotFoundException);
171 if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_MISSING) != 0) {
172 return null;
173 }
174 }
175 result.addException(e);
176 throw new ArtifactDescriptorException(result);
177 }
178
179 Model model;
180
181
182 final WorkspaceReader workspace = session.getWorkspaceReader();
183 if (workspace instanceof MavenWorkspaceReader mavenWorkspaceReader) {
184 model = mavenWorkspaceReader.findModel(pomArtifact);
185 if (model != null) {
186 return model;
187 }
188 }
189
190 try {
191 InternalSession iSession = InternalSession.from(session);
192 List<RemoteRepository> repositories = request.getRepositories().stream()
193 .map(iSession::getRemoteRepository)
194 .toList();
195 String gav =
196 pomArtifact.getGroupId() + ":" + pomArtifact.getArtifactId() + ":" + pomArtifact.getVersion();
197 ModelBuilderRequest modelRequest = ModelBuilderRequest.builder()
198 .session(iSession)
199 .trace(RequestTraceHelper.toMaven(request.getRequestContext(), trace))
200 .requestType(ModelBuilderRequest.RequestType.CONSUMER_DEPENDENCY)
201 .source(Sources.resolvedSource(pomArtifact.getPath(), gav))
202
203
204 .systemProperties(toProperties(session.getUserProperties(), session.getSystemProperties()))
205 .userProperties(Map.of())
206 .repositoryMerging(ModelBuilderRequest.RepositoryMerging.REQUEST_DOMINANT)
207 .repositories(repositories)
208 .build();
209
210 ModelBuilderResult modelResult = modelBuilder.newSession().build(modelRequest);
211
212
213 if (modelResult.getProblemCollector().hasWarningProblems()) {
214 ProblemCollector<ModelProblem> problemCollector = modelResult.getProblemCollector();
215 int totalProblems = problemCollector.totalProblemsReported();
216 if (logger.isDebugEnabled()) {
217 StringBuilder sb = new StringBuilder();
218 sb.append(totalProblems)
219 .append(" ")
220 .append((totalProblems == 1) ? "problem was" : "problems were")
221 .append(" encountered while building the effective model for '")
222 .append(request.getArtifact())
223 .append("' during ")
224 .append(RequestTraceHelper.interpretTrace(true, request.getTrace()))
225 .append("\n")
226 .append((totalProblems == 1) ? "Problem" : "Problems");
227 for (ModelProblem modelProblem :
228 problemCollector.problems().toList()) {
229 sb.append("\n* ")
230 .append(modelProblem.getMessage())
231 .append(" @ ")
232 .append(ModelProblemUtils.formatLocation(modelProblem, null));
233 }
234 logger.warn(sb.toString());
235 } else {
236 logger.warn(
237 "{} {} encountered while building the effective model for '{}' during {} (use -X to see details)",
238 totalProblems,
239 (totalProblems == 1) ? "problem was" : "problems were",
240 request.getArtifact(),
241 RequestTraceHelper.interpretTrace(false, request.getTrace()));
242 }
243 }
244 model = modelResult.getEffectiveModel();
245 } catch (ModelBuilderException e) {
246 for (ModelProblem problem :
247 e.getResult().getProblemCollector().problems().toList()) {
248 if (problem.getException() instanceof ModelResolverException modelResolverException) {
249 result.addException(modelResolverException);
250 throw new ArtifactDescriptorException(result);
251 }
252 }
253 invalidDescriptor(session, trace, a, e);
254 if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_INVALID) != 0) {
255 return null;
256 }
257 result.addException(e);
258 throw new ArtifactDescriptorException(result);
259 }
260
261 Artifact relocatedArtifact = getRelocation(session, result, model);
262 if (relocatedArtifact != null) {
263 if (withinSameGav(relocatedArtifact, a)) {
264 result.setArtifact(relocatedArtifact);
265 return model;
266 } else {
267 result.addRelocation(a);
268 a = relocatedArtifact;
269 result.setArtifact(a);
270 }
271 } else {
272 return model;
273 }
274 }
275 }
276
277 private boolean withinSameGav(Artifact a1, Artifact a2) {
278 return Objects.equals(a1.getGroupId(), a2.getGroupId())
279 && Objects.equals(a1.getArtifactId(), a2.getArtifactId())
280 && Objects.equals(a1.getVersion(), a2.getVersion());
281 }
282
283 private Map<String, String> toProperties(Map<String, String> dominant, Map<String, String> recessive) {
284 Map<String, String> props = new HashMap<>();
285 if (recessive != null) {
286 props.putAll(recessive);
287 }
288 if (dominant != null) {
289 props.putAll(dominant);
290 }
291 return props;
292 }
293
294 private Artifact getRelocation(
295 RepositorySystemSession session, ArtifactDescriptorResult artifactDescriptorResult, Model model)
296 throws ArtifactDescriptorException {
297 Artifact result = null;
298 for (MavenArtifactRelocationSource source : artifactRelocationSources.values()) {
299 result = source.relocatedTarget(session, artifactDescriptorResult, model);
300 if (result != null) {
301 break;
302 }
303 }
304 return result;
305 }
306
307 private void missingDescriptor(
308 RepositorySystemSession session, RequestTrace trace, Artifact artifact, Exception exception) {
309 RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DESCRIPTOR_MISSING);
310 event.setTrace(trace);
311 event.setArtifact(artifact);
312 event.setException(exception);
313
314 repositoryEventDispatcher.dispatch(event.build());
315 }
316
317 private void invalidDescriptor(
318 RepositorySystemSession session, RequestTrace trace, Artifact artifact, Exception exception) {
319 RepositoryEvent.Builder event = new RepositoryEvent.Builder(session, EventType.ARTIFACT_DESCRIPTOR_INVALID);
320 event.setTrace(trace);
321 event.setArtifact(artifact);
322 event.setException(exception);
323
324 repositoryEventDispatcher.dispatch(event.build());
325 }
326
327 private int getPolicy(RepositorySystemSession session, Artifact a, ArtifactDescriptorRequest request) {
328 ArtifactDescriptorPolicy policy = session.getArtifactDescriptorPolicy();
329 if (policy == null) {
330 return ArtifactDescriptorPolicy.STRICT;
331 }
332 return policy.getPolicy(session, new ArtifactDescriptorPolicyRequest(a, request.getRequestContext()));
333 }
334 }