Skip to content

Commit e6dd866

Browse files
MellowYarkerMellowYarker
committed
Run alarm without syncing alarm manager if currentTime past local time
Historically, if a SQLite DOs local alarm time in SQLite didn't match the AlarmManager's alarm time, we would reschedule the alarm and try to run the alarm again later. However, if the time we are attempting to sync to is already before the current real system time, there is no point in rescheduling to run later, since we might as well run now. This commit runs the alarm immediately if the current system time is already past the time we are trying to sync the alarm manager to, since it's better to run an alarm a little late rather than very late.
1 parent 7d8cacd commit e6dd866

File tree

7 files changed

+91
-28
lines changed

7 files changed

+91
-28
lines changed

‎src/workerd/api/global-scope.c++‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -438,8 +438,9 @@ kj::Promise<WorkerInterface::AlarmResult> ServiceWorkerGlobalScope::runAlarm(kj:
438438
}
439439
}
440440

441+
auto currentTime = context.now();
441442
KJ_SWITCH_ONEOF(persistent.armAlarmHandler(
442-
scheduledTime, context.getCurrentTraceSpan(), false, actorId)) {
443+
scheduledTime, context.getCurrentTraceSpan(), currentTime, false, actorId)) {
443444
KJ_CASE_ONEOF(armResult, ActorCacheInterface::RunAlarmHandler) {
444445
auto& handler = KJ_REQUIRE_NONNULL(exportedHandler);
445446
if (handler.alarm == kj::none) {

‎src/workerd/io/actor-cache-test.c++‎

Lines changed: 10 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -4938,6 +4938,8 @@ KJ_TEST("ActorCache alarm get/put") {
49384938

49394939
auto oneMs = 1 * kj::MILLISECONDS + kj::UNIX_EPOCH;
49404940
auto twoMs = 2 * kj::MILLISECONDS + kj::UNIX_EPOCH;
4941+
// Used as the "current time" parameter for armAlarmHandler in tests.
4942+
auto testCurrentTime = kj::UNIX_EPOCH;
49414943
{
49424944
// Test alarm writes happen transactionally with storage ops
49434945
test.setAlarm(oneMs);
@@ -4979,7 +4981,8 @@ KJ_TEST("ActorCache alarm get/put") {
49794981

49804982
{
49814983
// we have a cached time == nullptr, so we should not attempt to run an alarm
4982-
auto armResult = test.cache.armAlarmHandler(10 * kj::SECONDS + kj::UNIX_EPOCH, nullptr);
4984+
auto armResult =
4985+
test.cache.armAlarmHandler(10 * kj::SECONDS + kj::UNIX_EPOCH, nullptr, testCurrentTime);
49834986
KJ_ASSERT(armResult.is<ActorCache::CancelAlarmHandler>());
49844987
auto cancelResult = kj::mv(armResult.get<ActorCache::CancelAlarmHandler>());
49854988
KJ_ASSERT(cancelResult.waitBeforeCancel.poll(ws));
@@ -4997,7 +5000,7 @@ KJ_TEST("ActorCache alarm get/put") {
49975000
{
49985001
// Test that alarm handler handle clears alarm when dropped with no writes
49995002
{
5000-
auto armResult = test.cache.armAlarmHandler(oneMs, nullptr);
5003+
auto armResult = test.cache.armAlarmHandler(oneMs, nullptr, testCurrentTime);
50015004
KJ_ASSERT(armResult.is<ActorCache::RunAlarmHandler>());
50025005
}
50035006
mockStorage->expectCall("deleteAlarm", ws)
@@ -5010,7 +5013,7 @@ KJ_TEST("ActorCache alarm get/put") {
50105013

50115014
// Test that alarm handler handle does not clear alarm when dropped with writes
50125015
{
5013-
auto armResult = test.cache.armAlarmHandler(oneMs, nullptr);
5016+
auto armResult = test.cache.armAlarmHandler(oneMs, nullptr, testCurrentTime);
50145017
KJ_ASSERT(armResult.is<ActorCache::RunAlarmHandler>());
50155018
test.setAlarm(twoMs);
50165019
}
@@ -5024,7 +5027,7 @@ KJ_TEST("ActorCache alarm get/put") {
50245027

50255028
// Test that alarm handler handle does not cache delete when it fails
50265029
{
5027-
auto armResult = test.cache.armAlarmHandler(oneMs, nullptr);
5030+
auto armResult = test.cache.armAlarmHandler(oneMs, nullptr, testCurrentTime);
50285031
KJ_ASSERT(armResult.is<ActorCache::RunAlarmHandler>());
50295032
}
50305033
mockStorage->expectCall("deleteAlarm", ws)
@@ -5036,7 +5039,7 @@ KJ_TEST("ActorCache alarm get/put") {
50365039
{
50375040
// Test that alarm handler handle does not cache alarm delete when noCache == true
50385041
{
5039-
auto armResult = test.cache.armAlarmHandler(twoMs, nullptr, true);
5042+
auto armResult = test.cache.armAlarmHandler(twoMs, nullptr, testCurrentTime, true);
50405043
KJ_ASSERT(armResult.is<ActorCache::RunAlarmHandler>());
50415044
}
50425045
mockStorage->expectCall("deleteAlarm", ws)
@@ -5073,6 +5076,7 @@ KJ_TEST("ActorCache alarm delete when flush fails") {
50735076
auto& mockStorage = test.mockStorage;
50745077

50755078
auto oneMs = 1 * kj::MILLISECONDS + kj::UNIX_EPOCH;
5079+
auto testCurrentTime = kj::UNIX_EPOCH;
50765080

50775081
{
50785082
auto time = expectUncached(test.getAlarm());
@@ -5090,7 +5094,7 @@ KJ_TEST("ActorCache alarm delete when flush fails") {
50905094
// we want to test that even if a flush is retried
50915095
// that the post-delete actions for a checked delete happen.
50925096
{
5093-
auto handle = test.cache.armAlarmHandler(oneMs, nullptr);
5097+
auto handle = test.cache.armAlarmHandler(oneMs, nullptr, testCurrentTime);
50945098

50955099
auto time = expectCached(test.getAlarm());
50965100
KJ_ASSERT(time == kj::none);

‎src/workerd/io/actor-cache.c++‎

Lines changed: 5 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -164,7 +164,11 @@ kj::Maybe<kj::Promise<void>> ActorCache::evictStale(kj::Date now) {
164164
}
165165

166166
kj::OneOf<ActorCache::CancelAlarmHandler, ActorCache::RunAlarmHandler> ActorCache::armAlarmHandler(
167-
kj::Date scheduledTime, SpanParent parentSpan, bool noCache, kj::StringPtr actorId) {
167+
kj::Date scheduledTime,
168+
SpanParent parentSpan,
169+
kj::Date currentTime KJ_UNUSED,
170+
bool noCache,
171+
kj::StringPtr actorId) {
168172
noCache = noCache || lru.options.noCache;
169173

170174
KJ_ASSERT(!currentAlarmTime.is<DeferredAlarmDelete>());

‎src/workerd/io/actor-cache.h‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -243,8 +243,12 @@ class ActorCacheInterface: public ActorCacheOps {
243243
};
244244

245245
// Call when entering the alarm handler.
246+
//
247+
// `currentTime` is used to determine if an overdue alarm should run immediately even when
248+
// the local alarm state differs from the scheduled time (to avoid blocking on storage sync).
246249
virtual kj::OneOf<CancelAlarmHandler, RunAlarmHandler> armAlarmHandler(kj::Date scheduledTime,
247250
SpanParent parentSpan,
251+
kj::Date currentTime,
248252
bool noCache = false,
249253
kj::StringPtr actorId = "") = 0;
250254

@@ -363,6 +367,7 @@ class ActorCache final: public ActorCacheInterface {
363367

364368
kj::OneOf<CancelAlarmHandler, RunAlarmHandler> armAlarmHandler(kj::Date scheduledTime,
365369
SpanParent parentSpan,
370+
kj::Date currentTime,
366371
bool noCache = false,
367372
kj::StringPtr actorId = "") override;
368373
void cancelDeferredAlarmDeletion() override;

‎src/workerd/io/actor-sqlite-test.c++‎

Lines changed: 47 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,10 @@ static constexpr kj::Date twoMs = 2 * kj::MILLISECONDS + kj::UNIX_EPOCH;
2020
static constexpr kj::Date threeMs = 3 * kj::MILLISECONDS + kj::UNIX_EPOCH;
2121
static constexpr kj::Date fourMs = 4 * kj::MILLISECONDS + kj::UNIX_EPOCH;
2222
static constexpr kj::Date fiveMs = 5 * kj::MILLISECONDS + kj::UNIX_EPOCH;
23+
// Used as the "current time" parameter for armAlarmHandler in tests.
24+
// Set to epoch (before all test alarm times) so existing tests aren't affected by
25+
// the overdue alarm check.
26+
static constexpr kj::Date testCurrentTime = kj::UNIX_EPOCH;
2327

2428
template <typename T>
2529
kj::Promise<T> eagerlyReportExceptions(kj::Promise<T> promise, kj::SourceLocation location = {}) {
@@ -586,7 +590,7 @@ KJ_TEST("tells alarm handler to cancel when committed alarm is empty") {
586590
ActorSqliteTest test;
587591

588592
{
589-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
593+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
590594
// We expect armAlarmHandler() to tell us to cancel the alarm.
591595
KJ_ASSERT(armResult.is<ActorCache::CancelAlarmHandler>());
592596
auto waitPromise = kj::mv(armResult.get<ActorCache::CancelAlarmHandler>().waitBeforeCancel);
@@ -612,7 +616,7 @@ KJ_TEST("tells alarm handler to reschedule when handler alarm is later than comm
612616
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
613617

614618
// Request handler run at 2ms. Expect cancellation with rescheduling.
615-
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr);
619+
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr, testCurrentTime);
616620
KJ_ASSERT(armResult.is<ActorSqlite::CancelAlarmHandler>());
617621
auto cancelResult = kj::mv(armResult.get<ActorSqlite::CancelAlarmHandler>());
618622

@@ -636,7 +640,7 @@ KJ_TEST("tells alarm handler to reschedule when handler alarm is earlier than co
636640
KJ_ASSERT(expectSync(test.getAlarm()) == twoMs);
637641

638642
// Expect that armAlarmHandler() tells caller to cancel after rescheduling completes.
639-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
643+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
640644
KJ_ASSERT(armResult.is<ActorSqlite::CancelAlarmHandler>());
641645
auto cancelResult = kj::mv(armResult.get<ActorSqlite::CancelAlarmHandler>());
642646

@@ -649,6 +653,32 @@ KJ_TEST("tells alarm handler to reschedule when handler alarm is earlier than co
649653
waitBeforeCancel.wait(test.ws);
650654
}
651655

656+
KJ_TEST("runs overdue alarm immediately when local alarm time is in the past") {
657+
ActorSqliteTest test;
658+
659+
// Initialize alarm state to 2ms.
660+
test.setAlarm(twoMs);
661+
test.pollAndExpectCalls({"scheduleRun(2ms)"})[0]->fulfill();
662+
test.pollAndExpectCalls({"commit"})[0]->fulfill();
663+
test.pollAndExpectCalls({});
664+
KJ_ASSERT(expectSync(test.getAlarm()) == twoMs);
665+
666+
// The local state says the alarm is due to fire at 2ms, but we're saying the AlarmManager has 1ms,
667+
// usually this would result in a rescheduling of the alarm, but since our currentTime is 5ms, we
668+
// will just run the alarm now since it's already overdue.
669+
{
670+
auto overdueCurrentTime = fiveMs;
671+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, overdueCurrentTime);
672+
673+
// Should run the handler immediately instead of canceling/rescheduling.
674+
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
675+
}
676+
677+
// commit and delete the alarm after we drop the alarm handler (this is a deferred delete).
678+
test.pollAndExpectCalls({"commit"})[0]->fulfill();
679+
test.pollAndExpectCalls({"scheduleRun(none)"})[0]->fulfill();
680+
}
681+
652682
KJ_TEST("does not cancel handler when local db alarm state is later than scheduled alarm") {
653683
ActorSqliteTest test;
654684

@@ -661,7 +691,7 @@ KJ_TEST("does not cancel handler when local db alarm state is later than schedul
661691

662692
test.setAlarm(twoMs);
663693
{
664-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
694+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
665695
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
666696
}
667697
test.pollAndExpectCalls({"commit"})[0]->fulfill();
@@ -680,7 +710,7 @@ KJ_TEST("does not cancel handler when local db alarm state is earlier than sched
680710

681711
test.setAlarm(oneMs);
682712
{
683-
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr);
713+
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr, testCurrentTime);
684714
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
685715
}
686716
test.pollAndExpectCalls({"scheduleRun(1ms)"})[0]->fulfill();
@@ -698,7 +728,7 @@ KJ_TEST("getAlarm() returns null during handler") {
698728
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
699729

700730
{
701-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
731+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
702732
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
703733
test.pollAndExpectCalls({});
704734

@@ -719,7 +749,7 @@ KJ_TEST("alarm handler handle clears alarm when dropped with no writes") {
719749
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
720750

721751
{
722-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
752+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
723753
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
724754
}
725755
test.pollAndExpectCalls({"commit"})[0]->fulfill();
@@ -738,7 +768,7 @@ KJ_TEST("alarm deleter does not clear alarm when dropped with writes") {
738768
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
739769

740770
{
741-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
771+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
742772
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
743773
test.setAlarm(twoMs);
744774
}
@@ -759,7 +789,7 @@ KJ_TEST("can cancel deferred alarm deletion during handler") {
759789
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
760790

761791
{
762-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
792+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
763793
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
764794
test.actor.cancelDeferredAlarmDeletion();
765795
}
@@ -778,7 +808,7 @@ KJ_TEST("canceling deferred alarm deletion outside handler has no effect") {
778808
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
779809

780810
{
781-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
811+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
782812
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
783813
}
784814
test.pollAndExpectCalls({"commit"})[0]->fulfill();
@@ -803,7 +833,7 @@ KJ_TEST("canceling deferred alarm deletion outside handler edge case") {
803833
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
804834

805835
{
806-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
836+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
807837
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
808838
}
809839
test.actor.cancelDeferredAlarmDeletion();
@@ -825,7 +855,7 @@ KJ_TEST("canceling deferred alarm deletion is idempotent") {
825855
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
826856

827857
{
828-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
858+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
829859
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
830860
test.actor.cancelDeferredAlarmDeletion();
831861
test.actor.cancelDeferredAlarmDeletion();
@@ -846,7 +876,7 @@ KJ_TEST("alarm handler cleanup succeeds when output gate is broken") {
846876
test.pollAndExpectCalls({});
847877
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
848878

849-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
879+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
850880
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
851881
auto deferredDelete = kj::mv(armResult.get<ActorSqlite::RunAlarmHandler>().deferredDelete);
852882

@@ -893,7 +923,7 @@ KJ_TEST("handler alarm is not deleted when commit fails") {
893923
KJ_ASSERT(expectSync(test.getAlarm()) == oneMs);
894924

895925
{
896-
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr);
926+
auto armResult = test.actor.armAlarmHandler(oneMs, nullptr, testCurrentTime);
897927
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
898928

899929
KJ_ASSERT(expectSync(test.getAlarm()) == kj::none);
@@ -1340,7 +1370,7 @@ KJ_TEST("rolling back transaction leaves deferred alarm deletion in expected sta
13401370
KJ_ASSERT(expectSync(test.getAlarm()) == twoMs);
13411371

13421372
{
1343-
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr);
1373+
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr, testCurrentTime);
13441374
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
13451375

13461376
auto txn = test.actor.startTransaction();
@@ -1373,7 +1403,7 @@ KJ_TEST("committing transaction leaves deferred alarm deletion in expected state
13731403
KJ_ASSERT(expectSync(test.getAlarm()) == twoMs);
13741404

13751405
{
1376-
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr);
1406+
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr, testCurrentTime);
13771407
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
13781408

13791409
auto txn = test.actor.startTransaction();
@@ -1404,7 +1434,7 @@ KJ_TEST("rolling back nested transaction leaves deferred alarm deletion in expec
14041434
KJ_ASSERT(expectSync(test.getAlarm()) == twoMs);
14051435

14061436
{
1407-
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr);
1437+
auto armResult = test.actor.armAlarmHandler(twoMs, nullptr, testCurrentTime);
14081438
KJ_ASSERT(armResult.is<ActorSqlite::RunAlarmHandler>());
14091439

14101440
auto txn1 = test.actor.startTransaction();

‎src/workerd/io/actor-sqlite.c++‎

Lines changed: 21 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -863,8 +863,11 @@ void ActorSqlite::shutdown(kj::Maybe<const kj::Exception&> maybeException) {
863863
}
864864

865865
kj::OneOf<ActorSqlite::CancelAlarmHandler, ActorSqlite::RunAlarmHandler> ActorSqlite::
866-
armAlarmHandler(
867-
kj::Date scheduledTime, SpanParent parentSpan, bool noCache, kj::StringPtr actorId) {
866+
armAlarmHandler(kj::Date scheduledTime,
867+
SpanParent parentSpan,
868+
kj::Date currentTime,
869+
bool noCache,
870+
kj::StringPtr actorId) {
868871
KJ_ASSERT(!inAlarmHandler);
869872

870873
if (haveDeferredDelete) {
@@ -876,6 +879,20 @@ kj::OneOf<ActorSqlite::CancelAlarmHandler, ActorSqlite::RunAlarmHandler> ActorSq
876879
auto localAlarmState = metadata.getAlarm();
877880
if (localAlarmState != scheduledTime) {
878881
if (localAlarmState == lastConfirmedAlarmDbState) {
882+
// If the local alarm time is already in the past, just run the handler now. This avoids
883+
// blocking alarm execution on storage sync when storage is overloaded. The alarm will
884+
// either delete itself on success or reschedule on failure.
885+
if ((willFireEarlier(localAlarmState, currentTime))) {
886+
LOG_WARNING_PERIODICALLY(
887+
"NOSENTRY SQLite alarm overdue, running despite AlarmManager mismatch", scheduledTime,
888+
KJ_ASSERT_NONNULL(localAlarmState), currentTime, actorId);
889+
haveDeferredDelete = true;
890+
inAlarmHandler = true;
891+
deferredAlarmSpan = kj::mv(parentSpan);
892+
static const DeferredAlarmDeleter disposer;
893+
return RunAlarmHandler{.deferredDelete = kj::Own<void>(this, disposer)};
894+
}
895+
879896
// If there's a clean db time that differs from the requested handler's scheduled time, this
880897
// run should be canceled.
881898
if (willFireEarlier(scheduledTime, localAlarmState)) {
@@ -909,10 +926,11 @@ kj::OneOf<ActorSqlite::CancelAlarmHandler, ActorSqlite::RunAlarmHandler> ActorSq
909926
// which suggests that either the alarm manager is working with stale data or that local
910927
// alarm time has somehow gotten out of sync with the scheduled alarm time.
911928

912-
// Only log if the alarm manager is significantly late (>10 seconds behind SQLite)
913929
// We know localAlarmState has a value here because we're in the branch where it's earlier
914930
// than scheduledTime (not equal, and not later).
915931
auto localTime = KJ_ASSERT_NONNULL(localAlarmState);
932+
933+
// Only log if the alarm manager is significantly late (>10 seconds behind SQLite)
916934
if (scheduledTime - localTime > 10 * kj::SECONDS) {
917935
LOG_WARNING_PERIODICALLY(
918936
"NOSENTRY SQLite alarm handler canceled.", scheduledTime, actorId, localTime);

‎src/workerd/io/actor-sqlite.h‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -96,6 +96,7 @@ class ActorSqlite final: public ActorCacheInterface, private kj::TaskSet::ErrorH
9696
void shutdown(kj::Maybe<const kj::Exception&> maybeException) override;
9797
kj::OneOf<CancelAlarmHandler, RunAlarmHandler> armAlarmHandler(kj::Date scheduledTime,
9898
SpanParent parentSpan,
99+
kj::Date currentTime,
99100
bool noCache = false,
100101
kj::StringPtr actorId = "") override;
101102
void cancelDeferredAlarmDeletion() override;

0 commit comments

Comments
 (0)