mirror of
https://github.com/opentffoundation/opentf.git
synced 2025-12-25 01:00:16 -05:00
67a5cd0911
This extends statemgr.Persistent, statemgr.Locker and remote.Client to all expect context.Context parameters, and then updates all of the existing implementations of those interfaces to support them. All of the calls to statemgr.Persistent and statemgr.Locker methods outside of tests are consistently context.TODO() for now, because the caller landscape of these interfaces has some complications: 1. statemgr.Locker is also used by the clistate package for its state implementation that was derived from statemgr.Filesystem's predecessor, even though what clistate manages is not actually "state" in the sense of package statemgr. The callers of that are not yet ready to provide real contexts. In a future commit we'll either need to plumb context through to all of the clistate callers, or continue the effort to separate statemgr from clistate by introducing a clistate-specific "locker" API for it to use instead. 2. We call statemgr.Persistent and statemgr.Locker methods in situations where the active context might have already been cancelled, and so we'll need to make sure to ignore cancellation when calling those. This is mainly limited to PersistState and Unlock, since both need to be able to complete after a cancellation, but there are various codepaths that perform a Lock, Refresh, Persist, Unlock sequence and so it isn't yet clear where is the best place to enforce the invariant that Persist and Unlock must not be called with a cancelable context. We'll deal with that more in subsequent commits. Within the various state manager and remote client implementations the contexts _are_ wired together as best as possible with how these subsystems are already laid out, and so once we deal with the problems above and make callers provide suitable contexts they should be able to reach all of the leaf API clients that might want to generate OpenTelemetry traces. Signed-off-by: Martin Atkins <mart@degeneration.co.uk>
62 lines
2.0 KiB
Go
62 lines
2.0 KiB
Go
// Copyright (c) The OpenTofu Authors
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
// Copyright (c) 2023 HashiCorp, Inc.
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
package statemgr
|
|
|
|
// The functions in this file are helper wrappers for common sequences of
|
|
// operations done against full state managers.
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/opentofu/opentofu/internal/states"
|
|
"github.com/opentofu/opentofu/internal/states/statefile"
|
|
"github.com/opentofu/opentofu/internal/tofu"
|
|
"github.com/opentofu/opentofu/version"
|
|
)
|
|
|
|
// NewStateFile creates a new statefile.File object, with a newly-minted
|
|
// lineage identifier and serial 0, and returns a pointer to it.
|
|
func NewStateFile() *statefile.File {
|
|
return &statefile.File{
|
|
Lineage: NewLineage(),
|
|
TerraformVersion: version.SemVer,
|
|
State: states.NewState(),
|
|
}
|
|
}
|
|
|
|
// RefreshAndRead refreshes the persistent snapshot in the given state manager
|
|
// and then returns it.
|
|
//
|
|
// This is a wrapper around calling RefreshState and then State on the given
|
|
// manager.
|
|
func RefreshAndRead(ctx context.Context, mgr Storage) (*states.State, error) {
|
|
err := mgr.RefreshState(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return mgr.State(), nil
|
|
}
|
|
|
|
// WriteAndPersist writes a snapshot of the given state to the given state
|
|
// manager's transient store and then immediately persists it.
|
|
//
|
|
// The caller must ensure that the given state is not concurrently modified
|
|
// while this function is running, but it is safe to modify it after this
|
|
// function has returned.
|
|
//
|
|
// If an error is returned, it is undefined whether the state has been saved
|
|
// to the transient store or not, and so the only safe response is to bail
|
|
// out quickly with a user-facing error. In situations where more control
|
|
// is required, call WriteState and PersistState on the state manager directly
|
|
// and handle their errors.
|
|
func WriteAndPersist(ctx context.Context, mgr Storage, state *states.State, schemas *tofu.Schemas) error {
|
|
err := mgr.WriteState(state)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return mgr.PersistState(ctx, schemas)
|
|
}
|