config: Add plugin_dir config (#1235)

Author: wata727

cmd/init.go

@@ -17,7 +17,7 @@ func (cli *CLI) init(opts Options) int {
 	}
 
 	for _, pluginCfg := range cfg.Plugins {
-		installCfg := tfplugin.NewInstallConfig(pluginCfg)
+		installCfg := tfplugin.NewInstallConfig(cfg, pluginCfg)
 
 		// If version or source is not set, you need to install it manually
 		if installCfg.ManuallyInstalled() {

docs/user-guide/config.md

@@ -9,6 +9,8 @@ The config file is written in [HCL](https://github.com/hashicorp/hcl). An exampl
 
 ```hcl
 config {
+  plugin_dir = "~/.tflint.d/plugins"
+
   module = true
   force = false
   disabled_by_default = false
@@ -39,6 +41,10 @@ You can also use another file as a config file with the `--config` option:
 $ tflint --config other_config.hcl
 ```
 
+### `plugin_dir`
+
+Set the plugin directory. The default is `~/.tflint.d/plugins` (or `./.tflint.d/plugins`). See also [Configuring Plugins](plugins.md#advanced-usage)
+
 ### `module`
 
 CLI flag: `--module`

docs/user-guide/plugins.md

@@ -54,6 +54,14 @@ Plugin developer's PGP public signing key. When this attribute is set, TFLint wi
 
 Plugins under the terraform-linters organization (AWS/GCP/Azure ruleset plugins) can use the built-in signing key, so this attribute can be omitted.
 
+## Plugin directory
+
+Plugins are usually installed under `~/.tflint.d/plugins`. Exceptionally, if you already have `./.tflint.d/plugins` in your working directory, it will be installed there.
+
+The automatically installed plugins are placed as `[plugin dir]/[source]/[version]/tflint-ruleset-[name]`. (`tflint-ruleset-[name].exe` in Windows).
+
+If you want to change the plugin directory, you can change this with the [`plugin_dir`](config.md#plugin_dir) or `TFLINT_PLUGIN_DIR` environment variable.
+
 ## Avoiding rate limiting
 
 When you install plugins with `tflint --init`, call the GitHub API to get release metadata. This is typically an unauthenticated request with a rate limit of 60 requests per hour.
@@ -64,7 +72,7 @@ This limitation can be a problem if you need to run `--init` frequently, such as
 
 It's also a good idea to cache the plugin directory, as TFLint will only send requests if plugins aren't installed. See also the [setup-tflint's example](https://github.com/terraform-linters/setup-tflint#usage).
 
-## Advanced Usage
+## Manual installation
 
 You can also install the plugin manually. This is mainly useful for plugin development and for plugins that are not published on GitHub. In that case, omit the `source` and `version` attributes.
 
@@ -74,6 +82,4 @@ plugin "foo" {
 }
 ```
 
-When the plugin is enabled, TFLint invokes the `tflint-ruleset-<NAME>` (`tflint-ruleset-<NAME>.exe` on Windows) binary in the `~/.tflint.d/plugins` (or `./.tflint.d/plugins`) directory. So you should move the binary into the directory in advance.
-
-You can also change the plugin directory with the `TFLINT_PLUGIN_DIR` environment variable.
+When the plugin is enabled, TFLint invokes the `tflint-ruleset-[name]` (`tflint-ruleset-[name].exe` on Windows) binary in the plugin directory (For instance, `~/.tflint.d/plugins/tflint-ruleset-[name]`). So you should move the binary into the directory in advance.

plugin/discovery.go

@@ -24,12 +24,12 @@ func Discovery(config *tflint.Config) (*Plugin, error) {
 	clients := map[string]*plugin.Client{}
 	rulesets := map[string]*tfplugin.Client{}
 
-	for _, cfg := range config.Plugins {
-		installCfg := NewInstallConfig(cfg)
+	for _, pluginCfg := range config.Plugins {
+		installCfg := NewInstallConfig(config, pluginCfg)
 		pluginPath, err := FindPluginPath(installCfg)
 		var cmd *exec.Cmd
 		if os.IsNotExist(err) {
-			if cfg.Name == "aws" && installCfg.ManuallyInstalled() {
+			if pluginCfg.Name == "aws" && installCfg.ManuallyInstalled() {
 				log.Print("[INFO] Plugin `aws` is not installed, but bundled plugins are available.")
 				self, err := os.Executable()
 				if err != nil {
@@ -38,38 +38,38 @@ func Discovery(config *tflint.Config) (*Plugin, error) {
 				cmd = exec.Command(self, "--act-as-aws-plugin")
 			} else {
 				if installCfg.ManuallyInstalled() {
-					pluginDir, err := getPluginDir()
+					pluginDir, err := getPluginDir(config)
 					if err != nil {
 						return nil, err
 					}
-					return nil, fmt.Errorf("Plugin `%s` not found in %s", cfg.Name, pluginDir)
+					return nil, fmt.Errorf("Plugin `%s` not found in %s", pluginCfg.Name, pluginDir)
 				}
-				return nil, fmt.Errorf("Plugin `%s` not found. Did you run `tflint --init`?", cfg.Name)
+				return nil, fmt.Errorf("Plugin `%s` not found. Did you run `tflint --init`?", pluginCfg.Name)
 			}
 		} else {
 			cmd = exec.Command(pluginPath)
 		}
 
-		if cfg.Enabled {
-			log.Printf("[INFO] Plugin `%s` found", cfg.Name)
+		if pluginCfg.Enabled {
+			log.Printf("[INFO] Plugin `%s` found", pluginCfg.Name)
 
 			client := tfplugin.NewClient(&tfplugin.ClientOpts{
 				Cmd: cmd,
 			})
 			rpcClient, err := client.Client()
 			if err != nil {
-				return nil, pluginClientError(err, cfg)
+				return nil, pluginClientError(err, pluginCfg)
 			}
 			raw, err := rpcClient.Dispense("ruleset")
 			if err != nil {
 				return nil, err
 			}
 			ruleset := raw.(*tfplugin.Client)
 
-			clients[cfg.Name] = client
-			rulesets[cfg.Name] = ruleset
+			clients[pluginCfg.Name] = client
+			rulesets[pluginCfg.Name] = ruleset
 		} else {
-			log.Printf("[INFO] Plugin `%s` found, but the plugin is disabled", cfg.Name)
+			log.Printf("[INFO] Plugin `%s` found, but the plugin is disabled", pluginCfg.Name)
 		}
 	}
 
@@ -78,7 +78,7 @@ func Discovery(config *tflint.Config) (*Plugin, error) {
 
 // FindPluginPath returns the plugin binary path.
 func FindPluginPath(config *InstallConfig) (string, error) {
-	dir, err := getPluginDir()
+	dir, err := getPluginDir(config.globalConfig)
 	if err != nil {
 		return "", err
 	}
@@ -94,13 +94,18 @@ func FindPluginPath(config *InstallConfig) (string, error) {
 // getPluginDir returns the base plugin directory.
 // Adopted with the following priorities:
 //
-//   1. `TFLINT_PLUGIN_DIR` environment variable
-//   2. Current directory (./.tflint.d/plugins)
-//   3. Home directory (~/.tflint.d/plugins)
+//   1. `plugin_dir` in a global config
+//   2. `TFLINT_PLUGIN_DIR` environment variable
+//   3. Current directory (./.tflint.d/plugins)
+//   4. Home directory (~/.tflint.d/plugins)
 //
 // If the environment variable is set, other directories will not be considered,
 // but if the current directory does not exist, it will fallback to the home directory.
-func getPluginDir() (string, error) {
+func getPluginDir(cfg *tflint.Config) (string, error) {
+	if cfg.PluginDir != "" {
+		return homedir.Expand(cfg.PluginDir)
+	}
+
 	if dir := os.Getenv("TFLINT_PLUGIN_DIR"); dir != "" {
 		return dir, nil
 	}

plugin/discovery_test.go

@@ -119,6 +119,38 @@ func Test_Discovery_envVar(t *testing.T) {
 	}
 }
 
+func Test_Discovery_pluginDirConfig(t *testing.T) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	plugin, err := Discovery(&tflint.Config{
+		PluginDir: filepath.Join(cwd, "test-fixtures", "locals", ".tflint.d", "plugins"),
+		Plugins: map[string]*tflint.PluginConfig{
+			"foo": {
+				Name:    "foo",
+				Enabled: true,
+			},
+			"bar": {
+				Name:    "bar",
+				Enabled: false,
+				Source:  "github.com/terraform-linters/tflint-ruleset-bar",
+				Version: "0.1.0",
+			},
+		},
+	})
+	defer plugin.Clean()
+
+	if err != nil {
+		t.Fatalf("Unexpected error occurred %s", err)
+	}
+
+	if len(plugin.RuleSets) != 1 {
+		t.Fatalf("Only one plugin must be enabled, but %d plugins are enabled", len(plugin.RuleSets))
+	}
+}
+
 func Test_Discovery_notFound(t *testing.T) {
 	cwd, err := os.Getwd()
 	if err != nil {
@@ -252,12 +284,12 @@ func Test_FindPluginPath(t *testing.T) {
 	}{
 		{
 			Name:     "manually installed",
-			Input:    NewInstallConfig(&tflint.PluginConfig{Name: "foo", Enabled: true}),
+			Input:    NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{Name: "foo", Enabled: true}),
 			Expected: filepath.Join(PluginRoot, "tflint-ruleset-foo"+fileExt()),
 		},
 		{
 			Name: "auto installed",
-			Input: NewInstallConfig(&tflint.PluginConfig{
+			Input: NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{
 				Name:    "bar",
 				Enabled: true,
 				Source:  "github.com/terraform-linters/tflint-ruleset-bar",
@@ -302,12 +334,12 @@ func Test_FindPluginPath_locals(t *testing.T) {
 	}{
 		{
 			Name:     "manually installed",
-			Input:    NewInstallConfig(&tflint.PluginConfig{Name: "foo", Enabled: true}),
+			Input:    NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{Name: "foo", Enabled: true}),
 			Expected: filepath.Join(localPluginRoot, "tflint-ruleset-foo"+fileExt()),
 		},
 		{
 			Name: "auto installed",
-			Input: NewInstallConfig(&tflint.PluginConfig{
+			Input: NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{
 				Name:    "bar",
 				Enabled: true,
 				Source:  "github.com/terraform-linters/tflint-ruleset-bar",
@@ -345,12 +377,12 @@ func Test_FindPluginPath_envVar(t *testing.T) {
 	}{
 		{
 			Name:     "manually installed",
-			Input:    NewInstallConfig(&tflint.PluginConfig{Name: "foo", Enabled: true}),
+			Input:    NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{Name: "foo", Enabled: true}),
 			Expected: filepath.Join(dir, "tflint-ruleset-foo"+fileExt()),
 		},
 		{
 			Name: "auto installed",
-			Input: NewInstallConfig(&tflint.PluginConfig{
+			Input: NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{
 				Name:    "bar",
 				Enabled: true,
 				Source:  "github.com/terraform-linters/tflint-ruleset-bar",
@@ -371,6 +403,48 @@ func Test_FindPluginPath_envVar(t *testing.T) {
 	}
 }
 
+func Test_FindPluginPath_pluginDirConfig(t *testing.T) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	globalConfig := tflint.EmptyConfig()
+	globalConfig.PluginDir = filepath.Join(cwd, "test-fixtures", "locals", ".tflint.d", "plugins")
+
+	cases := []struct {
+		Name     string
+		Input    *InstallConfig
+		Expected string
+	}{
+		{
+			Name:     "manually installed",
+			Input:    NewInstallConfig(globalConfig, &tflint.PluginConfig{Name: "foo", Enabled: true}),
+			Expected: filepath.Join(globalConfig.PluginDir, "tflint-ruleset-foo"+fileExt()),
+		},
+		{
+			Name: "auto installed",
+			Input: NewInstallConfig(globalConfig, &tflint.PluginConfig{
+				Name:    "bar",
+				Enabled: true,
+				Source:  "github.com/terraform-linters/tflint-ruleset-bar",
+				Version: "0.1.0",
+			}),
+			Expected: filepath.Join(globalConfig.PluginDir, "github.com/terraform-linters/tflint-ruleset-bar", "0.1.0", "tflint-ruleset-bar"+fileExt()),
+		},
+	}
+
+	for _, tc := range cases {
+		got, err := FindPluginPath(tc.Input)
+		if err != nil {
+			t.Fatalf("Unexpected error occurred %s", err)
+		}
+		if got != tc.Expected {
+			t.Fatalf("Failed `%s`: want=%s got=%s", tc.Name, tc.Expected, got)
+		}
+	}
+}
+
 func Test_FindPluginPath_withoutExtensionInWindows(t *testing.T) {
 	cwd, err := os.Getwd()
 	if err != nil {
@@ -381,7 +455,7 @@ func Test_FindPluginPath_withoutExtensionInWindows(t *testing.T) {
 	PluginRoot = filepath.Join(cwd, "test-fixtures", "plugins")
 	defer func() { PluginRoot = original }()
 
-	config := NewInstallConfig(&tflint.PluginConfig{Name: "baz", Enabled: true})
+	config := NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{Name: "baz", Enabled: true})
 	expected := filepath.Join(PluginRoot, "tflint-ruleset-baz")
 
 	got, err := FindPluginPath(config)

plugin/install.go

@@ -20,13 +20,16 @@ import (
 // InstallConfig is a config for plugin installation.
 // This is a wrapper for PluginConfig and manages naming conventions
 // and directory names for installation.
+// Note that need a global config to manage installation directory.
 type InstallConfig struct {
+	globalConfig *tflint.Config
+
 	*tflint.PluginConfig
 }
 
 // NewInstallConfig returns a new InstallConfig from passed PluginConfig.
-func NewInstallConfig(config *tflint.PluginConfig) *InstallConfig {
-	return &InstallConfig{PluginConfig: config}
+func NewInstallConfig(config *tflint.Config, pluginCfg *tflint.PluginConfig) *InstallConfig {
+	return &InstallConfig{globalConfig: config, PluginConfig: pluginCfg}
 }
 
 // ManuallyInstalled returns whether the plugin should be installed manually.
@@ -71,7 +74,7 @@ func (c *InstallConfig) AssetName() string {
 //   - The signature file must be binary OpenPGP format
 //
 func (c *InstallConfig) Install() (string, error) {
-	dir, err := getPluginDir()
+	dir, err := getPluginDir(c.globalConfig)
 	if err != nil {
 		return "", fmt.Errorf("Failed to get plugin dir: %w", err)
 	}

plugin/install_test.go

@@ -12,7 +12,7 @@ func Test_Install(t *testing.T) {
 	PluginRoot = t.TempDir()
 	defer func() { PluginRoot = original }()
 
-	config := NewInstallConfig(&tflint.PluginConfig{
+	config := NewInstallConfig(tflint.EmptyConfig(), &tflint.PluginConfig{
 		Name:        "aws",
 		Enabled:     true,
 		Version:     "0.4.0",