README

Terraform Helper Lib: schema

The schema package provides a high-level interface for writing resource providers for Terraform.

If you're writing a resource provider, we recommend you use this package.

The interface exposed by this package is much friendlier than trying to write to the Terraform API directly. The core Terraform API is low-level and built for maximum flexibility and control, whereas this library is built as a framework around that to more easily write common providers.

Expand ▾ Collapse ▴

Documentation

Overview

    schema is a high-level framework for easily writing new providers for Terraform. Usage of schema is recommended over attempting to write to the low-level plugin interfaces manually.

    schema breaks down provider creation into simple CRUD operations for resources. The logic of diffing, destroying before creating, updating or creating, etc. is all handled by the framework. The plugin author only needs to implement a configuration schema and the CRUD operations and everything else is meant to just work.

    A good starting point is to view the Provider structure.

    Index

    Constants

    View Source
    const (
    	TimeoutCreate  = "create"
    	TimeoutRead    = "read"
    	TimeoutUpdate  = "update"
    	TimeoutDelete  = "delete"
    	TimeoutDefault = "default"
    )
    View Source
    const PanicOnErr = "TF_SCHEMA_PANIC_ON_ERROR"

      Name of ENV variable which (if not empty) prefers panic over error

      View Source
      const TimeoutKey = "e2bfb730-ecaa-11e6-8f88-34363bc7c4c0"
      View Source
      const TimeoutsConfigKey = "timeouts"

      Variables

      View Source
      var (
      
      	// This returns a *ResourceData for the connection information.
      	// Guaranteed to never be nil.
      	ProvConnDataKey = contextKey("provider conn data")
      
      	// This returns a *ResourceData for the config information.
      	// Guaranteed to never be nil.
      	ProvConfigDataKey = contextKey("provider config data")
      
      	// This returns a terraform.UIOutput. Guaranteed to never be nil.
      	ProvOutputKey = contextKey("provider output")
      
      	// This returns the raw InstanceState passed to Apply. Guaranteed to
      	// be set, but may be nil.
      	ProvRawStateKey = contextKey("provider raw state")
      )

        Keys that can be used to access data in the context parameters for Provisioners.

        View Source
        var ReservedDataSourceFields = []string{
        	"connection",
        	"count",
        	"depends_on",
        	"lifecycle",
        	"provider",
        	"provisioner",
        }
        View Source
        var ReservedProviderFields = []string{
        	"alias",
        	"version",
        }
        View Source
        var ReservedResourceFields = []string{
        	"connection",
        	"count",
        	"depends_on",
        	"id",
        	"lifecycle",
        	"provider",
        	"provisioner",
        }

        Functions

        func ApplyDiff

        func ApplyDiff(base cty.Value, d *terraform.InstanceDiff, schema *configschema.Block) (cty.Value, error)

          ApplyDiff takes a cty.Value state and applies a terraform.InstanceDiff to get a new cty.Value state. This is used to convert the diff returned from the legacy provider Diff method to the state required for the new PlanResourceChange method.

          func DefaultTimeout

          func DefaultTimeout(tx interface{}) *time.Duration

            could be time.Duration, int64 or float64

            func DiffFromValues

            func DiffFromValues(prior, planned cty.Value, res *Resource) (*terraform.InstanceDiff, error)

              DiffFromValues takes the current state and desired state as cty.Values and derives a terraform.InstanceDiff to give to the legacy providers. This is used to take the states provided by the new ApplyResourceChange method and convert them to a state+diff required for the legacy Apply method.

              func HashInt

              func HashInt(v interface{}) int

                HashInt hashes integers. If you want a Set of integers, this is the SchemaSetFunc you want.

                func HashString

                func HashString(v interface{}) int

                  HashString hashes strings. If you want a Set of strings, this is the SchemaSetFunc you want.

                  func JSONMapToStateValue

                  func JSONMapToStateValue(m map[string]interface{}, block *configschema.Block) (cty.Value, error)

                    JSONMapToStateValue takes a generic json map[string]interface{} and converts it to the specific type, ensuring that the values conform to the schema.

                    func Noop

                    func Noop(*ResourceData, interface{}) error

                      Noop is a convenience implementation of resource function which takes no action and returns no error.

                      func RemoveFromState

                      func RemoveFromState(d *ResourceData, _ interface{}) error

                        RemoveFromState is a convenience implementation of a resource function which sets the resource ID to empty string (to remove it from state) and returns no error.

                        func SerializeResourceForHash

                        func SerializeResourceForHash(buf *bytes.Buffer, val interface{}, resource *Resource)

                          SerializeValueForHash appends a serialization of the given resource config to the given buffer, guaranteeing deterministic results given the same value and schema.

                          Its primary purpose is as input into a hashing function in order to hash complex substructures when used in sets, and so the serialization is not reversible.

                          func SerializeValueForHash

                          func SerializeValueForHash(buf *bytes.Buffer, val interface{}, schema *Schema)

                          func SetProto5

                          func SetProto5()

                            SetProto5 enables a feature flag for any internal changes required required to work with the new plugin protocol. This should not be called by provider.

                            func StateValueFromInstanceState

                            func StateValueFromInstanceState(is *terraform.InstanceState, ty cty.Type) (cty.Value, error)

                              StateValueFromInstanceState converts a terraform.InstanceState to a cty.Value as described by the provided cty.Type, and maintains the resource ID as the "id" attribute.

                              func StateValueToJSONMap

                              func StateValueToJSONMap(val cty.Value, ty cty.Type) (map[string]interface{}, error)

                                StateValueToJSONMap converts a cty.Value to generic JSON map via the cty JSON encoding.

                                Types

                                type Backend

                                type Backend struct {
                                	// Schema is the schema for the configuration of this backend. If this
                                	// Backend has no configuration this can be omitted.
                                	Schema map[string]*Schema
                                
                                	// ConfigureFunc is called to configure the backend. Use the
                                	// FromContext* methods to extract information from the context.
                                	// This can be nil, in which case nothing will be called but the
                                	// config will still be stored.
                                	ConfigureFunc func(context.Context) error
                                	// contains filtered or unexported fields
                                }

                                  Backend represents a partial backend.Backend implementation and simplifies the creation of configuration loading and validation.

                                  Unlike other schema structs such as Provider, this struct is meant to be embedded within your actual implementation. It provides implementations only for Input and Configure and gives you a method for accessing the configuration in the form of a ResourceData that you're expected to call from the other implementation funcs.

                                  func (*Backend) Config

                                  func (b *Backend) Config() *ResourceData

                                    Config returns the configuration. This is available after Configure is called.

                                    func (*Backend) ConfigSchema

                                    func (b *Backend) ConfigSchema() *configschema.Block

                                    func (*Backend) Configure

                                    func (b *Backend) Configure(obj cty.Value) tfdiags.Diagnostics

                                    func (*Backend) CoreConfigSchema

                                    func (r *Backend) CoreConfigSchema() *configschema.Block

                                      CoreConfigSchema is a convenient shortcut for calling CoreConfigSchema on the backends's schema.

                                      func (*Backend) PrepareConfig

                                      func (b *Backend) PrepareConfig(configVal cty.Value) (cty.Value, tfdiags.Diagnostics)

                                      type BasicMapReader

                                      type BasicMapReader map[string]string

                                        BasicMapReader implements MapReader for a single map.

                                        func (BasicMapReader) Access

                                        func (r BasicMapReader) Access(k string) (string, bool)

                                        func (BasicMapReader) Range

                                        func (r BasicMapReader) Range(f func(string, string) bool) bool

                                        type ConfigFieldReader

                                        type ConfigFieldReader struct {
                                        	Config *terraform.ResourceConfig
                                        	Schema map[string]*Schema
                                        	// contains filtered or unexported fields
                                        }

                                          ConfigFieldReader reads fields out of an untyped map[string]string to the best of its ability. It also applies defaults from the Schema. (The other field readers do not need default handling because they source fully populated data structures.)

                                          func (*ConfigFieldReader) ReadField

                                          func (r *ConfigFieldReader) ReadField(address []string) (FieldReadResult, error)

                                          type ConfigureFunc

                                          type ConfigureFunc func(*ResourceData) (interface{}, error)

                                            ConfigureFunc is the function used to configure a Provider.

                                            The interface{} value returned by this function is stored and passed into the subsequent resources as the meta parameter. This return value is usually used to pass along a configured API client, a configuration structure, etc.

                                            type CreateFunc

                                            type CreateFunc func(*ResourceData, interface{}) error

                                              See Resource documentation.

                                              type CustomizeDiffFunc

                                              type CustomizeDiffFunc func(*ResourceDiff, interface{}) error

                                                See Resource documentation.

                                                type DeleteFunc

                                                type DeleteFunc func(*ResourceData, interface{}) error

                                                  See Resource documentation.

                                                  type DiffFieldReader

                                                  type DiffFieldReader struct {
                                                  	Diff   *terraform.InstanceDiff
                                                  	Source FieldReader
                                                  	Schema map[string]*Schema
                                                  	// contains filtered or unexported fields
                                                  }

                                                    DiffFieldReader reads fields out of a diff structures.

                                                    It also requires access to a Reader that reads fields from the structure that the diff was derived from. This is usually the state. This is required because a diff on its own doesn't have complete data about full objects such as maps.

                                                    The Source MUST be the data that the diff was derived from. If it isn't, the behavior of this struct is undefined.

                                                    Reading fields from a DiffFieldReader is identical to reading from Source except the diff will be applied to the end result.

                                                    The "Exists" field on the result will be set to true if the complete field exists whether its from the source, diff, or a combination of both. It cannot be determined whether a retrieved value is composed of diff elements.

                                                    func (*DiffFieldReader) ReadField

                                                    func (r *DiffFieldReader) ReadField(address []string) (FieldReadResult, error)

                                                    type Equal

                                                    type Equal interface {
                                                    	Equal(interface{}) bool
                                                    }

                                                      Equal is an interface that checks for deep equality between two objects.

                                                      type ExistsFunc

                                                      type ExistsFunc func(*ResourceData, interface{}) (bool, error)

                                                        See Resource documentation.

                                                        type FieldReadResult

                                                        type FieldReadResult struct {
                                                        	// Value is the actual read value. NegValue is the _negative_ value
                                                        	// or the items that should be removed (if they existed). NegValue
                                                        	// doesn't make sense for primitives but is important for any
                                                        	// container types such as maps, sets, lists.
                                                        	Value          interface{}
                                                        	ValueProcessed interface{}
                                                        
                                                        	// Exists is true if the field was found in the data. False means
                                                        	// it wasn't found if there was no error.
                                                        	Exists bool
                                                        
                                                        	// Computed is true if the field was found but the value
                                                        	// is computed.
                                                        	Computed bool
                                                        }

                                                          FieldReadResult encapsulates all the resulting data from reading a field.

                                                          func (*FieldReadResult) ValueOrZero

                                                          func (r *FieldReadResult) ValueOrZero(s *Schema) interface{}

                                                            ValueOrZero returns the value of this result or the zero value of the schema type, ensuring a consistent non-nil return value.

                                                            type FieldReader

                                                            type FieldReader interface {
                                                            	ReadField([]string) (FieldReadResult, error)
                                                            }

                                                              FieldReaders are responsible for decoding fields out of data into the proper typed representation. ResourceData uses this to query data out of multiple sources: config, state, diffs, etc.

                                                              type FieldWriter

                                                              type FieldWriter interface {
                                                              	WriteField([]string, interface{}) error
                                                              }

                                                                FieldWriters are responsible for writing fields by address into a proper typed representation. ResourceData uses this to write new data into existing sources.

                                                                type InternalMap

                                                                type InternalMap = schemaMap

                                                                  InternalMap is used to aid in the transition to the new schema types and protocol. The name is not meant to convey any usefulness, as this is not to be used directly by any providers.

                                                                  type MapFieldReader

                                                                  type MapFieldReader struct {
                                                                  	Map    MapReader
                                                                  	Schema map[string]*Schema
                                                                  }

                                                                    MapFieldReader reads fields out of an untyped map[string]string to the best of its ability.

                                                                    func (*MapFieldReader) ReadField

                                                                    func (r *MapFieldReader) ReadField(address []string) (FieldReadResult, error)

                                                                    type MapFieldWriter

                                                                    type MapFieldWriter struct {
                                                                    	Schema map[string]*Schema
                                                                    	// contains filtered or unexported fields
                                                                    }

                                                                      MapFieldWriter writes data into a single map[string]string structure.

                                                                      func (*MapFieldWriter) Map

                                                                      func (w *MapFieldWriter) Map() map[string]string

                                                                        Map returns the underlying map that is being written to.

                                                                        func (*MapFieldWriter) WriteField

                                                                        func (w *MapFieldWriter) WriteField(addr []string, value interface{}) error

                                                                        type MapReader

                                                                        type MapReader interface {
                                                                        	Access(string) (string, bool)
                                                                        	Range(func(string, string) bool) bool
                                                                        }

                                                                          MapReader is an interface that is given to MapFieldReader for accessing a "map". This can be used to have alternate implementations. For a basic map[string]string, use BasicMapReader.

                                                                          type MultiLevelFieldReader

                                                                          type MultiLevelFieldReader struct {
                                                                          	Readers map[string]FieldReader
                                                                          	Levels  []string
                                                                          }

                                                                            MultiLevelFieldReader reads from other field readers, merging their results along the way in a specific order. You can specify "levels" and name them in order to read only an exact level or up to a specific level.

                                                                            This is useful for saying things such as "read the field from the state and config and merge them" or "read the latest value of the field".

                                                                            func (*MultiLevelFieldReader) ReadField

                                                                            func (r *MultiLevelFieldReader) ReadField(address []string) (FieldReadResult, error)

                                                                            func (*MultiLevelFieldReader) ReadFieldExact

                                                                            func (r *MultiLevelFieldReader) ReadFieldExact(
                                                                            	address []string, level string) (FieldReadResult, error)

                                                                            func (*MultiLevelFieldReader) ReadFieldMerge

                                                                            func (r *MultiLevelFieldReader) ReadFieldMerge(
                                                                            	address []string, level string) (FieldReadResult, error)

                                                                            type MultiMapReader

                                                                            type MultiMapReader []map[string]string

                                                                              MultiMapReader reads over multiple maps, preferring keys that are founder earlier (lower number index) vs. later (higher number index)

                                                                              func (MultiMapReader) Access

                                                                              func (r MultiMapReader) Access(k string) (string, bool)

                                                                              func (MultiMapReader) Range

                                                                              func (r MultiMapReader) Range(f func(string, string) bool) bool

                                                                              type Provider

                                                                              type Provider struct {
                                                                              	// Schema is the schema for the configuration of this provider. If this
                                                                              	// provider has no configuration, this can be omitted.
                                                                              	//
                                                                              	// The keys of this map are the configuration keys, and the value is
                                                                              	// the schema describing the value of the configuration.
                                                                              	Schema map[string]*Schema
                                                                              
                                                                              	// ResourcesMap is the list of available resources that this provider
                                                                              	// can manage, along with their Resource structure defining their
                                                                              	// own schemas and CRUD operations.
                                                                              	//
                                                                              	// Provider automatically handles routing operations such as Apply,
                                                                              	// Diff, etc. to the proper resource.
                                                                              	ResourcesMap map[string]*Resource
                                                                              
                                                                              	// DataSourcesMap is the collection of available data sources that
                                                                              	// this provider implements, with a Resource instance defining
                                                                              	// the schema and Read operation of each.
                                                                              	//
                                                                              	// Resource instances for data sources must have a Read function
                                                                              	// and must *not* implement Create, Update or Delete.
                                                                              	DataSourcesMap map[string]*Resource
                                                                              
                                                                              	// ProviderMetaSchema is the schema for the configuration of the meta
                                                                              	// information for this provider. If this provider has no meta info,
                                                                              	// this can be omitted. This functionality is currently experimental
                                                                              	// and subject to change or break without warning; it should only be
                                                                              	// used by providers that are collaborating on its use with the
                                                                              	// Terraform team.
                                                                              	ProviderMetaSchema map[string]*Schema
                                                                              
                                                                              	// ConfigureFunc is a function for configuring the provider. If the
                                                                              	// provider doesn't need to be configured, this can be omitted.
                                                                              	//
                                                                              	// See the ConfigureFunc documentation for more information.
                                                                              	ConfigureFunc ConfigureFunc
                                                                              
                                                                              	// MetaReset is called by TestReset to reset any state stored in the meta
                                                                              	// interface.  This is especially important if the StopContext is stored by
                                                                              	// the provider.
                                                                              	MetaReset func() error
                                                                              
                                                                              	TerraformVersion string
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                Provider represents a resource provider in Terraform, and properly implements all of the ResourceProvider API.

                                                                                By defining a schema for the configuration of the provider, the map of supporting resources, and a configuration function, the schema framework takes over and handles all the provider operations for you.

                                                                                After defining the provider structure, it is unlikely that you'll require any of the methods on Provider itself.

                                                                                func (*Provider) Apply

                                                                                  Apply implementation of terraform.ResourceProvider interface.

                                                                                  func (*Provider) Configure

                                                                                  func (p *Provider) Configure(c *terraform.ResourceConfig) error

                                                                                    Configure implementation of terraform.ResourceProvider interface.

                                                                                    func (*Provider) DataSources

                                                                                    func (p *Provider) DataSources() []terraform.DataSource

                                                                                      DataSources implementation of terraform.ResourceProvider interface.

                                                                                      func (*Provider) Diff

                                                                                        Diff implementation of terraform.ResourceProvider interface.

                                                                                        func (*Provider) GetSchema

                                                                                          GetSchema implementation of terraform.ResourceProvider interface

                                                                                          func (*Provider) ImportState

                                                                                          func (p *Provider) ImportState(
                                                                                          	info *terraform.InstanceInfo,
                                                                                          	id string) ([]*terraform.InstanceState, error)

                                                                                          func (*Provider) Input

                                                                                            Input implementation of terraform.ResourceProvider interface.

                                                                                            func (*Provider) InternalValidate

                                                                                            func (p *Provider) InternalValidate() error

                                                                                              InternalValidate should be called to validate the structure of the provider.

                                                                                              This should be called in a unit test for any provider to verify before release that a provider is properly configured for use with this library.

                                                                                              func (*Provider) Meta

                                                                                              func (p *Provider) Meta() interface{}

                                                                                                Meta returns the metadata associated with this provider that was returned by the Configure call. It will be nil until Configure is called.

                                                                                                func (*Provider) ReadDataApply

                                                                                                  RefreshData implementation of terraform.ResourceProvider interface.

                                                                                                  func (*Provider) ReadDataDiff

                                                                                                    ReadDataDiff implementation of terraform.ResourceProvider interface.

                                                                                                    func (*Provider) Refresh

                                                                                                      Refresh implementation of terraform.ResourceProvider interface.

                                                                                                      func (*Provider) Resources

                                                                                                      func (p *Provider) Resources() []terraform.ResourceType

                                                                                                        Resources implementation of terraform.ResourceProvider interface.

                                                                                                        func (*Provider) SetMeta

                                                                                                        func (p *Provider) SetMeta(v interface{})

                                                                                                          SetMeta can be used to forcefully set the Meta object of the provider. Note that if Configure is called the return value will override anything set here.

                                                                                                          func (*Provider) SimpleDiff

                                                                                                            SimpleDiff is used by the new protocol wrappers to get a diff that doesn't attempt to calculate ignore_changes.

                                                                                                            func (*Provider) Stop

                                                                                                            func (p *Provider) Stop() error

                                                                                                              Stop implementation of terraform.ResourceProvider interface.

                                                                                                              func (*Provider) StopContext

                                                                                                              func (p *Provider) StopContext() context.Context

                                                                                                                StopCh returns a channel that is closed once the provider is stopped.

                                                                                                                func (*Provider) Stopped

                                                                                                                func (p *Provider) Stopped() bool

                                                                                                                  Stopped reports whether the provider has been stopped or not.

                                                                                                                  func (*Provider) TestReset

                                                                                                                  func (p *Provider) TestReset() error

                                                                                                                    TestReset resets any state stored in the Provider, and will call TestReset on Meta if it implements the TestProvider interface. This may be used to reset the schema.Provider at the start of a test, and is automatically called by resource.Test.

                                                                                                                    func (*Provider) Validate

                                                                                                                    func (p *Provider) Validate(c *terraform.ResourceConfig) ([]string, []error)

                                                                                                                      Validate implementation of terraform.ResourceProvider interface.

                                                                                                                      func (*Provider) ValidateDataSource

                                                                                                                      func (p *Provider) ValidateDataSource(
                                                                                                                      	t string, c *terraform.ResourceConfig) ([]string, []error)

                                                                                                                        ValidateDataSource implementation of terraform.ResourceProvider interface.

                                                                                                                        func (*Provider) ValidateResource

                                                                                                                        func (p *Provider) ValidateResource(
                                                                                                                        	t string, c *terraform.ResourceConfig) ([]string, []error)

                                                                                                                          ValidateResource implementation of terraform.ResourceProvider interface.

                                                                                                                          type Provisioner

                                                                                                                          type Provisioner struct {
                                                                                                                          	// ConnSchema is the schema for the connection settings for this
                                                                                                                          	// provisioner.
                                                                                                                          	//
                                                                                                                          	// The keys of this map are the configuration keys, and the value is
                                                                                                                          	// the schema describing the value of the configuration.
                                                                                                                          	//
                                                                                                                          	// NOTE: The value of connection keys can only be strings for now.
                                                                                                                          	ConnSchema map[string]*Schema
                                                                                                                          
                                                                                                                          	// Schema is the schema for the usage of this provisioner.
                                                                                                                          	//
                                                                                                                          	// The keys of this map are the configuration keys, and the value is
                                                                                                                          	// the schema describing the value of the configuration.
                                                                                                                          	Schema map[string]*Schema
                                                                                                                          
                                                                                                                          	// ApplyFunc is the function for executing the provisioner. This is required.
                                                                                                                          	// It is given a context. See the Provisioner struct docs for more
                                                                                                                          	// information.
                                                                                                                          	ApplyFunc func(ctx context.Context) error
                                                                                                                          
                                                                                                                          	// ValidateFunc is a function for extended validation. This is optional
                                                                                                                          	// and should be used when individual field validation is not enough.
                                                                                                                          	ValidateFunc func(*terraform.ResourceConfig) ([]string, []error)
                                                                                                                          	// contains filtered or unexported fields
                                                                                                                          }

                                                                                                                            Provisioner represents a resource provisioner in Terraform and properly implements all of the ResourceProvisioner API.

                                                                                                                            This higher level structure makes it much easier to implement a new or custom provisioner for Terraform.

                                                                                                                            The function callbacks for this structure are all passed a context object. This context object has a number of pre-defined values that can be accessed via the global functions defined in context.go.

                                                                                                                            func (*Provisioner) Apply

                                                                                                                              Apply implementation of terraform.ResourceProvisioner interface.

                                                                                                                              func (*Provisioner) GetConfigSchema

                                                                                                                              func (p *Provisioner) GetConfigSchema() (*configschema.Block, error)

                                                                                                                                GetConfigSchema implementation of terraform.ResourceProvisioner interface.

                                                                                                                                func (*Provisioner) InternalValidate

                                                                                                                                func (p *Provisioner) InternalValidate() error

                                                                                                                                  InternalValidate should be called to validate the structure of the provisioner.

                                                                                                                                  This should be called in a unit test to verify before release that this structure is properly configured for use.

                                                                                                                                  func (*Provisioner) Stop

                                                                                                                                  func (p *Provisioner) Stop() error

                                                                                                                                    Stop implementation of terraform.ResourceProvisioner interface.

                                                                                                                                    func (*Provisioner) StopContext

                                                                                                                                    func (p *Provisioner) StopContext() context.Context

                                                                                                                                      StopContext returns a context that checks whether a provisioner is stopped.

                                                                                                                                      func (*Provisioner) Validate

                                                                                                                                      func (p *Provisioner) Validate(c *terraform.ResourceConfig) (ws []string, es []error)

                                                                                                                                        Validate implements the terraform.ResourceProvisioner interface.

                                                                                                                                        type ReadFunc

                                                                                                                                        type ReadFunc func(*ResourceData, interface{}) error

                                                                                                                                          See Resource documentation.

                                                                                                                                          type Resource

                                                                                                                                          type Resource struct {
                                                                                                                                          	// Schema is the schema for the configuration of this resource.
                                                                                                                                          	//
                                                                                                                                          	// The keys of this map are the configuration keys, and the values
                                                                                                                                          	// describe the schema of the configuration value.
                                                                                                                                          	//
                                                                                                                                          	// The schema is used to represent both configurable data as well
                                                                                                                                          	// as data that might be computed in the process of creating this
                                                                                                                                          	// resource.
                                                                                                                                          	Schema map[string]*Schema
                                                                                                                                          
                                                                                                                                          	// SchemaVersion is the version number for this resource's Schema
                                                                                                                                          	// definition. The current SchemaVersion stored in the state for each
                                                                                                                                          	// resource. Provider authors can increment this version number
                                                                                                                                          	// when Schema semantics change. If the State's SchemaVersion is less than
                                                                                                                                          	// the current SchemaVersion, the InstanceState is yielded to the
                                                                                                                                          	// MigrateState callback, where the provider can make whatever changes it
                                                                                                                                          	// needs to update the state to be compatible to the latest version of the
                                                                                                                                          	// Schema.
                                                                                                                                          	//
                                                                                                                                          	// When unset, SchemaVersion defaults to 0, so provider authors can start
                                                                                                                                          	// their Versioning at any integer >= 1
                                                                                                                                          	SchemaVersion int
                                                                                                                                          
                                                                                                                                          	// MigrateState is deprecated and any new changes to a resource's schema
                                                                                                                                          	// should be handled by StateUpgraders. Existing MigrateState implementations
                                                                                                                                          	// should remain for compatibility with existing state. MigrateState will
                                                                                                                                          	// still be called if the stored SchemaVersion is less than the
                                                                                                                                          	// first version of the StateUpgraders.
                                                                                                                                          	//
                                                                                                                                          	// MigrateState is responsible for updating an InstanceState with an old
                                                                                                                                          	// version to the format expected by the current version of the Schema.
                                                                                                                                          	//
                                                                                                                                          	// It is called during Refresh if the State's stored SchemaVersion is less
                                                                                                                                          	// than the current SchemaVersion of the Resource.
                                                                                                                                          	//
                                                                                                                                          	// The function is yielded the state's stored SchemaVersion and a pointer to
                                                                                                                                          	// the InstanceState that needs updating, as well as the configured
                                                                                                                                          	// provider's configured meta interface{}, in case the migration process
                                                                                                                                          	// needs to make any remote API calls.
                                                                                                                                          	MigrateState StateMigrateFunc
                                                                                                                                          
                                                                                                                                          	// StateUpgraders contains the functions responsible for upgrading an
                                                                                                                                          	// existing state with an old schema version to a newer schema. It is
                                                                                                                                          	// called specifically by Terraform when the stored schema version is less
                                                                                                                                          	// than the current SchemaVersion of the Resource.
                                                                                                                                          	//
                                                                                                                                          	// StateUpgraders map specific schema versions to a StateUpgrader
                                                                                                                                          	// function. The registered versions are expected to be ordered,
                                                                                                                                          	// consecutive values. The initial value may be greater than 0 to account
                                                                                                                                          	// for legacy schemas that weren't recorded and can be handled by
                                                                                                                                          	// MigrateState.
                                                                                                                                          	StateUpgraders []StateUpgrader
                                                                                                                                          
                                                                                                                                          	// The functions below are the CRUD operations for this resource.
                                                                                                                                          	//
                                                                                                                                          	// The only optional operation is Update. If Update is not implemented,
                                                                                                                                          	// then updates will not be supported for this resource.
                                                                                                                                          	//
                                                                                                                                          	// The ResourceData parameter in the functions below are used to
                                                                                                                                          	// query configuration and changes for the resource as well as to set
                                                                                                                                          	// the ID, computed data, etc.
                                                                                                                                          	//
                                                                                                                                          	// The interface{} parameter is the result of the ConfigureFunc in
                                                                                                                                          	// the provider for this resource. If the provider does not define
                                                                                                                                          	// a ConfigureFunc, this will be nil. This parameter should be used
                                                                                                                                          	// to store API clients, configuration structures, etc.
                                                                                                                                          	//
                                                                                                                                          	// If any errors occur during each of the operation, an error should be
                                                                                                                                          	// returned. If a resource was partially updated, be careful to enable
                                                                                                                                          	// partial state mode for ResourceData and use it accordingly.
                                                                                                                                          	//
                                                                                                                                          	// Exists is a function that is called to check if a resource still
                                                                                                                                          	// exists. If this returns false, then this will affect the diff
                                                                                                                                          	// accordingly. If this function isn't set, it will not be called. You
                                                                                                                                          	// can also signal existence in the Read method by calling d.SetId("")
                                                                                                                                          	// if the Resource is no longer present and should be removed from state.
                                                                                                                                          	// The *ResourceData passed to Exists should _not_ be modified.
                                                                                                                                          	Create CreateFunc
                                                                                                                                          	Read   ReadFunc
                                                                                                                                          	Update UpdateFunc
                                                                                                                                          	Delete DeleteFunc
                                                                                                                                          	Exists ExistsFunc
                                                                                                                                          
                                                                                                                                          	// CustomizeDiff is a custom function for working with the diff that
                                                                                                                                          	// Terraform has created for this resource - it can be used to customize the
                                                                                                                                          	// diff that has been created, diff values not controlled by configuration,
                                                                                                                                          	// or even veto the diff altogether and abort the plan. It is passed a
                                                                                                                                          	// *ResourceDiff, a structure similar to ResourceData but lacking most write
                                                                                                                                          	// functions like Set, while introducing new functions that work with the
                                                                                                                                          	// diff such as SetNew, SetNewComputed, and ForceNew.
                                                                                                                                          	//
                                                                                                                                          	// The phases Terraform runs this in, and the state available via functions
                                                                                                                                          	// like Get and GetChange, are as follows:
                                                                                                                                          	//
                                                                                                                                          	//  * New resource: One run with no state
                                                                                                                                          	//  * Existing resource: One run with state
                                                                                                                                          	//   * Existing resource, forced new: One run with state (before ForceNew),
                                                                                                                                          	//     then one run without state (as if new resource)
                                                                                                                                          	//  * Tainted resource: No runs (custom diff logic is skipped)
                                                                                                                                          	//  * Destroy: No runs (standard diff logic is skipped on destroy diffs)
                                                                                                                                          	//
                                                                                                                                          	// This function needs to be resilient to support all scenarios.
                                                                                                                                          	//
                                                                                                                                          	// If this function needs to access external API resources, remember to flag
                                                                                                                                          	// the RequiresRefresh attribute mentioned below to ensure that
                                                                                                                                          	// -refresh=false is blocked when running plan or apply, as this means that
                                                                                                                                          	// this resource requires refresh-like behaviour to work effectively.
                                                                                                                                          	//
                                                                                                                                          	// For the most part, only computed fields can be customized by this
                                                                                                                                          	// function.
                                                                                                                                          	//
                                                                                                                                          	// This function is only allowed on regular resources (not data sources).
                                                                                                                                          	CustomizeDiff CustomizeDiffFunc
                                                                                                                                          
                                                                                                                                          	// Importer is the ResourceImporter implementation for this resource.
                                                                                                                                          	// If this is nil, then this resource does not support importing. If
                                                                                                                                          	// this is non-nil, then it supports importing and ResourceImporter
                                                                                                                                          	// must be validated. The validity of ResourceImporter is verified
                                                                                                                                          	// by InternalValidate on Resource.
                                                                                                                                          	Importer *ResourceImporter
                                                                                                                                          
                                                                                                                                          	// If non-empty, this string is emitted as a warning during Validate.
                                                                                                                                          	DeprecationMessage string
                                                                                                                                          
                                                                                                                                          	// Timeouts allow users to specify specific time durations in which an
                                                                                                                                          	// operation should time out, to allow them to extend an action to suit their
                                                                                                                                          	// usage. For example, a user may specify a large Creation timeout for their
                                                                                                                                          	// AWS RDS Instance due to it's size, or restoring from a snapshot.
                                                                                                                                          	// Resource implementors must enable Timeout support by adding the allowed
                                                                                                                                          	// actions (Create, Read, Update, Delete, Default) to the Resource struct, and
                                                                                                                                          	// accessing them in the matching methods.
                                                                                                                                          	Timeouts *ResourceTimeout
                                                                                                                                          }

                                                                                                                                            Resource represents a thing in Terraform that has a set of configurable attributes and a lifecycle (create, read, update, delete).

                                                                                                                                            The Resource schema is an abstraction that allows provider writers to worry only about CRUD operations while off-loading validation, diff generation, etc. to this higher level library.

                                                                                                                                            In spite of the name, this struct is not used only for terraform resources, but also for data sources. In the case of data sources, the Create, Update and Delete functions must not be provided.

                                                                                                                                            func DataSourceResourceShim

                                                                                                                                            func DataSourceResourceShim(name string, dataSource *Resource) *Resource

                                                                                                                                              DataSourceResourceShim takes a Resource instance describing a data source (with a Read implementation and a Schema, at least) and returns a new Resource instance with additional Create and Delete implementations that allow the data source to be used as a resource.

                                                                                                                                              This is a backward-compatibility layer for data sources that were formerly read-only resources before the data source concept was added. It should not be used for any *new* data sources.

                                                                                                                                              The Read function for the data source *must* call d.SetId with a non-empty id in order for this shim to function as expected.

                                                                                                                                              The provided Resource instance, and its schema, will be modified in-place to make it suitable for use as a full resource.

                                                                                                                                              func (*Resource) Apply

                                                                                                                                              func (r *Resource) Apply(
                                                                                                                                              	s *terraform.InstanceState,
                                                                                                                                              	d *terraform.InstanceDiff,
                                                                                                                                              	meta interface{}) (*terraform.InstanceState, error)

                                                                                                                                                Apply creates, updates, and/or deletes a resource.

                                                                                                                                                func (*Resource) CoreConfigSchema

                                                                                                                                                func (r *Resource) CoreConfigSchema() *configschema.Block

                                                                                                                                                  CoreConfigSchema is a convenient shortcut for calling CoreConfigSchema on the resource's schema. CoreConfigSchema adds the implicitly required "id" attribute for top level resources if it doesn't exist.

                                                                                                                                                  func (*Resource) Data

                                                                                                                                                    Data returns a ResourceData struct for this Resource. Each return value is a separate copy and can be safely modified differently.

                                                                                                                                                    The data returned from this function has no actual affect on the Resource itself (including the state given to this function).

                                                                                                                                                    This function is useful for unit tests and ResourceImporter functions.

                                                                                                                                                    func (*Resource) Diff

                                                                                                                                                    func (r *Resource) Diff(
                                                                                                                                                    	s *terraform.InstanceState,
                                                                                                                                                    	c *terraform.ResourceConfig,
                                                                                                                                                    	meta interface{}) (*terraform.InstanceDiff, error)

                                                                                                                                                      Diff returns a diff of this resource.

                                                                                                                                                      func (*Resource) InternalValidate

                                                                                                                                                      func (r *Resource) InternalValidate(topSchemaMap schemaMap, writable bool) error

                                                                                                                                                        InternalValidate should be called to validate the structure of the resource.

                                                                                                                                                        This should be called in a unit test for any resource to verify before release that a resource is properly configured for use with this library.

                                                                                                                                                        Provider.InternalValidate() will automatically call this for all of the resources it manages, so you don't need to call this manually if it is part of a Provider.

                                                                                                                                                        func (*Resource) ReadDataApply

                                                                                                                                                        func (r *Resource) ReadDataApply(
                                                                                                                                                        	d *terraform.InstanceDiff,
                                                                                                                                                        	meta interface{},
                                                                                                                                                        ) (*terraform.InstanceState, error)

                                                                                                                                                          ReadDataApply loads the data for a data source, given a diff that describes the configuration arguments and desired computed attributes.

                                                                                                                                                          func (*Resource) Refresh

                                                                                                                                                          func (r *Resource) Refresh(
                                                                                                                                                          	s *terraform.InstanceState,
                                                                                                                                                          	meta interface{}) (*terraform.InstanceState, error)

                                                                                                                                                            Refresh refreshes the state of the resource.

                                                                                                                                                            func (*Resource) RefreshWithoutUpgrade

                                                                                                                                                            func (r *Resource) RefreshWithoutUpgrade(
                                                                                                                                                            	s *terraform.InstanceState,
                                                                                                                                                            	meta interface{}) (*terraform.InstanceState, error)

                                                                                                                                                              RefreshWithoutUpgrade reads the instance state, but does not call MigrateState or the StateUpgraders, since those are now invoked in a separate API call. RefreshWithoutUpgrade is part of the new plugin shims.

                                                                                                                                                              func (*Resource) SchemasForFlatmapPath

                                                                                                                                                              func (r *Resource) SchemasForFlatmapPath(path string) []*Schema

                                                                                                                                                                SchemasForFlatmapPath tries its best to find a sequence of schemas that the given dot-delimited attribute path traverses through in the schema of the receiving Resource.

                                                                                                                                                                func (*Resource) ShimInstanceStateFromValue

                                                                                                                                                                func (r *Resource) ShimInstanceStateFromValue(state cty.Value) (*terraform.InstanceState, error)

                                                                                                                                                                  ShimInstanceStateFromValue converts a cty.Value to a terraform.InstanceState.

                                                                                                                                                                  func (*Resource) TestResourceData

                                                                                                                                                                  func (r *Resource) TestResourceData() *ResourceData

                                                                                                                                                                    TestResourceData Yields a ResourceData filled with this resource's schema for use in unit testing

                                                                                                                                                                    TODO: May be able to be removed with the above ResourceData function.

                                                                                                                                                                    func (*Resource) Validate

                                                                                                                                                                    func (r *Resource) Validate(c *terraform.ResourceConfig) ([]string, []error)

                                                                                                                                                                      Validate validates the resource configuration against the schema.

                                                                                                                                                                      type ResourceData

                                                                                                                                                                      type ResourceData struct {
                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                      }

                                                                                                                                                                        ResourceData is used to query and set the attributes of a resource.

                                                                                                                                                                        ResourceData is the primary argument received for CRUD operations on a resource as well as configuration of a provider. It is a powerful structure that can be used to not only query data, but check for changes, define partial state updates, etc.

                                                                                                                                                                        The most relevant methods to take a look at are Get, Set, and Partial.

                                                                                                                                                                        func FromContextBackendConfig

                                                                                                                                                                        func FromContextBackendConfig(ctx context.Context) *ResourceData

                                                                                                                                                                          FromContextBackendConfig extracts a ResourceData with the configuration from the context. This should only be called by Backend functions.

                                                                                                                                                                          func ImportStatePassthrough

                                                                                                                                                                          func ImportStatePassthrough(d *ResourceData, m interface{}) ([]*ResourceData, error)

                                                                                                                                                                            ImportStatePassthrough is an implementation of StateFunc that can be used to simply pass the ID directly through. This should be used only in the case that an ID-only refresh is possible.

                                                                                                                                                                            func TestResourceDataRaw

                                                                                                                                                                            func TestResourceDataRaw(
                                                                                                                                                                            	t *testing.T, schema map[string]*Schema, raw map[string]interface{}) *ResourceData

                                                                                                                                                                              TestResourceDataRaw creates a ResourceData from a raw configuration map.

                                                                                                                                                                              func (*ResourceData) ConnInfo

                                                                                                                                                                              func (d *ResourceData) ConnInfo() map[string]string

                                                                                                                                                                                ConnInfo returns the connection info for this resource.

                                                                                                                                                                                func (*ResourceData) Get

                                                                                                                                                                                func (d *ResourceData) Get(key string) interface{}

                                                                                                                                                                                  Get returns the data for the given key, or nil if the key doesn't exist in the schema.

                                                                                                                                                                                  If the key does exist in the schema but doesn't exist in the configuration, then the default value for that type will be returned. For strings, this is "", for numbers it is 0, etc.

                                                                                                                                                                                  If you want to test if something is set at all in the configuration, use GetOk.

                                                                                                                                                                                  func (*ResourceData) GetChange

                                                                                                                                                                                  func (d *ResourceData) GetChange(key string) (interface{}, interface{})

                                                                                                                                                                                    GetChange returns the old and new value for a given key.

                                                                                                                                                                                    HasChange should be used to check if a change exists. It is possible that both the old and new value are the same if the old value was not set and the new value is. This is common, for example, for boolean fields which have a zero value of false.

                                                                                                                                                                                    func (*ResourceData) GetOk

                                                                                                                                                                                    func (d *ResourceData) GetOk(key string) (interface{}, bool)

                                                                                                                                                                                      GetOk returns the data for the given key and whether or not the key has been set to a non-zero value at some point.

                                                                                                                                                                                      The first result will not necessarilly be nil if the value doesn't exist. The second result should be checked to determine this information.

                                                                                                                                                                                      func (*ResourceData) GetOkExists

                                                                                                                                                                                      func (d *ResourceData) GetOkExists(key string) (interface{}, bool)

                                                                                                                                                                                        GetOkExists returns the data for a given key and whether or not the key has been set to a non-zero value. This is only useful for determining if boolean attributes have been set, if they are Optional but do not have a Default value.

                                                                                                                                                                                        This is nearly the same function as GetOk, yet it does not check for the zero value of the attribute's type. This allows for attributes without a default, to fully check for a literal assignment, regardless of the zero-value for that type. This should only be used if absolutely required/needed.

                                                                                                                                                                                        func (*ResourceData) GetProviderMeta

                                                                                                                                                                                        func (d *ResourceData) GetProviderMeta(dst interface{}) error

                                                                                                                                                                                        func (*ResourceData) HasChange

                                                                                                                                                                                        func (d *ResourceData) HasChange(key string) bool

                                                                                                                                                                                          HasChange returns whether or not the given key has been changed.

                                                                                                                                                                                          func (*ResourceData) Id

                                                                                                                                                                                          func (d *ResourceData) Id() string

                                                                                                                                                                                            Id returns the ID of the resource.

                                                                                                                                                                                            func (*ResourceData) IsNewResource

                                                                                                                                                                                            func (d *ResourceData) IsNewResource() bool

                                                                                                                                                                                            func (*ResourceData) MarkNewResource

                                                                                                                                                                                            func (d *ResourceData) MarkNewResource()

                                                                                                                                                                                            func (*ResourceData) Partial

                                                                                                                                                                                            func (d *ResourceData) Partial(on bool)

                                                                                                                                                                                              Partial turns partial state mode on/off.

                                                                                                                                                                                              When partial state mode is enabled, then only key prefixes specified by SetPartial will be in the final state. This allows providers to return partial states for partially applied resources (when errors occur).

                                                                                                                                                                                              func (*ResourceData) Set

                                                                                                                                                                                              func (d *ResourceData) Set(key string, value interface{}) error

                                                                                                                                                                                                Set sets the value for the given key.

                                                                                                                                                                                                If the key is invalid or the value is not a correct type, an error will be returned.

                                                                                                                                                                                                func (*ResourceData) SetConnInfo

                                                                                                                                                                                                func (d *ResourceData) SetConnInfo(v map[string]string)

                                                                                                                                                                                                  SetConnInfo sets the connection info for a resource.

                                                                                                                                                                                                  func (*ResourceData) SetId

                                                                                                                                                                                                  func (d *ResourceData) SetId(v string)

                                                                                                                                                                                                    SetId sets the ID of the resource. If the value is blank, then the resource is destroyed.

                                                                                                                                                                                                    func (*ResourceData) SetPartial

                                                                                                                                                                                                    func (d *ResourceData) SetPartial(k string)

                                                                                                                                                                                                      SetPartial adds the key to the final state output while in partial state mode. The key must be a root key in the schema (i.e. it cannot be "list.0").

                                                                                                                                                                                                      If partial state mode is disabled, then this has no effect. Additionally, whenever partial state mode is toggled, the partial data is cleared.

                                                                                                                                                                                                      func (*ResourceData) SetType

                                                                                                                                                                                                      func (d *ResourceData) SetType(t string)

                                                                                                                                                                                                        SetType sets the ephemeral type for the data. This is only required for importing.

                                                                                                                                                                                                        func (*ResourceData) State

                                                                                                                                                                                                        func (d *ResourceData) State() *terraform.InstanceState

                                                                                                                                                                                                          State returns the new InstanceState after the diff and any Set calls.

                                                                                                                                                                                                          func (*ResourceData) Timeout

                                                                                                                                                                                                          func (d *ResourceData) Timeout(key string) time.Duration

                                                                                                                                                                                                            Timeout returns the data for the given timeout key Returns a duration of 20 minutes for any key not found, or not found and no default.

                                                                                                                                                                                                            func (*ResourceData) UnsafeSetFieldRaw

                                                                                                                                                                                                            func (d *ResourceData) UnsafeSetFieldRaw(key string, value string)

                                                                                                                                                                                                              UnsafeSetFieldRaw allows setting arbitrary values in state to arbitrary values, bypassing schema. This MUST NOT be used in normal circumstances - it exists only to support the remote_state data source.

                                                                                                                                                                                                              Deprecated: Fully define schema attributes and use Set() instead.

                                                                                                                                                                                                              type ResourceDiff

                                                                                                                                                                                                              type ResourceDiff struct {
                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                              }

                                                                                                                                                                                                                ResourceDiff is used to query and make custom changes to an in-flight diff. It can be used to veto particular changes in the diff, customize the diff that has been created, or diff values not controlled by config.

                                                                                                                                                                                                                The object functions similar to ResourceData, however most notably lacks Set, SetPartial, and Partial, as it should be used to change diff values only. Most other first-class ResourceData functions exist, namely Get, GetOk, HasChange, and GetChange exist.

                                                                                                                                                                                                                All functions in ResourceDiff, save for ForceNew, can only be used on computed fields.

                                                                                                                                                                                                                func (*ResourceDiff) Clear

                                                                                                                                                                                                                func (d *ResourceDiff) Clear(key string) error

                                                                                                                                                                                                                  Clear wipes the diff for a particular key. It is called by ResourceDiff's functionality to remove any possibility of conflicts, but can be called on its own to just remove a specific key from the diff completely.

                                                                                                                                                                                                                  Note that this does not wipe an override. This function is only allowed on computed keys.

                                                                                                                                                                                                                  func (*ResourceDiff) ForceNew

                                                                                                                                                                                                                  func (d *ResourceDiff) ForceNew(key string) error

                                                                                                                                                                                                                    ForceNew force-flags ForceNew in the schema for a specific key, and re-calculates its diff, effectively causing this attribute to force a new resource.

                                                                                                                                                                                                                    Keep in mind that forcing a new resource will force a second run of the resource's CustomizeDiff function (with a new ResourceDiff) once the current one has completed. This second run is performed without state. This behavior will be the same as if a new resource is being created and is performed to ensure that the diff looks like the diff for a new resource as much as possible. CustomizeDiff should expect such a scenario and act correctly.

                                                                                                                                                                                                                    This function is a no-op/error if there is no diff.

                                                                                                                                                                                                                    Note that the change to schema is permanent for the lifecycle of this specific ResourceDiff instance.

                                                                                                                                                                                                                    func (*ResourceDiff) Get

                                                                                                                                                                                                                    func (d *ResourceDiff) Get(key string) interface{}

                                                                                                                                                                                                                      Get hands off to ResourceData.Get.

                                                                                                                                                                                                                      func (*ResourceDiff) GetChange

                                                                                                                                                                                                                      func (d *ResourceDiff) GetChange(key string) (interface{}, interface{})

                                                                                                                                                                                                                        GetChange gets the change between the state and diff, checking first to see if an overridden diff exists.

                                                                                                                                                                                                                        This implementation differs from ResourceData's in the way that we first get results from the exact levels for the new diff, then from state and diff as per normal.

                                                                                                                                                                                                                        func (*ResourceDiff) GetChangedKeysPrefix

                                                                                                                                                                                                                        func (d *ResourceDiff) GetChangedKeysPrefix(prefix string) []string

                                                                                                                                                                                                                          GetChangedKeysPrefix helps to implement Resource.CustomizeDiff where we need to act on all nested fields without calling out each one separately

                                                                                                                                                                                                                          func (*ResourceDiff) GetOk

                                                                                                                                                                                                                          func (d *ResourceDiff) GetOk(key string) (interface{}, bool)

                                                                                                                                                                                                                            GetOk functions the same way as ResourceData.GetOk, but it also checks the new diff levels to provide data consistent with the current state of the customized diff.

                                                                                                                                                                                                                            func (*ResourceDiff) GetOkExists

                                                                                                                                                                                                                            func (d *ResourceDiff) GetOkExists(key string) (interface{}, bool)

                                                                                                                                                                                                                              GetOkExists functions the same way as GetOkExists within ResourceData, but it also checks the new diff levels to provide data consistent with the current state of the customized diff.

                                                                                                                                                                                                                              This is nearly the same function as GetOk, yet it does not check for the zero value of the attribute's type. This allows for attributes without a default, to fully check for a literal assignment, regardless of the zero-value for that type.

                                                                                                                                                                                                                              func (*ResourceDiff) HasChange

                                                                                                                                                                                                                              func (d *ResourceDiff) HasChange(key string) bool

                                                                                                                                                                                                                                HasChange checks to see if there is a change between state and the diff, or in the overridden diff.

                                                                                                                                                                                                                                func (*ResourceDiff) Id

                                                                                                                                                                                                                                func (d *ResourceDiff) Id() string

                                                                                                                                                                                                                                  Id returns the ID of this resource.

                                                                                                                                                                                                                                  Note that technically, ID does not change during diffs (it either has already changed in the refresh, or will change on update), hence we do not support updating the ID or fetching it from anything else other than state.

                                                                                                                                                                                                                                  func (*ResourceDiff) NewValueKnown

                                                                                                                                                                                                                                  func (d *ResourceDiff) NewValueKnown(key string) bool

                                                                                                                                                                                                                                    NewValueKnown returns true if the new value for the given key is available as its final value at diff time. If the return value is false, this means either the value is based of interpolation that was unavailable at diff time, or that the value was explicitly marked as computed by SetNewComputed.

                                                                                                                                                                                                                                    func (*ResourceDiff) SetNew

                                                                                                                                                                                                                                    func (d *ResourceDiff) SetNew(key string, value interface{}) error

                                                                                                                                                                                                                                      SetNew is used to set a new diff value for the mentioned key. The value must be correct for the attribute's schema (mostly relevant for maps, lists, and sets). The original value from the state is used as the old value.

                                                                                                                                                                                                                                      This function is only allowed on computed attributes.

                                                                                                                                                                                                                                      func (*ResourceDiff) SetNewComputed

                                                                                                                                                                                                                                      func (d *ResourceDiff) SetNewComputed(key string) error

                                                                                                                                                                                                                                        SetNewComputed functions like SetNew, except that it blanks out a new value and marks it as computed.

                                                                                                                                                                                                                                        This function is only allowed on computed attributes.

                                                                                                                                                                                                                                        func (*ResourceDiff) UpdatedKeys

                                                                                                                                                                                                                                        func (d *ResourceDiff) UpdatedKeys() []string

                                                                                                                                                                                                                                          UpdatedKeys returns the keys that were updated by this ResourceDiff run. These are the only keys that a diff should be re-calculated for.

                                                                                                                                                                                                                                          This is the combined result of both keys for which diff values were updated for or cleared, and also keys that were flagged to be re-diffed as a result of ForceNew.

                                                                                                                                                                                                                                          type ResourceImporter

                                                                                                                                                                                                                                          type ResourceImporter struct {
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          	// State is called to convert an ID to one or more InstanceState to
                                                                                                                                                                                                                                          	// insert into the Terraform state. If this isn't specified, then
                                                                                                                                                                                                                                          	// the ID is passed straight through.
                                                                                                                                                                                                                                          	State StateFunc
                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                            ResourceImporter defines how a resource is imported in Terraform. This can be set onto a Resource struct to make it Importable. Not all resources have to be importable; if a Resource doesn't have a ResourceImporter then it won't be importable.

                                                                                                                                                                                                                                            "Importing" in Terraform is the process of taking an already-created resource and bringing it under Terraform management. This can include updating Terraform state, generating Terraform configuration, etc.

                                                                                                                                                                                                                                            func (*ResourceImporter) InternalValidate

                                                                                                                                                                                                                                            func (r *ResourceImporter) InternalValidate() error

                                                                                                                                                                                                                                              InternalValidate should be called to validate the structure of this importer. This should be called in a unit test.

                                                                                                                                                                                                                                              Resource.InternalValidate() will automatically call this, so this doesn't need to be called manually. Further, Resource.InternalValidate() is automatically called by Provider.InternalValidate(), so you only need to internal validate the provider.

                                                                                                                                                                                                                                              type ResourceTimeout

                                                                                                                                                                                                                                              type ResourceTimeout struct {
                                                                                                                                                                                                                                              	Create, Read, Update, Delete, Default *time.Duration
                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                              func (*ResourceTimeout) ConfigDecode

                                                                                                                                                                                                                                              func (t *ResourceTimeout) ConfigDecode(s *Resource, c *terraform.ResourceConfig) error

                                                                                                                                                                                                                                                ConfigDecode takes a schema and the configuration (available in Diff) and validates, parses the timeouts into `t`

                                                                                                                                                                                                                                                func (*ResourceTimeout) DiffDecode

                                                                                                                                                                                                                                                func (t *ResourceTimeout) DiffDecode(is *terraform.InstanceDiff) error

                                                                                                                                                                                                                                                func (*ResourceTimeout) DiffEncode

                                                                                                                                                                                                                                                func (t *ResourceTimeout) DiffEncode(id *terraform.InstanceDiff) error

                                                                                                                                                                                                                                                  DiffEncode, StateEncode, and MetaDecode are analogous to the Go stdlib JSONEncoder interface: they encode/decode a timeouts struct from an instance diff, which is where the timeout data is stored after a diff to pass into Apply.

                                                                                                                                                                                                                                                  StateEncode encodes the timeout into the ResourceData's InstanceState for saving to state

                                                                                                                                                                                                                                                  func (*ResourceTimeout) StateDecode

                                                                                                                                                                                                                                                  func (t *ResourceTimeout) StateDecode(id *terraform.InstanceState) error

                                                                                                                                                                                                                                                  func (*ResourceTimeout) StateEncode

                                                                                                                                                                                                                                                  func (t *ResourceTimeout) StateEncode(is *terraform.InstanceState) error

                                                                                                                                                                                                                                                  type Schema

                                                                                                                                                                                                                                                  type Schema struct {
                                                                                                                                                                                                                                                  	// Type is the type of the value and must be one of the ValueType values.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// This type not only determines what type is expected/valid in configuring
                                                                                                                                                                                                                                                  	// this value, but also what type is returned when ResourceData.Get is
                                                                                                                                                                                                                                                  	// called. The types returned by Get are:
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	//   TypeBool - bool
                                                                                                                                                                                                                                                  	//   TypeInt - int
                                                                                                                                                                                                                                                  	//   TypeFloat - float64
                                                                                                                                                                                                                                                  	//   TypeString - string
                                                                                                                                                                                                                                                  	//   TypeList - []interface{}
                                                                                                                                                                                                                                                  	//   TypeMap - map[string]interface{}
                                                                                                                                                                                                                                                  	//   TypeSet - *schema.Set
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	Type ValueType
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// ConfigMode allows for overriding the default behaviors for mapping
                                                                                                                                                                                                                                                  	// schema entries onto configuration constructs.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// By default, the Elem field is used to choose whether a particular
                                                                                                                                                                                                                                                  	// schema is represented in configuration as an attribute or as a nested
                                                                                                                                                                                                                                                  	// block; if Elem is a *schema.Resource then it's a block and it's an
                                                                                                                                                                                                                                                  	// attribute otherwise.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// If Elem is *schema.Resource then setting ConfigMode to
                                                                                                                                                                                                                                                  	// SchemaConfigModeAttr will force it to be represented in configuration
                                                                                                                                                                                                                                                  	// as an attribute, which means that the Computed flag can be used to
                                                                                                                                                                                                                                                  	// provide default elements when the argument isn't set at all, while still
                                                                                                                                                                                                                                                  	// allowing the user to force zero elements by explicitly assigning an
                                                                                                                                                                                                                                                  	// empty list.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// When Computed is set without Optional, the attribute is not settable
                                                                                                                                                                                                                                                  	// in configuration at all and so SchemaConfigModeAttr is the automatic
                                                                                                                                                                                                                                                  	// behavior, and SchemaConfigModeBlock is not permitted.
                                                                                                                                                                                                                                                  	ConfigMode SchemaConfigMode
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// If one of these is set, then this item can come from the configuration.
                                                                                                                                                                                                                                                  	// Both cannot be set. If Optional is set, the value is optional. If
                                                                                                                                                                                                                                                  	// Required is set, the value is required.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// One of these must be set if the value is not computed. That is:
                                                                                                                                                                                                                                                  	// value either comes from the config, is computed, or is both.
                                                                                                                                                                                                                                                  	Optional bool
                                                                                                                                                                                                                                                  	Required bool
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// If this is non-nil, the provided function will be used during diff
                                                                                                                                                                                                                                                  	// of this field. If this is nil, a default diff for the type of the
                                                                                                                                                                                                                                                  	// schema will be used.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// This allows comparison based on something other than primitive, list
                                                                                                                                                                                                                                                  	// or map equality - for example SSH public keys may be considered
                                                                                                                                                                                                                                                  	// equivalent regardless of trailing whitespace.
                                                                                                                                                                                                                                                  	DiffSuppressFunc SchemaDiffSuppressFunc
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// If this is non-nil, then this will be a default value that is used
                                                                                                                                                                                                                                                  	// when this item is not set in the configuration.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// DefaultFunc can be specified to compute a dynamic default.
                                                                                                                                                                                                                                                  	// Only one of Default or DefaultFunc can be set. If DefaultFunc is
                                                                                                                                                                                                                                                  	// used then its return value should be stable to avoid generating
                                                                                                                                                                                                                                                  	// confusing/perpetual diffs.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// Changing either Default or the return value of DefaultFunc can be
                                                                                                                                                                                                                                                  	// a breaking change, especially if the attribute in question has
                                                                                                                                                                                                                                                  	// ForceNew set. If a default needs to change to align with changing
                                                                                                                                                                                                                                                  	// assumptions in an upstream API then it may be necessary to also use
                                                                                                                                                                                                                                                  	// the MigrateState function on the resource to change the state to match,
                                                                                                                                                                                                                                                  	// or have the Read function adjust the state value to align with the
                                                                                                                                                                                                                                                  	// new default.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// If Required is true above, then Default cannot be set. DefaultFunc
                                                                                                                                                                                                                                                  	// can be set with Required. If the DefaultFunc returns nil, then there
                                                                                                                                                                                                                                                  	// will be no default and the user will be asked to fill it in.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// If either of these is set, then the user won't be asked for input
                                                                                                                                                                                                                                                  	// for this key if the default is not nil.
                                                                                                                                                                                                                                                  	Default     interface{}
                                                                                                                                                                                                                                                  	DefaultFunc SchemaDefaultFunc
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Description is used as the description for docs or asking for user
                                                                                                                                                                                                                                                  	// input. It should be relatively short (a few sentences max) and should
                                                                                                                                                                                                                                                  	// be formatted to fit a CLI.
                                                                                                                                                                                                                                                  	Description string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// InputDefault is the default value to use for when inputs are requested.
                                                                                                                                                                                                                                                  	// This differs from Default in that if Default is set, no input is
                                                                                                                                                                                                                                                  	// asked for. If Input is asked, this will be the default value offered.
                                                                                                                                                                                                                                                  	InputDefault string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The fields below relate to diffs.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// If Computed is true, then the result of this value is computed
                                                                                                                                                                                                                                                  	// (unless specified by config) on creation.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// If ForceNew is true, then a change in this resource necessitates
                                                                                                                                                                                                                                                  	// the creation of a new resource.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// StateFunc is a function called to change the value of this before
                                                                                                                                                                                                                                                  	// storing it in the state (and likewise before comparing for diffs).
                                                                                                                                                                                                                                                  	// The use for this is for example with large strings, you may want
                                                                                                                                                                                                                                                  	// to simply store the hash of it.
                                                                                                                                                                                                                                                  	Computed  bool
                                                                                                                                                                                                                                                  	ForceNew  bool
                                                                                                                                                                                                                                                  	StateFunc SchemaStateFunc
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The following fields are only set for a TypeList, TypeSet, or TypeMap.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// Elem represents the element type. For a TypeMap, it must be a *Schema
                                                                                                                                                                                                                                                  	// with a Type that is one of the primitives: TypeString, TypeBool,
                                                                                                                                                                                                                                                  	// TypeInt, or TypeFloat. Otherwise it may be either a *Schema or a
                                                                                                                                                                                                                                                  	// *Resource. If it is *Schema, the element type is just a simple value.
                                                                                                                                                                                                                                                  	// If it is *Resource, the element type is a complex structure,
                                                                                                                                                                                                                                                  	// potentially managed via its own CRUD actions on the API.
                                                                                                                                                                                                                                                  	Elem interface{}
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The following fields are only set for a TypeList or TypeSet.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// MaxItems defines a maximum amount of items that can exist within a
                                                                                                                                                                                                                                                  	// TypeSet or TypeList. Specific use cases would be if a TypeSet is being
                                                                                                                                                                                                                                                  	// used to wrap a complex structure, however more than one instance would
                                                                                                                                                                                                                                                  	// cause instability.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// MinItems defines a minimum amount of items that can exist within a
                                                                                                                                                                                                                                                  	// TypeSet or TypeList. Specific use cases would be if a TypeSet is being
                                                                                                                                                                                                                                                  	// used to wrap a complex structure, however less than one instance would
                                                                                                                                                                                                                                                  	// cause instability.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// If the field Optional is set to true then MinItems is ignored and thus
                                                                                                                                                                                                                                                  	// effectively zero.
                                                                                                                                                                                                                                                  	MaxItems int
                                                                                                                                                                                                                                                  	MinItems int
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// PromoteSingle originally allowed for a single element to be assigned
                                                                                                                                                                                                                                                  	// where a primitive list was expected, but this no longer works from
                                                                                                                                                                                                                                                  	// Terraform v0.12 onwards (Terraform Core will require a list to be set
                                                                                                                                                                                                                                                  	// regardless of what this is set to) and so only applies to Terraform v0.11
                                                                                                                                                                                                                                                  	// and earlier, and so should be used only to retain this functionality
                                                                                                                                                                                                                                                  	// for those still using v0.11 with a provider that formerly used this.
                                                                                                                                                                                                                                                  	PromoteSingle bool
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// The following fields are only valid for a TypeSet type.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// Set defines a function to determine the unique ID of an item so that
                                                                                                                                                                                                                                                  	// a proper set can be built.
                                                                                                                                                                                                                                                  	Set SchemaSetFunc
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// ComputedWhen is a set of queries on the configuration. Whenever any
                                                                                                                                                                                                                                                  	// of these things is changed, it will require a recompute (this requires
                                                                                                                                                                                                                                                  	// that Computed is set to true).
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// NOTE: This currently does not work.
                                                                                                                                                                                                                                                  	ComputedWhen []string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// ConflictsWith is a set of schema keys that conflict with this schema.
                                                                                                                                                                                                                                                  	// This will only check that they're set in the _config_. This will not
                                                                                                                                                                                                                                                  	// raise an error for a malfunctioning resource that sets a conflicting
                                                                                                                                                                                                                                                  	// key.
                                                                                                                                                                                                                                                  	ConflictsWith []string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// When Deprecated is set, this attribute is deprecated.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// A deprecated field still works, but will probably stop working in near
                                                                                                                                                                                                                                                  	// future. This string is the message shown to the user with instructions on
                                                                                                                                                                                                                                                  	// how to address the deprecation.
                                                                                                                                                                                                                                                  	Deprecated string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// When Removed is set, this attribute has been removed from the schema
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// Removed attributes can be left in the Schema to generate informative error
                                                                                                                                                                                                                                                  	// messages for the user when they show up in resource configurations.
                                                                                                                                                                                                                                                  	// This string is the message shown to the user with instructions on
                                                                                                                                                                                                                                                  	// what do to about the removed attribute.
                                                                                                                                                                                                                                                  	Removed string
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// ValidateFunc allows individual fields to define arbitrary validation
                                                                                                                                                                                                                                                  	// logic. It is yielded the provided config value as an interface{} that is
                                                                                                                                                                                                                                                  	// guaranteed to be of the proper Schema type, and it can yield warnings or
                                                                                                                                                                                                                                                  	// errors based on inspection of that value.
                                                                                                                                                                                                                                                  	//
                                                                                                                                                                                                                                                  	// ValidateFunc is honored only when the schema's Type is set to TypeInt,
                                                                                                                                                                                                                                                  	// TypeFloat, TypeString, TypeBool, or TypeMap. It is ignored for all other types.
                                                                                                                                                                                                                                                  	ValidateFunc SchemaValidateFunc
                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                  	// Sensitive ensures that the attribute's value does not get displayed in
                                                                                                                                                                                                                                                  	// logs or regular output. It should be used for passwords or other
                                                                                                                                                                                                                                                  	// secret fields. Future versions of Terraform may encrypt these
                                                                                                                                                                                                                                                  	// values.
                                                                                                                                                                                                                                                  	Sensitive bool
                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                    Schema is used to describe the structure of a value.

                                                                                                                                                                                                                                                    Read the documentation of the struct elements for important details.

                                                                                                                                                                                                                                                    func SchemasForFlatmapPath

                                                                                                                                                                                                                                                    func SchemasForFlatmapPath(path string, schemaMap map[string]*Schema) []*Schema

                                                                                                                                                                                                                                                      SchemasForFlatmapPath tries its best to find a sequence of schemas that the given dot-delimited attribute path traverses through.

                                                                                                                                                                                                                                                      func (*Schema) DefaultValue

                                                                                                                                                                                                                                                      func (s *Schema) DefaultValue() (interface{}, error)

                                                                                                                                                                                                                                                        Returns a default value for this schema by either reading Default or evaluating DefaultFunc. If neither of these are defined, returns nil.

                                                                                                                                                                                                                                                        func (*Schema) GoString

                                                                                                                                                                                                                                                        func (s *Schema) GoString() string

                                                                                                                                                                                                                                                        func (*Schema) ZeroValue

                                                                                                                                                                                                                                                        func (s *Schema) ZeroValue() interface{}

                                                                                                                                                                                                                                                          Returns a zero value for the schema.

                                                                                                                                                                                                                                                          type SchemaConfigMode

                                                                                                                                                                                                                                                          type SchemaConfigMode int

                                                                                                                                                                                                                                                            SchemaConfigMode is used to influence how a schema item is mapped into a corresponding configuration construct, using the ConfigMode field of Schema.

                                                                                                                                                                                                                                                            const (
                                                                                                                                                                                                                                                            	SchemaConfigModeAuto SchemaConfigMode = iota
                                                                                                                                                                                                                                                            	SchemaConfigModeAttr
                                                                                                                                                                                                                                                            	SchemaConfigModeBlock
                                                                                                                                                                                                                                                            )

                                                                                                                                                                                                                                                            type SchemaDefaultFunc

                                                                                                                                                                                                                                                            type SchemaDefaultFunc func() (interface{}, error)

                                                                                                                                                                                                                                                              SchemaDefaultFunc is a function called to return a default value for a field.

                                                                                                                                                                                                                                                              func EnvDefaultFunc

                                                                                                                                                                                                                                                              func EnvDefaultFunc(k string, dv interface{}) SchemaDefaultFunc

                                                                                                                                                                                                                                                                EnvDefaultFunc is a helper function that returns the value of the given environment variable, if one exists, or the default value otherwise.

                                                                                                                                                                                                                                                                func MultiEnvDefaultFunc

                                                                                                                                                                                                                                                                func MultiEnvDefaultFunc(ks []string, dv interface{}) SchemaDefaultFunc

                                                                                                                                                                                                                                                                  MultiEnvDefaultFunc is a helper function that returns the value of the first environment variable in the given list that returns a non-empty value. If none of the environment variables return a value, the default value is returned.

                                                                                                                                                                                                                                                                  type SchemaDiffSuppressFunc

                                                                                                                                                                                                                                                                  type SchemaDiffSuppressFunc func(k, old, new string, d *ResourceData) bool

                                                                                                                                                                                                                                                                    SchemaDiffSuppressFunc is a function which can be used to determine whether a detected diff on a schema element is "valid" or not, and suppress it from the plan if necessary.

                                                                                                                                                                                                                                                                    Return true if the diff should be suppressed, false to retain it.

                                                                                                                                                                                                                                                                    type SchemaSetFunc

                                                                                                                                                                                                                                                                    type SchemaSetFunc func(interface{}) int

                                                                                                                                                                                                                                                                      SchemaSetFunc is a function that must return a unique ID for the given element. This unique ID is used to store the element in a hash.

                                                                                                                                                                                                                                                                      func HashResource

                                                                                                                                                                                                                                                                      func HashResource(resource *Resource) SchemaSetFunc

                                                                                                                                                                                                                                                                        HashResource hashes complex structures that are described using a *Resource. This is the default set implementation used when a set's element type is a full resource.

                                                                                                                                                                                                                                                                        func HashSchema

                                                                                                                                                                                                                                                                        func HashSchema(schema *Schema) SchemaSetFunc

                                                                                                                                                                                                                                                                          HashSchema hashes values that are described using a *Schema. This is the default set implementation used when a set's element type is a single schema.

                                                                                                                                                                                                                                                                          type SchemaStateFunc

                                                                                                                                                                                                                                                                          type SchemaStateFunc func(interface{}) string

                                                                                                                                                                                                                                                                            SchemaStateFunc is a function used to convert some type to a string to be stored in the state.

                                                                                                                                                                                                                                                                            type SchemaValidateFunc

                                                                                                                                                                                                                                                                            type SchemaValidateFunc func(interface{}, string) ([]string, []error)

                                                                                                                                                                                                                                                                              SchemaValidateFunc is a function used to validate a single field in the schema.

                                                                                                                                                                                                                                                                              type Set

                                                                                                                                                                                                                                                                              type Set struct {
                                                                                                                                                                                                                                                                              	F SchemaSetFunc
                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                Set is a set data structure that is returned for elements of type TypeSet.

                                                                                                                                                                                                                                                                                func CopySet

                                                                                                                                                                                                                                                                                func CopySet(otherSet *Set) *Set

                                                                                                                                                                                                                                                                                  CopySet returns a copy of another set.

                                                                                                                                                                                                                                                                                  func NewSet

                                                                                                                                                                                                                                                                                  func NewSet(f SchemaSetFunc, items []interface{}) *Set

                                                                                                                                                                                                                                                                                    NewSet is a convenience method for creating a new set with the given items.

                                                                                                                                                                                                                                                                                    func (*Set) Add

                                                                                                                                                                                                                                                                                    func (s *Set) Add(item interface{})

                                                                                                                                                                                                                                                                                      Add adds an item to the set if it isn't already in the set.

                                                                                                                                                                                                                                                                                      func (*Set) Contains

                                                                                                                                                                                                                                                                                      func (s *Set) Contains(item interface{}) bool

                                                                                                                                                                                                                                                                                        Contains checks if the set has the given item.

                                                                                                                                                                                                                                                                                        func (*Set) Difference

                                                                                                                                                                                                                                                                                        func (s *Set) Difference(other *Set) *Set

                                                                                                                                                                                                                                                                                          Difference performs a set difference of the two sets, returning a new third set that has only the elements unique to this set.

                                                                                                                                                                                                                                                                                          func (*Set) Equal

                                                                                                                                                                                                                                                                                          func (s *Set) Equal(raw interface{}) bool

                                                                                                                                                                                                                                                                                          func (*Set) GoString

                                                                                                                                                                                                                                                                                          func (s *Set) GoString() string

                                                                                                                                                                                                                                                                                          func (*Set) HashEqual

                                                                                                                                                                                                                                                                                          func (s *Set) HashEqual(raw interface{}) bool

                                                                                                                                                                                                                                                                                            HashEqual simply checks to the keys the top-level map to the keys in the other set's top-level map to see if they are equal. This obviously assumes you have a properly working hash function - use HashResource if in doubt.

                                                                                                                                                                                                                                                                                            func (*Set) Intersection

                                                                                                                                                                                                                                                                                            func (s *Set) Intersection(other *Set) *Set

                                                                                                                                                                                                                                                                                              Intersection performs the set intersection of the two sets and returns a new third set.

                                                                                                                                                                                                                                                                                              func (*Set) Len

                                                                                                                                                                                                                                                                                              func (s *Set) Len() int

                                                                                                                                                                                                                                                                                                Len returns the amount of items in the set.

                                                                                                                                                                                                                                                                                                func (*Set) List

                                                                                                                                                                                                                                                                                                func (s *Set) List() []interface{}

                                                                                                                                                                                                                                                                                                  List returns the elements of this set in slice format.

                                                                                                                                                                                                                                                                                                  The order of the returned elements is deterministic. Given the same set, the order of this will always be the same.

                                                                                                                                                                                                                                                                                                  func (*Set) Remove

                                                                                                                                                                                                                                                                                                  func (s *Set) Remove(item interface{})

                                                                                                                                                                                                                                                                                                    Remove removes an item if it's already in the set. Idempotent.

                                                                                                                                                                                                                                                                                                    func (*Set) Union

                                                                                                                                                                                                                                                                                                    func (s *Set) Union(other *Set) *Set

                                                                                                                                                                                                                                                                                                      Union performs the set union of the two sets and returns a new third set.

                                                                                                                                                                                                                                                                                                      type StateFunc

                                                                                                                                                                                                                                                                                                      type StateFunc func(*ResourceData, interface{}) ([]*ResourceData, error)

                                                                                                                                                                                                                                                                                                        StateFunc is the function called to import a resource into the Terraform state. It is given a ResourceData with only ID set. This ID is going to be an arbitrary value given by the user and may not map directly to the ID format that the resource expects, so that should be validated.

                                                                                                                                                                                                                                                                                                        This should return a slice of ResourceData that turn into the state that was imported. This might be as simple as returning only the argument that was given to the function. In other cases (such as AWS security groups), an import may fan out to multiple resources and this will have to return multiple.

                                                                                                                                                                                                                                                                                                        To create the ResourceData structures for other resource types (if you have to), instantiate your resource and call the Data function.

                                                                                                                                                                                                                                                                                                        type StateMigrateFunc

                                                                                                                                                                                                                                                                                                        type StateMigrateFunc func(
                                                                                                                                                                                                                                                                                                        	int, *terraform.InstanceState, interface{}) (*terraform.InstanceState, error)

                                                                                                                                                                                                                                                                                                          See Resource documentation.

                                                                                                                                                                                                                                                                                                          type StateUpgradeFunc

                                                                                                                                                                                                                                                                                                          type StateUpgradeFunc func(rawState map[string]interface{}, meta interface{}) (map[string]interface{}, error)

                                                                                                                                                                                                                                                                                                            See StateUpgrader

                                                                                                                                                                                                                                                                                                            type StateUpgrader

                                                                                                                                                                                                                                                                                                            type StateUpgrader struct {
                                                                                                                                                                                                                                                                                                            	// Version is the version schema that this Upgrader will handle, converting
                                                                                                                                                                                                                                                                                                            	// it to Version+1.
                                                                                                                                                                                                                                                                                                            	Version int
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// Type describes the schema that this function can upgrade. Type is
                                                                                                                                                                                                                                                                                                            	// required to decode the schema if the state was stored in a legacy
                                                                                                                                                                                                                                                                                                            	// flatmap format.
                                                                                                                                                                                                                                                                                                            	Type cty.Type
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            	// Upgrade takes the JSON encoded state and the provider meta value, and
                                                                                                                                                                                                                                                                                                            	// upgrades the state one single schema version. The provided state is
                                                                                                                                                                                                                                                                                                            	// deocded into the default json types using a map[string]interface{}. It
                                                                                                                                                                                                                                                                                                            	// is up to the StateUpgradeFunc to ensure that the returned value can be
                                                                                                                                                                                                                                                                                                            	// encoded using the new schema.
                                                                                                                                                                                                                                                                                                            	Upgrade StateUpgradeFunc
                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                            type UpdateFunc

                                                                                                                                                                                                                                                                                                            type UpdateFunc func(*ResourceData, interface{}) error

                                                                                                                                                                                                                                                                                                              See Resource documentation.

                                                                                                                                                                                                                                                                                                              type ValueType

                                                                                                                                                                                                                                                                                                              type ValueType int

                                                                                                                                                                                                                                                                                                                ValueType is an enum of the type that can be represented by a schema.

                                                                                                                                                                                                                                                                                                                const (
                                                                                                                                                                                                                                                                                                                	TypeInvalid ValueType = iota
                                                                                                                                                                                                                                                                                                                	TypeBool
                                                                                                                                                                                                                                                                                                                	TypeInt
                                                                                                                                                                                                                                                                                                                	TypeFloat
                                                                                                                                                                                                                                                                                                                	TypeString
                                                                                                                                                                                                                                                                                                                	TypeList
                                                                                                                                                                                                                                                                                                                	TypeMap
                                                                                                                                                                                                                                                                                                                	TypeSet
                                                                                                                                                                                                                                                                                                                )

                                                                                                                                                                                                                                                                                                                func (ValueType) String

                                                                                                                                                                                                                                                                                                                func (i ValueType) String() string

                                                                                                                                                                                                                                                                                                                func (ValueType) Zero

                                                                                                                                                                                                                                                                                                                func (t ValueType) Zero() interface{}

                                                                                                                                                                                                                                                                                                                  Zero returns the zero value for a type.