Java tutorial
package org.apache.maven.cli; /* * 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. */ import com.google.common.base.Charsets; import com.google.common.io.Files; import com.google.inject.AbstractModule; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.ParseException; import org.apache.commons.cli.UnrecognizedOptionException; import org.apache.maven.BuildAbort; import org.apache.maven.InternalErrorException; import org.apache.maven.Maven; import org.apache.maven.building.FileSource; import org.apache.maven.building.Problem; import org.apache.maven.building.Source; import org.apache.maven.cli.configuration.ConfigurationProcessor; import org.apache.maven.cli.configuration.SettingsXmlConfigurationProcessor; import org.apache.maven.cli.event.DefaultEventSpyContext; import org.apache.maven.cli.event.ExecutionEventLogger; import org.apache.maven.cli.internal.BootstrapCoreExtensionManager; import org.apache.maven.cli.internal.extension.model.CoreExtension; import org.apache.maven.cli.internal.extension.model.io.xpp3.CoreExtensionsXpp3Reader; import org.apache.maven.cli.logging.Slf4jConfiguration; import org.apache.maven.cli.logging.Slf4jConfigurationFactory; import org.apache.maven.cli.logging.Slf4jLoggerManager; import org.apache.maven.cli.logging.Slf4jStdoutLogger; import org.apache.maven.cli.transfer.ConsoleMavenTransferListener; import org.apache.maven.cli.transfer.QuietMavenTransferListener; import org.apache.maven.cli.transfer.Slf4jMavenTransferListener; import org.apache.maven.eventspy.internal.EventSpyDispatcher; import org.apache.maven.exception.DefaultExceptionHandler; import org.apache.maven.exception.ExceptionHandler; import org.apache.maven.exception.ExceptionSummary; import org.apache.maven.execution.DefaultMavenExecutionRequest; import org.apache.maven.execution.ExecutionListener; import org.apache.maven.execution.MavenExecutionRequest; import org.apache.maven.execution.MavenExecutionRequestPopulationException; import org.apache.maven.execution.MavenExecutionRequestPopulator; import org.apache.maven.execution.MavenExecutionResult; import org.apache.maven.extension.internal.CoreExports; import org.apache.maven.extension.internal.CoreExtensionEntry; import org.apache.maven.lifecycle.LifecycleExecutionException; import org.apache.maven.model.building.ModelProcessor; import org.apache.maven.project.MavenProject; import org.apache.maven.properties.internal.EnvironmentUtils; import org.apache.maven.properties.internal.SystemProperties; import org.apache.maven.toolchain.building.DefaultToolchainsBuildingRequest; import org.apache.maven.toolchain.building.ToolchainsBuilder; import org.apache.maven.toolchain.building.ToolchainsBuildingResult; import org.codehaus.plexus.ContainerConfiguration; import org.codehaus.plexus.DefaultContainerConfiguration; import org.codehaus.plexus.DefaultPlexusContainer; import org.codehaus.plexus.PlexusConstants; import org.codehaus.plexus.PlexusContainer; import org.codehaus.plexus.classworlds.ClassWorld; import org.codehaus.plexus.classworlds.realm.ClassRealm; import org.codehaus.plexus.classworlds.realm.NoSuchRealmException; import org.codehaus.plexus.component.repository.exception.ComponentLookupException; import org.codehaus.plexus.logging.LoggerManager; import org.codehaus.plexus.util.StringUtils; import org.codehaus.plexus.util.xml.pull.XmlPullParserException; import org.eclipse.aether.transfer.TransferListener; import org.slf4j.ILoggerFactory; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.sonatype.plexus.components.cipher.DefaultPlexusCipher; import org.sonatype.plexus.components.sec.dispatcher.DefaultSecDispatcher; import org.sonatype.plexus.components.sec.dispatcher.SecDispatcher; import org.sonatype.plexus.components.sec.dispatcher.SecUtil; import org.sonatype.plexus.components.sec.dispatcher.model.SettingsSecurity; import java.io.BufferedInputStream; import java.io.Console; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStream; import java.io.PrintStream; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Properties; import java.util.Set; import java.util.StringTokenizer; // TODO: push all common bits back to plexus cli and prepare for transition to Guice. We don't need 50 ways to make CLIs /** * @author Jason van Zyl * @noinspection UseOfSystemOutOrSystemErr, ACCESS_STATIC_VIA_INSTANCE */ public class MavenCli { public static final String LOCAL_REPO_PROPERTY = "maven.repo.local"; public static final String THREADS_DEPRECATED = "maven.threads.experimental"; public static final String MULTIMODULE_PROJECT_DIRECTORY = "maven.multiModuleProjectDirectory"; @SuppressWarnings("checkstyle:constantname") public static final String userHome = System.getProperty("user.home"); @SuppressWarnings("checkstyle:constantname") public static final File userMavenConfigurationHome = new File(userHome, ".m2"); /** * @deprecated use {@link SettingsXmlConfigurationProcessor#DEFAULT_USER_SETTINGS_FILE} */ public static final File DEFAULT_USER_SETTINGS_FILE = SettingsXmlConfigurationProcessor.DEFAULT_USER_SETTINGS_FILE; /** * @deprecated use {@link SettingsXmlConfigurationProcessor#DEFAULT_GLOBAL_SETTINGS_FILE} */ public static final File DEFAULT_GLOBAL_SETTINGS_FILE = SettingsXmlConfigurationProcessor.DEFAULT_GLOBAL_SETTINGS_FILE; public static final File DEFAULT_USER_TOOLCHAINS_FILE = new File(userMavenConfigurationHome, "toolchains.xml"); public static final File DEFAULT_GLOBAL_TOOLCHAINS_FILE = new File( System.getProperty("maven.home", System.getProperty("user.dir", "")), "conf/toolchains.xml"); private static final String EXT_CLASS_PATH = "maven.ext.class.path"; private static final String EXTENSIONS_FILENAME = ".mvn/extensions.xml"; private static final String MVN_MAVEN_CONFIG = ".mvn/maven.config"; private ClassWorld classWorld; private LoggerManager plexusLoggerManager; private ILoggerFactory slf4jLoggerFactory; private Logger slf4jLogger; private EventSpyDispatcher eventSpyDispatcher; private ModelProcessor modelProcessor; private Maven maven; private MavenExecutionRequestPopulator executionRequestPopulator; private ToolchainsBuilder toolchainsBuilder; private DefaultSecDispatcher dispatcher; private Map<String, ConfigurationProcessor> configurationProcessors; public MavenCli() { this(null); } // This supports painless invocation by the Verifier during embedded execution of the core ITs public MavenCli(ClassWorld classWorld) { this.classWorld = classWorld; } public static void main(String[] args) { int result = main(args, null); System.exit(result); } /** * @noinspection ConfusingMainMethod */ public static int main(String[] args, ClassWorld classWorld) { MavenCli cli = new MavenCli(); return cli.doMain(new CliRequest(args, classWorld)); } // TODO: need to externalize CliRequest public static int doMain(String[] args, ClassWorld classWorld) { MavenCli cli = new MavenCli(); return cli.doMain(new CliRequest(args, classWorld)); } // This supports painless invocation by the Verifier during embedded execution of the core ITs public int doMain(String[] args, String workingDirectory, PrintStream stdout, PrintStream stderr) { PrintStream oldout = System.out; PrintStream olderr = System.err; final Set<String> realms; if (classWorld != null) { realms = new HashSet<>(); for (ClassRealm realm : classWorld.getRealms()) { realms.add(realm.getId()); } } else { realms = Collections.emptySet(); } try { if (stdout != null) { System.setOut(stdout); } if (stderr != null) { System.setErr(stderr); } CliRequest cliRequest = new CliRequest(args, classWorld); cliRequest.workingDirectory = workingDirectory; return doMain(cliRequest); } finally { if (classWorld != null) { for (ClassRealm realm : new ArrayList<>(classWorld.getRealms())) { String realmId = realm.getId(); if (!realms.contains(realmId)) { try { classWorld.disposeRealm(realmId); } catch (NoSuchRealmException ignored) { // can't happen } } } } System.setOut(oldout); System.setErr(olderr); } } // TODO: need to externalize CliRequest public int doMain(CliRequest cliRequest) { PlexusContainer localContainer = null; try { initialize(cliRequest); cli(cliRequest); logging(cliRequest); version(cliRequest); properties(cliRequest); localContainer = container(cliRequest); commands(cliRequest); configure(cliRequest); toolchains(cliRequest); populateRequest(cliRequest); encryption(cliRequest); repository(cliRequest); return execute(cliRequest); } catch (ExitException e) { return e.exitCode; } catch (UnrecognizedOptionException e) { // pure user error, suppress stack trace return 1; } catch (BuildAbort e) { CLIReportingUtils.showError(slf4jLogger, "ABORTED", e, cliRequest.showErrors); return 2; } catch (Exception e) { CLIReportingUtils.showError(slf4jLogger, "Error executing Maven.", e, cliRequest.showErrors); return 1; } finally { if (localContainer != null) { localContainer.dispose(); } } } void initialize(CliRequest cliRequest) throws ExitException { if (cliRequest.workingDirectory == null) { cliRequest.workingDirectory = System.getProperty("user.dir"); } if (cliRequest.multiModuleProjectDirectory == null) { String basedirProperty = System.getProperty(MULTIMODULE_PROJECT_DIRECTORY); if (basedirProperty == null) { System.err.format( "-D%s system property is not set." + " Check $M2_HOME environment variable and mvn script match.", MULTIMODULE_PROJECT_DIRECTORY); throw new ExitException(1); } File basedir = basedirProperty != null ? new File(basedirProperty) : new File(""); try { cliRequest.multiModuleProjectDirectory = basedir.getCanonicalFile(); } catch (IOException e) { cliRequest.multiModuleProjectDirectory = basedir.getAbsoluteFile(); } } // // Make sure the Maven home directory is an absolute path to save us from confusion with say drive-relative // Windows paths. // String mavenHome = System.getProperty("maven.home"); if (mavenHome != null) { System.setProperty("maven.home", new File(mavenHome).getAbsolutePath()); } } void cli(CliRequest cliRequest) throws Exception { // // Parsing errors can happen during the processing of the arguments and we prefer not having to check if // the logger is null and construct this so we can use an SLF4J logger everywhere. // slf4jLogger = new Slf4jStdoutLogger(); CLIManager cliManager = new CLIManager(); List<String> args = new ArrayList<>(); try { File configFile = new File(cliRequest.multiModuleProjectDirectory, MVN_MAVEN_CONFIG); if (configFile.isFile()) { for (String arg : Files.toString(configFile, Charsets.UTF_8).split("\\s+")) { if (!arg.isEmpty()) { args.add(arg); } } CommandLine config = cliManager.parse(args.toArray(new String[args.size()])); List<?> unrecongized = config.getArgList(); if (!unrecongized.isEmpty()) { throw new ParseException("Unrecognized maven.config entries: " + unrecongized); } } } catch (ParseException e) { System.err.println("Unable to parse maven.config: " + e.getMessage()); cliManager.displayHelp(System.out); throw e; } try { args.addAll(0, Arrays.asList(cliRequest.args)); cliRequest.commandLine = cliManager.parse(args.toArray(new String[args.size()])); } catch (ParseException e) { System.err.println("Unable to parse command line options: " + e.getMessage()); cliManager.displayHelp(System.out); throw e; } if (cliRequest.commandLine.hasOption(CLIManager.HELP)) { cliManager.displayHelp(System.out); throw new ExitException(0); } if (cliRequest.commandLine.hasOption(CLIManager.VERSION)) { System.out.println(CLIReportingUtils.showVersion()); throw new ExitException(0); } } /** * configure logging */ private void logging(CliRequest cliRequest) { cliRequest.debug = cliRequest.commandLine.hasOption(CLIManager.DEBUG); cliRequest.quiet = !cliRequest.debug && cliRequest.commandLine.hasOption(CLIManager.QUIET); cliRequest.showErrors = cliRequest.debug || cliRequest.commandLine.hasOption(CLIManager.ERRORS); slf4jLoggerFactory = LoggerFactory.getILoggerFactory(); Slf4jConfiguration slf4jConfiguration = Slf4jConfigurationFactory.getConfiguration(slf4jLoggerFactory); if (cliRequest.debug) { cliRequest.request.setLoggingLevel(MavenExecutionRequest.LOGGING_LEVEL_DEBUG); slf4jConfiguration.setRootLoggerLevel(Slf4jConfiguration.Level.DEBUG); } else if (cliRequest.quiet) { cliRequest.request.setLoggingLevel(MavenExecutionRequest.LOGGING_LEVEL_ERROR); slf4jConfiguration.setRootLoggerLevel(Slf4jConfiguration.Level.ERROR); } // else fall back to default log level specified in conf // see https://issues.apache.org/jira/browse/MNG-2570 if (cliRequest.commandLine.hasOption(CLIManager.LOG_FILE)) { File logFile = new File(cliRequest.commandLine.getOptionValue(CLIManager.LOG_FILE)); logFile = resolveFile(logFile, cliRequest.workingDirectory); // redirect stdout and stderr to file try { PrintStream ps = new PrintStream(new FileOutputStream(logFile)); System.setOut(ps); System.setErr(ps); } catch (FileNotFoundException e) { // // Ignore // } } slf4jConfiguration.activate(); plexusLoggerManager = new Slf4jLoggerManager(); slf4jLogger = slf4jLoggerFactory.getLogger(this.getClass().getName()); } private void version(CliRequest cliRequest) { if (cliRequest.debug || cliRequest.commandLine.hasOption(CLIManager.SHOW_VERSION)) { System.out.println(CLIReportingUtils.showVersion()); } } private void commands(CliRequest cliRequest) { if (cliRequest.showErrors) { slf4jLogger.info("Error stacktraces are turned on."); } if (MavenExecutionRequest.CHECKSUM_POLICY_WARN.equals(cliRequest.request.getGlobalChecksumPolicy())) { slf4jLogger.info("Disabling strict checksum verification on all artifact downloads."); } else if (MavenExecutionRequest.CHECKSUM_POLICY_FAIL .equals(cliRequest.request.getGlobalChecksumPolicy())) { slf4jLogger.info("Enabling strict checksum verification on all artifact downloads."); } } private void properties(CliRequest cliRequest) { populateProperties(cliRequest.commandLine, cliRequest.systemProperties, cliRequest.userProperties); } private PlexusContainer container(CliRequest cliRequest) throws Exception { if (cliRequest.classWorld == null) { cliRequest.classWorld = new ClassWorld("plexus.core", Thread.currentThread().getContextClassLoader()); } ClassRealm coreRealm = cliRequest.classWorld.getClassRealm("plexus.core"); if (coreRealm == null) { coreRealm = cliRequest.classWorld.getRealms().iterator().next(); } List<File> extClassPath = parseExtClasspath(cliRequest); CoreExtensionEntry coreEntry = CoreExtensionEntry.discoverFrom(coreRealm); List<CoreExtensionEntry> extensions = loadCoreExtensions(cliRequest, coreRealm, coreEntry.getExportedArtifacts()); ClassRealm containerRealm = setupContainerRealm(cliRequest.classWorld, coreRealm, extClassPath, extensions); ContainerConfiguration cc = new DefaultContainerConfiguration().setClassWorld(cliRequest.classWorld) .setRealm(containerRealm).setClassPathScanning(PlexusConstants.SCANNING_INDEX).setAutoWiring(true) .setName("maven"); Set<String> exportedArtifacts = new HashSet<>(coreEntry.getExportedArtifacts()); Set<String> exportedPackages = new HashSet<>(coreEntry.getExportedPackages()); for (CoreExtensionEntry extension : extensions) { exportedArtifacts.addAll(extension.getExportedArtifacts()); exportedPackages.addAll(extension.getExportedPackages()); } final CoreExports exports = new CoreExports(containerRealm, exportedArtifacts, exportedPackages); DefaultPlexusContainer container = new DefaultPlexusContainer(cc, new AbstractModule() { @Override protected void configure() { bind(ILoggerFactory.class).toInstance(slf4jLoggerFactory); bind(CoreExports.class).toInstance(exports); } }); // NOTE: To avoid inconsistencies, we'll use the TCCL exclusively for lookups container.setLookupRealm(null); container.setLoggerManager(plexusLoggerManager); for (CoreExtensionEntry extension : extensions) { container.discoverComponents(extension.getClassRealm()); } customizeContainer(container); container.getLoggerManager().setThresholds(cliRequest.request.getLoggingLevel()); Thread.currentThread().setContextClassLoader(container.getContainerRealm()); eventSpyDispatcher = container.lookup(EventSpyDispatcher.class); DefaultEventSpyContext eventSpyContext = new DefaultEventSpyContext(); Map<String, Object> data = eventSpyContext.getData(); data.put("plexus", container); data.put("workingDirectory", cliRequest.workingDirectory); data.put("systemProperties", cliRequest.systemProperties); data.put("userProperties", cliRequest.userProperties); data.put("versionProperties", CLIReportingUtils.getBuildProperties()); eventSpyDispatcher.init(eventSpyContext); // refresh logger in case container got customized by spy slf4jLogger = slf4jLoggerFactory.getLogger(this.getClass().getName()); maven = container.lookup(Maven.class); executionRequestPopulator = container.lookup(MavenExecutionRequestPopulator.class); modelProcessor = createModelProcessor(container); configurationProcessors = container.lookupMap(ConfigurationProcessor.class); toolchainsBuilder = container.lookup(ToolchainsBuilder.class); dispatcher = (DefaultSecDispatcher) container.lookup(SecDispatcher.class, "maven"); return container; } private List<CoreExtensionEntry> loadCoreExtensions(CliRequest cliRequest, ClassRealm containerRealm, Set<String> providedArtifacts) { if (cliRequest.multiModuleProjectDirectory == null) { return Collections.emptyList(); } File extensionsFile = new File(cliRequest.multiModuleProjectDirectory, EXTENSIONS_FILENAME); if (!extensionsFile.isFile()) { return Collections.emptyList(); } try { List<CoreExtension> extensions = readCoreExtensionsDescriptor(extensionsFile); if (extensions.isEmpty()) { return Collections.emptyList(); } ContainerConfiguration cc = new DefaultContainerConfiguration() // .setClassWorld(cliRequest.classWorld) // .setRealm(containerRealm) // .setClassPathScanning(PlexusConstants.SCANNING_INDEX) // .setAutoWiring(true) // .setName("maven"); DefaultPlexusContainer container = new DefaultPlexusContainer(cc, new AbstractModule() { @Override protected void configure() { bind(ILoggerFactory.class).toInstance(slf4jLoggerFactory); } }); try { container.setLookupRealm(null); container.setLoggerManager(plexusLoggerManager); container.getLoggerManager().setThresholds(cliRequest.request.getLoggingLevel()); Thread.currentThread().setContextClassLoader(container.getContainerRealm()); executionRequestPopulator = container.lookup(MavenExecutionRequestPopulator.class); configurationProcessors = container.lookupMap(ConfigurationProcessor.class); configure(cliRequest); MavenExecutionRequest request = DefaultMavenExecutionRequest.copy(cliRequest.request); request = populateRequest(cliRequest, request); request = executionRequestPopulator.populateDefaults(request); BootstrapCoreExtensionManager resolver = container.lookup(BootstrapCoreExtensionManager.class); return Collections .unmodifiableList(resolver.loadCoreExtensions(request, providedArtifacts, extensions)); } finally { executionRequestPopulator = null; container.dispose(); } } catch (RuntimeException e) { // runtime exceptions are most likely bugs in maven, let them bubble up to the user throw e; } catch (Exception e) { slf4jLogger.warn("Failed to read extensions descriptor " + extensionsFile + ": " + e.getMessage()); } return Collections.emptyList(); } private List<CoreExtension> readCoreExtensionsDescriptor(File extensionsFile) throws IOException, XmlPullParserException { CoreExtensionsXpp3Reader parser = new CoreExtensionsXpp3Reader(); try (InputStream is = new BufferedInputStream(new FileInputStream(extensionsFile))) { return parser.read(is).getExtensions(); } } private ClassRealm setupContainerRealm(ClassWorld classWorld, ClassRealm coreRealm, List<File> extClassPath, List<CoreExtensionEntry> extensions) throws Exception { if (!extClassPath.isEmpty() || !extensions.isEmpty()) { ClassRealm extRealm = classWorld.newRealm("maven.ext", null); extRealm.setParentRealm(coreRealm); slf4jLogger.debug("Populating class realm " + extRealm.getId()); for (File file : extClassPath) { slf4jLogger.debug(" Included " + file); extRealm.addURL(file.toURI().toURL()); } for (CoreExtensionEntry entry : reverse(extensions)) { Set<String> exportedPackages = entry.getExportedPackages(); ClassRealm realm = entry.getClassRealm(); for (String exportedPackage : exportedPackages) { extRealm.importFrom(realm, exportedPackage); } if (exportedPackages.isEmpty()) { // sisu uses realm imports to establish component visibility extRealm.importFrom(realm, realm.getId()); } } return extRealm; } return coreRealm; } private static <T> List<T> reverse(List<T> list) { List<T> copy = new ArrayList<>(list); Collections.reverse(copy); return copy; } private List<File> parseExtClasspath(CliRequest cliRequest) { String extClassPath = cliRequest.userProperties.getProperty(EXT_CLASS_PATH); if (extClassPath == null) { extClassPath = cliRequest.systemProperties.getProperty(EXT_CLASS_PATH); } List<File> jars = new ArrayList<>(); if (StringUtils.isNotEmpty(extClassPath)) { for (String jar : StringUtils.split(extClassPath, File.pathSeparator)) { File file = resolveFile(new File(jar), cliRequest.workingDirectory); slf4jLogger.debug(" Included " + file); jars.add(file); } } return jars; } // // This should probably be a separate tool and not be baked into Maven. // private void encryption(CliRequest cliRequest) throws Exception { if (cliRequest.commandLine.hasOption(CLIManager.ENCRYPT_MASTER_PASSWORD)) { String passwd = cliRequest.commandLine.getOptionValue(CLIManager.ENCRYPT_MASTER_PASSWORD); if (passwd == null) { Console cons = System.console(); char[] password = (cons == null) ? null : cons.readPassword("Master password: "); if (password != null) { // Cipher uses Strings passwd = String.copyValueOf(password); // Sun/Oracle advises to empty the char array java.util.Arrays.fill(password, ' '); } } DefaultPlexusCipher cipher = new DefaultPlexusCipher(); System.out .println(cipher.encryptAndDecorate(passwd, DefaultSecDispatcher.SYSTEM_PROPERTY_SEC_LOCATION)); throw new ExitException(0); } else if (cliRequest.commandLine.hasOption(CLIManager.ENCRYPT_PASSWORD)) { String passwd = cliRequest.commandLine.getOptionValue(CLIManager.ENCRYPT_PASSWORD); if (passwd == null) { Console cons = System.console(); char[] password = (cons == null) ? null : cons.readPassword("Password: "); if (password != null) { // Cipher uses Strings passwd = String.copyValueOf(password); // Sun/Oracle advises to empty the char array java.util.Arrays.fill(password, ' '); } } String configurationFile = dispatcher.getConfigurationFile(); if (configurationFile.startsWith("~")) { configurationFile = System.getProperty("user.home") + configurationFile.substring(1); } String file = System.getProperty(DefaultSecDispatcher.SYSTEM_PROPERTY_SEC_LOCATION, configurationFile); String master = null; SettingsSecurity sec = SecUtil.read(file, true); if (sec != null) { master = sec.getMaster(); } if (master == null) { throw new IllegalStateException("Master password is not set in the setting security file: " + file); } DefaultPlexusCipher cipher = new DefaultPlexusCipher(); String masterPasswd = cipher.decryptDecorated(master, DefaultSecDispatcher.SYSTEM_PROPERTY_SEC_LOCATION); System.out.println(cipher.encryptAndDecorate(passwd, masterPasswd)); throw new ExitException(0); } } private void repository(CliRequest cliRequest) throws Exception { if (cliRequest.commandLine.hasOption(CLIManager.LEGACY_LOCAL_REPOSITORY) || Boolean.getBoolean("maven.legacyLocalRepo")) { cliRequest.request.setUseLegacyLocalRepository(true); } } private int execute(CliRequest cliRequest) throws MavenExecutionRequestPopulationException { MavenExecutionRequest request = executionRequestPopulator.populateDefaults(cliRequest.request); eventSpyDispatcher.onEvent(request); MavenExecutionResult result = maven.execute(request); eventSpyDispatcher.onEvent(result); eventSpyDispatcher.close(); if (result.hasExceptions()) { ExceptionHandler handler = new DefaultExceptionHandler(); Map<String, String> references = new LinkedHashMap<>(); MavenProject project = null; for (Throwable exception : result.getExceptions()) { ExceptionSummary summary = handler.handleException(exception); logSummary(summary, references, "", cliRequest.showErrors); if (project == null && exception instanceof LifecycleExecutionException) { project = ((LifecycleExecutionException) exception).getProject(); } } slf4jLogger.error(""); if (!cliRequest.showErrors) { slf4jLogger.error("To see the full stack trace of the errors, re-run Maven with the -e switch."); } if (!slf4jLogger.isDebugEnabled()) { slf4jLogger.error("Re-run Maven using the -X switch to enable full debug logging."); } if (!references.isEmpty()) { slf4jLogger.error(""); slf4jLogger.error("For more information about the errors and possible solutions" + ", please read the following articles:"); for (Map.Entry<String, String> entry : references.entrySet()) { slf4jLogger.error(entry.getValue() + " " + entry.getKey()); } } if (project != null && !project.equals(result.getTopologicallySortedProjects().get(0))) { slf4jLogger.error(""); slf4jLogger.error("After correcting the problems, you can resume the build with the command"); slf4jLogger.error(" mvn <goals> -rf :" + project.getArtifactId()); } if (MavenExecutionRequest.REACTOR_FAIL_NEVER.equals(cliRequest.request.getReactorFailureBehavior())) { slf4jLogger.info("Build failures were ignored."); return 0; } else { return 1; } } else { return 0; } } private void logSummary(ExceptionSummary summary, Map<String, String> references, String indent, boolean showErrors) { String referenceKey = ""; if (StringUtils.isNotEmpty(summary.getReference())) { referenceKey = references.get(summary.getReference()); if (referenceKey == null) { referenceKey = "[Help " + (references.size() + 1) + "]"; references.put(summary.getReference(), referenceKey); } } String msg = summary.getMessage(); if (StringUtils.isNotEmpty(referenceKey)) { if (msg.indexOf('\n') < 0) { msg += " -> " + referenceKey; } else { msg += "\n-> " + referenceKey; } } String[] lines = msg.split("(\r\n)|(\r)|(\n)"); for (int i = 0; i < lines.length; i++) { String line = indent + lines[i].trim(); if ((i == lines.length - 1) && (showErrors || (summary.getException() instanceof InternalErrorException))) { slf4jLogger.error(line, summary.getException()); } else { slf4jLogger.error(line); } } indent += " "; for (ExceptionSummary child : summary.getChildren()) { logSummary(child, references, indent, showErrors); } } @SuppressWarnings("checkstyle:methodlength") private void configure(CliRequest cliRequest) throws Exception { // // This is not ideal but there are events specifically for configuration from the CLI which I don't // believe are really valid but there are ITs which assert the right events are published so this // needs to be supported so the EventSpyDispatcher needs to be put in the CliRequest so that // it can be accessed by configuration processors. // cliRequest.request.setEventSpyDispatcher(eventSpyDispatcher); // // We expect at most 2 implementations to be available. The SettingsXmlConfigurationProcessor implementation // is always available in the core and likely always will be, but we may have another ConfigurationProcessor // present supplied by the user. The rule is that we only allow the execution of one ConfigurationProcessor. // If there is more than one then we execute the one supplied by the user, otherwise we execute the // the default SettingsXmlConfigurationProcessor. // int userSuppliedConfigurationProcessorCount = configurationProcessors.size() - 1; if (userSuppliedConfigurationProcessorCount == 0) { // // Our settings.xml source is historically how we have configured Maven from the CLI so we are going to // have to honour its existence forever. So let's run it. // configurationProcessors.get(SettingsXmlConfigurationProcessor.HINT).process(cliRequest); } else if (userSuppliedConfigurationProcessorCount == 1) { // // Run the user supplied ConfigurationProcessor // for (Entry<String, ConfigurationProcessor> entry : configurationProcessors.entrySet()) { String hint = entry.getKey(); if (!hint.equals(SettingsXmlConfigurationProcessor.HINT)) { ConfigurationProcessor configurationProcessor = entry.getValue(); configurationProcessor.process(cliRequest); } } } else if (userSuppliedConfigurationProcessorCount > 1) { // // There are too many ConfigurationProcessors so we don't know which one to run so report the error. // StringBuilder sb = new StringBuilder( String.format("\nThere can only be one user supplied ConfigurationProcessor, there are %s:\n\n", userSuppliedConfigurationProcessorCount)); for (Entry<String, ConfigurationProcessor> entry : configurationProcessors.entrySet()) { String hint = entry.getKey(); if (!hint.equals(SettingsXmlConfigurationProcessor.HINT)) { ConfigurationProcessor configurationProcessor = entry.getValue(); sb.append(String.format("%s\n", configurationProcessor.getClass().getName())); } } sb.append(String.format("\n")); throw new Exception(sb.toString()); } } @SuppressWarnings("checkstyle:methodlength") private void toolchains(CliRequest cliRequest) throws Exception { File userToolchainsFile; if (cliRequest.commandLine.hasOption(CLIManager.ALTERNATE_USER_TOOLCHAINS)) { userToolchainsFile = new File( cliRequest.commandLine.getOptionValue(CLIManager.ALTERNATE_USER_TOOLCHAINS)); userToolchainsFile = resolveFile(userToolchainsFile, cliRequest.workingDirectory); if (!userToolchainsFile.isFile()) { throw new FileNotFoundException( "The specified user toolchains file does not exist: " + userToolchainsFile); } } else { userToolchainsFile = DEFAULT_USER_TOOLCHAINS_FILE; } File globalToolchainsFile; if (cliRequest.commandLine.hasOption(CLIManager.ALTERNATE_GLOBAL_TOOLCHAINS)) { globalToolchainsFile = new File( cliRequest.commandLine.getOptionValue(CLIManager.ALTERNATE_GLOBAL_TOOLCHAINS)); globalToolchainsFile = resolveFile(globalToolchainsFile, cliRequest.workingDirectory); if (!globalToolchainsFile.isFile()) { throw new FileNotFoundException( "The specified global toolchains file does not exist: " + globalToolchainsFile); } } else { globalToolchainsFile = DEFAULT_GLOBAL_TOOLCHAINS_FILE; } cliRequest.request.setGlobalToolchainsFile(globalToolchainsFile); cliRequest.request.setUserToolchainsFile(userToolchainsFile); DefaultToolchainsBuildingRequest toolchainsRequest = new DefaultToolchainsBuildingRequest(); if (globalToolchainsFile.isFile()) { toolchainsRequest.setGlobalToolchainsSource(new FileSource(globalToolchainsFile)); } if (userToolchainsFile.isFile()) { toolchainsRequest.setUserToolchainsSource(new FileSource(userToolchainsFile)); } eventSpyDispatcher.onEvent(toolchainsRequest); slf4jLogger.debug("Reading global toolchains from " + getLocation(toolchainsRequest.getGlobalToolchainsSource(), globalToolchainsFile)); slf4jLogger.debug("Reading user toolchains from " + getLocation(toolchainsRequest.getUserToolchainsSource(), userToolchainsFile)); ToolchainsBuildingResult toolchainsResult = toolchainsBuilder.build(toolchainsRequest); eventSpyDispatcher.onEvent(toolchainsRequest); executionRequestPopulator.populateFromToolchains(cliRequest.request, toolchainsResult.getEffectiveToolchains()); if (!toolchainsResult.getProblems().isEmpty() && slf4jLogger.isWarnEnabled()) { slf4jLogger.warn(""); slf4jLogger.warn("Some problems were encountered while building the effective toolchains"); for (Problem problem : toolchainsResult.getProblems()) { slf4jLogger.warn(problem.getMessage() + " @ " + problem.getLocation()); } slf4jLogger.warn(""); } } private Object getLocation(Source source, File defaultLocation) { if (source != null) { return source.getLocation(); } return defaultLocation; } private MavenExecutionRequest populateRequest(CliRequest cliRequest) { return populateRequest(cliRequest, cliRequest.request); } private MavenExecutionRequest populateRequest(CliRequest cliRequest, MavenExecutionRequest request) { CommandLine commandLine = cliRequest.commandLine; String workingDirectory = cliRequest.workingDirectory; boolean quiet = cliRequest.quiet; boolean showErrors = cliRequest.showErrors; String[] deprecatedOptions = { "up", "npu", "cpu", "npr" }; for (String deprecatedOption : deprecatedOptions) { if (commandLine.hasOption(deprecatedOption)) { slf4jLogger.warn("Command line option -" + deprecatedOption + " is deprecated and will be removed in future Maven versions."); } } // ---------------------------------------------------------------------- // Now that we have everything that we need we will fire up plexus and // bring the maven component to life for use. // ---------------------------------------------------------------------- if (commandLine.hasOption(CLIManager.BATCH_MODE)) { request.setInteractiveMode(false); } boolean noSnapshotUpdates = false; if (commandLine.hasOption(CLIManager.SUPRESS_SNAPSHOT_UPDATES)) { noSnapshotUpdates = true; } // ---------------------------------------------------------------------- // // ---------------------------------------------------------------------- @SuppressWarnings("unchecked") List<String> goals = commandLine.getArgList(); boolean recursive = true; // this is the default behavior. String reactorFailureBehaviour = MavenExecutionRequest.REACTOR_FAIL_FAST; if (commandLine.hasOption(CLIManager.NON_RECURSIVE)) { recursive = false; } if (commandLine.hasOption(CLIManager.FAIL_FAST)) { reactorFailureBehaviour = MavenExecutionRequest.REACTOR_FAIL_FAST; } else if (commandLine.hasOption(CLIManager.FAIL_AT_END)) { reactorFailureBehaviour = MavenExecutionRequest.REACTOR_FAIL_AT_END; } else if (commandLine.hasOption(CLIManager.FAIL_NEVER)) { reactorFailureBehaviour = MavenExecutionRequest.REACTOR_FAIL_NEVER; } if (commandLine.hasOption(CLIManager.OFFLINE)) { request.setOffline(true); } boolean updateSnapshots = false; if (commandLine.hasOption(CLIManager.UPDATE_SNAPSHOTS)) { updateSnapshots = true; } String globalChecksumPolicy = null; if (commandLine.hasOption(CLIManager.CHECKSUM_FAILURE_POLICY)) { globalChecksumPolicy = MavenExecutionRequest.CHECKSUM_POLICY_FAIL; } else if (commandLine.hasOption(CLIManager.CHECKSUM_WARNING_POLICY)) { globalChecksumPolicy = MavenExecutionRequest.CHECKSUM_POLICY_WARN; } File baseDirectory = new File(workingDirectory, "").getAbsoluteFile(); // ---------------------------------------------------------------------- // Profile Activation // ---------------------------------------------------------------------- List<String> activeProfiles = new ArrayList<>(); List<String> inactiveProfiles = new ArrayList<>(); if (commandLine.hasOption(CLIManager.ACTIVATE_PROFILES)) { String[] profileOptionValues = commandLine.getOptionValues(CLIManager.ACTIVATE_PROFILES); if (profileOptionValues != null) { for (String profileOptionValue : profileOptionValues) { StringTokenizer profileTokens = new StringTokenizer(profileOptionValue, ","); while (profileTokens.hasMoreTokens()) { String profileAction = profileTokens.nextToken().trim(); if (profileAction.startsWith("-") || profileAction.startsWith("!")) { inactiveProfiles.add(profileAction.substring(1)); } else if (profileAction.startsWith("+")) { activeProfiles.add(profileAction.substring(1)); } else { activeProfiles.add(profileAction); } } } } } TransferListener transferListener; if (quiet) { transferListener = new QuietMavenTransferListener(); } else if (request.isInteractiveMode() && !cliRequest.commandLine.hasOption(CLIManager.LOG_FILE)) { // // If we're logging to a file then we don't want the console transfer listener as it will spew // download progress all over the place // transferListener = getConsoleTransferListener(cliRequest.commandLine.hasOption(CLIManager.DEBUG)); } else { transferListener = getBatchTransferListener(); } ExecutionListener executionListener = new ExecutionEventLogger(); if (eventSpyDispatcher != null) { executionListener = eventSpyDispatcher.chainListener(executionListener); } String alternatePomFile = null; if (commandLine.hasOption(CLIManager.ALTERNATE_POM_FILE)) { alternatePomFile = commandLine.getOptionValue(CLIManager.ALTERNATE_POM_FILE); } File userToolchainsFile; if (commandLine.hasOption(CLIManager.ALTERNATE_USER_TOOLCHAINS)) { userToolchainsFile = new File(commandLine.getOptionValue(CLIManager.ALTERNATE_USER_TOOLCHAINS)); userToolchainsFile = resolveFile(userToolchainsFile, workingDirectory); } else { userToolchainsFile = MavenCli.DEFAULT_USER_TOOLCHAINS_FILE; } request.setBaseDirectory(baseDirectory).setGoals(goals).setSystemProperties(cliRequest.systemProperties) .setUserProperties(cliRequest.userProperties).setReactorFailureBehavior(reactorFailureBehaviour) // default: fail fast .setRecursive(recursive) // default: true .setShowErrors(showErrors) // default: false .addActiveProfiles(activeProfiles) // optional .addInactiveProfiles(inactiveProfiles) // optional .setExecutionListener(executionListener).setTransferListener(transferListener) // default: batch mode which goes along with interactive .setUpdateSnapshots(updateSnapshots) // default: false .setNoSnapshotUpdates(noSnapshotUpdates) // default: false .setGlobalChecksumPolicy(globalChecksumPolicy) // default: warn .setMultiModuleProjectDirectory(cliRequest.multiModuleProjectDirectory); if (alternatePomFile != null) { File pom = resolveFile(new File(alternatePomFile), workingDirectory); if (pom.isDirectory()) { pom = new File(pom, "pom.xml"); } request.setPom(pom); } else if (modelProcessor != null) { File pom = modelProcessor.locatePom(baseDirectory); if (pom.isFile()) { request.setPom(pom); } } if ((request.getPom() != null) && (request.getPom().getParentFile() != null)) { request.setBaseDirectory(request.getPom().getParentFile()); } if (commandLine.hasOption(CLIManager.RESUME_FROM)) { request.setResumeFrom(commandLine.getOptionValue(CLIManager.RESUME_FROM)); } if (commandLine.hasOption(CLIManager.PROJECT_LIST)) { String[] projectOptionValues = commandLine.getOptionValues(CLIManager.PROJECT_LIST); List<String> inclProjects = new ArrayList<>(); List<String> exclProjects = new ArrayList<>(); if (projectOptionValues != null) { for (String projectOptionValue : projectOptionValues) { StringTokenizer projectTokens = new StringTokenizer(projectOptionValue, ","); while (projectTokens.hasMoreTokens()) { String projectAction = projectTokens.nextToken().trim(); if (projectAction.startsWith("-") || projectAction.startsWith("!")) { exclProjects.add(projectAction.substring(1)); } else if (projectAction.startsWith("+")) { inclProjects.add(projectAction.substring(1)); } else { inclProjects.add(projectAction); } } } } request.setSelectedProjects(inclProjects); request.setExcludedProjects(exclProjects); } if (commandLine.hasOption(CLIManager.ALSO_MAKE) && !commandLine.hasOption(CLIManager.ALSO_MAKE_DEPENDENTS)) { request.setMakeBehavior(MavenExecutionRequest.REACTOR_MAKE_UPSTREAM); } else if (!commandLine.hasOption(CLIManager.ALSO_MAKE) && commandLine.hasOption(CLIManager.ALSO_MAKE_DEPENDENTS)) { request.setMakeBehavior(MavenExecutionRequest.REACTOR_MAKE_DOWNSTREAM); } else if (commandLine.hasOption(CLIManager.ALSO_MAKE) && commandLine.hasOption(CLIManager.ALSO_MAKE_DEPENDENTS)) { request.setMakeBehavior(MavenExecutionRequest.REACTOR_MAKE_BOTH); } String localRepoProperty = request.getUserProperties().getProperty(MavenCli.LOCAL_REPO_PROPERTY); if (localRepoProperty == null) { localRepoProperty = request.getSystemProperties().getProperty(MavenCli.LOCAL_REPO_PROPERTY); } if (localRepoProperty != null) { request.setLocalRepositoryPath(localRepoProperty); } request.setCacheNotFound(true); request.setCacheTransferError(false); // // Builder, concurrency and parallelism // // We preserve the existing methods for builder selection which is to look for various inputs in the threading // configuration. We don't have an easy way to allow a pluggable builder to provide its own configuration // parameters but this is sufficient for now. Ultimately we want components like Builders to provide a way to // extend the command line to accept its own configuration parameters. // final String threadConfiguration = commandLine.hasOption(CLIManager.THREADS) ? commandLine.getOptionValue(CLIManager.THREADS) : request.getSystemProperties().getProperty(MavenCli.THREADS_DEPRECATED); // TODO: Remove this setting. Note that the int-tests use it if (threadConfiguration != null) { // // Default to the standard multithreaded builder // request.setBuilderId("multithreaded"); if (threadConfiguration.contains("C")) { request.setDegreeOfConcurrency(calculateDegreeOfConcurrencyWithCoreMultiplier(threadConfiguration)); } else { request.setDegreeOfConcurrency(Integer.valueOf(threadConfiguration)); } } // // Allow the builder to be overriden by the user if requested. The builders are now pluggable. // if (commandLine.hasOption(CLIManager.BUILDER)) { request.setBuilderId(commandLine.getOptionValue(CLIManager.BUILDER)); } return request; } int calculateDegreeOfConcurrencyWithCoreMultiplier(String threadConfiguration) { int procs = Runtime.getRuntime().availableProcessors(); return (int) (Float.valueOf(threadConfiguration.replace("C", "")) * procs); } static File resolveFile(File file, String workingDirectory) { if (file == null) { return null; } else if (file.isAbsolute()) { return file; } else if (file.getPath().startsWith(File.separator)) { // drive-relative Windows path return file.getAbsoluteFile(); } else { return new File(workingDirectory, file.getPath()).getAbsoluteFile(); } } // ---------------------------------------------------------------------- // System properties handling // ---------------------------------------------------------------------- static void populateProperties(CommandLine commandLine, Properties systemProperties, Properties userProperties) { EnvironmentUtils.addEnvVars(systemProperties); // ---------------------------------------------------------------------- // Options that are set on the command line become system properties // and therefore are set in the session properties. System properties // are most dominant. // ---------------------------------------------------------------------- if (commandLine.hasOption(CLIManager.SET_SYSTEM_PROPERTY)) { String[] defStrs = commandLine.getOptionValues(CLIManager.SET_SYSTEM_PROPERTY); if (defStrs != null) { for (String defStr : defStrs) { setCliProperty(defStr, userProperties); } } } SystemProperties.addSystemProperties(systemProperties); // ---------------------------------------------------------------------- // Properties containing info about the currently running version of Maven // These override any corresponding properties set on the command line // ---------------------------------------------------------------------- Properties buildProperties = CLIReportingUtils.getBuildProperties(); String mavenVersion = buildProperties.getProperty(CLIReportingUtils.BUILD_VERSION_PROPERTY); systemProperties.setProperty("maven.version", mavenVersion); String mavenBuildVersion = CLIReportingUtils.createMavenVersionString(buildProperties); systemProperties.setProperty("maven.build.version", mavenBuildVersion); } private static void setCliProperty(String property, Properties properties) { String name; String value; int i = property.indexOf('='); if (i <= 0) { name = property.trim(); value = "true"; } else { name = property.substring(0, i).trim(); value = property.substring(i + 1); } properties.setProperty(name, value); // ---------------------------------------------------------------------- // I'm leaving the setting of system properties here as not to break // the SystemPropertyProfileActivator. This won't harm embedding. jvz. // ---------------------------------------------------------------------- System.setProperty(name, value); } static class ExitException extends Exception { @SuppressWarnings("checkstyle:visibilitymodifier") public int exitCode; public ExitException(int exitCode) { this.exitCode = exitCode; } } // // Customizations available via the CLI // protected TransferListener getConsoleTransferListener(boolean printResourceNames) { return new ConsoleMavenTransferListener(System.out, printResourceNames); } protected TransferListener getBatchTransferListener() { return new Slf4jMavenTransferListener(); } protected void customizeContainer(PlexusContainer container) { } protected ModelProcessor createModelProcessor(PlexusContainer container) throws ComponentLookupException { return container.lookup(ModelProcessor.class); } }