Plugins: Remove pkg/infra/fs, pkg/infra/tracing and pkg/infra/process dependencies from pkg/plugins (#115798)

* remove dependency on packages

* update tests

* trigger

pkg/services/pluginsintegration/pluginsources/pluginsources.go

@@ -0,0 +1,78 @@
+package pluginsources
+
+import (
+	"context"
+	"path/filepath"
+
+	"github.com/grafana/grafana/pkg/plugins"
+	"github.com/grafana/grafana/pkg/plugins/config"
+	"github.com/grafana/grafana/pkg/plugins/log"
+	"github.com/grafana/grafana/pkg/plugins/manager/sources"
+	"github.com/grafana/grafana/pkg/setting"
+)
+
+type Service struct {
+	cfg            *config.PluginManagementCfg
+	staticRootPath string
+
+	log log.Logger
+}
+
+func ProvideService(cfg *setting.Cfg, pCcfg *config.PluginManagementCfg) *Service {
+	return &Service{
+		cfg:            pCcfg,
+		staticRootPath: cfg.StaticRootPath,
+		log:            log.New("plugin.sources"),
+	}
+}
+
+func (s *Service) List(_ context.Context) []plugins.PluginSource {
+	r := []plugins.PluginSource{
+		sources.NewLocalSource(
+			plugins.ClassCore,
+			s.corePluginPaths(),
+		),
+	}
+	r = append(r, s.externalPluginSources()...)
+	r = append(r, s.pluginSettingSources()...)
+	return r
+}
+
+func (s *Service) externalPluginSources() []plugins.PluginSource {
+	localSrcs, err := sources.DirAsLocalSources(s.cfg, s.cfg.PluginsPath, plugins.ClassExternal)
+	if err != nil {
+		s.log.Error("Failed to load external plugins", "error", err)
+		return []plugins.PluginSource{}
+	}
+
+	srcs := make([]plugins.PluginSource, len(localSrcs))
+	for i, src := range localSrcs {
+		srcs[i] = src
+	}
+
+	return srcs
+}
+
+func (s *Service) pluginSettingSources() []plugins.PluginSource {
+	srcs := make([]plugins.PluginSource, 0, len(s.cfg.PluginSettings))
+	for _, ps := range s.cfg.PluginSettings {
+		path, exists := ps["path"]
+		if !exists || path == "" {
+			continue
+		}
+		if s.cfg.DevMode {
+			srcs = append(srcs, sources.NewUnsafeLocalSource(plugins.ClassExternal, []string{path}))
+		} else {
+			srcs = append(srcs, sources.NewLocalSource(plugins.ClassExternal, []string{path}))
+		}
+	}
+
+	return srcs
+}
+
+// corePluginPaths provides a list of the Core plugin file system paths
+func (s *Service) corePluginPaths() []string {
+	datasourcePaths := filepath.Join(s.staticRootPath, "app", "plugins", "datasource")
+	panelsPath := filepath.Join(s.staticRootPath, "app", "plugins", "panel")
+	return []string{datasourcePaths, panelsPath}
+}

pkg/services/pluginsintegration/pluginsources/pluginsources_test.go

@@ -0,0 +1,139 @@
+package pluginsources
+
+import (
+	"context"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/grafana/grafana/pkg/plugins"
+	"github.com/grafana/grafana/pkg/plugins/config"
+	"github.com/grafana/grafana/pkg/plugins/manager/sources"
+	"github.com/grafana/grafana/pkg/setting"
+)
+
+func TestSources_List(t *testing.T) {
+	t.Run("Plugin sources are populated by default and listed in specific order", func(t *testing.T) {
+		testdata := testDataDir(t)
+
+		cfg := &setting.Cfg{
+			StaticRootPath: testdata,
+		}
+
+		pCfg := &config.PluginManagementCfg{
+			PluginsPath: filepath.Join(testdata, "pluginRootWithDist"),
+			PluginSettings: config.PluginSettings{
+				"foo": map[string]string{
+					"path": filepath.Join(testdata, "test-app"),
+				},
+				"bar": map[string]string{
+					"url": "https://grafana.plugin",
+				},
+			},
+		}
+
+		s := ProvideService(cfg, pCfg)
+		srcs := s.List(context.Background())
+
+		ctx := context.Background()
+
+		require.Len(t, srcs, 5)
+
+		require.Equal(t, srcs[0].PluginClass(ctx), plugins.ClassCore)
+		if localSrc, ok := srcs[0].(*sources.LocalSource); ok {
+			require.Equal(t, localSrc.Paths(), []string{
+				filepath.Join(testdata, "app", "plugins", "datasource"),
+				filepath.Join(testdata, "app", "plugins", "panel"),
+			})
+		} else {
+			t.Fatalf("Expected LocalSource, got %T", srcs[0])
+		}
+		sig, exists := srcs[0].DefaultSignature(ctx, "")
+		require.True(t, exists)
+		require.Equal(t, plugins.SignatureStatusInternal, sig.Status)
+		require.Equal(t, plugins.SignatureType(""), sig.Type)
+		require.Equal(t, "", sig.SigningOrg)
+
+		require.Equal(t, srcs[1].PluginClass(ctx), plugins.ClassExternal)
+		if localSrc, ok := srcs[1].(*sources.LocalSource); ok {
+			require.Equal(t, localSrc.Paths(), []string{
+				filepath.Join(testdata, "pluginRootWithDist", "datasource"),
+			})
+		} else {
+			t.Fatalf("Expected LocalSource, got %T", srcs[1])
+		}
+		sig, exists = srcs[1].DefaultSignature(ctx, "")
+		require.False(t, exists)
+		require.Equal(t, plugins.Signature{}, sig)
+
+		require.Equal(t, srcs[2].PluginClass(ctx), plugins.ClassExternal)
+		if localSrc, ok := srcs[2].(*sources.LocalSource); ok {
+			require.Equal(t, localSrc.Paths(), []string{
+				filepath.Join(testdata, "pluginRootWithDist", "dist"),
+			})
+		} else {
+			t.Fatalf("Expected LocalSource, got %T", srcs[2])
+		}
+		sig, exists = srcs[2].DefaultSignature(ctx, "")
+		require.False(t, exists)
+		require.Equal(t, plugins.Signature{}, sig)
+
+		require.Equal(t, srcs[3].PluginClass(ctx), plugins.ClassExternal)
+		if localSrc, ok := srcs[3].(*sources.LocalSource); ok {
+			require.Equal(t, localSrc.Paths(), []string{
+				filepath.Join(testdata, "pluginRootWithDist", "panel"),
+			})
+		} else {
+			t.Fatalf("Expected LocalSource, got %T", srcs[3])
+		}
+		sig, exists = srcs[3].DefaultSignature(ctx, "")
+		require.False(t, exists)
+		require.Equal(t, plugins.Signature{}, sig)
+	})
+
+	t.Run("Plugin sources are populated with symbolic links", func(t *testing.T) {
+		testdata := testDataDir(t)
+		cfg := &setting.Cfg{
+			StaticRootPath: testdata,
+		}
+
+		pCfg := &config.PluginManagementCfg{
+			PluginsPath: filepath.Join(testdata, "symbolic-plugin-dirs"),
+		}
+
+		s := ProvideService(cfg, pCfg)
+		ctx := context.Background()
+		srcs := s.List(ctx)
+		uris := map[plugins.Class]map[string]struct{}{}
+		for _, src := range srcs {
+			class := src.PluginClass(ctx)
+			if _, exists := uris[class]; !exists {
+				uris[class] = map[string]struct{}{}
+			}
+			if localSrc, ok := src.(*sources.LocalSource); ok {
+				for _, path := range localSrc.Paths() {
+					uris[class][path] = struct{}{}
+				}
+			}
+		}
+
+		require.Equal(t, uris[plugins.ClassCore], map[string]struct{}{
+			filepath.Join(testdata, "app", "plugins", "datasource"): {},
+			filepath.Join(testdata, "app", "plugins", "panel"):      {},
+		}, "should include core plugins")
+
+		require.Equal(t, uris[plugins.ClassExternal], map[string]struct{}{
+			filepath.Join(testdata, "symbolic-plugin-dirs", "plugin"): {},
+		}, "should include external symlinked plugin")
+	})
+}
+
+func testDataDir(t *testing.T) string {
+	dir, err := filepath.Abs("../../../plugins/manager/testdata")
+	if err != nil {
+		t.Errorf("could not construct absolute path of current dir")
+		return ""
+	}
+	return dir
+}