/*
* 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.scriptinterpreter;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.apache.commons.io.FilenameUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Runs pre-/post-build hook scripts.
*
* @author Benjamin Bentmann
*/
public class ScriptRunner {
private static final Logger LOG = LoggerFactory.getLogger(ScriptRunner.class);
/**
* The supported script interpreters, indexed by the lower-case file extension of their associated script files,
* never null.
*/
private Map scriptInterpreters;
/**
* The common set of global variables to pass into the script interpreter, never null.
*/
private Map globalVariables;
/**
* The additional class path for the script interpreter, never null.
*/
private List classPath;
/**
* The file encoding of the hook scripts or null to use platform encoding.
*/
private String encoding;
/**
* Creates a new script runner with BSH and Groovy interpreters.
*/
public ScriptRunner() {
scriptInterpreters = new LinkedHashMap<>();
scriptInterpreters.put("bsh", new BeanShellScriptInterpreter());
scriptInterpreters.put("groovy", new GroovyScriptInterpreter());
globalVariables = new HashMap<>();
classPath = new ArrayList<>();
}
/**
* Add new script Interpreter
*
* @param id The Id of interpreter
* @param scriptInterpreter the Script Interpreter implementation
*/
public void addScriptInterpreter(String id, ScriptInterpreter scriptInterpreter) {
scriptInterpreters.put(id, scriptInterpreter);
}
/**
* Sets a global variable for the script interpreter.
*
* @param name The name of the variable, must not be null.
* @param value The value of the variable, may be null.
*/
public void setGlobalVariable(String name, Object value) {
this.globalVariables.put(name, value);
}
/**
* Sets the additional class path for the hook scripts. Note that the provided list is copied, so any later changes
* will not affect the scripts.
*
* @param classPath The additional class path for the script interpreter, may be null or empty if only
* the plugin realm should be used for the script evaluation. If specified, this class path will precede the
* artifacts from the plugin class path.
*/
public void setClassPath(List classPath) {
this.classPath = (classPath != null) ? new ArrayList<>(classPath) : new ArrayList<>();
}
/**
* Sets the file encoding of the hook scripts.
*
* @param encoding The file encoding of the hook scripts, may be null or empty to use the platform's
* default encoding.
*/
public void setScriptEncoding(String encoding) {
this.encoding = (encoding != null && encoding.length() > 0) ? encoding : null;
}
/**
* Runs the specified hook script (after resolution).
*
* @param scriptDescription The description of the script to use for logging, must not be null.
* @param basedir The base directory of the project, must not be null.
* @param relativeScriptPath The path to the script relative to the project base directory, may be null
* to skip the script execution and may not have extensions (resolution will search).
* @param context The key-value storage used to share information between hook scripts, may be null.
* @param logger The logger to redirect the script output to, may be null to use stdout/stderr.
* @throws IOException If an I/O error occurred while reading the script file.
* @throws ScriptException If the script did not return true of threw an exception.
*/
public void run(
final String scriptDescription,
final File basedir,
final String relativeScriptPath,
final Map context,
final ExecutionLogger logger)
throws IOException, ScriptException {
if (relativeScriptPath == null) {
LOG.debug("{}: relativeScriptPath is null, not executing script", scriptDescription);
return;
}
final File scriptFile = resolveScript(new File(basedir, relativeScriptPath));
if (!scriptFile.exists()) {
LOG.debug(
"{} : no script '{}' found in directory {}",
scriptDescription,
relativeScriptPath,
basedir.getAbsolutePath());
return;
}
LOG.info(
"run {} {}.{}",
scriptDescription,
relativeScriptPath,
FilenameUtils.getExtension(scriptFile.getAbsolutePath()));
executeRun(scriptDescription, scriptFile, context, logger);
}
/**
* Runs the specified hook script.
*
* @param scriptDescription The description of the script to use for logging, must not be null.
* @param scriptFile The path to the script, may be null to skip the script execution.
* @param context The key-value storage used to share information between hook scripts, may be null.
* @param logger The logger to redirect the script output to, may be null to use stdout/stderr.
* @throws IOException If an I/O error occurred while reading the script file.
* @throws ScriptException If the script did not return true of threw an exception.
*/
public void run(
final String scriptDescription, File scriptFile, final Map context, final ExecutionLogger logger)
throws IOException, ScriptException {
if (!scriptFile.exists()) {
LOG.debug("{} : script file not found in directory {}", scriptDescription, scriptFile.getAbsolutePath());
return;
}
LOG.info("run {} {}", scriptDescription, scriptFile.getAbsolutePath());
executeRun(scriptDescription, scriptFile, context, logger);
}
private void executeRun(
final String scriptDescription, File scriptFile, final Map context, final ExecutionLogger logger)
throws IOException, ScriptException {
ScriptInterpreter interpreter = getInterpreter(scriptFile);
if (LOG.isDebugEnabled()) {
String name = interpreter.getClass().getName();
name = name.substring(name.lastIndexOf('.') + 1);
LOG.debug("Running script with {} :{}", name, scriptFile);
}
String script;
try {
byte[] bytes = Files.readAllBytes(scriptFile.toPath());
if (encoding != null) {
script = new String(bytes, encoding);
} else {
script = new String(bytes);
}
} catch (IOException e) {
String errorMessage =
"error reading " + scriptDescription + " " + scriptFile.getPath() + ", " + e.getMessage();
throw new IOException(errorMessage, e);
}
Object result;
try {
if (logger != null) {
logger.consumeLine("Running " + scriptDescription + ": " + scriptFile);
}
PrintStream out = (logger != null) ? logger.getPrintStream() : null;
Map scriptVariables = new HashMap<>(this.globalVariables);
scriptVariables.put("basedir", scriptFile.getParentFile());
scriptVariables.put("context", context);
result = interpreter.evaluateScript(script, classPath, scriptVariables, out);
if (logger != null) {
logger.consumeLine("Finished " + scriptDescription + ": " + scriptFile);
}
} catch (ScriptEvaluationException e) {
Throwable t = (e.getCause() != null) ? e.getCause() : e;
if (logger != null) {
t.printStackTrace(logger.getPrintStream());
}
throw e;
}
if (!(result == null || Boolean.parseBoolean(String.valueOf(result)))) {
throw new ScriptReturnException("The " + scriptDescription + " returned " + result + ".", result);
}
}
/**
* Gets the effective path to the specified script. For convenience, we allow to specify a script path as "verify"
* and have the plugin auto-append the file extension to search for "verify.bsh" and "verify.groovy".
*
* @param scriptFile The script file to resolve, may be null.
* @return The effective path to the script file or null if the input was null.
*/
private File resolveScript(File scriptFile) {
if (scriptFile != null && !scriptFile.exists()) {
for (String ext : this.scriptInterpreters.keySet()) {
File candidateFile = new File(scriptFile.getPath() + '.' + ext);
if (candidateFile.exists()) {
scriptFile = candidateFile;
break;
}
}
}
return scriptFile;
}
/**
* Determines the script interpreter for the specified script file by looking at its file extension. In this
* context, file extensions are considered case-insensitive. For backward compatibility with plugin versions 1.2-,
* the BeanShell interpreter will be used for any unrecognized extension.
*
* @param scriptFile The script file for which to determine an interpreter, must not be null.
* @return The script interpreter for the file, never null.
*/
private ScriptInterpreter getInterpreter(File scriptFile) {
String ext = FilenameUtils.getExtension(scriptFile.getName()).toLowerCase(Locale.ENGLISH);
ScriptInterpreter interpreter = scriptInterpreters.get(ext);
if (interpreter == null) {
interpreter = scriptInterpreters.get("bsh");
}
return interpreter;
}
}