admin
a829cdc91f
assertBundleDataComplete's claimed-tar checks pass trivially when discovery claims nothing (0 claims -> 0 checks) — the exact blind spot that shipped a 4.17 GB app as a 2308-byte config-only bundle. A needs_hdd manifest with neither HDD data nor volume data now fails the job with an honest Hungarian error. Red-proof recorded: removing the assertion returns scenario D to silent hollow success.
307 lines
11 KiB
Go
307 lines
11 KiB
Go
package appexport
|
|
|
|
import (
|
|
"archive/tar"
|
|
"compress/gzip"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
// C6B-F1 (v0.130.0) — the additive-export tests. A needs_hdd app bundles BOTH its HDD mounts
|
|
// and its named volumes (the old either/or dropped every needs_hdd app's volumes); a basename
|
|
// collision between mounts fails LOUDLY (the old code silently overwrote the first tar); the
|
|
// HDD round-trip places a "userdata" tar back at <HDD_PATH>/userdata through the untouched
|
|
// import mapping.
|
|
|
|
// listFabEntries returns the entry names inside an unencrypted .fab (tar.gz).
|
|
func listFabEntries(t *testing.T, fabPath string) map[string]int64 {
|
|
t.Helper()
|
|
f, err := os.Open(fabPath)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer f.Close()
|
|
gz, err := gzip.NewReader(f)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
tr := tar.NewReader(gz)
|
|
entries := map[string]int64{}
|
|
for {
|
|
hdr, err := tr.Next()
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
entries[filepath.ToSlash(hdr.Name)] = hdr.Size
|
|
}
|
|
return entries
|
|
}
|
|
|
|
func findFab(t *testing.T, drive string) string {
|
|
t.Helper()
|
|
entries, _ := os.ReadDir(ExportDir(drive))
|
|
for _, en := range entries {
|
|
if strings.HasSuffix(en.Name(), ".fab") {
|
|
return filepath.Join(ExportDir(drive), en.Name())
|
|
}
|
|
}
|
|
t.Fatal("no .fab produced")
|
|
return ""
|
|
}
|
|
|
|
// Scenario A (§7): the sonarr shape — a needs_hdd app with a populated userdata mount AND a
|
|
// named volume. The bundle must contain BOTH tars; the manifest must claim both.
|
|
// RED-PROOF (either/or): revert executeExport to the else-only volume branch → the volume tar
|
|
// is absent and has_volume_data=false → this test fails.
|
|
// RED-PROOF (discovery): with the pre-fix ${HDD_PATH}-only adapter the mount list is empty →
|
|
// has_hdd_data=false → this test fails (proven at the adapter level in stacks/export_mounts_test.go).
|
|
func TestExport_NeedsHDDBundlesBothUserdataAndVolumes(t *testing.T) {
|
|
swapDockerExec(t, func(c dockerCall, stdin io.Reader, stdout io.Writer) (string, error) {
|
|
switch c.args[0] {
|
|
case "create":
|
|
fmt.Fprint(stdout, "cid-123\n")
|
|
return "", nil
|
|
case "cp":
|
|
// stream a plausible non-empty tar for the volume
|
|
fmt.Fprint(stdout, strings.Repeat("VOLTAR", 100))
|
|
return "", nil
|
|
case "rm":
|
|
return "", nil
|
|
}
|
|
return "", fmt.Errorf("unexpected docker call: %v", c.args)
|
|
})
|
|
|
|
srcStack := t.TempDir()
|
|
os.WriteFile(filepath.Join(srcStack, "docker-compose.yml"),
|
|
[]byte("services:\n hdd-app:\n image: alpine\n"), 0644)
|
|
|
|
hdd := t.TempDir()
|
|
ud := filepath.Join(hdd, "userdata")
|
|
os.MkdirAll(filepath.Join(ud, "media", "tv"), 0755)
|
|
os.WriteFile(filepath.Join(ud, "media", "tv", "marker.bin"), []byte("USERDATA-MARKER-7"), 0644)
|
|
|
|
prov := &hddProvider{
|
|
rtProvider: &rtProvider{stackDir: srcStack, stacksDir: t.TempDir(), deployed: true,
|
|
volumes: []string{"hdd-app_config"}},
|
|
mounts: []string{ud}, hddPath: hdd,
|
|
}
|
|
drive := t.TempDir()
|
|
e := NewExporter(prov, log.New(io.Discard, "", 0), "test")
|
|
|
|
if err := e.StartExport(ExportRequest{StackName: "hdd-app", DestDrive: drive}); err != nil {
|
|
t.Fatalf("StartExport: %v", err)
|
|
}
|
|
job := waitJob(t, e)
|
|
if msg := jobErr(job); msg != "" {
|
|
t.Fatalf("export failed: %s", msg)
|
|
}
|
|
|
|
fabPath := findFab(t, drive)
|
|
man, err := ReadManifestFromFAB(fabPath)
|
|
if err != nil {
|
|
t.Fatalf("manifest: %v", err)
|
|
}
|
|
if !man.HasHDDData {
|
|
t.Error("has_hdd_data=false — the userdata mount was dropped (C6B-F1 cause 2)")
|
|
}
|
|
if !man.HasVolumeData {
|
|
t.Error("has_volume_data=false — the named volume was dropped (C6B-F1 cause 1, the either/or)")
|
|
}
|
|
|
|
entries := listFabEntries(t, fabPath)
|
|
if sz, ok := entries["data/hdd/userdata.tar"]; !ok || sz == 0 {
|
|
t.Errorf("bundle is missing a non-empty data/hdd/userdata.tar (entries: %v)", entries)
|
|
}
|
|
if sz, ok := entries["data/volumes/hdd-app_config.tar"]; !ok || sz == 0 {
|
|
t.Errorf("bundle is missing a non-empty data/volumes/hdd-app_config.tar (entries: %v)", entries)
|
|
}
|
|
}
|
|
|
|
// Scenario E (§7): a needs_hdd app whose volume export strands (cp writes nothing) must FAIL the
|
|
// whole job loudly — never a partial-success bundle with userdata but silently-missing volumes.
|
|
func TestExport_NeedsHDDVolumeStrandFailsLoud(t *testing.T) {
|
|
swapDockerExec(t, func(c dockerCall, stdin io.Reader, stdout io.Writer) (string, error) {
|
|
switch c.args[0] {
|
|
case "create":
|
|
fmt.Fprint(stdout, "cid-123\n")
|
|
return "", nil
|
|
case "cp":
|
|
return "", nil // stranded: nothing written
|
|
case "rm":
|
|
return "", nil
|
|
}
|
|
return "", fmt.Errorf("unexpected docker call: %v", c.args)
|
|
})
|
|
|
|
srcStack := t.TempDir()
|
|
os.WriteFile(filepath.Join(srcStack, "docker-compose.yml"),
|
|
[]byte("services:\n hdd-app:\n image: alpine\n"), 0644)
|
|
hdd := t.TempDir()
|
|
ud := filepath.Join(hdd, "userdata")
|
|
os.MkdirAll(ud, 0755)
|
|
os.WriteFile(filepath.Join(ud, "f.bin"), []byte("x"), 0644)
|
|
|
|
prov := &hddProvider{
|
|
rtProvider: &rtProvider{stackDir: srcStack, stacksDir: t.TempDir(), deployed: true,
|
|
volumes: []string{"vol1"}},
|
|
mounts: []string{ud}, hddPath: hdd,
|
|
}
|
|
drive := t.TempDir()
|
|
e := NewExporter(prov, log.New(io.Discard, "", 0), "test")
|
|
if err := e.StartExport(ExportRequest{StackName: "hdd-app", DestDrive: drive}); err != nil {
|
|
t.Fatalf("StartExport: %v", err)
|
|
}
|
|
job := waitJob(t, e)
|
|
if msg := jobErr(job); msg == "" {
|
|
t.Fatal("a stranded volume tar must FAIL a needs_hdd export too — got success")
|
|
}
|
|
entries, _ := os.ReadDir(ExportDir(drive))
|
|
for _, en := range entries {
|
|
if strings.HasSuffix(en.Name(), ".fab") {
|
|
t.Fatalf("a bundle was produced despite the stranded volume: %s", en.Name())
|
|
}
|
|
}
|
|
}
|
|
|
|
// §8: two mounts sharing a basename cannot round-trip through the basename-keyed manifest —
|
|
// the export must fail loudly instead of silently overwriting the first tar (the pre-fix
|
|
// behavior). RED-PROOF: drop the collision check in exportHDDData → this test fails.
|
|
func TestExport_HDDMountBasenameCollisionFailsLoud(t *testing.T) {
|
|
srcStack := t.TempDir()
|
|
os.WriteFile(filepath.Join(srcStack, "docker-compose.yml"),
|
|
[]byte("services:\n hdd-app:\n image: alpine\n"), 0644)
|
|
|
|
hdd := t.TempDir()
|
|
a := filepath.Join(hdd, "a", "config")
|
|
b := filepath.Join(hdd, "b", "config")
|
|
os.MkdirAll(a, 0755)
|
|
os.MkdirAll(b, 0755)
|
|
os.WriteFile(filepath.Join(a, "one.txt"), []byte("A"), 0644)
|
|
os.WriteFile(filepath.Join(b, "two.txt"), []byte("B"), 0644)
|
|
|
|
prov := &hddProvider{
|
|
rtProvider: &rtProvider{stackDir: srcStack, stacksDir: t.TempDir(), deployed: true},
|
|
mounts: []string{a, b}, hddPath: hdd,
|
|
}
|
|
drive := t.TempDir()
|
|
e := NewExporter(prov, log.New(io.Discard, "", 0), "test")
|
|
if err := e.StartExport(ExportRequest{StackName: "hdd-app", DestDrive: drive}); err != nil {
|
|
t.Fatalf("StartExport: %v", err)
|
|
}
|
|
job := waitJob(t, e)
|
|
msg := jobErr(job)
|
|
if msg == "" {
|
|
t.Fatal("a basename collision must FAIL the export — got success (silent overwrite)")
|
|
}
|
|
if !strings.Contains(msg, "config") {
|
|
t.Errorf("the error must name the colliding basename, got %q", msg)
|
|
}
|
|
}
|
|
|
|
// Scenario A' — the round-trip placement proof: an exported "userdata" tar restores back to
|
|
// <HDD_PATH>/userdata through the UNTOUCHED import mapping (basename → <HDD_PATH>/<subdir>
|
|
// fallback). This is the property that dictated capturing the userdata ROOT rather than
|
|
// per-bind subpaths.
|
|
func TestFabRoundTrip_UserdataPlacement(t *testing.T) {
|
|
const stack = "ud-app"
|
|
lg := log.New(io.Discard, "", 0)
|
|
|
|
hdd := t.TempDir()
|
|
ud := filepath.Join(hdd, "userdata")
|
|
os.MkdirAll(filepath.Join(ud, "media", "tv"), 0755)
|
|
marker := "ROUNDTRIP-MARKER-99"
|
|
os.WriteFile(filepath.Join(ud, "media", "tv", "show.bin"), []byte(marker), 0644)
|
|
|
|
srcStack := t.TempDir()
|
|
os.WriteFile(filepath.Join(srcStack, "docker-compose.yml"),
|
|
[]byte("services:\n ud-app:\n image: alpine\n volumes:\n - ${USERDATA_PATH}/media/tv:/tv\n"), 0644)
|
|
// app.yaml carries HDD_PATH into the bundle — the import derives every restore path from it.
|
|
os.WriteFile(filepath.Join(srcStack, "app.yaml"),
|
|
[]byte("deployed: true\nenv:\n HDD_PATH: "+hdd+"\n"), 0644)
|
|
|
|
prov := &hddProvider{
|
|
rtProvider: &rtProvider{stackDir: srcStack, stacksDir: t.TempDir(), deployed: true},
|
|
mounts: []string{ud}, hddPath: hdd,
|
|
}
|
|
drive := t.TempDir()
|
|
e := NewExporter(prov, lg, "test")
|
|
if err := e.StartExport(ExportRequest{StackName: stack, DestDrive: drive}); err != nil {
|
|
t.Fatalf("StartExport: %v", err)
|
|
}
|
|
job := waitJob(t, e)
|
|
if msg := jobErr(job); msg != "" {
|
|
t.Fatalf("export failed: %s", msg)
|
|
}
|
|
fabPath := findFab(t, drive)
|
|
|
|
// wipe the source userdata — the import must bring it back to the same place
|
|
if err := os.RemoveAll(ud); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
prov2 := &hddProvider{
|
|
rtProvider: &rtProvider{stackDir: srcStack, stacksDir: t.TempDir(), deployed: false},
|
|
hddPath: hdd,
|
|
}
|
|
e2 := NewExporter(prov2, lg, "test")
|
|
if err := e2.StartImport(ImportRequest{FABPath: fabPath}); err != nil {
|
|
t.Fatalf("StartImport: %v", err)
|
|
}
|
|
job = waitJob(t, e2)
|
|
if msg := jobErr(job); msg != "" {
|
|
t.Fatalf("import failed: %s", msg)
|
|
}
|
|
|
|
got, err := os.ReadFile(filepath.Join(hdd, "userdata", "media", "tv", "show.bin"))
|
|
if err != nil {
|
|
t.Fatalf("restored userdata not at <HDD_PATH>/userdata/media/tv/show.bin: %v", err)
|
|
}
|
|
if string(got) != marker {
|
|
t.Fatalf("restored content differs: got %q want %q", got, marker)
|
|
}
|
|
}
|
|
|
|
// Scenario D (§7) — the anti-hollow net (C6B-F1 cause 3): a needs_hdd app where discovery finds
|
|
// NOTHING (mounts absent on disk, no volumes) must FAIL the export with an honest Hungarian
|
|
// error — never success-with-a-hollow-bundle. RED-PROOF: remove the needs_hdd&&no-data assertion
|
|
// from assertBundleDataComplete → this test fails (the pre-fix silent hollow success).
|
|
func TestExport_NeedsHDDNoDataAtAllRefused(t *testing.T) {
|
|
srcStack := t.TempDir()
|
|
os.WriteFile(filepath.Join(srcStack, "docker-compose.yml"),
|
|
[]byte("services:\n hdd-app:\n image: alpine\n"), 0644)
|
|
|
|
hdd := t.TempDir()
|
|
prov := &hddProvider{
|
|
rtProvider: &rtProvider{stackDir: srcStack, stacksDir: t.TempDir(), deployed: true},
|
|
// the mount does NOT exist on disk and there are no volumes — total discovery blank
|
|
mounts: []string{filepath.Join(hdd, "userdata")}, hddPath: hdd,
|
|
}
|
|
drive := t.TempDir()
|
|
e := NewExporter(prov, log.New(io.Discard, "", 0), "test")
|
|
if err := e.StartExport(ExportRequest{StackName: "hdd-app", DestDrive: drive}); err != nil {
|
|
t.Fatalf("StartExport: %v", err)
|
|
}
|
|
job := waitJob(t, e)
|
|
msg := jobErr(job)
|
|
if msg == "" {
|
|
t.Fatal("a needs_hdd export with ZERO discovered data must FAIL — got success (the hollow bundle)")
|
|
}
|
|
if !strings.Contains(msg, "nem tartalmaz alkalmazásadatot") {
|
|
t.Errorf("expected the honest Hungarian no-app-data error, got %q", msg)
|
|
}
|
|
entries, _ := os.ReadDir(ExportDir(drive))
|
|
for _, en := range entries {
|
|
if strings.HasSuffix(en.Name(), ".fab") {
|
|
t.Fatalf("a hollow bundle was produced: %s", en.Name())
|
|
}
|
|
}
|
|
}
|