You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2026/08/13 22:03:22 UTC
(juneau) branch master updated: Measure MCP schema-safety compute budget as thread CPU time; add view-mixin responseProcessor auto-fold opt-in; FreeMarker object-wrapper + fluent ConfigItem.setValue
This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new f2932362a6 Measure MCP schema-safety compute budget as thread CPU time; add view-mixin responseProcessor auto-fold opt-in; FreeMarker object-wrapper + fluent ConfigItem.setValue
f2932362a6 is described below
commit f2932362a6158e2d9fb2ed109d35866c4f0720e9
Author: James Bognar <ja...@apache.org>
AuthorDate: Thu Aug 13 18:03:16 2026 -0400
Measure MCP schema-safety compute budget as thread CPU time; add view-mixin responseProcessor auto-fold opt-in; FreeMarker object-wrapper + fluent ConfigItem.setValue
McpSchemaSafety (mcp-v20260728): the tools/call input-schema-validation DoS budget is now charged against the validating thread's actual CPU time (ThreadMXBean.getThreadCpuTime) instead of wall-clock, so OS preemption/scheduling no longer counts against the ~100ms budget. Includes a support-check with a verbatim wall-clock fallback when thread-CPU timing is unavailable, correct ns/-1-sentinel handling, and sleep-vs-CPU-burn regression tests. Fixes an intermittent CI false-trip (-32602 [...]
TODO-358 (juneau-rest-server view mixins): (1) FreemarkerDispatcher's bridge-default Configuration now installs a DefaultObjectWrapper(exposeFields=true) so public-field DTOs render instead of silently resolving to null, with new exposeFields(boolean)/objectWrapper(ObjectWrapper) builder knobs. (2) New non-silent, response-processor-scoped @Rest(mergeResponseProcessorsIntoHost=true) opt-in: a plain @Rest(mixins=<ViewMixin>.class) now folds the mixin's renderer into the host chain so t [...]
TODO-320 (juneau-sc-server): ConfigItem.setValue(String) is now a fluent self-returning setter, matching the repo-wide convention (the lone void-setter outlier); source-compatible, no reflective contract broken.
Docs: release notes for both behavioral changes, plus FreeMarker/JSP view-support and mixin-subcontexts topic updates.
---
.../rest/server/mcp/v20260728/McpSchemaSafety.java | 169 +++++++++++++++++----
.../server/mcp/v20260728/McpSchemaSafety_Test.java | 96 +++++++++++-
.../view/freemarker/FreemarkerDispatcher.java | 107 ++++++++++++-
.../server/view/freemarker/FreemarkerMixin.java | 142 ++++++++++++++++-
.../view/freemarker/FreemarkerDispatcher_Test.java | 53 +++++++
.../freemarker/FreemarkerMixin_Builder_Test.java | 30 ++++
.../juneau/rest/server/view/jsp/JspMixin.java | 39 +++--
.../jsp/JspViewRenderer_ForwardPaths_Test.java | 79 +++++++---
.../rest/server/view/mustache/MustacheMixin.java | 13 +-
.../rest/server/view/thymeleaf/ThymeleafMixin.java | 13 +-
.../java/org/apache/juneau/rest/server/Rest.java | 31 ++++
.../apache/juneau/rest/server/RestAnnotation.java | 19 +++
.../org/apache/juneau/rest/server/RestContext.java | 51 ++++++-
.../server/MixinResponseProcessorFold_Test.java | 139 +++++++++++++++++
.../server/config/repository/ConfigItem.java | 3 +-
15 files changed, 888 insertions(+), 96 deletions(-)
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety.java
index d3c8dee7a1..c17065ab14 100644
--- a/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety.java
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/main/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety.java
@@ -18,6 +18,7 @@ package org.apache.juneau.rest.server.mcp.v20260728;
import static java.util.concurrent.TimeUnit.*;
+import java.lang.management.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
@@ -49,12 +50,28 @@ import org.apache.juneau.rest.server.mcp.McpSchema;
* <p>
* Validation itself runs on a fixed-size pool of daemon threads and is bounded by the same overall budget: if
* a pathological schema (for example a catastrophically-backtracking {@code pattern}) fails to complete in
- * time, the task is cancelled and a {@code -32602} error is raised instead of hanging the request thread. That
- * compute budget is measured from the moment the task actually starts running, not from the moment it is
- * submitted: time spent waiting for a free thread in {@link #VALIDATION_POOL} (for example under heavy
- * concurrent build/test load) is scheduling latency, not validation cost, so it is never charged against
- * {@link #MAX_VALIDATION_MILLIS}. A separate, much more generous {@link #MAX_SCHEDULING_MILLIS} backstop still
- * bounds the scheduling wait itself, purely so a wedged or saturated pool cannot block the caller forever.
+ * time, the task is cancelled and a {@code -32602} error is raised instead of hanging the request thread.
+ *
+ * <p>
+ * <b>The compute budget is charged against the validating thread's actual CPU time, not wall-clock time.</b>
+ * The DoS threat being defended against is a schema that burns CPU (catastrophic backtracking, quadratic
+ * blowups); the amount of CPU a validation consumes is exactly what that budget should cap. Measuring
+ * wall-clock instead would wrongly count time the validating thread was <i>not</i> running - time it spent
+ * preempted by the OS scheduler, or queued behind sibling work - as if it were validation cost. Under heavy
+ * concurrent load (for example {@code juneau-integration-tests} running Surefire with {@code forkCount=8}) that
+ * false accounting can trip the budget on trivial input, and the same false-positive can bite a saturated
+ * production deployment. Sampling {@link ThreadMXBean#getThreadCpuTime(long) thread CPU time} on the thread
+ * that actually does the work means only real compute counts: preemption and scheduling latency no longer
+ * shrink the budget, while a genuinely expensive validation still trips it and returns the same {@code -32602}
+ * error. On a JVM where per-thread CPU timing is unavailable, {@link #awaitBounded} transparently falls back to
+ * the original wall-clock measurement so the guard still functions everywhere.
+ *
+ * <p>
+ * Independently of the compute budget, time spent waiting for a free thread in {@link #VALIDATION_POOL} is
+ * scheduling latency, not validation cost, so it is never charged against {@link #MAX_VALIDATION_MILLIS}: the
+ * budget clock (CPU or wall-clock) only starts once the task is actually running. A separate, much more
+ * generous {@link #MAX_SCHEDULING_MILLIS} backstop bounds the scheduling wait itself, purely so a wedged or
+ * saturated pool cannot block the caller forever.
*/
final class McpSchemaSafety {
@@ -65,10 +82,10 @@ final class McpSchemaSafety {
static final int MAX_NODES = 10_000;
/**
- * Maximum compute time permitted for a single schema validation, in milliseconds, measured from the
- * moment the validation task actually starts running on {@link #VALIDATION_POOL} (not from submission).
+ * Maximum compute time permitted for a single schema validation, in milliseconds, measured as the
+ * validating thread's actual CPU time (see class-level notes) - not from submission, and not as wall-clock.
* This is the DoS bound: it caps how much CPU a pathological schema can burn, and is deliberately
- * unaffected by how long the task had to wait for a free thread.
+ * unaffected both by how long the task had to wait for a free thread and by any OS preemption while it runs.
*/
static final long MAX_VALIDATION_MILLIS = 100;
@@ -80,6 +97,36 @@ final class McpSchemaSafety {
*/
static final long MAX_SCHEDULING_MILLIS = 2_000;
+ private static final ThreadMXBean THREAD_MX = ManagementFactory.getThreadMXBean();
+
+ /**
+ * Whether per-thread CPU-time measurement is available (and enabled) on this JVM. When <jk>true</jk>, the
+ * compute budget is charged against the validating thread's actual CPU time; when <jk>false</jk> (a JVM that
+ * cannot report per-thread CPU time), {@link #awaitBounded} falls back to the original wall-clock measurement
+ * so the DoS guard still functions everywhere.
+ */
+ private static final boolean CPU_TIME_SUPPORTED = initCpuTimeSupport();
+
+ /**
+ * How often the waiting thread re-samples the validating thread's accumulated CPU time while a validation is
+ * still running. Small enough that a runaway validation is stopped promptly once it burns past the budget,
+ * large enough that the sampling overhead is negligible.
+ */
+ private static final long CPU_POLL_INTERVAL_NANOS = MILLISECONDS.toNanos(5);
+
+ private static boolean initCpuTimeSupport() {
+ if (! THREAD_MX.isThreadCpuTimeSupported())
+ return false; // HTT: CI JVMs support per-thread CPU time; this fallback path isn't reachable there.
+ if (! THREAD_MX.isThreadCpuTimeEnabled()) {
+ try {
+ THREAD_MX.setThreadCpuTimeEnabled(true); // HTT: HotSpot enables thread CPU time by default; not reachable in CI.
+ } catch (@SuppressWarnings("unused") SecurityException | UnsupportedOperationException e) {
+ return false; // HTT: enabling is rejected only under a restrictive SecurityManager; not reachable in CI.
+ }
+ }
+ return true;
+ }
+
private static final ExecutorService VALIDATION_POOL = newValidationPool();
private static ExecutorService newValidationPool() {
@@ -125,56 +172,79 @@ final class McpSchemaSafety {
/**
* Runs {@link JsonSchemaValidator} on a daemon thread and enforces the remaining share of the shared
- * {@link JsonValueSafety} deadline against the task's own compute time - never against however long it
- * had to wait in {@link #VALIDATION_POOL} for a free thread.
+ * {@link JsonValueSafety} deadline against the task's own compute time - never against however long it had
+ * to wait in {@link #VALIDATION_POOL} for a free thread, and (when CPU timing is available) never against
+ * wall-clock time it spent preempted rather than running.
*/
private static void validateBounded(JsonSchema<?> schema, Object value, long deadlineNanos) {
var remaining = JsonValueSafety.remainingNanos(deadlineNanos);
if (remaining == 0)
throw validationTimeoutException();
var started = new CountDownLatch(1);
- var startedAtNanos = new AtomicLong();
+ var taskStart = new AtomicReference<TaskStart>();
var future = VALIDATION_POOL.submit(() -> {
- startedAtNanos.set(System.nanoTime());
+ taskStart.set(TaskStart.capture());
started.countDown();
JsonSchemaValidator.of(schema).validate(value);
return null;
});
- awaitBounded(future, started, startedAtNanos, remaining);
+ awaitBounded(future, started, taskStart, remaining);
}
/**
- * Waits for a submitted validation task to complete, charging only its own compute time - measured from
- * {@code startedAtNanos}, which the task sets as its first instruction - against {@code remaining}, the
- * caller's share of the shared {@link JsonValueSafety} deadline.
+ * Snapshot of when a validation task actually began running, captured on the validating thread itself as its
+ * first instruction.
+ *
+ * @param threadId The validating thread's id, so the waiting thread can sample that same thread's CPU time.
+ * @param wallNanos The {@link System#nanoTime()} baseline, used by the wall-clock fallback.
+ * @param cpuNanos The validating thread's CPU-time baseline in nanoseconds ({@link ThreadMXBean#getThreadCpuTime(long)}),
+ * or {@code -1} if per-thread CPU timing is unavailable on this JVM.
+ */
+ record TaskStart(long threadId, long wallNanos, long cpuNanos) {
+
+ /** Captures the current thread's start snapshot; must be called on the thread that runs the validation. */
+ static TaskStart capture() {
+ var id = Thread.currentThread().getId();
+ return new TaskStart(id, System.nanoTime(), CPU_TIME_SUPPORTED ? THREAD_MX.getThreadCpuTime(id) : -1L);
+ }
+ }
+
+ /**
+ * Waits for a submitted validation task to complete, charging only its own compute time against
+ * {@code remaining} (the caller's share of the shared {@link JsonValueSafety} deadline) - never however long
+ * it had to wait in {@link #VALIDATION_POOL} for a free thread.
*
* <p>
- * This waits in two phases. First, {@code started} is awaited so the calling thread learns exactly when
- * the task begins running; this wait is bounded only by the generous {@link #MAX_SCHEDULING_MILLIS}
- * backstop, since scheduling delay under load (queueing behind other work in {@link #VALIDATION_POOL})
- * is not the thing being defended against. Second, once running, the task is given the full
- * {@code remaining} share of the deadline as its own fresh compute window - anchored to its actual start
- * time rather than to submission time - so a busy pool cannot eat into the budget that is meant to cap
- * the validator's own work.
+ * This waits in two phases. First, {@code started} is awaited so the calling thread learns exactly when the
+ * task begins running; this wait is bounded only by the generous {@link #MAX_SCHEDULING_MILLIS} backstop,
+ * since scheduling delay under load (queueing behind other work in {@link #VALIDATION_POOL}) is not the thing
+ * being defended against. Second, once the task is running, its compute is bounded: when per-thread CPU
+ * timing is available (the normal case) the waiting thread polls the validating thread's accumulated
+ * <i>CPU</i> time and trips only if that exceeds {@code remaining}, so preemption and scheduling latency
+ * never shrink the budget - only real CPU work does. When CPU timing is unavailable, it falls back to the
+ * original wall-clock window anchored to the task's actual start time.
*
* <p>
* Package-private (rather than private) purely so this can be exercised directly against a test-local
- * {@link Future}/latch pair - deterministically simulating scheduling delay - without needing to saturate
- * the shared {@link #VALIDATION_POOL}.
+ * {@link Future}/latch pair - deterministically simulating scheduling delay, a CPU burn, or a sleep that
+ * elapses wall-clock without consuming CPU - without needing to saturate the shared {@link #VALIDATION_POOL}.
*
* @param future The in-flight (or already-complete) validation task.
* @param started Counted down by the task as its first instruction, once it actually begins running.
- * @param startedAtNanos Set by the task (before counting down {@code started}) to {@link System#nanoTime()}.
+ * @param taskStart Set by the task (before counting down {@code started}) to its {@link TaskStart} snapshot.
* @param remaining The caller's remaining share of the shared deadline, in nanoseconds, captured before submission.
*/
- static void awaitBounded(Future<?> future, CountDownLatch started, AtomicLong startedAtNanos, long remaining) {
+ static void awaitBounded(Future<?> future, CountDownLatch started, AtomicReference<TaskStart> taskStart, long remaining) {
try {
if (! started.await(MAX_SCHEDULING_MILLIS, MILLISECONDS)) {
future.cancel(true);
throw new McpException(McpRevision.CODE_INVALID_PARAMS, "Tool input schema validation could not be scheduled within " + MAX_SCHEDULING_MILLIS + " ms");
}
- var computeRemainingNanos = remaining - (System.nanoTime() - startedAtNanos.get());
- future.get(Math.max(0, computeRemainingNanos), NANOSECONDS);
+ var start = taskStart.get();
+ if (CPU_TIME_SUPPORTED && start.cpuNanos() >= 0)
+ awaitByCpuTime(future, start.threadId(), start.cpuNanos(), remaining);
+ else
+ future.get(Math.max(0, remaining - (System.nanoTime() - start.wallNanos())), NANOSECONDS); // HTT: wall-clock fallback; CI JVMs use the CPU-time path.
} catch (TimeoutException e) {
future.cancel(true);
throw validationTimeoutException();
@@ -190,6 +260,45 @@ final class McpSchemaSafety {
}
}
+ /**
+ * Bounds a running validation by the validating thread's actual CPU time.
+ *
+ * <p>
+ * The waiting thread polls at {@link #CPU_POLL_INTERVAL_NANOS} intervals: each time the task hasn't finished
+ * yet, it re-samples thread CPU time and keeps waiting as long as the CPU consumed since {@code baseCpuNanos}
+ * is within {@code budgetNanos}. Wall-clock elapsed while the thread was preempted (or deliberately sleeping)
+ * accrues no CPU, so it never trips the budget; a schema that genuinely burns CPU does. Validation is pure
+ * in-memory work with no I/O or blocking, so CPU accrual is a sufficient bound and no wall-clock ceiling is
+ * needed here - a task that never returns would necessarily be burning CPU and will trip the budget.
+ *
+ * @param future The running validation task.
+ * @param threadId The validating thread's id.
+ * @param baseCpuNanos The validating thread's CPU-time baseline captured at task start.
+ * @param budgetNanos The maximum CPU time, in nanoseconds, the validation may consume.
+ * @throws TimeoutException If the CPU budget is exceeded while the task is still running.
+ */
+ private static void awaitByCpuTime(Future<?> future, long threadId, long baseCpuNanos, long budgetNanos)
+ throws InterruptedException, ExecutionException, TimeoutException {
+ while (true) {
+ try {
+ future.get(CPU_POLL_INTERVAL_NANOS, NANOSECONDS);
+ return;
+ } catch (TimeoutException poll) {
+ var cpuNow = THREAD_MX.getThreadCpuTime(threadId);
+ if (cpuNow >= 0 && cpuNow - baseCpuNanos <= budgetNanos)
+ continue; // real CPU work still within budget; preemption/scheduling doesn't count against it
+ if (future.isDone())
+ continue; // finished inside the sampling race window; the next get() harvests its result/exception
+ throw poll; // CPU work exceeded the DoS budget (or CPU timing was lost) while the task is still running
+ }
+ }
+ }
+
+ /** Whether the compute budget is charged against thread CPU time (vs. the wall-clock fallback); for tests. */
+ static boolean cpuTimeBudgetEnabled() {
+ return CPU_TIME_SUPPORTED;
+ }
+
private static McpException validationTimeoutException() {
return new McpException(McpRevision.CODE_INVALID_PARAMS, "Tool input schema validation exceeded " + MAX_VALIDATION_MILLIS + " ms");
}
diff --git a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety_Test.java b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety_Test.java
index 22af41ae8f..fd4855c23f 100644
--- a/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety_Test.java
+++ b/juneau-rest/juneau-rest-server-mcp-v20260728/src/test/java/org/apache/juneau/rest/server/mcp/v20260728/McpSchemaSafety_Test.java
@@ -41,7 +41,7 @@ import org.junit.jupiter.api.*;
/**
* Coverage for {@link McpSchemaSafety}: no-fetch handling of external {@code $ref}s and bounded
- * (depth / node / wall-clock) schema validation (Resolution B2).
+ * (depth / node / CPU-time) schema validation (Resolution B2).
*/
class McpSchemaSafety_Test {
@@ -159,7 +159,7 @@ class McpSchemaSafety_Test {
assertContains("node count", e.getMessage());
}
- // -------- bounded wall-clock ---------
+ // -------- bounded compute (thread CPU time, with wall-clock fallback) ---------
@Test
void d01_adversarialValidation_terminatesWithinDeadline() {
@@ -190,23 +190,107 @@ class McpSchemaSafety_Test {
// deliberately delays counting down `started` well past MAX_VALIDATION_MILLIS before doing its
// (instantaneous) "work". If scheduling latency were - the regression this guards against - counted
// against the compute budget, awaitBounded() would throw a timeout error despite the task's own
- // work costing nothing; with the root-cause fix, only compute time (measured from `started`) counts.
+ // work costing nothing; with the root-cause fix, only compute time (measured from the task's start
+ // snapshot) counts.
var schedulingDelayMillis = 3 * McpSchemaSafety.MAX_VALIDATION_MILLIS;
assertTrue(schedulingDelayMillis < McpSchemaSafety.MAX_SCHEDULING_MILLIS, "test fixture assumption");
var started = new CountDownLatch(1);
- var startedAtNanos = new AtomicLong();
+ var taskStart = new AtomicReference<McpSchemaSafety.TaskStart>();
var executor = Executors.newSingleThreadExecutor();
try {
var future = executor.submit(() -> {
Thread.sleep(schedulingDelayMillis); // simulates thread-pool queueing/scheduling delay
- startedAtNanos.set(System.nanoTime());
+ taskStart.set(McpSchemaSafety.TaskStart.capture());
started.countDown();
return null; // the "validation" work itself is instantaneous
});
assertDoesNotThrow(() -> McpSchemaSafety.awaitBounded(
- future, started, startedAtNanos, TimeUnit.MILLISECONDS.toNanos(McpSchemaSafety.MAX_VALIDATION_MILLIS)));
+ future, started, taskStart, TimeUnit.MILLISECONDS.toNanos(McpSchemaSafety.MAX_VALIDATION_MILLIS)));
+ } finally {
+ executor.shutdownNow();
+ }
+ }
+
+ @SuppressWarnings({
+ "java:S2925" // Thread.sleep here deterministically models a validation that elapses wall-clock without consuming CPU, not a wait-and-hope delay.
+ })
+ @Test
+ void d03_sleepingValidation_doesNotTripCpuBudget() {
+ // The core of the wall-clock->CPU-time fix: a "validation" that lets a lot of wall-clock elapse but
+ // consumes ~no CPU (here, by sleeping *after* its start snapshot) must NOT trip the compute budget,
+ // because only real CPU work is the DoS threat. Under the old wall-clock measurement this would have
+ // tripped MAX_VALIDATION_MILLIS. Only meaningful when CPU timing is active (otherwise awaitBounded
+ // legitimately falls back to wall-clock, under which a sleep does count).
+ Assumptions.assumeTrue(McpSchemaSafety.cpuTimeBudgetEnabled(), "per-thread CPU timing unavailable on this JVM");
+ var sleepMillis = 4 * McpSchemaSafety.MAX_VALIDATION_MILLIS; // far past the budget in wall-clock terms
+ assertTrue(sleepMillis < McpSchemaSafety.MAX_SCHEDULING_MILLIS, "test fixture assumption");
+
+ var started = new CountDownLatch(1);
+ var taskStart = new AtomicReference<McpSchemaSafety.TaskStart>();
+ var executor = Executors.newSingleThreadExecutor();
+ try {
+ var future = executor.submit(() -> {
+ taskStart.set(McpSchemaSafety.TaskStart.capture());
+ started.countDown();
+ Thread.sleep(sleepMillis); // wall-clock elapses well past the budget, but burns ~no CPU
+ return null;
+ });
+
+ assertDoesNotThrow(() -> McpSchemaSafety.awaitBounded(
+ future, started, taskStart, TimeUnit.MILLISECONDS.toNanos(McpSchemaSafety.MAX_VALIDATION_MILLIS)));
+ } finally {
+ executor.shutdownNow();
+ }
+ }
+
+ @Test
+ void d04_cpuBurningValidation_tripsBudget() {
+ // The complement of d03: a "validation" that actually burns CPU past the budget MUST still trip it and
+ // raise the same -32602 error. A generous CPU-burn margin (many multiples of the budget) keeps this
+ // robust rather than racing a tight wall-clock bound.
+ var started = new CountDownLatch(1);
+ var taskStart = new AtomicReference<McpSchemaSafety.TaskStart>();
+ var executor = Executors.newSingleThreadExecutor();
+ try {
+ var future = executor.submit(() -> {
+ taskStart.set(McpSchemaSafety.TaskStart.capture());
+ started.countDown();
+ var sink = 0L;
+ while (! Thread.currentThread().isInterrupted()) // spins until awaitBounded trips the budget and cancels us
+ for (var i = 1; i < 5_000_000; i++)
+ sink += (long) Math.sqrt(i) * i;
+ return sink; // returned only so the JIT can't elide the loop
+ });
+
+ var e = assertThrows(McpException.class, () -> McpSchemaSafety.awaitBounded(
+ future, started, taskStart, TimeUnit.MILLISECONDS.toNanos(McpSchemaSafety.MAX_VALIDATION_MILLIS)));
+ assertEquals(-32602, e.getCode());
+ assertContains("exceeded " + McpSchemaSafety.MAX_VALIDATION_MILLIS + " ms", e.getMessage());
+ } finally {
+ executor.shutdownNow();
+ }
+ }
+
+ @Test
+ void d05_cpuTimeUnavailable_fallsBackToWallClock() {
+ // When per-thread CPU timing is unavailable (cpuNanos == -1 in the start snapshot), awaitBounded must
+ // fall back to the original wall-clock budget so the guard still functions on such JVMs. Simulated here
+ // by handing awaitBounded a snapshot with cpuNanos == -1; the instantaneous task completes well within
+ // the wall-clock window.
+ var started = new CountDownLatch(1);
+ var taskStart = new AtomicReference<McpSchemaSafety.TaskStart>();
+ var executor = Executors.newSingleThreadExecutor();
+ try {
+ var future = executor.submit(() -> {
+ taskStart.set(new McpSchemaSafety.TaskStart(Thread.currentThread().getId(), System.nanoTime(), -1L));
+ started.countDown();
+ return null; // instantaneous work, well within the wall-clock window
+ });
+
+ assertDoesNotThrow(() -> McpSchemaSafety.awaitBounded(
+ future, started, taskStart, TimeUnit.MILLISECONDS.toNanos(McpSchemaSafety.MAX_VALIDATION_MILLIS)));
} finally {
executor.shutdownNow();
}
diff --git a/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher.java b/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher.java
index e01c7976b0..fcbaa8bcca 100644
--- a/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher.java
+++ b/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher.java
@@ -66,9 +66,14 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
/** Default template-cache flag — {@code true} (production-safe). */
public static final boolean DEFAULT_CACHE_TEMPLATES = true;
+ /** Default field-exposure flag — {@code true} (public-field DTOs render out of the box). */
+ public static final boolean DEFAULT_EXPOSE_FIELDS = true;
+
private final String basePath;
private final String templateSuffix;
private final boolean cacheTemplates;
+ private final boolean exposeFields;
+ private final ObjectWrapper objectWrapper;
// Lazy bridge-default configuration. Built on first call to resolveConfiguration(...) when
// no Configuration bean is registered in the request's BeanStore. Volatile so the
@@ -96,6 +101,8 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
basePath = builder.basePath;
templateSuffix = builder.templateSuffix;
cacheTemplates = builder.cacheTemplates;
+ exposeFields = builder.exposeFields;
+ objectWrapper = builder.objectWrapper;
}
/**
@@ -125,6 +132,25 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
return cacheTemplates;
}
+ /**
+ * Returns the field-exposure flag applied to the bridge-default object wrapper.
+ *
+ * @return The field-exposure flag. Ignored once {@link #getObjectWrapper()} returns non-{@code null}.
+ */
+ public boolean isExposeFields() {
+ return exposeFields;
+ }
+
+ /**
+ * Returns the user-supplied {@link ObjectWrapper} override, if any.
+ *
+ * @return The object wrapper override, or {@code null} if the bridge builds its own default
+ * (a {@link DefaultObjectWrapper} configured per {@link #isExposeFields() isExposeFields()}).
+ */
+ public ObjectWrapper getObjectWrapper() {
+ return objectWrapper;
+ }
+
/**
* Appends {@link #getTemplateSuffix()} to {@code name} if not already present (idempotent).
*
@@ -183,9 +209,16 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
* pins {@code IncompatibleImprovements} to {@link Configuration#VERSION_2_3_34} so behavior is
* stable across consumer upgrades of {@code org.freemarker:freemarker}; sets
* {@code DefaultEncoding} to {@code UTF-8} and {@code OutputFormat} to
- * {@link HTMLOutputFormat#INSTANCE} so HTML escaping is the natural target; and applies
+ * {@link HTMLOutputFormat#INSTANCE} so HTML escaping is the natural target; applies
* {@code TemplateUpdateDelayMilliseconds} per the configured
- * {@link #isCacheTemplates() cacheTemplates} flag.
+ * {@link #isCacheTemplates() cacheTemplates} flag; and sets an {@code ObjectWrapper} —
+ * either the user-supplied {@link #getObjectWrapper() objectWrapper} override, or (by default)
+ * a {@link DefaultObjectWrapper} built with {@code exposeFields} set to
+ * {@link #isExposeFields() isExposeFields()}. Field exposure defaults to {@code true} (unlike
+ * FreeMarker's own version-default wrapper, which is getter-only): Juneau's own marshalling is
+ * comfortable with public-field beans elsewhere, so a view-model DTO written with public fields
+ * and no getters renders its field values here too, instead of silently resolving to
+ * {@code null}/missing.
*
* <p>
* Subclasses may override to plug in custom loaders / encodings / output formats without
@@ -199,9 +232,23 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
cfg.setDefaultEncoding("UTF-8");
cfg.setOutputFormat(HTMLOutputFormat.INSTANCE);
cfg.setTemplateUpdateDelayMilliseconds(cacheTemplates ? Long.MAX_VALUE : 0L);
+ cfg.setObjectWrapper(objectWrapper != null ? objectWrapper : buildDefaultObjectWrapper());
return cfg;
}
+ /**
+ * Builds the bridge-default {@link ObjectWrapper} — a {@link DefaultObjectWrapper} with
+ * {@code exposeFields} set per {@link #isExposeFields() isExposeFields()}. Only called when no
+ * {@link #getObjectWrapper() objectWrapper} override has been supplied.
+ *
+ * @return A new {@link DefaultObjectWrapper} instance.
+ */
+ private ObjectWrapper buildDefaultObjectWrapper() {
+ var b = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_34);
+ b.setExposeFields(exposeFields);
+ return b.build();
+ }
+
/**
* Translates a virtual base path (e.g. {@code "/templates/"}) into a FreeMarker
* {@code ClassLoaderTemplateLoader} resource root (e.g. {@code "/templates"}).
@@ -314,6 +361,8 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
String basePath = DEFAULT_BASE_PATH;
String templateSuffix = DEFAULT_TEMPLATE_SUFFIX;
boolean cacheTemplates = DEFAULT_CACHE_TEMPLATES;
+ boolean exposeFields = DEFAULT_EXPOSE_FIELDS;
+ ObjectWrapper objectWrapper;
/** Constructor — package access for {@link FreemarkerDispatcher#create()}. */
protected Builder() {}
@@ -354,6 +403,42 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
return this;
}
+ /**
+ * Sets whether the bridge-default {@code ObjectWrapper} exposes public fields (not just
+ * JavaBean getters) to templates.
+ *
+ * <p>
+ * Defaults to {@link FreemarkerDispatcher#DEFAULT_EXPOSE_FIELDS true} so simple view-model
+ * DTOs written with public fields and no getters render their field values instead of
+ * silently resolving to {@code null}/missing. Has no effect once {@link #objectWrapper}
+ * has been called with a non-{@code null} value — the explicit wrapper always wins.
+ *
+ * @param value The field-exposure flag.
+ * @return This object.
+ */
+ public Builder exposeFields(boolean value) {
+ exposeFields = value;
+ return this;
+ }
+
+ /**
+ * Sets a fully custom {@code ObjectWrapper} for the bridge-default configuration,
+ * overriding {@link #exposeFields(boolean)} entirely.
+ *
+ * <p>
+ * Escape hatch for consumers who need full control (e.g. a {@code BeansWrapper} with
+ * custom method/property exposure, or a third-party wrapper) without hand-rolling and
+ * registering a whole replacement {@code Configuration} bean.
+ *
+ * @param value The object wrapper. {@code null} reverts to the bridge-built
+ * {@link DefaultObjectWrapper} (per {@link #exposeFields(boolean)}).
+ * @return This object.
+ */
+ public Builder objectWrapper(ObjectWrapper value) {
+ objectWrapper = value;
+ return this;
+ }
+
/**
* Reads the current base path setting (test/inspection helper).
*
@@ -381,6 +466,24 @@ public class FreemarkerDispatcher implements RawTemplateDispatcher {
return cacheTemplates;
}
+ /**
+ * Reads the current field-exposure setting (test/inspection helper).
+ *
+ * @return The field-exposure flag.
+ */
+ public boolean isExposeFields() {
+ return exposeFields;
+ }
+
+ /**
+ * Reads the current object-wrapper override (test/inspection helper).
+ *
+ * @return The object wrapper override, or {@code null} if none has been set.
+ */
+ public ObjectWrapper getObjectWrapper() {
+ return objectWrapper;
+ }
+
/**
* Builds the {@link FreemarkerDispatcher}.
*
diff --git a/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin.java b/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin.java
index b4d0de7c16..20291fd129 100644
--- a/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin.java
+++ b/juneau-rest/juneau-rest-server-view-freemarker/src/main/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin.java
@@ -37,12 +37,46 @@ import freemarker.template.*;
* the importer's classpath by asking the configured {@link Configuration} for the named
* template and rendering it with an empty data model (raw render path; callers who want
* attributes use {@link FreemarkerView} from a typed handler instead).
- * <li>Picks up {@link FreemarkerViewRenderer} automatically via the mixin's
- * {@link Rest#responseProcessors() @Rest(responseProcessors=...)} declaration, so
- * {@code @RestOp}-method return values of type {@link FreemarkerView} render through the
- * FreeMarker engine without any additional wiring.
+ * <li>Registers {@link FreemarkerViewRenderer} for the mixin's <b>own</b> endpoints (e.g. the
+ * {@code /freemarker/*} route above) via the mixin's own
+ * {@link Rest#responseProcessors() @Rest(responseProcessors=...)} declaration.
* </ol>
*
+ * <h5 class='section'>Auto-wiring the renderer into the host's own endpoints:</h5>
+ *
+ * <p>
+ * A bare {@code @Rest(mixins=FreemarkerMixin.class)} is enough — a host whose own {@code @RestOp} method
+ * returns {@link FreemarkerView} renders it through the FreeMarker engine with no extra wiring. That works
+ * because {@code FreemarkerMixin} declares
+ * {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)} on its own class,
+ * so the framework folds {@code FreemarkerMixin}'s {@link FreemarkerViewRenderer} into the host's own
+ * response-processor chain automatically.
+ *
+ * <p>
+ * This fold is per-mixin, opt-in, and response-processor-scoped: it happens only because
+ * {@code FreemarkerMixin} declares the opt-in (a mixin that does not is still scoped to its own endpoints, the
+ * standard {@link Rest#mixins() @Rest(mixins=...)} rule), and it folds only the renderer — never
+ * {@code guards}, {@code serializers}, or any other list-shaped attribute.
+ *
+ * <p>
+ * Two explicit wirings remain supported — useful when you want to be explicit, or to fold more than the
+ * renderer:
+ *
+ * <ol class='spaced-list'>
+ * <li><b>{@link Mixin#mergeIntoHost() @Mixin(mergeIntoHost=true)}</b> via the rich {@link Rest#mixinDefs()
+ * mixinDefs} form — folds <b>all</b> of {@code FreemarkerMixin}'s list-shaped {@code @Rest}
+ * attributes into the host's own chain, not just the renderer.
+ * <li><b>List {@link FreemarkerViewRenderer FreemarkerViewRenderer.class} explicitly</b> in the host's own
+ * {@code @Rest(responseProcessors=...)} — the fully manual equivalent.
+ * </ol>
+ *
+ * <p>
+ * The {@link org.apache.juneau.rest.server.processor.ResponseProcessorList} partition pass repositions
+ * {@link FreemarkerViewRenderer} (a
+ * {@link org.apache.juneau.rest.server.view.ViewRenderer ViewRenderer}) ahead of
+ * {@code SerializedPojoProcessor} in every case, so the {@link FreemarkerView} bean is dispatched to the
+ * FreeMarker engine rather than bean-serialized.
+ *
* <h5 class='figure'>Composition example (microservice):</h5>
*
* <p class='bjava'>
@@ -102,16 +136,33 @@ import freemarker.template.*;
* {@code ClassLoaderTemplateResolver}-equivalent prefix {@code "/templates"}). The default
* pins {@code IncompatibleImprovements} to the bridge-tested minor version
* ({@code Configuration.VERSION_2_3_34}), sets {@code DefaultEncoding} to {@code UTF-8},
- * uses {@code HTMLOutputFormat} so HTML escaping is the natural target, and applies
+ * uses {@code HTMLOutputFormat} so HTML escaping is the natural target, applies
* {@code TemplateUpdateDelayMilliseconds} per the {@link #isCacheTemplates() cacheTemplates}
* flag (production-safe by default; users opt into hot-reload via
- * {@link Builder#cacheTemplates(boolean) cacheTemplates(false)}).
+ * {@link Builder#cacheTemplates(boolean) cacheTemplates(false)}), and sets an
+ * {@code ObjectWrapper} with {@code exposeFields=true} (see below) unless overridden.
* </ul>
*
* <p>
* When no FreeMarker engine is on the classpath, the renderer surfaces
* {@link FreemarkerViewRenderer#NO_ENGINE_DIAGNOSTIC} naming the missing dependency.
*
+ * <h5 class='section'>Public-field DTOs (getter-only default trap):</h5>
+ *
+ * <p>
+ * FreeMarker's own version-default {@code ObjectWrapper} exposes only JavaBean getters — a
+ * view-model bean written as a simple DTO with public fields and no getters resolves every
+ * {@code ${bean.field}} reference to {@code null}/missing, <b>silently</b> (a template using
+ * {@code !'default'} fallbacks renders the default with no error at all; a bare {@code ${bean.field}}
+ * with no fallback throws at render time). This bridge avoids that trap by default: the bridge-built
+ * {@link Configuration} sets a {@link DefaultObjectWrapper} with {@code exposeFields=true}
+ * ({@link #DEFAULT_EXPOSE_FIELDS}), so public-field DTOs render their field values out of the
+ * box — matching how Juneau's own marshalling is comfortable with public-field beans elsewhere.
+ * Use {@link Builder#exposeFields(boolean) exposeFields(false)} to restore FreeMarker's getter-only
+ * behavior, or {@link Builder#objectWrapper(ObjectWrapper) objectWrapper(...)} for full control
+ * (e.g. a {@code BeansWrapper} with custom exposure rules). Both knobs only affect the
+ * bridge-default {@link Configuration}; a user-supplied {@code @Bean Configuration} is used as-is.
+ *
* <h5 class='section'>Template suffix:</h5>
*
* <p>
@@ -155,7 +206,8 @@ import freemarker.template.*;
*/
// @formatter:off
@Rest(
- responseProcessors={FreemarkerViewRenderer.class}
+ responseProcessors={FreemarkerViewRenderer.class},
+ mergeResponseProcessorsIntoHost=true
)
public class FreemarkerMixin {
@@ -168,6 +220,9 @@ public class FreemarkerMixin {
/** Default template-cache flag — {@code true} (production-safe). */
public static final boolean DEFAULT_CACHE_TEMPLATES = FreemarkerDispatcher.DEFAULT_CACHE_TEMPLATES;
+ /** Default field-exposure flag — {@code true} (public-field DTOs render out of the box). */
+ public static final boolean DEFAULT_EXPOSE_FIELDS = FreemarkerDispatcher.DEFAULT_EXPOSE_FIELDS;
+
private final FreemarkerDispatcher worker;
/**
@@ -229,6 +284,24 @@ public class FreemarkerMixin {
return worker.isCacheTemplates();
}
+ /**
+ * Returns the field-exposure flag applied to the bridge-default object wrapper.
+ *
+ * @return The field-exposure flag. Ignored once {@link #getObjectWrapper()} returns non-{@code null}.
+ */
+ public boolean isExposeFields() {
+ return worker.isExposeFields();
+ }
+
+ /**
+ * Returns the user-supplied {@link ObjectWrapper} override, if any.
+ *
+ * @return The object wrapper override, or {@code null} if the bridge builds its own default.
+ */
+ public ObjectWrapper getObjectWrapper() {
+ return worker.getObjectWrapper();
+ }
+
/**
* Appends {@link #getTemplateSuffix()} to {@code name} if not already present (idempotent).
*
@@ -357,6 +430,43 @@ public class FreemarkerMixin {
return this;
}
+ /**
+ * Sets whether the bridge-default {@code ObjectWrapper} exposes public fields (not just
+ * JavaBean getters) to templates.
+ *
+ * <p>
+ * Defaults to {@link FreemarkerMixin#DEFAULT_EXPOSE_FIELDS true} so simple view-model
+ * DTOs written with public fields and no getters render their field values instead of
+ * silently resolving to {@code null}/missing (see the class-level
+ * "Public-field DTOs" section). Has no effect once {@link #objectWrapper(ObjectWrapper)}
+ * has been called with a non-{@code null} value — the explicit wrapper always wins.
+ *
+ * @param value The field-exposure flag.
+ * @return This object.
+ */
+ public Builder exposeFields(boolean value) {
+ worker.exposeFields(value);
+ return this;
+ }
+
+ /**
+ * Sets a fully custom {@code ObjectWrapper} for the bridge-default configuration,
+ * overriding {@link #exposeFields(boolean)} entirely.
+ *
+ * <p>
+ * Escape hatch for consumers who need full control (e.g. a {@code BeansWrapper} with
+ * custom method/property exposure, or a third-party wrapper) without hand-rolling and
+ * registering a whole replacement {@code Configuration} bean.
+ *
+ * @param value The object wrapper. {@code null} reverts to the bridge-built
+ * {@link DefaultObjectWrapper} (per {@link #exposeFields(boolean)}).
+ * @return This object.
+ */
+ public Builder objectWrapper(ObjectWrapper value) {
+ worker.objectWrapper(value);
+ return this;
+ }
+
/**
* Reads the current base path setting (test/inspection helper).
*
@@ -384,6 +494,24 @@ public class FreemarkerMixin {
return worker.isCacheTemplates();
}
+ /**
+ * Reads the current field-exposure setting (test/inspection helper).
+ *
+ * @return The field-exposure flag.
+ */
+ public boolean isExposeFields() {
+ return worker.isExposeFields();
+ }
+
+ /**
+ * Reads the current object-wrapper override (test/inspection helper).
+ *
+ * @return The object wrapper override, or {@code null} if none has been set.
+ */
+ public ObjectWrapper getObjectWrapper() {
+ return worker.getObjectWrapper();
+ }
+
/**
* Builds the {@link FreemarkerMixin}.
*
diff --git a/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher_Test.java b/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher_Test.java
index 11aeafab91..a80458fa3a 100644
--- a/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher_Test.java
+++ b/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerDispatcher_Test.java
@@ -20,6 +20,7 @@ import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.io.*;
+import java.util.*;
import org.apache.juneau.*;
import org.apache.juneau.commons.inject.*;
@@ -29,6 +30,7 @@ import org.junit.jupiter.api.*;
import freemarker.cache.*;
import freemarker.template.Configuration;
+import freemarker.template.DefaultObjectWrapperBuilder;
/**
* Unit tests for {@link FreemarkerDispatcher#render(String, RestRequest, RestResponse) render(...)} and
@@ -178,4 +180,55 @@ class FreemarkerDispatcher_Test extends TestBase {
var cfg = dispatcher.buildDefaultConfiguration();
assertEquals(Long.MAX_VALUE, cfg.getTemplateUpdateDelayMilliseconds());
}
+
+ /* ---------------------------------------------------------------------------------------- *
+ * Section D: buildDefaultConfiguration object-wrapper / exposeFields behavior
+ * ---------------------------------------------------------------------------------------- */
+
+ /** View-model DTO with a public field and no getter — the shape that bit the dogfooded consumer. */
+ public static class D_FieldOnlyBean {
+ public String name = "Alice";
+ }
+
+ private static String renderToString(Configuration cfg, String template, Object bean) throws Exception {
+ var loader = new StringTemplateLoader();
+ loader.putTemplate("t", template);
+ cfg.setTemplateLoader(loader);
+ var sw = new StringWriter();
+ cfg.getTemplate("t").process(Map.of("bean", bean), sw);
+ return sw.toString();
+ }
+
+ @Test void d01_buildDefaultConfiguration_exposeFieldsDefaultTrue_rendersPublicFieldValue() throws Exception {
+ var dispatcher = FreemarkerDispatcher.create().build();
+ var cfg = dispatcher.buildDefaultConfiguration();
+
+ assertEquals("Alice", renderToString(cfg, "${bean.name}", new D_FieldOnlyBean()));
+ }
+
+ @Test void d02_exposeFieldsFalse_publicFieldIsInvisibleToTemplates() throws Exception {
+ var dispatcher = FreemarkerDispatcher.create().exposeFields(false).build();
+ var cfg = dispatcher.buildDefaultConfiguration();
+
+ // With exposeFields=false (FreeMarker's own version-default behavior), the public field
+ // isn't visible as a bean property, so a defaulted reference falls through silently.
+ assertEquals("MISSING", renderToString(cfg, "${bean.name!'MISSING'}", new D_FieldOnlyBean()));
+ }
+
+ @Test void d03_objectWrapperOverride_takesPrecedenceOverExposeFields() {
+ var b = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_34);
+ b.setExposeFields(false);
+ var custom = b.build();
+ var dispatcher = FreemarkerDispatcher.create().exposeFields(true).objectWrapper(custom).build();
+
+ var cfg = dispatcher.buildDefaultConfiguration();
+
+ assertSame(custom, cfg.getObjectWrapper());
+ }
+
+ @Test void d04_exposeFieldsAndObjectWrapperDefaultToTrueAndNull() {
+ var dispatcher = FreemarkerDispatcher.create().build();
+ assertTrue(dispatcher.isExposeFields());
+ assertNull(dispatcher.getObjectWrapper());
+ }
}
diff --git a/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin_Builder_Test.java b/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin_Builder_Test.java
index 13bc53438c..b0a41f350c 100644
--- a/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin_Builder_Test.java
+++ b/juneau-rest/juneau-rest-server-view-freemarker/src/test/java/org/apache/juneau/rest/server/view/freemarker/FreemarkerMixin_Builder_Test.java
@@ -138,6 +138,36 @@ class FreemarkerMixin_Builder_Test extends TestBase {
assertNotNull(c1.getTemplateLoader());
}
+ @Test void a14_exposeFieldsDefaultsTrue() {
+ var r = FreemarkerMixin.create().build();
+ assertTrue(r.isExposeFields());
+ }
+
+ @Test void a15_exposeFieldsSetterRoundTrips() {
+ var r = FreemarkerMixin.create().exposeFields(false).build();
+ assertFalse(r.isExposeFields());
+ }
+
+ @Test void a16_objectWrapperDefaultsNull() {
+ var r = FreemarkerMixin.create().build();
+ assertNull(r.getObjectWrapper());
+ }
+
+ @Test void a17_objectWrapperSetterRoundTrips() {
+ var wrapper = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_34).build();
+ var r = FreemarkerMixin.create().objectWrapper(wrapper).build();
+ assertSame(wrapper, r.getObjectWrapper());
+ }
+
+ @Test void a18_builderReadersReflectExposeFieldsAndObjectWrapperMutations() {
+ var wrapper = new DefaultObjectWrapperBuilder(Configuration.VERSION_2_3_34).build();
+ var b = FreemarkerMixin.create()
+ .exposeFields(false)
+ .objectWrapper(wrapper);
+ assertFalse(b.isExposeFields());
+ assertSame(wrapper, b.getObjectWrapper());
+ }
+
/* ---------------------------------------------------------------------------------------- *
* Section B: applyTemplateSuffix helper (idempotent appender)
* ---------------------------------------------------------------------------------------- */
diff --git a/juneau-rest/juneau-rest-server-view-jsp/src/main/java/org/apache/juneau/rest/server/view/jsp/JspMixin.java b/juneau-rest/juneau-rest-server-view-jsp/src/main/java/org/apache/juneau/rest/server/view/jsp/JspMixin.java
index 4ef847187a..79ad89e3d6 100644
--- a/juneau-rest/juneau-rest-server-view-jsp/src/main/java/org/apache/juneau/rest/server/view/jsp/JspMixin.java
+++ b/juneau-rest/juneau-rest-server-view-jsp/src/main/java/org/apache/juneau/rest/server/view/jsp/JspMixin.java
@@ -42,35 +42,41 @@ import org.apache.juneau.rest.server.view.*;
* <h5 class='section'>Auto-wiring the renderer into the host's own endpoints:</h5>
*
* <p>
- * By default a mixin's {@code responseProcessors} apply only to the mixin's own endpoints — a host's own
- * {@code @RestOp} methods see only the host's chain (the {@link Rest#mixins() @Rest(mixins=...)} rule "host's
- * chain runs first, then the mixin's appended; host endpoints see only the host's chain"). So with a bare
- * {@code @Rest(mixins=JspMixin.class)}, a host whose own {@code @RestOp} returns {@link JspView} would have the
- * framework's default {@code SerializedPojoProcessor} bean-serialize it instead of dispatching it to the JSP
- * engine. Two ways to make the host's own {@code JspView} returns reach {@link JspViewRenderer}:
+ * A bare {@code @Rest(mixins=JspMixin.class)} is enough — a host whose own {@code @RestOp} method returns
+ * {@link JspView} renders it through the JSP engine with no extra wiring. That works because {@code JspMixin}
+ * declares {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)} on its own
+ * class, so the framework folds {@code JspMixin}'s {@link JspViewRenderer} into the host's own response-processor
+ * chain automatically.
+ *
+ * <p>
+ * This fold is per-mixin, opt-in, and response-processor-scoped: it happens only because {@code JspMixin}
+ * declares the opt-in (a mixin that does not is still scoped to its own endpoints, the standard
+ * {@link Rest#mixins() @Rest(mixins=...)} rule), and it folds only the renderer — never {@code guards},
+ * {@code serializers}, or any other list-shaped attribute.
+ *
+ * <p>
+ * Two explicit wirings remain supported — useful when you want to be explicit, or to fold more than the
+ * renderer:
*
* <ol class='spaced-list'>
- * <li><b>Opt in via {@link Mixin#mergeIntoHost() @Mixin(mergeIntoHost=true)}</b> (recommended) — the
- * host declares the mixin through the rich {@link Rest#mixinDefs() mixinDefs} form with
- * {@code mergeIntoHost=true}, which folds {@code JspMixin}'s {@code @Rest(responseProcessors=...)} (and any
- * other list-shaped attributes) into the host's own chain. No need to repeat
- * {@link JspViewRenderer JspViewRenderer.class} on the host.
+ * <li><b>{@link Mixin#mergeIntoHost() @Mixin(mergeIntoHost=true)}</b> via the rich {@link Rest#mixinDefs()
+ * mixinDefs} form — folds <b>all</b> of {@code JspMixin}'s list-shaped {@code @Rest} attributes into
+ * the host's own chain, not just the renderer.
* <li><b>List {@link JspViewRenderer JspViewRenderer.class} explicitly</b> in the host's own
- * {@code @Rest(responseProcessors=...)} — the manual equivalent, useful when the host does not
- * declare the mixin via {@code mixinDefs}.
+ * {@code @Rest(responseProcessors=...)} — the fully manual equivalent.
* </ol>
*
* <p>
* The {@link org.apache.juneau.rest.server.processor.ResponseProcessorList} partition pass repositions
* {@link JspViewRenderer} (a
* {@link org.apache.juneau.rest.server.view.ViewRenderer ViewRenderer}) ahead of
- * {@code SerializedPojoProcessor} in either case, so the {@link JspView} bean is dispatched to the JSP engine
+ * {@code SerializedPojoProcessor} in every case, so the {@link JspView} bean is dispatched to the JSP engine
* rather than bean-serialized.
*
* <h5 class='figure'>Composition example (microservice):</h5>
*
* <p class='bjava'>
- * <ja>@Rest</ja>(path=<js>"/app"</js>, mixinDefs=<ja>@Mixin</ja>(type=JspMixin.<jk>class</jk>, mergeIntoHost=<jk>true</jk>))
+ * <ja>@Rest</ja>(path=<js>"/app"</js>, mixins=JspMixin.<jk>class</jk>)
* <jk>public class</jk> AppResource <jk>extends</jk> RestServlet {
*
* <ja>@Bean</ja> JspMixin jsp() {
@@ -162,7 +168,8 @@ import org.apache.juneau.rest.server.view.*;
*/
// @formatter:off
@Rest(
- responseProcessors={JspViewRenderer.class}
+ responseProcessors={JspViewRenderer.class},
+ mergeResponseProcessorsIntoHost=true
)
public class JspMixin {
diff --git a/juneau-rest/juneau-rest-server-view-jsp/src/test/java/org/apache/juneau/rest/server/view/jsp/JspViewRenderer_ForwardPaths_Test.java b/juneau-rest/juneau-rest-server-view-jsp/src/test/java/org/apache/juneau/rest/server/view/jsp/JspViewRenderer_ForwardPaths_Test.java
index 768857a114..678f755422 100644
--- a/juneau-rest/juneau-rest-server-view-jsp/src/test/java/org/apache/juneau/rest/server/view/jsp/JspViewRenderer_ForwardPaths_Test.java
+++ b/juneau-rest/juneau-rest-server-view-jsp/src/test/java/org/apache/juneau/rest/server/view/jsp/JspViewRenderer_ForwardPaths_Test.java
@@ -40,8 +40,10 @@ import org.junit.jupiter.api.*;
*
* <p>
* Fixture {@code A} declares {@code @Rest(responseProcessors=JspViewRenderer.class)} directly
- * (the pattern proven to work by {@code JspView_TypedHandler_Test} in {@code juneau-integration-tests}),
- * rather than relying on {@code @Rest(mixins=JspMixin.class)} alone — see {@code z01} below for why.
+ * (the pattern proven to work by {@code JspView_TypedHandler_Test} in {@code juneau-integration-tests}).
+ * A bare {@code @Rest(mixins=JspMixin.class)} now reaches the same code path too, because {@code JspMixin}
+ * declares {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)} on its
+ * own class, folding {@link JspViewRenderer} into the host's own chain — see {@code z01} below.
*
* @since 10.0.0
*/
@@ -71,19 +73,13 @@ class JspViewRenderer_ForwardPaths_Test extends TestBase {
private static final MockRestClient c = MockRestClient.buildLax(A.class);
- // A BARE @Rest(mixins=JspMixin.class) does NOT route a HOST-defined @RestGet method's
- // JspView return value through JspViewRenderer -- this is the default, deliberately-isolated behavior.
- // RestContext#getRestAnnotationsForProperty resolves a HOST context's own responseProcessors chain from the
- // host's OWN @Rest annotation chain (ancestor classes); a mixin class's @Rest(responseProcessors=...) is a
- // property of the MIXIN's own sub-context (consulted only for ops declared directly on the mixin class
- // itself, e.g. JspMixin#render), and is NOT folded into the host's list unless the host opts in. See
- // Rest#mixins() javadoc ("host's chain runs first, then the mixin's appended. Host endpoints see only the
- // host's chain") and MixinInheritance_ResponseProcessors_Test#a02 in juneau-integration-tests, which pins
- // this default isolation. To have a host's own JspView returns reach JspViewRenderer, the host opts in via
- // @Mixin(mergeIntoHost=true) (see MergeIntoHost fixture + z02 below), which folds the mixin's list-shaped
- // @Rest attributes (including responseProcessors) into the host's own chain; the manual equivalent is
- // listing JspViewRenderer.class directly in the host's own @Rest(responseProcessors=...) -- exactly like
- // this class's own fixture A above.
+ // A bare @Rest(mixins=JspMixin.class) DOES route a HOST-defined @RestGet method's JspView return value
+ // through JspViewRenderer, because JspMixin declares @Rest(mergeResponseProcessorsIntoHost=true) on its own
+ // class. That opt-in folds JspMixin's own @Rest(responseProcessors=JspViewRenderer.class) into the host's
+ // own response-processor chain (response-processor-scoped only), so a host op returning a JspView reaches
+ // the renderer with no extra wiring. See z01 below, JspMixin's class javadoc, and
+ // MixinResponseProcessorFold_Test (rest-server) / MixinInheritance_ResponseProcessors_Test
+ // (juneau-integration-tests), which pin the fold at the RestContext and mock-client levels respectively.
@Rest(mixins=JspMixin.class)
public static class MixinOnly extends BasicRestServlet {
private static final long serialVersionUID = 1L;
@@ -95,6 +91,29 @@ class JspViewRenderer_ForwardPaths_Test extends TestBase {
private static final MockRestClient cMixinOnly = MockRestClient.buildLax(MixinOnly.class);
+ // Non-silent regression guard: a mixin that registers JspViewRenderer but does NOT declare the
+ // mergeResponseProcessorsIntoHost opt-in stays scoped to its own endpoints -- its responseProcessors are
+ // NOT folded into the host's chain, so a host op returning a JspView falls back to bean-serialization.
+ // This is the deliberately-isolated default that JspMixin overrides by opting in (see z03 vs z01).
+ @Rest(responseProcessors=JspViewRenderer.class)
+ public static class NoFoldMixin {
+ @RestGet(path="/mixin-only-endpoint")
+ public String noop() {
+ return "noop";
+ }
+ }
+
+ @Rest(mixins=NoFoldMixin.class)
+ public static class HostWithNoFoldMixin extends BasicRestServlet {
+ private static final long serialVersionUID = 1L;
+ @RestGet(path="/view")
+ public View view() {
+ return JspView.of("hello.jsp");
+ }
+ }
+
+ private static final MockRestClient cNoFoldMixin = MockRestClient.buildLax(HostWithNoFoldMixin.class);
+
// Opt-in host: adopts JspMixin via the rich mixinDefs form with mergeIntoHost=true, so the mixin's
// @Rest(responseProcessors=JspViewRenderer.class) folds into THIS host's own chain.
@Rest(mixinDefs=@Mixin(type=JspMixin.class, mergeIntoHost=true))
@@ -108,10 +127,30 @@ class JspViewRenderer_ForwardPaths_Test extends TestBase {
private static final MockRestClient cMergeIntoHost = MockRestClient.buildLax(MergeIntoHost.class);
- @Test void z01_mixinAlone_doesNotRouteHostViewReturnThroughRenderer() throws Exception {
- // Bean-serialized fallback (SerializedPojoProcessor won), NOT JSP-dispatched -- the body contains the
- // JspView bean's own "templateName" field, which JspViewRenderer's actual dispatch path never produces.
- var res = cMixinOnly.get("/view").accept("application/json").run();
+ @Test void z01_mixinAlone_routesHostViewReturnThroughRenderer() throws Exception {
+ // JspMixin declares @Rest(mergeResponseProcessorsIntoHost=true), so a bare @Rest(mixins=JspMixin.class)
+ // folds JspViewRenderer into the host's own chain: a host @RestGet returning a JspView is CLAIMED by the
+ // renderer (not bean-serialized). With a well-behaved dispatcher that commits the response, the render
+ // succeeds end-to-end (200) -- deterministic proof the fold routes AND renders, not merely that it was
+ // intercepted. The companion null-dispatcher assertion below pins that it reached the renderer rather than
+ // the default SerializedPojoProcessor (which would have produced a 200 "templateName" body, as in z03).
+ var okCtx = fakeServletContext(new FakeDispatcher(() -> { /* well-behaved engine committed the response */ }));
+ cMixinOnly.get("/view").servletContext(okCtx).run().assertStatus(200);
+
+ var noEngineCtx = fakeServletContext(null);
+ var res = cMixinOnly.get("/view").servletContext(noEngineCtx).run();
+ res.assertStatus(500);
+ res.assertContent().asString().isContains("Could not resolve RequestDispatcher");
+ res.assertContent().asString().isContains("No JSP engine is available on the classpath");
+ }
+
+ @Test void z03_nonOptedInMixin_doesNotRouteHostViewReturnThroughRenderer() throws Exception {
+ // Regression guard for the non-silent contract: NoFoldMixin registers JspViewRenderer but does NOT opt in
+ // via mergeResponseProcessorsIntoHost, so the renderer stays scoped to the mixin's own endpoints and is
+ // NOT folded into the host's chain. The host's JspView return therefore falls back to bean-serialization
+ // (SerializedPojoProcessor won) -- a 200 whose body contains the JspView bean's own "templateName" field,
+ // which JspViewRenderer's dispatch path never produces. Contrast with z01 (opted-in JspMixin routes).
+ var res = cNoFoldMixin.get("/view").accept("application/json").run();
res.assertStatus(200);
res.assertContent().asString().isContains("templateName");
}
@@ -121,7 +160,7 @@ class JspViewRenderer_ForwardPaths_Test extends TestBase {
// into the HOST's own chain, so a host @RestGet returning a JspView is now CLAIMED by JspViewRenderer
// (not bean-serialized). With a ServletContext that resolves no dispatcher, the renderer surfaces its
// NO_ENGINE_DIAGNOSTIC 500 -- deterministic proof the JspView reached JspViewRenderer rather than the
- // default SerializedPojoProcessor (which would have produced a 200 "templateName" body as in z01).
+ // default SerializedPojoProcessor (which would have produced a 200 "templateName" body as in z03).
var ctx = fakeServletContext(null);
var res = cMergeIntoHost.get("/view").servletContext(ctx).run();
res.assertStatus(500);
diff --git a/juneau-rest/juneau-rest-server-view-mustache/src/main/java/org/apache/juneau/rest/server/view/mustache/MustacheMixin.java b/juneau-rest/juneau-rest-server-view-mustache/src/main/java/org/apache/juneau/rest/server/view/mustache/MustacheMixin.java
index 095810dc04..c46c5d8fdd 100644
--- a/juneau-rest/juneau-rest-server-view-mustache/src/main/java/org/apache/juneau/rest/server/view/mustache/MustacheMixin.java
+++ b/juneau-rest/juneau-rest-server-view-mustache/src/main/java/org/apache/juneau/rest/server/view/mustache/MustacheMixin.java
@@ -37,10 +37,12 @@ import com.github.mustachejava.*;
* importer's classpath by asking the configured {@link MustacheFactory} to compile and
* render them with no scope (raw render path; callers who want attributes use
* {@link MustacheView} from a typed handler instead).
- * <li>Picks up {@link MustacheViewRenderer} automatically via the mixin's
- * {@link Rest#responseProcessors() @Rest(responseProcessors=...)} declaration, so
- * {@code @RestOp}-method return values of type {@link MustacheView} render through the
- * Mustache engine without any additional wiring.
+ * <li>Routes the host's own {@code @RestOp}-method return values of type {@link MustacheView} through the
+ * Mustache engine automatically. {@code MustacheMixin} declares
+ * {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)}, so a plain
+ * {@code @Rest(mixins=MustacheMixin.class)} folds its {@link MustacheViewRenderer} into the host's own
+ * response-processor chain — no {@code mergeIntoHost} or explicit {@code responseProcessors=} on the
+ * host needed.
* </ol>
*
* <h5 class='figure'>Composition example (microservice):</h5>
@@ -150,7 +152,8 @@ import com.github.mustachejava.*;
*/
// @formatter:off
@Rest(
- responseProcessors={MustacheViewRenderer.class}
+ responseProcessors={MustacheViewRenderer.class},
+ mergeResponseProcessorsIntoHost=true
)
public class MustacheMixin {
diff --git a/juneau-rest/juneau-rest-server-view-thymeleaf/src/main/java/org/apache/juneau/rest/server/view/thymeleaf/ThymeleafMixin.java b/juneau-rest/juneau-rest-server-view-thymeleaf/src/main/java/org/apache/juneau/rest/server/view/thymeleaf/ThymeleafMixin.java
index 42d9364f83..c7d53a4d2b 100644
--- a/juneau-rest/juneau-rest-server-view-thymeleaf/src/main/java/org/apache/juneau/rest/server/view/thymeleaf/ThymeleafMixin.java
+++ b/juneau-rest/juneau-rest-server-view-thymeleaf/src/main/java/org/apache/juneau/rest/server/view/thymeleaf/ThymeleafMixin.java
@@ -37,10 +37,12 @@ import org.thymeleaf.templatemode.*;
* the importer's classpath by asking the configured
* {@link org.thymeleaf.TemplateEngine TemplateEngine} to render them with the current
* request's locale and attributes available to the template.
- * <li>Picks up {@link ThymeleafViewRenderer} automatically via the mixin's
- * {@link Rest#responseProcessors() @Rest(responseProcessors=...)} declaration, so
- * {@code @RestOp}-method return values of type {@link ThymeleafView} render through the
- * Thymeleaf engine without any additional wiring.
+ * <li>Routes the host's own {@code @RestOp}-method return values of type {@link ThymeleafView} through the
+ * Thymeleaf engine automatically. {@code ThymeleafMixin} declares
+ * {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)}, so a plain
+ * {@code @Rest(mixins=ThymeleafMixin.class)} folds its {@link ThymeleafViewRenderer} into the host's own
+ * response-processor chain — no {@code mergeIntoHost} or explicit {@code responseProcessors=} on the
+ * host needed.
* </ol>
*
* <h5 class='figure'>Composition example (microservice):</h5>
@@ -134,7 +136,8 @@ import org.thymeleaf.templatemode.*;
*/
// @formatter:off
@Rest(
- responseProcessors={ThymeleafViewRenderer.class}
+ responseProcessors={ThymeleafViewRenderer.class},
+ mergeResponseProcessorsIntoHost=true
)
@SuppressWarnings({
"java:S1192" // Duplicate string literals are Thymeleaf MIME type strings and template attribute keys; intentional
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/Rest.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/Rest.java
index a0c8de9f61..16fb24b791 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/Rest.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/Rest.java
@@ -363,6 +363,37 @@ public @interface Rest {
*/
Mixin[] mixinDefs() default {};
+ /**
+ * Mixin-declared opt-in: fold this class's own {@link #responseProcessors() responseProcessors} into the
+ * <b>host</b> resource's chain whenever this class is composed as a mixin via a plain
+ * {@link #mixins() @Rest(mixins=...)} reference.
+ *
+ * <p>
+ * By default ({@code false}) a mixin's {@code responseProcessors} apply only to the mixin's own endpoints
+ * — a host's own {@code @RestOp} methods see only the host's chain (the standard {@link #mixins() mixin}
+ * inheritance rule "host's chain runs first, then the mixin's appended; host endpoints see only the host's
+ * chain"). Setting this to {@code true} <b>on the mixin class itself</b> makes a plain
+ * {@code @Rest(mixins=ThisClass.class)} reference additionally append this class's own
+ * {@code responseProcessors} to the end of the host's own chain, so the host's own endpoints pick them up too.
+ *
+ * <p>
+ * This is the mixin-declared, response-processor-scoped counterpart to
+ * {@link Mixin#mergeIntoHost() @Mixin(mergeIntoHost=true)} (which is host-declared and folds <i>all</i>
+ * list-shaped attributes). Unlike {@code mergeIntoHost}, this directive lives with the mixin and folds
+ * <b>only</b> {@code responseProcessors} — never {@code guards}, {@code serializers}, or any other
+ * list-shaped attribute. It is intended for view-renderer mixins (e.g. {@code FreemarkerMixin}) so that
+ * declaring the mixin is enough to route the host's own {@code View} returns through the renderer.
+ *
+ * <p>
+ * Strictly opt-in and non-silent: it has no effect for a mixin that leaves it {@code false}, so existing
+ * mixins keep today's scoping exactly. Same-class de-duplication applies, so a response processor the host
+ * already declares is not added twice.
+ *
+ * @return The annotation value.
+ * @since 10.0.0
+ */
+ boolean mergeResponseProcessorsIntoHost() default false;
+
/**
* Client version header.
*
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestAnnotation.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestAnnotation.java
index b654d6f7c1..1be09c9ca3 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestAnnotation.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestAnnotation.java
@@ -80,6 +80,7 @@ public class RestAnnotation {
private Child[] childrenDefs = {};
private Class<?>[] mixins = {};
private Mixin[] mixinDefs = {};
+ private boolean mergeResponseProcessorsIntoHost;
private Class<?>[] parsers = {};
private Swagger swagger = SwaggerAnnotation.DEFAULT;
private String disableContentParam = "";
@@ -250,6 +251,17 @@ public class RestAnnotation {
return this;
}
+ /**
+ * Sets the {@link Rest#mergeResponseProcessorsIntoHost()} property on this annotation.
+ *
+ * @param value The new value for this property.
+ * @return This object.
+ */
+ public Builder mergeResponseProcessorsIntoHost(boolean value) {
+ mergeResponseProcessorsIntoHost = value;
+ return this;
+ }
+
/**
* Sets the {@link Rest#clientVersionHeader()} property on this annotation.
*
@@ -821,6 +833,7 @@ public class RestAnnotation {
private final Child[] childrenDefs;
private final Class<?>[] mixins;
private final Mixin[] mixinDefs;
+ private final boolean mergeResponseProcessorsIntoHost;
private final Class<?>[] parsers;
private final Swagger swagger;
private final String disableContentParam;
@@ -878,6 +891,7 @@ public class RestAnnotation {
childrenDefs = cp(b.childrenDefs);
mixins = cp(b.mixins);
mixinDefs = cp(b.mixinDefs);
+ mergeResponseProcessorsIntoHost = b.mergeResponseProcessorsIntoHost;
clientVersionHeader = b.clientVersionHeader;
config = b.config;
eagerInit = b.eagerInit;
@@ -976,6 +990,11 @@ public class RestAnnotation {
return mixinDefs;
}
+ @Override /* Overridden from Rest */
+ public boolean mergeResponseProcessorsIntoHost() {
+ return mergeResponseProcessorsIntoHost;
+ }
+
@Override /* Overridden from Rest */
public String clientVersionHeader() {
return clientVersionHeader;
diff --git a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestContext.java b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestContext.java
index a3a74d4d52..9a99f51e7c 100644
--- a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestContext.java
+++ b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/server/RestContext.java
@@ -3558,10 +3558,19 @@ public class RestContext extends Context {
// Opt-in @Mixin(mergeIntoHost=true) directive: for a host context and a list-shaped property, append the
// adopted mixin(s)' own @Rest contributions AFTER the host's chain (parent-to-child), so the host's own
// endpoints pick up the mixin's list-shaped attributes. Default behavior (no opted-in mixin) is unchanged.
- if (! isMixinContextField() && MERGEABLE_LIST_PROPERTIES.contains(name)) {
- var merged = mergeIntoHostMixinAnnotations.get();
- if (! merged.isEmpty())
- return Stream.concat(hostStream, merged.stream());
+ if (! isMixinContextField()) {
+ if (MERGEABLE_LIST_PROPERTIES.contains(name)) {
+ var merged = mergeIntoHostMixinAnnotations.get();
+ if (! merged.isEmpty())
+ hostStream = Stream.concat(hostStream, merged.stream());
+ }
+ // Mixin-declared @Rest(mergeResponseProcessorsIntoHost=true) opt-in: fold the opted-in mixin's OWN response
+ // processors into the host's chain — response-processor-scoped only (never other list-shaped attributes).
+ if (PROPERTY_responseProcessors.equals(name)) {
+ var mergedRp = mergeResponseProcessorsIntoHostMixinAnnotations.get();
+ if (! mergedRp.isEmpty())
+ hostStream = Stream.concat(hostStream, mergedRp.stream());
+ }
}
return hostStream;
}
@@ -3592,6 +3601,40 @@ public class RestContext extends Context {
return u(out);
});
+ /**
+ * The OWN {@code @Rest} annotation chains (parent-to-child, framework {@code DefaultConfig} entries excluded) of any
+ * mixin that opts into folding its response processors into the host via
+ * {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)} on its own class,
+ * appended by {@link #getRestAnnotationsForProperty(String)} for the {@code responseProcessors} property only so the
+ * mixin's {@code responseProcessors} fold into the host's own chain under a plain {@link Rest#mixins() mixins=}
+ * reference.
+ *
+ * <p>
+ * This is the mixin-declared, response-processor-scoped counterpart to the host-declared
+ * {@link Mixin#mergeIntoHost() @Mixin(mergeIntoHost=true)} directive handled by
+ * {@link #mergeIntoHostMixinAnnotations}: it folds <b>only</b> {@code responseProcessors}, never other list-shaped
+ * attributes. Empty for mixin sub-contexts and for hosts with no opted-in mixins — keeping the default (drop)
+ * behavior for every mixin that does not declare the opt-in. Built once at memoizer-init time (zero per-request
+ * cost).
+ */
+ private final Memoizer<List<AnnotationInfo<Rest>>> mergeResponseProcessorsIntoHostMixinAnnotations = memoizer(() -> {
+ if (isMixinContextField())
+ return List.of();
+ var out = new ArrayList<AnnotationInfo<Rest>>();
+ for (var rm : getResolvedMixins()) {
+ if (rm.type() == resourceClass())
+ continue;
+ // Fold in the mixin class's OWN @Rest chain (parent-to-child), excluding the framework DefaultConfig
+ // entries, but only when the mixin's own @Rest declares the mergeResponseProcessorsIntoHost opt-in.
+ var mixinRest = rstream(getAnnotationProvider().find(Rest.class, ClassInfo.of(rm.type())))
+ .filter(ai -> ! (ai.getAnnotatable() instanceof ClassInfo ci && DefaultConfig.class.equals(ci.inner())))
+ .toList();
+ if (mixinRest.stream().anyMatch(ai -> ai.inner().mergeResponseProcessorsIntoHost()))
+ out.addAll(mixinRest);
+ }
+ return u(out);
+ });
+
/**
* For a {@linkplain #isMixinContext() mixin sub-context}, returns the <b>host</b> resource class's
* class-level annotation infos (host class chain, in parent-to-child order) so a mixin operation can
diff --git a/juneau-rest/juneau-rest-server/src/test/java/org/apache/juneau/rest/server/MixinResponseProcessorFold_Test.java b/juneau-rest/juneau-rest-server/src/test/java/org/apache/juneau/rest/server/MixinResponseProcessorFold_Test.java
new file mode 100644
index 0000000000..700daf70fe
--- /dev/null
+++ b/juneau-rest/juneau-rest-server/src/test/java/org/apache/juneau/rest/server/MixinResponseProcessorFold_Test.java
@@ -0,0 +1,139 @@
+/*
+ * 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.juneau.rest.server;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.io.*;
+import java.util.*;
+
+import org.apache.juneau.http.response.*;
+import org.apache.juneau.rest.server.processor.*;
+import org.junit.jupiter.api.*;
+
+/**
+ * Verifies the mixin-declared {@link Rest#mergeResponseProcessorsIntoHost() @Rest(mergeResponseProcessorsIntoHost=true)}
+ * opt-in: a mixin that declares it on its own class has its {@code responseProcessors} folded into the host's own chain
+ * under a plain {@link Rest#mixins() @Rest(mixins=...)} reference, while a mixin that does NOT declare it keeps today's
+ * isolated scoping (the non-silent contract).
+ *
+ * <p>
+ * This is the mixin-side, response-processor-scoped counterpart to
+ * {@code MixinInheritance_ResponseProcessors_Test} (a02/a04) in {@code juneau-integration-tests}, exercised here at the
+ * {@link RestContext} level without a mock client so it runs inside {@code juneau-rest-server}'s own test suite.
+ *
+ * @since 10.0.0
+ */
+class MixinResponseProcessorFold_Test extends org.apache.juneau.TestBase {
+
+ //-----------------------------------------------------------------------------------------------------------
+ // Fixtures
+ //-----------------------------------------------------------------------------------------------------------
+
+ public static class HostRp1 implements ResponseProcessor {
+ @Override public int process(RestOpSession s) throws IOException, NotAcceptable, BasicHttpException { return NEXT; }
+ }
+
+ public static class MixinRp1 implements ResponseProcessor {
+ @Override public int process(RestOpSession s) throws IOException, NotAcceptable, BasicHttpException { return NEXT; }
+ }
+
+ /** Opted-in mixin: declares the response-processor fold on its own class. */
+ @Rest(responseProcessors={MixinRp1.class}, mergeResponseProcessorsIntoHost=true)
+ public static class M_OptedIn {
+ @RestGet(path="/my") public String my() { return "my"; }
+ }
+
+ /** Non-opted-in mixin: same response processor, but no fold opt-in (regression guard for the non-silent contract). */
+ @Rest(responseProcessors={MixinRp1.class})
+ public static class M_NotOptedIn {
+ @RestGet(path="/my") public String my() { return "my"; }
+ }
+
+ @Rest(responseProcessors={HostRp1.class}, mixins={M_OptedIn.class})
+ public static class HostWithOptedInMixin {
+ @RestGet(path="/h") public String h() { return "h"; }
+ }
+
+ @Rest(responseProcessors={HostRp1.class}, mixins={M_NotOptedIn.class})
+ public static class HostWithNonOptedInMixin {
+ @RestGet(path="/h") public String h() { return "h"; }
+ }
+
+ static RestContext.Args argsOf(Class<?> resourceClass, java.util.function.Supplier<?> supplier) {
+ return new RestContext.Args(resourceClass, null, null, supplier, null, null, null, null, null, null);
+ }
+
+ private static List<Class<?>> classesOf(ResponseProcessor[] rps) {
+ var l = new ArrayList<Class<?>>(rps.length);
+ for (var rp : rps) l.add(rp.getClass());
+ return l;
+ }
+
+ //-----------------------------------------------------------------------------------------------------------
+ // a - opt-in folds the mixin's response processor into the host chain
+ //-----------------------------------------------------------------------------------------------------------
+
+ @Test void a01_optedInMixin_foldsResponseProcessorIntoHostChain() throws Exception {
+ var hostCtx = new RestContext(argsOf(HostWithOptedInMixin.class, HostWithOptedInMixin::new));
+ var hostRps = classesOf(hostCtx.getResponseProcessors());
+
+ assertTrue(hostRps.contains(MixinRp1.class),
+ "Host must fold in the opted-in mixin's MixinRp1 under a plain mixins= reference");
+ assertTrue(hostRps.contains(HostRp1.class),
+ "Host must still register its own HostRp1");
+
+ var mixinCtx = hostCtx.getMixinContexts().get(M_OptedIn.class);
+ assertNotNull(mixinCtx);
+ assertTrue(classesOf(mixinCtx.getResponseProcessors()).contains(MixinRp1.class),
+ "Mixin endpoint must still have its own MixinRp1");
+ }
+
+ //-----------------------------------------------------------------------------------------------------------
+ // b - non-opted-in mixin keeps today's isolated scoping (non-silent contract)
+ //-----------------------------------------------------------------------------------------------------------
+
+ @Test void b01_nonOptedInMixin_keepsIsolatedScoping() throws Exception {
+ var hostCtx = new RestContext(argsOf(HostWithNonOptedInMixin.class, HostWithNonOptedInMixin::new));
+ var hostRps = classesOf(hostCtx.getResponseProcessors());
+
+ assertFalse(hostRps.contains(MixinRp1.class),
+ "Host must NOT have MixinRp1 — a mixin without the opt-in stays scoped to its own endpoints");
+ assertTrue(hostRps.contains(HostRp1.class),
+ "Host must still register its own HostRp1");
+
+ var mixinCtx = hostCtx.getMixinContexts().get(M_NotOptedIn.class);
+ assertNotNull(mixinCtx);
+ assertTrue(classesOf(mixinCtx.getResponseProcessors()).contains(MixinRp1.class),
+ "Mixin endpoint must still have its own MixinRp1 via its own @Rest(responseProcessors=)");
+ }
+
+ //-----------------------------------------------------------------------------------------------------------
+ // c - ordering / precedence: the host's own processor precedes the folded mixin processor
+ //-----------------------------------------------------------------------------------------------------------
+
+ @Test void c01_foldedProcessorAppendedAfterHostChain() throws Exception {
+ var hostCtx = new RestContext(argsOf(HostWithOptedInMixin.class, HostWithOptedInMixin::new));
+ var hostRps = classesOf(hostCtx.getResponseProcessors());
+
+ var hostIdx = hostRps.indexOf(HostRp1.class);
+ var mixinIdx = hostRps.indexOf(MixinRp1.class);
+ assertTrue(hostIdx >= 0 && mixinIdx >= 0, "Both processors must be present");
+ assertTrue(hostIdx < mixinIdx,
+ "Host's own HostRp1 must precede the folded MixinRp1 (append semantics)");
+ }
+}
diff --git a/juneau-sc/juneau-sc-server/src/main/java/org/apache/juneau/server/config/repository/ConfigItem.java b/juneau-sc/juneau-sc-server/src/main/java/org/apache/juneau/server/config/repository/ConfigItem.java
index 61762ba263..0d5eafc5e9 100644
--- a/juneau-sc/juneau-sc-server/src/main/java/org/apache/juneau/server/config/repository/ConfigItem.java
+++ b/juneau-sc/juneau-sc-server/src/main/java/org/apache/juneau/server/config/repository/ConfigItem.java
@@ -46,6 +46,7 @@ public class ConfigItem {
* Sets the configuration value.
*
* @param value The value to set.
+ * @return This object.
*/
- public void setValue(String value) { this.value = value; }
+ public ConfigItem setValue(String value) { this.value = value; return this; }
}
\ No newline at end of file