package schema import ( "fmt" "reflect" "strconv" "strings" "sync" "github.com/hashicorp/terraform/terraform" "github.com/mitchellh/mapstructure" ) // 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. type ResourceData struct { // Settable (internally) schema map[string]*Schema config *terraform.ResourceConfig state *terraform.InstanceState diff *terraform.InstanceDiff diffing bool // Don't set setMap map[string]string newState *terraform.InstanceState partial bool partialMap map[string]struct{} once sync.Once } // getSource represents the level we want to get for a value (internally). // Any source less than or equal to the level will be loaded (whichever // has a value first). type getSource byte const ( getSourceState getSource = 1 << iota getSourceConfig getSourceDiff getSourceSet getSourceExact getSourceMax = getSourceSet ) // getResult is the internal structure that is generated when a Get // is called that contains some extra data that might be used. type getResult struct { Value interface{} ValueProcessed interface{} Computed bool Exists bool Schema *Schema } var getResultEmpty getResult // 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 (d *ResourceData) Get(key string) interface{} { v, _ := d.GetOk(key) return v } // 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 (d *ResourceData) GetChange(key string) (interface{}, interface{}) { o, n := d.getChange(key, getSourceConfig, getSourceDiff) return o.Value, n.Value } // GetOk returns the data for the given key and whether or not the key // existed or not in the configuration. The second boolean result will also // be false if a key is given that isn't in the schema at all. // // 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 (d *ResourceData) GetOk(key string) (interface{}, bool) { r := d.getRaw(key, getSourceSet) return r.Value, r.Exists } func (d *ResourceData) getRaw(key string, level getSource) getResult { var parts []string if key != "" { parts = strings.Split(key, ".") } return d.getObject("", parts, d.schema, level) } // HasChange returns whether or not the given key has been changed. func (d *ResourceData) HasChange(key string) bool { o, n := d.GetChange(key) return !reflect.DeepEqual(o, n) } // 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 (d *ResourceData) Partial(on bool) { d.partial = on if on { if d.partialMap == nil { d.partialMap = make(map[string]struct{}) } } else { d.partialMap = nil } } // 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 (d *ResourceData) Set(key string, value interface{}) error { if d.setMap == nil { d.setMap = make(map[string]string) } parts := strings.Split(key, ".") return d.setObject("", parts, d.schema, value) } // SetPartial adds the key prefix to the final state output while // in partial state mode. // // If partial state mode is disabled, then this has no effect. Additionally, // whenever partial state mode is toggled, the partial data is cleared. func (d *ResourceData) SetPartial(k string) { if d.partial { d.partialMap[k] = struct{}{} } } // Id returns the ID of the resource. func (d *ResourceData) Id() string { var result string if d.state != nil { result = d.state.ID } if d.newState != nil { result = d.newState.ID } return result } // ConnInfo returns the connection info for this resource. func (d *ResourceData) ConnInfo() map[string]string { if d.newState != nil { return d.newState.Ephemeral.ConnInfo } if d.state != nil { return d.state.Ephemeral.ConnInfo } return nil } // SetId sets the ID of the resource. If the value is blank, then the // resource is destroyed. func (d *ResourceData) SetId(v string) { d.once.Do(d.init) d.newState.ID = v } // SetConnInfo sets the connection info for a resource. func (d *ResourceData) SetConnInfo(v map[string]string) { d.once.Do(d.init) d.newState.Ephemeral.ConnInfo = v } // State returns the new InstanceState after the diff and any Set // calls. func (d *ResourceData) State() *terraform.InstanceState { var result terraform.InstanceState result.ID = d.Id() // If we have no ID, then this resource doesn't exist and we just // return nil. if result.ID == "" { return nil } result.Attributes = d.stateObject("", d.schema) result.Ephemeral.ConnInfo = d.ConnInfo() if v := d.Id(); v != "" { result.Attributes["id"] = d.Id() } return &result } func (d *ResourceData) init() { var copyState terraform.InstanceState if d.state != nil { copyState = *d.state } d.newState = ©State } func (d *ResourceData) diffChange( k string) (interface{}, interface{}, bool, bool) { // Get the change between the state and the config. o, n := d.getChange(k, getSourceState, getSourceConfig|getSourceExact) if !o.Exists { o.Value = nil } if !n.Exists { n.Value = nil } // Return the old, new, and whether there is a change return o.Value, n.Value, !reflect.DeepEqual(o.Value, n.Value), n.Computed } func (d *ResourceData) getChange( key string, oldLevel getSource, newLevel getSource) (getResult, getResult) { var parts, parts2 []string if key != "" { parts = strings.Split(key, ".") parts2 = strings.Split(key, ".") } o := d.getObject("", parts, d.schema, oldLevel) n := d.getObject("", parts2, d.schema, newLevel) return o, n } func (d *ResourceData) get( k string, parts []string, schema *Schema, source getSource) getResult { switch schema.Type { case TypeList: return d.getList(k, parts, schema, source) case TypeMap: return d.getMap(k, parts, schema, source) case TypeSet: return d.getSet(k, parts, schema, source) case TypeBool: fallthrough case TypeInt: fallthrough case TypeString: return d.getPrimitive(k, parts, schema, source) default: panic(fmt.Sprintf("%s: unknown type %#v", k, schema.Type)) } } func (d *ResourceData) getSet( k string, parts []string, schema *Schema, source getSource) getResult { s := &Set{F: schema.Set} result := getResult{Schema: schema, Value: s} // Get the list. For sets, the entire source must be exact: the // entire set must come from set, diff, state, etc. So we go backwards // and once we get a result, we take it. Or, we never get a result. var raw getResult for listSource := source; listSource > 0; listSource >>= 1 { if source&getSourceExact != 0 && listSource != source { break } raw = d.getList(k, nil, schema, listSource|getSourceExact) if raw.Exists { break } } if !raw.Exists { if len(parts) > 0 { return d.getList(k, parts, schema, source) } return result } // If the entire list is computed, then the entire set is // necessarilly computed. if raw.Computed { result.Computed = true return result } list := raw.Value.([]interface{}) if len(list) == 0 { if len(parts) > 0 { return d.getList(k, parts, schema, source) } result.Exists = raw.Exists return result } // This is a reverse map of hash code => index in config used to // resolve direct set item lookup for turning into state. Confused? // Read on... // // To create the state (the state* functions), a Get call is done // with a full key such as "ports.0". The index of a set ("0") doesn't // make a lot of sense, but we need to deterministically list out // elements of the set like this. Luckily, same sets have a deterministic // List() output, so we can use that to look things up. // // This mapping makes it so that we can look up the hash code of an // object back to its index in the REAL config. var indexMap map[int]int if len(parts) > 0 { indexMap = make(map[int]int) } // Build the set from all the items using the given hash code for i, v := range list { code := s.add(v) if indexMap != nil { indexMap[code] = i } } // If we're trying to get a specific element, then rewrite the // index to be just that, then jump direct to getList. if len(parts) > 0 { index := parts[0] indexInt, err := strconv.ParseInt(index, 0, 0) if err != nil { return getResultEmpty } codes := s.listCode() if int(indexInt) >= len(codes) { return getResultEmpty } code := codes[indexInt] realIndex := indexMap[code] parts[0] = strconv.FormatInt(int64(realIndex), 10) return d.getList(k, parts, schema, source) } result.Exists = true return result } func (d *ResourceData) getMap( k string, parts []string, schema *Schema, source getSource) getResult { elemSchema := &Schema{Type: TypeString} result := make(map[string]interface{}) resultSet := false prefix := k + "." exact := source&getSourceExact != 0 source &^= getSourceExact if !exact || source == getSourceState { if d.state != nil && source >= getSourceState { for k, _ := range d.state.Attributes { if !strings.HasPrefix(k, prefix) { continue } single := k[len(prefix):] result[single] = d.getPrimitive(k, nil, elemSchema, source).Value resultSet = true } } } if d.config != nil && source == getSourceConfig { // For config, we always set the result to exactly what was requested if mraw, ok := d.config.Get(k); ok { result = make(map[string]interface{}) switch m := mraw.(type) { case []interface{}: for _, innerRaw := range m { for k, v := range innerRaw.(map[string]interface{}) { result[k] = v } } resultSet = true case []map[string]interface{}: for _, innerRaw := range m { for k, v := range innerRaw { result[k] = v } } resultSet = true case map[string]interface{}: result = m resultSet = true default: panic(fmt.Sprintf("unknown type: %#v", mraw)) } } else { result = nil } } if !exact || source == getSourceDiff { if d.diff != nil && source >= getSourceDiff { for k, v := range d.diff.Attributes { if !strings.HasPrefix(k, prefix) { continue } resultSet = true single := k[len(prefix):] if v.NewRemoved { delete(result, single) } else { result[single] = d.getPrimitive(k, nil, elemSchema, source).Value } } } } if !exact || source == getSourceSet { if d.setMap != nil && source >= getSourceSet { cleared := false for k, _ := range d.setMap { if !strings.HasPrefix(k, prefix) { continue } resultSet = true if !cleared { // We clear the results if they are in the set map result = make(map[string]interface{}) cleared = true } single := k[len(prefix):] result[single] = d.getPrimitive(k, nil, elemSchema, source).Value } } } // If we're requesting a specific element, return that var resultValue interface{} = result if len(parts) > 0 { resultValue = result[parts[0]] } return getResult{ Value: resultValue, Exists: resultSet, Schema: schema, } } func (d *ResourceData) getObject( k string, parts []string, schema map[string]*Schema, source getSource) getResult { if len(parts) > 0 { // We're requesting a specific key in an object key := parts[0] parts = parts[1:] s, ok := schema[key] if !ok { return getResultEmpty } if k != "" { // If we're not at the root, then we need to append // the key to get the full key path. key = fmt.Sprintf("%s.%s", k, key) } return d.get(key, parts, s, source) } // Get the entire object result := make(map[string]interface{}) for field, _ := range schema { result[field] = d.getObject(k, []string{field}, schema, source).Value } return getResult{ Value: result, Exists: true, Schema: &Schema{ Elem: schema, }, } } func (d *ResourceData) getList( k string, parts []string, schema *Schema, source getSource) getResult { if len(parts) > 0 { // We still have parts left over meaning we're accessing an // element of this list. idx := parts[0] parts = parts[1:] // Special case if we're accessing the count of the list if idx == "#" { schema := &Schema{Type: TypeInt} return d.get(k+".#", parts, schema, source) } key := fmt.Sprintf("%s.%s", k, idx) switch t := schema.Elem.(type) { case *Resource: return d.getObject(key, parts, t.Schema, source) case *Schema: return d.get(key, parts, t, source) } } // Get the entire list. var result []interface{} count := d.getList(k, []string{"#"}, schema, source) if !count.Computed { result = make([]interface{}, count.Value.(int)) for i, _ := range result { is := strconv.FormatInt(int64(i), 10) result[i] = d.getList(k, []string{is}, schema, source).Value } } return getResult{ Value: result, Computed: count.Computed, Exists: count.Exists, Schema: schema, } } func (d *ResourceData) getPrimitive( k string, parts []string, schema *Schema, source getSource) getResult { var result string var resultProcessed interface{} var resultComputed, resultSet bool exact := source&getSourceExact != 0 source &^= getSourceExact if !exact || source == getSourceState { if d.state != nil && source >= getSourceState { result, resultSet = d.state.Attributes[k] } } // No exact check is needed here because config is always exact if d.config != nil && source == getSourceConfig { // For config, we always return the exact value if v, ok := d.config.Get(k); ok { if err := mapstructure.WeakDecode(v, &result); err != nil { panic(err) } resultSet = true } else { result = "" resultSet = false } // If it is computed, set that. resultComputed = d.config.IsComputed(k) } if !exact || source == getSourceDiff { if d.diff != nil && source >= getSourceDiff { attrD, ok := d.diff.Attributes[k] if ok { if !attrD.NewComputed { result = attrD.New if attrD.NewExtra != nil { // If NewExtra != nil, then we have processed data as the New, // so we store that but decode the unprocessed data into result resultProcessed = result err := mapstructure.WeakDecode(attrD.NewExtra, &result) if err != nil { panic(err) } } resultSet = true } else { result = "" resultSet = false } } } } if !exact || source == getSourceSet { if d.setMap != nil && source >= getSourceSet { if v, ok := d.setMap[k]; ok { result = v resultSet = true } } } if !resultSet { result = "" } var resultValue interface{} switch schema.Type { case TypeBool: if result == "" { resultValue = false break } v, err := strconv.ParseBool(result) if err != nil { panic(err) } resultValue = v case TypeString: // Use the value as-is. We just put this case here to be explicit. resultValue = result case TypeInt: if result == "" { resultValue = 0 break } if resultComputed { break } v, err := strconv.ParseInt(result, 0, 0) if err != nil { panic(err) } resultValue = int(v) default: panic(fmt.Sprintf("Unknown type: %#v", schema.Type)) } return getResult{ Value: resultValue, ValueProcessed: resultProcessed, Computed: resultComputed, Exists: resultSet, Schema: schema, } } func (d *ResourceData) set( k string, parts []string, schema *Schema, value interface{}) error { switch schema.Type { case TypeList: return d.setList(k, parts, schema, value) case TypeMap: return d.setMapValue(k, parts, schema, value) case TypeSet: return d.setSet(k, parts, schema, value) case TypeBool: fallthrough case TypeInt: fallthrough case TypeString: return d.setPrimitive(k, schema, value) default: panic(fmt.Sprintf("%s: unknown type %#v", k, schema.Type)) } } func (d *ResourceData) setList( k string, parts []string, schema *Schema, value interface{}) error { if len(parts) > 0 { // We're setting a specific element idx := parts[0] parts = parts[1:] // Special case if we're accessing the count of the list if idx == "#" { return fmt.Errorf("%s: can't set count of list", k) } key := fmt.Sprintf("%s.%s", k, idx) switch t := schema.Elem.(type) { case *Resource: return d.setObject(key, parts, t.Schema, value) case *Schema: return d.set(key, parts, t, value) } } var vs []interface{} if err := mapstructure.Decode(value, &vs); err != nil { return fmt.Errorf("%s: %s", k, err) } // Set the entire list. var err error for i, elem := range vs { is := strconv.FormatInt(int64(i), 10) err = d.setList(k, []string{is}, schema, elem) if err != nil { break } } if err != nil { for i, _ := range vs { is := strconv.FormatInt(int64(i), 10) d.setList(k, []string{is}, schema, nil) } return err } d.setMap[k+".#"] = strconv.FormatInt(int64(len(vs)), 10) return nil } func (d *ResourceData) setMapValue( k string, parts []string, schema *Schema, value interface{}) error { elemSchema := &Schema{Type: TypeString} if len(parts) > 0 { return fmt.Errorf("%s: full map must be set, no a single element", k) } // Delete any prior map set /* v := d.getMap(k, nil, schema, getSourceSet) for subKey, _ := range v.(map[string]interface{}) { delete(d.setMap, fmt.Sprintf("%s.%s", k, subKey)) } */ v := reflect.ValueOf(value) if v.Kind() != reflect.Map { return fmt.Errorf("%s: must be a map", k) } if v.Type().Key().Kind() != reflect.String { return fmt.Errorf("%s: keys must strings", k) } vs := make(map[string]interface{}) for _, mk := range v.MapKeys() { mv := v.MapIndex(mk) vs[mk.String()] = mv.Interface() } for subKey, v := range vs { err := d.set(fmt.Sprintf("%s.%s", k, subKey), nil, elemSchema, v) if err != nil { return err } } return nil } func (d *ResourceData) setObject( k string, parts []string, schema map[string]*Schema, value interface{}) error { if len(parts) > 0 { // We're setting a specific key in an object key := parts[0] parts = parts[1:] s, ok := schema[key] if !ok { return fmt.Errorf("%s (internal): unknown key to set: %s", k, key) } if k != "" { // If we're not at the root, then we need to append // the key to get the full key path. key = fmt.Sprintf("%s.%s", k, key) } return d.set(key, parts, s, value) } // Set the entire object. First decode into a proper structure var v map[string]interface{} if err := mapstructure.Decode(value, &v); err != nil { return fmt.Errorf("%s: %s", k, err) } // Set each element in turn var err error for k1, v1 := range v { err = d.setObject(k, []string{k1}, schema, v1) if err != nil { break } } if err != nil { for k1, _ := range v { d.setObject(k, []string{k1}, schema, nil) } } return err } func (d *ResourceData) setPrimitive( k string, schema *Schema, v interface{}) error { if v == nil { delete(d.setMap, k) return nil } var set string switch schema.Type { case TypeBool: var b bool if err := mapstructure.Decode(v, &b); err != nil { return fmt.Errorf("%s: %s", k, err) } set = strconv.FormatBool(b) case TypeString: if err := mapstructure.Decode(v, &set); err != nil { return fmt.Errorf("%s: %s", k, err) } case TypeInt: var n int if err := mapstructure.Decode(v, &n); err != nil { return fmt.Errorf("%s: %s", k, err) } set = strconv.FormatInt(int64(n), 10) default: return fmt.Errorf("Unknown type: %#v", schema.Type) } d.setMap[k] = set return nil } func (d *ResourceData) setSet( k string, parts []string, schema *Schema, value interface{}) error { if len(parts) > 0 { return fmt.Errorf("%s: can only set the full set, not elements", k) } // If it is a slice, then we have to turn it into a *Set so that // we get the proper order back based on the hash code. if v := reflect.ValueOf(value); v.Kind() == reflect.Slice { // Set the entire list, this lets us get sane values out of it if err := d.setList(k, nil, schema, value); err != nil { return err } // Build the set by going over the list items in order and // hashing them into the set. The reason we go over the list and // not the `value` directly is because this forces all types // to become []interface{} (generic) instead of []string, which // most hash functions are expecting. s := &Set{F: schema.Set} source := getSourceSet | getSourceExact for i := 0; i < v.Len(); i++ { is := strconv.FormatInt(int64(i), 10) result := d.getList(k, []string{is}, schema, source) if !result.Exists { panic("just set item doesn't exist") } s.Add(result.Value) } value = s } if s, ok := value.(*Set); ok { value = s.List() } return d.setList(k, nil, schema, value) } func (d *ResourceData) stateList( prefix string, schema *Schema) map[string]string { countRaw := d.get(prefix, []string{"#"}, schema, d.stateSource(prefix)) if !countRaw.Exists { if schema.Computed { // If it is computed, then it always _exists_ in the state, // it is just empty. countRaw.Exists = true countRaw.Value = 0 } else { return nil } } count := countRaw.Value.(int) result := make(map[string]string) if count > 0 || schema.Computed { result[prefix+".#"] = strconv.FormatInt(int64(count), 10) } for i := 0; i < count; i++ { key := fmt.Sprintf("%s.%d", prefix, i) var m map[string]string switch t := schema.Elem.(type) { case *Resource: m = d.stateObject(key, t.Schema) case *Schema: m = d.stateSingle(key, t) } for k, v := range m { result[k] = v } } return result } func (d *ResourceData) stateMap( prefix string, schema *Schema) map[string]string { v := d.getMap(prefix, nil, schema, d.stateSource(prefix)) if !v.Exists { return nil } elemSchema := &Schema{Type: TypeString} result := make(map[string]string) for mk, _ := range v.Value.(map[string]interface{}) { mp := fmt.Sprintf("%s.%s", prefix, mk) for k, v := range d.stateSingle(mp, elemSchema) { result[k] = v } } return result } func (d *ResourceData) stateObject( prefix string, schema map[string]*Schema) map[string]string { result := make(map[string]string) for k, v := range schema { key := k if prefix != "" { key = prefix + "." + key } for k1, v1 := range d.stateSingle(key, v) { result[k1] = v1 } } return result } func (d *ResourceData) statePrimitive( prefix string, schema *Schema) map[string]string { raw := d.getRaw(prefix, d.stateSource(prefix)) if !raw.Exists { return nil } v := raw.Value if raw.ValueProcessed != nil { v = raw.ValueProcessed } var vs string switch schema.Type { case TypeBool: vs = strconv.FormatBool(v.(bool)) case TypeString: vs = v.(string) case TypeInt: vs = strconv.FormatInt(int64(v.(int)), 10) default: panic(fmt.Sprintf("Unknown type: %#v", schema.Type)) } return map[string]string{ prefix: vs, } } func (d *ResourceData) stateSet( prefix string, schema *Schema) map[string]string { raw := d.get(prefix, nil, schema, d.stateSource(prefix)) if !raw.Exists { if schema.Computed { // If it is computed, then it always _exists_ in the state, // it is just empty. raw.Exists = true raw.Value = new(Set) } else { return nil } } set := raw.Value.(*Set) list := set.List() result := make(map[string]string) result[prefix+".#"] = strconv.FormatInt(int64(len(list)), 10) for i := 0; i < len(list); i++ { key := fmt.Sprintf("%s.%d", prefix, i) var m map[string]string switch t := schema.Elem.(type) { case *Resource: m = d.stateObject(key, t.Schema) case *Schema: m = d.stateSingle(key, t) } for k, v := range m { result[k] = v } } return result } func (d *ResourceData) stateSingle( prefix string, schema *Schema) map[string]string { switch schema.Type { case TypeList: return d.stateList(prefix, schema) case TypeMap: return d.stateMap(prefix, schema) case TypeSet: return d.stateSet(prefix, schema) case TypeBool: fallthrough case TypeInt: fallthrough case TypeString: return d.statePrimitive(prefix, schema) default: panic(fmt.Sprintf("%s: unknown type %#v", prefix, schema.Type)) } } func (d *ResourceData) stateSource(prefix string) getSource { // If we're not doing a partial apply, then get the set level if !d.partial { return getSourceSet } // Otherwise, only return getSourceSet if its in the partial map. // Otherwise we use state level only. for k, _ := range d.partialMap { if strings.HasPrefix(prefix, k) { return getSourceSet } } return getSourceState }