f-37: migration: add state change at boot #37

Signed-off-by: GnomeZworc <nicolas.boufidjeline@g3e.fr>

internal/migration/state.go

@@ -0,0 +1,84 @@
+// Package migration met la DB au format attendu par la version courante de
+// l'agent. Les migrations sont idempotentes et jouées au démarrage.
+package migration
+
+import (
+	"fmt"
+	"log/slog"
+	"strings"
+
+	"git.g3e.fr/syonad/two/internal/state"
+	"git.g3e.fr/syonad/two/pkg/db/kv"
+
+	"github.com/dgraph-io/badger/v4"
+)
+
+// prefixes énumère les familles de ressources portant une clé /state.
+var prefixes = []string{"vpc/", "subnet/", "vm/"}
+
+// legacyStates traduit l'ancien vocabulaire (états VPC/subnet d'avant
+// l'unification, et états VM start/stop) vers l'enum courant.
+var legacyStates = map[string]state.State{
+	"created":  state.Running,
+	"started":  state.Running,
+	"starting": state.Creating,
+	"stopping": state.Deleting,
+	"stopped":  state.Deleted,
+}
+
+// MigrateStates convertit les valeurs de state héritées vers l'enum courant,
+// puis marque en erreur les ressources restées dans un état transitoire.
+//
+// La réconciliation est sûre au démarrage : la queue worker est en mémoire et
+// vide à ce moment, donc aucune commande n'est en cours. Une ressource en
+// creating/deleting est nécessairement orpheline d'un arrêt de l'agent — sans
+// ce passage en error, elle resterait indéfiniment non supprimable.
+func MigrateStates(db *badger.DB, log *slog.Logger) error {
+	for _, prefix := range prefixes {
+		entries, err := kv.ListByPrefix(db, prefix)
+		if err != nil {
+			return fmt.Errorf("list %s: %w", prefix, err)
+		}
+		for key, value := range entries {
+			if !strings.HasSuffix(key, "/state") {
+				continue
+			}
+			resource := strings.TrimSuffix(key, "/state")
+			target, reason := targetState(value)
+			if target == "" {
+				continue
+			}
+			if err := state.Set(db, resource, target); err != nil {
+				return fmt.Errorf("migrate %s: %w", key, err)
+			}
+			log.Info("state migrated",
+				"resource", resource, "from", value, "to", string(target), "reason", reason)
+		}
+	}
+	return nil
+}
+
+// targetState retourne l'état vers lequel migrer une valeur brute, ou "" si
+// elle doit rester inchangée.
+func targetState(value string) (state.State, string) {
+	if legacy, ok := legacyStates[value]; ok {
+		// Un état hérité transitoire est orphelin au même titre qu'un état
+		// transitoire courant : on applique la réconciliation directement.
+		if state.IsTransient(legacy) {
+			return state.Error, "orphaned legacy state"
+		}
+		return legacy, "legacy state"
+	}
+
+	current, err := state.Parse(value)
+	if err != nil {
+		// Valeur inconnue : ni l'ancien vocabulaire, ni le nouveau. On la
+		// bascule en error plutôt que de la laisser bloquer l'agent — la
+		// ressource reste visible et supprimable.
+		return state.Error, "unknown state"
+	}
+	if state.IsTransient(current) {
+		return state.Error, "orphaned transient state"
+	}
+	return "", ""
+}