Light, fluffy, and always free - The AWS Local Emulator alternative
fix(eventbridge): stop a cron rule deleted or disabled mid-delivery (#4346)
Niels Kootstracd21d58403b3
diff --git a/src/main/java/io/github/hectorvent/floci/services/eventbridge/RuleScheduler.java b/src/main/java/io/github/hectorvent/floci/services/eventbridge/RuleScheduler.javaindex db0150ddf2..dfbe0b4040 100644--- a/src/main/java/io/github/hectorvent/floci/services/eventbridge/RuleScheduler.java+++ b/src/main/java/io/github/hectorvent/floci/services/eventbridge/RuleScheduler.java@@ -13,6 +13,7 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import org.jboss.logging.Logger;+import java.time.Clock;import java.time.ZoneOffset;import java.time.ZonedDateTime;import java.util.List;@@ -29,6 +30,7 @@ public class RuleScheduler implements Resettable {private final ObjectMapper objectMapper;private final String defaultAccountId;private final EventBridgeInvoker invoker;+ private final Clock clock;private final ConcurrentHashMap<String, ScheduleContext> scheduleContexts = new ConcurrentHashMap<>();@Inject@@ -36,10 +38,24 @@ public class RuleScheduler implements Resettable {EmulatorConfig config,ObjectMapper objectMapper,EventBridgeInvoker invoker) {+ this(vertx, config, objectMapper, invoker, Clock.systemUTC());+ }++ /**+ * Test seam: lets cron next-fire computation be exercised deterministically instead+ * of depending on wall-clock time. Production code always goes through the+ * public/{@code @Inject} constructor, which pins the system clock.+ */+ RuleScheduler(Vertx vertx,+ EmulatorConfig config,+ ObjectMapper objectMapper,+ EventBridgeInvoker invoker,+ Clock clock) {this.vertx = vertx;this.objectMapper = objectMapper;this.defaultAccountId = config.defaultAccountId();this.invoker = invoker;+ this.clock = clock;}@PreDestroy@@ -69,7 +85,7 @@ public class RuleScheduler implements Resettable {if (ScheduleExpressionParser.isRateExpression(scheduleExpr)) {startRateScheduler(ruleArn, scheduleExpr, dataSupplier);} else if (ScheduleExpressionParser.isCronExpression(scheduleExpr)) {- scheduleCronFire(ruleArn, scheduleExpr, dataSupplier);+ scheduleCronFire(ruleArn, scheduleExpr, dataSupplier, null);} else {LOG.warnv("Unknown schedule expression format for rule {0}: {1}", ruleArn, scheduleExpr);}@@ -88,22 +104,39 @@ public class RuleScheduler implements Resettable {LOG.debugv("Started rate scheduler for rule {0} with interval {1}ms", ruleArn, intervalMs);}+ /**+ * Arms the next cron fire. {@code previous} is the context of the fire that is re-arming,+ * or {@code null} when the rule is starting.+ */private void scheduleCronFire(String ruleArn, String scheduleExpr,- Supplier<ScheduleData> dataSupplier) {+ Supplier<ScheduleData> dataSupplier, ScheduleContext previous) {long delayMs;try {- delayMs = ScheduleExpressionParser.millisUntilNextFire(scheduleExpr, ZonedDateTime.now());+ delayMs = ScheduleExpressionParser.millisUntilNextFire(scheduleExpr, ZonedDateTime.now(clock));} catch (Exception e) {LOG.warnv("Failed to compute next fire time for rule {0}: {1}", ruleArn, e.getMessage());+ if (previous != null) {+ scheduleContexts.remove(ruleArn, previous);+ }return;}long timerId = vertx.setTimer(delayMs, id -> {tick(dataSupplier);- scheduleContexts.remove(ruleArn);- scheduleCronFire(ruleArn, scheduleExpr, dataSupplier);+ ScheduleContext current = scheduleContexts.get(ruleArn);+ if (current != null && current.timerId() == id) {+ scheduleCronFire(ruleArn, scheduleExpr, dataSupplier, current);+ }});- scheduleContexts.put(ruleArn, new ScheduleContext(timerId, scheduleExpr));+ ScheduleContext next = new ScheduleContext(timerId, scheduleExpr);+ if (previous == null) {+ scheduleContexts.put(ruleArn, next);+ } else if (!scheduleContexts.replace(ruleArn, previous, next)) {+ // DeleteRule, DisableRule or a restart replaced this fire's context while it was+ // delivering. Swapping in one step means a stop is either seen here or cancels next.+ vertx.cancelTimer(timerId);+ return;+ }LOG.debugv("Scheduled cron fire for rule {0} in {1}ms", ruleArn, delayMs);}diff --git a/src/test/java/io/github/hectorvent/floci/services/eventbridge/RuleSchedulerTest.java b/src/test/java/io/github/hectorvent/floci/services/eventbridge/RuleSchedulerTest.javanew file mode 100644index 0000000000..f5426f3b8d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/eventbridge/RuleSchedulerTest.java@@ -0,0 +1,178 @@+package io.github.hectorvent.floci.services.eventbridge;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.eventbridge.model.Rule;+import io.github.hectorvent.floci.services.eventbridge.model.RuleState;+import io.github.hectorvent.floci.services.eventbridge.model.Target;+import io.vertx.core.Handler;+import io.vertx.core.Vertx;+import org.junit.jupiter.api.Test;+import org.mockito.ArgumentCaptor;++import java.time.Clock;+import java.time.Instant;+import java.time.ZoneOffset;+import java.util.List;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.anyLong;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.times;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * Covers the race between an in-flight cron tick and a concurrent DeleteRule/DisableRule:+ * the tick's self-rescheduling must not resurrect a timer for a rule that stopped+ * scheduling (deleted or disabled) while target delivery was still in progress.+ * The timer is driven by hand through a mocked Vertx, so no real time passes.+ */+class RuleSchedulerTest {++ private static final String ACCOUNT = "000000000000";+ private static final String RULE_ARN = "arn:aws:events:us-east-1:000000000000:rule/default/timer-stop-rule";+ private static final String EVERY_MINUTE_CRON = "cron(0/1 * * * ? *)";+ private static final Instant JUST_BEFORE_MINUTE_BOUNDARY = Instant.parse("2026-06-15T12:00:59.000Z");++ @Test+ void deletedRuleDoesNotResurrectCronTimerDuringInFlightTick() {+ Vertx vertx = mock(Vertx.class);+ ArgumentCaptor<Handler<Long>> fire = timerHandlerCaptor();+ when(vertx.setTimer(anyLong(), fire.capture())).thenReturn(1L, 2L);++ AtomicReference<Rule> currentRule = new AtomicReference<>(enabledRule());+ AtomicReference<RuleScheduler> schedulerRef = new AtomicReference<>();+ // AWS DeleteRule lands mid-delivery. EventBridgeService.deleteRule always calls+ // RuleScheduler.stopScheduler before removing the rule; mirror that ordering here.+ StoppingInvoker invoker = new StoppingInvoker(() -> {+ schedulerRef.get().stopScheduler(RULE_ARN);+ currentRule.set(null);+ });+ RuleScheduler scheduler = newScheduler(vertx, invoker);+ schedulerRef.set(scheduler);+ scheduler.startScheduler(RULE_ARN, EVERY_MINUTE_CRON, () -> toScheduleData(currentRule.get()));++ fire.getValue().handle(1L);++ assertEquals(1, invoker.invocationCount());+ verify(vertx, times(1)).setTimer(anyLong(), any());+ assertFalse(scheduler.isRunning(RULE_ARN), "deleted rule must not have its cron timer re-armed");+ }++ @Test+ void disabledRuleDoesNotResurrectCronTimerDuringInFlightTick() {+ Vertx vertx = mock(Vertx.class);+ ArgumentCaptor<Handler<Long>> fire = timerHandlerCaptor();+ when(vertx.setTimer(anyLong(), fire.capture())).thenReturn(1L, 2L);++ Rule rule = enabledRule();+ AtomicReference<RuleScheduler> schedulerRef = new AtomicReference<>();+ // AWS DisableRule lands mid-delivery: the rule stays but flips to DISABLED.+ // EventBridgeService.disableRule always calls RuleScheduler.stopScheduler.+ StoppingInvoker invoker = new StoppingInvoker(() -> {+ rule.setState(RuleState.DISABLED);+ schedulerRef.get().stopScheduler(RULE_ARN);+ });+ RuleScheduler scheduler = newScheduler(vertx, invoker);+ schedulerRef.set(scheduler);+ scheduler.startScheduler(RULE_ARN, EVERY_MINUTE_CRON, () -> toScheduleData(rule));++ fire.getValue().handle(1L);++ assertEquals(1, invoker.invocationCount());+ verify(vertx, times(1)).setTimer(anyLong(), any());+ assertFalse(scheduler.isRunning(RULE_ARN), "disabled rule must not have its cron timer re-armed");+ }++ @Test+ void stopBetweenReArmCheckAndReplaceCancelsTheNewTimer() {+ Vertx vertx = mock(Vertx.class);+ ArgumentCaptor<Handler<Long>> fire = timerHandlerCaptor();+ AtomicReference<RuleScheduler> schedulerRef = new AtomicReference<>();+ // The re-arm's own setTimer call is the last step before the context swap, so a stop+ // issued from inside it lands after the "still my timer" check and before the replace.+ when(vertx.setTimer(anyLong(), fire.capture())).thenReturn(1L).thenAnswer(invocation -> {+ schedulerRef.get().stopScheduler(RULE_ARN);+ return 2L;+ });++ Rule rule = enabledRule();+ StoppingInvoker invoker = new StoppingInvoker(() -> { });+ RuleScheduler scheduler = newScheduler(vertx, invoker);+ schedulerRef.set(scheduler);+ scheduler.startScheduler(RULE_ARN, EVERY_MINUTE_CRON, () -> toScheduleData(rule));++ fire.getValue().handle(1L);++ verify(vertx).cancelTimer(2L);+ assertFalse(scheduler.isRunning(RULE_ARN), "a stop racing the re-arm must not leave the new timer recorded");+ }++ @SuppressWarnings("unchecked")+ private static ArgumentCaptor<Handler<Long>> timerHandlerCaptor() {+ return ArgumentCaptor.forClass(Handler.class);+ }++ private static RuleScheduler.ScheduleData toScheduleData(Rule rule) {+ if (rule == null) {+ return null;+ }+ return new RuleScheduler.ScheduleData(rule, List.of(target()));+ }++ private static Rule enabledRule() {+ Rule rule = new Rule();+ rule.setName("timer-stop-rule");+ rule.setArn(RULE_ARN);+ rule.setAccountId(ACCOUNT);+ rule.setEventBusName("default");+ rule.setScheduleExpression(EVERY_MINUTE_CRON);+ rule.setState(RuleState.ENABLED);+ return rule;+ }++ private static Target target() {+ return new Target("target-1", "arn:aws:lambda:us-east-1:000000000000:function:test-fn", null, null);+ }++ private static RuleScheduler newScheduler(Vertx vertx, EventBridgeInvoker invoker) {+ return new RuleScheduler(vertx, testConfig(), new ObjectMapper(), invoker,+ Clock.fixed(JUST_BEFORE_MINUTE_BOUNDARY, ZoneOffset.UTC));+ }++ /**+ * Runs a stop action from inside target delivery, putting a DeleteRule/DisableRule+ * exactly while the tick is still delivering.+ */+ private static final class StoppingInvoker extends EventBridgeInvoker {++ private final Runnable onDelivery;+ private final AtomicInteger invocationCount = new AtomicInteger();++ StoppingInvoker(Runnable onDelivery) {+ super(null, null, null, new ObjectMapper(), testConfig());+ this.onDelivery = onDelivery;+ }++ @Override+ public void invokeTarget(Target target, String eventJson, String region) {+ invocationCount.incrementAndGet();+ onDelivery.run();+ }++ int invocationCount() {+ return invocationCount.get();+ }+ }++ private static EmulatorConfig testConfig() {+ EmulatorConfig config = mock(EmulatorConfig.class);+ when(config.defaultAccountId()).thenReturn(ACCOUNT);+ return config;+ }+}