This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git
The following commit(s) were added to refs/heads/master by this push:
new e11b475e8b [MNG-8052] Concurrently lifecycle executor (#1429)
e11b475e8b is described below
commit e11b475e8bae20e8a2b3c0bebcacf4ef354a062e
Author: Guillaume Nodet <gno...@gmail.com>
AuthorDate: Thu Aug 29 19:44:53 2024 +0200
[MNG-8052] Concurrently lifecycle executor (#1429)
---
.../main/java/org/apache/maven/api/Lifecycle.java | 1 +
maven-core/pom.xml | 8 +
.../org/apache/maven/execution/BuildFailure.java | 14 +-
.../org/apache/maven/execution/BuildSuccess.java | 13 +-
.../org/apache/maven/execution/BuildSummary.java | 36 +-
.../internal/CompoundProjectExecutionListener.java | 4 +-
.../maven/lifecycle/internal/MojoExecutor.java | 91 +-
.../lifecycle/internal/concurrent/BuildPlan.java | 166 ++++
.../internal/concurrent/BuildPlanExecutor.java | 939 +++++++++++++++++++++
.../internal/concurrent/BuildPlanLogger.java | 177 ++++
.../lifecycle/internal/concurrent/BuildStep.java | 133 +++
.../concurrent/ConcurrentLifecycleStarter.java | 191 +++++
.../internal/concurrent/ConcurrentLogOutput.java | 81 ++
.../internal/concurrent/MojoExecutor.java | 59 ++
.../internal/concurrent/PhasingExecutor.java | 54 ++
.../internal/concurrent/PluginLifecycle.java | 94 +++
.../internal/concurrent/BuildPlanCreatorTest.java | 144 ++++
.../internal/concurrent/PhasingExecutorTest.java} | 37 +-
18 files changed, 2180 insertions(+), 62 deletions(-)
diff --git
a/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
b/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
index 40d2715e33..c7612a1d84 100644
--- a/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
+++ b/api/maven-api-core/src/main/java/org/apache/maven/api/Lifecycle.java
@@ -56,6 +56,7 @@ public interface Lifecycle extends ExtensibleEnum {
// ======================
String BEFORE = "before:";
String AFTER = "after:";
+ String AT = "at:";
/**
* Name or identifier of this lifecycle.
diff --git a/maven-core/pom.xml b/maven-core/pom.xml
index f79a0d40df..39eca04145 100644
--- a/maven-core/pom.xml
+++ b/maven-core/pom.xml
@@ -91,6 +91,14 @@ under the License.
<groupId>org.apache.maven</groupId>
<artifactId>maven-api-impl</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-jline</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.maven</groupId>
+ <artifactId>maven-slf4j-provider</artifactId>
+ </dependency>
<dependency>
<groupId>org.apache.maven.resolver</groupId>
<artifactId>maven-resolver-api</artifactId>
diff --git
a/maven-core/src/main/java/org/apache/maven/execution/BuildFailure.java
b/maven-core/src/main/java/org/apache/maven/execution/BuildFailure.java
index cd7155076d..2c43f1e943 100644
--- a/maven-core/src/main/java/org/apache/maven/execution/BuildFailure.java
+++ b/maven-core/src/main/java/org/apache/maven/execution/BuildFailure.java
@@ -39,7 +39,19 @@ public class BuildFailure extends BuildSummary {
* @param cause The cause of the build failure, may be {@code null}.
*/
public BuildFailure(MavenProject project, long time, Throwable cause) {
- super(project, time);
+ this(project, time, time, cause);
+ }
+
+ /**
+ * Creates a new build summary for the specified project.
+ *
+ * @param project The project being summarized, must not be {@code null}.
+ * @param execTime The exec time of the project in milliseconds.
+ * @param wallTime The wall time of the project in milliseconds.
+ * @param cause The cause of the build failure, may be {@code null}.
+ */
+ public BuildFailure(MavenProject project, long execTime, long wallTime,
Throwable cause) {
+ super(project, execTime, wallTime);
this.cause = cause;
}
diff --git
a/maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
b/maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
index 0f0310d3cd..a2a4546b23 100644
--- a/maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
+++ b/maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
@@ -33,6 +33,17 @@ public class BuildSuccess extends BuildSummary {
* @param time The build time of the project in milliseconds.
*/
public BuildSuccess(MavenProject project, long time) {
- super(project, time);
+ super(project, time, time);
+ }
+
+ /**
+ * Creates a new build summary for the specified project.
+ *
+ * @param project The project being summarized, must not be {@code null}.
+ * @param wallTime The wall time of the project in milliseconds.
+ * @param execTime The exec time of the project in milliseconds.
+ */
+ public BuildSuccess(MavenProject project, long wallTime, long execTime) {
+ super(project, wallTime, execTime);
}
}
diff --git
a/maven-core/src/main/java/org/apache/maven/execution/BuildSummary.java
b/maven-core/src/main/java/org/apache/maven/execution/BuildSummary.java
index 657afb31eb..efc0da1d8b 100644
--- a/maven-core/src/main/java/org/apache/maven/execution/BuildSummary.java
+++ b/maven-core/src/main/java/org/apache/maven/execution/BuildSummary.java
@@ -36,7 +36,12 @@ public abstract class BuildSummary {
/**
* The build time of the project in milliseconds.
*/
- private final long time;
+ private final long wallTime;
+
+ /**
+ * The total amount of time spent for to run mojos in milliseconds.
+ */
+ private final long execTime;
/**
* Creates a new build summary for the specified project.
@@ -45,9 +50,21 @@ public abstract class BuildSummary {
* @param time The build time of the project in milliseconds.
*/
protected BuildSummary(MavenProject project, long time) {
+ this(project, time, time);
+ }
+
+ /**
+ * Creates a new build summary for the specified project.
+ *
+ * @param project The project being summarized, must not be {@code null}.
+ * @param execTime The exec time of the project in milliseconds.
+ * @param wallTime The wall time of the project in milliseconds.
+ */
+ protected BuildSummary(MavenProject project, long execTime, long wallTime)
{
this.project = Objects.requireNonNull(project, "project cannot be
null");
// TODO Validate for < 0?
- this.time = time;
+ this.execTime = execTime;
+ this.wallTime = wallTime;
}
/**
@@ -60,11 +77,20 @@ public abstract class BuildSummary {
}
/**
- * Gets the build time of the project in milliseconds.
+ * Gets the wall time of the project in milliseconds.
*
- * @return The build time of the project in milliseconds.
+ * @return The wall time of the project in milliseconds.
*/
public long getTime() {
- return time;
+ return execTime;
+ }
+
+ /**
+ * Gets the exec time of the project in milliseconds.
+ *
+ * @return The exec time of the project in milliseconds.
+ */
+ public long getWallTime() {
+ return wallTime;
}
}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/CompoundProjectExecutionListener.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/CompoundProjectExecutionListener.java
index 34cee12b95..33eb878aab 100644
---
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/CompoundProjectExecutionListener.java
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/CompoundProjectExecutionListener.java
@@ -24,10 +24,10 @@ import org.apache.maven.execution.ProjectExecutionEvent;
import org.apache.maven.execution.ProjectExecutionListener;
import org.apache.maven.lifecycle.LifecycleExecutionException;
-class CompoundProjectExecutionListener implements ProjectExecutionListener {
+public class CompoundProjectExecutionListener implements
ProjectExecutionListener {
private final Collection<ProjectExecutionListener> listeners;
- CompoundProjectExecutionListener(Collection<ProjectExecutionListener>
listeners) {
+ public
CompoundProjectExecutionListener(Collection<ProjectExecutionListener>
listeners) {
this.listeners = listeners; // NB this is live injected collection
}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java
index 0c3779ae7a..7a479d4d2f 100644
---
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/MojoExecutor.java
@@ -214,6 +214,13 @@ public class MojoExecutor {
doExecute(session, mojoExecution, dependencyContext);
}
+ protected static class NoLock implements NoExceptionCloseable {
+ public NoLock() {}
+
+ @Override
+ public void close() {}
+ }
+
/**
* Aggregating mojo executions (possibly) modify all MavenProjects,
including those that are currently in use
* by concurrently running mojo executions. To prevent race conditions, an
aggregating execution will block
@@ -222,54 +229,45 @@ public class MojoExecutor {
* TODO: ideally, the builder should take care of the ordering in a
smarter way
* TODO: and concurrency issues fixed with MNG-7157
*/
- private class ProjectLock implements AutoCloseable {
+ protected class ProjectLock implements NoExceptionCloseable {
final Lock acquiredAggregatorLock;
final OwnerReentrantLock acquiredProjectLock;
ProjectLock(MavenSession session, MojoDescriptor mojoDescriptor) {
mojos.put(Thread.currentThread(), mojoDescriptor);
- if (session.getRequest().getDegreeOfConcurrency() > 1) {
- boolean aggregator = mojoDescriptor.isAggregator();
- acquiredAggregatorLock = aggregator ?
aggregatorLock.writeLock() : aggregatorLock.readLock();
- acquiredProjectLock = getProjectLock(session);
- if (!acquiredAggregatorLock.tryLock()) {
- Thread owner = aggregatorLock.getOwner();
- MojoDescriptor ownerMojo = owner != null ?
mojos.get(owner) : null;
- String str = ownerMojo != null ? " The " +
ownerMojo.getId() : "An";
- String msg = str + " aggregator mojo is already being
executed "
- + "in this parallel build, those kind of mojos
require exclusive access to "
- + "reactor to prevent race conditions. This mojo
execution will be blocked "
- + "until the aggregator mojo is done.";
- warn(msg);
- acquiredAggregatorLock.lock();
- }
- if (!acquiredProjectLock.tryLock()) {
- Thread owner = acquiredProjectLock.getOwner();
- MojoDescriptor ownerMojo = owner != null ?
mojos.get(owner) : null;
- String str = ownerMojo != null ? " The " +
ownerMojo.getId() : "A";
- String msg = str + " mojo is already being executed "
- + "on the project " +
session.getCurrentProject().getGroupId()
- + ":" +
session.getCurrentProject().getArtifactId() + ". "
- + "This mojo execution will be blocked "
- + "until the mojo is done.";
- warn(msg);
- acquiredProjectLock.lock();
- }
- } else {
- acquiredAggregatorLock = null;
- acquiredProjectLock = null;
+ boolean aggregator = mojoDescriptor.isAggregator();
+ acquiredAggregatorLock = aggregator ? aggregatorLock.writeLock() :
aggregatorLock.readLock();
+ acquiredProjectLock = getProjectLock(session);
+ if (!acquiredAggregatorLock.tryLock()) {
+ Thread owner = aggregatorLock.getOwner();
+ MojoDescriptor ownerMojo = owner != null ? mojos.get(owner) :
null;
+ String str = ownerMojo != null ? " The " + ownerMojo.getId() :
"An";
+ String msg = str + " aggregator mojo is already being executed
"
+ + "in this parallel build, those kind of mojos require
exclusive access to "
+ + "reactor to prevent race conditions. This mojo
execution will be blocked "
+ + "until the aggregator mojo is done.";
+ warn(msg);
+ acquiredAggregatorLock.lock();
+ }
+ if (!acquiredProjectLock.tryLock()) {
+ Thread owner = acquiredProjectLock.getOwner();
+ MojoDescriptor ownerMojo = owner != null ? mojos.get(owner) :
null;
+ String str = ownerMojo != null ? " The " + ownerMojo.getId() :
"A";
+ String msg = str + " mojo is already being executed "
+ + "on the project " +
session.getCurrentProject().getGroupId()
+ + ":" + session.getCurrentProject().getArtifactId() +
". "
+ + "This mojo execution will be blocked "
+ + "until the mojo is done.";
+ warn(msg);
+ acquiredProjectLock.lock();
}
}
@Override
public void close() {
// release the lock in the reverse order of the acquisition
- if (acquiredProjectLock != null) {
- acquiredProjectLock.unlock();
- }
- if (acquiredAggregatorLock != null) {
- acquiredAggregatorLock.unlock();
- }
+ acquiredProjectLock.unlock();
+ acquiredAggregatorLock.unlock();
mojos.remove(Thread.currentThread());
}
@@ -308,7 +306,7 @@ public class MojoExecutor {
ensureDependenciesAreResolved(mojoDescriptor, session,
dependencyContext);
- try (ProjectLock lock = new ProjectLock(session, mojoDescriptor)) {
+ try (NoExceptionCloseable lock = getProjectLock(session,
mojoDescriptor)) {
doExecute2(session, mojoExecution);
} finally {
for (MavenProject forkedProject : forkedProjects) {
@@ -317,6 +315,23 @@ public class MojoExecutor {
}
}
+ protected interface NoExceptionCloseable extends AutoCloseable {
+ @Override
+ void close();
+ }
+
+ protected NoExceptionCloseable getProjectLock(MavenSession session,
MojoDescriptor mojoDescriptor) {
+ if (useProjectLock(session)) {
+ return new ProjectLock(session, mojoDescriptor);
+ } else {
+ return new NoLock();
+ }
+ }
+
+ protected boolean useProjectLock(MavenSession session) {
+ return session.getRequest().getDegreeOfConcurrency() > 1;
+ }
+
private void doExecute2(MavenSession session, MojoExecution mojoExecution)
throws LifecycleExecutionException {
eventCatapult.fire(ExecutionEvent.Type.MojoStarted, session,
mojoExecution);
try {
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlan.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlan.java
new file mode 100644
index 0000000000..222a1ecd77
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlan.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.plugin.MojoExecution;
+import org.apache.maven.project.MavenProject;
+
+public class BuildPlan {
+
+ private final Map<MavenProject, Map<String, BuildStep>> plan = new
LinkedHashMap<>();
+ private final Map<MavenProject, List<MavenProject>> projects;
+ private final Map<String, String> aliases = new HashMap<>();
+ private volatile Set<String> duplicateIds;
+ private volatile List<BuildStep> sortedNodes;
+
+ BuildPlan() {
+ this.projects = null;
+ }
+
+ public BuildPlan(Map<MavenProject, List<MavenProject>> projects) {
+ this.projects = projects;
+ }
+
+ public Map<MavenProject, List<MavenProject>> getAllProjects() {
+ return projects;
+ }
+
+ public Map<String, String> aliases() {
+ return aliases;
+ }
+
+ public Stream<MavenProject> projects() {
+ return plan.keySet().stream();
+ }
+
+ public void addProject(MavenProject project, Map<String, BuildStep> steps)
{
+ plan.put(project, steps);
+ }
+
+ public void addStep(MavenProject project, String name, BuildStep step) {
+ plan.get(project).put(name, step);
+ }
+
+ public Stream<BuildStep> allSteps() {
+ return plan.values().stream().flatMap(m -> m.values().stream());
+ }
+
+ public Stream<BuildStep> steps(MavenProject project) {
+ return Optional.ofNullable(plan.get(project))
+ .map(m -> m.values().stream())
+ .orElse(Stream.empty());
+ }
+
+ public Optional<BuildStep> step(MavenProject project, String name) {
+ return Optional.ofNullable(plan.get(project)).map(m -> m.get(name));
+ }
+
+ public BuildStep requiredStep(MavenProject project, String name) {
+ return step(project, name).get();
+ }
+
+ // add a follow-up plan to this one
+ public void then(BuildPlan step) {
+ step.plan.forEach((k, v) -> plan.merge(k, v, this::merge));
+ aliases.putAll(step.aliases);
+ }
+
+ private Map<String, BuildStep> merge(Map<String, BuildStep> org,
Map<String, BuildStep> add) {
+ // all new phases should be added after the existing ones
+ List<BuildStep> lasts =
+ org.values().stream().filter(b ->
b.successors.isEmpty()).collect(Collectors.toList());
+ List<BuildStep> firsts =
+ add.values().stream().filter(b ->
b.predecessors.isEmpty()).collect(Collectors.toList());
+ firsts.stream()
+ .filter(addNode -> !org.containsKey(addNode.name))
+ .forEach(addNode -> lasts.forEach(orgNode ->
addNode.executeAfter(orgNode)));
+ add.forEach((name, node) -> org.merge(name, node, this::merge));
+ return org;
+ }
+
+ private BuildStep merge(BuildStep node1, BuildStep node2) {
+ node1.predecessors.addAll(node2.predecessors);
+ node1.successors.addAll(node2.successors);
+ node2.mojos.forEach((k, v) -> node1.mojos.merge(k, v,
this::mergeMojos));
+ return node1;
+ }
+
+ private Map<String, MojoExecution> mergeMojos(Map<String, MojoExecution>
l1, Map<String, MojoExecution> l2) {
+ l2.forEach(l1::putIfAbsent);
+ return l1;
+ }
+
+ // gather artifactIds which are not unique so that the respective thread
names can be extended with the groupId
+ public Set<String> duplicateIds() {
+ if (duplicateIds == null) {
+ synchronized (this) {
+ if (duplicateIds == null) {
+ duplicateIds = projects()
+ .map(MavenProject::getArtifactId)
+
.collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
+ .entrySet()
+ .stream()
+ .filter(p -> p.getValue() > 1)
+ .map(Map.Entry::getKey)
+ .collect(Collectors.toSet());
+ }
+ }
+ }
+ return duplicateIds;
+ }
+
+ public List<BuildStep> sortedNodes() {
+ if (sortedNodes == null) {
+ synchronized (this) {
+ if (sortedNodes == null) {
+ List<BuildStep> sortedNodes = new ArrayList<>();
+ Set<BuildStep> visited = new HashSet<>();
+ // Visit each unvisited node
+ allSteps().forEach(node -> visitNode(node, visited,
sortedNodes));
+ // Reverse the sorted nodes to get the correct order
+ Collections.reverse(sortedNodes);
+ this.sortedNodes = sortedNodes;
+ }
+ }
+ }
+ return sortedNodes;
+ }
+
+ // Helper method to visit a node
+ private static void visitNode(BuildStep node, Set<BuildStep> visited,
List<BuildStep> sortedNodes) {
+ if (visited.add(node)) {
+ // For each successor of the current node, visit unvisited
successors
+ node.successors.forEach(successor -> visitNode(successor, visited,
sortedNodes));
+ sortedNodes.add(node);
+ }
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
new file mode 100644
index 0000000000..6f77b92781
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
@@ -0,0 +1,939 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.xml.stream.XMLStreamException;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.api.Lifecycle;
+import org.apache.maven.api.services.LifecycleRegistry;
+import org.apache.maven.api.services.MavenException;
+import org.apache.maven.api.xml.XmlNode;
+import org.apache.maven.execution.BuildFailure;
+import org.apache.maven.execution.BuildSuccess;
+import org.apache.maven.execution.ExecutionEvent;
+import org.apache.maven.execution.MavenExecutionRequest;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.execution.ProjectDependencyGraph;
+import org.apache.maven.execution.ProjectExecutionEvent;
+import org.apache.maven.execution.ProjectExecutionListener;
+import org.apache.maven.internal.MultilineMessageHelper;
+import org.apache.maven.internal.transformation.ConsumerPomArtifactTransformer;
+import org.apache.maven.internal.xml.XmlNodeImpl;
+import org.apache.maven.lifecycle.LifecycleExecutionException;
+import org.apache.maven.lifecycle.LifecycleNotFoundException;
+import org.apache.maven.lifecycle.LifecyclePhaseNotFoundException;
+import org.apache.maven.lifecycle.MojoExecutionConfigurator;
+import org.apache.maven.lifecycle.internal.BuildThreadFactory;
+import org.apache.maven.lifecycle.internal.CompoundProjectExecutionListener;
+import org.apache.maven.lifecycle.internal.DefaultLifecyclePluginAnalyzer;
+import org.apache.maven.lifecycle.internal.ExecutionEventCatapult;
+import org.apache.maven.lifecycle.internal.GoalTask;
+import org.apache.maven.lifecycle.internal.LifecycleTask;
+import org.apache.maven.lifecycle.internal.MojoDescriptorCreator;
+import org.apache.maven.lifecycle.internal.MojoExecutor;
+import org.apache.maven.lifecycle.internal.ReactorContext;
+import org.apache.maven.lifecycle.internal.Task;
+import org.apache.maven.lifecycle.internal.TaskSegment;
+import org.apache.maven.model.Plugin;
+import org.apache.maven.model.PluginExecution;
+import org.apache.maven.plugin.MavenPluginManager;
+import org.apache.maven.plugin.MojoExecution;
+import org.apache.maven.plugin.MojoNotFoundException;
+import org.apache.maven.plugin.PluginDescriptorParsingException;
+import org.apache.maven.plugin.descriptor.MojoDescriptor;
+import org.apache.maven.plugin.descriptor.Parameter;
+import org.apache.maven.plugin.descriptor.PluginDescriptor;
+import org.apache.maven.project.MavenProject;
+import org.codehaus.plexus.classworlds.realm.ClassRealm;
+import org.eclipse.aether.repository.RemoteRepository;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.maven.api.Lifecycle.AFTER;
+import static org.apache.maven.api.Lifecycle.AT;
+import static org.apache.maven.api.Lifecycle.BEFORE;
+import static org.apache.maven.api.Lifecycle.Phase.PACKAGE;
+import static org.apache.maven.api.Lifecycle.Phase.READY;
+import static org.apache.maven.lifecycle.internal.concurrent.BuildStep.CREATED;
+import static
org.apache.maven.lifecycle.internal.concurrent.BuildStep.EXECUTED;
+import static org.apache.maven.lifecycle.internal.concurrent.BuildStep.FAILED;
+import static org.apache.maven.lifecycle.internal.concurrent.BuildStep.PLAN;
+import static
org.apache.maven.lifecycle.internal.concurrent.BuildStep.PLANNING;
+import static
org.apache.maven.lifecycle.internal.concurrent.BuildStep.SCHEDULED;
+import static org.apache.maven.lifecycle.internal.concurrent.BuildStep.SETUP;
+import static
org.apache.maven.lifecycle.internal.concurrent.BuildStep.TEARDOWN;
+
+/**
+ * Builds the full lifecycle in weave-mode (phase by phase as opposed to
project-by-project).
+ * <p>
+ * This builder uses a number of threads equal to the minimum of the degree of
concurrency (which is the thread count
+ * set with <code>-T</code> on the command-line) and the number of projects to
build. As such, building a single project
+ * will always result in a sequential build, regardless of the thread count.
+ * </p>
+ * <strong>NOTE:</strong> This class is not part of any public api and can be
changed or deleted without prior notice.
+ *
+ * @since 3.0
+ * Builds one or more lifecycles for a full module
+ * NOTE: This class is not part of any public api and can be changed
or deleted without prior notice.
+ */
+@Named
+public class BuildPlanExecutor {
+
+ private static final Object GLOBAL = new Object();
+
+ private final Logger logger = LoggerFactory.getLogger(getClass());
+
+ private final MojoExecutor mojoExecutor;
+ private final ExecutionEventCatapult eventCatapult;
+ private final ProjectExecutionListener projectExecutionListener;
+ private final ConsumerPomArtifactTransformer
consumerPomArtifactTransformer;
+ private final BuildPlanLogger buildPlanLogger;
+ private final Map<String, MojoExecutionConfigurator>
mojoExecutionConfigurators;
+ private final MavenPluginManager mavenPluginManager;
+ private final MojoDescriptorCreator mojoDescriptorCreator;
+ private final LifecycleRegistry lifecycles;
+
+ @Inject
+ @SuppressWarnings("checkstyle:ParameterNumber")
+ public BuildPlanExecutor(
+ @Named("concurrent") MojoExecutor mojoExecutor,
+ ExecutionEventCatapult eventCatapult,
+ List<ProjectExecutionListener> listeners,
+ ConsumerPomArtifactTransformer consumerPomArtifactTransformer,
+ BuildPlanLogger buildPlanLogger,
+ Map<String, MojoExecutionConfigurator> mojoExecutionConfigurators,
+ MavenPluginManager mavenPluginManager,
+ MojoDescriptorCreator mojoDescriptorCreator,
+ LifecycleRegistry lifecycles) {
+ this.mojoExecutor = mojoExecutor;
+ this.eventCatapult = eventCatapult;
+ this.projectExecutionListener = new
CompoundProjectExecutionListener(listeners);
+ this.consumerPomArtifactTransformer = consumerPomArtifactTransformer;
+ this.buildPlanLogger = buildPlanLogger;
+ this.mojoExecutionConfigurators = mojoExecutionConfigurators;
+ this.mavenPluginManager = mavenPluginManager;
+ this.mojoDescriptorCreator = mojoDescriptorCreator;
+ this.lifecycles = lifecycles;
+ }
+
+ public void execute(MavenSession session, ReactorContext reactorContext,
List<TaskSegment> taskSegments)
+ throws ExecutionException, InterruptedException {
+ try (BuildContext ctx = new BuildContext(session, reactorContext,
taskSegments)) {
+ ctx.execute();
+ }
+ }
+
+ class BuildContext implements AutoCloseable {
+ final MavenSession session;
+ final ReactorContext reactorContext;
+ final PhasingExecutor executor;
+ final ConcurrentLogOutput appender;
+ final Map<Object, Clock> clocks = new ConcurrentHashMap<>();
+ final ReadWriteLock lock = new ReentrantReadWriteLock();
+ final int threads;
+ BuildPlan plan;
+
+ BuildContext(MavenSession session, ReactorContext reactorContext,
List<TaskSegment> taskSegments) {
+ this.session = session;
+ this.reactorContext = reactorContext;
+ this.threads = Math.min(
+ session.getRequest().getDegreeOfConcurrency(),
+ session.getProjects().size());
+ // Propagate the parallel flag to the root session
+ session.setParallel(threads > 1);
+ this.executor = new
PhasingExecutor(Executors.newFixedThreadPool(threads, new
BuildThreadFactory()));
+ this.appender = new ConcurrentLogOutput();
+
+ // build initial plan
+ this.plan = buildInitialPlan(taskSegments);
+ }
+
+ BuildContext() {
+ this.session = null;
+ this.reactorContext = null;
+ this.threads = 1;
+ this.executor = null;
+ this.appender = null;
+ this.plan = null;
+ }
+
+ public BuildPlan buildInitialPlan(List<TaskSegment> taskSegments) {
+ int nThreads = Math.min(
+ session.getRequest().getDegreeOfConcurrency(),
+ session.getProjects().size());
+ boolean parallel = nThreads > 1;
+ // Propagate the parallel flag to the root session
+ session.setParallel(parallel);
+
+ ProjectDependencyGraph dependencyGraph =
session.getProjectDependencyGraph();
+ MavenProject rootProject = session.getTopLevelProject();
+
+ Map<MavenProject, List<MavenProject>> allProjects = new
LinkedHashMap<>();
+ dependencyGraph
+ .getSortedProjects()
+ .forEach(p -> allProjects.put(p,
dependencyGraph.getUpstreamProjects(p, false)));
+
+ BuildPlan plan = new BuildPlan(allProjects);
+ for (TaskSegment taskSegment : taskSegments) {
+ Map<MavenProject, List<MavenProject>> projects =
taskSegment.isAggregating()
+ ? Collections.singletonMap(rootProject,
allProjects.get(rootProject))
+ : allProjects;
+
+ BuildPlan segment = calculateMojoExecutions(projects,
taskSegment.getTasks());
+ plan.then(segment);
+ }
+
+ // Create plan, setup and teardown
+ for (MavenProject project : plan.getAllProjects().keySet()) {
+ BuildStep pplan = new BuildStep(PLAN, project, null);
+ pplan.status.set(PLANNING); // the plan step always need
planning
+ BuildStep setup = new BuildStep(SETUP, project, null);
+ BuildStep teardown = new BuildStep(TEARDOWN, project, null);
+ setup.executeAfter(pplan);
+ plan.steps(project).forEach(step -> {
+ if (step.predecessors.isEmpty()) {
+ step.executeAfter(setup);
+ } else if (step.successors.isEmpty()) {
+ teardown.executeAfter(step);
+ }
+ });
+ Stream.of(pplan, setup, teardown).forEach(step ->
plan.addStep(project, step.name, step));
+ }
+
+ return plan;
+ }
+
+ private void checkUnboundVersions(BuildPlan buildPlan) {
+ String defaulModelId =
DefaultLifecyclePluginAnalyzer.DEFAULTLIFECYCLEBINDINGS_MODELID;
+ List<String> unversionedPlugins = buildPlan
+ .allSteps()
+ .flatMap(step -> step.mojos.values().stream().flatMap(map
-> map.values().stream()))
+ .map(MojoExecution::getPlugin)
+ .filter(p -> p.getLocation("version") != null
+ && p.getLocation("version").getSource() != null
+ && defaulModelId.equals(
+
p.getLocation("version").getSource().getModelId()))
+ .distinct()
+ .map(Plugin::getArtifactId) // managed by us, groupId is
always o.a.m.plugins
+ .toList();
+ if (!unversionedPlugins.isEmpty()) {
+ logger.warn("Version not locked for default bindings plugins "
+ unversionedPlugins
+ + ", you should define versions in pluginManagement
section of your " + "pom.xml or parent");
+ }
+ }
+
+ private void checkThreadSafety(BuildPlan buildPlan) {
+ if (threads > 1) {
+ Set<MojoExecution> unsafeExecutions = buildPlan
+ .allSteps()
+ .flatMap(step ->
step.mojos.values().stream().flatMap(map -> map.values().stream()))
+ .filter(execution ->
!execution.getMojoDescriptor().isV4Api())
+ .collect(Collectors.toSet());
+ if (!unsafeExecutions.isEmpty()) {
+ for (String s : MultilineMessageHelper.format(
+ """
+ Your build is requesting concurrent execution,
but this project contains the \
+ following plugin(s) that have goals not built
with Maven 4 to support concurrent \
+ execution. While this /may/ work fine, please
look for plugin updates and/or \
+ request plugins be made thread-safe. If
reporting an issue, report it against the \
+ plugin in question, not against Apache
Maven.""")) {
+ logger.warn(s);
+ }
+ if (logger.isDebugEnabled()) {
+ Set<MojoDescriptor> unsafeGoals =
unsafeExecutions.stream()
+ .map(MojoExecution::getMojoDescriptor)
+ .collect(Collectors.toSet());
+ logger.warn("The following goals are not Maven 4
goals:");
+ for (MojoDescriptor unsafeGoal : unsafeGoals) {
+ logger.warn(" " + unsafeGoal.getId());
+ }
+ } else {
+ Set<Plugin> unsafePlugins = unsafeExecutions.stream()
+ .map(MojoExecution::getPlugin)
+ .collect(Collectors.toSet());
+ logger.warn("The following plugins are not Maven 4
plugins:");
+ for (Plugin unsafePlugin : unsafePlugins) {
+ logger.warn(" " + unsafePlugin.getId());
+ }
+ logger.warn("");
+ logger.warn("Enable verbose output (-X) to see
precisely which goals are not marked as"
+ + " thread-safe.");
+ }
+ logger.warn(MultilineMessageHelper.separatorLine());
+ }
+ }
+ }
+
+ void execute() {
+ try {
+ plan();
+ executePlan();
+ executor.await();
+ } catch (Exception e) {
+ session.getResult().addException(e);
+ }
+ }
+
+ @Override
+ public void close() {
+ this.appender.close();
+ this.executor.close();
+ }
+
+ private void executePlan() {
+ if (reactorContext.getReactorBuildStatus().isHalted()) {
+ return;
+ }
+ Clock global = clocks.computeIfAbsent(GLOBAL, p -> new Clock());
+ global.start();
+ lock.readLock().lock();
+ try {
+ plan.sortedNodes().stream()
+ .filter(step -> step.status.get() == CREATED)
+ .filter(step -> step.predecessors.stream().allMatch(s
-> s.status.get() == EXECUTED))
+ .filter(step -> step.status.compareAndSet(CREATED,
SCHEDULED))
+ .forEach(step -> {
+ boolean nextIsPlanning =
step.successors.stream().anyMatch(st -> PLAN.equals(st.name));
+ executor.execute(() -> {
+ try (AutoCloseable ctx =
appender.build(step.project)) {
+ executeStep(step);
+ if (nextIsPlanning) {
+ lock.writeLock().lock();
+ try {
+ plan();
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+ executePlan();
+ } catch (Exception e) {
+ step.status.compareAndSet(SCHEDULED,
FAILED);
+ global.stop();
+ handleBuildError(reactorContext, session,
step.project, e, global);
+ }
+ });
+ });
+ } finally {
+ lock.readLock().unlock();
+ }
+ }
+
+ private void executeStep(BuildStep step) throws IOException,
LifecycleExecutionException {
+ Clock clock = getClock(step.project);
+ switch (step.name) {
+ case PLAN:
+ // Planning steps should be executed out of normal
execution
+ throw new IllegalStateException();
+ case SETUP:
+ consumerPomArtifactTransformer.injectTransformedArtifacts(
+ session.getRepositorySession(), step.project);
+ projectExecutionListener.beforeProjectExecution(new
ProjectExecutionEvent(session, step.project));
+ eventCatapult.fire(ExecutionEvent.Type.ProjectStarted,
session, null);
+ break;
+ case TEARDOWN:
+ projectExecutionListener.afterProjectExecutionSuccess(
+ new ProjectExecutionEvent(session, step.project,
Collections.emptyList()));
+ reactorContext
+ .getResult()
+ .addBuildSummary(new BuildSuccess(step.project,
clock.wallTime(), clock.execTime()));
+ eventCatapult.fire(ExecutionEvent.Type.ProjectSucceeded,
session, null);
+ break;
+ default:
+ List<MojoExecution> executions =
step.executions().collect(Collectors.toList());
+ if (!executions.isEmpty()) {
+ attachToThread(step.project);
+ session.setCurrentProject(step.project);
+ clock.start();
+ executions.forEach(mojoExecution -> {
+
mojoExecutionConfigurator(mojoExecution).configure(step.project, mojoExecution,
true);
+ finalizeMojoConfiguration(mojoExecution);
+ });
+ mojoExecutor.execute(session, executions);
+ clock.stop();
+ }
+ break;
+ }
+ step.status.compareAndSet(SCHEDULED, EXECUTED);
+ }
+
+ private Clock getClock(Object key) {
+ return clocks.computeIfAbsent(key, p -> new Clock());
+ }
+
+ private void plan() {
+ lock.writeLock().lock();
+ try {
+ Set<BuildStep> planSteps = plan.allSteps()
+ .filter(st -> PLAN.equals(st.name))
+ .filter(step -> step.predecessors.stream().allMatch(s
-> s.status.get() == EXECUTED))
+ .filter(step -> step.status.compareAndSet(PLANNING,
SCHEDULED))
+ .collect(Collectors.toSet());
+ for (BuildStep step : planSteps) {
+ MavenProject project = step.project;
+ for (Plugin plugin : project.getBuild().getPlugins()) {
+ for (PluginExecution execution :
plugin.getExecutions()) {
+ for (String goal : execution.getGoals()) {
+ MojoDescriptor mojoDescriptor =
getMojoDescriptor(project, plugin, goal);
+ String phase =
+ execution.getPhase() != null ?
execution.getPhase() : mojoDescriptor.getPhase();
+ String tmpResolvedPhase =
plan.aliases().getOrDefault(phase, phase);
+ String resolvedPhase =
tmpResolvedPhase.startsWith(AT)
+ ?
tmpResolvedPhase.substring(AT.length())
+ : tmpResolvedPhase;
+ plan.step(project, resolvedPhase).ifPresent(n
-> {
+ MojoExecution mojoExecution = new
MojoExecution(mojoDescriptor, execution.getId());
+ mojoExecution.setLifecyclePhase(phase);
+ n.addMojo(mojoExecution,
execution.getPriority());
+ if
(mojoDescriptor.getDependencyCollectionRequired() != null
+ ||
mojoDescriptor.getDependencyResolutionRequired() != null) {
+ for (MavenProject p :
+
plan.getAllProjects().get(project)) {
+ plan.step(p, AFTER + PACKAGE)
+ .ifPresent(a ->
plan.requiredStep(project, resolvedPhase)
+ .executeAfter(a));
+ }
+ }
+ });
+ }
+ }
+ }
+ }
+
+ BuildPlan buildPlan = plan;
+ for (BuildStep step :
+ planSteps.stream().flatMap(p ->
plan.steps(p.project)).toList()) {
+ for (MojoExecution execution : step.executions().toList())
{
+ buildPlan = computeForkPlan(step, execution,
buildPlan);
+ }
+ }
+
+ for (BuildStep step : planSteps) {
+ MavenProject project = step.project;
+ buildPlanLogger.writePlan(plan, project);
+ step.status.compareAndSet(SCHEDULED, EXECUTED);
+ }
+
+ checkThreadSafety(plan);
+ checkUnboundVersions(plan);
+ } finally {
+ lock.writeLock().unlock();
+ }
+ }
+
+ protected BuildPlan computeForkPlan(BuildStep step, MojoExecution
execution, BuildPlan buildPlan) {
+ MojoDescriptor mojoDescriptor = execution.getMojoDescriptor();
+ PluginDescriptor pluginDescriptor =
mojoDescriptor.getPluginDescriptor();
+ String forkedGoal = mojoDescriptor.getExecuteGoal();
+ String phase = mojoDescriptor.getExecutePhase();
+ // We have a fork goal
+ if (forkedGoal != null && !forkedGoal.isEmpty()) {
+ MojoDescriptor forkedMojoDescriptor =
pluginDescriptor.getMojo(forkedGoal);
+ if (forkedMojoDescriptor == null) {
+ throw new MavenException(new
MojoNotFoundException(forkedGoal, pluginDescriptor));
+ }
+
+ List<MavenProject> toFork = new ArrayList<>();
+ toFork.add(step.project);
+ if (mojoDescriptor.isAggregator() &&
step.project.getCollectedProjects() != null) {
+ toFork.addAll(step.project.getCollectedProjects());
+ }
+
+ BuildPlan plan = new BuildPlan();
+ for (MavenProject project : toFork) {
+ BuildStep st = new BuildStep(forkedGoal, project, null);
+ MojoExecution mojoExecution = new
MojoExecution(forkedMojoDescriptor, forkedGoal);
+ st.addMojo(mojoExecution, 0);
+ Map<String, BuildStep> n = new HashMap<>();
+ n.put(forkedGoal, st);
+ plan.addProject(project, n);
+ }
+
+ for (BuildStep astep : plan.allSteps().toList()) {
+ for (MojoExecution aexecution :
astep.executions().toList()) {
+ plan = computeForkPlan(astep, aexecution, plan);
+ }
+ }
+
+ return plan;
+
+ } else if (phase != null && !phase.isEmpty()) {
+ String forkedLifecycle = mojoDescriptor.getExecuteLifecycle();
+ Lifecycle lifecycle;
+ if (forkedLifecycle != null && !forkedLifecycle.isEmpty()) {
+ org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle
lifecycleOverlay;
+ try {
+ lifecycleOverlay =
pluginDescriptor.getLifecycleMapping(forkedLifecycle);
+ } catch (IOException | XMLStreamException e) {
+ throw new MavenException(new
PluginDescriptorParsingException(
+ pluginDescriptor.getPlugin(),
pluginDescriptor.getSource(), e));
+ }
+ if (lifecycleOverlay == null) {
+ Optional<Lifecycle> lf =
lifecycles.lookup(forkedLifecycle);
+ if (lf.isPresent()) {
+ lifecycle = lf.get();
+ } else {
+ throw new MavenException(new
LifecycleNotFoundException(forkedLifecycle));
+ }
+ } else {
+ lifecycle = new PluginLifecycle(lifecycleOverlay,
pluginDescriptor);
+ }
+ } else {
+ if (execution.getLifecyclePhase() != null) {
+ String n = execution.getLifecyclePhase();
+ String phaseName = n.startsWith(BEFORE)
+ ? n.substring(BEFORE.length())
+ : n.startsWith(AFTER) ?
n.substring(AFTER.length()) : n;
+ lifecycle = lifecycles.stream()
+ .filter(l -> l.allPhases().anyMatch(p ->
phaseName.equals(p.name())))
+ .findFirst()
+ .orElse(null);
+ if (lifecycle == null) {
+ throw new IllegalStateException();
+ }
+ } else {
+ lifecycle = lifecycles.require(Lifecycle.DEFAULT);
+ }
+ }
+
+ String resolvedPhase = getResolvedPhase(lifecycle, phase);
+
+ Map<MavenProject, List<MavenProject>> map =
Collections.singletonMap(
+ step.project, plan.getAllProjects().get(step.project));
+ BuildPlan forkedPlan = calculateLifecycleMappings(map,
lifecycle, resolvedPhase);
+ forkedPlan.then(buildPlan);
+ return forkedPlan;
+ } else {
+ return buildPlan;
+ }
+ }
+
+ private String getResolvedPhase(Lifecycle lifecycle, String phase) {
+ return lifecycle.aliases().stream()
+ .filter(a -> phase.equals(a.v3Phase()))
+ .findFirst()
+ .map(Lifecycle.Alias::v4Phase)
+ .orElse(phase);
+ }
+
+ private String getResolvedPhase(String phase) {
+ return lifecycles.stream()
+ .flatMap(l -> l.aliases().stream())
+ .filter(a -> phase.equals(a.v3Phase()))
+ .findFirst()
+ .map(Lifecycle.Alias::v4Phase)
+ .orElse(phase);
+ }
+
+ protected void handleBuildError(
+ final ReactorContext buildContext,
+ final MavenSession session,
+ final MavenProject mavenProject,
+ Throwable t,
+ final Clock clock) {
+ // record the error and mark the project as failed
+ buildContext.getResult().addException(t);
+ buildContext
+ .getResult()
+ .addBuildSummary(new BuildFailure(mavenProject,
clock.execTime(), clock.wallTime(), t));
+
+ // notify listeners about "soft" project build failures only
+ if (t instanceof Exception && !(t instanceof RuntimeException)) {
+ eventCatapult.fire(ExecutionEvent.Type.ProjectFailed, session,
null, (Exception) t);
+ }
+
+ // reactor failure modes
+ if (t instanceof RuntimeException || !(t instanceof Exception)) {
+ // fail fast on RuntimeExceptions, Errors and "other"
Throwables
+ // assume these are system errors and further build is
meaningless
+ buildContext.getReactorBuildStatus().halt();
+ } else if
(MavenExecutionRequest.REACTOR_FAIL_NEVER.equals(session.getReactorFailureBehavior()))
{
+ // continue the build
+ } else if
(MavenExecutionRequest.REACTOR_FAIL_AT_END.equals(session.getReactorFailureBehavior()))
{
+ // continue the build but ban all projects that depend on the
failed one
+ buildContext.getReactorBuildStatus().blackList(mavenProject);
+ } else if
(MavenExecutionRequest.REACTOR_FAIL_FAST.equals(session.getReactorFailureBehavior()))
{
+ buildContext.getReactorBuildStatus().halt();
+ } else {
+ logger.error("invalid reactor failure behavior " +
session.getReactorFailureBehavior());
+ buildContext.getReactorBuildStatus().halt();
+ }
+ }
+
+ public BuildPlan calculateMojoExecutions(Map<MavenProject,
List<MavenProject>> projects, List<Task> tasks) {
+ BuildPlan buildPlan = new BuildPlan(projects);
+
+ for (Task task : tasks) {
+ BuildPlan step;
+
+ if (task instanceof GoalTask) {
+ String pluginGoal = task.getValue();
+
+ String executionId = "default-cli";
+ int executionIdx = pluginGoal.indexOf('@');
+ if (executionIdx > 0) {
+ executionId = pluginGoal.substring(executionIdx + 1);
+ }
+
+ step = new BuildPlan();
+ for (MavenProject project : projects.keySet()) {
+ BuildStep st = new BuildStep(pluginGoal, project,
null);
+ MojoDescriptor mojoDescriptor =
getMojoDescriptor(project, pluginGoal);
+ MojoExecution mojoExecution =
+ new MojoExecution(mojoDescriptor, executionId,
MojoExecution.Source.CLI);
+ st.addMojo(mojoExecution, 0);
+ Map<String, BuildStep> n = new HashMap<>();
+ n.put(pluginGoal, st);
+ step.addProject(project, n);
+ }
+ } else if (task instanceof LifecycleTask) {
+ String lifecyclePhase = task.getValue();
+
+ step = calculateLifecycleMappings(projects,
lifecyclePhase);
+
+ } else {
+ throw new IllegalStateException("unexpected task " + task);
+ }
+
+ buildPlan.then(step);
+ }
+
+ return buildPlan;
+ }
+
+ private MojoDescriptor getMojoDescriptor(MavenProject project, Plugin
plugin, String goal) {
+ try {
+ return mavenPluginManager.getMojoDescriptor(
+ plugin, goal, project.getRemotePluginRepositories(),
session.getRepositorySession());
+ } catch (MavenException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new MavenException(e);
+ }
+ }
+
+ private MojoDescriptor getMojoDescriptor(MavenProject project, String
task) {
+ try {
+ return mojoDescriptorCreator.getMojoDescriptor(task, session,
project);
+ } catch (MavenException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new MavenException(e);
+ }
+ }
+
+ public BuildPlan calculateLifecycleMappings(
+ Map<MavenProject, List<MavenProject>> projects, String
lifecyclePhase) {
+
+ String resolvedPhase = getResolvedPhase(lifecyclePhase);
+ String mainPhase = resolvedPhase.startsWith(BEFORE)
+ ? resolvedPhase.substring(BEFORE.length())
+ : resolvedPhase.startsWith(AFTER)
+ ? resolvedPhase.substring(AFTER.length())
+ : resolvedPhase.startsWith(AT) ?
resolvedPhase.substring(AT.length()) : resolvedPhase;
+
+ /*
+ * Determine the lifecycle that corresponds to the given phase.
+ */
+ Lifecycle lifecycle = lifecycles.stream()
+ .filter(l -> l.allPhases().anyMatch(p ->
mainPhase.equals(p.name())))
+ .findFirst()
+ .orElse(null);
+
+ if (lifecycle == null) {
+ throw new MavenException(new LifecyclePhaseNotFoundException(
+ "Unknown lifecycle phase \"" + lifecyclePhase
+ + "\". You must specify a valid lifecycle
phase"
+ + " or a goal in the format
<plugin-prefix>:<goal> or"
+ + "
<plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>. Available
lifecycle phases are: "
+ + lifecycles.stream()
+ .flatMap(l -> l.orderedPhases()
+ .map(List::stream)
+ .orElseGet(() ->
l.allPhases().map(Lifecycle.Phase::name)))
+ .collect(Collectors.joining(", "))
+ + ".",
+ lifecyclePhase));
+ }
+
+ return calculateLifecycleMappings(projects, lifecycle,
resolvedPhase);
+ }
+
+ public BuildPlan calculateLifecycleMappings(
+ Map<MavenProject, List<MavenProject>> projects, Lifecycle
lifecycle, String lifecyclePhase) {
+ BuildPlan plan = new BuildPlan(projects);
+
+ for (MavenProject project : projects.keySet()) {
+ // For each phase, create and sequence the pre, run and post
steps
+ Map<String, BuildStep> steps = lifecycle
+ .allPhases()
+ .flatMap(phase -> {
+ BuildStep a = new BuildStep(BEFORE + phase.name(),
project, phase);
+ BuildStep b = new BuildStep(phase.name(), project,
phase);
+ BuildStep c = new BuildStep(AFTER + phase.name(),
project, phase);
+ b.executeAfter(a);
+ c.executeAfter(b);
+ return Stream.of(a, b, c);
+ })
+ .collect(Collectors.toMap(n -> n.name, n -> n));
+ // for each phase, make sure children phases are execute
between pre and post steps
+ lifecycle.allPhases().forEach(phase ->
phase.phases().forEach(child -> {
+ steps.get(BEFORE +
child.name()).executeAfter(steps.get(BEFORE + phase.name()));
+ steps.get(AFTER +
phase.name()).executeAfter(steps.get(AFTER + child.name()));
+ }));
+ // for each phase, create links between this project phases
+ lifecycle.allPhases().forEach(phase -> {
+ phase.links().stream()
+ .filter(l -> l.pointer().type() ==
Lifecycle.Pointer.Type.PROJECT)
+ .forEach(link -> {
+ String n1 = phase.name();
+ String n2 = link.pointer().phase();
+ if (link.kind() == Lifecycle.Link.Kind.AFTER) {
+ steps.get(BEFORE +
n1).executeAfter(steps.get(AFTER + n2));
+ } else {
+ steps.get(BEFORE +
n2).executeAfter(steps.get(AFTER + n1));
+ }
+ });
+ });
+
+ // Only keep mojo executions before the end phase
+ String endPhase = lifecyclePhase.startsWith(BEFORE) ||
lifecyclePhase.startsWith(AFTER)
+ ? lifecyclePhase
+ : lifecyclePhase.startsWith(AT)
+ ? lifecyclePhase.substring(AT.length())
+ : AFTER + lifecyclePhase;
+ Set<BuildStep> toKeep =
steps.get(endPhase).allPredecessors().collect(Collectors.toSet());
+ steps.values().stream().filter(n ->
!toKeep.contains(n)).forEach(BuildStep::skip);
+
+ plan.addProject(project, steps);
+ }
+
+ // Create inter project dependencies
+ plan.allSteps().filter(step -> step.phase != null).forEach(step ->
{
+ Lifecycle.Phase phase = step.phase;
+ MavenProject project = step.project;
+ phase.links().stream()
+ .filter(l -> l.pointer().type() !=
Lifecycle.Pointer.Type.PROJECT)
+ .forEach(link -> {
+ String n1 = phase.name();
+ String n2 = link.pointer().phase();
+ // for each project, if the phase in the build,
link after it
+ getLinkedProjects(projects, project,
link).forEach(p -> plan.step(p, AFTER + n2)
+ .ifPresent(a -> plan.requiredStep(project,
BEFORE + n1)
+ .executeAfter(a)));
+ });
+ });
+
+ // Keep projects in reactors by GAV
+ Map<String, MavenProject> reactorGavs =
+
projects.keySet().stream().collect(Collectors.toMap(BuildPlanExecutor::gav, p
-> p));
+
+ // Go through all plugins
+ List<Runnable> toResolve = new ArrayList<>();
+ projects.keySet().forEach(project ->
project.getBuild().getPlugins().forEach(plugin -> {
+ MavenProject pluginProject = reactorGavs.get(gav(plugin));
+ if (pluginProject != null) {
+ // In order to plan the project, we need all its plugins...
+ plan.requiredStep(project,
PLAN).executeAfter(plan.requiredStep(pluginProject, READY));
+ } else {
+ toResolve.add(() -> resolvePlugin(session,
project.getRemotePluginRepositories(), plugin));
+ }
+ }));
+
+ // Eagerly resolve all plugins in parallel
+ toResolve.parallelStream().forEach(Runnable::run);
+
+ // Keep track of phase aliases
+ lifecycle.aliases().forEach(alias ->
plan.aliases().put(alias.v3Phase(), alias.v4Phase()));
+
+ return plan;
+ }
+
+ private List<MavenProject> getLinkedProjects(
+ Map<MavenProject, List<MavenProject>> projects, MavenProject
project, Lifecycle.Link link) {
+ if (link.pointer().type() == Lifecycle.Pointer.Type.DEPENDENCIES) {
+ // TODO: String scope = ((Lifecycle.DependenciesPointer)
link.pointer()).scope();
+ return projects.get(project);
+ } else if (link.pointer().type() ==
Lifecycle.Pointer.Type.CHILDREN) {
+ return project.getCollectedProjects();
+ } else {
+ throw new IllegalArgumentException(
+ "Unsupported pointer type: " + link.pointer().type());
+ }
+ }
+ }
+
+ private void resolvePlugin(MavenSession session, List<RemoteRepository>
repositories, Plugin plugin) {
+ try {
+ mavenPluginManager.getPluginDescriptor(plugin, repositories,
session.getRepositorySession());
+ } catch (Exception e) {
+ throw new MavenException(e);
+ }
+ }
+
+ private static String gav(MavenProject p) {
+ return p.getGroupId() + ":" + p.getArtifactId() + ":" + p.getVersion();
+ }
+
+ private static String gav(Plugin p) {
+ return p.getGroupId() + ":" + p.getArtifactId() + ":" + p.getVersion();
+ }
+
+ /**
+ * Post-processes the effective configuration for the specified mojo
execution. This step discards all parameters
+ * from the configuration that are not applicable to the mojo and injects
the default values for any missing
+ * parameters.
+ *
+ * @param mojoExecution The mojo execution whose configuration should be
finalized, must not be {@code null}.
+ */
+ private void finalizeMojoConfiguration(MojoExecution mojoExecution) {
+ MojoDescriptor mojoDescriptor = mojoExecution.getMojoDescriptor();
+
+ XmlNode executionConfiguration = mojoExecution.getConfiguration() !=
null
+ ? mojoExecution.getConfiguration().getDom()
+ : null;
+ if (executionConfiguration == null) {
+ executionConfiguration = new XmlNodeImpl("configuration");
+ }
+
+ XmlNode defaultConfiguration = getMojoConfiguration(mojoDescriptor);
+
+ List<XmlNode> children = new ArrayList<>();
+ if (mojoDescriptor.getParameters() != null) {
+ for (Parameter parameter : mojoDescriptor.getParameters()) {
+ XmlNode parameterConfiguration =
executionConfiguration.getChild(parameter.getName());
+
+ if (parameterConfiguration == null) {
+ parameterConfiguration =
executionConfiguration.getChild(parameter.getAlias());
+ }
+
+ XmlNode parameterDefaults =
defaultConfiguration.getChild(parameter.getName());
+
+ if (parameterConfiguration != null) {
+ parameterConfiguration =
parameterConfiguration.merge(parameterDefaults, Boolean.TRUE);
+ } else {
+ parameterConfiguration = parameterDefaults;
+ }
+
+ if (parameterConfiguration != null) {
+ Map<String, String> attributes = new
HashMap<>(parameterConfiguration.getAttributes());
+
+ String attributeForImplementation =
parameterConfiguration.getAttribute("implementation");
+ String parameterForImplementation =
parameter.getImplementation();
+ if ((attributeForImplementation == null ||
attributeForImplementation.isEmpty())
+ && ((parameterForImplementation != null) &&
!parameterForImplementation.isEmpty())) {
+ attributes.put("implementation",
parameter.getImplementation());
+ }
+
+ parameterConfiguration = new XmlNodeImpl(
+ parameter.getName(),
+ parameterConfiguration.getValue(),
+ attributes,
+ parameterConfiguration.getChildren(),
+ parameterConfiguration.getInputLocation());
+
+ children.add(parameterConfiguration);
+ }
+ }
+ }
+ XmlNode finalConfiguration = new XmlNodeImpl("configuration", null,
null, children, null);
+
+ mojoExecution.setConfiguration(finalConfiguration);
+ }
+
+ private XmlNode getMojoConfiguration(MojoDescriptor mojoDescriptor) {
+ if (mojoDescriptor.isV4Api()) {
+ return
MojoDescriptorCreator.convert(mojoDescriptor.getMojoDescriptorV4());
+ } else {
+ return MojoDescriptorCreator.convert(mojoDescriptor).getDom();
+ }
+ }
+
+ private MojoExecutionConfigurator mojoExecutionConfigurator(MojoExecution
mojoExecution) {
+ String configuratorId =
mojoExecution.getMojoDescriptor().getComponentConfigurator();
+ if (configuratorId == null) {
+ configuratorId = "default";
+ }
+
+ MojoExecutionConfigurator mojoExecutionConfigurator =
mojoExecutionConfigurators.get(configuratorId);
+
+ if (mojoExecutionConfigurator == null) {
+ //
+ // The plugin has a custom component configurator but does not
have a custom mojo execution configurator
+ // so fall back to the default mojo execution configurator.
+ //
+ mojoExecutionConfigurator =
mojoExecutionConfigurators.get("default");
+ }
+ return mojoExecutionConfigurator;
+ }
+
+ public static void attachToThread(MavenProject currentProject) {
+ ClassRealm projectRealm = currentProject.getClassRealm();
+ if (projectRealm != null) {
+ Thread.currentThread().setContextClassLoader(projectRealm);
+ }
+ }
+
+ protected static class Clock {
+ long start;
+ long end;
+ long resumed;
+ long exec;
+
+ protected void start() {
+ if (start == 0) {
+ start = System.nanoTime();
+ resumed = start;
+ } else {
+ resumed = System.nanoTime();
+ }
+ }
+
+ protected void stop() {
+ end = System.nanoTime();
+ exec += end - resumed;
+ }
+
+ protected long wallTime() {
+ return TimeUnit.NANOSECONDS.toMillis(end - start);
+ }
+
+ protected long execTime() {
+ return TimeUnit.NANOSECONDS.toMillis(exec);
+ }
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanLogger.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanLogger.java
new file mode 100644
index 0000000000..85bbe00e64
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanLogger.java
@@ -0,0 +1,177 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import javax.inject.Named;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.plugin.MojoExecution;
+import org.apache.maven.project.MavenProject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * <p>
+ * Logs debug output from the various lifecycle phases.
+ * </p>
+ * <strong>NOTE:</strong> This class is not part of any public api and can be
changed or deleted without prior notice.
+ *
+ * @since 3.0
+ */
+@Named
+public class BuildPlanLogger {
+ private final Logger logger = LoggerFactory.getLogger(getClass());
+
+ public void writePlan(BuildPlan plan) {
+ if (logger.isDebugEnabled()) {
+ writePlan(logger::debug, plan);
+ }
+ }
+
+ public void writePlan(BuildPlan plan, MavenProject project) {
+ if (logger.isDebugEnabled()) {
+ writePlan(logger::debug, plan, project);
+ }
+ }
+
+ public void writePlan(Consumer<String> writer, BuildPlan plan) {
+ plan.projects().forEach(project -> writePlan(writer, plan, project));
+ }
+
+ public void writePlan(Consumer<String> writer, BuildPlan plan,
MavenProject project) {
+ writer.accept("=== PROJECT BUILD PLAN
================================================");
+ writer.accept("Project: " + getKey(project));
+ writer.accept("Repositories (dependencies): " +
project.getRemoteProjectRepositories());
+ writer.accept("Repositories (plugins): " +
project.getRemotePluginRepositories());
+
+ Optional<BuildStep> planStep = plan.step(project, BuildStep.PLAN);
+ if (planStep.isPresent() && planStep.get().status.get() ==
BuildStep.PLANNING) {
+ writer.accept("Build plan will be lazily computed");
+ } else {
+ plan.steps(project)
+ .filter(step ->
+ step.phase != null &&
step.executions().findAny().isPresent())
+
.sorted(Comparator.comparingInt(plan.sortedNodes()::indexOf))
+ .forEach(step -> {
+
writer.accept("\t-----------------------------------------------------------------------");
+ writer.accept("\tPhase: " + step.name);
+ if (!step.predecessors.isEmpty()) {
+ writer.accept("\tPredecessors: "
+ + nonEmptyPredecessors(step)
+ .map(n -> phase(project, n,
plan.duplicateIds()))
+ .collect(Collectors.joining(",
")));
+ }
+ /*
+ if (!node.successors.isEmpty()) {
+ writer.accept("\tSuccessors: "
+ + node.successors.stream()
+ .map(n -> phase(currentProject, n,
duplicateIds))
+ .collect(Collectors.joining(",
")));
+ }
+ */
+ step.mojos.values().stream()
+ .flatMap(m -> m.values().stream())
+ .forEach(mojo -> mojo(writer, mojo));
+ });
+ }
+
+
writer.accept("=======================================================================");
+ }
+
+ protected Stream<BuildStep> nonEmptyPredecessors(BuildStep step) {
+ HashSet<BuildStep> preds = new HashSet<>();
+ nonEmptyPredecessors(step, preds, new HashSet<>());
+ return preds.stream();
+ }
+
+ private void nonEmptyPredecessors(BuildStep step, Set<BuildStep> preds,
Set<BuildStep> visited) {
+ if (visited.add(step)) {
+ step.predecessors.forEach(ch -> {
+ if (ch.executions().findAny().isPresent()) {
+ preds.add(ch);
+ } else {
+ nonEmptyPredecessors(ch, preds, visited);
+ }
+ });
+ }
+ }
+
+ protected String phase(MavenProject currentProject, BuildStep step,
Set<String> duplicateIds) {
+ if (step.project == currentProject) {
+ return step.name;
+ } else {
+ String artifactId = step.project.getArtifactId();
+ if (duplicateIds.contains(artifactId)) {
+ return step.name + "(" + step.project.getGroupId() + ":" +
artifactId + ")";
+ } else {
+ return step.name + "(:" + artifactId + ")";
+ }
+ }
+ }
+
+ protected void mojo(Consumer<String> writer, MojoExecution mojoExecution) {
+ String mojoExecId =
+ mojoExecution.getGroupId() + ':' +
mojoExecution.getArtifactId() + ':' + mojoExecution.getVersion()
+ + ':' + mojoExecution.getGoal() + " (" +
mojoExecution.getExecutionId() + ')';
+
+ Map<String, List<MojoExecution>> forkedExecutions =
mojoExecution.getForkedExecutions();
+ if (!forkedExecutions.isEmpty()) {
+ for (Map.Entry<String, List<MojoExecution>> fork :
forkedExecutions.entrySet()) {
+ writer.accept("\t--- init fork of " + fork.getKey() + " for "
+ mojoExecId + " ---");
+
+ for (MojoExecution forkedExecution : fork.getValue()) {
+ mojo(writer, forkedExecution);
+ }
+
+ writer.accept("\t--- exit fork of " + fork.getKey() + " for "
+ mojoExecId + " ---");
+ }
+ }
+
+
writer.accept("\t\t-----------------------------------------------------------------------");
+ if (mojoExecution.getMojoDescriptor().isAggregator()) {
+ writer.accept("\t\tAggregator goal: " + mojoExecId);
+ } else {
+ writer.accept("\t\tGoal: " + mojoExecId);
+ }
+ if (mojoExecution.getConfiguration() != null) {
+ writer.accept("\t\tConfiguration: " +
mojoExecution.getConfiguration());
+ }
+ if
(mojoExecution.getMojoDescriptor().getDependencyCollectionRequired() != null) {
+ writer.accept("\t\tDependencies (collect): "
+ +
mojoExecution.getMojoDescriptor().getDependencyCollectionRequired());
+ }
+ if
(mojoExecution.getMojoDescriptor().getDependencyResolutionRequired() != null) {
+ writer.accept("\t\tDependencies (resolve): "
+ +
mojoExecution.getMojoDescriptor().getDependencyResolutionRequired());
+ }
+ }
+
+ protected String getKey(MavenProject project) {
+ return project.getGroupId() + ':' + project.getArtifactId() + ':' +
project.getVersion();
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildStep.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildStep.java
new file mode 100644
index 0000000000..e0b7c9598a
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildStep.java
@@ -0,0 +1,133 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Stream;
+
+import org.apache.maven.api.Lifecycle;
+import org.apache.maven.plugin.MojoExecution;
+import org.apache.maven.project.MavenProject;
+
+public class BuildStep {
+ public static final int CREATED = 0;
+ public static final int PLANNING = 1;
+ public static final int SCHEDULED = 2;
+ public static final int EXECUTED = 3;
+ public static final int FAILED = 4;
+
+ public static final String PLAN = "$plan$";
+ public static final String SETUP = "$setup$";
+ public static final String TEARDOWN = "$teardown$";
+
+ final MavenProject project;
+ final String name;
+ final Lifecycle.Phase phase;
+ final Map<Integer, Map<String, MojoExecution>> mojos = new TreeMap<>();
+ final Collection<BuildStep> predecessors = new HashSet<>();
+ final Collection<BuildStep> successors = new HashSet<>();
+ final AtomicInteger status = new AtomicInteger();
+ final AtomicBoolean skip = new AtomicBoolean();
+
+ public BuildStep(String name, MavenProject project, Lifecycle.Phase phase)
{
+ this.name = name;
+ this.project = project;
+ this.phase = phase;
+ }
+
+ public Stream<BuildStep> allPredecessors() {
+ return preds(new HashSet<>()).stream();
+ }
+
+ private Set<BuildStep> preds(Set<BuildStep> preds) {
+ if (preds.add(this)) {
+ this.predecessors.forEach(n -> n.preds(preds));
+ }
+ return preds;
+ }
+
+ public boolean isSuccessorOf(BuildStep step) {
+ return isSuccessorOf(new HashSet<>(), step);
+ }
+
+ private boolean isSuccessorOf(Set<BuildStep> visited, BuildStep step) {
+ if (this == step) {
+ return true;
+ } else if (visited.add(this)) {
+ return this.predecessors.stream().anyMatch(n ->
n.isSuccessorOf(visited, step));
+ } else {
+ return false;
+ }
+ }
+
+ public void skip() {
+ skip.set(true);
+ mojos.clear();
+ }
+
+ public void addMojo(MojoExecution mojo, int priority) {
+ if (!skip.get()) {
+ mojos.computeIfAbsent(priority, k -> new LinkedHashMap<>())
+ .put(mojo.getGoal() + ":" + mojo.getExecutionId(), mojo);
+ }
+ }
+
+ public void executeAfter(BuildStep stepToExecuteBefore) {
+ if (!isSuccessorOf(stepToExecuteBefore)) {
+ predecessors.add(stepToExecuteBefore);
+ stepToExecuteBefore.successors.add(this);
+ }
+ }
+
+ public Stream<MojoExecution> executions() {
+ return mojos.values().stream().flatMap(m -> m.values().stream());
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ BuildStep that = (BuildStep) o;
+ return Objects.equals(project, that.project) && Objects.equals(name,
that.name);
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(project, name);
+ }
+
+ @Override
+ public String toString() {
+ return "BuildStep[" + "project="
+ + project.getGroupId() + ":" + project.getArtifactId() + ",
phase="
+ + name + ']';
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/ConcurrentLifecycleStarter.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/ConcurrentLifecycleStarter.java
new file mode 100644
index 0000000000..e4422ffc1c
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/ConcurrentLifecycleStarter.java
@@ -0,0 +1,191 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Singleton;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.execution.ExecutionEvent;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.lifecycle.DefaultLifecycles;
+import org.apache.maven.lifecycle.MissingProjectException;
+import org.apache.maven.lifecycle.NoGoalSpecifiedException;
+import org.apache.maven.lifecycle.internal.ExecutionEventCatapult;
+import org.apache.maven.lifecycle.internal.GoalTask;
+import org.apache.maven.lifecycle.internal.LifecyclePluginResolver;
+import org.apache.maven.lifecycle.internal.LifecycleStarter;
+import org.apache.maven.lifecycle.internal.LifecycleTask;
+import org.apache.maven.lifecycle.internal.MojoDescriptorCreator;
+import org.apache.maven.lifecycle.internal.ReactorBuildStatus;
+import org.apache.maven.lifecycle.internal.ReactorContext;
+import org.apache.maven.lifecycle.internal.TaskSegment;
+import org.apache.maven.plugin.descriptor.MojoDescriptor;
+import org.apache.maven.project.MavenProject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Starts the build life cycle
+ */
+@Named("concurrent")
+@Singleton
+public class ConcurrentLifecycleStarter implements LifecycleStarter {
+ private final Logger logger = LoggerFactory.getLogger(getClass());
+
+ private final ExecutionEventCatapult eventCatapult;
+ private final DefaultLifecycles defaultLifeCycles;
+ private final BuildPlanExecutor executor;
+ private final LifecyclePluginResolver lifecyclePluginResolver;
+ private final MojoDescriptorCreator mojoDescriptorCreator;
+
+ @Inject
+ public ConcurrentLifecycleStarter(
+ ExecutionEventCatapult eventCatapult,
+ DefaultLifecycles defaultLifeCycles,
+ BuildPlanExecutor executor,
+ LifecyclePluginResolver lifecyclePluginResolver,
+ MojoDescriptorCreator mojoDescriptorCreator) {
+ this.eventCatapult = eventCatapult;
+ this.defaultLifeCycles = defaultLifeCycles;
+ this.executor = executor;
+ this.lifecyclePluginResolver = lifecyclePluginResolver;
+ this.mojoDescriptorCreator = mojoDescriptorCreator;
+ }
+
+ public void execute(MavenSession session) {
+ eventCatapult.fire(ExecutionEvent.Type.SessionStarted, session, null);
+
+ try {
+ if (requiresProject(session) && projectIsNotPresent(session)) {
+ throw new MissingProjectException("The goal you specified
requires a project to execute"
+ + " but there is no POM in this directory (" +
session.getTopDirectory() + ")."
+ + " Please verify you invoked Maven from the correct
directory.");
+ }
+
+ List<TaskSegment> taskSegments = calculateTaskSegments(session);
+ if (taskSegments.isEmpty()) {
+ throw new NoGoalSpecifiedException("No goals have been
specified for this build."
+ + " You must specify a valid lifecycle phase or a goal
in the format <plugin-prefix>:<goal> or"
+ + "
<plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>."
+ + " Available lifecycle phases are: " +
defaultLifeCycles.getLifecyclePhaseList() + ".");
+ }
+
+ int degreeOfConcurrency =
session.getRequest().getDegreeOfConcurrency();
+ if (degreeOfConcurrency > 1) {
+ logger.info("");
+ logger.info(String.format(
+ "Using the %s implementation with a thread count of
%d",
+ executor.getClass().getSimpleName(),
degreeOfConcurrency));
+ }
+
+ ClassLoader oldContextClassLoader =
Thread.currentThread().getContextClassLoader();
+ ReactorBuildStatus reactorBuildStatus = new
ReactorBuildStatus(session.getProjectDependencyGraph());
+ ReactorContext reactorContext =
+ new ReactorContext(session.getResult(),
oldContextClassLoader, reactorBuildStatus);
+ executor.execute(session, reactorContext, taskSegments);
+
+ } catch (Exception e) {
+ session.getResult().addException(e);
+ } finally {
+ eventCatapult.fire(ExecutionEvent.Type.SessionEnded, session,
null);
+ }
+ }
+
+ public List<TaskSegment> calculateTaskSegments(MavenSession session)
throws Exception {
+
+ MavenProject rootProject = session.getTopLevelProject();
+
+ List<String> tasks = requireNonNull(session.getGoals()); // session
never returns null, but empty list
+
+ if (tasks.isEmpty()
+ && (rootProject.getDefaultGoal() != null
+ && !rootProject.getDefaultGoal().isEmpty())) {
+ tasks = Stream.of(rootProject.getDefaultGoal().split("\\s+"))
+ .filter(g -> !g.isEmpty())
+ .collect(Collectors.toList());
+ }
+
+ return calculateTaskSegments(session, tasks);
+ }
+
+ public List<TaskSegment> calculateTaskSegments(MavenSession session,
List<String> tasks) throws Exception {
+ List<TaskSegment> taskSegments = new ArrayList<>(tasks.size());
+
+ TaskSegment currentSegment = null;
+
+ for (String task : tasks) {
+ if (isGoalSpecification(task)) {
+ // "pluginPrefix[:version]:goal" or
"groupId:artifactId[:version]:goal"
+
+
lifecyclePluginResolver.resolveMissingPluginVersions(session.getTopLevelProject(),
session);
+
+ MojoDescriptor mojoDescriptor =
+ mojoDescriptorCreator.getMojoDescriptor(task, session,
session.getTopLevelProject());
+
+ boolean aggregating = mojoDescriptor.isAggregator() ||
!mojoDescriptor.isProjectRequired();
+
+ if (currentSegment == null || currentSegment.isAggregating()
!= aggregating) {
+ currentSegment = new TaskSegment(aggregating);
+ taskSegments.add(currentSegment);
+ }
+
+ currentSegment.getTasks().add(new GoalTask(task));
+ } else {
+ // lifecycle phase
+
+ if (currentSegment == null || currentSegment.isAggregating()) {
+ currentSegment = new TaskSegment(false);
+ taskSegments.add(currentSegment);
+ }
+
+ currentSegment.getTasks().add(new LifecycleTask(task));
+ }
+ }
+
+ return taskSegments;
+ }
+
+ private boolean projectIsNotPresent(MavenSession session) {
+ return !session.getRequest().isProjectPresent();
+ }
+
+ private boolean requiresProject(MavenSession session) {
+ List<String> goals = session.getGoals();
+ if (goals != null) {
+ for (String goal : goals) {
+ if (!isGoalSpecification(goal)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private boolean isGoalSpecification(String task) {
+ return task.indexOf(':') >= 0;
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/ConcurrentLogOutput.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/ConcurrentLogOutput.java
new file mode 100644
index 0000000000..5c5342ba8e
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/ConcurrentLogOutput.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.apache.maven.project.MavenProject;
+import org.apache.maven.slf4j.MavenSimpleLogger;
+
+/**
+ * Forwards log messages to the client.
+ */
+public class ConcurrentLogOutput implements AutoCloseable {
+
+ private static final ThreadLocal<ProjectExecutionContext> CONTEXT = new
InheritableThreadLocal<>();
+
+ public ConcurrentLogOutput() {
+ MavenSimpleLogger.setLogSink(this::accept);
+ }
+
+ protected void accept(String message) {
+ ProjectExecutionContext context = CONTEXT.get();
+ if (context != null) {
+ context.accept(message);
+ } else {
+ System.out.println(message);
+ }
+ }
+
+ @Override
+ public void close() {
+ MavenSimpleLogger.setLogSink(null);
+ }
+
+ public AutoCloseable build(MavenProject project) {
+ return new ProjectExecutionContext(project);
+ }
+
+ private static class ProjectExecutionContext implements AutoCloseable {
+ final MavenProject project;
+ final List<String> messages = new CopyOnWriteArrayList<>();
+ boolean closed;
+
+ ProjectExecutionContext(MavenProject project) {
+ this.project = project;
+ CONTEXT.set(this);
+ }
+
+ void accept(String message) {
+ if (!closed) {
+ this.messages.add(message);
+ } else {
+ System.out.println(message);
+ }
+ }
+
+ @Override
+ public void close() {
+ closed = true;
+ CONTEXT.set(null);
+ this.messages.forEach(System.out::println);
+ }
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/MojoExecutor.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/MojoExecutor.java
new file mode 100644
index 0000000000..273035b82c
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/MojoExecutor.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+import javax.inject.Provider;
+import javax.inject.Singleton;
+
+import org.apache.maven.api.services.MessageBuilderFactory;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.lifecycle.internal.ExecutionEventCatapult;
+import org.apache.maven.lifecycle.internal.LifecycleDependencyResolver;
+import org.apache.maven.plugin.BuildPluginManager;
+import org.apache.maven.plugin.MavenPluginManager;
+import org.apache.maven.plugin.MojosExecutionStrategy;
+
+@Named("concurrent")
+@Singleton
+public class MojoExecutor extends
org.apache.maven.lifecycle.internal.MojoExecutor {
+
+ @Inject
+ public MojoExecutor(
+ BuildPluginManager pluginManager,
+ MavenPluginManager mavenPluginManager,
+ LifecycleDependencyResolver lifeCycleDependencyResolver,
+ ExecutionEventCatapult eventCatapult,
+ Provider<MojosExecutionStrategy> mojosExecutionStrategy,
+ MessageBuilderFactory messageBuilderFactory) {
+ super(
+ pluginManager,
+ mavenPluginManager,
+ lifeCycleDependencyResolver,
+ eventCatapult,
+ mojosExecutionStrategy,
+ messageBuilderFactory);
+ }
+
+ @Override
+ protected boolean useProjectLock(MavenSession session) {
+ return false;
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/PhasingExecutor.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/PhasingExecutor.java
new file mode 100644
index 0000000000..c27f5ce5b3
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/PhasingExecutor.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Phaser;
+
+public class PhasingExecutor implements Executor, AutoCloseable {
+ private final ExecutorService executor;
+ private final Phaser phaser = new Phaser();
+
+ public PhasingExecutor(ExecutorService executor) {
+ this.executor = executor;
+ this.phaser.register();
+ }
+
+ @Override
+ public void execute(Runnable command) {
+ phaser.register();
+ executor.submit(() -> {
+ try {
+ command.run();
+ } finally {
+ phaser.arriveAndDeregister();
+ }
+ });
+ }
+
+ public void await() {
+ phaser.arriveAndAwaitAdvance();
+ }
+
+ @Override
+ public void close() {
+ executor.shutdownNow();
+ }
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/PluginLifecycle.java
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/PluginLifecycle.java
new file mode 100644
index 0000000000..81a319b7ae
--- /dev/null
+++
b/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/PluginLifecycle.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.apache.maven.api.Lifecycle;
+import org.apache.maven.api.model.Plugin;
+import org.apache.maven.plugin.descriptor.PluginDescriptor;
+
+class PluginLifecycle implements Lifecycle {
+ private final org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle
lifecycleOverlay;
+ private final PluginDescriptor pluginDescriptor;
+
+ PluginLifecycle(
+ org.apache.maven.api.plugin.descriptor.lifecycle.Lifecycle
lifecycleOverlay,
+ PluginDescriptor pluginDescriptor) {
+ this.lifecycleOverlay = lifecycleOverlay;
+ this.pluginDescriptor = pluginDescriptor;
+ }
+
+ @Override
+ public String id() {
+ return lifecycleOverlay.getId();
+ }
+
+ @Override
+ public Collection<Phase> phases() {
+ return lifecycleOverlay.getPhases().stream()
+ .map(phase -> new Phase() {
+ @Override
+ public String name() {
+ return phase.getId();
+ }
+
+ @Override
+ public List<Plugin> plugins() {
+ return Collections.singletonList(Plugin.newBuilder()
+ .groupId(pluginDescriptor.getGroupId())
+ .artifactId(pluginDescriptor.getArtifactId())
+ .version(pluginDescriptor.getVersion())
+ .configuration(phase.getConfiguration())
+ .executions(phase.getExecutions().stream()
+ .map(exec ->
org.apache.maven.api.model.PluginExecution.newBuilder()
+ .goals(exec.getGoals())
+
.configuration(exec.getConfiguration())
+ .build())
+ .collect(Collectors.toList()))
+ .build());
+ }
+
+ @Override
+ public Collection<Link> links() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public List<Phase> phases() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public Stream<Phase> allPhases() {
+ return Stream.concat(Stream.of(this),
phases().stream().flatMap(Phase::allPhases));
+ }
+ })
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public Collection<Alias> aliases() {
+ return Collections.emptyList();
+ }
+}
diff --git
a/maven-core/src/test/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanCreatorTest.java
b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanCreatorTest.java
new file mode 100644
index 0000000000..0e3fd5dd0c
--- /dev/null
+++
b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanCreatorTest.java
@@ -0,0 +1,144 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.lifecycle.internal.concurrent;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import java.util.stream.Stream;
+
+import org.apache.maven.internal.impl.DefaultLifecycleRegistry;
+import org.apache.maven.plugin.MojoExecution;
+import org.apache.maven.project.MavenProject;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class BuildPlanCreatorTest {
+
+ @Test
+ void testMulti() {
+ MavenProject project = new MavenProject();
+ Map<MavenProject, List<MavenProject>> projects =
Collections.singletonMap(project, Collections.emptyList());
+
+ BuildPlan plan = calculateLifecycleMappings(projects, "package");
+
+ new BuildPlanLogger().writePlan(System.out::println, plan);
+ }
+
+ @Test
+ void testCondense() {
+ MavenProject p1 = new MavenProject();
+ p1.setArtifactId("p1");
+ MavenProject p2 = new MavenProject();
+ p2.setArtifactId("p2");
+ Map<MavenProject, List<MavenProject>> projects = new HashMap<>();
+ projects.put(p1, Collections.emptyList());
+ projects.put(p2, Collections.singletonList(p1));
+
+ BuildPlan plan = calculateLifecycleMappings(projects, "verify");
+ plan.then(calculateLifecycleMappings(projects, "install"));
+
+ Stream.of(p1, p2).forEach(project -> {
+ plan.requiredStep(project, "after:resources").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "after:test-resources").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "compile").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "test-compile").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "test").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "package").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "install").addMojo(new
MojoExecution(null), 0);
+ });
+
+ new BuildPlanLogger() {
+ @Override
+ protected void mojo(Consumer<String> writer, MojoExecution
mojoExecution) {}
+ }.writePlan(System.out::println, plan);
+
+ plan.allSteps().forEach(phase -> {
+ phase.predecessors.forEach(
+ pred -> assertTrue(plan.step(pred.project,
pred.name).isPresent(), "Phase not present: " + pred));
+ });
+ }
+
+ @Test
+ void testAlias() {
+ MavenProject p1 = new MavenProject();
+ p1.setArtifactId("p1");
+ Map<MavenProject, List<MavenProject>> projects =
Collections.singletonMap(p1, Collections.emptyList());
+
+ BuildPlan plan = calculateLifecycleMappings(projects,
"generate-resources");
+ }
+
+ private BuildPlan calculateLifecycleMappings(Map<MavenProject,
List<MavenProject>> projects, String phase) {
+ DefaultLifecycleRegistry lifecycles = new
DefaultLifecycleRegistry(Collections.emptyList());
+ BuildPlanExecutor builder = new BuildPlanExecutor(null, null, null,
null, null, null, null, null, lifecycles);
+ BuildPlanExecutor.BuildContext context = builder.new BuildContext();
+ return context.calculateLifecycleMappings(projects, phase);
+ }
+
+ /*
+ @Test
+ void testPlugins() {
+ DefaultLifecycleRegistry lifecycles =
+ new DefaultLifecycleRegistry(Collections.emptyList(),
Collections.emptyMap());
+ BuildPlanCreator builder = new BuildPlanCreator(null, null, null,
null, null, lifecycles);
+ MavenProject p1 = new MavenProject();
+ p1.setGroupId("g");
+ p1.setArtifactId("p1");
+ p1.getBuild().getPlugins().add(new
Plugin(org.apache.maven.api.model.Plugin.newBuilder()
+ .groupId("g").artifactId("p2")
+ .
+ .build()))
+ MavenProject p2 = new MavenProject();
+ p2.setGroupId("g");
+ p2.setArtifactId("p2");
+
+ Map<MavenProject, List<MavenProject>> projects = new HashMap<>();
+ projects.put(p1, Collections.emptyList());
+ projects.put(p2, Collections.singletonList(p1));
+ Lifecycle lifecycle = lifecycles.require("default");
+ BuildPlan plan = builder.calculateLifecycleMappings(null, projects,
lifecycle, "verify");
+ plan.then(builder.calculateLifecycleMappings(null, projects,
lifecycle, "install"));
+
+ Stream.of(p1, p2).forEach(project -> {
+ plan.requiredStep(project, "post:resources").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "post:test-resources").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "compile").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "test-compile").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "test").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "package").addMojo(new
MojoExecution(null), 0);
+ plan.requiredStep(project, "install").addMojo(new
MojoExecution(null), 0);
+ });
+
+ plan.condense();
+
+ new BuildPlanLogger() {
+ @Override
+ protected void mojo(Consumer<String> writer, MojoExecution
mojoExecution) {}
+ }.writePlan(System.out::println, plan);
+
+ plan.allSteps().forEach(phase -> {
+ phase.predecessors.forEach(
+ pred -> assertTrue(plan.step(pred.project,
pred.name).isPresent(), "Phase not present: " + pred));
+ });
+ }
+ */
+}
diff --git
a/maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/concurrent/PhasingExecutorTest.java
similarity index 53%
copy from maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
copy to
maven-core/src/test/java/org/apache/maven/lifecycle/internal/concurrent/PhasingExecutorTest.java
index 0f0310d3cd..5c038cd072 100644
--- a/maven-core/src/main/java/org/apache/maven/execution/BuildSuccess.java
+++
b/maven-core/src/test/java/org/apache/maven/lifecycle/internal/concurrent/PhasingExecutorTest.java
@@ -16,23 +16,30 @@
* specific language governing permissions and limitations
* under the License.
*/
-package org.apache.maven.execution;
+package org.apache.maven.lifecycle.internal.concurrent;
-import org.apache.maven.project.MavenProject;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
-/**
- * Summarizes the result of a successful project build in the reactor.
- *
- */
-public class BuildSuccess extends BuildSummary {
+import org.junit.jupiter.api.Test;
+
+public class PhasingExecutorTest {
+
+ @Test
+ void testPhaser() {
+ PhasingExecutor p = new
PhasingExecutor(Executors.newFixedThreadPool(4));
+ p.execute(() -> waitSomeTime(p, 2));
+ p.await();
+ }
- /**
- * Creates a new build summary for the specified project.
- *
- * @param project The project being summarized, must not be {@code null}.
- * @param time The build time of the project in milliseconds.
- */
- public BuildSuccess(MavenProject project, long time) {
- super(project, time);
+ private void waitSomeTime(Executor executor, int nb) {
+ try {
+ Thread.sleep(10);
+ if (nb > 0) {
+ executor.execute(() -> waitSomeTime(executor, nb - 1));
+ }
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
}
}
