Data-driven Terraform Configuration

builtin/providers/null/data_source.go

@@ -0,0 +1,54 @@
+package null
+
+import (
+	"fmt"
+	"math/rand"
+	"time"
+
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+func init() {
+	rand.Seed(time.Now().Unix())
+}
+
+func dataSource() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceRead,
+
+		Schema: map[string]*schema.Schema{
+			"inputs": &schema.Schema{
+				Type:     schema.TypeMap,
+				Optional: true,
+			},
+			"outputs": &schema.Schema{
+				Type:     schema.TypeMap,
+				Computed: true,
+			},
+			"random": &schema.Schema{
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"has_computed_default": &schema.Schema{
+				Type:     schema.TypeString,
+				Optional: true,
+				Computed: true,
+			},
+		},
+	}
+}
+
+func dataSourceRead(d *schema.ResourceData, meta interface{}) error {
+
+	inputs := d.Get("inputs")
+	d.Set("outputs", inputs)
+
+	d.Set("random", fmt.Sprintf("%d", rand.Int()))
+	if d.Get("has_computed_default") == "" {
+		d.Set("has_computed_default", "default")
+	}
+
+	d.SetId("static")
+
+	return nil
+}

builtin/providers/null/provider.go

@@ -13,5 +13,9 @@ func Provider() terraform.ResourceProvider {
 		ResourcesMap: map[string]*schema.Resource{
 			"null_resource": resource(),
 		},
+
+		DataSourcesMap: map[string]*schema.Resource{
+			"null_data_source": dataSource(),
+		},
 	}
 }

builtin/providers/terraform/resource_state.go → builtin/providers/terraform/data_source_state.go

@@ -8,23 +8,19 @@ import (
 	"github.com/hashicorp/terraform/state/remote"
 )
 
-func resourceRemoteState() *schema.Resource {
+func dataSourceRemoteState() *schema.Resource {
 	return &schema.Resource{
-		Create: resourceRemoteStateCreate,
-		Read:   resourceRemoteStateRead,
-		Delete: resourceRemoteStateDelete,
+		Read: dataSourceRemoteStateRead,
 
 		Schema: map[string]*schema.Schema{
 			"backend": &schema.Schema{
 				Type:     schema.TypeString,
 				Required: true,
-				ForceNew: true,
 			},
 
 			"config": &schema.Schema{
 				Type:     schema.TypeMap,
 				Optional: true,
-				ForceNew: true,
 			},
 
 			"output": &schema.Schema{
@@ -35,11 +31,7 @@ func resourceRemoteState() *schema.Resource {
 	}
 }
 
-func resourceRemoteStateCreate(d *schema.ResourceData, meta interface{}) error {
-	return resourceRemoteStateRead(d, meta)
-}
-
-func resourceRemoteStateRead(d *schema.ResourceData, meta interface{}) error {
+func dataSourceRemoteStateRead(d *schema.ResourceData, meta interface{}) error {
 	backend := d.Get("backend").(string)
 	config := make(map[string]string)
 	for k, v := range d.Get("config").(map[string]interface{}) {
@@ -69,8 +61,3 @@ func resourceRemoteStateRead(d *schema.ResourceData, meta interface{}) error {
 	d.Set("output", outputs)
 	return nil
 }
-
-func resourceRemoteStateDelete(d *schema.ResourceData, meta interface{}) error {
-	d.SetId("")
-	return nil
-}

builtin/providers/terraform/provider.go

@@ -9,7 +9,13 @@ import (
 func Provider() terraform.ResourceProvider {
 	return &schema.Provider{
 		ResourcesMap: map[string]*schema.Resource{
-			"terraform_remote_state": resourceRemoteState(),
+			"terraform_remote_state": schema.DataSourceResourceShim(
+				"terraform_remote_state",
+				dataSourceRemoteState(),
+			),
+		},
+		DataSourcesMap: map[string]*schema.Resource{
+			"terraform_remote_state": dataSourceRemoteState(),
 		},
 	}
 }

command/format_plan.go

@@ -87,13 +87,26 @@ func formatPlanModuleExpand(
 		// resource header.
 		color := "yellow"
 		symbol := "~"
+		oldValues := true
 		switch rdiff.ChangeType() {
 		case terraform.DiffDestroyCreate:
 			color = "green"
 			symbol = "-/+"
 		case terraform.DiffCreate:
 			color = "green"
 			symbol = "+"
+			oldValues = false
+
+			// If we're "creating" a data resource then we'll present it
+			// to the user as a "read" operation, so it's clear that this
+			// operation won't change anything outside of the Terraform state.
+			// Unfortunately by the time we get here we only have the name
+			// to work with, so we need to cheat and exploit knowledge of the
+			// naming scheme for data resources.
+			if strings.HasPrefix(name, "data.") {
+				symbol = "<="
+				color = "cyan"
+			}
 		case terraform.DiffDestroy:
 			color = "red"
 			symbol = "-"
@@ -134,13 +147,22 @@ func formatPlanModuleExpand(
 				newResource = opts.Color.Color(" [red](forces new resource)")
 			}
 
-			buf.WriteString(fmt.Sprintf(
-				"    %s:%s %#v => %#v%s\n",
-				attrK,
-				strings.Repeat(" ", keyLen-len(attrK)),
-				attrDiff.Old,
-				v,
-				newResource))
+			if oldValues {
+				buf.WriteString(fmt.Sprintf(
+					"    %s:%s %#v => %#v%s\n",
+					attrK,
+					strings.Repeat(" ", keyLen-len(attrK)),
+					attrDiff.Old,
+					v,
+					newResource))
+			} else {
+				buf.WriteString(fmt.Sprintf(
+					"    %s:%s %#v%s\n",
+					attrK,
+					strings.Repeat(" ", keyLen-len(attrK)),
+					v,
+					newResource))
+			}
 		}
 
 		// Write the reset color so we don't overload the user's terminal

command/hook_ui.go

@@ -245,9 +245,17 @@ func (h *UiHook) PreRefresh(
 	h.once.Do(h.init)
 
 	id := n.HumanId()
+
+	var stateIdSuffix string
+	// Data resources refresh before they have ids, whereas managed
+	// resources are only refreshed when they have ids.
+	if s.ID != "" {
+		stateIdSuffix = fmt.Sprintf(" (ID: %s)", s.ID)
+	}
+
 	h.ui.Output(h.Colorize.Color(fmt.Sprintf(
-		"[reset][bold]%s: Refreshing state... (ID: %s)",
-		id, s.ID)))
+		"[reset][bold]%s: Refreshing state...%s",
+		id, stateIdSuffix)))
 	return terraform.HookActionContinue, nil
 }
 

command/plan.go

@@ -219,7 +219,7 @@ The Terraform execution plan has been generated and is shown below.
 Resources are shown in alphabetical order for quick scanning. Green resources
 will be created (or destroyed and then created if an existing resource
 exists), yellow resources are being changed in-place, and red resources
-will be destroyed.
+will be destroyed. Cyan entries are data sources to be read.
 
 Note: You didn't specify an "-out" parameter to save this plan, so when
 "apply" is called, Terraform can't guarantee this is what will execute.
@@ -230,7 +230,7 @@ The Terraform execution plan has been generated and is shown below.
 Resources are shown in alphabetical order for quick scanning. Green resources
 will be created (or destroyed and then created if an existing resource
 exists), yellow resources are being changed in-place, and red resources
-will be destroyed.
+will be destroyed. Cyan entries are data sources to be read.
 
 Your plan was also saved to the path below. Call the "apply" subcommand
 with this plan file and Terraform will exactly execute this execution

command/taint.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"log"
 	"strings"
+
+	"github.com/hashicorp/terraform/terraform"
 )
 
 // TaintCommand is a cli.Command implementation that manually taints
@@ -43,6 +45,17 @@ func (c *TaintCommand) Run(args []string) int {
 		module = "root." + module
 	}
 
+	rsk, err := terraform.ParseResourceStateKey(name)
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Failed to parse resource name: %s", err))
+		return 1
+	}
+
+	if !rsk.Mode.Taintable() {
+		c.Ui.Error(fmt.Sprintf("Resource '%s' cannot be tainted", name))
+		return 1
+	}
+
 	// Get the state that we'll be modifying
 	state, err := c.State()
 	if err != nil {

config/config.go

@@ -67,9 +67,11 @@ type ProviderConfig struct {
 }
 
 // A resource represents a single Terraform resource in the configuration.
-// A Terraform resource is something that represents some component that
-// can be created and managed, and has some properties associated with it.
+// A Terraform resource is something that supports some or all of the
+// usual "create, read, update, delete" operations, depending on
+// the given Mode.
 type Resource struct {
+	Mode         ResourceMode // which operations the resource supports
 	Name         string
 	Type         string
 	RawCount     *RawConfig
@@ -85,6 +87,7 @@ type Resource struct {
 // interpolation.
 func (r *Resource) Copy() *Resource {
 	n := &Resource{
+		Mode:         r.Mode,
 		Name:         r.Name,
 		Type:         r.Type,
 		RawCount:     r.RawCount.Copy(),
@@ -210,7 +213,14 @@ func (r *Resource) Count() (int, error) {
 
 // A unique identifier for this resource.
 func (r *Resource) Id() string {
-	return fmt.Sprintf("%s.%s", r.Type, r.Name)
+	switch r.Mode {
+	case ManagedResourceMode:
+		return fmt.Sprintf("%s.%s", r.Type, r.Name)
+	case DataResourceMode:
+		return fmt.Sprintf("data.%s.%s", r.Type, r.Name)
+	default:
+		panic(fmt.Errorf("unknown resource mode %s", r.Mode))
+	}
 }
 
 // Validate does some basic semantic checking of the configuration.
@@ -558,7 +568,7 @@ func (c *Config) Validate() error {
 				continue
 			}
 
-			id := fmt.Sprintf("%s.%s", rv.Type, rv.Name)
+			id := rv.ResourceId()
 			if _, ok := resources[id]; !ok {
 				errs = append(errs, fmt.Errorf(
 					"%s: unknown resource '%s' referenced in variable %s",
@@ -804,13 +814,14 @@ func (c *ProviderConfig) mergerMerge(m merger) merger {
 }
 
 func (r *Resource) mergerName() string {
-	return fmt.Sprintf("%s.%s", r.Type, r.Name)
+	return r.Id()
 }
 
 func (r *Resource) mergerMerge(m merger) merger {
 	r2 := m.(*Resource)
 
 	result := *r
+	result.Mode = r2.Mode
 	result.Name = r2.Name
 	result.Type = r2.Type
 	result.RawConfig = result.RawConfig.merge(r2.RawConfig)
@@ -927,3 +938,14 @@ func (v *Variable) inferTypeFromDefault() VariableType {
 
 	return VariableTypeUnknown
 }
+
+func (m ResourceMode) Taintable() bool {
+	switch m {
+	case ManagedResourceMode:
+		return true
+	case DataResourceMode:
+		return false
+	default:
+		panic(fmt.Errorf("unsupported ResourceMode value %s", m))
+	}
+}

config/config_string.go

@@ -178,7 +178,7 @@ func resourcesStr(rs []*Resource) string {
 	ks := make([]string, 0, len(rs))
 	mapping := make(map[string]int)
 	for i, r := range rs {
-		k := fmt.Sprintf("%s[%s]", r.Type, r.Name)
+		k := r.Id()
 		ks = append(ks, k)
 		mapping[k] = i
 	}
@@ -190,9 +190,8 @@ func resourcesStr(rs []*Resource) string {
 	for _, i := range order {
 		r := rs[i]
 		result += fmt.Sprintf(
-			"%s[%s] (x%s)\n",
-			r.Type,
-			r.Name,
+			"%s (x%s)\n",
+			r.Id(),
 			r.RawCount.Value())
 
 		ks := make([]string, 0, len(r.RawConfig.Raw))