gnodet commented on code in PR #22769:
URL: https://github.com/apache/camel/pull/22769#discussion_r3147112984
##########
core/camel-core-model/src/main/java/org/apache/camel/model/AggregateDefinition.java:
##########
@@ -1004,6 +1016,16 @@ public AggregateDefinition optimisticLocking() {
return this;
}
+ /**
+ * When optimistic locking is enabled, retries happen synchronously in the
same thread instead of being scheduled on
+ * a background thread. This preserves transaction context for
repositories that require single-thread transactional
+ * guarantees.
+ */
Review Comment:
Nice Javadoc. Consider adding a note that this option only takes effect when
`optimisticLocking` is also enabled:
```suggestion
/**
* When optimistic locking is enabled, retries happen synchronously in
the same thread instead of being scheduled on
* a background thread. This preserves transaction context for
repositories that require single-thread transactional
* guarantees. Only takes effect when {@link #optimisticLocking()} is
also enabled.
*/
```
##########
core/camel-core-model/src/main/java/org/apache/camel/model/AggregateDefinition.java:
##########
@@ -90,6 +90,9 @@ public class AggregateDefinition extends
OutputDefinition<AggregateDefinition>
@Metadata(javaType = "java.lang.Boolean")
private String optimisticLocking;
@XmlAttribute
+ @Metadata(label = "advanced", javaType = "java.lang.Boolean", defaultValue
= "false")
+ private String syncOptimisticRetry;
Review Comment:
Nit / naming: consider `optimisticLockingSyncRetry` (or
`optimisticLockRetrySync`) to group it visually with the existing
`optimisticLocking` field in docs and configuration. `syncOptimisticRetry`
reads a bit ambiguously ("synchronize" vs "synchronous"). Not a blocker — just
a readability suggestion.
##########
core/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateOptimisticLockSyncRetryTest.java:
##########
@@ -0,0 +1,117 @@
+/*
+ * 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.camel.processor.aggregator;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ContextTestSupport;
+import org.apache.camel.Exchange;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.processor.BodyInAggregatingStrategy;
+import org.apache.camel.processor.aggregate.MemoryAggregationRepository;
+import org.apache.camel.processor.aggregate.OptimisticLockRetryPolicy;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Tests that optimistic locking retries happen synchronously in the same
thread when syncOptimisticRetry is enabled.
+ */
+public class AggregateOptimisticLockSyncRetryTest extends ContextTestSupport {
+
+ private static final int FAIL_FIRST_N_ATTEMPTS = 3;
+
+ private final AtomicInteger addCounter = new AtomicInteger();
+ private volatile String aggregateThreadName;
+
+ /**
+ * Repository that throws OptimisticLockingException for the first N
attempts, then succeeds.
+ */
+ private final MemoryAggregationRepository repository = new
MemoryAggregationRepository(true) {
+ @Override
+ public Exchange add(CamelContext camelContext, String key, Exchange
oldExchange, Exchange newExchange) {
+ int count = addCounter.incrementAndGet();
+ // Record the thread name on every attempt
+ aggregateThreadName = Thread.currentThread().getName();
+ if (count <= FAIL_FIRST_N_ATTEMPTS) {
+ throw new OptimisticLockingException();
+ }
+ return super.add(camelContext, key, oldExchange, newExchange);
+ }
+ };
+
+ @Test
+ public void testSyncRetryHappensInSameThread() throws Exception {
+ MockEndpoint mock = getMockEndpoint("mock:result");
+ mock.expectedMessageCount(1);
+
+ String callerThread = Thread.currentThread().getName();
+
+ template.sendBodyAndHeader("direct:start", "A", "id", 1);
+ template.sendBodyAndHeader("direct:start", "B", "id", 1);
+
+ mock.assertIsSatisfied();
+
+ // The repository should have been called more than
FAIL_FIRST_N_ATTEMPTS times
+ // (the first N fail, then succeed)
+ assertTrue(addCounter.get() > FAIL_FIRST_N_ATTEMPTS,
+ "Expected more than " + FAIL_FIRST_N_ATTEMPTS + " attempts,
got " + addCounter.get());
+
+ // Since syncOptimisticRetry is enabled, the retry should happen in a
Camel thread
+ // (the route's thread), NOT in the AggregateOptimisticLockingExecutor
thread pool.
+ // The key assertion is that the thread name does NOT contain the
async executor name.
+ if (aggregateThreadName != null) {
+
assertFalse(aggregateThreadName.contains("AggregateOptimisticLockingExecutor"),
+ "Expected synchronous retry but found async executor
thread: " + aggregateThreadName);
+ }
+ }
+
+ @Test
+ public void testSyncRetryCompletes() throws Exception {
+ MockEndpoint mock = getMockEndpoint("mock:result");
+ mock.expectedBodiesReceived("A+B");
+
+ template.sendBodyAndHeader("direct:start", "A", "id", 1);
+
+ // Reset counter so next message triggers failures and retries
+ addCounter.set(0);
+ template.sendBodyAndHeader("direct:start", "B", "id", 1);
+
+ mock.assertIsSatisfied();
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ from("direct:start")
+ .aggregate(header("id"), new
BodyInAggregatingStrategy())
+ .aggregationRepository(repository)
+ .optimisticLocking()
+ .syncOptimisticRetry()
+ .optimisticLockRetryPolicy(
+ new
OptimisticLockRetryPolicy().maximumRetries(10).retryDelay(0))
Review Comment:
Good test coverage overall. One observation: `retryDelay(0)` means
`doDelay()` returns immediately without sleeping, so the `Thread.sleep` +
`InterruptedException` code path isn't exercised.
Consider adding a small test with a nonzero delay (e.g., `retryDelay(10)`)
to verify the synchronous sleep actually happens on the calling thread under
realistic conditions. A test that interrupts the thread during retry would
further strengthen coverage of the `InterruptedException` branch. Not a
blocker, but would increase confidence.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
