org.apache.maven.shared.release.phase.CheckDependencySnapshotsPhase Maven / Gradle / Ivy
The newest version!
/*
* 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.shared.release.phase;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicReference;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.ArtifactUtils;
import org.apache.maven.project.MavenProject;
import org.apache.maven.shared.release.ReleaseExecutionException;
import org.apache.maven.shared.release.ReleaseFailureException;
import org.apache.maven.shared.release.ReleaseResult;
import org.apache.maven.shared.release.config.ReleaseDescriptor;
import org.apache.maven.shared.release.env.ReleaseEnvironment;
import org.apache.maven.shared.release.versions.DefaultVersionInfo;
import org.apache.maven.shared.release.versions.VersionInfo;
import org.apache.maven.shared.release.versions.VersionParseException;
import org.codehaus.plexus.components.interactivity.Prompter;
import org.codehaus.plexus.components.interactivity.PrompterException;
import static java.util.Objects.requireNonNull;
/**
* Check the dependencies of all projects being released to see if there are any unreleased snapshots.
*
* @author Brett Porter
*/
// TODO plugins with no version will be resolved to RELEASE which is not a snapshot, but remains unresolved to this
// point. This is a potential hole in the check, and should be revisited after the release pom writing is done and
// resolving versions to verify whether it is.
// TODO plugins injected by the lifecycle are not tested here. They will be injected with a RELEASE version so are
// covered under the above point.
@Singleton
@Named("check-dependency-snapshots")
public class CheckDependencySnapshotsPhase extends AbstractReleasePhase {
public static final String RESOLVE_SNAPSHOT_MESSAGE = "There are still some remaining snapshot dependencies.\n";
public static final String RESOLVE_SNAPSHOT_PROMPT = "Do you want to resolve them now?";
public static final String RESOLVE_SNAPSHOT_TYPE_MESSAGE = "Dependency type to resolve,";
public static final String RESOLVE_SNAPSHOT_TYPE_PROMPT =
"specify the selection number ( 0:All 1:Project Dependencies 2:Plugins 3:Reports 4:Extensions ):";
/**
* Component used to prompt for input.
*/
private final AtomicReference prompter;
// Be aware of the difference between usedSnapshots and specifiedSnapshots:
// UsedSnapshots end up on the classpath.
// SpecifiedSnapshots are defined anywhere in the pom.
// We'll probably need to introduce specifiedSnapshots as well.
// @TODO MRELEASE-378: verify custom dependencies in plugins. Be aware of deprecated/removed Components in M3, such
// as PluginCollector
// @TODO MRELEASE-763: verify all dependencies in inactive profiles
// Don't prompt for every project in reactor, remember state of questions
private String resolveSnapshot;
private String resolveSnapshotType;
@Inject
public CheckDependencySnapshotsPhase(Prompter prompter) {
this.prompter = new AtomicReference<>(requireNonNull(prompter));
}
/**
* For easier testing only!
*/
public void setPrompter(Prompter prompter) {
this.prompter.set(prompter);
}
@Override
public ReleaseResult execute(
ReleaseDescriptor releaseDescriptor,
ReleaseEnvironment releaseEnvironment,
List reactorProjects)
throws ReleaseExecutionException, ReleaseFailureException {
ReleaseResult result = new ReleaseResult();
if (!releaseDescriptor.isAllowTimestampedSnapshots()) {
logInfo(result, "Checking dependencies and plugins for snapshots ...");
for (MavenProject project : reactorProjects) {
checkProject(project, releaseDescriptor);
}
} else {
logInfo(result, "Ignoring SNAPSHOT dependencies and plugins ...");
}
result.setResultCode(ReleaseResult.SUCCESS);
return result;
}
private void checkProject(MavenProject project, ReleaseDescriptor releaseDescriptor)
throws ReleaseFailureException, ReleaseExecutionException {
Map artifactMap = ArtifactUtils.artifactMapByVersionlessId(project.getArtifacts());
Set usedSnapshotDependencies = new HashSet<>();
if (project.getParentArtifact() != null) {
if (checkArtifact(project.getParentArtifact(), artifactMap, releaseDescriptor)) {
usedSnapshotDependencies.add(project.getParentArtifact());
}
}
Set dependencyArtifacts = project.getDependencyArtifacts();
usedSnapshotDependencies.addAll(checkDependencies(releaseDescriptor, artifactMap, dependencyArtifacts));
// @todo check dependencyManagement
Set pluginArtifacts = project.getPluginArtifacts();
Set usedSnapshotPlugins = checkPlugins(releaseDescriptor, artifactMap, pluginArtifacts);
// @todo check pluginManagement
Set reportArtifacts = project.getReportArtifacts();
Set usedSnapshotReports = checkReports(releaseDescriptor, artifactMap, reportArtifacts);
Set extensionArtifacts = project.getExtensionArtifacts();
Set usedSnapshotExtensions = checkExtensions(releaseDescriptor, artifactMap, extensionArtifacts);
// @todo check profiles
if (!usedSnapshotDependencies.isEmpty()
|| !usedSnapshotReports.isEmpty()
|| !usedSnapshotExtensions.isEmpty()
|| !usedSnapshotPlugins.isEmpty()) {
if (releaseDescriptor.isInteractive() || null != releaseDescriptor.getAutoResolveSnapshots()) {
resolveSnapshots(
usedSnapshotDependencies,
usedSnapshotReports,
usedSnapshotExtensions,
usedSnapshotPlugins,
releaseDescriptor);
}
if (!usedSnapshotDependencies.isEmpty()
|| !usedSnapshotReports.isEmpty()
|| !usedSnapshotExtensions.isEmpty()
|| !usedSnapshotPlugins.isEmpty()) {
StringBuilder message = new StringBuilder();
printSnapshotDependencies(usedSnapshotDependencies, message);
printSnapshotDependencies(usedSnapshotReports, message);
printSnapshotDependencies(usedSnapshotExtensions, message);
printSnapshotDependencies(usedSnapshotPlugins, message);
message.append("in project '" + project.getName() + "' (" + project.getId() + ")");
throw new ReleaseFailureException(
"Can't release project due to non released dependencies :\n" + message);
}
}
}
private Set checkPlugins(
ReleaseDescriptor releaseDescriptor, Map artifactMap, Set pluginArtifacts)
throws ReleaseExecutionException {
Set usedSnapshotPlugins = new HashSet<>();
for (Artifact artifact : pluginArtifacts) {
if (checkArtifact(artifact, artifactMap, releaseDescriptor)) {
boolean addToFailures;
if ("org.apache.maven.plugins".equals(artifact.getGroupId())
&& "maven-release-plugin".equals(artifact.getArtifactId())) {
// It's a snapshot of the release plugin. Maybe just testing - ask
// By default, we fail as for any other plugin
if (releaseDescriptor.isSnapshotReleasePluginAllowed()) {
addToFailures = false;
} else if (releaseDescriptor.isInteractive()) {
try {
String result;
if (!releaseDescriptor.isSnapshotReleasePluginAllowed()) {
prompter.get()
.showMessage("This project relies on a SNAPSHOT of the release plugin. "
+ "This may be necessary during testing.\n");
result = prompter.get()
.prompt(
"Do you want to continue with the release?",
Arrays.asList("yes", "no"),
"no");
} else {
result = "yes";
}
addToFailures = !result.toLowerCase(Locale.ENGLISH).startsWith("y");
} catch (PrompterException e) {
throw new ReleaseExecutionException(e.getMessage(), e);
}
} else {
addToFailures = true;
}
} else {
addToFailures = true;
}
if (addToFailures) {
usedSnapshotPlugins.add(artifact);
}
}
}
return usedSnapshotPlugins;
}
private Set checkDependencies(
ReleaseDescriptor releaseDescriptor, Map artifactMap, Set dependencyArtifacts) {
Set usedSnapshotDependencies = new HashSet<>();
for (Artifact artifact : dependencyArtifacts) {
if (checkArtifact(artifact, artifactMap, releaseDescriptor)) {
usedSnapshotDependencies.add(getArtifactFromMap(artifact, artifactMap));
}
}
return usedSnapshotDependencies;
}
private Set checkReports(
ReleaseDescriptor releaseDescriptor, Map artifactMap, Set reportArtifacts) {
Set usedSnapshotReports = new HashSet<>();
for (Artifact artifact : reportArtifacts) {
if (checkArtifact(artifact, artifactMap, releaseDescriptor)) {
// snapshotDependencies.add( artifact );
usedSnapshotReports.add(artifact);
}
}
return usedSnapshotReports;
}
private Set checkExtensions(
ReleaseDescriptor releaseDescriptor, Map artifactMap, Set extensionArtifacts) {
Set usedSnapshotExtensions = new HashSet<>();
for (Artifact artifact : extensionArtifacts) {
if (checkArtifact(artifact, artifactMap, releaseDescriptor)) {
usedSnapshotExtensions.add(artifact);
}
}
return usedSnapshotExtensions;
}
private static boolean checkArtifact(
Artifact artifact, Map artifactMapByVersionlessId, ReleaseDescriptor releaseDescriptor) {
Artifact checkArtifact = getArtifactFromMap(artifact, artifactMapByVersionlessId);
return checkArtifact(checkArtifact, releaseDescriptor);
}
private static Artifact getArtifactFromMap(Artifact artifact, Map artifactMapByVersionlessId) {
String versionlessId = ArtifactUtils.versionlessKey(artifact);
Artifact checkArtifact = artifactMapByVersionlessId.get(versionlessId);
if (checkArtifact == null) {
checkArtifact = artifact;
}
return checkArtifact;
}
private static boolean checkArtifact(Artifact artifact, ReleaseDescriptor releaseDescriptor) {
String versionlessKey = ArtifactUtils.versionlessKey(artifact.getGroupId(), artifact.getArtifactId());
String releaseDescriptorResolvedVersion = releaseDescriptor.getDependencyReleaseVersion(versionlessKey);
boolean releaseDescriptorResolvedVersionIsSnapshot = releaseDescriptorResolvedVersion == null
|| releaseDescriptorResolvedVersion.contains(Artifact.SNAPSHOT_VERSION);
// We are only looking at dependencies external to the project - ignore anything found in the reactor as
// it's version will be updated
boolean bannedVersion = artifact.isSnapshot()
&& !artifact.getBaseVersion().equals(releaseDescriptor.getProjectOriginalVersion(versionlessKey))
&& releaseDescriptorResolvedVersionIsSnapshot;
// If we have a snapshot but allowTimestampedSnapshots is true, accept the artifact if the version
// indicates that it is a timestamped snapshot.
if (bannedVersion && releaseDescriptor.isAllowTimestampedSnapshots()) {
bannedVersion = artifact.getVersion().contains(Artifact.SNAPSHOT_VERSION);
}
return bannedVersion;
}
@Override
public ReleaseResult simulate(
ReleaseDescriptor releaseDescriptor,
ReleaseEnvironment releaseEnvironment,
List reactorProjects)
throws ReleaseExecutionException, ReleaseFailureException {
// It makes no modifications, so simulate is the same as execute
return execute(releaseDescriptor, releaseEnvironment, reactorProjects);
}
private void printSnapshotDependencies(Set snapshotsSet, StringBuilder message) {
List snapshotsList = new ArrayList<>(snapshotsSet);
Collections.sort(snapshotsList);
for (Artifact artifact : snapshotsList) {
message.append(" ");
message.append(artifact);
message.append("\n");
}
}
private void resolveSnapshots(
Set projectDependencies,
Set reportDependencies,
Set extensionDependencies,
Set pluginDependencies,
ReleaseDescriptor releaseDescriptor)
throws ReleaseExecutionException {
try {
String autoResolveSnapshots = releaseDescriptor.getAutoResolveSnapshots();
if (resolveSnapshot == null) {
prompter.get().showMessage(RESOLVE_SNAPSHOT_MESSAGE);
if (autoResolveSnapshots != null) {
resolveSnapshot = "yes";
prompter.get().showMessage(RESOLVE_SNAPSHOT_PROMPT + " " + resolveSnapshot);
} else {
resolveSnapshot = prompter.get().prompt(RESOLVE_SNAPSHOT_PROMPT, Arrays.asList("yes", "no"), "no");
}
}
if (resolveSnapshot.toLowerCase(Locale.ENGLISH).startsWith("y")) {
if (resolveSnapshotType == null) {
prompter.get().showMessage(RESOLVE_SNAPSHOT_TYPE_MESSAGE);
int defaultAnswer = -1;
if (autoResolveSnapshots != null) {
if ("all".equalsIgnoreCase(autoResolveSnapshots)) {
defaultAnswer = 0;
} else if ("dependencies".equalsIgnoreCase(autoResolveSnapshots)) {
defaultAnswer = 1;
} else if ("plugins".equalsIgnoreCase(autoResolveSnapshots)) {
defaultAnswer = 2;
} else if ("reports".equalsIgnoreCase(autoResolveSnapshots)) {
defaultAnswer = 3;
} else if ("extensions".equalsIgnoreCase(autoResolveSnapshots)) {
defaultAnswer = 4;
} else {
try {
defaultAnswer = Integer.parseInt(autoResolveSnapshots);
} catch (NumberFormatException e) {
throw new ReleaseExecutionException(e.getMessage(), e);
}
}
}
if (defaultAnswer >= 0 && defaultAnswer <= 4) {
prompter.get().showMessage(RESOLVE_SNAPSHOT_TYPE_PROMPT + " " + autoResolveSnapshots);
resolveSnapshotType = Integer.toString(defaultAnswer);
} else {
resolveSnapshotType = prompter.get()
.prompt(RESOLVE_SNAPSHOT_TYPE_PROMPT, Arrays.asList("0", "1", "2", "3"), "1");
}
}
switch (Integer.parseInt(resolveSnapshotType.toLowerCase(Locale.ENGLISH))) {
// all
case 0:
processSnapshot(projectDependencies, releaseDescriptor, autoResolveSnapshots);
processSnapshot(pluginDependencies, releaseDescriptor, autoResolveSnapshots);
processSnapshot(reportDependencies, releaseDescriptor, autoResolveSnapshots);
processSnapshot(extensionDependencies, releaseDescriptor, autoResolveSnapshots);
break;
// project dependencies
case 1:
processSnapshot(projectDependencies, releaseDescriptor, autoResolveSnapshots);
break;
// plugins
case 2:
processSnapshot(pluginDependencies, releaseDescriptor, autoResolveSnapshots);
break;
// reports
case 3:
processSnapshot(reportDependencies, releaseDescriptor, autoResolveSnapshots);
break;
// extensions
case 4:
processSnapshot(extensionDependencies, releaseDescriptor, autoResolveSnapshots);
break;
default:
}
}
} catch (PrompterException | VersionParseException e) {
throw new ReleaseExecutionException(e.getMessage(), e);
}
}
private void processSnapshot(
Set snapshotSet, ReleaseDescriptor releaseDescriptor, String autoResolveSnapshots)
throws PrompterException, VersionParseException {
Iterator iterator = snapshotSet.iterator();
while (iterator.hasNext()) {
Artifact currentArtifact = iterator.next();
String versionlessKey = ArtifactUtils.versionlessKey(currentArtifact);
VersionInfo versionInfo = new DefaultVersionInfo(currentArtifact.getBaseVersion());
releaseDescriptor.addDependencyOriginalVersion(versionlessKey, versionInfo.toString());
prompter.get()
.showMessage("Dependency '" + versionlessKey + "' is a snapshot (" + currentArtifact.getVersion()
+ ")\n");
String message = "Which release version should it be set to?";
String result;
if (null != autoResolveSnapshots) {
result = versionInfo.getReleaseVersionString();
prompter.get().showMessage(message + " " + result);
} else {
result = prompter.get().prompt(message, versionInfo.getReleaseVersionString());
}
releaseDescriptor.addDependencyReleaseVersion(versionlessKey, result);
iterator.remove();
// by default, keep the same version for the dependency after release, unless it was previously newer
// the user may opt to type in something different
VersionInfo nextVersionInfo = new DefaultVersionInfo(result);
String nextVersion;
if (nextVersionInfo.compareTo(versionInfo) > 0) {
nextVersion = nextVersionInfo.toString();
} else {
nextVersion = versionInfo.toString();
}
message = "What version should the dependency be reset to for development?";
if (null != autoResolveSnapshots) {
result = nextVersion;
prompter.get().showMessage(message + " " + result);
} else {
result = prompter.get().prompt(message, nextVersion);
}
releaseDescriptor.addDependencyDevelopmentVersion(versionlessKey, result);
}
}
}