328 lines
13 KiB
Java
328 lines
13 KiB
Java
/*
|
|
* Copyright (c) 2011, 2018, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
package vm.share.options;
|
|
|
|
import java.util.Map;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.ArrayList;
|
|
import java.util.LinkedList;
|
|
import java.util.Iterator;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.Modifier;
|
|
import java.io.PrintStream;
|
|
import nsk.share.TestBug;
|
|
import nsk.share.log.LogSupport;
|
|
|
|
class OptionsSetup {
|
|
private LogSupport log = new LogSupport();
|
|
private boolean verbose = true;
|
|
private Object test;
|
|
private String[] args;
|
|
private OptionHandler unknownOptionHandler;
|
|
|
|
private int argIndex = 0;
|
|
private Map<String, OptionDefinition> optionDefs = new LinkedHashMap<String, OptionDefinition>(); // Use LinkedHashMap to ensure order of options
|
|
private List<OptionDefinition> unconfiguredOptionsList = new ArrayList<OptionDefinition>();
|
|
private List<OptionDefinition> unconfiguredOptionList = new ArrayList<OptionDefinition>();
|
|
private Map<String, Object> optionValues = new LinkedHashMap<String, Object>();
|
|
|
|
public OptionsSetup(Object test, String[] args, OptionHandler unknownOptionHandler) {
|
|
this.test = test;
|
|
this.args = args;
|
|
this.unknownOptionHandler = unknownOptionHandler;
|
|
log.setDebugEnabled(verbose);
|
|
}
|
|
|
|
public void run() {
|
|
searchAnnotations(test, null);
|
|
while (argIndex < args.length) {
|
|
process1Arg();
|
|
}
|
|
setDefaultValues();
|
|
checkMandatoryOptions();
|
|
if (unconfiguredOptionsList.size() > 0) {
|
|
for (OptionDefinition optDef : unconfiguredOptionsList)
|
|
log.info("Unconfigured option: " + optDef);
|
|
throw new TestBug("Some options are unconfigured");
|
|
}
|
|
}
|
|
|
|
private void checkMandatoryOptions() {
|
|
for (Map.Entry<String, OptionDefinition> e : optionDefs.entrySet()) {
|
|
String name = e.getKey();
|
|
OptionDefinition optDef = e.getValue();
|
|
if (optDef.getDefaultValue() == null && !optionValues.containsKey(name))
|
|
throw new TestBug("Mandatory option is not specified: -" + name);
|
|
}
|
|
}
|
|
|
|
private void setDefaultValues() {
|
|
for (Iterator<OptionDefinition> it = unconfiguredOptionList.iterator(); it.hasNext(); ) {
|
|
OptionDefinition optDef = it.next();
|
|
String value = optDef.getDefaultValue();
|
|
if (value == null)
|
|
continue;
|
|
setOptionValue(optDef, value);
|
|
it.remove();
|
|
if (unconfiguredOptionsList.contains(optDef))
|
|
unconfiguredOptionsList.remove(optDef);
|
|
}
|
|
|
|
for (Iterator<OptionDefinition> it = unconfiguredOptionsList.iterator(); it.hasNext(); ) {
|
|
OptionDefinition optDef = it.next();
|
|
if (optionsAnnotation(optDef.getOwner(), optDef.getField(), null, optDef, true))
|
|
it.remove();
|
|
}
|
|
}
|
|
|
|
private void process1Arg() {
|
|
String arg = args[argIndex++];
|
|
//log.debug("Processing argument: " + arg);
|
|
if (!arg.startsWith("-")) {
|
|
processUnknownArg(arg);
|
|
return;
|
|
}
|
|
String opt = arg.substring(1);
|
|
String value = null;
|
|
int i = opt.indexOf('=');
|
|
if (i != -1) {
|
|
value = opt.substring(i + 1);
|
|
opt = opt.substring(0, i);
|
|
}
|
|
if (opt.equals("help")) {
|
|
printHelp();
|
|
throw new TestBug("-help was specified");
|
|
}
|
|
if (!optionDefs.containsKey(opt)) {
|
|
if (value == null && argIndex < args.length)
|
|
value = args[argIndex++];
|
|
// We need to try to resolve default values of all unconfigured fields because one of them may potentially have this option
|
|
setDefaultValues();
|
|
if (!optionDefs.containsKey(opt)) {
|
|
processUnknownOpt(opt, value);
|
|
return;
|
|
}
|
|
}
|
|
OptionDefinition optDef = optionDefs.get(opt);
|
|
Field f = optDef.getField();
|
|
// Handle boolean omitted value
|
|
if (value == null && (argIndex >= args.length || args[argIndex].startsWith("-"))) {
|
|
if (f.getType() == boolean.class || f.getType() == Boolean.class) {
|
|
value = "true";
|
|
}
|
|
}
|
|
if (value == null) {
|
|
if (argIndex >= args.length)
|
|
throw new TestBug("Missing value for option -" + opt);
|
|
value = args[argIndex++];
|
|
}
|
|
setOptionValue(optDef, value);
|
|
if (unconfiguredOptionList.contains(optDef)){
|
|
unconfiguredOptionList.remove(optDef);
|
|
}
|
|
}
|
|
|
|
private void setOptionValue(OptionDefinition optDef, String value) {
|
|
Object ovalue = null;
|
|
if (optDef.hasFactory()) {
|
|
ovalue = optDef.getFactory().getObject(value);
|
|
} else {
|
|
ovalue = PrimitiveParser.parse(value, optDef.getField().getType());
|
|
}
|
|
optionValues.put(optDef.getName(), ovalue);
|
|
try {
|
|
Field f = optDef.getField();
|
|
Object o = optDef.getOwner();
|
|
f.set(o, ovalue);
|
|
if (f.isAnnotationPresent(Options.class)) {
|
|
if (!optionsAnnotation(o, f, optDef.getPrefix(), optDef, false))
|
|
throw new TestBug("Unexpected (bug in framework?): optionsAnnotation returned null: " + optDef);
|
|
if (unconfiguredOptionsList.contains(optDef))
|
|
unconfiguredOptionsList.remove(optDef);
|
|
}
|
|
} catch (IllegalArgumentException e) {
|
|
throw new TestBug("Exception setting field value for option " + optDef.getName(), e);
|
|
} catch (IllegalAccessException e) {
|
|
throw new TestBug("Exception setting field value for option " + optDef.getName(), e);
|
|
}
|
|
}
|
|
|
|
private void processUnknownArg(String arg) {
|
|
if (unknownOptionHandler != null)
|
|
unknownOptionHandler.argument(arg);
|
|
else
|
|
throw new TestBug("Invalid argument: " + arg);
|
|
}
|
|
|
|
private void processUnknownOpt(String opt, String value) {
|
|
if (unknownOptionHandler != null)
|
|
unknownOptionHandler.option(opt, value);
|
|
else
|
|
throw new TestBug("Invalid option: '" + opt + "', value: '" + value + "'");
|
|
}
|
|
|
|
private void searchAnnotations(Object o, String prefix) {
|
|
Class<?> cl0 = o.getClass();
|
|
//log.debug("Looking for annotations for object " + o + ", class " + cl0);
|
|
List<Class> classes = new LinkedList<Class>();
|
|
while (cl0.getSuperclass() != null) {
|
|
classes.add(0, cl0); // Add to the beginning to ensure the option order is from superclass to subclass
|
|
cl0 = cl0.getSuperclass();
|
|
}
|
|
for (Class<?> cl : classes) {
|
|
for (Field f : cl.getDeclaredFields()) {
|
|
OptionDefinition optDef = null;
|
|
if (f.isAnnotationPresent(Option.class)) {
|
|
optDef = optionAnnotation(o, f, prefix);
|
|
if (optDef != null) {
|
|
unconfiguredOptionList.add(optDef);
|
|
}
|
|
}
|
|
if (f.isAnnotationPresent(Options.class)) {
|
|
if (!optionsAnnotation(o, f, prefix, optDef, false)) {
|
|
if (!unconfiguredOptionsList.contains(optDef))
|
|
unconfiguredOptionsList.add(optDef);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean optionsAnnotation(Object o, Field f, String prefix, OptionDefinition optDef, boolean useDefault) {
|
|
if (Modifier.isStatic(f.getModifiers()))
|
|
throw new OptionError("@Options annotation is not allowed at static field", optDef);
|
|
if (!Object.class.isAssignableFrom(f.getDeclaringClass()))
|
|
throw new OptionError("@Options annotation is only allowed on object types", optDef);
|
|
//log.debug("Processing @Options annotation: object " + o + ", field " + f + ", prefix " + prefix);
|
|
Object v = null;
|
|
try {
|
|
f.setAccessible(true);
|
|
v = f.get(o);
|
|
} catch (IllegalAccessException e) {
|
|
throw new OptionError("Exception getting value of field ", e, optDef);
|
|
}
|
|
if (v == null) {
|
|
if (optDef == null)
|
|
throw new OptionError("Value of field is null and no @Option annotation is present", optDef);
|
|
if (!optDef.hasFactory())
|
|
throw new OptionError("Value of field is null and no @Option annotation does not have factory", optDef);
|
|
if (useDefault) {
|
|
setOptionValue(optDef, optDef.getDefaultValue());
|
|
try {
|
|
v = f.get(o);
|
|
} catch (IllegalAccessException e) {
|
|
throw new OptionError("Exception getting value of field ", e, optDef);
|
|
}
|
|
}
|
|
if (v == null) {
|
|
// We cannot setup it right away, so it is stored until value is set
|
|
return false;
|
|
} else
|
|
return true; // setOption Value already searched annotations
|
|
}
|
|
Options opts = f.getAnnotation(Options.class);
|
|
String vprefix = opts.prefix();
|
|
if (vprefix.equals(Options.defPrefix))
|
|
vprefix = null;
|
|
if (vprefix != null) {
|
|
if (prefix != null)
|
|
prefix = prefix + "." + vprefix;
|
|
else
|
|
prefix = vprefix;
|
|
}
|
|
searchAnnotations(v, prefix);
|
|
return true;
|
|
}
|
|
|
|
private OptionDefinition optionAnnotation(Object o, Field f, String prefix) {
|
|
//log.debug("Processing @Option annotation: object " + o + ", field " + f + ", prefix " + prefix);
|
|
f.setAccessible(true);
|
|
Option opt = f.getAnnotation(Option.class);
|
|
String name = opt.name();
|
|
if (name.equals(Option.defName))
|
|
name = f.getName(); // option name defaults to field name
|
|
if (prefix != null)
|
|
name = prefix + "." + name;
|
|
if (optionDefs.containsKey(name))
|
|
throw new TestBug("Option is already defined: " + name);
|
|
String defaultValue = opt.default_value();
|
|
if (defaultValue.equals(Option.defDefaultValue))
|
|
defaultValue = null; // default value defaults to null
|
|
String description = opt.description();
|
|
if (description.equals(Option.defDescription))
|
|
description = null;
|
|
if (description == null) {
|
|
if (name.equals("log") || name.endsWith(".log")) {
|
|
try {
|
|
f.set(o, log);
|
|
} catch (IllegalAccessException e) {
|
|
throw new TestBug("Exception setting log field of " + o, e);
|
|
}
|
|
return null;
|
|
} else
|
|
throw new TestBug("@Option annotation should always have description set: " + name + ", field: " + f);
|
|
}
|
|
Class<? extends OptionObjectFactory> factory = opt.factory();
|
|
//log.debug("Factory: " + factory);
|
|
if (factory.equals(OptionObjectFactory.class))
|
|
factory = null;
|
|
OptionDefinition optDef = new OptionDefinition(
|
|
prefix,
|
|
name,
|
|
description,
|
|
defaultValue,
|
|
factory,
|
|
f,
|
|
o
|
|
);
|
|
optionDefs.put(name, optDef);
|
|
//log.debug("Added option definition: " + optDef);
|
|
return optDef;
|
|
}
|
|
|
|
private void printHelp() {
|
|
PrintStream out = System.out;
|
|
out.println(" Supported options:");
|
|
out.println(" -help");
|
|
out.println(" Show this help screen");
|
|
for (Map.Entry<String, OptionDefinition> entry : optionDefs.entrySet()) {
|
|
String opt = entry.getKey();
|
|
OptionDefinition optDef = entry.getValue();
|
|
out.println(" -" + opt + " <" + optDef.getPlaceHolder() + ">");
|
|
out.print(" " + optDef.getDescription() + " ");
|
|
if (optDef.getDefaultValue() != null) {
|
|
out.println("(default: " + optDef.getDefaultValue() + ")");
|
|
} else {
|
|
out.println("(mandatory)");
|
|
}
|
|
if (optDef.hasFactory()) {
|
|
OptionObjectFactory factory = optDef.getFactory();
|
|
for (String key : factory.getPossibleValues()) {
|
|
out.println(" " + key + ": " + factory.getParameterDescription(key));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|