Files
sam d11a0cd245
deploy / plan (push) Successful in 14s
deploy / archied-image (push) Canceled after 0s
deploy / agent-image (push) Canceled after 0s
deploy / dist-zip (push) Canceled after 0s
deploy / gate (push) Canceled after 1m2s
fix(workflow): one baseline fix per repository revision, drop download noise from gate output (#1806)
2026-11-08 17:23:21 +11:00

141 lines
4.3 KiB
Go

package worktreerpc
import (
"context"
"encoding/json"
"errors"
"sync"
"time"
"github.com/nats-io/nats.go"
"github.com/samcharles93/archie-core/internal/domain/workflow"
"github.com/samcharles93/archie-core/internal/natsrpc"
)
const (
SubjectBaseline = "archie.worktree.baseline"
// A repair that never reports back (its container died) stops blocking
// other tasks after claimTTL; a finished verdict is reused for verdictTTL,
// so a transient failure is retried later.
claimTTL = time.Hour
verdictTTL = 15 * time.Minute
)
type BaselineRequest struct {
Grant string `json:"grant"`
Key string `json:"key"`
Finish bool `json:"finish,omitempty"`
Failure string `json:"failure,omitempty"`
}
type BaselineResponse struct {
natsrpc.Envelope
Lead bool `json:"lead,omitempty"`
Task int64 `json:"task,omitempty"`
Done bool `json:"done,omitempty"`
Failure string `json:"failure,omitempty"`
}
type baselineEntry struct {
task int64
done bool
failure string
at time.Time
}
// BaselineClaims records which task repairs each red baseline. It is memory
// only: after a daemon restart the next task simply claims again.
type BaselineClaims struct {
mu sync.Mutex
entries map[string]baselineEntry
now func() time.Time
}
func NewBaselineClaims() *BaselineClaims {
return &BaselineClaims{entries: map[string]baselineEntry{}, now: time.Now}
}
// Claim makes taskID the repair's owner when nobody holds a live claim for
// key; a retry of the owning task takes it back.
func (b *BaselineClaims) Claim(taskID int64, key string) workflow.BaselineClaim {
b.mu.Lock()
defer b.mu.Unlock()
now := b.now()
e, ok := b.entries[key]
ttl := claimTTL
if e.done {
ttl = verdictTTL
}
if !ok || e.task == taskID || now.Sub(e.at) > ttl {
b.entries[key] = baselineEntry{task: taskID, at: now}
return workflow.BaselineClaim{Lead: true}
}
return workflow.BaselineClaim{Task: e.task, Done: e.done, Failure: e.failure}
}
// Finish records the owner's verdict; failure is empty when it repaired the
// baseline.
func (b *BaselineClaims) Finish(taskID int64, key, failure string) {
b.mu.Lock()
defer b.mu.Unlock()
if e, ok := b.entries[key]; ok && e.task == taskID {
b.entries[key] = baselineEntry{task: taskID, done: true, failure: failure, at: b.now()}
}
}
func (s *Server) handleBaseline(parent context.Context, identity string, msg *nats.Msg) {
var req BaselineRequest
if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respondBaseline(msg, BaselineResponse{Envelope: natsrpc.NewEnvelope(err)})
return
}
ctx, cancel := s.handlerContext(parent)
defer cancel()
task, err := publishable(ctx, s.Runs, req.Grant, identity)
if err != nil || s.Baselines == nil {
if err == nil {
err = errors.New("baseline claims unavailable")
}
s.respondBaseline(msg, BaselineResponse{Envelope: natsrpc.NewEnvelope(err)})
return
}
key := task.Owner + "/" + task.Repo + " " + req.Key
if req.Finish {
s.Baselines.Finish(task.ID, key, req.Failure)
s.respondBaseline(msg, BaselineResponse{})
return
}
claim := s.Baselines.Claim(task.ID, key)
s.respondBaseline(msg, BaselineResponse{Lead: claim.Lead, Task: claim.Task, Done: claim.Done, Failure: claim.Failure})
}
// ClaimBaselineFix asks the daemon whether this task repairs the red baseline
// named by key.
func (c *Client) ClaimBaselineFix(ctx context.Context, key string) (workflow.BaselineClaim, error) {
resp, err := c.baseline(ctx, BaselineRequest{Grant: c.Grant, Key: key})
if err != nil {
return workflow.BaselineClaim{}, err
}
return workflow.BaselineClaim{Lead: resp.Lead, Task: resp.Task, Done: resp.Done, Failure: resp.Failure}, nil
}
// FinishBaselineFix reports the repair's outcome; failure is empty on success.
func (c *Client) FinishBaselineFix(ctx context.Context, key, failure string) error {
_, err := c.baseline(ctx, BaselineRequest{Grant: c.Grant, Key: key, Finish: true, Failure: failure})
return err
}
func (s *Server) respondBaseline(msg *nats.Msg, resp BaselineResponse) {
natsrpc.Respond(msg, s.Log, "worktreerpc", resp)
}
func (c *Client) baseline(ctx context.Context, req BaselineRequest) (BaselineResponse, error) {
resp, err := natsrpc.Call[BaselineResponse](ctx, c.rpc(), c.subject(SubjectBaseline), req)
if err != nil {
return BaselineResponse{}, err
}
return resp, resp.Err()
}