141 lines
4.3 KiB
Go
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()
|
|
}
|