1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.graph;
20
21 import javax.inject.Inject;
22 import javax.inject.Named;
23 import javax.inject.Singleton;
24
25 import java.io.File;
26 import java.util.ArrayList;
27 import java.util.Collections;
28 import java.util.HashMap;
29 import java.util.HashSet;
30 import java.util.Iterator;
31 import java.util.List;
32 import java.util.Map;
33 import java.util.Set;
34
35 import org.apache.maven.MavenExecutionException;
36 import org.apache.maven.ProjectCycleException;
37 import org.apache.maven.artifact.ArtifactUtils;
38 import org.apache.maven.execution.BuildResumptionDataRepository;
39 import org.apache.maven.execution.MavenExecutionRequest;
40 import org.apache.maven.execution.MavenSession;
41 import org.apache.maven.execution.ProjectActivation;
42 import org.apache.maven.execution.ProjectDependencyGraph;
43 import org.apache.maven.model.Plugin;
44 import org.apache.maven.model.building.DefaultModelProblem;
45 import org.apache.maven.model.building.Result;
46 import org.apache.maven.project.DuplicateProjectException;
47 import org.apache.maven.project.MavenProject;
48 import org.apache.maven.project.ProjectBuildingException;
49 import org.apache.maven.project.collector.MultiModuleCollectionStrategy;
50 import org.apache.maven.project.collector.PomlessCollectionStrategy;
51 import org.apache.maven.project.collector.RequestPomCollectionStrategy;
52 import org.codehaus.plexus.util.StringUtils;
53 import org.codehaus.plexus.util.dag.CycleDetectedException;
54 import org.slf4j.Logger;
55 import org.slf4j.LoggerFactory;
56
57 import static java.util.Comparator.comparing;
58
59
60
61
62 @Named(GraphBuilder.HINT)
63 @Singleton
64 public class DefaultGraphBuilder implements GraphBuilder {
65 private static final Logger LOGGER = LoggerFactory.getLogger(DefaultGraphBuilder.class);
66
67 private final BuildResumptionDataRepository buildResumptionDataRepository;
68 private final PomlessCollectionStrategy pomlessCollectionStrategy;
69 private final MultiModuleCollectionStrategy multiModuleCollectionStrategy;
70 private final RequestPomCollectionStrategy requestPomCollectionStrategy;
71 private final ProjectSelector projectSelector;
72
73
74
75
76
77 @Deprecated
78 public DefaultGraphBuilder() {
79 this(null, null, null, null);
80 }
81
82 @Inject
83 public DefaultGraphBuilder(
84 BuildResumptionDataRepository buildResumptionDataRepository,
85 PomlessCollectionStrategy pomlessCollectionStrategy,
86 MultiModuleCollectionStrategy multiModuleCollectionStrategy,
87 RequestPomCollectionStrategy requestPomCollectionStrategy) {
88 this.buildResumptionDataRepository = buildResumptionDataRepository;
89 this.pomlessCollectionStrategy = pomlessCollectionStrategy;
90 this.multiModuleCollectionStrategy = multiModuleCollectionStrategy;
91 this.requestPomCollectionStrategy = requestPomCollectionStrategy;
92 this.projectSelector = new ProjectSelector();
93 }
94
95 @Override
96 public Result<ProjectDependencyGraph> build(MavenSession session) {
97 try {
98 Result<ProjectDependencyGraph> result = sessionDependencyGraph(session);
99
100 if (result == null) {
101 final List<MavenProject> projects = getProjectsForMavenReactor(session);
102 validateProjects(projects, session.getRequest());
103 enrichRequestFromResumptionData(projects, session.getRequest());
104 result = reactorDependencyGraph(session, projects);
105 }
106
107 return result;
108 } catch (final ProjectBuildingException | DuplicateProjectException | MavenExecutionException e) {
109 return Result.error(Collections.singletonList(new DefaultModelProblem(null, null, null, null, 0, 0, e)));
110 } catch (final CycleDetectedException e) {
111 String message = "The projects in the reactor contain a cyclic reference: " + e.getMessage();
112 ProjectCycleException error = new ProjectCycleException(message, e);
113 return Result.error(
114 Collections.singletonList(new DefaultModelProblem(null, null, null, null, 0, 0, error)));
115 }
116 }
117
118 private Result<ProjectDependencyGraph> sessionDependencyGraph(final MavenSession session)
119 throws CycleDetectedException, DuplicateProjectException {
120 Result<ProjectDependencyGraph> result = null;
121
122 if (session.getProjectDependencyGraph() != null || session.getProjects() != null) {
123 final ProjectDependencyGraph graph =
124 new DefaultProjectDependencyGraph(session.getAllProjects(), session.getProjects());
125
126 result = Result.success(graph);
127 }
128
129 return result;
130 }
131
132 private Result<ProjectDependencyGraph> reactorDependencyGraph(MavenSession session, List<MavenProject> projects)
133 throws CycleDetectedException, DuplicateProjectException, MavenExecutionException {
134 ProjectDependencyGraph projectDependencyGraph = new DefaultProjectDependencyGraph(projects);
135 List<MavenProject> activeProjects = projectDependencyGraph.getSortedProjects();
136 List<MavenProject> allSortedProjects = projectDependencyGraph.getSortedProjects();
137 activeProjects = trimProjectsToRequest(activeProjects, projectDependencyGraph, session.getRequest());
138 activeProjects =
139 trimSelectedProjects(activeProjects, allSortedProjects, projectDependencyGraph, session.getRequest());
140 activeProjects = trimResumedProjects(activeProjects, projectDependencyGraph, session.getRequest());
141 activeProjects = trimExcludedProjects(activeProjects, projectDependencyGraph, session.getRequest());
142
143 if (activeProjects.size() != projectDependencyGraph.getSortedProjects().size()) {
144 projectDependencyGraph = new FilteredProjectDependencyGraph(projectDependencyGraph, activeProjects);
145 }
146
147 return Result.success(projectDependencyGraph);
148 }
149
150 private List<MavenProject> trimProjectsToRequest(
151 List<MavenProject> activeProjects, ProjectDependencyGraph graph, MavenExecutionRequest request)
152 throws MavenExecutionException {
153 List<MavenProject> result = activeProjects;
154
155 if (request.getPom() != null) {
156 result = getProjectsInRequestScope(request, activeProjects);
157
158 List<MavenProject> sortedProjects = graph.getSortedProjects();
159 result.sort(comparing(sortedProjects::indexOf));
160
161 result = includeAlsoMakeTransitively(result, request, graph);
162 }
163
164 return result;
165 }
166
167 private List<MavenProject> trimSelectedProjects(
168 List<MavenProject> projects,
169 List<MavenProject> allSortedProjects,
170 ProjectDependencyGraph graph,
171 MavenExecutionRequest request)
172 throws MavenExecutionException {
173 List<MavenProject> result = projects;
174
175 ProjectActivation projectActivation = request.getProjectActivation();
176 Set<String> requiredSelectors = projectActivation.getRequiredActiveProjectSelectors();
177 Set<String> optionalSelectors = projectActivation.getOptionalActiveProjectSelectors();
178 if (!requiredSelectors.isEmpty() || !optionalSelectors.isEmpty()) {
179 Set<MavenProject> selectedProjects = new HashSet<>(requiredSelectors.size() + optionalSelectors.size());
180 selectedProjects.addAll(
181 projectSelector.getRequiredProjectsBySelectors(request, allSortedProjects, requiredSelectors));
182 selectedProjects.addAll(
183 projectSelector.getOptionalProjectsBySelectors(request, allSortedProjects, optionalSelectors));
184
185
186 if (!selectedProjects.isEmpty()) {
187 result = new ArrayList<>(selectedProjects);
188
189 result = includeAlsoMakeTransitively(result, request, graph);
190
191
192 List<MavenProject> sortedProjects = graph.getSortedProjects();
193 result.sort(comparing(sortedProjects::indexOf));
194 }
195 }
196
197 return result;
198 }
199
200 private List<MavenProject> trimResumedProjects(
201 List<MavenProject> projects, ProjectDependencyGraph graph, MavenExecutionRequest request)
202 throws MavenExecutionException {
203 List<MavenProject> result = projects;
204
205 if (StringUtils.isNotEmpty(request.getResumeFrom())) {
206 File reactorDirectory = projectSelector.getBaseDirectoryFromRequest(request);
207
208 String selector = request.getResumeFrom();
209
210 MavenProject resumingFromProject = projects.stream()
211 .filter(project -> projectSelector.isMatchingProject(project, selector, reactorDirectory))
212 .findFirst()
213 .orElseThrow(() -> new MavenExecutionException(
214 "Could not find project to resume reactor build from: " + selector + " vs "
215 + formatProjects(projects),
216 request.getPom()));
217 int resumeFromProjectIndex = projects.indexOf(resumingFromProject);
218 List<MavenProject> retainingProjects = result.subList(resumeFromProjectIndex, projects.size());
219
220 result = includeAlsoMakeTransitively(retainingProjects, request, graph);
221 }
222
223 return result;
224 }
225
226 private List<MavenProject> trimExcludedProjects(
227 List<MavenProject> projects, ProjectDependencyGraph graph, MavenExecutionRequest request)
228 throws MavenExecutionException {
229 List<MavenProject> result = projects;
230
231 ProjectActivation projectActivation = request.getProjectActivation();
232 Set<String> requiredSelectors = projectActivation.getRequiredInactiveProjectSelectors();
233 Set<String> optionalSelectors = projectActivation.getOptionalInactiveProjectSelectors();
234 if (!requiredSelectors.isEmpty() || !optionalSelectors.isEmpty()) {
235 Set<MavenProject> excludedProjects = new HashSet<>(requiredSelectors.size() + optionalSelectors.size());
236 List<MavenProject> allProjects = graph.getAllProjects();
237 excludedProjects.addAll(
238 projectSelector.getRequiredProjectsBySelectors(request, allProjects, requiredSelectors));
239 excludedProjects.addAll(
240 projectSelector.getOptionalProjectsBySelectors(request, allProjects, optionalSelectors));
241
242 result = new ArrayList<>(projects);
243 result.removeAll(excludedProjects);
244
245 if (result.isEmpty()) {
246 boolean isPlural = excludedProjects.size() > 1;
247 String message = String.format(
248 "The project exclusion%s in --projects/-pl resulted in an "
249 + "empty reactor, please correct %s.",
250 isPlural ? "s" : "", isPlural ? "them" : "it");
251 throw new MavenExecutionException(message, request.getPom());
252 }
253 }
254
255 return result;
256 }
257
258 private List<MavenProject> includeAlsoMakeTransitively(
259 List<MavenProject> projects, MavenExecutionRequest request, ProjectDependencyGraph graph)
260 throws MavenExecutionException {
261 List<MavenProject> result = projects;
262
263 String makeBehavior = request.getMakeBehavior();
264 boolean makeBoth = MavenExecutionRequest.REACTOR_MAKE_BOTH.equals(makeBehavior);
265
266 boolean makeUpstream = makeBoth || MavenExecutionRequest.REACTOR_MAKE_UPSTREAM.equals(makeBehavior);
267 boolean makeDownstream = makeBoth || MavenExecutionRequest.REACTOR_MAKE_DOWNSTREAM.equals(makeBehavior);
268
269 if (StringUtils.isNotEmpty(makeBehavior) && !makeUpstream && !makeDownstream) {
270 throw new MavenExecutionException("Invalid reactor make behavior: " + makeBehavior, request.getPom());
271 }
272
273 if (makeUpstream || makeDownstream) {
274 Set<MavenProject> projectsSet = new HashSet<>(projects);
275
276 for (MavenProject project : projects) {
277 if (makeUpstream) {
278 projectsSet.addAll(graph.getUpstreamProjects(project, true));
279 }
280 if (makeDownstream) {
281 projectsSet.addAll(graph.getDownstreamProjects(project, true));
282 }
283 }
284
285 result = new ArrayList<>(projectsSet);
286
287
288 List<MavenProject> sortedProjects = graph.getSortedProjects();
289 result.sort(comparing(sortedProjects::indexOf));
290 }
291
292 return result;
293 }
294
295 private void enrichRequestFromResumptionData(List<MavenProject> projects, MavenExecutionRequest request) {
296 if (request.isResume()) {
297 projects.stream()
298 .filter(MavenProject::isExecutionRoot)
299 .findFirst()
300 .ifPresent(rootProject -> buildResumptionDataRepository.applyResumptionData(request, rootProject));
301 }
302 }
303
304 private List<MavenProject> getProjectsInRequestScope(MavenExecutionRequest request, List<MavenProject> projects)
305 throws MavenExecutionException {
306 if (request.getPom() == null) {
307 return projects;
308 }
309
310 MavenProject requestPomProject = projects.stream()
311 .filter(project -> request.getPom().equals(project.getFile()))
312 .findFirst()
313 .orElseThrow(() -> new MavenExecutionException(
314 "Could not find a project in reactor matching the request POM", request.getPom()));
315
316 List<MavenProject> modules = requestPomProject.getCollectedProjects() != null
317 ? requestPomProject.getCollectedProjects()
318 : Collections.emptyList();
319
320 List<MavenProject> result = new ArrayList<>(modules);
321 result.add(requestPomProject);
322 return result;
323 }
324
325 private String formatProjects(List<MavenProject> projects) {
326 StringBuilder projectNames = new StringBuilder();
327 Iterator<MavenProject> iterator = projects.iterator();
328 while (iterator.hasNext()) {
329 MavenProject project = iterator.next();
330 projectNames.append(project.getGroupId()).append(":").append(project.getArtifactId());
331 if (iterator.hasNext()) {
332 projectNames.append(", ");
333 }
334 }
335 return projectNames.toString();
336 }
337
338
339
340
341
342
343
344 private List<MavenProject> getProjectsForMavenReactor(MavenSession session) throws ProjectBuildingException {
345 MavenExecutionRequest request = session.getRequest();
346 request.getProjectBuildingRequest().setRepositorySession(session.getRepositorySession());
347
348
349 if (request.getPom() == null) {
350 return pomlessCollectionStrategy.collectProjects(request);
351 }
352
353
354 if (request.getMakeBehavior() != null || !request.getProjectActivation().isEmpty()) {
355 List<MavenProject> projects = multiModuleCollectionStrategy.collectProjects(request);
356 if (!projects.isEmpty()) {
357 return projects;
358 }
359 }
360
361
362 return requestPomCollectionStrategy.collectProjects(request);
363 }
364
365 private void validateProjects(List<MavenProject> projects, MavenExecutionRequest request)
366 throws MavenExecutionException {
367 Map<String, MavenProject> projectsMap = new HashMap<>();
368
369 List<MavenProject> projectsInRequestScope = getProjectsInRequestScope(request, projects);
370 for (MavenProject p : projectsInRequestScope) {
371 String projectKey = ArtifactUtils.key(p.getGroupId(), p.getArtifactId(), p.getVersion());
372
373 projectsMap.put(projectKey, p);
374 }
375
376 for (MavenProject project : projects) {
377
378 for (Plugin plugin : project.getBuildPlugins()) {
379 if (plugin.isExtensions()) {
380 String pluginKey =
381 ArtifactUtils.key(plugin.getGroupId(), plugin.getArtifactId(), plugin.getVersion());
382
383 if (projectsMap.containsKey(pluginKey)) {
384 LOGGER.warn(
385 "'{}' uses '{}' as extension which is not possible within the same reactor build. "
386 + "This plugin was pulled from the local repository!",
387 project.getName(),
388 plugin.getKey());
389 }
390 }
391 }
392 }
393 }
394 }