CHANGELOG.md

@@ -1,3 +1,20 @@
+## 1.0.1 (June 24, 2021)
+
+ENHANCEMENTS:
+
+* json-output: The JSON plan output now indicates which state values are sensitive. ([#28889](https://github.com/hashicorp/terraform/issues/28889))
+* cli: The darwin builds can now make use of the host DNS resolver, which will fix many network related issues on MacOS.
+
+BUG FIXES:
+
+* backend/remote: Fix faulty Terraform Cloud version check when migrating state to the remote backend with multiple local workspaces ([#28864](https://github.com/hashicorp/terraform/issues/28864))
+* cli: Fix crash with deposed instances in json plan output ([#28922](https://github.com/hashicorp/terraform/issues/28922))
+* core: Fix crash when provider modifies and unknown block during plan ([#28941](https://github.com/hashicorp/terraform/issues/28941))
+* core: Diagnostic context was missing for some errors when validating blocks ([#28979](https://github.com/hashicorp/terraform/issues/28979))
+* core: Fix crash when calling `setproduct` with unknown values ([#28984](https://github.com/hashicorp/terraform/issues/28984))
+* json-output: Fix an issue where the JSON configuration representation was missing fully-unwrapped references. ([#8884](https://github.com/hashicorp/terraform/issues/8884))
+* json-output: Fix JSON plan resource drift to remove unchanged resources. ([#28975](https://github.com/hashicorp/terraform/issues/28975))
+
 ## 1.0.0 (June 08, 2021)
 
 Terraform v1.0 is an unusual release in that its primary focus is on stability, and it represents the culmination of several years of work in previous major releases to make sure that the Terraform language and internal architecture will be a suitable foundation for forthcoming additions that will remain backward compatible.

go.mod

@@ -114,7 +114,7 @@ require (
 	github.com/xanzy/ssh-agent v0.2.1
 	github.com/xiang90/probing v0.0.0-20160813154853-07dd2e8dfe18 // indirect
 	github.com/xlab/treeprint v0.0.0-20161029104018-1d6e34225557
-	github.com/zclconf/go-cty v1.8.3
+	github.com/zclconf/go-cty v1.8.4
 	github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b
 	github.com/zclconf/go-cty-yaml v1.0.2
 	go.uber.org/atomic v1.3.2 // indirect

go.sum

@@ -612,8 +612,8 @@ github.com/zclconf/go-cty v1.0.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLE
 github.com/zclconf/go-cty v1.1.0/go.mod h1:xnAOWiHeOqg2nWS62VtQ7pbOu17FtxJNW8RLEih+O3s=
 github.com/zclconf/go-cty v1.2.0/go.mod h1:hOPWgoHbaTUnI5k4D2ld+GRpFJSCe6bCM7m1q/N4PQ8=
 github.com/zclconf/go-cty v1.8.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
-github.com/zclconf/go-cty v1.8.3 h1:48gwZXrdSADU2UW9eZKHprxAI7APZGW9XmExpJpSjT0=
-github.com/zclconf/go-cty v1.8.3/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
+github.com/zclconf/go-cty v1.8.4 h1:pwhhz5P+Fjxse7S7UriBrMu6AUJSZM5pKqGem1PjGAs=
+github.com/zclconf/go-cty v1.8.4/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
 github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b h1:FosyBZYxY34Wul7O/MSKey3txpPYyCqVO5ZyceuQJEI=
 github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b/go.mod h1:ZRKQfBXbGkpdV6QMzT3rU1kSTAnfu1dO8dPKjYprgj8=
 github.com/zclconf/go-cty-yaml v1.0.2 h1:dNyg4QLTrv2IfJpm7Wtxi55ed5gLGOlPrZ6kMd51hY0=

internal/backend/remote/backend.go

@@ -721,6 +721,10 @@ func (b *Remote) Operation(ctx context.Context, op *backend.Operation) (*backend
 		f = b.opPlan
 	case backend.OperationTypeApply:
 		f = b.opApply
+	case backend.OperationTypeRefresh:
+		return nil, fmt.Errorf(
+			"\n\nThe \"refresh\" operation is not supported when using the \"remote\" backend. " +
+				"Use \"terraform apply -refresh-only\" instead.")
 	default:
 		return nil, fmt.Errorf(
 			"\n\nThe \"remote\" backend does not support the %q operation.", op.Type)

internal/backend/remote/backend_plan.go

@@ -273,14 +273,8 @@ in order to capture the filesystem context the remote workspace expects:
 			"Failed to upload configuration files", errors.New("operation timed out"))
 	}
 
-	queueMessage := "Queued manually using Terraform"
-	if op.Targets != nil {
-		queueMessage = "Queued manually via Terraform using -target"
-	}
-
 	runOptions := tfe.RunCreateOptions{
 		ConfigurationVersion: cv,
-		Message:              tfe.String(queueMessage),
 		Refresh:              tfe.Bool(op.PlanRefresh),
 		Workspace:            w,
 	}

internal/backend/remote/backend_plan_test.go

@@ -482,10 +482,6 @@ func TestRemote_planWithTarget(t *testing.T) {
 		if diff := cmp.Diff([]string{"null_resource.foo"}, run.TargetAddrs); diff != "" {
 			t.Errorf("wrong TargetAddrs in the created run\n%s", diff)
 		}
-
-		if !strings.Contains(run.Message, "using -target") {
-			t.Errorf("incorrect Message on the created run: %s", run.Message)
-		}
 	}
 }
 

internal/command/init.go

@@ -49,6 +49,7 @@ func (c *InitCommand) Run(args []string) int {
 	cmdFlags.BoolVar(&flagUpgrade, "upgrade", false, "")
 	cmdFlags.Var(&flagPluginPath, "plugin-dir", "plugin directory")
 	cmdFlags.StringVar(&flagLockfile, "lockfile", "", "Set a dependency lockfile mode")
+	cmdFlags.BoolVar(&c.Meta.ignoreRemoteVersion, "ignore-remote-version", false, "continue even if remote and local Terraform versions are incompatible")
 	cmdFlags.Usage = func() { c.Ui.Error(c.Help()) }
 	if err := cmdFlags.Parse(args); err != nil {
 		return 1
@@ -962,46 +963,49 @@ Usage: terraform [global options] init [options]
 
 Options:
 
-  -backend=true        Configure the backend for this configuration.
+  -backend=true           Configure the backend for this configuration.
 
-  -backend-config=path This can be either a path to an HCL file with key/value
-                       assignments (same format as terraform.tfvars) or a
-                       'key=value' format. This is merged with what is in the
-                       configuration file. This can be specified multiple
-                       times. The backend type must be in the configuration
-                       itself.
+  -backend-config=path    This can be either a path to an HCL file with key/value
+                          assignments (same format as terraform.tfvars) or a
+                          'key=value' format. This is merged with what is in the
+                          configuration file. This can be specified multiple
+                          times. The backend type must be in the configuration
+                          itself.
 
-  -force-copy          Suppress prompts about copying state data. This is
-                       equivalent to providing a "yes" to all confirmation
-                       prompts.
+  -force-copy             Suppress prompts about copying state data. This is
+                          equivalent to providing a "yes" to all confirmation
+                          prompts.
 
-  -from-module=SOURCE  Copy the contents of the given module into the target
-                       directory before initialization.
+  -from-module=SOURCE     Copy the contents of the given module into the target
+                          directory before initialization.
 
-  -get=true            Download any modules for this configuration.
+  -get=true               Download any modules for this configuration.
 
-  -input=true          Ask for input if necessary. If false, will error if
-                       input was required.
+  -input=true             Ask for input if necessary. If false, will error if
+                          input was required.
 
-  -no-color            If specified, output won't contain any color.
+  -no-color               If specified, output won't contain any color.
 
-  -plugin-dir          Directory containing plugin binaries. This overrides all
-                       default search paths for plugins, and prevents the
-                       automatic installation of plugins. This flag can be used
-                       multiple times.
+  -plugin-dir             Directory containing plugin binaries. This overrides all
+                          default search paths for plugins, and prevents the
+                          automatic installation of plugins. This flag can be used
+                          multiple times.
 
-  -reconfigure         Reconfigure the backend, ignoring any saved
-                       configuration.
+  -reconfigure            Reconfigure the backend, ignoring any saved
+                          configuration.
 
-  -migrate-state       Reconfigure the backend, and attempt to migrate any
-                       existing state.
+  -migrate-state          Reconfigure the backend, and attempt to migrate any
+                          existing state.
 
-  -upgrade=false       If installing modules (-get) or plugins, ignore
-                       previously-downloaded objects and install the
-                       latest version allowed within configured constraints.
+  -upgrade=false          If installing modules (-get) or plugins, ignore
+                          previously-downloaded objects and install the
+                          latest version allowed within configured constraints.
 
-  -lockfile=MODE       Set a dependency lockfile mode.
-                       Currently only "readonly" is valid.
+  -lockfile=MODE          Set a dependency lockfile mode.
+                          Currently only "readonly" is valid.
+
+  -ignore-remote-version  A rare option used for the remote backend only. See
+                          the remote backend documentation for more information.
 
 `
 	return strings.TrimSpace(helpText)

internal/command/jsonconfig/expression.go

@@ -1,10 +1,13 @@
 package jsonconfig
 
 import (
+	"bytes"
 	"encoding/json"
+	"fmt"
 
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hcldec"
+	"github.com/hashicorp/terraform/internal/addrs"
 	"github.com/hashicorp/terraform/internal/configs/configschema"
 	"github.com/hashicorp/terraform/internal/lang"
 	"github.com/zclconf/go-cty/cty"
@@ -30,22 +33,49 @@ type expression struct {
 
 func marshalExpression(ex hcl.Expression) expression {
 	var ret expression
-	if ex != nil {
-		val, _ := ex.Value(nil)
-		if val != cty.NilVal {
-			valJSON, _ := ctyjson.Marshal(val, val.Type())
-			ret.ConstantValue = valJSON
-		}
-		vars, _ := lang.ReferencesInExpr(ex)
+	if ex == nil {
+		return ret
+	}
+
+	val, _ := ex.Value(nil)
+	if val != cty.NilVal {
+		valJSON, _ := ctyjson.Marshal(val, val.Type())
+		ret.ConstantValue = valJSON
+	}
+
+	refs, _ := lang.ReferencesInExpr(ex)
+	if len(refs) > 0 {
 		var varString []string
-		if len(vars) > 0 {
-			for _, v := range vars {
-				varString = append(varString, v.Subject.String())
+		for _, ref := range refs {
+			// We work backwards here, starting with the full reference +
+			// reamining traversal, and then unwrapping the remaining traversals
+			// into parts until we end up at the smallest referencable address.
+			remains := ref.Remaining
+			for len(remains) > 0 {
+				varString = append(varString, fmt.Sprintf("%s%s", ref.Subject, traversalStr(remains)))
+				remains = remains[:(len(remains) - 1)]
+			}
+			varString = append(varString, ref.Subject.String())
+
+			switch ref.Subject.(type) {
+			case addrs.ModuleCallInstance:
+				if ref.Subject.(addrs.ModuleCallInstance).Key != addrs.NoKey {
+					// Include the module call, without the key
+					varString = append(varString, ref.Subject.(addrs.ModuleCallInstance).Call.String())
+				}
+			case addrs.ResourceInstance:
+				if ref.Subject.(addrs.ResourceInstance).Key != addrs.NoKey {
+					// Include the resource, without the key
+					varString = append(varString, ref.Subject.(addrs.ResourceInstance).Resource.String())
+				}
+			case addrs.AbsModuleCallOutput:
+				// Include the module name, without the output name
+				varString = append(varString, ref.Subject.(addrs.AbsModuleCallOutput).Call.String())
 			}
-			ret.References = varString
 		}
-		return ret
+		ret.References = varString
 	}
+
 	return ret
 }
 
@@ -117,3 +147,31 @@ func marshalExpressions(body hcl.Body, schema *configschema.Block) expressions {
 
 	return ret
 }
+
+// traversalStr produces a representation of an HCL traversal that is compact,
+// resembles HCL native syntax, and is suitable for display in the UI.
+//
+// This was copied (and simplified) from internal/command/views/json/diagnostic.go.
+func traversalStr(traversal hcl.Traversal) string {
+	var buf bytes.Buffer
+	for _, step := range traversal {
+		switch tStep := step.(type) {
+		case hcl.TraverseRoot:
+			buf.WriteString(tStep.Name)
+		case hcl.TraverseAttr:
+			buf.WriteByte('.')
+			buf.WriteString(tStep.Name)
+		case hcl.TraverseIndex:
+			buf.WriteByte('[')
+			switch tStep.Key.Type() {
+			case cty.String:
+				buf.WriteString(fmt.Sprintf("%q", tStep.Key.AsString()))
+			case cty.Number:
+				bf := tStep.Key.AsBigFloat()
+				buf.WriteString(bf.Text('g', 10))
+			}
+			buf.WriteByte(']')
+		}
+	}
+	return buf.String()
+}

internal/command/jsonconfig/expression_test.go

@@ -9,14 +9,14 @@ import (
 
 	"github.com/hashicorp/hcl/v2"
 	"github.com/hashicorp/hcl/v2/hclsyntax"
+	"github.com/hashicorp/hcl/v2/hcltest"
 	"github.com/hashicorp/terraform/internal/configs/configschema"
 )
 
 func TestMarshalExpressions(t *testing.T) {
 	tests := []struct {
-		Input  hcl.Body
-		Schema *configschema.Block
-		Want   expressions
+		Input hcl.Body
+		Want  expressions
 	}{
 		{
 			&hclsyntax.Body{
@@ -28,27 +28,73 @@ func TestMarshalExpressions(t *testing.T) {
 					},
 				},
 			},
-			&configschema.Block{
-				Attributes: map[string]*configschema.Attribute{
+			expressions{
+				"foo": expression{
+					ConstantValue: json.RawMessage([]byte(`"bar"`)),
+					References:    []string(nil),
+				},
+			},
+		},
+		{
+			hcltest.MockBody(&hcl.BodyContent{
+				Attributes: hcl.Attributes{
+					"foo": {
+						Name: "foo",
+						Expr: hcltest.MockExprTraversalSrc(`var.list[1]`),
+					},
+				},
+			}),
+			expressions{
+				"foo": expression{
+					References: []string{"var.list[1]", "var.list"},
+				},
+			},
+		},
+		{
+			hcltest.MockBody(&hcl.BodyContent{
+				Attributes: hcl.Attributes{
 					"foo": {
-						Type:     cty.String,
-						Optional: true,
+						Name: "foo",
+						Expr: hcltest.MockExprTraversalSrc(`data.template_file.foo[1].vars["baz"]`),
 					},
 				},
+			}),
+			expressions{
+				"foo": expression{
+					References: []string{"data.template_file.foo[1].vars[\"baz\"]", "data.template_file.foo[1].vars", "data.template_file.foo[1]", "data.template_file.foo"},
+				},
 			},
+		},
+		{
+			hcltest.MockBody(&hcl.BodyContent{
+				Attributes: hcl.Attributes{
+					"foo": {
+						Name: "foo",
+						Expr: hcltest.MockExprTraversalSrc(`module.foo.bar`),
+					},
+				},
+			}),
 			expressions{
 				"foo": expression{
-					ConstantValue: json.RawMessage([]byte(`"bar"`)),
-					References:    []string(nil),
+					References: []string{"module.foo.bar", "module.foo"},
 				},
 			},
 		},
 	}
 
 	for _, test := range tests {
-		got := marshalExpressions(test.Input, test.Schema)
+		schema := &configschema.Block{
+			Attributes: map[string]*configschema.Attribute{
+				"foo": {
+					Type:     cty.String,
+					Optional: true,
+				},
+			},
+		}
+
+		got := marshalExpressions(test.Input, schema)
 		if !reflect.DeepEqual(got, test.Want) {
-			t.Fatalf("wrong result:\nGot: %#v\nWant: %#v\n", got, test.Want)
+			t.Errorf("wrong result:\nGot: %#v\nWant: %#v\n", got, test.Want)
 		}
 	}
 }