Do not print missing JSON elements for reflection

Author: vjovanov

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/config/TypeConfiguration.java

@@ -143,7 +143,7 @@ public void printJson(JsonWriter writer) throws IOException {
 
  @Override
  public ConfigurationParser createParser() {
- return new ReflectionConfigurationParser<>(new ParserConfigurationAdapter(this), true);
+ return new ReflectionConfigurationParser<>(new ParserConfigurationAdapter(this), true, false);
  }
 
  @Override

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ConfigurationFiles.java

@@ -100,8 +100,11 @@ public static final class Options {
  public static final HostedOptionKey<LocatableMultiOptionValue.Strings> PredefinedClassesConfigurationResources = new HostedOptionKey<>(
  LocatableMultiOptionValue.Strings.buildWithCommaDelimiter());
 
- @Option(help = "Causes unknown attributes in configuration objects to abort the image build instead of emitting a warning.")//
+ @Option(help = "When configuration files don't match the schema, abort the image build instead of emitting a warning.")//
  public static final HostedOptionKey<Boolean> StrictConfiguration = new HostedOptionKey<>(false);
+
+ @Option(help = "When configuration files don't match the schema, abort the image build instead of emitting a warning.", type = OptionType.Expert)//
+ public static final HostedOptionKey<Boolean> PrintMissingMetadataElements = new HostedOptionKey<>(false);
  }
 
  public static List<Path> findConfigurationFiles(String fileName) {

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ConfigurationParser.java

@@ -62,10 +62,10 @@ public static InputStream openStream(URI uri) throws IOException {
  public static final String CONDITIONAL_KEY = "condition";
  public static final String TYPE_REACHABLE_KEY = "typeReachable";
  private final Map<String, Set<String>> seenUnknownAttributesByType = new HashMap<>();
- private final boolean strictConfiguration;
+ private final boolean strictSchema;
 
  protected ConfigurationParser(boolean strictConfiguration) {
- this.strictConfiguration = strictConfiguration;
+ this.strictSchema = strictConfiguration;
  }
 
  public void parseAndRegister(URI uri) throws IOException {
@@ -121,14 +121,20 @@ protected void checkAttributes(EconomicMap<String, Object> map, String type, Col
 
  if (unknownAttributes.size() > 0) {
  String message = "Unknown attribute(s) [" + String.join(", ", unknownAttributes) + "] in " + type;
- warnOrFail(message);
+ warnOrFailOnSchemaError(message);
  Set<String> unknownAttributesForType = seenUnknownAttributesByType.computeIfAbsent(type, key -> new HashSet<>());
  unknownAttributesForType.addAll(unknownAttributes);
  }
  }
 
- protected void warnOrFail(String message) {
- if (strictConfiguration) {
+ /**
+ * Used to warn about schema errors in configuration files. Should never be used if the type is
+ * missing.
+ *
+ * @param message message to be displayed.
+ */
+ protected void warnOrFailOnSchemaError(String message) {
+ if (strictSchema) {
  throw new JSONParserException(message);
  } else {
  LogUtils.warning(message);
@@ -182,7 +188,7 @@ protected ConfigurationCondition parseCondition(EconomicMap<String, Object> data
  if (conditionType instanceof String) {
  return ConfigurationCondition.create((String) conditionType);
  } else {
- warnOrFail("'" + TYPE_REACHABLE_KEY + "' should be of type string");
+ warnOrFailOnSchemaError("'" + TYPE_REACHABLE_KEY + "' should be of type string");
  }
  }
  return ConfigurationCondition.alwaysTrue();

substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/configure/ReflectionConfigurationParser.java

@@ -52,13 +52,15 @@ public final class ReflectionConfigurationParser<T> extends ConfigurationParser
  "allDeclaredClasses", "allRecordComponents", "allPermittedSubclasses", "allNestMembers", "allSigners",
  "allPublicClasses", "methods", "queriedMethods", "fields", CONDITIONAL_KEY,
  "queryAllDeclaredConstructors", "queryAllPublicConstructors", "queryAllDeclaredMethods", "queryAllPublicMethods", "unsafeAllocated");
+ private final boolean printMissingElements;
 
  public ReflectionConfigurationParser(ReflectionConfigurationParserDelegate<T> delegate) {
- this(delegate, true);
+ this(delegate, true, false);
  }
 
- public ReflectionConfigurationParser(ReflectionConfigurationParserDelegate<T> delegate, boolean strictConfiguration) {
+ public ReflectionConfigurationParser(ReflectionConfigurationParserDelegate<T> delegate, boolean strictConfiguration, boolean printMissingElements) {
  super(strictConfiguration);
+ this.printMissingElements = printMissingElements;
  this.delegate = delegate;
  }
 
@@ -91,7 +93,7 @@ private void parseClass(EconomicMap<String, Object> data) {
  */
  TypeResult<T> result = delegate.resolveType(condition, className, true);
  if (!result.isPresent()) {
- handleError("Could not resolve class " + className + " for reflection configuration.", result.getException());
+ handleMissingElement("Could not resolve class " + className + " for reflection configuration.", result.getException());
  return;
  }
  T clazz = result.get();
@@ -199,7 +201,7 @@ private void parseClass(EconomicMap<String, Object> data) {
  break;
  }
  } catch (LinkageError e) {
- handleError("Could not register " + delegate.getTypeName(clazz) + ": " + name + " for reflection.", e);
+ handleMissingElement("Could not register " + delegate.getTypeName(clazz) + ": " + name + " for reflection.", e);
  }
  }
  }
@@ -218,9 +220,9 @@ private void parseField(EconomicMap<String, Object> data, T clazz) {
  try {
  delegate.registerField(clazz, fieldName, allowWrite);
  } catch (NoSuchFieldException e) {
- handleError("Field " + formatField(clazz, fieldName) + " not found.");
+ handleMissingElement("Field " + formatField(clazz, fieldName) + " not found.");
  } catch (LinkageError e) {
- handleError("Could not register field " + formatField(clazz, fieldName) + " for reflection.", e);
+ handleMissingElement("Could not register field " + formatField(clazz, fieldName) + " for reflection.", e);
  }
  }
 
@@ -251,9 +253,9 @@ private void parseMethod(boolean queriedOnly, EconomicMap<String, Object> data,
  delegate.registerMethod(queriedOnly, clazz, methodName, methodParameterTypes);
  }
  } catch (NoSuchMethodException e) {
- handleError("Method " + formatMethod(clazz, methodName, methodParameterTypes) + " not found.");
+ handleMissingElement("Method " + formatMethod(clazz, methodName, methodParameterTypes) + " not found.");
  } catch (LinkageError e) {
- handleError("Could not register method " + formatMethod(clazz, methodName, methodParameterTypes) + " for reflection.", e);
+ handleMissingElement("Could not register method " + formatMethod(clazz, methodName, methodParameterTypes) + " for reflection.", e);
  }
  } else {
  try {
@@ -267,7 +269,7 @@ private void parseMethod(boolean queriedOnly, EconomicMap<String, Object> data,
  throw new JSONParserException("Method " + formatMethod(clazz, methodName) + " not found");
  }
  } catch (LinkageError e) {
- handleError("Could not register method " + formatMethod(clazz, methodName) + " for reflection.", e);
+ handleMissingElement("Could not register method " + formatMethod(clazz, methodName) + " for reflection.", e);
  }
  }
  }
@@ -278,7 +280,7 @@ private List<T> parseMethodParameters(T clazz, String methodName, List<Object> t
  String typeName = asString(type, "types");
  TypeResult<T> typeResult = delegate.resolveType(ConfigurationCondition.alwaysTrue(), typeName, true);
  if (!typeResult.isPresent()) {
- handleError("Could not register method " + formatMethod(clazz, methodName) + " for reflection.", typeResult.getException());
+ handleMissingElement("Could not register method " + formatMethod(clazz, methodName) + " for reflection.", typeResult.getException());
  return null;
  }
  result.add(typeResult.get());
@@ -303,15 +305,17 @@ private String formatMethod(T clazz, String methodName, List<T> paramTypes) {
  return delegate.getTypeName(clazz) + '.' + methodName + '(' + parameterTypeNames + ')';
  }
 
- private static void handleError(String message) {
- handleError(message, null);
+ private void handleMissingElement(String message) {
+ handleMissingElement(message, null);
  }
 
- private static void handleError(String msg, Throwable cause) {
- String message = msg;
- if (cause != null) {
- message += " Reason: " + formatError(cause) + '.';
+ private void handleMissingElement(String msg, Throwable cause) {
+ if (printMissingElements) {
+ String message = msg;
+ if (cause != null) {
+ message += " Reason: " + formatError(cause) + '.';
+ }
+ LogUtils.warning(message);
  }
- LogUtils.warning(message);
  }
 }

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/config/ConfigurationParserUtils.java

@@ -57,7 +57,9 @@ public final class ConfigurationParserUtils {
 
  public static ReflectionConfigurationParser<ConditionalElement<Class<?>>> create(ReflectionRegistry registry, ImageClassLoader imageClassLoader) {
  return new ReflectionConfigurationParser<>(RegistryAdapter.create(registry, imageClassLoader),
- ConfigurationFiles.Options.StrictConfiguration.getValue());
+ ConfigurationFiles.Options.StrictConfiguration.getValue(),
+ ConfigurationFiles.Options.PrintMissingMetadataElements.getValue()
+ );
  }
 
  /**