Nicer error pages

plugin/src/main/java/io/jenkins/plugins/casc/BaseConfigurator.java

@@ -377,14 +377,16 @@ protected void configure(Mapping config, T instance, boolean dryrun, Configurati
     protected final void handleUnknown(Mapping config, ConfigurationContext context) throws ConfiguratorException {
         if (!config.isEmpty()) {
             final String invalid = StringUtils.join(config.keySet(), ',');
-            final String message = "Invalid configuration elements for type " + getTarget() + " : " + invalid + ".\n"
+            List<String> validAttributes =
+                    getAttributes().stream().map(Attribute::getName).collect(Collectors.toList());
+            String baseErrorMessage = "Invalid configuration elements for type: ";
+            final String message = baseErrorMessage + getTarget() + " : " + invalid + ".\n"
                     + "Available attributes : "
-                    + StringUtils.join(
-                            getAttributes().stream().map(Attribute::getName).collect(Collectors.toList()), ", ");
+                    + StringUtils.join(validAttributes, ", ");
             context.warning(config, message);
             switch (context.getUnknown()) {
                 case reject:
-                    throw new ConfiguratorException(message);
+                    throw new UnknownAttributesException(this, baseErrorMessage, message, invalid, validAttributes);
 
                 case warn:
                     LOGGER.warning(message);

plugin/src/main/java/io/jenkins/plugins/casc/ConfigurationAsCode.java

@@ -68,6 +68,7 @@
 import java.util.stream.Stream;
 import javax.inject.Inject;
 import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletResponse;
 import jenkins.model.GlobalConfiguration;
 import jenkins.model.Jenkins;
@@ -169,10 +170,42 @@ public void doReload(StaplerRequest request, StaplerResponse response) throws Ex
             response.sendError(HttpServletResponse.SC_FORBIDDEN);
             return;
         }
-        configure();
+
+        try {
+            configure();
+        } catch (ConfiguratorException e) {
+            LOGGER.log(Level.SEVERE, "Failed to reload configuration", e);
+
+            Throwable throwableCause = e.getCause();
+            if (throwableCause instanceof ConfiguratorException) {
+                ConfiguratorException cause = (ConfiguratorException) throwableCause;
+
+                handleExceptionOnReloading(request, response, cause);
+            } else {
+                handleExceptionOnReloading(request, response, e);
+            }
+            return;
+        }
         response.sendRedirect("");
     }
 
+    @Restricted(NoExternalUse.class)
+    public static void handleExceptionOnReloading(
+            StaplerRequest request, StaplerResponse response, ConfiguratorException cause)
+            throws ServletException, IOException {
+        Configurator<?> configurator = cause.getConfigurator();
+        request.setAttribute("errorMessage", cause.getErrorMessage());
+        if (configurator != null) {
+            request.setAttribute("target", configurator.getName());
+        } else if (cause instanceof UnknownConfiguratorException) {
+            List<String> configuratorNames = ((UnknownConfiguratorException) cause).getConfiguratorNames();
+            request.setAttribute("target", String.join(", ", configuratorNames));
+        }
+        request.setAttribute("invalidAttribute", cause.getInvalidAttribute());
+        request.setAttribute("validAttributes", cause.getValidAttributes());
+        request.getView(ConfigurationAsCode.class, "error.jelly").forward(request, response);
+    }
+
     @RequirePOST
     @Restricted(NoExternalUse.class)
     public void doReplace(StaplerRequest request, StaplerResponse response) throws Exception {
@@ -303,7 +336,11 @@ private List<YamlSource> getConfigFromSources(List<String> newSources) throws Co
     @Initializer(after = InitMilestone.SYSTEM_CONFIG_LOADED, before = InitMilestone.SYSTEM_CONFIG_ADAPTED)
     public static void init() throws Exception {
         detectVaultPluginMissing();
-        get().configure();
+        try {
+            get().configure();
+        } catch (ConfiguratorException e) {
+            throw new ConfigurationAsCodeBootFailure(e);
+        }
     }
 
     /**
@@ -727,18 +764,9 @@ private static void invokeWith(Mapping entries, ConfiguratorOperation function)
                 if (!entry.getKey().equalsIgnoreCase(configurator.getName())) {
                     continue;
                 }
-                try {
-                    function.apply(configurator, entry.getValue());
-                    it.remove();
-                    break;
-                } catch (ConfiguratorException e) {
-                    throw new ConfiguratorException(
-                            configurator,
-                            format(
-                                    "error configuring '%s' with %s configurator",
-                                    entry.getKey(), configurator.getClass()),
-                            e);
-                }
+                function.apply(configurator, entry.getValue());
+                it.remove();
+                break;
             }
         }
 
@@ -752,8 +780,7 @@ private static void invokeWith(Mapping entries, ConfiguratorOperation function)
             });
 
             if (!unknownKeys.isEmpty()) {
-                throw new ConfiguratorException(
-                        format("No configurator for the following root elements %s", String.join(", ", unknownKeys)));
+                throw new UnknownConfiguratorException(unknownKeys, "No configurator for the following root elements:");
             }
         }
     }

plugin/src/main/java/io/jenkins/plugins/casc/ConfigurationAsCodeBootFailure.java

@@ -0,0 +1,19 @@
+package io.jenkins.plugins.casc;
+
+import hudson.util.BootFailure;
+import java.io.IOException;
+import javax.servlet.ServletException;
+import org.kohsuke.stapler.StaplerRequest;
+import org.kohsuke.stapler.StaplerResponse;
+
+public class ConfigurationAsCodeBootFailure extends BootFailure {
+
+    public ConfigurationAsCodeBootFailure(ConfiguratorException cause) {
+        super(cause);
+    }
+
+    public void doDynamic(StaplerRequest req, StaplerResponse rsp) throws IOException, ServletException {
+        rsp.setStatus(503);
+        ConfigurationAsCode.handleExceptionOnReloading(req, rsp, (ConfiguratorException) getCause());
+    }
+}

plugin/src/main/java/io/jenkins/plugins/casc/ConfiguratorException.java

@@ -23,7 +23,8 @@
 
 import edu.umd.cs.findbugs.annotations.CheckForNull;
 import io.jenkins.plugins.casc.model.CNode;
-import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Exception type for {@link Configurator} issues.
@@ -32,38 +33,70 @@
  * @see Configurator#configure(CNode, ConfigurationContext)
  * @see Configurator
  */
-public class ConfiguratorException extends IOException {
+public class ConfiguratorException extends RuntimeException {
 
     @CheckForNull
     private final Configurator configurator;
 
+    private final List<String> validAttributes;
+
+    @CheckForNull
+    private final String invalidAttribute;
+
+    public ConfiguratorException(
+            @CheckForNull Configurator configurator,
+            @CheckForNull String message,
+            String invalidAttribute,
+            List<String> validAttributes,
+            @CheckForNull Throwable cause) {
+        super(message, cause);
+        this.configurator = configurator;
+
+        this.invalidAttribute = invalidAttribute;
+        this.validAttributes = validAttributes;
+    }
+
     public ConfiguratorException(
             @CheckForNull Configurator configurator, @CheckForNull String message, @CheckForNull Throwable cause) {
         super(message, cause);
         this.configurator = configurator;
+        this.invalidAttribute = null;
+        this.validAttributes = Collections.emptyList();
     }
 
     public ConfiguratorException(@CheckForNull String message, @CheckForNull Throwable cause) {
-        this(null, message, cause);
+        this(null, message, null, Collections.emptyList(), cause);
     }
 
     public ConfiguratorException(@CheckForNull Configurator configurator, @CheckForNull String message) {
-        this(configurator, message, null);
+        this(configurator, message, null, Collections.emptyList(), null);
     }
 
     public ConfiguratorException(@CheckForNull String message) {
-        this(null, message, null);
+        this(null, message, null, Collections.emptyList(), null);
     }
 
     public ConfiguratorException(@CheckForNull Throwable cause) {
-        this(null, null, cause);
+        this(null, null, null, Collections.emptyList(), cause);
     }
 
     @CheckForNull
     public Configurator getConfigurator() {
         return configurator;
     }
 
+    public List<String> getValidAttributes() {
+        return validAttributes;
+    }
+
+    public String getInvalidAttribute() {
+        return invalidAttribute;
+    }
+
+    public String getErrorMessage() {
+        return super.getMessage();
+    }
+
     @Override
     public String getMessage() {
         if (configurator != null) {

plugin/src/main/java/io/jenkins/plugins/casc/UnknownAttributesException.java

@@ -0,0 +1,23 @@
+package io.jenkins.plugins.casc;
+
+import edu.umd.cs.findbugs.annotations.CheckForNull;
+import java.util.List;
+
+public class UnknownAttributesException extends ConfiguratorException {
+
+    private final String errorMessage;
+
+    public UnknownAttributesException(
+            @CheckForNull Configurator configurator,
+            String simpleMessage,
+            @CheckForNull String message,
+            String invalidAttribute,
+            List<String> validAttributes) {
+        super(configurator, message, invalidAttribute, validAttributes, null);
+        this.errorMessage = simpleMessage;
+    }
+
+    public String getErrorMessage() {
+        return errorMessage;
+    }
+}

plugin/src/main/java/io/jenkins/plugins/casc/UnknownConfiguratorException.java

@@ -0,0 +1,23 @@
+package io.jenkins.plugins.casc;
+
+import java.util.List;
+
+public class UnknownConfiguratorException extends ConfiguratorException {
+
+    private final List<String> configuratorNames;
+    private final String errorMessage;
+
+    public UnknownConfiguratorException(List<String> configuratorNames, String errorMessage) {
+        super(errorMessage + String.join(", ", configuratorNames));
+        this.errorMessage = errorMessage;
+        this.configuratorNames = configuratorNames;
+    }
+
+    public String getErrorMessage() {
+        return errorMessage;
+    }
+
+    public List<String> getConfiguratorNames() {
+        return configuratorNames;
+    }
+}

plugin/src/main/java/io/jenkins/plugins/casc/impl/configurators/HeteroDescribableConfigurator.java

@@ -14,6 +14,7 @@
 import io.jenkins.plugins.casc.ConfigurationContext;
 import io.jenkins.plugins.casc.Configurator;
 import io.jenkins.plugins.casc.ObsoleteConfigurationMonitor;
+import io.jenkins.plugins.casc.UnknownAttributesException;
 import io.jenkins.plugins.casc.impl.attributes.DescribableAttribute;
 import io.jenkins.plugins.casc.model.CNode;
 import io.jenkins.plugins.casc.model.Mapping;
@@ -33,6 +34,7 @@
 import java.util.function.Predicate;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+import java.util.stream.Collectors;
 import jenkins.model.Jenkins;
 import org.jenkinsci.Symbol;
 import org.kohsuke.accmod.Restricted;
@@ -214,16 +216,26 @@ private Class<T> descriptorClass(Descriptor<T> descriptor) {
     }
 
     private Option<Descriptor<T>> lookupDescriptor(String symbol, CNode config) {
-        return getDescriptors()
+        Stream<Descriptor<T>> descriptors = getDescriptors();
+        return descriptors
                 .filter(descriptor ->
                         findByPreferredSymbol(descriptor, symbol) || findBySymbols(descriptor, symbol, config))
                 .map(descriptor -> Tuple.of(preferredSymbol(descriptor), descriptor))
                 .foldLeft(HashMap.empty(), this::handleDuplicateSymbols)
                 .values()
                 .headOption()
                 .orElse(() -> {
-                    throw new IllegalArgumentException(
-                            "No " + target.getName() + " implementation found for " + symbol);
+                    List<String> availableImplementations = descriptors
+                            .toJavaStream()
+                            .map(d -> DescribableAttribute.getPreferredSymbol(d, getImplementedAPI(), target))
+                            .collect(Collectors.toList());
+
+                    throw new UnknownAttributesException(
+                            this,
+                            "No implementation found for:",
+                            "No " + target.getName() + " implementation found for " + symbol,
+                            symbol,
+                            availableImplementations);
                 });
     }
 

plugin/src/main/resources/io/jenkins/plugins/casc/ConfigurationAsCode/error.jelly

@@ -0,0 +1,24 @@
+<?jelly escape-by-default='true'?>
+<j:jelly xmlns:j="jelly:core" xmlns:l="/lib/layout">
+  <l:layout type="one-column" title="${%Error loading configuration}">
+    <l:main-panel>
+     <l:app-bar title="${%Error loading configuration}" />
+
+      <p>${errorMessage}<pre><code>${target}</code></pre></p>
+
+      <j:if test="${invalidAttribute != null}">
+        <p>Attribute was: <pre><code>${invalidAttribute}</code></pre></p>
+      </j:if>
+
+      <j:if test="${!empty(validAttributes)}">
+        <p>Valid attributes are:</p>
+
+        <ul>
+          <j:forEach var="attribute" items="${validAttributes}">
+            <li>${attribute}</li>
+          </j:forEach>
+        </ul>
+      </j:if>
+    </l:main-panel>
+  </l:layout>
+</j:jelly>