github.com/medzin/terraform@v0.11.11/config/configschema/schema.go (about)

     1  package configschema
     2  
     3  import (
     4  	"github.com/zclconf/go-cty/cty"
     5  )
     6  
     7  // Block represents a configuration block.
     8  //
     9  // "Block" here is a logical grouping construct, though it happens to map
    10  // directly onto the physical block syntax of Terraform's native configuration
    11  // syntax. It may be a more a matter of convention in other syntaxes, such as
    12  // JSON.
    13  //
    14  // When converted to a value, a Block always becomes an instance of an object
    15  // type derived from its defined attributes and nested blocks
    16  type Block struct {
    17  	// Attributes describes any attributes that may appear directly inside
    18  	// the block.
    19  	Attributes map[string]*Attribute
    20  
    21  	// BlockTypes describes any nested block types that may appear directly
    22  	// inside the block.
    23  	BlockTypes map[string]*NestedBlock
    24  }
    25  
    26  // Attribute represents a configuration attribute, within a block.
    27  type Attribute struct {
    28  	// Type is a type specification that the attribute's value must conform to.
    29  	Type cty.Type
    30  
    31  	// Required, if set to true, specifies that an omitted or null value is
    32  	// not permitted.
    33  	Required bool
    34  
    35  	// Optional, if set to true, specifies that an omitted or null value is
    36  	// permitted. This field conflicts with Required.
    37  	Optional bool
    38  
    39  	// Computed, if set to true, specifies that the value comes from the
    40  	// provider rather than from configuration. If combined with Optional,
    41  	// then the config may optionally provide an overridden value.
    42  	Computed bool
    43  
    44  	// Sensitive, if set to true, indicates that an attribute may contain
    45  	// sensitive information.
    46  	//
    47  	// At present nothing is done with this information, but callers are
    48  	// encouraged to set it where appropriate so that it may be used in the
    49  	// future to help Terraform mask sensitive information. (Terraform
    50  	// currently achieves this in a limited sense via other mechanisms.)
    51  	Sensitive bool
    52  }
    53  
    54  // NestedBlock represents the embedding of one block within another.
    55  type NestedBlock struct {
    56  	// Block is the description of the block that's nested.
    57  	Block
    58  
    59  	// Nesting provides the nesting mode for the child block, which determines
    60  	// how many instances of the block are allowed, how many labels it expects,
    61  	// and how the resulting data will be converted into a data structure.
    62  	Nesting NestingMode
    63  
    64  	// MinItems and MaxItems set, for the NestingList and NestingSet nesting
    65  	// modes, lower and upper limits on the number of child blocks allowed
    66  	// of the given type. If both are left at zero, no limit is applied.
    67  	//
    68  	// As a special case, both values can be set to 1 for NestingSingle in
    69  	// order to indicate that a particular single block is required.
    70  	//
    71  	// These fields are ignored for other nesting modes and must both be left
    72  	// at zero.
    73  	MinItems, MaxItems int
    74  }
    75  
    76  // NestingMode is an enumeration of modes for nesting blocks inside other
    77  // blocks.
    78  type NestingMode int
    79  
    80  //go:generate stringer -type=NestingMode
    81  
    82  const (
    83  	nestingModeInvalid NestingMode = iota
    84  
    85  	// NestingSingle indicates that only a single instance of a given
    86  	// block type is permitted, with no labels, and its content should be
    87  	// provided directly as an object value.
    88  	NestingSingle
    89  
    90  	// NestingList indicates that multiple blocks of the given type are
    91  	// permitted, with no labels, and that their corresponding objects should
    92  	// be provided in a list.
    93  	NestingList
    94  
    95  	// NestingSet indicates that multiple blocks of the given type are
    96  	// permitted, with no labels, and that their corresponding objects should
    97  	// be provided in a set.
    98  	NestingSet
    99  
   100  	// NestingMap indicates that multiple blocks of the given type are
   101  	// permitted, each with a single label, and that their corresponding
   102  	// objects should be provided in a map whose keys are the labels.
   103  	//
   104  	// It's an error, therefore, to use the same label value on multiple
   105  	// blocks.
   106  	NestingMap
   107  )