Skip to content

armgit / Pulse

Public Imported from GitHub
0

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.

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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()
+ })
+ }
+}