vendor/github.com/hashicorp/terraform/config/configschema/schema.go

   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 )