fix(daemon): record terminal non-dispatch outcomes so a capture is evaluated once

This commit is contained in:
sam committed 2026-10-05 20:06:45 +11:00
1 parent e302103e78
commit 79f005bd28
12 files changed
+127 -16

No files matched your search

+14 -3
View File
@@ -10645,7 +10645,10 @@ type RecordDispatchRequest struct {
BindingVersion int64 `protobuf:"varint,2,opt,name=binding_version,json=bindingVersion,proto3" json:"binding_version,omitempty"`
CaptureId string `protobuf:"bytes,3,opt,name=capture_id,json=captureId,proto3" json:"capture_id,omitempty"`
// task_id addresses the tasks table.
TaskId int64 `protobuf:"varint,4,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
TaskId int64 `protobuf:"varint,4,opt,name=task_id,json=taskId,proto3" json:"task_id,omitempty"`
// reason is empty for a dispatch and names why an evaluated capture
// started no task.
Reason string `protobuf:"bytes,5,opt,name=reason,proto3" json:"reason,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -10708,6 +10711,13 @@ func (x *RecordDispatchRequest) GetTaskId() int64 {
return 0
}
func (x *RecordDispatchRequest) GetReason() string {
if x != nil {
return x.Reason
}
return ""
}
type RecordDispatchResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
unknownFields protoimpl.UnknownFields
@@ -13662,14 +13672,15 @@ const file_state_v1_state_proto_rawDesc = "" +
"\x1dArmedBindingsForSourceRequest\x12\x16\n" +
"\x06source\x18\x01 \x01(\tR\x06source\"O\n" +
"\x1eArmedBindingsForSourceResponse\x12-\n" +
"\bbindings\x18\x01 \x03(\v2\x11.state.v1.BindingR\bbindings\"\x97\x01\n" +
"\bbindings\x18\x01 \x03(\v2\x11.state.v1.BindingR\bbindings\"\xaf\x01\n" +
"\x15RecordDispatchRequest\x12\x1d\n" +
"\n" +
"binding_id\x18\x01 \x01(\tR\tbindingId\x12'\n" +
"\x0fbinding_version\x18\x02 \x01(\x03R\x0ebindingVersion\x12\x1d\n" +
"\n" +
"capture_id\x18\x03 \x01(\tR\tcaptureId\x12\x17\n" +
"\atask_id\x18\x04 \x01(\x03R\x06taskId\"\x18\n" +
"\atask_id\x18\x04 \x01(\x03R\x06taskId\x12\x16\n" +
"\x06reason\x18\x05 \x01(\tR\x06reason\"\x18\n" +
"\x16RecordDispatchResponse\"\xa3\x01\n" +
"\x1dRecordPlaybookDispatchRequest\x12\x1f\n" +
"\vplaybook_id\x18\x01 \x01(\tR\n" +
+17 -4
View File
@@ -660,6 +660,7 @@ func (d *Daemon) dispatchOneBinding(ctx context.Context, b binding.Binding, c st
return
}
if admitted, _ := filter.Admits(values); !admitted {
d.recordEvaluated(ctx, b, c, "filtered")
return
}
@@ -672,8 +673,8 @@ func (d *Daemon) dispatchOneBinding(ctx context.Context, b binding.Binding, c st
}
// The chain decides dispatch: the workflow's identity may `run` this
// workflow in its workspace, and the event's signature result and address
// travel with the request. A denial is recorded and the dispatch is not
// claimed: the capture stays listed for the next cycle.
// travel with the request. A denial is terminal; an unavailable principal
// leaves the capture listed for the next cycle.
if !d.authorizeDispatch(ctx, b, c, target) {
return
}
@@ -684,7 +685,7 @@ func (d *Daemon) dispatchOneBinding(ctx context.Context, b binding.Binding, c st
// the task. A failed enqueue after the claim loses that dispatch, which is
// the at-most-once side of the trade.
func (d *Daemon) claimAndEnqueue(ctx context.Context, b binding.Binding, c storecontract.CapturedEvent, target bindingTarget, values map[string]any) {
if err := d.BindingDispatcher.RecordDispatch(ctx, b.ID, int64(b.Version), c.ID, 0); err != nil {
if err := d.BindingDispatcher.RecordDispatch(ctx, b.ID, int64(b.Version), c.ID, 0, ""); err != nil {
if !errors.Is(err, storecontract.ErrAlreadyDispatched) {
d.Log.Warn("binding dispatch: record", "binding", b.ID, "capture", c.ID, "error", err)
}
@@ -767,8 +768,10 @@ func (d *Daemon) markUnsignedStart(ctx context.Context, taskID int64, b binding.
}
}
// recordDispatchFailure records why a binding did not dispatch a capture.
// recordDispatchFailure records why a binding did not dispatch a capture and
// marks the pair evaluated, so the capture is not offered to it again.
func (d *Daemon) recordDispatchFailure(ctx context.Context, b binding.Binding, c storecontract.CapturedEvent, reason string, extra map[string]any) {
d.recordEvaluated(ctx, b, c, reason)
data := map[string]any{
"binding_id": b.ID,
"binding_version": b.Version,
@@ -782,6 +785,16 @@ func (d *Daemon) recordDispatchFailure(ctx context.Context, b binding.Binding, c
})
}
// recordEvaluated writes the ledger row for an evaluation that started no
// task. Only terminal outcomes call it; transient ones leave the capture
// listed for the next cycle.
func (d *Daemon) recordEvaluated(ctx context.Context, b binding.Binding, c storecontract.CapturedEvent, reason string) {
err := d.BindingDispatcher.RecordDispatch(ctx, b.ID, int64(b.Version), c.ID, 0, reason)
if err != nil && !errors.Is(err, storecontract.ErrAlreadyDispatched) {
d.Log.Warn("binding dispatch: record evaluation", "binding", b.ID, "capture", c.ID, "error", err)
}
}
// hasBlockingFailure reports whether any failure is on a required field.
func hasBlockingFailure(fields []mapping.Field, failures []mapping.Failure) bool {
if len(failures) == 0 {
@@ -257,6 +257,9 @@ type BindingDispatcher interface {
// migrating: it stays an integer on purpose. The binding dispatch
// loop claims before it enqueues, so it records 0.
taskID int64,
// reason is empty for a dispatch and names the terminal outcome of
// an evaluation that started no task.
reason string,
) error
ListUndispatchedCaptures(ctx context.Context, sources []string, limit int) ([]CapturedEvent, error)
}
@@ -0,0 +1,65 @@
package postgres_test
import (
"errors"
"testing"
"time"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/domain/storecontract"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres"
"github.com/samcharles93/archie-core/internal/infrastructure/postgres/pgstore"
)
// A capture a binding evaluated without dispatching is recorded once and not
// offered to that binding again; a later dispatch of the pair is refused.
func TestEvaluatedCaptureIsNotReoffered(t *testing.T) {
ctx := t.Context()
eda := pgstore.EDA(t, nil)
eventTypeID, err := eda.InsertEventType(ctx, eventtype.EventType{Source: "forge", Name: "push"})
if err != nil {
t.Fatal(err)
}
mappingID, err := eda.InsertMapping(ctx, mapping.Mapping{Name: "push", EventTypeID: eventTypeID})
if err != nil {
t.Fatal(err)
}
bindingID, err := eda.InsertBinding(ctx, binding.Binding{
Name: "on-push", Matcher: binding.Matcher{Source: "forge"}, MappingID: mappingID, Workflow: "tdd",
})
if err != nil {
t.Fatal(err)
}
if err := eda.ApproveBinding(ctx, bindingID); err != nil {
t.Fatal(err)
}
captureID, err := eda.InsertCapture(ctx, storecontract.CapturedEvent{
Source: "forge", Body: "{}", Authenticated: true, ReceivedAt: time.Now(),
}, time.Hour, 100)
if err != nil {
t.Fatal(err)
}
assertUndispatched(t, eda, 1)
if err := eda.RecordDispatch(ctx, bindingID, 1, captureID, 0, "filtered"); err != nil {
t.Fatalf("record filtered evaluation: %v", err)
}
assertUndispatched(t, eda, 0)
if err := eda.RecordDispatch(ctx, bindingID, 1, captureID, 0, ""); !errors.Is(err, storecontract.ErrAlreadyDispatched) {
t.Fatalf("dispatch after a filtered evaluation = %v, want ErrAlreadyDispatched", err)
}
}
func assertUndispatched(t *testing.T, eda *postgres.EDA, want int) {
t.Helper()
got, err := eda.ListUndispatchedCaptures(t.Context(), []string{"forge"}, 10)
if err != nil {
t.Fatal(err)
}
if len(got) != want {
t.Fatalf("undispatched captures = %d, want %d", len(got), want)
}
}
+4 -2
View File
@@ -485,13 +485,15 @@ func (s *EDA) ApproveBinding(ctx context.Context, id string) error {
// RecordDispatch writes one at-most-once binding dispatch. binding_version is
// stored but is not part of the unique key, so a version bump does not permit
// re-dispatching the same (binding, capture).
func (s *EDA) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64) error {
// re-dispatching the same (binding, capture). A non-empty reason records an
// evaluation that ended without a task.
func (s *EDA) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64, reason string) error {
err := s.q.InsertBindingDispatch(ctx, postgresdb.InsertBindingDispatchParams{
Binding: bindingID,
BindingVersion: bindingVersion,
Capture: captureID,
TaskID: taskID,
Reason: reason,
})
return ledgerWrite(err, "edastore: record dispatch")
}
@@ -0,0 +1,11 @@
-- binding_dispatches.reason says why an evaluated capture did not start a
-- task; empty means it dispatched. Recording terminal non-dispatch outcomes
-- keeps the capture from being re-evaluated every cycle.
-- +goose Up
ALTER TABLE binding_dispatches ADD COLUMN reason text NOT NULL DEFAULT '';
-- +goose Down
ALTER TABLE binding_dispatches DROP COLUMN reason;
@@ -395,8 +395,8 @@ func (q *Queries) InsertBinding(ctx context.Context, arg InsertBindingParams) er
}
const insertBindingDispatch = `-- name: InsertBindingDispatch :exec
INSERT INTO binding_dispatches (binding, binding_version, capture, task_id)
VALUES ($1, $2, $3, $4)
INSERT INTO binding_dispatches (binding, binding_version, capture, task_id, reason)
VALUES ($1, $2, $3, $4, $5)
`
type InsertBindingDispatchParams struct {
@@ -404,6 +404,7 @@ type InsertBindingDispatchParams struct {
BindingVersion int64
Capture string
TaskID int64
Reason string
}
func (q *Queries) InsertBindingDispatch(ctx context.Context, arg InsertBindingDispatchParams) error {
@@ -412,6 +413,7 @@ func (q *Queries) InsertBindingDispatch(ctx context.Context, arg InsertBindingDi
arg.BindingVersion,
arg.Capture,
arg.TaskID,
arg.Reason,
)
return err
}
@@ -78,6 +78,7 @@ type BindingDispatch struct {
Capture string
TaskID int64
DispatchedAt time.Time
Reason string
}
type Capture struct {
@@ -88,8 +88,8 @@ UPDATE bindings SET status = 'armed', updated_at = now() WHERE id = $1;
DELETE FROM bindings WHERE id = $1;
-- name: InsertBindingDispatch :exec
INSERT INTO binding_dispatches (binding, binding_version, capture, task_id)
VALUES ($1, $2, $3, $4);
INSERT INTO binding_dispatches (binding, binding_version, capture, task_id, reason)
VALUES ($1, $2, $3, $4, $5);
-- name: InsertPlaybookDispatch :exec
INSERT INTO playbook_dispatches (playbook_id, playbook_version, event_id, action_id)
+2 -2
View File
@@ -635,8 +635,8 @@ func (c *Client) ArmedBindingsForSource(ctx context.Context, source string) ([]b
return mapValues(r.Bindings, bindingValue), nil
}
func (c *Client) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64) error {
_, err := c.client.RecordDispatch(ctx, &pb.RecordDispatchRequest{BindingId: bindingID, BindingVersion: bindingVersion, CaptureId: captureID, TaskId: taskID})
func (c *Client) RecordDispatch(ctx context.Context, bindingID string, bindingVersion int64, captureID string, taskID int64, reason string) error {
_, err := c.client.RecordDispatch(ctx, &pb.RecordDispatchRequest{BindingId: bindingID, BindingVersion: bindingVersion, CaptureId: captureID, TaskId: taskID, Reason: reason})
return unmapError(err)
}
+1 -1
View File
@@ -942,7 +942,7 @@ func (s *server) RecordDispatch(ctx context.Context, r *pb.RecordDispatchRequest
if s.deps.BindingDispatcher == nil {
return nil, errBindingDispatchUnavailable
}
if err := s.deps.BindingDispatcher.RecordDispatch(ctx, r.BindingId, r.BindingVersion, r.CaptureId, r.TaskId); err != nil {
if err := s.deps.BindingDispatcher.RecordDispatch(ctx, r.BindingId, r.BindingVersion, r.CaptureId, r.TaskId, r.Reason); err != nil {
return nil, s.logErr("RecordDispatch", err)
}
return &pb.RecordDispatchResponse{}, nil
+3
View File
@@ -1114,6 +1114,9 @@ message RecordDispatchRequest {
string capture_id = 3;
// task_id addresses the tasks table.
int64 task_id = 4;
// reason is empty for a dispatch and names why an evaluated capture
// started no task.
string reason = 5;
}
message RecordDispatchResponse {}