mesh-controller/internal/inventory/unseen.go

package inventory

import (
	"context"
	"encoding/json"
	"errors"
	"time"

	"github.com/jackc/pgx/v5"
)

// What a change replaces (novox/hq ADR 0217, to-be 44): the settings layer a set or a clear replaced,
// and a summary of what a machine was last sent. Both were missing when a change took effect unseen.

// Layer is one settings layer as it stands — the whole mesh's when nodeName is empty — and whether
// there is one. A layer is replaced whole when set; reading it first is how one key is changed
// without losing the others.
func (i *Inventory) Layer(ctx context.Context, nodeName, module string) (map[string]any, bool, error) {
	nodeID, err := i.layerNode(ctx, nodeName)
	if err != nil {
		return nil, false, err
	}
	// Said whole, as it was set: its config values and the placement kept beside them (novox/hq ADR 0348
	// clause 11), so a person reading it before setting it sees every key they may keep or remove.
	var raw []byte
	err = i.store.Pool().QueryRow(ctx, `select `+layerWhole+` from settings s
		  where s.module = $1 and s.node is not distinct from $2::uuid`,
		module, nodeID).Scan(&raw)
	if errors.Is(err, pgx.ErrNoRows) {
		return nil, false, nil
	}
	if err != nil {
		return nil, false, err
	}
	values := map[string]any{}
	if err := json.Unmarshal(raw, &values); err != nil {
		return nil, false, err
	}
	return values, true, nil
}

// PastLayer is a layer that was replaced or cleared.
type PastLayer struct {
	Values     map[string]any
	SetAt      *time.Time
	ReplacedAt time.Time
	// ReplacedBy is "set" or "clear".
	ReplacedBy string
	// SetBy is who had set the layer, when it was kept (novox/hq ADR 0277); empty for one set before that was kept.
	SetBy string
	// Why is why it went, where that was said: "moved to placement, ADR 0348 clause 11" for a layer whose
	// placement keys migration 0097 moved out of it (ReplacedBy "moved").
	Why string
}

// LayerOrigin is who set a layer and when (novox/hq ADR 0277): empty words for a layer set before who set it was
// kept, and has false where there is no layer.
func (i *Inventory) LayerOrigin(ctx context.Context, nodeName, module string) (setBy string, setAt time.Time, has bool, err error) {
	nodeID, err := i.layerNode(ctx, nodeName)
	if err != nil {
		return "", time.Time{}, false, err
	}
	var by *string
	err = i.store.Pool().QueryRow(ctx,
		`select set_by, set_at from settings where module = $1 and node is not distinct from $2::uuid`,
		module, nodeID).Scan(&by, &setAt)
	if errors.Is(err, pgx.ErrNoRows) {
		return "", time.Time{}, false, nil
	}
	if err != nil {
		return "", time.Time{}, false, err
	}
	if by != nil {
		setBy = *by
	}
	return setBy, setAt, true, nil
}

// SettingsHistory is every layer of one module on one machine — the whole mesh's when nodeName is
// empty — that was replaced or cleared, the latest first.
func (i *Inventory) SettingsHistory(ctx context.Context, nodeName, module string) ([]PastLayer, error) {
	nodeID, err := i.layerNode(ctx, nodeName)
	if err != nil {
		return nil, err
	}
	rows, err := i.store.Pool().Query(ctx,
		`select values, set_at, replaced_at, replaced_by, set_by, why from settings_history
		  where module = $1 and node is not distinct from $2::uuid order by replaced_at desc`,
		module, nodeID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var out []PastLayer
	for rows.Next() {
		var raw []byte
		var p PastLayer
		var by, why *string
		if err := rows.Scan(&raw, &p.SetAt, &p.ReplacedAt, &p.ReplacedBy, &by, &why); err != nil {
			return nil, err
		}
		if by != nil {
			p.SetBy = *by
		}
		if why != nil {
			p.Why = *why
		}
		if err := json.Unmarshal(raw, &p.Values); err != nil {
			return nil, err
		}
		out = append(out, p)
	}
	return out, rows.Err()
}

// keepReplacedSQL copies a layer into the history before it is replaced or cleared; run in the same
// transaction as the write where there is one, so a write that fails leaves no history of it.
//
// The layer is kept whole, as it was set: its config values and its placement (novox/hq ADR 0348 clause 11).
const keepReplacedSQL = `insert into settings_history (node, module, values, set_at, replaced_by, set_by)
	select s.node, s.module, ` + layerWhole + `, s.set_at, $3, s.set_by from settings s
	 where s.module = $1 and s.node is not distinct from $2::uuid`

// layerWhole is a settings row `s` with the placement kept beside it folded back in: the layer as it was set.
const layerWhole = `s.values || coalesce((select p.values from placement p
	 where p.module = s.module and p.node is not distinct from s.node), '{}'::jsonb)`

// layerNode is the node id of a layer, nil for the whole mesh's.
func (i *Inventory) layerNode(ctx context.Context, nodeName string) (*string, error) {
	if nodeName == "" {
		return nil, nil
	}
	n, err := i.NodeByName(ctx, nodeName)
	if err != nil {
		return nil, err
	}
	return &n.ID, nil
}

// RecordSentSummary keeps what a machine was last sent, summarised (migration 0078): read only to
// compare what would be sent with it, never as what the machine should be.
func (i *Inventory) RecordSentSummary(ctx context.Context, node string, summary []byte) error {
	_, err := i.store.Pool().Exec(ctx, `update node set sent_summary = $2 where id = $1`, node, summary)
	return err
}

// SentSummary is what a machine was last sent, summarised, by its name; empty for a machine sent
// nothing since the summary was first kept.
func (i *Inventory) SentSummary(ctx context.Context, name string) ([]byte, error) {
	var raw []byte
	err := i.store.Pool().QueryRow(ctx,
		`select sent_summary from node where name = $1`, name).Scan(&raw)
	if errors.Is(err, pgx.ErrNoRows) {
		return nil, nil
	}
	return raw, err
}