Support running nested plugins via standalone when debugging (#1255)

* support running nested plugins via standalone

* remove test

* simplify error message

* add more tests

* update to be more specific where we're generally looking

* update tests

* apply PR feedback

* fix linter issues

Author: wbrowne

internal/standalone/standalone.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"flag"
 	"fmt"
+	"io/fs"
 	"log"
 	"net"
 	"os"
@@ -81,14 +82,24 @@ func RunDummyPluginLocator(address string) {
 }
 
 func serverSettings(pluginID string) (ServerSettings, error) {
-	curProcPath, err := currentProcPath()
+	cwd, err := currentWd()
 	if err != nil {
 		return ServerSettings{}, err
 	}
 
-	dir := filepath.Dir(curProcPath) // Default to current directory
-	if pluginDir, found := findPluginRootDir(curProcPath); found {
-		dir = pluginDir
+	// if we are in the pkg directory, go up one level
+	if filepath.Base(cwd) == "pkg" {
+		cwd = filepath.Dir(cwd)
+	}
+
+	// if dist directory exists, use that as the base directory
+	if finfo, err := os.Stat(filepath.Join(cwd, "dist")); err == nil && finfo.IsDir() {
+		cwd = filepath.Join(cwd, "dist")
+	}
+
+	dir, found := findPluginDir(cwd, pluginID)
+	if !found {
+		return ServerSettings{}, fmt.Errorf("plugin directory not found for plugin ID: %s", pluginID)
 	}
 
 	address, err := createStandaloneAddress(pluginID)
@@ -101,6 +112,10 @@ func serverSettings(pluginID string) (ServerSettings, error) {
 	}, nil
 }
 
+// currentWd returns the current working directory.
+// This is a variable so that it can be mocked in tests.
+var currentWd = os.Getwd
+
 // clientSettings will attempt to find a standalone server's address and PID.
 func clientSettings(pluginID string) (ClientSettings, error) {
 	procPath, err := currentProcPath()
@@ -139,29 +154,39 @@ func currentProcPath() (string, error) {
 	return curProcPath, nil
 }
 
-// findPluginRootDir will attempt to find a plugin directory based on the executing process's file-system path.
-func findPluginRootDir(curProcPath string) (string, bool) {
-	cwd, _ := os.Getwd()
-	if filepath.Base(cwd) == "pkg" {
-		cwd = filepath.Join(cwd, "..")
-	}
+// findPluginDir will attempt to find a plugin directory based on the provided plugin ID.
+// This function will traverse the filesystem from the provided directory until it finds a directory that contains
+// a plugin.json file containing an id matching the provided plugin ID.
+func findPluginDir(dir, pluginID string) (string, bool) {
+	var pluginDir string
+	err := filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
+		if err != nil {
+			return err
+		}
 
-	check := []string{
-		filepath.Join(curProcPath, "plugin.json"),
-		filepath.Join(curProcPath, "dist", "plugin.json"),
-		filepath.Join(filepath.Dir(curProcPath), "plugin.json"),
-		filepath.Join(filepath.Dir(curProcPath), "dist", "plugin.json"),
-		filepath.Join(cwd, "dist", "plugin.json"),
-		filepath.Join(cwd, "plugin.json"),
-	}
+		if d.Name() != "plugin.json" || d.IsDir() {
+			return nil
+		}
+
+		id, err := internal.GetStringValueFromJSON(path, "id")
+		if err != nil {
+			return nil
+		}
 
-	for _, path := range check {
-		if _, err := os.Stat(path); err == nil {
-			return filepath.Dir(path), true
+		if pluginID == id {
+			pluginDir = filepath.Dir(path)
+			return fs.SkipAll
 		}
+
+		return nil
+	})
+
+	if err != nil {
+		log.Printf("findPluginDir error: %s", err.Error())
+		return "", false
 	}
 
-	return "", false
+	return pluginDir, pluginDir != ""
 }
 
 func getStandaloneAddress(pluginID string, dir string) (string, error) {

internal/standalone/standalone_test.go

@@ -1,6 +1,7 @@
 package standalone
 
 import (
+	"errors"
 	"os"
 	"path/filepath"
 	"testing"
@@ -21,51 +22,21 @@ func TestServerModeEnabled(t *testing.T) {
 	})
 
 	t.Run("Enabled by flag", func(t *testing.T) {
+		testDataDir, err := filepath.Abs("testdata")
+		require.NoError(t, err)
+
 		before := standaloneEnabled
 		t.Cleanup(func() {
 			standaloneEnabled = before
 		})
 		truthy := true
 		standaloneEnabled = &truthy
 
-		curProcPath, err := os.Executable()
-		require.NoError(t, err)
-
 		settings, enabled := ServerModeEnabled(pluginID)
 		require.True(t, enabled)
 		require.NotEmpty(t, settings.Address)
-		require.Equal(t, filepath.Dir(curProcPath), settings.Dir)
+		require.Equal(t, filepath.Join(testDataDir, "plugin"), settings.Dir)
 	})
-
-	t.Run("Nearby dist folder will be used as server directory",
-		func(t *testing.T) {
-			curProcPath, err := os.Executable()
-			require.NoError(t, err)
-
-			procDir := filepath.Dir(curProcPath)
-			distDir := filepath.Join(procDir, "dist")
-
-			err = os.MkdirAll(distDir, 0755)
-			require.NoError(t, err)
-			_, err = os.Create(filepath.Join(distDir, "plugin.json"))
-			require.NoError(t, err)
-			t.Cleanup(func() {
-				err = os.RemoveAll(distDir)
-				require.NoError(t, err)
-			})
-
-			before := standaloneEnabled
-			t.Cleanup(func() {
-				standaloneEnabled = before
-			})
-			truthy := true
-			standaloneEnabled = &truthy
-
-			settings, enabled := ServerModeEnabled(pluginID)
-			require.True(t, enabled)
-			require.NotEmpty(t, settings.Address)
-			require.Equal(t, distDir, settings.Dir)
-		})
 }
 
 func TestClientModeEnabled(t *testing.T) {
@@ -166,3 +137,181 @@ func TestClientModeEnabled(t *testing.T) {
 		require.Zero(t, settings.TargetPID)
 	})
 }
+
+func Test_findPluginDir(t *testing.T) {
+	tests := []struct {
+		name     string
+		dir      string
+		pluginID string
+		want     string
+		exists   bool
+	}{
+		{
+			name:     "existing plugin found from root directory",
+			pluginID: pluginID,
+			dir:      "testdata",
+			want:     filepath.Join("testdata", "plugin"),
+			exists:   true,
+		},
+		{
+			name:     "existing plugin found from plugin directory",
+			pluginID: pluginID,
+			dir:      filepath.Join("testdata", "plugin"),
+			want:     filepath.Join("testdata", "plugin"),
+			exists:   true,
+		},
+		{
+			name:     "existing plugin found from nested plugin directory",
+			pluginID: "grafana-nested-datasource",
+			dir:      filepath.Join("testdata", "plugin"),
+			want:     filepath.Join("testdata", "plugin", "datasource"),
+			exists:   true,
+		},
+		{
+			name:     "existing plugin found from dist directory",
+			pluginID: "grafana-foobar-datasource",
+			dir:      filepath.Join("testdata", "dist"),
+			want:     filepath.Join("testdata", "dist"),
+			exists:   true,
+		},
+		{
+			name:     "non matching plugin id",
+			pluginID: pluginID,
+			dir:      filepath.Join("testdata", "GoLand"),
+			want:     "",
+		},
+		{
+			name:     "non-existing plugin",
+			pluginID: "non-existing-plugin",
+			dir:      "testdata",
+			want:     "",
+		},
+		{
+			name:     "empty plugin ID",
+			pluginID: "",
+			dir:      "testdata",
+			want:     "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, found := findPluginDir(tt.dir, tt.pluginID)
+			require.Equal(t, tt.exists, found)
+			require.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func TestServerSettings(t *testing.T) {
+	originalWd := currentWd
+	defer func() { currentWd = originalWd }()
+
+	t.Run("Returns settings for valid plugin", func(t *testing.T) {
+		testDataDir, err := filepath.Abs(filepath.Join("testdata", "plugin"))
+		require.NoError(t, err)
+
+		currentWd = func() (string, error) {
+			return testDataDir, nil
+		}
+
+		settings, err := serverSettings(pluginID)
+		require.NoError(t, err)
+		require.NotEmpty(t, settings.Address)
+		require.Equal(t, testDataDir, settings.Dir)
+	})
+
+	t.Run("Returns settings for nested plugin", func(t *testing.T) {
+		testDataDir, err := filepath.Abs(filepath.Join("testdata", "plugin"))
+		require.NoError(t, err)
+
+		currentWd = func() (string, error) {
+			return testDataDir, nil
+		}
+
+		settings, err := serverSettings("grafana-nested-datasource")
+		require.NoError(t, err)
+		require.NotEmpty(t, settings.Address)
+		require.Equal(t, filepath.Join(testDataDir, "datasource"), settings.Dir)
+	})
+
+	t.Run("Returns error for invalid plugin ID", func(t *testing.T) {
+		testDataDir, err := filepath.Abs("testdata")
+		require.NoError(t, err)
+
+		currentWd = func() (string, error) {
+			return testDataDir, nil
+		}
+
+		settings, err := serverSettings("")
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "plugin directory not found")
+		require.Empty(t, settings)
+	})
+
+	t.Run("Handles pkg directory by moving up one level", func(t *testing.T) {
+		tmpDir, err := os.MkdirTemp("", "plugin-test")
+		require.NoError(t, err)
+		defer func() {
+			err = os.RemoveAll(tmpDir)
+			t.Log("Error removing temp directory:", err)
+		}()
+
+		pkgDir := filepath.Join(tmpDir, "pkg")
+		err = os.Mkdir(pkgDir, 0755)
+		require.NoError(t, err)
+
+		distDir := filepath.Join(tmpDir, "dist")
+		err = os.Mkdir(distDir, 0755)
+		require.NoError(t, err)
+
+		err = os.WriteFile(filepath.Join(distDir, "plugin.json"), []byte(`{"id": "`+pluginID+`"}`), 0600)
+		require.NoError(t, err)
+
+		currentWd = func() (string, error) {
+			return pkgDir, nil
+		}
+
+		settings, err := serverSettings(pluginID)
+		require.NoError(t, err)
+		require.Equal(t, filepath.Join(tmpDir, "dist"), settings.Dir)
+		require.NotEmpty(t, settings.Address)
+	})
+
+	t.Run("Uses dist directory when available", func(t *testing.T) {
+		tmpDir, err := os.MkdirTemp("", "plugin-test")
+		require.NoError(t, err)
+		defer func() {
+			err = os.RemoveAll(tmpDir)
+			t.Log("Error removing temp directory:", err)
+		}()
+
+		distDir := filepath.Join(tmpDir, "dist")
+		err = os.Mkdir(distDir, 0755)
+		require.NoError(t, err)
+
+		err = os.WriteFile(filepath.Join(distDir, "plugin.json"), []byte(`{"id": "`+pluginID+`"}`), 0600)
+		require.NoError(t, err)
+
+		currentWd = func() (string, error) {
+			return tmpDir, nil
+		}
+
+		settings, err := serverSettings(pluginID)
+		require.NoError(t, err)
+		require.Equal(t, filepath.Join(tmpDir, "dist"), settings.Dir)
+		require.NotEmpty(t, settings.Address)
+	})
+
+	t.Run("Returns error when working directory cannot be determined", func(t *testing.T) {
+		wdErr := errors.New("mock working directory error")
+		currentWd = func() (string, error) {
+			return "", wdErr
+		}
+
+		settings, err := serverSettings(pluginID)
+		require.Error(t, err)
+		require.ErrorIs(t, err, wdErr)
+		require.Empty(t, settings)
+	})
+}

internal/standalone/testdata/dist/plugin.json

@@ -0,0 +1,3 @@
+{
+  "id": "grafana-foobar-datasource"
+}

internal/standalone/testdata/plugin/datasource/plugin.json

@@ -0,0 +1,3 @@
+{
+  "id": "grafana-nested-datasource"
+}

internal/standalone/testdata/plugin/plugin.json

@@ -1 +1,3 @@
-{}
+{
+  "id": "grafana-test-datasource"
+}