ReactorReader.java
/*
* 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;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import java.io.File;
import java.io.IOException;
import java.nio.file.DirectoryNotEmptyException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.maven.api.model.Model;
import org.apache.maven.api.services.Lookup;
import org.apache.maven.eventspy.EventSpy;
import org.apache.maven.execution.ExecutionEvent;
import org.apache.maven.execution.MavenSession;
import org.apache.maven.impl.resolver.MavenWorkspaceReader;
import org.apache.maven.project.MavenProject;
import org.apache.maven.project.artifact.ProjectArtifact;
import org.eclipse.aether.artifact.Artifact;
import org.eclipse.aether.repository.WorkspaceRepository;
import org.eclipse.aether.util.artifact.ArtifactIdUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* An implementation of a workspace reader that knows how to search the Maven reactor for artifacts, either as packaged
* jar if it has been built, or only compile output directory if packaging hasn't happened yet.
*
*/
@Named(ReactorReader.HINT)
@SessionScoped
class ReactorReader implements MavenWorkspaceReader {
public static final String HINT = "reactor";
public static final String PROJECT_LOCAL_REPO = "project-local-repo";
private static final Collection<String> COMPILE_PHASE_TYPES = new HashSet<>(
Arrays.asList("jar", "ejb-client", "war", "rar", "ejb", "par", "sar", "wsr", "har", "app-client"));
private static final Logger LOGGER = LoggerFactory.getLogger(ReactorReader.class);
private final MavenSession session;
private final WorkspaceRepository repository;
// groupId -> (artifactId -> (version -> project)))
private Map<String, Map<String, Map<String, MavenProject>>> projects;
private Map<String, Map<String, Map<String, MavenProject>>> allProjects;
private Path projectLocalRepository;
// projectId -> Deque<lifecycle>
private final Map<String, Deque<String>> lifecycles = new ConcurrentHashMap<>();
@Inject
ReactorReader(MavenSession session) {
this.session = session;
this.repository = new WorkspaceRepository("reactor", null);
}
//
// Public API
//
@Override
public WorkspaceRepository getRepository() {
return repository;
}
@Override
public File findArtifact(Artifact artifact) {
MavenProject project = getProject(artifact);
if (project != null) {
File file = findArtifact(project, artifact, true);
if (file == null && project != project.getExecutionProject()) {
file = findArtifact(project.getExecutionProject(), artifact, true);
}
return file;
}
// No project, but most certainly a dependency which has been built previously
File packagedArtifactFile = findInProjectLocalRepository(artifact);
if (packagedArtifactFile != null && packagedArtifactFile.exists()) {
// Check if artifact is up-to-date (only for non-POM artifacts)
if (!"pom".equals(artifact.getExtension())) {
project = getProject(artifact, getAllProjects());
if (project != null) {
isPackagedArtifactUpToDate(project, packagedArtifactFile);
}
}
return packagedArtifactFile;
}
return null;
}
@Override
public List<String> findVersions(Artifact artifact) {
List<String> versions = getProjects()
.getOrDefault(artifact.getGroupId(), Collections.emptyMap())
.getOrDefault(artifact.getArtifactId(), Collections.emptyMap())
.values()
.stream()
.map(MavenProject::getVersion)
.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
if (!versions.isEmpty()) {
return versions;
}
return getAllProjects()
.getOrDefault(artifact.getGroupId(), Collections.emptyMap())
.getOrDefault(artifact.getArtifactId(), Collections.emptyMap())
.values()
.stream()
.filter(p -> Objects.nonNull(findArtifact(p, artifact, false)))
.map(MavenProject::getVersion)
.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
}
@Override
public Model findModel(Artifact artifact) {
MavenProject project = getProject(artifact);
return project == null ? null : project.getModel().getDelegate();
}
//
// Implementation
//
private File findArtifact(MavenProject project, Artifact artifact, boolean checkUptodate) {
// POMs are always returned from the file system
if ("pom".equals(artifact.getExtension())) {
return project.getFile();
}
// Get the matching artifact from the project
Artifact projectArtifact = findMatchingArtifact(project, artifact);
if (projectArtifact != null) {
// If the artifact has been associated to a file, use it
File packagedArtifactFile = projectArtifact.getFile();
if (packagedArtifactFile != null && packagedArtifactFile.exists()) {
return packagedArtifactFile;
}
}
// Check in the project local repository
File packagedArtifactFile = findInProjectLocalRepository(artifact);
if (packagedArtifactFile != null
&& packagedArtifactFile.exists()
&& (!checkUptodate
|| "pom".equals(artifact.getExtension())
|| isPackagedArtifactUpToDate(project, packagedArtifactFile))) {
return packagedArtifactFile;
}
if (!hasBeenPackagedDuringThisSession(project)) {
// fallback to loose class files only if artifacts haven't been packaged yet
// and only for plain old jars. Not war files, not ear files, not anything else.
return determineBuildOutputDirectoryForArtifact(project, artifact);
}
// The fall-through indicates that the artifact cannot be found;
// for instance if package produced nothing or classifier problems.
return null;
}
private File determineBuildOutputDirectoryForArtifact(final MavenProject project, final Artifact artifact) {
if (isTestArtifact(artifact)) {
if (project.hasLifecyclePhase("test-compile")) {
return new File(project.getBuild().getTestOutputDirectory());
}
} else {
String type = artifact.getProperty("type", "");
File outputDirectory = new File(project.getBuild().getOutputDirectory());
// Check if the project is being built during this session, and if we can expect any output.
// There is no need to check if the build has created any outputs, see MNG-2222.
boolean projectCompiledDuringThisSession =
project.hasLifecyclePhase("compile") && COMPILE_PHASE_TYPES.contains(type);
// Check if the project is part of the session (not filtered by -pl, -rf, etc). If so, we check
// if a possible earlier Maven invocation produced some output for that project which we can use.
boolean projectHasOutputFromPreviousSession =
!session.getProjects().contains(project) && outputDirectory.exists();
if (projectHasOutputFromPreviousSession || projectCompiledDuringThisSession) {
return outputDirectory;
}
}
// The fall-through indicates that the artifact cannot be found;
// for instance if package produced nothing or classifier problems.
return null;
}
private boolean isPackagedArtifactUpToDate(MavenProject project, File packagedArtifactFile) {
Path outputDirectory = Paths.get(project.getBuild().getOutputDirectory());
if (!outputDirectory.toFile().exists()) {
return true;
}
try (Stream<Path> outputFiles = Files.walk(outputDirectory)) {
// Not using File#lastModified() to avoid a Linux JDK8 milliseconds precision bug: JDK-8177809.
long artifactLastModified =
Files.getLastModifiedTime(packagedArtifactFile.toPath()).toMillis();
if (session.getProjectBuildingRequest().getBuildStartTime() != null) {
long buildStartTime =
session.getProjectBuildingRequest().getBuildStartTime().getTime();
if (artifactLastModified > buildStartTime) {
return true;
}
}
for (Path outputFile : (Iterable<Path>) outputFiles::iterator) {
if (Files.isDirectory(outputFile)) {
continue;
}
long outputFileLastModified =
Files.getLastModifiedTime(outputFile).toMillis();
if (outputFileLastModified > artifactLastModified) {
LOGGER.warn(
"File '{}' is more recent than the packaged artifact for '{}', "
+ "please run a full `mvn package` build",
relativizeOutputFile(outputFile),
project.getArtifactId());
return false;
} else if (LOGGER.isDebugEnabled()) {
LOGGER.debug(
"File '{}' timestamp {} vs artifact timestamp {} for '{}'",
relativizeOutputFile(outputFile),
outputFileLastModified,
artifactLastModified,
project.getArtifactId());
}
}
return true;
} catch (IOException e) {
LOGGER.warn(
"An I/O error occurred while checking if the packaged artifact is up-to-date "
+ "against the build output directory. "
+ "Continuing with the assumption that it is up-to-date.",
e);
return true;
}
}
private boolean hasBeenPackagedDuringThisSession(MavenProject project) {
boolean packaged = false;
for (String phase : getLifecycles(project)) {
switch (phase) {
case "clean":
packaged = false;
break;
case "package":
case "install":
case "deploy":
packaged = true;
break;
default:
break;
}
}
return packaged;
}
private Path relativizeOutputFile(final Path outputFile) {
Path rootDirectory = session.getRequest().getRootDirectory();
return rootDirectory.relativize(outputFile);
}
/**
* Tries to resolve the specified artifact from the artifacts of the given project.
*
* @param project The project to try to resolve the artifact from, must not be <code>null</code>.
* @param requestedArtifact The artifact to resolve, must not be <code>null</code>.
* @return The matching artifact from the project or <code>null</code> if not found. Note that this
*/
private Artifact findMatchingArtifact(MavenProject project, Artifact requestedArtifact) {
String requestedRepositoryConflictId = ArtifactIdUtils.toVersionlessId(requestedArtifact);
return getProjectArtifacts(project)
.filter(artifact ->
Objects.equals(requestedRepositoryConflictId, ArtifactIdUtils.toVersionlessId(artifact)))
.findFirst()
.orElse(null);
}
/**
* Determines whether the specified artifact refers to test classes.
*
* @param artifact The artifact to check, must not be {@code null}.
* @return {@code true} if the artifact refers to test classes, {@code false} otherwise.
*/
private static boolean isTestArtifact(Artifact artifact) {
return ("test-jar".equals(artifact.getProperty("type", "")))
|| ("jar".equals(artifact.getExtension()) && "tests".equals(artifact.getClassifier()));
}
private File findInProjectLocalRepository(Artifact artifact) {
// Prefer the consumer POM when resolving POMs from the project-local repository,
// to avoid treating a build POM as a repository (consumer) POM.
if ("pom".equals(artifact.getExtension())) {
String classifier = artifact.getClassifier();
if (classifier == null || classifier.isEmpty()) {
Path consumer = getArtifactPath(
artifact.getGroupId(), artifact.getArtifactId(), artifact.getBaseVersion(), "consumer", "pom");
if (Files.isRegularFile(consumer)) {
return consumer.toFile();
}
}
}
Path target = getArtifactPath(artifact);
return Files.isRegularFile(target) ? target.toFile() : null;
}
/**
* We are interested in project success events, in which case we call
* the {@link #installIntoProjectLocalRepository(MavenProject)} method.
* The mojo started event is also captured to determine the lifecycle
* phases the project has been through.
*
* @param event the execution event
*/
private void processEvent(ExecutionEvent event) {
MavenProject project = event.getProject();
switch (event.getType()) {
case MojoStarted:
String phase = event.getMojoExecution().getLifecyclePhase();
if (phase != null) {
Deque<String> phases = getLifecycles(project);
if (!Objects.equals(phase, phases.peekLast())) {
phases.addLast(phase);
if ("clean".equals(phase)) {
synchronized (project) {
cleanProjectLocalRepository(project);
}
}
}
}
break;
case ProjectSucceeded:
case ForkedProjectSucceeded:
synchronized (project) {
installIntoProjectLocalRepository(project);
}
break;
default:
break;
}
}
private Deque<String> getLifecycles(MavenProject project) {
return lifecycles.computeIfAbsent(project.getId(), k -> new ArrayDeque<>());
}
/**
* Copy packaged and attached artifacts from this project to the
* project local repository.
* This allows a subsequent build to resume while still being able
* to locate attached artifacts.
*
* @param project the project to copy artifacts from
*/
private void installIntoProjectLocalRepository(MavenProject project) {
if ("pom".equals(project.getPackaging())
&& !"clean".equals(getLifecycles(project).peekLast())
|| hasBeenPackagedDuringThisSession(project)) {
getProjectArtifacts(project).filter(this::isRegularFile).forEach(this::installIntoProjectLocalRepository);
}
}
private void cleanProjectLocalRepository(MavenProject project) {
try {
Path artifactPath = getProjectLocalRepo()
.resolve(project.getGroupId())
.resolve(project.getArtifactId())
.resolve(project.getVersion());
if (Files.isDirectory(artifactPath)) {
try (Stream<Path> paths = Files.list(artifactPath)) {
for (Path path : (Iterable<Path>) paths::iterator) {
Files.delete(path);
}
}
try {
Files.delete(artifactPath);
Files.delete(artifactPath.getParent());
Files.delete(artifactPath.getParent().getParent());
} catch (DirectoryNotEmptyException e) {
// ignore
}
}
} catch (IOException e) {
LOGGER.error("Error while cleaning project local repository", e);
}
}
/**
* Retrieve a stream of the project's artifacts
*/
private Stream<Artifact> getProjectArtifacts(MavenProject project) {
Stream<org.apache.maven.artifact.Artifact> artifacts = Stream.concat(
Stream.concat(
// pom artifact
Stream.of(new ProjectArtifact(project)),
// main project artifact if not a pom
"pom".equals(project.getPackaging()) ? Stream.empty() : Stream.of(project.getArtifact())),
// attached artifacts
project.getAttachedArtifacts().stream());
return artifacts.map(RepositoryUtils::toArtifact);
}
private boolean isRegularFile(Artifact artifact) {
return artifact.getFile() != null && artifact.getFile().isFile();
}
private void installIntoProjectLocalRepository(Artifact artifact) {
String extension = artifact.getExtension();
String classifier = artifact.getClassifier();
Path target = getArtifactPath(
artifact.getGroupId(), artifact.getArtifactId(), artifact.getVersion(), classifier, extension);
try {
LOGGER.info("Copying {} to project local repository", artifact);
Files.createDirectories(target.getParent());
Files.copy(
artifact.getPath(),
target,
StandardCopyOption.REPLACE_EXISTING,
StandardCopyOption.COPY_ATTRIBUTES);
} catch (IOException e) {
LOGGER.error("Error while copying artifact to project local repository", e);
}
}
private Path getArtifactPath(Artifact artifact) {
String groupId = artifact.getGroupId();
String artifactId = artifact.getArtifactId();
String version = artifact.getBaseVersion();
String classifier = artifact.getClassifier();
String extension = artifact.getExtension();
return getArtifactPath(groupId, artifactId, version, classifier, extension);
}
private Path getArtifactPath(
String groupId, String artifactId, String version, String classifier, String extension) {
Path repo = getProjectLocalRepo();
return repo.resolve(groupId)
.resolve(artifactId)
.resolve(version)
.resolve(artifactId
+ "-" + version
+ (classifier != null && !classifier.isEmpty() ? "-" + classifier : "")
+ "." + extension);
}
private Path getProjectLocalRepo() {
if (projectLocalRepository == null) {
Path root = session.getRequest().getRootDirectory();
List<MavenProject> projects = session.getProjects();
if (projects != null) {
projectLocalRepository = projects.stream()
.filter(project -> Objects.equals(root.toFile(), project.getBasedir()))
.findFirst()
.map(project -> project.getBuild().getDirectory())
.map(Paths::get)
.orElseGet(() -> root.resolve("target"))
.resolve(PROJECT_LOCAL_REPO);
} else {
return root.resolve("target").resolve(PROJECT_LOCAL_REPO);
}
}
return projectLocalRepository;
}
private MavenProject getProject(Artifact artifact) {
return getProject(artifact, getProjects());
}
private MavenProject getProject(Artifact artifact, Map<String, Map<String, Map<String, MavenProject>>> projects) {
return projects.getOrDefault(artifact.getGroupId(), Collections.emptyMap())
.getOrDefault(artifact.getArtifactId(), Collections.emptyMap())
.getOrDefault(artifact.getBaseVersion(), null);
}
// groupId -> (artifactId -> (version -> project)))
private Map<String, Map<String, Map<String, MavenProject>>> getAllProjects() {
// compute the projects mapping
if (allProjects == null) {
List<MavenProject> allProjects = session.getAllProjects();
if (allProjects != null) {
Map<String, Map<String, Map<String, MavenProject>>> map = new HashMap<>();
allProjects.forEach(project -> map.computeIfAbsent(project.getGroupId(), k -> new HashMap<>())
.computeIfAbsent(project.getArtifactId(), k -> new HashMap<>())
.put(project.getVersion(), project));
this.allProjects = map;
} else {
return Collections.emptyMap();
}
}
return allProjects;
}
private Map<String, Map<String, Map<String, MavenProject>>> getProjects() {
// compute the projects mapping
if (projects == null) {
List<MavenProject> projects = session.getProjects();
if (projects != null) {
Map<String, Map<String, Map<String, MavenProject>>> map = new HashMap<>();
projects.forEach(project -> map.computeIfAbsent(project.getGroupId(), k -> new HashMap<>())
.computeIfAbsent(project.getArtifactId(), k -> new HashMap<>())
.put(project.getVersion(), project));
this.projects = map;
} else {
return Collections.emptyMap();
}
}
return projects;
}
/**
* Singleton class used to receive events by implementing the EventSpy.
* It simply forwards all {@code ExecutionEvent}s to the {@code ReactorReader}.
*/
@Named
@Singleton
@SuppressWarnings("unused")
static class ReactorReaderSpy implements EventSpy {
private final Lookup lookup;
@Inject
ReactorReaderSpy(Lookup lookup) {
this.lookup = lookup;
}
@Override
public void init(Context context) throws Exception {}
@Override
public void onEvent(Object event) throws Exception {
if (event instanceof ExecutionEvent executionEvent) {
ReactorReader reactorReader = lookup.lookup(ReactorReader.class);
reactorReader.processEvent(executionEvent);
}
}
@Override
public void close() throws Exception {}
}
}