0
0
package clusterprovider
import (
"context"
"errors"
"fmt"
"log/slog"
"github.com/johnandersen777/socialweb-computer-kcp/internal/identitybundle"
"github.com/johnandersen777/socialweb-computer-kcp/internal/instance"
"github.com/johnandersen777/socialweb-computer-kcp/internal/materialiser"
"github.com/johnandersen777/socialweb-computer-kcp/internal/procgroup"
)
var (
ErrNoRowDeleter = errors.New(
"clusterprovider: the datastore holds a bootstrap row encrypted with the previous " +
"instance's token and no row deleter is wired, so k3s would exit immediately; " +
"see internal/instance")
ErrNoBundleSeeder = errors.New(
"clusterprovider: the identity bundle must be pre-seeded before k3s starts and no " +
"seeder is wired; see internal/identitybundle")
ErrNoBundle = errors.New(
"clusterprovider: no identity bundle source was supplied, so the pre-seeded entries " +
"cannot be verified; an unverified bundle is what GuardFor exists to refuse")
ErrNoTokenSource = errors.New(
"clusterprovider: no token source was supplied, so instance.PlanFor cannot answer; the " +
"token plan is not optional because a k3s started with the wrong token dies on the " +
"next start with 'bootstrap data already found and encrypted with different token'")
)
type GuardDeps struct {
Bundle func(cluster string) (*identitybundle.Bundle, error)
StateDir string
Token func(cluster string) instance.Token
HasRow func(ctx context.Context, cluster string) bool
DeleteRow func(ctx context.Context, cluster string) error
SeedBundle func(ctx context.Context, cluster string) error
Log *slog.Logger
}
func GuardFor(d GuardDeps) materialiser.IdentityGuard {
return func(ctx context.Context, o materialiser.Observed) error {
cluster := o.Cluster.Name
log := d.Log
if log == nil {
log = slog.Default()
}
dir, err := ClusterDataDir(d.StateDir, cluster)
if err != nil {
return err
}
if d.Token == nil {
return fmt.Errorf("%w (cluster %s)", ErrNoTokenSource, cluster)
}
if d.Bundle == nil {
return fmt.Errorf("%w (cluster %s)", ErrNoBundle, cluster)
}
if uid := string(o.Cluster.UID); uid != "" {
bdir, err := BundleDir(d.StateDir, cluster)
if err != nil {
return err
}
adopted, err := identitybundle.BindClusterUID(bdir, uid)
if err != nil {
return fmt.Errorf("clusterprovider: %s: refusing to seed or verify it: %w", cluster, err)
}
if adopted {
log.Info("guard: identity bundle adopted for uid", "cluster", cluster, "uid", uid)
}
}
plan, err := instance.PlanFor(d.Token(cluster), d.HasRow != nil && d.HasRow(ctx, cluster))
if err != nil {
return fmt.Errorf("clusterprovider: the token plan for %s: %w", cluster, err)
}
log.Info("guard: token plan", "cluster", cluster, "dataDir", dir,
"deleteBootstrapRow", plan.DeleteBootstrapRow, "reSeedBundle", plan.ReSeedBundle,
"reason", plan.Reason)
if plan.DeleteBootstrapRow {
if d.DeleteRow == nil {
return fmt.Errorf("%w (cluster %s)", ErrNoRowDeleter, cluster)
}
if err := d.DeleteRow(ctx, cluster); err != nil {
return fmt.Errorf("clusterprovider: deleting the bootstrap row for %s: %w", cluster, err)
}
}
if plan.ReSeedBundle {
if d.SeedBundle == nil {
return fmt.Errorf("%w (cluster %s)", ErrNoBundleSeeder, cluster)
}
if err := d.SeedBundle(ctx, cluster); err != nil && !errors.Is(err, ErrNoBundleYet) {
return fmt.Errorf("clusterprovider: seeding the identity bundle for %s: %w", cluster, err)
}
}
b, err := d.Bundle(cluster)
if errors.Is(err, ErrNoBundleYet) {
log.Warn("guard: no identity bundle is persisted for this cluster yet, so there is "+
"nothing to verify. k3s authors the 13 entries on a datastore with no bootstrap row, "+
"and the harvest after the group is up is what persists them; every later start "+
"seeds from that copy and verifies it byte for byte",
"cluster", cluster, "bundleDir", dir)
return nil
}
if err != nil {
return err
}
root, err := bundleRoot(d.StateDir, cluster)
if err != nil {
return err
}
return b.Verify(root)
}
}
var ErrNoHarvestSeam = errors.New(
"clusterprovider: this Stack puts no k3s step in the group, so there is no moment after " +
"the CAs exist and before anything else could need them, and the harvest would SILENTLY " +
"NOT RUN -- a bundle harvested by nothing and a bundle harvested correctly look " +
"identical from a green suite")
func HarvestAfterK3s(steps []procgroup.Step, harvest func(ctx context.Context, cluster string) error, cluster string) ([]procgroup.Step, error) {
if harvest == nil {
return nil, fmt.Errorf(
"clusterprovider: this Stack has a k3s step and no identity-bundle harvest, so the " +
"cluster's CAs would never be persisted and every rebuild would be a NEW cluster " +
"under the same name -- invalidating every kubeconfig issued before it")
}
idx := -1
for i, s := range steps {
if s.Name == procgroup.ComponentK3s {
idx = i
break
}
}
if idx < 0 {
return nil, ErrNoHarvestSeam
}
inner := steps[idx].Ready
steps[idx].Ready = func(ctx context.Context, p procgroup.Member) error {
if inner != nil {
if err := inner(ctx, p); err != nil {
return err
}
}
return harvest(ctx, cluster)
}
return steps, nil
}