0
0
package providermain
import (
"context"
"errors"
"fmt"
"io/fs"
"log/slog"
"os"
"path/filepath"
"slices"
"github.com/johnandersen777/socialweb-computer-kcp/internal/clusterprovider"
"github.com/johnandersen777/socialweb-computer-kcp/internal/portallocator"
"github.com/johnandersen777/socialweb-computer-kcp/internal/subnetallocator"
)
type legacyKeys struct {
StateDir string
Ports *portallocator.Allocator
Networks *subnetallocator.Allocator
Log *slog.Logger
}
func migrateLegacyKeys(ctx context.Context, registry clusterprovider.Clusters, d legacyKeys) error {
if d.Log == nil {
d.Log = slog.Default()
}
refs, err := registry.Refs(ctx)
if err != nil {
return fmt.Errorf(
"clusterprovider: listing the Cluster CRs before the legacy-key migration: %w. The "+
"migration renames a state dir, a node dir and a mint credential from the bare "+
"cluster name to the cluster's own key, and a list that failed is not an empty "+
"tree: it would leave every legacy directory unclaimed and every later pass "+
"reading an empty state dir over a cluster that is running", err)
}
byName := map[string][]clusterprovider.Ref{}
for _, ref := range refs {
byName[ref.Name] = append(byName[ref.Name], ref)
}
names := make([]string, 0, len(byName))
for name := range byName {
names = append(names, name)
}
slices.Sort(names)
for _, name := range names {
group := byName[name]
if len(group) != 1 {
homes := make([]string, 0, len(group))
for _, ref := range group {
homes = append(homes, ref.Home)
}
d.Log.Warn("cluster provider: two or more home workspaces hold a Cluster with this "+
"name, so the legacy directories named by it belong to no one cluster and are left "+
"where they are",
"cluster", name, "homes", homes)
continue
}
key, err := group[0].Key()
if err != nil {
return err
}
if err := migrateOne(d, name, key); err != nil {
return err
}
}
return nil
}
func migrateOne(d legacyKeys, name, key string) error {
if name == key {
return nil
}
instance, err := clusterprovider.InstanceName(name)
if err != nil {
return err
}
instanceKey, err := clusterprovider.InstanceName(key)
if err != nil {
return err
}
for _, move := range []struct{ parent, from, to string }{
{d.StateDir, instance, instanceKey},
{d.StateDir, name, key},
} {
if move.parent == "" || move.from == move.to {
continue
}
if err := renameLegacy(d.Log, move.parent, move.from, move.to, name, key); err != nil {
return err
}
}
if d.Ports != nil {
moved, err := d.Ports.Rekey(name, key)
if err != nil {
return fmt.Errorf("clusterprovider: re-keying the port leases of %s to %s: %w", name, key, err)
}
if moved > 0 {
d.Log.Info("cluster provider: re-keyed the port leases of a legacy cluster name",
"cluster", name, "key", key, "leases", moved)
}
}
if d.Networks != nil {
moved, err := d.Networks.Rekey(name, key)
if err != nil {
return fmt.Errorf("clusterprovider: re-keying the subnet lease of %s to %s: %w", name, key, err)
}
if moved > 0 {
d.Log.Info("cluster provider: re-keyed the subnet lease of a legacy cluster name",
"cluster", name, "key", key, "leases", moved)
}
}
return nil
}
func renameLegacy(log *slog.Logger, parent, from, to, name, key string) error {
fromPath := filepath.Join(parent, from)
toPath := filepath.Join(parent, to)
if _, err := os.Stat(fromPath); err != nil {
if errors.Is(err, fs.ErrNotExist) {
return nil
}
return fmt.Errorf("clusterprovider: reading %s before the legacy-key migration: %w", fromPath, err)
}
if _, err := os.Stat(toPath); err == nil {
log.Warn("cluster provider: a legacy directory and this cluster's keyed directory both "+
"exist, so the legacy one is left exactly where it is and nothing is merged into the "+
"keyed one",
"cluster", name, "key", key, "legacy", fromPath, "keyed", toPath)
return nil
}
if err := os.Rename(fromPath, toPath); err != nil {
return fmt.Errorf("clusterprovider: renaming %s to %s: %w. The cluster's identity inside "+
"this provider is the key, and a state dir still named by the bare cluster name is one "+
"no later pass finds: the node records, the instance token and the identity bundle "+
"would all read as absent, and the first pass would provision over a cluster that is "+
"already running", fromPath, toPath, err)
}
log.Info("cluster provider: migrated a directory named by a bare cluster name to this "+
"cluster's key", "cluster", name, "key", key, "from", fromPath, "to", toPath)
return nil
}