Merge pull request #79 from terraform-linters/extend_runner_api_for_accessing_root_provider

tflint: Extend runner API for accessing the root provider configuration

Author: wata727

helper/runner.go

@@ -118,6 +118,12 @@ func (r *Runner) Config() (*configs.Config, error) {
 	return r.config, nil
 }
 
+// RootProvider returns the provider configuration.
+// In the helper runner, it always returns its own provider.
+func (r *Runner) RootProvider(name string) (*configs.Provider, error) {
+	return r.config.Module.ProviderConfigs[name], nil
+}
+
 // EvaluateExpr returns a value of the passed expression.
 // Note that some features are limited
 func (r *Runner) EvaluateExpr(expr hcl.Expression, ret interface{}) error {
@@ -159,6 +165,12 @@ func (r *Runner) EvaluateExpr(expr hcl.Expression, ret interface{}) error {
 	return gocty.FromCtyValue(val, ret)
 }
 
+// EvaluateExprOnRootCtx returns a value of the passed expression.
+// Note this is just alias of EvaluateExpr.
+func (r *Runner) EvaluateExprOnRootCtx(expr hcl.Expression, ret interface{}) error {
+	return r.EvaluateExpr(expr, ret)
+}
+
 // EmitIssueOnExpr adds an issue to the runner itself.
 func (r *Runner) EmitIssueOnExpr(rule tflint.Rule, message string, expr hcl.Expression) error {
 	r.Issues = append(r.Issues, &Issue{

tflint/client/client.go

@@ -170,6 +170,26 @@ func (c *Client) Config() (*configs.Config, error) {
 	return config, nil
 }
 
+// RootProvider calls the server-side RootProvider method and returns the provider configuration.
+func (c *Client) RootProvider(name string) (*configs.Provider, error) {
+	log.Printf("[DEBUG] Accessing to the `%s` provider config in the root module", name)
+
+	var response RootProviderResponse
+	if err := c.rpcClient.Call("Plugin.RootProvider", RootProviderRequest{Name: name}, &response); err != nil {
+		return nil, err
+	}
+	if response.Err != nil {
+		return nil, response.Err
+	}
+
+	provider, diags := decodeProvider(response.Provider)
+	if diags.HasErrors() {
+		return nil, diags
+	}
+
+	return provider, nil
+}
+
 // EvaluateExpr calls the server-side EvalExpr method and reflects the response
 // in the passed argument.
 func (c *Client) EvaluateExpr(expr hcl.Expression, ret interface{}) error {
@@ -207,6 +227,43 @@ func (c *Client) EvaluateExpr(expr hcl.Expression, ret interface{}) error {
 	return nil
 }
 
+// EvaluateExprOnRootCtx calls the server-side EvalExprOnRootCtx method and reflects the response
+// in the passed argument.
+func (c *Client) EvaluateExprOnRootCtx(expr hcl.Expression, ret interface{}) error {
+	var response EvalExprResponse
+	var err error
+
+	src, err := ioutil.ReadFile(expr.Range().Filename)
+	if err != nil {
+		return err
+	}
+	req := EvalExprRequest{Ret: ret}
+	req.Expr, req.ExprRange = encodeExpr(src, expr)
+	if err := c.rpcClient.Call("Plugin.EvalExprOnRootCtx", req, &response); err != nil {
+		return err
+	}
+	if response.Err != nil {
+		return response.Err
+	}
+
+	err = gocty.FromCtyValue(response.Val, ret)
+	if err != nil {
+		err := &tflint.Error{
+			Code:  tflint.TypeMismatchError,
+			Level: tflint.ErrorLevel,
+			Message: fmt.Sprintf(
+				"Invalid type expression in %s:%d",
+				expr.Range().Filename,
+				expr.Range().Start.Line,
+			),
+			Cause: err,
+		}
+		log.Printf("[ERROR] %s", err)
+		return err
+	}
+	return nil
+}
+
 // EmitIssueOnExpr calls the server-side EmitIssue method with the passed expression.
 func (c *Client) EmitIssueOnExpr(rule tflint.Rule, message string, expr hcl.Expression) error {
 	req := &EmitIssueRequest{

tflint/client/decode_provider.go

@@ -23,6 +23,10 @@ type Provider struct {
 }
 
 func decodeProvider(provider *Provider) (*configs.Provider, hcl.Diagnostics) {
+	if provider == nil {
+		return nil, nil
+	}
+
 	versionConstraint, diags := parseVersionConstraint(provider.Version, provider.VersionRange)
 	if diags.HasErrors() {
 		return nil, diags

tflint/client/rpc.go

@@ -67,6 +67,17 @@ type ConfigResponse struct {
 	Err    error
 }
 
+// RootProviderRequest is a request to the server-side RootProvider method.
+type RootProviderRequest struct {
+	Name string
+}
+
+// RootProviderResponse is a response to the server-side RootProvider method.
+type RootProviderResponse struct {
+	Provider *Provider
+	Err      error
+}
+
 // EvalExprRequest is a request to the server-side EvalExpr method.
 type EvalExprRequest struct {
 	Expr      []byte

tflint/interface.go

@@ -53,11 +53,19 @@ type Runner interface {
 	// This object contains almost all accessible data structures from plugins.
 	Config() (*configs.Config, error)
 
+	// RootProvider returns the provider configuration in the root module.
+	// It can be used by child modules to access the credentials defined in the root module.
+	RootProvider(name string) (*configs.Provider, error)
+
 	// EvaluateExpr evaluates the passed expression and reflects the result in ret.
 	// Since this function returns an application error, it is expected to use the EnsureNoError
 	// to determine whether to continue processing.
 	EvaluateExpr(expr hcl.Expression, ret interface{}) error
 
+	// EvaluateExprOnRootCtx is the equivalent of EvaluateExpr method in the context of the root module.
+	// Its main use is to evaluate the provider block obtained by the RootProvider method.
+	EvaluateExprOnRootCtx(expr hcl.Expression, ret interface{}) error
+
 	// EmitIssue sends an issue with an expression to TFLint. You need to pass the message of the issue and the expression.
 	EmitIssueOnExpr(rule Rule, message string, expr hcl.Expression) error