90 lines
3.0 KiB
Go
90 lines
3.0 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"git.novox.be/novox/mesh-contracts/go/clients/nodeengineclient"
|
|
"git.novox.be/novox/mesh-contracts/go/seats/nodeengine"
|
|
"github.com/novox/mesh-host/internal/link"
|
|
"github.com/novox/mesh-host/internal/liveness"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// owedBus is a link that takes reports and statements and keeps a have bucket in memory.
|
|
type owedBus struct {
|
|
mu sync.Mutex
|
|
kv map[string][]byte
|
|
rv map[string]uint64
|
|
}
|
|
|
|
func (b *owedBus) Health(context.Context, string, []byte) error { return nil }
|
|
func (b *owedBus) HaveBind(context.Context) (link.HaveBucket, error) { return b, nil }
|
|
|
|
func (b *owedBus) Get(_ context.Context, key string) ([]byte, uint64, error) {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
v, ok := b.kv[key]
|
|
if !ok {
|
|
return nil, 0, link.ErrHaveAbsent
|
|
}
|
|
return v, b.rv[key], nil
|
|
}
|
|
|
|
func (b *owedBus) Set(_ context.Context, key string, value []byte, revision uint64) error {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
if b.rv[key] != revision {
|
|
return errors.New("wrong last sequence")
|
|
}
|
|
b.kv[key], b.rv[key] = value, revision+1
|
|
return nil
|
|
}
|
|
|
|
func (b *owedBus) have(key string) (nodeengine.HaveByNodeModuleValue, bool) {
|
|
b.mu.Lock()
|
|
defer b.mu.Unlock()
|
|
h, err := nodeengineclient.DecodeHave(b.kv[key])
|
|
return h, err == nil
|
|
}
|
|
|
|
// A module with nothing long-running (xorg) is ok within one look of its apply, not at the five-minute statement: the
|
|
// facts look inside the apply runs while it is applying and judges nothing, and the running write then owes a look,
|
|
// which the health loop makes at once (review of fix 15, B1).
|
|
func TestAModuleWithNothingLongRunningIsOkWithinALookOfItsApply(t *testing.T) {
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
bus := &owedBus{kv: map[string][]byte{}, rv: map[string]uint64{}}
|
|
queue := &link.Session{Membership: link.Membership{Node: "n1"}, Timeout: time.Second}
|
|
queue.Attach(ctx, bus)
|
|
j, err := liveness.Open(filepath.Join(t.TempDir(), "liveness.json"), nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
fact := link.ModuleFact{Module: "xorg", FP: "src2:" + strings.Repeat("a", 64), Composed: "sha256:" + strings.Repeat("b", 64)}
|
|
applying := fact
|
|
applying.Phase = string(nodeengineclient.PhaseApplying)
|
|
queue.NoteModule(ctx, applying)
|
|
go judgeWhatRuns(ctx, j, queue, func(string) {}, nil, nil)
|
|
// The facts look inside the apply, while the module is still applying.
|
|
queue.SayFacts(ctx, link.Report{Health: &link.Health{Contract: link.LivenessContract, At: time.Now().UTC()}})
|
|
if h, _ := bus.have("n1.xorg"); h.Health != nodeengineclient.HealthUnknown {
|
|
t.Fatalf("judged while applying: %+v", h)
|
|
}
|
|
queue.NoteModule(ctx, fact)
|
|
deadline := time.Now().Add(2 * time.Second) // well within one look (liveness.LookEvery, 15 s)
|
|
for {
|
|
h, _ := bus.have("n1.xorg")
|
|
if h.Phase == nodeengineclient.PhaseRunning && h.Health == nodeengineclient.HealthOK {
|
|
return
|
|
}
|
|
if time.Now().After(deadline) {
|
|
t.Fatalf("not ok within a look of its apply: %+v", h)
|
|
}
|
|
time.Sleep(10 * time.Millisecond)
|
|
}
|
|
}
|