Files
mesh-catalog/modules/mesh-recovery/internal/recovery/points.go
T

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)
}