WW-4164 Support per-package and per-action action extensions

core/src/main/java/org/apache/struts2/components/Component.java

@@ -31,6 +31,7 @@
 import org.apache.logging.log4j.Logger;
 import org.apache.struts2.StrutsConstants;
 import org.apache.struts2.StrutsException;
+import org.apache.struts2.dispatcher.mapper.ActionExtensionResolver;
 import org.apache.struts2.dispatcher.mapper.ActionMapper;
 import org.apache.struts2.dispatcher.mapper.ActionMapping;
 import org.apache.struts2.util.ComponentUtils;
@@ -81,6 +82,7 @@ public static void clearStandardAttributesMap() {
     protected ValueStack stack;
     protected Map<String, Object> attributes;
     protected ActionMapper actionMapper;
+    protected ActionExtensionResolver actionExtensionResolver;
     protected boolean throwExceptionOnELFailure;
     protected boolean performClearTagStateForTagPoolingServers = false;
     private UrlHelper urlHelper;
@@ -121,6 +123,15 @@ public void setActionMapper(ActionMapper mapper) {
         this.actionMapper = mapper;
     }
 
+    /**
+     * @param actionExtensionResolver chooses the extension of generated action URLs
+     * @since 7.5.0
+     */
+    @Inject
+    public void setActionExtensionResolver(ActionExtensionResolver actionExtensionResolver) {
+        this.actionExtensionResolver = actionExtensionResolver;
+    }
+
     @Inject(StrutsConstants.STRUTS_EL_THROW_EXCEPTION)
     public void setThrowExceptionsOnELFailure(String throwException) {
         this.throwExceptionOnELFailure = BooleanUtils.toBoolean(throwException);
@@ -422,6 +433,7 @@ protected String determineActionURL(String action, String namespace, String meth
         String finalMethod = method != null ? findString(method) : null;
         String finalNamespace = determineNamespace(namespace, getStack(), req);
         ActionMapping mapping = new ActionMapping(finalAction, finalNamespace, finalMethod, parameters);
+        actionExtensionResolver.applyTo(mapping);
         String uri = actionMapper.getUriFromActionMapping(mapping);
         return urlHelper.buildUrl(uri, req, res, parameters, scheme, includeContext, encodeResult, forceAddSchemeHostAndPort, escapeAmp);
     }

core/src/main/java/org/apache/struts2/components/ServletUrlRenderer.java

@@ -176,6 +176,7 @@ public void renderFormUrl(Form formComponent) {
         if (actionConfig != null) {
 
             ActionMapping mapping = new ActionMapping(actionName, namespace, actionMethod, formComponent.attributes);
+            formComponent.actionExtensionResolver.applyTo(mapping);
             String result = urlHelper.buildUrl(formComponent.actionMapper.getUriFromActionMapping(mapping),
                 formComponent.request, formComponent.response, queryStringResult.getQueryParams(), scheme, formComponent.includeContext, true, false, false);
             formComponent.addParameter("action", result);

core/src/main/java/org/apache/struts2/config/RuntimeConfiguration.java

@@ -42,6 +42,19 @@ public interface RuntimeConfiguration extends Serializable {
      */
     ActionConfig getActionConfig(String namespace, String name);
 
+    /**
+     * Same lookup as {@link #getActionConfig(String, String)}, but returns {@code null} when the result comes only from
+     * a namespace's {@code default-action-ref}, so only exact and wildcard matches of {@code name} are returned.
+     *
+     * @param namespace the namespace of the Action, {@code null} means the empty namespace
+     * @param name      the name of the Action
+     * @return the matched ActionConfig, or {@code null}
+     * @since 7.5.0
+     */
+    default ActionConfig getMatchedActionConfig(String namespace, String name) {
+        return getActionConfig(namespace, name);
+    }
+
     /**
      * returns a Map of all the registered ActionConfigs.  Again, these ActionConfigs are fully expanded so that any
      * inherited interceptors, results, etc. will be included

core/src/main/java/org/apache/struts2/config/entities/ActionConfig.java

@@ -69,6 +69,7 @@ public class ActionConfig extends Located implements Serializable {
     protected boolean strictMethodInvocation = true;
     protected AllowedMethods allowedMethods;
     private Set<HttpMethod> httpMethods;
+    private List<String> extensions = List.of();
 
     protected ActionConfig(String packageName, String name, String className) {
         this.packageName = packageName;
@@ -98,6 +99,7 @@ protected ActionConfig(ActionConfig orig) {
         this.allowedMethods = orig.allowedMethods;
         this.httpMethods = EnumSet.noneOf(HttpMethod.class);
         this.httpMethods.addAll(orig.httpMethods);
+        this.extensions = orig.extensions;
         this.location = orig.location;
         this.strictMethodInvocation = orig.strictMethodInvocation;
     }
@@ -130,6 +132,14 @@ public Set<HttpMethod> getHttpMethods() {
         return httpMethods;
     }
 
+    /**
+     * @return action extensions in declared order, empty when neither the action nor its package declares any
+     * @since 7.5.0
+     */
+    public List<String> getExtensions() {
+        return extensions;
+    }
+
     /**
      * Returns name of the action method
      *
@@ -200,7 +210,11 @@ public boolean equals(Object o) {
             return false;
         }
 
-        return Objects.equals(httpMethods, actionConfig.httpMethods);
+        if (!Objects.equals(httpMethods, actionConfig.httpMethods)) {
+            return false;
+        }
+
+        return extensions.equals(actionConfig.extensions);
     }
 
     @Override
@@ -216,6 +230,7 @@ public int hashCode() {
         result = 31 * result + (name != null ? name.hashCode() : 0);
         result = 31 * result + (allowedMethods != null ? allowedMethods.hashCode() : 0);
         result = 31 * result + (httpMethods != null ? httpMethods.hashCode() : 0);
+        result = 31 * result + extensions.hashCode();
         return result;
     }
 
@@ -234,6 +249,9 @@ public String toString() {
         if (!httpMethods.isEmpty()) {
             sb.append(" - ").append(httpMethods);
         }
+        if (!extensions.isEmpty()) {
+            sb.append(" - extensions ").append(extensions);
+        }
         sb.append("}");
         return sb.toString();
     }
@@ -368,6 +386,14 @@ public Builder addHttpMethods(Collection<HttpMethod> methods) {
             return this;
         }
 
+        /**
+         * @since 7.5.0
+         */
+        public Builder extensions(List<String> extensions) {
+            target.extensions = extensions != null ? List.copyOf(extensions) : List.of();
+            return this;
+        }
+
         public Builder location(Location loc) {
             target.location = loc;
             return this;

core/src/main/java/org/apache/struts2/config/entities/PackageConfig.java

@@ -59,6 +59,7 @@ public class PackageConfig extends Located implements Comparable<PackageConfig>,
     protected boolean isFinal = false; // a final package is unextendable
     protected boolean needsRefresh;
     protected boolean strictMethodInvocation = true;
+    private List<String> extensions = List.of();
     private Map<String, String> scopedConstants;
     private Map<String, String> allScopedConstants;
 
@@ -94,6 +95,7 @@ protected PackageConfig(PackageConfig orig) {
         this.parents = new ArrayList<>(orig.parents);
         this.location = orig.location;
         this.strictMethodInvocation = orig.strictMethodInvocation;
+        this.extensions = orig.extensions;
         this.scopedConstants = new LinkedHashMap<>(orig.scopedConstants);
         this.allScopedConstants = orig.allScopedConstants;
     }
@@ -321,6 +323,31 @@ public String getFullDefaultResultType() {
         return defaultResultType;
     }
 
+    /**
+     * @return extensions declared on this package, or empty when it declares none
+     * @since 7.5.0
+     */
+    public List<String> getExtensions() {
+        return extensions;
+    }
+
+    /**
+     * @return extensions declared on this package, else on the first parent that declares them, else empty
+     * @since 7.5.0
+     */
+    public List<String> getFullExtensions() {
+        if (!extensions.isEmpty()) {
+            return extensions;
+        }
+        for (PackageConfig parent : parents) {
+            List<String> parentExtensions = parent.getFullExtensions();
+            if (!parentExtensions.isEmpty()) {
+                return parentExtensions;
+            }
+        }
+        return List.of();
+    }
+
     /**
      * gets the global ResultConfigs local to this package
      *
@@ -422,6 +449,7 @@ public boolean equals(Object o) {
             return false;
         if (!Objects.equals(defaultClassRef, that.defaultClassRef))
             return false;
+        if (!extensions.equals(that.extensions)) return false;
         if (!name.equals(that.name)) return false;
         return Objects.equals(namespace, that.namespace);
     }
@@ -446,6 +474,7 @@ public int hashCode() {
         result = 31 * result + (isFinal ? 1 : 0);
         result = 31 * result + (needsRefresh ? 1 : 0);
         result = 31 * result + (strictMethodInvocation ? 1 : 0);
+        result = 31 * result + extensions.hashCode();
         return result;
     }
 
@@ -676,6 +705,14 @@ public Builder strictMethodInvocation(boolean strict) {
             return this;
         }
 
+        /**
+         * @since 7.5.0
+         */
+        public Builder extensions(List<String> extensions) {
+            target.extensions = extensions != null ? List.copyOf(extensions) : List.of();
+            return this;
+        }
+
         public boolean isStrictMethodInvocation() {
             return target.strictMethodInvocation;
         }

core/src/main/java/org/apache/struts2/config/impl/ActionConfigMatcher.java

@@ -146,6 +146,7 @@ public ActionConfig convert(String path, ActionConfig orig,
                 .setStrictMethodInvocation(orig.isStrictMethodInvocation())
                 .addAllowedMethod(orig.getAllowedMethods())
                 .addHttpMethods(orig.getHttpMethods())
+                .extensions(orig.getExtensions())
                 .addInterceptors(orig.getInterceptors())
                 .addExceptionMappings(exs)
                 .location(orig.getLocation())

core/src/main/java/org/apache/struts2/config/impl/DefaultConfiguration.java

@@ -93,6 +93,7 @@
 import org.apache.struts2.ognl.accessor.CompoundRootAccessor;
 import org.apache.struts2.ognl.accessor.RootAccessor;
 import org.apache.struts2.ognl.accessor.XWorkMethodAccessor;
+import org.apache.struts2.interceptor.ActionExtensionInterceptor;
 import org.apache.struts2.interceptor.httpmethod.HttpMethodInterceptor;
 import org.apache.struts2.interceptor.parameter.OgnlParameterAllowlister;
 import org.apache.struts2.interceptor.parameter.ParameterAllowlister;
@@ -562,6 +563,11 @@ private ActionConfig buildFullActionConfig(PackageConfig packageContext, ActionC
 
         warnIfHttpMethodNotEnforced(baseConfig, interceptors);
 
+        List<String> extensions = baseConfig.getExtensions().isEmpty()
+                ? packageContext.getFullExtensions()
+                : baseConfig.getExtensions();
+        warnIfExtensionNotEnforced(baseConfig, extensions, interceptors);
+
         String methodRegex = container.getInstance(String.class, StrutsConstants.STRUTS_SMI_METHOD_REGEX);
         if (methodRegex == null) {
             methodRegex = ActionConfig.DEFAULT_METHOD_REGEX;
@@ -570,6 +576,7 @@ private ActionConfig buildFullActionConfig(PackageConfig packageContext, ActionC
         LOG.debug("Using pattern [{}] to match allowed methods when SMI is disabled!", methodRegex);
 
         return new ActionConfig.Builder(baseConfig)
+                .extensions(extensions)
                 .addParams(params)
                 .addResultConfigs(results)
                 .defaultClassName(packageContext.getDefaultClassRef())  // fill in default if non class has been provided
@@ -588,6 +595,14 @@ private void warnIfHttpMethodNotEnforced(ActionConfig baseConfig, List<Intercept
         }
     }
 
+    private void warnIfExtensionNotEnforced(ActionConfig baseConfig, List<String> extensions, List<InterceptorMapping> interceptors) {
+        if (!extensions.isEmpty()
+                && interceptors.stream().noneMatch(mapping -> mapping.getInterceptor() instanceof ActionExtensionInterceptor)) {
+            LOG.warn("Action [{}] in package [{}] declares extension {} but its interceptors do not include {}, the restriction will not be enforced",
+                    baseConfig.getName(), baseConfig.getPackageName(), extensions, ActionExtensionInterceptor.class.getSimpleName());
+        }
+    }
+
     private static class RuntimeConfigurationImpl implements RuntimeConfiguration {
 
         private final Map<String, Map<String, ActionConfig>> namespaceActionConfigs;
@@ -625,36 +640,47 @@ public RuntimeConfigurationImpl(Map<String, Map<String, ActionConfig>> namespace
          */
         @Override
         public ActionConfig getActionConfig(String namespace, String name) {
-            ActionConfig config = findActionConfigInNamespace(namespace, name);
+            Lookup lookup = lookup(namespace, name);
+            return lookup == null ? null : lookup.config;
+        }
+
+        @Override
+        public ActionConfig getMatchedActionConfig(String namespace, String name) {
+            Lookup lookup = lookup(namespace, name);
+            return lookup == null || lookup.defaultAction ? null : lookup.config;
+        }
+
+        private Lookup lookup(String namespace, String name) {
+            Lookup lookup = lookupInNamespace(namespace, name);
 
             // try wildcarded namespaces
-            if (config == null) {
+            if (lookup == null) {
                 NamespaceMatch match = namespaceMatcher.match(namespace);
                 if (match != null) {
-                    config = findActionConfigInNamespace(match.getPattern(), name);
+                    lookup = lookupInNamespace(match.getPattern(), name);
 
                     // If config found, place all the matches found in the namespace processing in the action's parameters
-                    if (config != null) {
-                        config = new ActionConfig.Builder(config)
+                    if (lookup != null) {
+                        lookup = lookup.withConfig(new ActionConfig.Builder(lookup.config)
                                 .addParams(match.getVariables())
-                                .build();
+                                .build());
                     }
                 }
             }
 
             // fail over to empty namespace
-            if (config == null && shouldFallbackToEmptyNamespace(namespace)) {
-                config = findActionConfigInNamespace("", name);
+            if (lookup == null && shouldFallbackToEmptyNamespace(namespace)) {
+                lookup = lookupInNamespace("", name);
             }
 
-            return config;
+            return lookup;
         }
 
         private boolean shouldFallbackToEmptyNamespace(String namespace) {
             return StringUtils.isNotBlank(namespace) && ("/".equals(namespace) || fallbackToEmptyNamespace);
         }
 
-        private ActionConfig findActionConfigInNamespace(String namespace, String name) {
+        private Lookup lookupInNamespace(String namespace, String name) {
             if (namespace == null) {
                 namespace = "";
             }
@@ -665,15 +691,16 @@ private ActionConfig findActionConfigInNamespace(String namespace, String name)
 
             ActionConfig config = actions.get(name);
             if (config != null) {
-                return config;
+                return Lookup.matched(config);
             }
 
             config = namespaceActionConfigMatchers.get(namespace).match(name);
             if (config != null) {
-                return config;
+                return Lookup.matched(config);
             }
 
-            return findDefaultActionConfig(namespace, actions);
+            config = findDefaultActionConfig(namespace, actions);
+            return config == null ? null : Lookup.defaultAction(config);
         }
 
         private ActionConfig findDefaultActionConfig(String namespace, Map<String, ActionConfig> actions) {
@@ -714,6 +741,28 @@ public String toString() {
 
             return buff.toString();
         }
+
+        private static final class Lookup {
+            private final ActionConfig config;
+            private final boolean defaultAction;
+
+            private Lookup(ActionConfig config, boolean defaultAction) {
+                this.config = config;
+                this.defaultAction = defaultAction;
+            }
+
+            private static Lookup matched(ActionConfig config) {
+                return new Lookup(config, false);
+            }
+
+            private static Lookup defaultAction(ActionConfig config) {
+                return new Lookup(config, true);
+            }
+
+            private Lookup withConfig(ActionConfig other) {
+                return new Lookup(other, defaultAction);
+            }
+        }
     }
 
     class ContainerProperties extends LocatableProperties {