terraform: github.com/hashicorp/terraform/helper/schema Index | Files

package schema

import "github.com/hashicorp/terraform/helper/schema"

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

Package Files

backend.go core_schema.go data_source_resource_shim.go equal.go field_reader.go field_reader_config.go field_reader_diff.go field_reader_map.go field_reader_multi.go field_writer.go field_writer_map.go getsource_string.go provider.go provisioner.go resource.go resource_data.go resource_data_get_source.go resource_diff.go resource_importer.go resource_timeout.go schema.go serialize.go set.go testing.go valuetype.go valuetype_string.go

Constants

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

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

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

Variables

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.

func DefaultTimeout Uses

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

could be time.Duration, int64 or float64

func HashInt Uses

func HashInt(v interface{}) int

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

func HashString Uses

func HashString(v interface{}) int

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

func Noop Uses

func Noop(*ResourceData, interface{}) error

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

func RemoveFromState Uses

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 Uses

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 Uses

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

type Backend Uses

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 Uses

func (b *Backend) Config() *ResourceData

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

func (*Backend) Configure Uses

func (b *Backend) Configure(c *terraform.ResourceConfig) error

func (*Backend) Input Uses

func (b *Backend) Input(
    input terraform.UIInput,
    c *terraform.ResourceConfig) (*terraform.ResourceConfig, error)

func (*Backend) Validate Uses

func (b *Backend) Validate(c *terraform.ResourceConfig) ([]string, []error)

type BasicMapReader Uses

type BasicMapReader map[string]string

BasicMapReader implements MapReader for a single map.

func (BasicMapReader) Access Uses

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

func (BasicMapReader) Range Uses

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

type ConfigFieldReader Uses

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 Uses

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

type ConfigureFunc Uses

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 Uses

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

See Resource documentation.

type CustomizeDiffFunc Uses

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

See Resource documentation.

type DeleteFunc Uses

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

See Resource documentation.

type DiffFieldReader Uses

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 Uses

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

type Equal Uses

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

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

type ExistsFunc Uses

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

See Resource documentation.

type FieldReadResult Uses

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 Uses

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 Uses

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 Uses

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 MapFieldReader Uses

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 Uses

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

type MapFieldWriter Uses

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 Uses

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

Map returns the underlying map that is being written to.

func (*MapFieldWriter) WriteField Uses

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

type MapReader Uses

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 Uses

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 Uses

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

func (*MultiLevelFieldReader) ReadFieldExact Uses

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

func (*MultiLevelFieldReader) ReadFieldMerge Uses

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

type MultiMapReader Uses

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 Uses

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

func (MultiMapReader) Range Uses

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

type Provider Uses

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

    // 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
    // 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 Uses

func (p *Provider) Apply(
    info *terraform.InstanceInfo,
    s *terraform.InstanceState,
    d *terraform.InstanceDiff) (*terraform.InstanceState, error)

Apply implementation of terraform.ResourceProvider interface.

func (*Provider) Configure Uses

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

Configure implementation of terraform.ResourceProvider interface.

func (*Provider) DataSources Uses

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

DataSources implementation of terraform.ResourceProvider interface.

func (*Provider) Diff Uses

func (p *Provider) Diff(
    info *terraform.InstanceInfo,
    s *terraform.InstanceState,
    c *terraform.ResourceConfig) (*terraform.InstanceDiff, error)

Diff implementation of terraform.ResourceProvider interface.

func (*Provider) GetSchema Uses

func (p *Provider) GetSchema(req *terraform.ProviderSchemaRequest) (*terraform.ProviderSchema, error)

GetSchema implementation of terraform.ResourceProvider interface

func (*Provider) ImportState Uses

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

func (*Provider) Input Uses

func (p *Provider) Input(
    input terraform.UIInput,
    c *terraform.ResourceConfig) (*terraform.ResourceConfig, error)

Input implementation of terraform.ResourceProvider interface.

func (*Provider) InternalValidate Uses

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 Uses

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 Uses

func (p *Provider) ReadDataApply(
    info *terraform.InstanceInfo,
    d *terraform.InstanceDiff) (*terraform.InstanceState, error)

RefreshData implementation of terraform.ResourceProvider interface.

func (*Provider) ReadDataDiff Uses

func (p *Provider) ReadDataDiff(
    info *terraform.InstanceInfo,
    c *terraform.ResourceConfig) (*terraform.InstanceDiff, error)

ReadDataDiff implementation of terraform.ResourceProvider interface.

func (*Provider) Refresh Uses

func (p *Provider) Refresh(
    info *terraform.InstanceInfo,
    s *terraform.InstanceState) (*terraform.InstanceState, error)

Refresh implementation of terraform.ResourceProvider interface.

func (*Provider) Resources Uses

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

Resources implementation of terraform.ResourceProvider interface.

func (*Provider) SetMeta Uses

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) Stop Uses

func (p *Provider) Stop() error

Stop implementation of terraform.ResourceProvider interface.

func (*Provider) StopContext Uses

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

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

func (*Provider) Stopped Uses

func (p *Provider) Stopped() bool

Stopped reports whether the provider has been stopped or not.

func (*Provider) TestReset Uses

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 Uses

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

Validate implementation of terraform.ResourceProvider interface.

func (*Provider) ValidateDataSource Uses

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

ValidateDataSource implementation of terraform.ResourceProvider interface.

func (*Provider) ValidateResource Uses

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

ValidateResource implementation of terraform.ResourceProvider interface.

type Provisioner Uses

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 Uses

func (p *Provisioner) Apply(
    o terraform.UIOutput,
    s *terraform.InstanceState,
    c *terraform.ResourceConfig) error

Apply implementation of terraform.ResourceProvisioner interface.

func (*Provisioner) InternalValidate Uses

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 Uses

func (p *Provisioner) Stop() error

Stop implementation of terraform.ResourceProvisioner interface.

func (*Provisioner) StopContext Uses

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

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

func (*Provisioner) Validate Uses

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

Validate implements the terraform.ResourceProvisioner interface.

type ReadFunc Uses

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

See Resource documentation.

type Resource Uses

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 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

    // 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. It
    // is highly recommended to set it. 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 Uses

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 Uses

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 Uses

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

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

func (*Resource) Data Uses

func (r *Resource) Data(s *terraform.InstanceState) *ResourceData

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 Uses

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 Uses

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 Uses

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 Uses

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

Refresh refreshes the state of the resource.

func (*Resource) TestResourceData Uses

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 Uses

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

Validate validates the resource configuration against the schema.

type ResourceData Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

ConnInfo returns the connection info for this resource.

func (*ResourceData) Get Uses

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 Uses

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 Uses

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 Uses

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) HasChange Uses

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

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

func (*ResourceData) Id Uses

func (d *ResourceData) Id() string

Id returns the ID of the resource.

func (*ResourceData) IsNewResource Uses

func (d *ResourceData) IsNewResource() bool

func (*ResourceData) MarkNewResource Uses

func (d *ResourceData) MarkNewResource()

func (*ResourceData) Partial Uses

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 Uses

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 Uses

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

SetConnInfo sets the connection info for a resource.

func (*ResourceData) SetId Uses

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 Uses

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 Uses

func (d *ResourceData) SetType(t string)

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

func (*ResourceData) State Uses

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

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

func (*ResourceData) Timeout Uses

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 Uses

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.

type ResourceDiff Uses

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 Uses

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 Uses

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 Uses

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

Get hands off to ResourceData.Get.

func (*ResourceDiff) GetChange Uses

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

GetChange gets the change between the state and diff, checking first to see if a 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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

func (*ResourceTimeout) ConfigDecode Uses

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 Uses

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

func (*ResourceTimeout) DiffEncode Uses

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 Uses

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

func (*ResourceTimeout) StateEncode Uses

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

type Schema Uses

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

    // 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 of TypeString, 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 with its own lifecycle.
    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.
    //
    // PromoteSingle, if true, will allow single elements to be standalone
    // and promote them to a list. For example "foo" would be promoted to
    // ["foo"] automatically. This is primarily for legacy reasons and the
    // ambiguity is not recommended for new usage. Promotion is only allowed
    // for primitive element types.
    MaxItems      int
    MinItems      int
    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 currently only works for primitive 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 (*Schema) DefaultValue Uses

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 Uses

func (s *Schema) GoString() string

func (*Schema) ZeroValue Uses

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

Returns a zero value for the schema.

type SchemaDefaultFunc Uses

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

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

func EnvDefaultFunc Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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

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

type Set Uses

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 Uses

func CopySet(otherSet *Set) *Set

CopySet returns a copy of another set.

func NewSet Uses

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

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

func (*Set) Add Uses

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

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

func (*Set) Contains Uses

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

Contains checks if the set has the given item.

func (*Set) Difference Uses

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 Uses

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

func (*Set) GoString Uses

func (s *Set) GoString() string

func (*Set) HashEqual Uses

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 Uses

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 Uses

func (s *Set) Len() int

Len returns the amount of items in the set.

func (*Set) List Uses

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 Uses

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

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

func (*Set) Union Uses

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

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

type StateFunc Uses

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 Uses

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

See Resource documentation.

type UpdateFunc Uses

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

See Resource documentation.

type ValueType Uses

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 Uses

func (i ValueType) String() string

func (ValueType) Zero Uses

func (t ValueType) Zero() interface{}

Zero returns the zero value for a type.

Package schema imports 22 packages (graph) and is imported by 3015 packages. Updated 2018-09-17. Refresh now. Tools for package owners.