mesh-host/cmd/mesh-host/found.go

package main

import (
	"errors"
	"fmt"
	"os"
	"os/user"
	"path/filepath"
	"sort"
	"strings"
	"sync/atomic"
	"time"

	"github.com/novox/mesh-host/internal/apply"
	"github.com/novox/mesh-host/internal/link"
	"github.com/novox/mesh-host/internal/store"
)

// A directory used as found is never quiet (novox/hq issue 339).
//
// The engine leaves the owner and mode of a directory it did not make: changing them would be root handing a
// directory it never made to whichever account a declaration named. That is safe and, said nowhere, a module
// whose data directory it cannot write would simply fail. So each such directory is said three ways: a WARNING
// line in every apply's log; a resource of its module of kind `directory`, stated unhealthy on every look,
// which the controller raises as that module's condition naming the directory and its owner; and a way out,
// which is the operator's line at the controller's terminal — `nox node hand-over <node> <path>` on the
// control-node (novox/hq ADR 0272, issue 356) — after which the next apply gives it the declared owner and
// mode like any directory of the mesh's. The controller carries that line to this engine over the bus
// (link.AskHandOverSubject); the engine's own `hand-over` subcommand is the same act for a machine with no
// mesh to reach.

// foundState is where the node's state is, for the looks to read the directories used as found from; empty
// until the engine runs.
var foundState atomic.Value

// foundNode is this node's name in the mesh, for the way out to name it; empty until the engine is enrolled.
var foundNode atomic.Value

// handedOverFrom has the apply read the directories handed over from beside the state at statePath.
func handedOverFrom(statePath string) {
	apply.HandedOver = func() map[string]bool {
		all, err := store.LoadHandedOver(statePath)
		if err != nil {
			fmt.Fprintf(os.Stderr, "mesh-host: %v; no directory counts as handed over until it reads\n", err)
			return nil
		}
		out := map[string]bool{}
		for _, h := range all {
			out[apply.HandOverKey(h.ID, h.Path)] = true
		}
		return out
	}
}

// foundDirectories is every directory the node's state records as used as found, sorted by id.
func foundDirectories(known store.State) []store.Applied {
	var out []store.Applied
	for _, r := range known.Resources {
		if r.Type == "directory" && r.AsFound {
			out = append(out, r)
		}
	}
	sort.Slice(out, func(a, b int) bool { return out[a].ID < out[b].ID })
	return out
}

// handOverLine is the way out of a directory used as found, with this node's name when it is known: the node seat's
// hand-over with the directory's path, which asks the operator on their channel (novox/hq ADR 0563 §5). The controller
// that answered `nox node hand-over` ended by its unassignment (issue 1126), so that line has no answerer. The path is
// the resource's target beside the reason, never in it: the operator's channel withholds a path (ADR 0234 §6).
func handOverLine() string {
	node, _ := foundNode.Load().(string)
	if node == "" {
		node = "<node>"
	}
	return fmt.Sprintf("`%s/node-engine.hand-over` with the directory's path, then your yes on your channel", node)
}

// withFoundDirectories adds to a statement every directory used as found, as its module's resource of kind
// directory, unhealthy: the reason names its owner and mode as they are now, what was declared, and the line
// that hands it over. The path is the target, which the controller keeps as evidence.
func withFoundDirectories(h *link.Health, found []store.Applied) *link.Health {
	for _, r := range found {
		at := strings.LastIndex(r.ID, ".")
		if at <= 0 {
			continue
		}
		owner, mode := "unknown", "unknown"
		if info, err := os.Lstat(r.Target); err == nil {
			mode = fmt.Sprintf("%o", info.Mode().Perm())
			if uid, gid, ok := apply.OwnerOf(info); ok {
				owner = fmt.Sprintf("%d:%d", uid, gid)
			}
		}
		declared := r.Declared
		if declared == "" {
			declared = "another owner or mode"
		}
		h.Resources = append(h.Resources, link.ResourceHealth{Module: r.ID[:at], Resource: r.ID,
			Kind: link.KindDirectory, Target: r.Target, State: link.StateUnhealthy,
			Reason: fmt.Sprintf("%s owned by %s, mode %s, as found; %s was declared and not given it — %s, with its "+
				"path, hands it to the mesh", link.ReasonUsedAsFound, owner, mode, declared, handOverLine()),
			Since: foundSince(r).UTC()})
	}
	return h
}

// foundNow is the directories used as found, read from the node's state; none when it cannot be read, which
// the apply says on its own.
func foundNow() []store.Applied {
	path, _ := foundState.Load().(string)
	if path == "" {
		return nil
	}
	known, err := store.Load(path)
	if err != nil {
		return nil
	}
	return foundDirectories(known)
}

// handOverFound hands one directory used as found to the mesh, on the operator's word carried by the
// controller (link.HandOverFunc) or typed at this machine. It changes nothing on disk itself; the next apply
// gives the directory its declared owner and mode, and says so.
//
// **Every value is judged, and a refusal records nothing.** The path is the directory's absolute path exactly
// as the engine states it — clean, so `..` and a doubled separator never name a directory; one this machine's
// state records as used as found; on disk a directory and not a link, reached through no link. The engine
// never follows a path it did not state: a hand-over is root giving a directory to an account at the next
// apply, and a path that resolves elsewhere would give that elsewhere.
func handOverFound(statePath, path, by string) (string, error) {
	found, _, err := judgeFound(statePath, path)
	if err != nil {
		return "", err
	}
	if err := store.AddHandedOver(statePath, store.HandOver{ID: found.ID, Path: path, At: time.Now().UTC(), By: by}); err != nil {
		return "", err
	}
	return fmt.Sprintf("%s (%s) is handed to the mesh by %s: the next apply gives it %s, and it is the mesh's from "+
		"then on — removed when empty and no longer declared", path, found.ID, by, orUnsaid(found.Declared)), nil
}

// judgeFound is the judgement of a hand-over's path, recording nothing: the directory this machine uses as found at
// that path, as the engine states it, and what is on disk there.
func judgeFound(statePath, path string) (store.Applied, os.FileInfo, error) {
	if !filepath.IsAbs(path) {
		return store.Applied{}, nil, fmt.Errorf("hand-over takes the directory's absolute path, and %q is not one; nothing was handed over", path)
	}
	if filepath.Clean(path) != path {
		return store.Applied{}, nil, fmt.Errorf("%q is not the directory's path as the engine states it (no `..`, no doubled or trailing "+
			"separator); nothing was handed over", path)
	}
	known, err := store.Load(statePath)
	if err != nil {
		return store.Applied{}, nil, err
	}
	var found *store.Applied
	for _, r := range foundDirectories(known) {
		if filepath.Clean(r.Target) == path {
			r := r
			found = &r
			break
		}
	}
	if found == nil {
		return store.Applied{}, nil, errors.New(path + " is not a directory this machine uses as found (the module's condition names " +
			"the ones that are); nothing was handed over")
	}
	info, err := os.Lstat(path)
	switch {
	case err != nil:
		return store.Applied{}, nil, fmt.Errorf("%s cannot be read on this machine: %v; nothing was handed over", path, err)
	case info.Mode()&os.ModeSymlink != 0:
		return store.Applied{}, nil, fmt.Errorf("%s is a link, and the mesh hands over no link (novox/hq ADR 0012); nothing was handed over", path)
	case !info.IsDir():
		return store.Applied{}, nil, fmt.Errorf("%s is not a directory on this machine; nothing was handed over", path)
	}
	resolved, err := filepath.EvalSymlinks(path)
	if err != nil {
		return store.Applied{}, nil, fmt.Errorf("%s cannot be resolved on this machine: %v; nothing was handed over", path, err)
	}
	if resolved != path {
		return store.Applied{}, nil, fmt.Errorf("%s is reached through a link (it is %s), and the mesh hands over nothing through one "+
			"(novox/hq issue 339); nothing was handed over", path, resolved)
	}
	return *found, info, nil
}

// handOverFrom is the engine's hand-over for the controller's ask: the state beside statePath, the path as asked.
func handOverFrom(statePath string) link.HandOverFunc {
	return func(path, by string) (string, error) { return handOverFound(statePath, path, by) }
}

// handOverCommand is `nox-mesh-host hand-over <dir>` at this machine, as root: the same act, for a machine
// with no mesh to reach. The operator's line is `nox node hand-over <node> <dir>` on the control-node.
func handOverCommand(opts options) error {
	by := "a person at the machine"
	if u, err := user.Current(); err == nil {
		by = u.Username + " at the machine"
	}
	said, err := handOverFound(opts.state, filepath.Clean(opts.file), by)
	if err != nil {
		return err
	}
	fmt.Fprintln(opts.out, said)
	return nil
}

// foundSince is when a directory was first found as it is: kept across applies, so the controller can tell one
// a send found from one found before it. A record from before that was kept says when it was last applied.
func foundSince(r store.Applied) time.Time {
	if !r.FoundAt.IsZero() {
		return r.FoundAt
	}
	return r.AppliedAt
}

func orUnsaid(s string) string {
	if s == "" {
		return "the declared owner and mode"
	}
	return s
}