package statemgr import ( "io/ioutil" "os" "os/exec" "path/filepath" "strings" "sync" "testing" "github.com/go-test/deep" version "github.com/hashicorp/go-version" "github.com/zclconf/go-cty/cty" "github.com/hashicorp/terraform/internal/addrs" "github.com/hashicorp/terraform/states" "github.com/hashicorp/terraform/states/statefile" tfversion "github.com/hashicorp/terraform/version" ) func TestFilesystem(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() ls := testFilesystem(t) defer os.Remove(ls.readPath) TestFull(t, ls) } func TestFilesystemRace(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() ls := testFilesystem(t) defer os.Remove(ls.readPath) current := TestFullInitialState() var wg sync.WaitGroup for i := 0; i < 100; i++ { wg.Add(1) go func() { defer wg.Done() ls.WriteState(current) }() } wg.Wait() } func TestFilesystemLocks(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() s := testFilesystem(t) defer os.Remove(s.readPath) // lock first info := NewLockInfo() info.Operation = "test" lockID, err := s.Lock(info) if err != nil { t.Fatal(err) } out, err := exec.Command("go", "run", "testdata/lockstate.go", s.path).CombinedOutput() if err != nil { t.Fatal("unexpected lock failure", err, string(out)) } if !strings.Contains(string(out), "lock failed") { t.Fatal("expected 'locked failed', got", string(out)) } // check our lock info lockInfo, err := s.lockInfo() if err != nil { t.Fatal(err) } if lockInfo.Operation != "test" { t.Fatalf("invalid lock info %#v\n", lockInfo) } // a noop, since we unlock on exit if err := s.Unlock(lockID); err != nil { t.Fatal(err) } // local locks can re-lock lockID, err = s.Lock(info) if err != nil { t.Fatal(err) } if err := s.Unlock(lockID); err != nil { t.Fatal(err) } // we should not be able to unlock the same lock twice if err := s.Unlock(lockID); err == nil { t.Fatal("unlocking an unlocked state should fail") } // make sure lock info is gone lockInfoPath := s.lockInfoPath() if _, err := os.Stat(lockInfoPath); !os.IsNotExist(err) { t.Fatal("lock info not removed") } } // Verify that we can write to the state file, as Windows' mandatory locking // will prevent writing to a handle different than the one that hold the lock. func TestFilesystem_writeWhileLocked(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() s := testFilesystem(t) defer os.Remove(s.readPath) // lock first info := NewLockInfo() info.Operation = "test" lockID, err := s.Lock(info) if err != nil { t.Fatal(err) } defer func() { if err := s.Unlock(lockID); err != nil { t.Fatal(err) } }() if err := s.WriteState(TestFullInitialState()); err != nil { t.Fatal(err) } } func TestFilesystem_pathOut(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() f, err := ioutil.TempFile("", "tf") if err != nil { t.Fatalf("err: %s", err) } f.Close() defer os.Remove(f.Name()) ls := testFilesystem(t) ls.path = f.Name() defer os.Remove(ls.path) TestFull(t, ls) } func TestFilesystem_backup(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() f, err := ioutil.TempFile("", "tf") if err != nil { t.Fatalf("err: %s", err) } f.Close() defer os.Remove(f.Name()) ls := testFilesystem(t) backupPath := f.Name() ls.SetBackupPath(backupPath) TestFull(t, ls) // The backup functionality should've saved a copy of the original state // prior to all of the modifications that TestFull does. bfh, err := os.Open(backupPath) if err != nil { t.Fatal(err) } bf, err := statefile.Read(bfh) if err != nil { t.Fatal(err) } origState := TestFullInitialState() if !bf.State.Equal(origState) { for _, problem := range deep.Equal(origState, bf.State) { t.Error(problem) } } } // This test verifies a particularly tricky behavior where the input file // is overridden and backups are enabled at the same time. This combination // requires special care because we must ensure that when we create a backup // it is of the original contents of the output file (which we're overwriting), // not the contents of the input file (which is left unchanged). func TestFilesystem_backupAndReadPath(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() workDir, err := ioutil.TempDir("", "tf") if err != nil { t.Fatalf("failed to create temporary directory: %s", err) } defer os.RemoveAll(workDir) markerOutput := addrs.OutputValue{Name: "foo"}.Absolute(addrs.RootModuleInstance) outState := states.BuildState(func(ss *states.SyncState) { ss.SetOutputValue( markerOutput, cty.StringVal("from-output-state"), false, // not sensitive ) }) outFile, err := os.Create(filepath.Join(workDir, "output.tfstate")) if err != nil { t.Fatalf("failed to create temporary outFile %s", err) } defer outFile.Close() err = statefile.Write(&statefile.File{ Lineage: "-", Serial: 0, TerraformVersion: version.Must(version.NewVersion("1.2.3")), State: outState, }, outFile) if err != nil { t.Fatalf("failed to write initial outfile state to %s: %s", outFile.Name(), err) } inState := states.BuildState(func(ss *states.SyncState) { ss.SetOutputValue( markerOutput, cty.StringVal("from-input-state"), false, // not sensitive ) }) inFile, err := os.Create(filepath.Join(workDir, "input.tfstate")) if err != nil { t.Fatalf("failed to create temporary inFile %s", err) } defer inFile.Close() err = statefile.Write(&statefile.File{ Lineage: "-", Serial: 0, TerraformVersion: version.Must(version.NewVersion("1.2.3")), State: inState, }, inFile) if err != nil { t.Fatalf("failed to write initial infile state to %s: %s", inFile.Name(), err) } backupPath := outFile.Name() + ".backup" ls := NewFilesystemBetweenPaths(inFile.Name(), outFile.Name()) ls.SetBackupPath(backupPath) newState := states.BuildState(func(ss *states.SyncState) { ss.SetOutputValue( markerOutput, cty.StringVal("from-new-state"), false, // not sensitive ) }) err = ls.WriteState(newState) if err != nil { t.Fatalf("failed to write new state: %s", err) } // The backup functionality should've saved a copy of the original contents // of the _output_ file, even though the first snapshot was read from // the _input_ file. t.Run("backup file", func(t *testing.T) { bfh, err := os.Open(backupPath) if err != nil { t.Fatal(err) } bf, err := statefile.Read(bfh) if err != nil { t.Fatal(err) } os := bf.State.OutputValue(markerOutput) if got, want := os.Value, cty.StringVal("from-output-state"); !want.RawEquals(got) { t.Errorf("wrong marker value in backup state file\ngot: %#v\nwant: %#v", got, want) } }) t.Run("output file", func(t *testing.T) { ofh, err := os.Open(outFile.Name()) if err != nil { t.Fatal(err) } of, err := statefile.Read(ofh) if err != nil { t.Fatal(err) } os := of.State.OutputValue(markerOutput) if got, want := os.Value, cty.StringVal("from-new-state"); !want.RawEquals(got) { t.Errorf("wrong marker value in backup state file\ngot: %#v\nwant: %#v", got, want) } }) } func TestFilesystem_nonExist(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() ls := NewFilesystem("ishouldntexist") if err := ls.RefreshState(); err != nil { t.Fatalf("err: %s", err) } if state := ls.State(); state != nil { t.Fatalf("bad: %#v", state) } } func TestFilesystem_lockUnlockWithoutWrite(t *testing.T) { info := NewLockInfo() info.Operation = "test" ls := testFilesystem(t) // Delete the just-created tempfile so that Lock recreates it os.Remove(ls.path) // Lock the state, and in doing so recreate the tempfile lockID, err := ls.Lock(info) if err != nil { t.Fatal(err) } if !ls.created { t.Fatal("should have marked state as created") } if err := ls.Unlock(lockID); err != nil { t.Fatal(err) } _, err = os.Stat(ls.path) if os.IsNotExist(err) { // Success! Unlocking the state successfully deleted the tempfile return } else if err != nil { t.Fatalf("unexpected error from os.Stat: %s", err) } else { os.Remove(ls.readPath) t.Fatal("should have removed path, but exists") } } func TestFilesystem_impl(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() var _ Reader = new(Filesystem) var _ Writer = new(Filesystem) var _ Persister = new(Filesystem) var _ Refresher = new(Filesystem) var _ Locker = new(Filesystem) } func testFilesystem(t *testing.T) *Filesystem { f, err := ioutil.TempFile("", "tf") if err != nil { t.Fatalf("failed to create temporary file %s", err) } t.Logf("temporary state file at %s", f.Name()) err = statefile.Write(&statefile.File{ Lineage: "test-lineage", Serial: 0, TerraformVersion: version.Must(version.NewVersion("1.2.3")), State: TestFullInitialState(), }, f) if err != nil { t.Fatalf("failed to write initial state to %s: %s", f.Name(), err) } f.Close() ls := NewFilesystem(f.Name()) if err := ls.RefreshState(); err != nil { t.Fatalf("initial refresh failed: %s", err) } return ls } // Make sure we can refresh while the state is locked func TestFilesystem_refreshWhileLocked(t *testing.T) { defer testOverrideVersion(t, "1.2.3")() f, err := ioutil.TempFile("", "tf") if err != nil { t.Fatalf("err: %s", err) } err = statefile.Write(&statefile.File{ Lineage: "test-lineage", Serial: 0, TerraformVersion: version.Must(version.NewVersion("1.2.3")), State: TestFullInitialState(), }, f) if err != nil { t.Fatalf("err: %s", err) } f.Close() s := NewFilesystem(f.Name()) defer os.Remove(s.path) // lock first info := NewLockInfo() info.Operation = "test" lockID, err := s.Lock(info) if err != nil { t.Fatal(err) } defer func() { if err := s.Unlock(lockID); err != nil { t.Fatal(err) } }() if err := s.RefreshState(); err != nil { t.Fatal(err) } readState := s.State() if readState == nil { t.Fatal("missing state") } } func testOverrideVersion(t *testing.T, v string) func() { oldVersionStr := tfversion.Version oldPrereleaseStr := tfversion.Prerelease oldSemVer := tfversion.SemVer var newPrereleaseStr string if dash := strings.Index(v, "-"); dash != -1 { newPrereleaseStr = v[dash+1:] v = v[:dash] } newSemVer, err := version.NewVersion(v) if err != nil { t.Errorf("invalid override version %q: %s", v, err) } newVersionStr := newSemVer.String() tfversion.Version = newVersionStr tfversion.Prerelease = newPrereleaseStr tfversion.SemVer = newSemVer return func() { // reset function tfversion.Version = oldVersionStr tfversion.Prerelease = oldPrereleaseStr tfversion.SemVer = oldSemVer } }