mesh-catalog/modules/disk-load/cmd/disk-load/readings_tools.go

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"sort"
	"strings"
	"time"

	stdio "git.novox.be/novox/mesh-sdk/go"
	"git.novox.be/novox/mesh-sdk/go/health"
)

// ReadingTools are the tools over the state `readings`: every key, one key, how full the state is, and one item
// measured now (a module's tools are its command line).
func ReadingTools(k *Keeper) []stdio.Tool {
	return []stdio.Tool{
		{
			Name: "disk_readings",
			Description: "The data readings disk-load keeps for this machine's data items (ADR 0233, ADR 0571 clause 3): every key " +
				"`<node>.<module>.<item>` with its size, newest write, measured-at, precision and seven-day peak, or one key with " +
				"all it holds when `key` is given; and how full the state is: keys kept, their bytes, and the cap the bus puts on " +
				"a state (none declared). Filter by `module`. (r)",
			Input: map[string]any{
				"key":    map[string]any{"type": "string", "description": "one key, <node>.<module>.<item>, with everything it holds"},
				"module": map[string]any{"type": "string", "description": "only this module's items"},
			},
			Run: func(args map[string]any) (any, error) {
				if key := text(args, "key"); key != "" {
					raw, err := k.Store.Get(key)
					if err != nil {
						return nil, err
					}
					if len(raw) == 0 {
						return nil, fmt.Errorf("no reading is kept at %q", key)
					}
					r, err := health.DecodeReading(raw)
					return r, err
				}
				keys, err := k.Store.Keys()
				if err != nil {
					return nil, err
				}
				sort.Strings(keys)
				module := text(args, "module")
				type line struct {
					Key       string         `json:"key"`
					SizeBytes *int64         `json:"size_bytes,omitempty"`
					PeakBytes *int64         `json:"peak_bytes,omitempty"`
					Precision string         `json:"precision,omitempty"`
					Error     string         `json:"error,omitempty"`
					Reading   health.Reading `json:"-"`
				}
				var lines []line
				total := 0
				for _, key := range keys {
					raw, err := k.Store.Get(key)
					if err != nil {
						return nil, err
					}
					total += len(raw)
					r, err := health.DecodeReading(raw)
					if err != nil || (module != "" && r.Module != module) {
						continue
					}
					lines = append(lines, line{Key: key, SizeBytes: r.SizeBytes, PeakBytes: r.Peak, Precision: r.Precision, Error: r.Error})
				}
				return map[string]any{"readings": lines, "fill": map[string]any{"keys": len(keys), "bytes": total,
					"cap": "none declared: the bus's own limit on a state applies"}}, nil
			},
		},
		{
			Name: "disk_round",
			Description: "How far this machine's last round of measuring its data items got (novox/hq ADR 0577 clause 3), from " +
				"disk-load's state `rounds`, this machine's key `<node>`: when it started and ended (no end while it runs), how " +
				"many items it had, measured, wrote and kept unchanged, each item that failed and why, and how old the round is. " +
				"A round that never ends, or fails every item, shows here. (r)",
			Input: map[string]any{},
			Run: func(args map[string]any) (any, error) {
				node := k.Node
				if k.Rounds == nil {
					return nil, fmt.Errorf("this disk-load keeps no rounds")
				}
				raw, err := k.Rounds.Get(node)
				if err != nil {
					return nil, err
				}
				if len(raw) == 0 {
					return nil, fmt.Errorf("no round of %s is kept yet: its first round starts a few minutes after disk-load starts", node)
				}
				var r Round
				if err := json.Unmarshal(raw, &r); err != nil {
					return nil, fmt.Errorf("the round of %s is not readable: %w", node, err)
				}
				state := "ended"
				if r.Ended == nil {
					state = "running"
				}
				return map[string]any{"round": r, "state": state,
					"age": k.Measurer.Now().UTC().Sub(r.Started).Round(time.Second).String()}, nil
			},
		},
		{
			Name: "disk_measure",
			Description: "Measure one data item of this machine now, whatever its method (a walk too), and write its reading when it " +
				"changed. Reads the disks as root: a walk is bounded by time and files and says when it was partial.",
			Input: map[string]any{
				"module": map[string]any{"type": "string", "description": "the module that declares the item"},
				"item":   map[string]any{"type": "string", "description": "the item's id"},
			},
			Run: func(args map[string]any) (any, error) {
				module, item := text(args, "module"), text(args, "item")
				if module == "" || item == "" {
					return nil, fmt.Errorf("module and item are required")
				}
				r, written, err := k.MeasureNow(context.Background(), module, item)
				if err != nil {
					return nil, err
				}
				return map[string]any{"written": written, "reading": r, "key": health.ReadingKey(k.Node, module, item),
					"note": strings.TrimSpace(map[bool]string{true: "the reading changed and was written", false: "the reading had not changed"}[written])}, nil
			},
		},
	}
}