DefaultLifecyclePluginAnalyzer.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.lifecycle.internal;
import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Singleton;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.maven.api.services.Lookup;
import org.apache.maven.api.xml.XmlNode;
import org.apache.maven.internal.impl.DefaultLifecycleRegistry;
import org.apache.maven.lifecycle.DefaultLifecycles;
import org.apache.maven.lifecycle.LifeCyclePluginAnalyzer;
import org.apache.maven.lifecycle.Lifecycle;
import org.apache.maven.lifecycle.mapping.LifecycleMapping;
import org.apache.maven.lifecycle.mapping.LifecycleMojo;
import org.apache.maven.lifecycle.mapping.LifecyclePhase;
import org.apache.maven.model.InputLocation;
import org.apache.maven.model.InputSource;
import org.apache.maven.model.Plugin;
import org.apache.maven.model.PluginExecution;
import org.codehaus.plexus.util.xml.Xpp3Dom;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import static java.util.Objects.requireNonNull;
/**
* <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
*
* @since 3.0
*/
@Singleton
@Named
public class DefaultLifecyclePluginAnalyzer implements LifeCyclePluginAnalyzer {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final Lookup lookup;
private final DefaultLifecycles defaultLifeCycles;
@Inject
public DefaultLifecyclePluginAnalyzer(Lookup lookup, DefaultLifecycles defaultLifeCycles) {
this.lookup = requireNonNull(lookup);
this.defaultLifeCycles = requireNonNull(defaultLifeCycles);
}
// These methods deal with construction intact Plugin object that look like they come from a standard
// <plugin/> block in a Maven POM. We have to do some wiggling to pull the sources of information
// together and this really shows the problem of constructing a sensible default configuration, but
// it's all encapsulated here so it appears normalized to the POM builder.
// We are going to take the project packaging and find all plugins in the default lifecycle and create
// fully populated Plugin objects, including executions with goals and default configuration taken
// from the plugin.xml inside a plugin.
@Override
public Set<Plugin> getPluginsBoundByDefaultToAllLifecycles(String packaging) {
if (logger.isDebugEnabled()) {
logger.debug("Looking up lifecycle mappings for packaging " + packaging + " from "
+ Thread.currentThread().getContextClassLoader());
}
LifecycleMapping lifecycleMappingForPackaging = lookupLifecycleMapping(packaging);
if (lifecycleMappingForPackaging == null) {
return null;
}
Map<Plugin, Plugin> plugins = new LinkedHashMap<>();
for (Lifecycle lifecycle : defaultLifeCycles.getLifeCycles()) {
org.apache.maven.lifecycle.mapping.Lifecycle lifecycleConfiguration =
lifecycleMappingForPackaging.getLifecycles().get(lifecycle.getId());
Map<String, LifecyclePhase> phaseToGoalMapping = null;
if (lifecycleConfiguration != null) {
phaseToGoalMapping = lifecycleConfiguration.getLifecyclePhases();
} else if (lifecycle.getDefaultLifecyclePhases() != null) {
phaseToGoalMapping = lifecycle.getDefaultLifecyclePhases();
}
if (phaseToGoalMapping != null) {
for (Map.Entry<String, LifecyclePhase> goalsForLifecyclePhase : phaseToGoalMapping.entrySet()) {
String phase = goalsForLifecyclePhase.getKey();
LifecyclePhase goals = goalsForLifecyclePhase.getValue();
if (goals != null) {
parseLifecyclePhaseDefinitions(plugins, phase, goals);
}
}
}
}
return plugins.keySet();
}
/**
* Performs a lookup using Plexus API to make sure we can look up only "visible" (see Maven classloading) components
* from current module and for example not extensions coming from other modules.
*/
private LifecycleMapping lookupLifecycleMapping(final String packaging) {
return lookup.lookupOptional(LifecycleMapping.class, packaging).orElse(null);
}
private void parseLifecyclePhaseDefinitions(Map<Plugin, Plugin> plugins, String phase, LifecyclePhase goals) {
InputSource inputSource = new InputSource();
inputSource.setModelId(DefaultLifecycleRegistry.DEFAULT_LIFECYCLE_MODELID);
InputLocation location = new InputLocation(-1, -1, inputSource);
location.setLocation(0, location);
List<LifecycleMojo> mojos = goals.getMojos();
if (mojos != null) {
for (int i = 0; i < mojos.size(); i++) {
LifecycleMojo mojo = mojos.get(i);
GoalSpec gs = parseGoalSpec(mojo.getGoal());
if (gs == null) {
logger.warn(
"Ignored invalid goal specification '{}' from lifecycle mapping for phase {}",
mojo.getGoal(),
phase);
continue;
}
Plugin plugin = new Plugin();
plugin.setGroupId(gs.groupId);
plugin.setArtifactId(gs.artifactId);
plugin.setVersion(gs.version);
plugin.setLocation("", location);
plugin.setLocation("groupId", location);
plugin.setLocation("artifactId", location);
plugin.setLocation("version", location);
Plugin existing = plugins.get(plugin);
if (existing != null) {
if (existing.getVersion() == null) {
existing.setVersion(plugin.getVersion());
existing.setLocation("version", location);
}
plugin = existing;
} else {
plugins.put(plugin, plugin);
}
PluginExecution execution = new PluginExecution();
execution.setId(getExecutionId(plugin, gs.goal));
execution.setPhase(phase);
execution.setPriority(i - mojos.size());
execution.getGoals().add(gs.goal);
execution.setLocation("", location);
execution.setLocation("id", location);
execution.setLocation("phase", location);
execution.setLocation("goals", location);
XmlNode lifecycleConfiguration = mojo.getConfiguration();
if (lifecycleConfiguration != null) {
execution.setConfiguration(new Xpp3Dom(lifecycleConfiguration));
}
if (mojo.getDependencies() != null) {
plugin.setDependencies(mojo.getDependencies());
}
plugin.getExecutions().add(execution);
}
}
}
private GoalSpec parseGoalSpec(String goalSpec) {
GoalSpec gs = new GoalSpec();
String[] p = goalSpec.trim().split(":");
if (p.length == 3) {
// <groupId>:<artifactId>:<goal>
gs.groupId = p[0];
gs.artifactId = p[1];
gs.goal = p[2];
} else if (p.length == 4) {
// <groupId>:<artifactId>:<version>:<goal>
gs.groupId = p[0];
gs.artifactId = p[1];
gs.version = p[2];
gs.goal = p[3];
} else {
// invalid
gs = null;
}
return gs;
}
private String getExecutionId(Plugin plugin, String goal) {
Set<String> existingIds = new HashSet<>();
for (PluginExecution execution : plugin.getExecutions()) {
existingIds.add(execution.getId());
}
String base = "default-" + goal;
String id = base;
for (int index = 1; existingIds.contains(id); index++) {
id = base + '-' + index;
}
return id;
}
static class GoalSpec {
String groupId;
String artifactId;
String version;
String goal;
}
}