Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Reproduce partial recovery when guest metadata cannot be imported
pulse-triage[bot]c794556acfd4
diff --git a/internal/api/configapi/config_import_metadata_test.go b/internal/api/configapi/config_import_metadata_test.gonew file mode 100644index 0000000000..6201f7047a--- /dev/null+++ b/internal/api/configapi/config_import_metadata_test.go@@ -0,0 +1,116 @@+package configapi++import (+ "bytes"+ "encoding/json"+ "net/http"+ "net/http/httptest"+ "os"+ "path/filepath"+ "reflect"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/config"+)++func TestHandleImportConfigMetadataFailureDoesNotApplyOrSucceed(t *testing.T) {+ for _, failure := range []string{"metadata_directory", "closed_store"} {+ t.Run(failure, func(t *testing.T) {+ const passphrase = "synthetic-import-validation-passphrase"+ cfg := &config.Config{DataPath: t.TempDir(), PublicURL: "https://keep.invalid", AuthUser: "keep-admin", AuthPass: "synthetic-auth-hash"}+ p := config.NewConfigPersistence(cfg.DataPath)+ settings := config.DefaultSystemSettings()+ settings.PublicURL = cfg.PublicURL+ if err := p.SaveSystemSettings(*settings); err != nil {+ t.Fatal(err)+ }+ if err := p.SaveAPITokens([]config.APITokenRecord{{ID: "keep-token", Hash: "synthetic-token-hash", OrgID: "default"}}); err != nil {+ t.Fatal(err)+ }+ store := p.GetGuestMetadataStore()+ if err := store.Set("keep:101", &config.GuestMetadata{Description: "Retained operator metadata"}); err != nil {+ t.Fatal(err)+ }+ metadataBefore := store.GetAll()+ if failure == "closed_store" {+ if err := store.Close(time.Second); err != nil {+ t.Fatal(err)+ }+ } else {+ metadataPath := filepath.Join(cfg.DataPath, "guest_metadata.json")+ if err := os.Remove(metadataPath); err != nil {+ t.Fatal(err)+ }+ if err := os.Mkdir(metadataPath, 0700); err != nil {+ t.Fatal(err)+ }+ }+ before := metadataImportFiles(t, cfg.DataPath)+ beforeConfig := cfg.DeepCopy()+ reloads, audits := 0, 0+ h := &ConfigHandlers{defaultConfig: cfg, defaultPersistence: p, reloadFunc: func() error { reloads++; return nil }}+ h.SetRuntimeDependencies(RuntimeDependencies{AuditEvent: func(_, event, _, _, _ string, success bool, _ string) {+ audits+++ if event != "config_imported" || success {+ t.Error("failed metadata import produced a success audit")+ }+ }})+ plaintext, err := json.Marshal(map[string]any{+ "version": "4.4", "nodes": map[string]any{}, "alerts": map[string]any{},+ "email": map[string]any{}, "webhooks": nil, "system": map[string]any{},+ "guestMetadata": map[string]any{"imported:202": map[string]string{"description": failure}},+ })+ if err != nil {+ t.Fatal(err)+ }+ request := ImportConfigRequest{Data: encryptedImportValidationFixture(t, plaintext, passphrase), Passphrase: passphrase}+ body, err := json.Marshal(request)+ if err != nil {+ t.Fatal(err)+ }+ rec := httptest.NewRecorder()+ h.HandleImportConfig(rec, httptest.NewRequest(http.MethodPost, "/api/config/import", bytes.NewReader(body)))+ if rec.Code != http.StatusBadRequest || rec.Body.String() != "Failed to import configuration. Verify the backup file and passphrase are correct.\n" {+ t.Fatalf("failed metadata import response = %d %q", rec.Code, rec.Body.String())+ }+ if reloads != 0 || audits != 1 || !reflect.DeepEqual(beforeConfig, cfg.DeepCopy()) {+ t.Error("failed import changed runtime or triggered apply")+ }+ if !reflect.DeepEqual(before, metadataImportFiles(t, cfg.DataPath)) || !reflect.DeepEqual(metadataBefore, store.GetAll()) {+ t.Error("failed import changed persisted or live state")+ }+ readback, err := json.Marshal(map[string]any{"request": request, "status": rec.Code, "contentType": rec.Header().Get("Content-Type"), "body": rec.Body.String()})+ if err != nil {+ t.Fatal(err)+ }+ t.Logf("SYNTHETIC_METADATA_IMPORT_REJECTION_READBACK %s", readback)+ })+ }+}++func metadataImportFiles(t *testing.T, dir string) map[string]string {+ t.Helper()+ files := make(map[string]string)+ if err := filepath.WalkDir(dir, func(path string, entry os.DirEntry, err error) error {+ if err != nil {+ return err+ }+ info, err := entry.Info()+ if err != nil {+ return err+ }+ files[path] = info.Mode().String()+ if !entry.IsDir() {+ data, err := os.ReadFile(path)+ if err != nil {+ return err+ }+ files[path] += string(data)+ }+ return nil+ }); err != nil {+ t.Fatal(err)+ }+ return files+}diff --git a/internal/config/export_metadata_transaction_test.go b/internal/config/export_metadata_transaction_test.gonew file mode 100644index 0000000000..106e1fb6ac--- /dev/null+++ b/internal/config/export_metadata_transaction_test.go@@ -0,0 +1,130 @@+package config++import (+ "encoding/json"+ "os"+ "path/filepath"+ "reflect"+ "strings"+ "testing"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/notifications"+)++func metadataImportArchive(t *testing.T, metadata map[string]*GuestMetadata) string {+ t.Helper()+ settings := DefaultSystemSettings()+ settings.PublicURL = "https://imported.invalid"+ data, err := json.Marshal(ExportData{+ Version: "4.4", System: *settings,+ Email: notifications.EmailConfig{SMTPHost: "imported.invalid", Password: "synthetic-imported-secret"},+ APITokens: []APITokenRecord{{ID: "imported-token", Hash: "synthetic-imported-hash", OrgID: "default"}},+ GuestMetadata: metadata,+ })+ if err != nil {+ t.Fatal(err)+ }+ return encryptImportValidationData(t, data)+}++func TestImportConfigMetadataFailurePreservesState(t *testing.T) {+ for _, failure := range []string{"metadata_directory", "closed_store", "later_destination", "later_destination_without_metadata_file"} {+ t.Run(failure, func(t *testing.T) {+ cp := seedImportValidationState(t)+ store := cp.GetGuestMetadataStore()+ metadataBefore := store.GetAll()+ metadataFile := filepath.Join(cp.configDir, "guest_metadata.json")+ var blocker string+ switch failure {+ case "metadata_directory":+ blocker = metadataFile+ case "closed_store":+ if err := store.Close(time.Second); err != nil {+ t.Fatal(err)+ }+ case "later_destination_without_metadata_file":+ if err := os.Remove(metadataFile); err != nil {+ t.Fatal(err)+ }+ blocker = cp.systemFile+ case "later_destination":+ blocker = cp.systemFile+ }+ if blocker != "" {+ if err := os.Remove(blocker); err != nil {+ t.Fatal(err)+ }+ if err := os.Mkdir(blocker, 0700); err != nil {+ t.Fatal(err)+ }+ if err := os.WriteFile(filepath.Join(blocker, "keep"), []byte("retained blocker"), 0600); err != nil {+ t.Fatal(err)+ }+ }+ before := importValidationFiles(t, cp.configDir)+ err := cp.ImportConfig(metadataImportArchive(t, map[string]*GuestMetadata{+ "imported:202": {Description: "Imported metadata", Tags: []string{"imported"}},+ }), "synthetic-import-validation-passphrase")+ if err == nil {+ t.Error("failed metadata recovery was reported as successful")+ }+ if !reflect.DeepEqual(before, importValidationFiles(t, cp.configDir)) {+ t.Error("failed import changed files, credentials or transaction artifacts")+ }+ if !reflect.DeepEqual(metadataBefore, store.GetAll()) {+ t.Error("failed import replaced live metadata")+ }+ })+ }+}++func TestImportConfigCommitsMetadataWithConfiguration(t *testing.T) {+ for _, inventory := range []string{"nil", "empty", "populated"} {+ t.Run(inventory, func(t *testing.T) {+ cp := seedImportValidationState(t)+ var metadata map[string]*GuestMetadata+ expected := map[string]*GuestMetadata{}+ if inventory == "empty" {+ metadata = map[string]*GuestMetadata{}+ }+ if inventory == "populated" {+ metadata = map[string]*GuestMetadata{+ "imported:202": {ID: "wrong-id", Description: "Imported description", Notes: []string{"retained note"}},+ "null-entry": nil,+ }+ expected["imported:202"] = &GuestMetadata{ID: "imported:202", Description: "Imported description", Notes: []string{"retained note"}, Tags: []string{}}+ }+ if err := cp.ImportConfig(metadataImportArchive(t, metadata), "synthetic-import-validation-passphrase"); err != nil {+ t.Fatal(err)+ }+ if !reflect.DeepEqual(cp.GetGuestMetadataStore().GetAll(), expected) {+ t.Error("successful import did not publish normalized metadata")+ }+ reloaded := NewGuestMetadataStore(cp.configDir, nil)+ if !reflect.DeepEqual(reloaded.GetAll(), expected) {+ t.Error("fresh metadata reader does not match the imported live state")+ }+ if err := cp.GetGuestMetadataStore().Load(); err != nil {+ t.Fatalf("committed metadata cannot be reloaded: %v", err)+ }+ settings, err := cp.LoadSystemSettings()+ if err != nil || settings.PublicURL != "https://imported.invalid" {+ t.Fatal("successful import did not persist settings")+ }+ tokens, err := cp.LoadAPITokens()+ if err != nil || len(tokens) != 1 || tokens[0].ID != "imported-token" {+ t.Fatal("successful import did not persist credentials")+ }+ info, err := os.Stat(filepath.Join(cp.configDir, "guest_metadata.json"))+ if err != nil || info.Mode().Perm() != 0600 {+ t.Fatal("imported metadata is not a private file")+ }+ for path := range importValidationFiles(t, cp.configDir) {+ if strings.HasPrefix(filepath.Base(path), ".import-") || strings.Contains(filepath.Base(path), ".import-backup-") {+ t.Error("successful import retained transaction staging")+ }+ }+ })+ }+}diff --git a/internal/config/import_transaction_restore_test.go b/internal/config/import_transaction_restore_test.gonew file mode 100644index 0000000000..b978a6033a--- /dev/null+++ b/internal/config/import_transaction_restore_test.go@@ -0,0 +1,68 @@+package config++import (+ "os"+ "path/filepath"+ "testing"+)++// Failed replacement must restore both overwritten files and the absence of+// files first created by this transaction, before returning to its caller.+func TestImportTransactionFailedCommitRestoresEveryTarget(t *testing.T) {+ for _, failure := range []string{"later_directory", "missing_staged_existing", "missing_staged_new"} {+ t.Run(failure, func(t *testing.T) {+ dir := t.TempDir()+ existing := filepath.Join(dir, "a-existing")+ created := filepath.Join(dir, "b-new")+ blocked := filepath.Join(dir, "z-directory")+ if err := os.WriteFile(existing, []byte("original"), 0640); err != nil {+ t.Fatal(err)+ }+ if err := os.Mkdir(blocked, 0700); err != nil {+ t.Fatal(err)+ }+ tx, err := newImportTransaction(dir)+ if err != nil {+ t.Fatal(err)+ }+ defer tx.Cleanup()+ for _, target := range []string{existing, created, blocked} {+ if err := tx.StageFile(target, []byte("replacement"), 0600); err != nil {+ t.Fatal(err)+ }+ }+ if failure != "later_directory" {+ target := existing+ if failure == "missing_staged_new" {+ target = created+ }+ if err := os.Remove(tx.staged[target]); err != nil {+ t.Fatal(err)+ }+ }+ if err := tx.Commit(); err == nil {+ t.Fatal("expected failed commit")+ }+ assertRestored := func() {+ t.Helper()+ data, err := os.ReadFile(existing)+ if err != nil || string(data) != "original" {+ t.Error("failed commit did not restore the original file")+ }+ info, err := os.Stat(existing)+ if err != nil || info.Mode().Perm() != 0640 {+ t.Error("failed commit did not restore original permissions")+ }+ if _, err := os.Stat(created); !os.IsNotExist(err) {+ t.Error("failed commit left a newly created configuration file")+ }+ if info, err := os.Stat(blocked); err != nil || !info.IsDir() {+ t.Error("failed commit changed the blocking directory")+ }+ }+ assertRestored()+ tx.Rollback()+ assertRestored()+ })+ }+}