[QTI-284] Allow complex provider configuration (#66)

* [QTI-284] Allow complex provider configuration

This change modifies how we decode and store provider information passed
into from the scenario. Before we would only allow attributes, now we
allow any number of attributes and blocks.

* Create a schemaless block type to handle decoding blocks that have
  unknown schema.
* Update provider decoder to use a schemaless block for its
  configuration.
* Add kubernetes transport support to enos-provider decoder
* Add acceptance test for generation
* Update the generator to support schemaless blocks in the provider

Signed-off-by: Ryan Cragun <[email protected]>

Author: ryancragun

acceptance/scenario_generate_test.go

@@ -66,6 +66,12 @@ func TestAcc_Cmd_Scenario_Generate(t *testing.T) {
 			[][]string{{"skip", "keep"}},
 			fmt.Sprintf("%x", sha256.Sum256([]byte("path [skip:keep]"))),
 		},
+		{
+			"scenario_generate_complex_provider",
+			"kubernetes",
+			[][]string{},
+			fmt.Sprintf("%x", sha256.Sum256([]byte("kubernetes"))),
+		},
 	} {
 		t.Run(fmt.Sprintf("%s %s %s", test.dir, test.name, test.variants), func(t *testing.T) {
 			outDir := filepath.Join(tmpDir, test.dir)

acceptance/scenarios/scenario_generate_complex_provider/enos.hcl

@@ -0,0 +1,33 @@
+terraform "default" {
+  required_version = ">= 1.0.0"
+
+  required_providers {
+    kubernetes = {
+      source  = "hashicorp/kubernetes"
+    }
+  }
+}
+
+module "kubernetes" {
+  source = "./modules/kubernetes"
+}
+
+provider "kubernetes" "default" {
+  host                   = "http://example.com"
+  cluster_ca_certificate = "base64cert"
+  exec {
+    api_version = "client.authentication.k8s.io/v1alpha1"
+    args        = ["eks", "get-token", "--cluster-name", "foo"]
+    command     = "aws"
+  }
+}
+
+scenario "kubernetes" {
+  providers = [
+    provider.kubernetes.default
+  ]
+
+  step "kubernetes" {
+    module = module.kubernetes
+  }
+}

acceptance/scenarios/scenario_generate_complex_provider/enos.vars.hcl

@@ -0,0 +1,3 @@
+output "random" {
+  value = "notactuallyrandom"
+}

acceptance/scenarios/scenario_generate_complex_provider/modules/kubernetes/main.tf

@@ -328,7 +328,7 @@ func (fp *FlightPlan) decodeTerraformCLIs(ctx *hcl.EvalContext) hcl.Diagnostics
 // top-level schema.
 func (fp *FlightPlan) decodeProviders(ctx *hcl.EvalContext) hcl.Diagnostics {
 	var diags hcl.Diagnostics
-	// type -> map of aliases -> provider object
+	// provider type -> alias name -> provider object value
 	providers := map[string]map[string]cty.Value{}
 
 	for _, block := range fp.BodyContent.Blocks.OfType(blockTypeProvider) {

internal/flightplan/flightplan.go

@@ -13,15 +13,15 @@ import (
 
 // Provider is a Enos transport configuration
 type Provider struct {
-	Type  string               `cty:"type"`
-	Alias string               `cty:"alias"`
-	Attrs map[string]cty.Value `cty:"attrs"`
+	Type   string           `cty:"type"`
+	Alias  string           `cty:"alias"`
+	Config *SchemalessBlock `cty:"config"`
 }
 
 // NewProvider returns a new Provider
 func NewProvider() *Provider {
 	return &Provider{
-		Attrs: map[string]cty.Value{},
+		Config: NewSchemalessBlock(),
 	}
 }
 
@@ -36,51 +36,38 @@ func (p *Provider) decode(block *hcl.Block, ctx *hcl.EvalContext) hcl.Diagnostic
 
 	if p.Type == "enos" {
 		// Since we know the schema for the "enos" provider we can more fine
-		// grained decoding.
+		// grained decoding and validation.
 		moreDiags := p.decodeEnosProvider(block, ctx)
 		diags = diags.Extend(moreDiags)
 		if moreDiags.HasErrors() {
 			return diags
 		}
 	} else {
-		attrs, moreDiags := block.Body.JustAttributes()
+		// Decode the entire provider block as a schemaless block
+		moreDiags := p.Config.Decode(block, ctx)
 		diags = diags.Extend(moreDiags)
 		if moreDiags.HasErrors() {
 			return diags
 		}
-
-		for name, attr := range attrs {
-			val, moreDiags := attr.Expr.Value(ctx)
-			diags = diags.Extend(moreDiags)
-			if moreDiags.HasErrors() {
-				continue
-			}
-			p.Attrs[name] = val
-		}
 	}
 
 	return diags
 }
 
 // ToCtyValue returns the provider contents as an object cty.Value.
 func (p *Provider) ToCtyValue() cty.Value {
-	vals := map[string]cty.Value{
-		"type":  cty.StringVal(p.Type),
-		"alias": cty.StringVal(p.Alias),
-	}
-
-	if len(p.Attrs) > 0 {
-		vals["attrs"] = cty.ObjectVal(p.Attrs)
-	} else {
-		vals["attrs"] = cty.NullVal(cty.EmptyObject)
-	}
-
-	return cty.ObjectVal(vals)
+	return cty.ObjectVal(map[string]cty.Value{
+		"type":   cty.StringVal(p.Type),
+		"alias":  cty.StringVal(p.Alias),
+		"config": p.Config.ToCtyValue(),
+	})
 }
 
 // FromCtyValue takes a cty.Value and unmarshals it onto itself. It expects
 // a valid object created from ToCtyValue()
 func (p *Provider) FromCtyValue(val cty.Value) error {
+	var err error
+
 	if val.IsNull() {
 		return nil
 	}
@@ -105,13 +92,10 @@ func (p *Provider) FromCtyValue(val cty.Value) error {
 				return fmt.Errorf("provider alias must be a string ")
 			}
 			p.Alias = val.AsString()
-		case "attrs":
-			if !val.CanIterateElements() {
-				return fmt.Errorf("provider attrs must a map of attributes")
-			}
-
-			for k, v := range val.AsValueMap() {
-				p.Attrs[k] = v
+		case "config":
+			err = p.Config.FromCtyValue(val)
+			if err != nil {
+				return err
 			}
 		default:
 			return fmt.Errorf("unknown key in value object: %s", key)
@@ -141,7 +125,17 @@ func (p *Provider) decodeEnosProvider(block *hcl.Block, ctx *hcl.EvalContext) hc
 					"user", "host", "private_key", "private_key_path",
 					"passphrase", "passphrase_path",
 				}),
-			}, []string{"ssh"}),
+				"kubernetes": cty.ObjectWithOptionalAttrs(map[string]cty.Type{
+					"kubeconfig_base64": cty.String,
+					"context_name":      cty.String,
+					"namespace":         cty.String,
+					"pod":               cty.String,
+					"container":         cty.String,
+				}, []string{
+					"kubeconfig_base64", "context_name", "namespace", "pod",
+					"container",
+				}),
+			}, []string{"ssh", "kubernetes"}),
 		},
 	}
 
@@ -164,15 +158,23 @@ func (p *Provider) decodeEnosProvider(block *hcl.Block, ctx *hcl.EvalContext) hc
 		return diags
 	}
 
+	// We should have either a valid k8s or ssh transport.
+	p.Config.Type = "provider"
+	p.Config.Labels = []string{p.Type, p.Alias}
+	p.Config.Attrs["transport"] = trans
+
 	ssh, ok := trans.AsValueMap()["ssh"]
 	if !ok {
+		// We're done, we're not going to do anything else with k8s
 		return diags
 	}
 
 	if ssh.IsNull() || !ssh.IsWhollyKnown() || !ssh.CanIterateElements() {
 		return diags
 	}
 
+	// We have an ssh transport. Make sure any of the paths that we've been
+	// given exist.
 	sshVals := map[string]cty.Value{}
 	for name, val := range ssh.AsValueMap() {
 		// Only pass through known values
@@ -224,7 +226,7 @@ func (p *Provider) decodeEnosProvider(block *hcl.Block, ctx *hcl.EvalContext) hc
 		}
 	}
 
-	p.Attrs["transport"] = cty.ObjectVal(map[string]cty.Value{
+	p.Config.Attrs["transport"] = cty.ObjectVal(map[string]cty.Value{
 		"ssh": cty.ObjectVal(sshVals),
 	})