mirror of
https://github.com/opentofu/opentofu.git
synced 2024-12-28 01:41:48 -06:00
53cafc542b
This idea of a "state manager" was previously modelled via the confusingly-named state.State interface, which we've been calling a "state manager" only in some local variable names in situations where there were also *terraform.State variables. As part of reworking our state models to make room for the new type system, we also need to change what was previously the state.StateReader interface. Since we've found the previous organization confusing anyway, here we just copy all of those interfaces over into statemgr where we can make the relationship to states.State hopefully a little clearer. This is not yet a complete move of the functionality from "state", since we're not yet ready to break existing callers. In a future commit we'll turn the interfaces in the old "state" package into aliases of the interfaces in this package, and update all the implementers of what will by then be statemgr.Reader to use *states.State instead of *terraform.State. This also includes an adaptation of what was previously state.LocalState into statemgr.FileSystem, using the new state serialization functionality from package statefile instead of the old terraform.ReadState and terraform.WriteState.
67 lines
2.8 KiB
Go
67 lines
2.8 KiB
Go
package statemgr
|
|
|
|
import "github.com/hashicorp/terraform/states"
|
|
|
|
// Transient is a union of the Reader and Writer interfaces, for types that
|
|
// deal with transient snapshots.
|
|
//
|
|
// Transient snapshots are ones that are generally retained only locally and
|
|
// to not create any historical version record when updated. Transient
|
|
// snapshots are not expected to outlive a particular Terraform process,
|
|
// and are not shared with any other process.
|
|
//
|
|
// A state manager type that is primarily concerned with persistent storage
|
|
// may embed type Transient and then call State from its PersistState and
|
|
// WriteState from its RefreshState in order to build on any existing
|
|
// Transient implementation, such as the one returned by NewTransientInMemory.
|
|
type Transient interface {
|
|
Reader
|
|
Writer
|
|
}
|
|
|
|
// Reader is the interface for managers that can return transient snapshots
|
|
// of state.
|
|
//
|
|
// Retrieving the snapshot must not fail, so retrieving a snapshot from remote
|
|
// storage (for example) should be dealt with elsewhere, often in an
|
|
// implementation of Refresher. For a type that implements both Reader
|
|
// and Refresher, it is okay for State to return nil if called before
|
|
// a RefreshState call has completed.
|
|
//
|
|
// For a type that implements both Reader and Writer, State must return the
|
|
// result of the most recently completed call to WriteState, and the state
|
|
// manager must accept concurrent calls to both State and WriteState.
|
|
//
|
|
// Each caller of this function must get a distinct copy of the state, and
|
|
// it must also be distinct from any instance cached inside the reader, to
|
|
// ensure that mutations of the returned state will not affect the values
|
|
// returned to other callers.
|
|
type Reader interface {
|
|
// State returns the latest state.
|
|
//
|
|
// Each call to State returns an entirely-distinct copy of the state, with
|
|
// no storage shared with any other call, so the caller may freely mutate
|
|
// the returned object via the state APIs.
|
|
State() *states.State
|
|
}
|
|
|
|
// Writer is the interface for managers that can create transient snapshots
|
|
// from state.
|
|
//
|
|
// Writer is the opposite of Reader, and so it must update whatever the State
|
|
// method reads from. It does not write the state to any persistent
|
|
// storage, and (for managers that support historical versions) must not
|
|
// be recorded as a persistent new version of state.
|
|
//
|
|
// Implementations that cache the state in memory must take a deep copy of it,
|
|
// since the caller may continue to modify the given state object after
|
|
// WriteState returns.
|
|
type Writer interface {
|
|
// Write state saves a transient snapshot of the given state.
|
|
//
|
|
// The caller must ensure that the given state object is not concurrently
|
|
// modified while a WriteState call is in progress. WriteState itself
|
|
// will never modify the given state.
|
|
WriteState(*states.State) error
|
|
}
|