Builds: design 47 G A-230 (answers G-22) Claude-Session: https://claude.ai/code/session_01NcbgfGKaxw984XyAPfLm4h
253 lines
8.1 KiB
Go
253 lines
8.1 KiB
Go
package recovery
|
|
|
|
import (
|
|
"context"
|
|
"crypto/sha256"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
seat "git.novox.be/novox/mesh-contracts/go/seats/meshrecovery"
|
|
"git.novox.be/novox/mesh-sdk/go/keys"
|
|
)
|
|
|
|
const pointFile = "point.json"
|
|
|
|
// run is the work of one accepted act; it ends the act with its event under the act's id (§560).
|
|
func (e *Engine) run(ctx context.Context, a *Act) {
|
|
var err error
|
|
switch a.Kind {
|
|
case KindTake:
|
|
err = e.take(ctx, a)
|
|
case KindExpire:
|
|
e.expire(a.ID, true)
|
|
case KindRestore:
|
|
err = e.restore(ctx, a)
|
|
case KindAside:
|
|
err = e.aside(ctx, a)
|
|
case KindRestoreAside:
|
|
err = e.restoreAside(ctx, a)
|
|
case KindDiscardAside:
|
|
err = e.discardAside(a)
|
|
default:
|
|
err = e.endedFailed(a, fmt.Errorf("no act of kind %q", a.Kind))
|
|
}
|
|
if err != nil {
|
|
e.logf("act %s ended failed: %v", a.ID, err)
|
|
a.Error = err.Error()
|
|
}
|
|
e.markEnded(a)
|
|
}
|
|
|
|
// sayEnd says the ending event of the act id (§554, §560): the act is first no longer the running one and written ended, so
|
|
// a caller told busy that asks again on hearing it is never told busy with the same act again.
|
|
func (e *Engine) sayEnd(id, event string, body any, parts ...string) {
|
|
e.mu.Lock()
|
|
if e.running != nil && e.running.ID == id {
|
|
e.markEnded(e.running)
|
|
e.running, e.cancel = nil, nil
|
|
}
|
|
e.mu.Unlock()
|
|
e.say(event, body, parts...)
|
|
}
|
|
|
|
// say publishes an event and logs the failure; an event lost is never silent.
|
|
func (e *Engine) say(event string, body any, parts ...string) {
|
|
if err := e.Seats.Say(event, body, parts...); err != nil {
|
|
e.logf("the event %s was not said: %v", event, err)
|
|
}
|
|
}
|
|
|
|
func (e *Engine) endedFailed(a *Act, why error) error {
|
|
why = e.stoppedOr(why)
|
|
e.sayEnd(a.ID, seat.EventEnded, seat.EndedEvent{Act: a.ID, At: e.now(), Module: a.Module, Kept: a.Kept, Form: a.Form,
|
|
Fingerprint: a.Fingerprint, Snapshot: a.Snapshot, Outcome: seat.EndedEventOutcomeFailed, Error: why.Error(), Why: cancelWhy(a, why)},
|
|
a.Module, a.Kept)
|
|
return why
|
|
}
|
|
|
|
// cancelWhy is the hand act's words for a cancel (A-117).
|
|
func cancelWhy(a *Act, why error) string {
|
|
if why != nil && why.Error() == ErrCanceled {
|
|
return a.Why
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// filled is the fill of the points directory without the temporary names of acts still writing.
|
|
func (e *Engine) filled() int64 {
|
|
return dirSize(filepath.Join(e.Dir, "points")) + dirSize(filepath.Join(e.Dir, "aside"))
|
|
}
|
|
|
|
// take is `snapshot-kept` and the hand verb `take` (§516, §564, §567): one stream at a time under a temporary name,
|
|
// renamed whole, its digests on the bus before `ended` is said.
|
|
func (e *Engine) take(ctx context.Context, a *Act) error {
|
|
dir, err := e.pointDir(a.Module, a.Kept, a.Form, a.Fingerprint)
|
|
if err != nil {
|
|
return e.endedFailed(a, err)
|
|
}
|
|
names, err := e.Seats.Streams(ctx, a.Module, a.Kept, a.Fingerprint)
|
|
if err != nil || len(names) == 0 {
|
|
if err == nil {
|
|
err = fmt.Errorf("%s's %s has no bus name at %s", a.Module, a.Kept, a.Fingerprint)
|
|
}
|
|
return e.endedFailed(a, err)
|
|
}
|
|
e.setStep(a, "measuring", "")
|
|
objs, err := e.Bus.Objects(ctx, names)
|
|
if err != nil {
|
|
return e.endedFailed(a, err)
|
|
}
|
|
var need int64
|
|
for _, o := range objs {
|
|
need += o.Bytes
|
|
}
|
|
if fill := e.filled(); fill+need > e.Settings.Cap {
|
|
return e.endedFailed(a, fmt.Errorf("%s: the cap is %d bytes, the point needs %d and the directory holds %d", ErrCap, e.Settings.Cap, need, fill))
|
|
}
|
|
tmp := filepath.Join(filepath.Dir(dir), ".tmp-"+a.ID)
|
|
_ = os.RemoveAll(tmp)
|
|
if err := os.MkdirAll(tmp, 0o700); err != nil {
|
|
return e.endedFailed(a, err)
|
|
}
|
|
defer os.RemoveAll(tmp)
|
|
p := seat.Point{At: e.now(), CatchUp: a.CatchUp, Fingerprint: a.Fingerprint, Form: a.Form, Kept: a.Kept, Module: a.Module,
|
|
Snapshot: strings.TrimPrefix(dir, filepath.Join(e.Dir, "points")+string(filepath.Separator))}
|
|
e.setStep(a, "taking", "")
|
|
for _, o := range objs {
|
|
if !o.Exists {
|
|
continue
|
|
}
|
|
file := filepath.Join(tmp, keys.EscapeName(o.Stream)+".snap")
|
|
sum, n, err := e.takeOne(ctx, o.Stream, file)
|
|
if err != nil {
|
|
return e.endedFailed(a, err)
|
|
}
|
|
p.Digests = append(p.Digests, seat.Digest{Name: o.Stream, Digest: sum})
|
|
p.Names = append(p.Names, o.Stream)
|
|
p.Size += n
|
|
p.Consumers = append(p.Consumers, o.Consumers...)
|
|
if e.filled()+p.Size > e.Settings.Cap {
|
|
return e.endedFailed(a, fmt.Errorf("%s: the stream grew while it was taken and passes the cap of %d bytes", ErrCap, e.Settings.Cap))
|
|
}
|
|
}
|
|
if err := writeJSON(filepath.Join(tmp, pointFile), p); err != nil {
|
|
return e.endedFailed(a, err)
|
|
}
|
|
_ = os.RemoveAll(dir)
|
|
if err := os.Rename(tmp, dir); err != nil {
|
|
return e.endedFailed(a, err)
|
|
}
|
|
raw, _ := jsonMarshal(p.Digests)
|
|
if err := e.Digests.Put(keys.EscapeName(p.Snapshot), raw); err != nil {
|
|
_ = os.RemoveAll(dir)
|
|
return e.endedFailed(a, fmt.Errorf("the digests are not on the bus: %w", err))
|
|
}
|
|
// The removal at each snapshot-kept (§551) runs within the take, before its ended, so one act runs at a time.
|
|
e.expire(a.ID, false)
|
|
e.sayEnd(a.ID, seat.EventEnded, seat.EndedEvent{Act: a.ID, At: e.now(), Module: a.Module, Kept: a.Kept, Form: a.Form,
|
|
Fingerprint: a.Fingerprint, Snapshot: p.Snapshot, Outcome: seat.EndedEventOutcomeDone, Consumers: p.Consumers,
|
|
Digests: p.Digests, Size: p.Size, CatchUp: p.CatchUp}, a.Module, a.Kept)
|
|
return nil
|
|
}
|
|
|
|
func (e *Engine) takeOne(ctx context.Context, stream, file string) (string, int64, error) {
|
|
f, err := os.Create(file)
|
|
if err != nil {
|
|
return "", 0, err
|
|
}
|
|
if err := e.Bus.Take(ctx, stream, f); err != nil {
|
|
f.Close()
|
|
return "", 0, fmt.Errorf("stream %s: %w", stream, err)
|
|
}
|
|
if err := f.Close(); err != nil {
|
|
return "", 0, err
|
|
}
|
|
return digestOf(file)
|
|
}
|
|
|
|
func digestOf(file string) (string, int64, error) {
|
|
f, err := os.Open(file)
|
|
if err != nil {
|
|
return "", 0, err
|
|
}
|
|
defer f.Close()
|
|
h := sha256.New()
|
|
n, err := io.Copy(h, f)
|
|
return "sha256:" + hex.EncodeToString(h.Sum(nil)), n, err
|
|
}
|
|
|
|
// Points lists every restore point in the directory, newest first (§517): the one place they are kept.
|
|
func (e *Engine) Points() ([]seat.Point, error) {
|
|
var out []seat.Point
|
|
root := filepath.Join(e.Dir, "points")
|
|
err := filepath.WalkDir(root, func(path string, d os.DirEntry, err error) error {
|
|
if err != nil {
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return nil
|
|
}
|
|
return err
|
|
}
|
|
if d.IsDir() && strings.HasPrefix(d.Name(), ".") {
|
|
return filepath.SkipDir
|
|
}
|
|
if !d.IsDir() && d.Name() == pointFile {
|
|
var p seat.Point
|
|
if err := readJSON(path, &p); err != nil {
|
|
return fmt.Errorf("%s: %w", path, err)
|
|
}
|
|
out = append(out, p)
|
|
}
|
|
return nil
|
|
})
|
|
sort.Slice(out, func(i, j int) bool { return out[i].At.After(out[j].At) })
|
|
return out, err
|
|
}
|
|
|
|
// expire is §551's removal: a point 90 days after its `at` (the setting), never the newest of its kept data, each removal
|
|
// said as point-removed and the run as expiry-ended, also when it removes nothing (§560). It runs inside an act: own when
|
|
// it is the act expire-points, whose ending event its expiry-ended is.
|
|
func (e *Engine) expire(act string, own bool) {
|
|
pts, err := e.Points()
|
|
if err != nil {
|
|
e.logf("expiry: %v", err)
|
|
}
|
|
newest := map[string]string{}
|
|
for _, p := range pts { // newest first
|
|
k := p.Module + "\x00" + p.Kept
|
|
if _, ok := newest[k]; !ok {
|
|
newest[k] = p.Snapshot
|
|
}
|
|
}
|
|
cutoff := e.now().Add(-time.Duration(e.Settings.KeepDays * float64(24*time.Hour)))
|
|
removed := int64(0)
|
|
for _, p := range pts {
|
|
if !p.At.Before(cutoff) || newest[p.Module+"\x00"+p.Kept] == p.Snapshot {
|
|
continue
|
|
}
|
|
if err := os.RemoveAll(filepath.Join(e.Dir, "points", p.Snapshot)); err != nil {
|
|
e.logf("the point %s is not removed: %v", p.Snapshot, err)
|
|
continue
|
|
}
|
|
_ = e.Digests.Delete(keys.EscapeName(p.Snapshot))
|
|
if err := e.Seats.HandAct(Module, "", "point-removed "+p.Snapshot, "older than the keep days"); err != nil {
|
|
e.logf("the removal of %s is not in the hand-act log: %v", p.Snapshot, err)
|
|
}
|
|
e.say(seat.EventPointRemoved, seat.PointRemovedEvent{Act: act, At: e.now(), Module: p.Module, Kept: p.Kept, Form: p.Form,
|
|
Fingerprint: p.Fingerprint, Snapshot: p.Snapshot}, p.Module, p.Kept)
|
|
removed++
|
|
}
|
|
ev := seat.ExpiryEndedEvent{Act: act, At: e.now(), Removed: removed}
|
|
if own {
|
|
e.sayEnd(act, seat.EventExpiryEnded, ev)
|
|
return
|
|
}
|
|
e.say(seat.EventExpiryEnded, ev)
|
|
}
|