releases/ClaudeDo
2
0
Fork 0
Code Issues 1 Pull Requests 2 Actions Packages Projects Releases 12 Wiki Activity

refactor(worker/queue): split queue waker and picker, auto-wake on enqueue

Browse Source 
Slice 3 of the worker state and queue consolidation refactor.

- Add IQueueWaker / QueueWaker (singleton holding the wake semaphore).
- Add IQueuePicker / QueuePicker; raw SQL UPDATE...RETURNING moves out of
  TaskRepository.GetNextQueuedAgentTaskAsync (deleted) and now also filters
  on blocked_by_task_id IS NULL and writes started_at on claim.
- TaskStateService takes IQueueWaker directly; the Func<QueueService>
  indirection is gone. State transitions to Queued auto-wake the dispatcher.
- QueueService waits via the shared waker and dispatches via the picker.
- Drop explicit _queue.WakeQueue() calls in WorkerHub.QueuePlanningSubtasksAsync
  and ExternalMcpService.AddTask. The hub WakeQueue endpoint stays for
  diagnostics, delegating to _waker.Wake().
- Migrate tests; pre-existing flaky AppSettings/ExternalMcp tests untouched.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Mika Kuns
2026-04-27 12:05:54 +02:00
parent 8823265e5a
commit 064a903076
18 changed files with 354 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
tests/ClaudeDo.Worker.Tests/External/ExternalMcpServiceTests.cs vendored
View File

@@ -115,7 +115,9 @@ public sealed class ExternalMcpServiceTests : IDisposable
var argsBuilder = new ClaudeArgsBuilder();
var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, cfg,
NullLogger<TaskRunner>.Instance, TaskStateServiceBuilder.Build(dbFactory).State);
return new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance);
var waker = new ClaudeDo.Worker.Queue.QueueWaker();
var picker = new ClaudeDo.Worker.Queue.QueuePicker(dbFactory);
return new QueueService(dbFactory, runner, cfg, NullLogger<QueueService>.Instance, waker, picker);
}
[Fact]

2
tests/ClaudeDo.Worker.Tests/Hub/PlanningHubTests.cs
View File

@@ -49,7 +49,7 @@ public sealed class PlanningHubTests : IDisposable
private WorkerHub CreateHub()
{
var hub = new WorkerHub(
null!, null!, null!, null!, null!, null!, null!, null!,
null!, null!, null!, null!, null!, null!, null!, null!, null!,
_planning, _launcher, null!, null!, null!);
hub.Clients = new FakeHubCallerClients(_proxy);
hub.Context = new FakeHubCallerContext();

17
tests/ClaudeDo.Worker.Tests/Infrastructure/TaskStateServiceBuilder.cs
View File

@@ -1,6 +1,7 @@
using ClaudeDo.Data;
using ClaudeDo.Worker.Hub;
using ClaudeDo.Worker.Planning;
using ClaudeDo.Worker.Queue;
using ClaudeDo.Worker.State;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging.Abstractions;
@@ -15,23 +16,31 @@ public static class TaskStateServiceBuilder
TaskStateService State,
PlanningChainCoordinator Chain,
CapturingHubContext Hub,
Func<int> WakeCount);
Func<int> WakeCount,
CountingQueueWaker Waker);
public static Built Build(IDbContextFactory<ClaudeDoDbContext> dbFactory)
{
var hub = new CapturingHubContext();
var broadcaster = new HubBroadcaster(hub);
var wakeCount = new int[1];
var waker = new CountingQueueWaker();
TaskStateService? state = null;
var chain = new PlanningChainCoordinator(dbFactory, () => state!);
state = new TaskStateService(
dbFactory,
broadcaster,
() => Interlocked.Increment(ref wakeCount[0]),
waker,
chain,
NullLogger<TaskStateService>.Instance);
return new Built(state, chain, hub, () => Volatile.Read(ref wakeCount[0]));
return new Built(state, chain, hub, () => waker.Count, waker);
}
}
public sealed class CountingQueueWaker : IQueueWaker
{
private int _count;
public int Count => Volatile.Read(ref _count);
public void Wake() => Interlocked.Increment(ref _count);
}

188
tests/ClaudeDo.Worker.Tests/Queue/QueuePickerTests.cs Normal file
View File

@@ -0,0 +1,188 @@
using ClaudeDo.Data;
using ClaudeDo.Data.Models;
using ClaudeDo.Data.Repositories;
using ClaudeDo.Worker.Queue;
using ClaudeDo.Worker.Tests.Infrastructure;
using TaskStatus = ClaudeDo.Data.Models.TaskStatus;
namespace ClaudeDo.Worker.Tests.Queue;
public sealed class QueuePickerTests : IDisposable
{
private readonly DbFixture _db = new();
private readonly ClaudeDoDbContext _ctx;
private readonly TaskRepository _tasks;
private readonly ListRepository _lists;
private readonly TagRepository _tags;
private readonly QueuePicker _picker;
public QueuePickerTests()
{
_ctx = _db.CreateContext();
_tasks = new TaskRepository(_ctx);
_lists = new ListRepository(_ctx);
_tags = new TagRepository(_ctx);
_picker = new QueuePicker(_db.CreateFactory());
}
public void Dispose()
{
_ctx.Dispose();
_db.Dispose();
}
private async Task<string> CreateListAsync(bool listAgentTag = false)
{
var listId = Guid.NewGuid().ToString();
await _lists.AddAsync(new ListEntity
{
Id = listId,
Name = "Test",
CreatedAt = DateTime.UtcNow,
});
if (listAgentTag)
{
var tagId = await _tags.GetOrCreateAsync("agent");
await _lists.AddTagAsync(listId, tagId);
}
return listId;
}
private async Task<TaskEntity> SeedAsync(
string listId,
TaskStatus status = TaskStatus.Queued,
DateTime? createdAt = null,
DateTime? scheduledFor = null,
string? blockedBy = null,
bool taskAgentTag = false,
int? sortOrder = null)
{
var task = new TaskEntity
{
Id = Guid.NewGuid().ToString(),
ListId = listId,
Title = "T",
Status = status,
CreatedAt = createdAt ?? DateTime.UtcNow,
ScheduledFor = scheduledFor,
BlockedByTaskId = blockedBy,
CommitType = "feat",
};
await _tasks.AddAsync(task);
if (taskAgentTag)
{
var tagId = await _tags.GetOrCreateAsync("agent");
await _tasks.AddTagAsync(task.Id, tagId);
}
if (sortOrder is not null)
{
task.SortOrder = sortOrder.Value;
await _tasks.UpdateAsync(task);
}
return task;
}
[Fact]
public async Task ClaimNextAsync_Skips_TasksWithBlockedByTaskId()
{
var listId = await CreateListAsync(listAgentTag: true);
var blocker = await SeedAsync(listId);
await SeedAsync(listId, blockedBy: blocker.Id);
// Only `blocker` is unblocked → it should be claimed; the second pick is null.
var first = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
Assert.NotNull(first);
Assert.Equal(blocker.Id, first!.Id);
var second = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
Assert.Null(second);
}
[Fact]
public async Task ClaimNextAsync_Skips_TasksWithoutAgentTag()
{
var listId = await CreateListAsync(listAgentTag: false);
await SeedAsync(listId);
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
Assert.Null(picked);
}
[Fact]
public async Task ClaimNextAsync_Skips_FutureScheduledFor()
{
var listId = await CreateListAsync(listAgentTag: true);
await SeedAsync(listId, scheduledFor: DateTime.UtcNow.AddHours(1));
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
Assert.Null(picked);
}
[Fact]
public async Task ClaimNextAsync_Skips_NonQueuedStatuses()
{
var listId = await CreateListAsync(listAgentTag: true);
await SeedAsync(listId, status: TaskStatus.Idle);
await SeedAsync(listId, status: TaskStatus.Running);
await SeedAsync(listId, status: TaskStatus.Done);
await SeedAsync(listId, status: TaskStatus.Failed);
await SeedAsync(listId, status: TaskStatus.Cancelled);
await SeedAsync(listId, status: TaskStatus.Manual);
await SeedAsync(listId, status: TaskStatus.Draft);
await SeedAsync(listId, status: TaskStatus.Planning);
await SeedAsync(listId, status: TaskStatus.Planned);
await SeedAsync(listId, status: TaskStatus.Waiting);
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
Assert.Null(picked);
}
[Fact]
public async Task ClaimNextAsync_Picks_ByUserSortOrder_ThenCreatedAt()
{
var listId = await CreateListAsync(listAgentTag: true);
// Created in order first, second; reorder so second is sort-order 0.
var first = await SeedAsync(listId, createdAt: DateTime.UtcNow.AddMinutes(-10));
var second = await SeedAsync(listId, createdAt: DateTime.UtcNow);
await _tasks.ReorderAsync(listId, new[] { second.Id, first.Id });
var picked = await _picker.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None);
Assert.NotNull(picked);
Assert.Equal(second.Id, picked!.Id);
}
[Fact]
public async Task ClaimNextAsync_FlipsToRunning_WithStartedAt()
{
var listId = await CreateListAsync(listAgentTag: true);
var task = await SeedAsync(listId);
var before = DateTime.UtcNow;
var picked = await _picker.ClaimNextAsync(before, CancellationToken.None);
Assert.NotNull(picked);
var loaded = await _tasks.GetByIdAsync(task.Id);
Assert.Equal(TaskStatus.Running, loaded!.Status);
Assert.NotNull(loaded.StartedAt);
}
[Fact]
public async Task ClaimNextAsync_TwoParallelPickers_OnlyOneClaimsRow()
{
var listId = await CreateListAsync(listAgentTag: true);
await SeedAsync(listId);
// Two pickers, same DB factory, racing each other.
var picker1 = new QueuePicker(_db.CreateFactory());
var picker2 = new QueuePicker(_db.CreateFactory());
var t1 = Task.Run(() => picker1.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
var t2 = Task.Run(() => picker2.ClaimNextAsync(DateTime.UtcNow, CancellationToken.None));
var results = await Task.WhenAll(t1, t2);
var nonNull = results.Where(r => r is not null).ToList();
Assert.Single(nonNull);
}
}

24
tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryPlanningTests.cs
View File

@@ -302,28 +302,4 @@ public sealed class TaskRepositoryPlanningTests : IDisposable
Assert.NotNull(stillThere);
}
[Fact]
public async Task GetNextQueuedAgentTask_SkipsDraftPlanningPlanned()
{
var listId = await CreateListAsync();
var agentTagId = await _tags.GetOrCreateAsync("agent");
async Task<TaskEntity> T(TaskStatus s, bool withTag, string? parent = null)
{
var t = MakeTask(listId, s, parentId: parent);
await _tasks.AddAsync(t);
if (withTag) await _tasks.AddTagAsync(t.Id, agentTagId);
return t;
}
var planning = await T(TaskStatus.Planning, withTag: true);
var planned = await T(TaskStatus.Planned, withTag: true);
var draft = await T(TaskStatus.Draft, withTag: true, parent: planning.Id);
var queued = await T(TaskStatus.Queued, withTag: true);
var picked = await _tasks.GetNextQueuedAgentTaskAsync(DateTime.UtcNow);
Assert.NotNull(picked);
Assert.Equal(queued.Id, picked!.Id);
}
}

78
tests/ClaudeDo.Worker.Tests/Repositories/TaskRepositoryTests.cs
View File

@@ -87,64 +87,6 @@ public sealed class TaskRepositoryTests : IDisposable
Assert.Equal(entity.CommitType, loaded.CommitType);
}
[Fact]
public async Task GetNextQueuedAgentTaskAsync_Returns_OldestWithAgentTag_ViaTaskTag()
{
var listId = await CreateListAsync();
var agentTagId = await _tags.GetOrCreateAsync("agent");
var older = MakeTask(listId, createdAt: DateTime.UtcNow.AddMinutes(-10));
var newer = MakeTask(listId, createdAt: DateTime.UtcNow);
await _tasks.AddAsync(older);
await _tasks.AddAsync(newer);
await _tasks.AddTagAsync(older.Id, agentTagId);
await _tasks.AddTagAsync(newer.Id, agentTagId);
var picked = await _tasks.GetNextQueuedAgentTaskAsync(DateTime.UtcNow);
Assert.NotNull(picked);
Assert.Equal(older.Id, picked.Id);
}
[Fact]
public async Task GetNextQueuedAgentTaskAsync_Returns_TaskWithAgentTag_ViaListTag()
{
var listId = await CreateListAsync();
var agentTagId = await _tags.GetOrCreateAsync("agent");
await _lists.AddTagAsync(listId, agentTagId);
var task = MakeTask(listId);
await _tasks.AddAsync(task);
var picked = await _tasks.GetNextQueuedAgentTaskAsync(DateTime.UtcNow);
Assert.NotNull(picked);
Assert.Equal(task.Id, picked.Id);
}
[Fact]
public async Task GetNextQueuedAgentTaskAsync_ReturnsNull_WhenNoAgentTag()
{
var listId = await CreateListAsync();
var task = MakeTask(listId);
await _tasks.AddAsync(task);
var picked = await _tasks.GetNextQueuedAgentTaskAsync(DateTime.UtcNow);
Assert.Null(picked);
}
[Fact]
public async Task GetNextQueuedAgentTaskAsync_Skips_FutureScheduledFor()
{
var listId = await CreateListAsync();
var agentTagId = await _tags.GetOrCreateAsync("agent");
var task = MakeTask(listId, scheduledFor: DateTime.UtcNow.AddHours(1));
await _tasks.AddAsync(task);
await _tasks.AddTagAsync(task.Id, agentTagId);
var picked = await _tasks.GetNextQueuedAgentTaskAsync(DateTime.UtcNow);
Assert.Null(picked);
}
[Fact]
public async Task Transitions_MarkRunning_ThenMarkDone()
{
@@ -297,26 +239,6 @@ public sealed class TaskRepositoryTests : IDisposable
Assert.Equal(0, reloadB!.SortOrder);
}
[Fact]
public async Task GetNextQueuedAgentTaskAsync_Picks_ByUserSortOrder()
{
var listId = await CreateListAsync();
var agentTagId = await _tags.GetOrCreateAsync("agent");
await _lists.AddTagAsync(listId, agentTagId);
// created in order first, second; then user reorders to put second on top.
var first = MakeTask(listId, createdAt: DateTime.UtcNow.AddMinutes(-10));
var second = MakeTask(listId, createdAt: DateTime.UtcNow);
await _tasks.AddAsync(first);
await _tasks.AddAsync(second);
await _tasks.ReorderAsync(listId, new[] { second.Id, first.Id });
var picked = await _tasks.GetNextQueuedAgentTaskAsync(DateTime.UtcNow);
Assert.NotNull(picked);
Assert.Equal(second.Id, picked!.Id);
}
[Fact]
public async Task GetEffectiveTagsAsync_Returns_Union_Of_ListTags_And_TaskTags()
{

11
tests/ClaudeDo.Worker.Tests/Services/QueueServiceSlotGuardTests.cs
View File

@@ -3,6 +3,7 @@ using ClaudeDo.Data.Models;
using ClaudeDo.Data.Repositories;
using ClaudeDo.Worker.Config;
using ClaudeDo.Worker.Hub;
using ClaudeDo.Worker.Queue;
using ClaudeDo.Worker.Runner;
using ClaudeDo.Worker.Services;
using ClaudeDo.Worker.Tests.Infrastructure;
@@ -45,6 +46,8 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
try { Directory.Delete(_tempDir, true); } catch { }
}
private QueueWaker _waker = null!;
private (QueueService service, FakeClaudeProcess fakeProcess) CreateService(
Func<string, string, string, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
{
@@ -55,7 +58,9 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
var argsBuilder = new ClaudeArgsBuilder();
var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, _cfg,
NullLogger<TaskRunner>.Instance, TaskStateServiceBuilder.Build(dbFactory).State);
var service = new QueueService(dbFactory, runner, _cfg, NullLogger<QueueService>.Instance);
_waker = new QueueWaker();
var picker = new QueuePicker(dbFactory);
var service = new QueueService(dbFactory, runner, _cfg, NullLogger<QueueService>.Instance, _waker, picker);
return (service, fake);
}
@@ -102,7 +107,7 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
using var cts = new CancellationTokenSource();
await service.StartAsync(cts.Token);
service.WakeQueue();
_waker.Wake();
// Wait until the queue slot has actually picked up the task.
await queuePickedUp.Task.WaitAsync(TimeSpan.FromSeconds(5));
@@ -132,7 +137,7 @@ public sealed class QueueServiceSlotGuardTests : IDisposable
using var cts = new CancellationTokenSource();
await service.StartAsync(cts.Token);
service.WakeQueue();
_waker.Wake();
await queuePickedUp.Task.WaitAsync(TimeSpan.FromSeconds(5));

11
tests/ClaudeDo.Worker.Tests/Services/QueueServiceTests.cs
View File

@@ -4,6 +4,7 @@ using ClaudeDo.Data.Models;
using ClaudeDo.Data.Repositories;
using ClaudeDo.Worker.Config;
using ClaudeDo.Worker.Hub;
using ClaudeDo.Worker.Queue;
using ClaudeDo.Worker.Runner;
using ClaudeDo.Worker.Services;
using ClaudeDo.Worker.Tests.Infrastructure;
@@ -46,6 +47,8 @@ public sealed class QueueServiceTests : IDisposable
try { Directory.Delete(_tempDir, true); } catch { }
}
private QueueWaker _waker = null!;
private (QueueService service, FakeClaudeProcess fakeProcess) CreateService(
Func<string, string, string, Func<string, Task>, CancellationToken, Task<RunResult>>? handler = null)
{
@@ -56,7 +59,9 @@ public sealed class QueueServiceTests : IDisposable
var argsBuilder = new ClaudeArgsBuilder();
var runner = new TaskRunner(fake, dbFactory, broadcaster, wtManager, argsBuilder, _cfg,
NullLogger<TaskRunner>.Instance, TaskStateServiceBuilder.Build(dbFactory).State);
var service = new QueueService(dbFactory, runner, _cfg, NullLogger<QueueService>.Instance);
_waker = new QueueWaker();
var picker = new QueuePicker(dbFactory);
var service = new QueueService(dbFactory, runner, _cfg, NullLogger<QueueService>.Instance, _waker, picker);
return (service, fake);
}
@@ -126,7 +131,7 @@ public sealed class QueueServiceTests : IDisposable
// Start the service loop, wake it, give it time.
await service.StartAsync(cts.Token);
service.WakeQueue();
_waker.Wake();
await Task.Delay(200);
cts.Cancel();
@@ -158,7 +163,7 @@ public sealed class QueueServiceTests : IDisposable
using var cts = new CancellationTokenSource();
await service.StartAsync(cts.Token);
service.WakeQueue();
_waker.Wake();
// Wait until task1 has been picked up (poll instead of fixed delay to avoid flake under load).
var deadline = DateTime.UtcNow.AddSeconds(5);