diff --git a/experimental/test/src/test/java/io/serverlessworkflow/fluent/test/FuncTryCatchTest.java b/experimental/test/src/test/java/io/serverlessworkflow/fluent/test/FuncTryCatchTest.java index a97a6755c..686c90fda 100644 --- a/experimental/test/src/test/java/io/serverlessworkflow/fluent/test/FuncTryCatchTest.java +++ b/experimental/test/src/test/java/io/serverlessworkflow/fluent/test/FuncTryCatchTest.java @@ -32,6 +32,7 @@ */ import static io.serverlessworkflow.fluent.func.dsl.FuncDSL.function; +import static io.serverlessworkflow.fluent.func.dsl.FuncDSL.tasks; import static io.serverlessworkflow.fluent.func.dsl.FuncDSL.tryCatch; import static io.serverlessworkflow.fluent.test.TestSerializationUtils.writeAndReadInMemory; import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat; @@ -45,6 +46,8 @@ import io.serverlessworkflow.impl.WorkflowModel; import java.io.IOException; import java.util.List; +import java.util.concurrent.atomic.AtomicInteger; +import org.assertj.core.api.Assertions; import org.junit.jupiter.api.Test; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -61,6 +64,8 @@ public class FuncTryCatchTest { private static final String ORDER_002 = "ORDER#002"; private static final String ORDER_003 = "ORDER#003"; + private static final String TRANSIENT_ERROR = "ERR_TRANSIENT"; + @Test void booking_compensation_dsl() throws IOException { @@ -472,6 +477,129 @@ void testCatchAll_WithAnyError() throws IOException { } } + @Test + void testRetryWithoutBackoff() { + AtomicInteger attempts = new AtomicInteger(); + Workflow workflow = + FuncWorkflowBuilder.workflow() + .tasks( + tryCatch( + "tryTask", + t -> + t.tryCatch( + tasks( + function( + "riskyTask", + (String input) -> { + if (attempts.incrementAndGet() <= 2) { + throw new WorkflowException( + WorkflowError.error(TRANSIENT_ERROR, 503).build()); + } + return "success"; + }, + String.class))) + .catchHandler( + handler -> + handler + .errorsWith(err -> err.type(TRANSIENT_ERROR)) + .retry( + retry -> + retry + .delay(d -> d.milliseconds(10)) + .limit( + limit -> limit.attempt(a -> a.count(3))))))) + .build(); + + try (WorkflowApplication application = WorkflowApplication.builder().build()) { + WorkflowDefinition definition = application.workflowDefinition(workflow); + WorkflowModel result = definition.instance("input").start().join(); + Assertions.assertThat(result.asText()).hasValue("success"); + Assertions.assertThat(attempts.get()).isEqualTo(3); + } + } + + @Test + void testRetryWithoutLimit() { + AtomicInteger attempts = new AtomicInteger(); + Workflow workflow = + FuncWorkflowBuilder.workflow() + .tasks( + tryCatch( + "tryTask", + t -> + t.tryCatch( + tasks( + function( + "riskyTask", + (String input) -> { + if (attempts.incrementAndGet() <= 2) { + throw new WorkflowException( + WorkflowError.error(TRANSIENT_ERROR, 503).build()); + } + return "success"; + }, + String.class))) + .catchHandler( + handler -> + handler + .errorsWith(err -> err.type(TRANSIENT_ERROR)) + .retry( + retry -> + retry + .delay(d -> d.milliseconds(10)) + .backoff(b -> b.constant("c", "10")))))) + .build(); + + try (WorkflowApplication application = WorkflowApplication.builder().build()) { + WorkflowDefinition definition = application.workflowDefinition(workflow); + WorkflowModel result = definition.instance("input").start().join(); + Assertions.assertThat(result.asText()).hasValue("success"); + Assertions.assertThat(attempts.get()).isEqualTo(3); + } + } + + @Test + void testRetryWithoutDelay() { + AtomicInteger attempts = new AtomicInteger(); + + Workflow workflow = + FuncWorkflowBuilder.workflow() + .tasks( + tryCatch( + "tryTask", + t -> + t.tryCatch( + tasks( + function( + "riskyTask", + (String input) -> { + if (attempts.incrementAndGet() <= 2) { + throw new WorkflowException( + WorkflowError.error(TRANSIENT_ERROR, 503).build()); + } + return "success"; + }, + String.class))) + .catchHandler( + handler -> + handler + .errorsWith(err -> err.type(TRANSIENT_ERROR)) + .retry( + retry -> + retry + .backoff(b -> b.constant("c", "10")) + .limit( + limit -> limit.attempt(a -> a.count(3))))))) + .build(); + + try (WorkflowApplication application = WorkflowApplication.builder().build()) { + WorkflowDefinition definition = application.workflowDefinition(workflow); + WorkflowModel result = definition.instance("input").start().join(); + Assertions.assertThat(result.asText()).hasValue("success"); + Assertions.assertThat(attempts.get()).isEqualTo(3); + } + } + public String reserveStock(String order) { log.info("Reserving stock for order: {}", order); if (order.equals(ORDER_001)) { diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContext.java b/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContext.java index 279f45337..428bc3ab0 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContext.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContext.java @@ -37,10 +37,10 @@ public class TaskContext implements TaskContextData { private WorkflowModel rawOutput; private Instant completedAt; private TransitionInfo transition; - private short retryAttempt; + private int retryAttempt; private int iteration; private AuthorizationDescriptor authorization; - private Optional tryRetryCount = Optional.empty(); + private Optional tryRetryCount = Optional.empty(); public TaskContext( WorkflowModel input, @@ -71,7 +71,7 @@ private TaskContext( this.output = output; this.rawOutput = rawOutput; this.retryAttempt = - parentContext.map(ctx -> ctx.tryRetryCount.orElse(ctx.retryAttempt())).orElse((short) 0); + parentContext.map(ctx -> ctx.tryRetryCount.orElse(ctx.retryAttempt())).orElse(0); this.contextVariables = parentContext.map(p -> new HashMap<>(p.contextVariables)).orElseGet(HashMap::new); } @@ -173,19 +173,19 @@ public boolean isCompleted() { } @Override - public short retryAttempt() { + public int retryAttempt() { return retryAttempt; } - public void retryAttempt(short retryAttempt) { + public void retryAttempt(int retryAttempt) { this.retryAttempt = retryAttempt; } - public void tryRetryCount(short tryRetryCount) { + public void tryRetryCount(int tryRetryCount) { this.tryRetryCount = Optional.of(tryRetryCount); } - public Optional tryRetryCount() { + public Optional tryRetryCount() { return tryRetryCount; } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContextData.java b/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContextData.java index 2e735f63c..fa01ae560 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContextData.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/TaskContextData.java @@ -40,5 +40,5 @@ public interface TaskContextData { int iteration(); - short retryAttempt(); + int retryAttempt(); } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/WorkflowUtils.java b/impl/core/src/main/java/io/serverlessworkflow/impl/WorkflowUtils.java index 16979fc1f..5ff4ea0d6 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/WorkflowUtils.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/WorkflowUtils.java @@ -187,30 +187,36 @@ public static boolean whenExceptTest( && exceptFilter.map(w -> !w.test(workflow, taskContext, model)).orElse(true); } + private static final class ZeroDelayResolverHolder { + private static final WorkflowValueResolver ZERO_DELAY_RESOLVER = + (w, t, f) -> Duration.ZERO; + } + public static WorkflowValueResolver fromTimeoutAfter( WorkflowApplication application, TimeoutAfter timeout) { - if (timeout.getDurationExpression() != null) { - return (w, f, t) -> - Duration.parse( - application - .expressionFactory() - .resolveString(ExpressionDescriptor.from(timeout.getDurationExpression())) - .apply(w, f, t)); - } else if (timeout.getDurationLiteral() != null) { - Duration duration = Duration.parse(timeout.getDurationLiteral()); - return (w, f, t) -> duration; - } else if (timeout.getDurationInline() != null) { - DurationInline inlineDuration = timeout.getDurationInline(); - return (w, t, f) -> - Duration.ofDays(inlineDuration.getDays()) - .plus( - Duration.ofHours(inlineDuration.getHours()) - .plus(Duration.ofMinutes(inlineDuration.getMinutes())) - .plus(Duration.ofSeconds(inlineDuration.getSeconds())) - .plus(Duration.ofMillis(inlineDuration.getMilliseconds()))); - } else { - return (w, t, f) -> Duration.ZERO; + if (timeout != null) { + if (timeout.getDurationExpression() != null) { + return (w, f, t) -> + Duration.parse( + application + .expressionFactory() + .resolveString(ExpressionDescriptor.from(timeout.getDurationExpression())) + .apply(w, f, t)); + } else if (timeout.getDurationLiteral() != null) { + Duration duration = Duration.parse(timeout.getDurationLiteral()); + return (w, f, t) -> duration; + } else if (timeout.getDurationInline() != null) { + DurationInline inlineDuration = timeout.getDurationInline(); + return (w, t, f) -> + Duration.ofDays(inlineDuration.getDays()) + .plus( + Duration.ofHours(inlineDuration.getHours()) + .plus(Duration.ofMinutes(inlineDuration.getMinutes())) + .plus(Duration.ofSeconds(inlineDuration.getSeconds())) + .plus(Duration.ofMillis(inlineDuration.getMilliseconds()))); + } } + return ZeroDelayResolverHolder.ZERO_DELAY_RESOLVER; } public static Optional> getTaskTimeout( diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/TryExecutor.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/TryExecutor.java index 00e765d5e..7ef9c64d7 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/TryExecutor.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/TryExecutor.java @@ -19,6 +19,7 @@ import io.serverlessworkflow.api.types.ErrorFilter; import io.serverlessworkflow.api.types.Retry; import io.serverlessworkflow.api.types.RetryBackoff; +import io.serverlessworkflow.api.types.RetryLimit; import io.serverlessworkflow.api.types.RetryPolicy; import io.serverlessworkflow.api.types.TaskItem; import io.serverlessworkflow.api.types.TryTask; @@ -107,25 +108,34 @@ private Optional buildRetryInterval(Retry retry) { protected RetryExecutor buildRetryExecutor(RetryPolicy retryPolicy) { return new DefaultRetryExecutor( - retryPolicy.getLimit().getAttempt().getCount(), + resolveMaxAttempts(retryPolicy.getLimit()), buildIntervalFunction(retryPolicy), WorkflowUtils.optionalPredicate(application, retryPolicy.getWhen()), WorkflowUtils.optionalPredicate(application, retryPolicy.getExceptWhen())); } + private static int resolveMaxAttempts(RetryLimit limit) { + return limit != null && limit.getAttempt() != null + ? limit.getAttempt().getCount() + : Integer.MAX_VALUE - 1; + } + private RetryIntervalFunction buildIntervalFunction(RetryPolicy retryPolicy) { RetryBackoff backoff = retryPolicy.getBackoff(); - if (backoff.getConstantBackoff() != null) { - return new ConstantRetryIntervalFunction( - application, retryPolicy.getDelay(), retryPolicy.getJitter()); - } else if (backoff.getLinearBackoff() != null) { - return new LinearRetryIntervalFunction( - application, retryPolicy.getDelay(), retryPolicy.getJitter()); - } else if (backoff.getExponentialBackOff() != null) { - return new ExponentialRetryIntervalFunction( - application, retryPolicy.getDelay(), retryPolicy.getJitter()); + if (backoff != null) { + if (backoff.getConstantBackoff() != null) { + return new ConstantRetryIntervalFunction( + application, retryPolicy.getDelay(), retryPolicy.getJitter()); + } else if (backoff.getLinearBackoff() != null) { + return new LinearRetryIntervalFunction( + application, retryPolicy.getDelay(), retryPolicy.getJitter()); + } else if (backoff.getExponentialBackOff() != null) { + return new ExponentialRetryIntervalFunction( + application, retryPolicy.getDelay(), retryPolicy.getJitter()); + } } - throw new IllegalStateException("A backoff strategy should be set"); + return new ConstantRetryIntervalFunction( + application, retryPolicy.getDelay(), retryPolicy.getJitter()); } @Override diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/AbstractRetryIntervalFunction.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/AbstractRetryIntervalFunction.java index 8779f444d..df8ed903c 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/AbstractRetryIntervalFunction.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/AbstractRetryIntervalFunction.java @@ -49,21 +49,24 @@ public Duration apply( WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel model, - short numAttempts) { + int numAttempts) { Duration delay = delayResolver.apply(workflowContext, taskContext, model); Duration minJittering = minJitteringResolver .map(min -> min.apply(workflowContext, taskContext, model)) .orElse(Duration.ZERO); - Duration maxJittering = + Duration result = calcDelay(delay, numAttempts).plus(minJittering); + long maxJittering = maxJitteringResolver .map(max -> max.apply(workflowContext, taskContext, model)) - .orElse(Duration.ZERO); - return calcDelay(delay, numAttempts) - .plus( - Duration.ofMillis( - (long) (minJittering.toMillis() + Math.random() * maxJittering.toMillis()))); + .orElse(Duration.ZERO) + .toMillis(); + long diff = maxJittering - minJittering.toMillis(); + if (diff > 0) { + result = result.plus(Duration.ofMillis(Math.round(Math.random() * diff))); + } + return result; } - protected abstract Duration calcDelay(Duration delay, short numAttempts); + protected abstract Duration calcDelay(Duration delay, int numAttempts); } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ConstantRetryIntervalFunction.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ConstantRetryIntervalFunction.java index e7746fbbf..28ebdc704 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ConstantRetryIntervalFunction.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ConstantRetryIntervalFunction.java @@ -28,7 +28,7 @@ public ConstantRetryIntervalFunction( } @Override - protected Duration calcDelay(Duration delay, short numAttempts) { + protected Duration calcDelay(Duration delay, int numAttempts) { return delay; } } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/DefaultRetryExecutor.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/DefaultRetryExecutor.java index f31ae0ab1..2c6d59f66 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/DefaultRetryExecutor.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/DefaultRetryExecutor.java @@ -46,7 +46,7 @@ public DefaultRetryExecutor( @Override public Optional> retry( WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel model) { - short numAttempts = taskContext.tryRetryCount().orElseThrow(); + int numAttempts = taskContext.tryRetryCount().orElseThrow(); if (numAttempts++ < maxAttempts && WorkflowUtils.whenExceptTest( whenFilter, exceptFilter, workflowContext, taskContext, model)) { @@ -62,7 +62,7 @@ public Optional> retry( @Override public void init(WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel model) { if (taskContext.tryRetryCount().isEmpty()) { - taskContext.tryRetryCount((short) 0); + taskContext.tryRetryCount(0); } } } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ExponentialRetryIntervalFunction.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ExponentialRetryIntervalFunction.java index fff1d8c83..be50d3f0d 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ExponentialRetryIntervalFunction.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/ExponentialRetryIntervalFunction.java @@ -22,13 +22,16 @@ public class ExponentialRetryIntervalFunction extends AbstractRetryIntervalFunction { + // 2^33 will be several years, which I think is too high as delay + private static final int MAX_EXPONENTIAL_RETRY = 32; + public ExponentialRetryIntervalFunction( WorkflowApplication appl, TimeoutAfter delay, RetryPolicyJitter jitter) { super(appl, delay, jitter); } @Override - protected Duration calcDelay(Duration delay, short numAttempts) { - return delay.multipliedBy(1 << numAttempts); + protected Duration calcDelay(Duration delay, int numAttempts) { + return delay.multipliedBy(1L << Math.min(numAttempts, MAX_EXPONENTIAL_RETRY)); } } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/LinearRetryIntervalFunction.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/LinearRetryIntervalFunction.java index f2713cf46..1e645c548 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/LinearRetryIntervalFunction.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/LinearRetryIntervalFunction.java @@ -28,7 +28,7 @@ public LinearRetryIntervalFunction( } @Override - protected Duration calcDelay(Duration delay, short numAttempts) { + protected Duration calcDelay(Duration delay, int numAttempts) { return delay.multipliedBy(numAttempts); } } diff --git a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/RetryIntervalFunction.java b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/RetryIntervalFunction.java index b0e06d926..09ef700a8 100644 --- a/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/RetryIntervalFunction.java +++ b/impl/core/src/main/java/io/serverlessworkflow/impl/executors/retry/RetryIntervalFunction.java @@ -25,5 +25,5 @@ Duration apply( WorkflowContext workflowContext, TaskContext taskContext, WorkflowModel model, - short numAttempts); + int numAttempts); } diff --git a/impl/core/src/test/java/io/serverlessworkflow/impl/WorkflowAdditionalObjectTest.java b/impl/core/src/test/java/io/serverlessworkflow/impl/WorkflowAdditionalObjectTest.java index 0cdc8e3f2..9ba69c060 100644 --- a/impl/core/src/test/java/io/serverlessworkflow/impl/WorkflowAdditionalObjectTest.java +++ b/impl/core/src/test/java/io/serverlessworkflow/impl/WorkflowAdditionalObjectTest.java @@ -59,7 +59,7 @@ public List get() { void testAdditionalObjectBiFunction() { WorkflowContext workflowContext = mock(WorkflowContext.class); TaskContext taskContext = mock(TaskContext.class); - when(taskContext.retryAttempt()).thenReturn((short) 2); + when(taskContext.retryAttempt()).thenReturn(2); final String key = "Dummy_Bifactory"; try (WorkflowApplication appl = WorkflowApplication.builder() diff --git a/impl/persistence/api/src/main/java/io/serverlessworkflow/impl/persistence/RetriedTaskInfo.java b/impl/persistence/api/src/main/java/io/serverlessworkflow/impl/persistence/RetriedTaskInfo.java index 192fdd627..e01130768 100644 --- a/impl/persistence/api/src/main/java/io/serverlessworkflow/impl/persistence/RetriedTaskInfo.java +++ b/impl/persistence/api/src/main/java/io/serverlessworkflow/impl/persistence/RetriedTaskInfo.java @@ -15,4 +15,4 @@ */ package io.serverlessworkflow.impl.persistence; -public record RetriedTaskInfo(short retryAttempt) implements PersistenceTaskInfo {} +public record RetriedTaskInfo(int retryAttempt) implements PersistenceTaskInfo {} diff --git a/impl/persistence/bigmap/src/main/java/io/serverlessworkflow/impl/persistence/bigmap/BytesMapInstanceTransaction.java b/impl/persistence/bigmap/src/main/java/io/serverlessworkflow/impl/persistence/bigmap/BytesMapInstanceTransaction.java index ee91d9eb4..33ce047da 100644 --- a/impl/persistence/bigmap/src/main/java/io/serverlessworkflow/impl/persistence/bigmap/BytesMapInstanceTransaction.java +++ b/impl/persistence/bigmap/src/main/java/io/serverlessworkflow/impl/persistence/bigmap/BytesMapInstanceTransaction.java @@ -124,9 +124,9 @@ protected byte[] marshallTaskRetried( WorkflowContextData workflowContext, TaskContext taskContext) { ByteArrayOutputStream bytes = new ByteArrayOutputStream(); try (WorkflowOutputBuffer writer = factory.output(bytes)) { - writer.writeByte(VERSION_1); + writer.writeByte(VERSION_2); writer.writeEnum(TaskStatus.RETRIED); - writer.writeShort(taskContext.retryAttempt()); + writer.writeInt(taskContext.retryAttempt()); } return bytes.toByteArray(); } @@ -159,7 +159,7 @@ private PersistenceTaskInfo readVersion2(WorkflowInputBuffer buffer) { buffer.readBoolean() ? buffer.readString() : null, buffer.readInt()); case RETRIED: - return new RetriedTaskInfo(buffer.readShort()); + return new RetriedTaskInfo(buffer.readInt()); } throw new UnsupportedOperationException("Unknown status " + taskStatus); } diff --git a/impl/persistence/tests/src/main/java/io/serverlessworkflow/impl/persistence/test/AbstractHandlerPersistenceTest.java b/impl/persistence/tests/src/main/java/io/serverlessworkflow/impl/persistence/test/AbstractHandlerPersistenceTest.java index 0314e917f..0cfc77dfa 100644 --- a/impl/persistence/tests/src/main/java/io/serverlessworkflow/impl/persistence/test/AbstractHandlerPersistenceTest.java +++ b/impl/persistence/tests/src/main/java/io/serverlessworkflow/impl/persistence/test/AbstractHandlerPersistenceTest.java @@ -95,7 +95,7 @@ protected TaskContextData completedTaskContext( return taskContext; } - protected TaskContextData retriedTaskContext(WorkflowPosition position, short retryAttempt) { + protected TaskContextData retriedTaskContext(WorkflowPosition position, int retryAttempt) { TaskContext taskContext = mock(TaskContext.class); when(taskContext.position()).thenReturn(position); when(taskContext.retryAttempt()).thenReturn(retryAttempt); @@ -120,7 +120,7 @@ void testWorkflowInstance() throws InterruptedException { app.positionFactory().get().addProperty("do").addIndex(0).addProperty("useExpression"); final WorkflowMutablePosition position2 = app.positionFactory().get().addProperty("do").addIndex(1).addProperty("useExpression"); - final short numRetries = 1; + final int numRetries = 1; final Map completedMap = Map.of("name", "fulanito"); @@ -147,7 +147,7 @@ void testWorkflowInstance() throws InterruptedException { when(parentContext.task()).thenReturn(taskBase); when(updateTContext.parent()).thenReturn(Optional.of(parentContext)); instance.restoreContext(updateWContext, updateTContext); - ArgumentCaptor retryAttempt = ArgumentCaptor.forClass(Short.class); + ArgumentCaptor retryAttempt = ArgumentCaptor.forClass(Integer.class); verify(updateTContext).retryAttempt(retryAttempt.capture()); assertThat(retryAttempt.getValue()).isEqualTo(numRetries); verify(parentContext).tryRetryCount(retryAttempt.capture()); diff --git a/impl/test/src/test/java/io/serverlessworkflow/impl/test/RetryTimeoutTest.java b/impl/test/src/test/java/io/serverlessworkflow/impl/test/RetryTimeoutTest.java index 909e4af61..47898829c 100644 --- a/impl/test/src/test/java/io/serverlessworkflow/impl/test/RetryTimeoutTest.java +++ b/impl/test/src/test/java/io/serverlessworkflow/impl/test/RetryTimeoutTest.java @@ -65,8 +65,8 @@ void tearDown() throws IOException { private class RetryListener implements WorkflowExecutionListener { - private Map taskRetried = new ConcurrentHashMap<>(); - private Map taskCompleted = new ConcurrentHashMap<>(); + private Map taskRetried = new ConcurrentHashMap<>(); + private Map taskCompleted = new ConcurrentHashMap<>(); @Override public void onTaskRetried(TaskRetriedEvent ev) { @@ -78,7 +78,7 @@ public void onTaskCompleted(TaskCompletedEvent ev) { add2Map(taskCompleted, ev); } - private static void add2Map(Map map, TaskEvent ev) { + private static void add2Map(Map map, TaskEvent ev) { TaskContextData taskContext = ev.taskContext(); map.put(taskContext.position().jsonPointer(), taskContext.retryAttempt()); }