public/grafana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Plugins: Move store and plugin dto to pluginsintegration (#74655)

Browse Source 
move store and plugin dto
This commit is contained in:
Will Browne
2023-09-11 13:59:24 +02:00
committed by GitHub
parent 499b02b3c6
commit e855efb13d
63 changed files with 359 additions and 335 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/services/pluginsintegration/dashboards/filestore.go
+104
View File
@@ -0,0 +1,104 @@
package dashboards
import (
"context"
"errors"
"strings"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
"github.com/grafana/grafana/pkg/util"
)
var _ FileStore = (*FileStoreManager)(nil)
type FileStoreManager struct {
pluginStore pluginstore.Store
pluginFileStore plugins.FileStore
}
func ProvideFileStoreManager(pluginStore pluginstore.Store, pluginFileStore plugins.FileStore) *FileStoreManager {
return &FileStoreManager{
pluginStore: pluginStore,
pluginFileStore: pluginFileStore,
}
}
var openDashboardFile = func(ctx context.Context, pluginFileStore plugins.FileStore, pluginID, name string) (*plugins.File, error) {
f, err := pluginFileStore.File(ctx, pluginID, name)
if err != nil {
return &plugins.File{}, err
}
return f, nil
}
func (m *FileStoreManager) ListPluginDashboardFiles(ctx context.Context, args *ListPluginDashboardFilesArgs) (*ListPluginDashboardFilesResult, error) {
if args == nil {
return nil, errors.New("args cannot be nil")
}
if len(strings.TrimSpace(args.PluginID)) == 0 {
return nil, errors.New("args.PluginID cannot be empty")
}
plugin, exists := m.pluginStore.Plugin(ctx, args.PluginID)
if !exists {
return nil, plugins.NotFoundError{PluginID: args.PluginID}
}
references := []string{}
for _, include := range plugin.DashboardIncludes() {
references = append(references, include.Path)
}
return &ListPluginDashboardFilesResult{
FileReferences: references,
}, nil
}
func (m *FileStoreManager) GetPluginDashboardFileContents(ctx context.Context, args *GetPluginDashboardFileContentsArgs) (*GetPluginDashboardFileContentsResult, error) {
if args == nil {
return nil, errors.New("args cannot be nil")
}
if len(strings.TrimSpace(args.PluginID)) == 0 {
return nil, errors.New("args.PluginID cannot be empty")
}
if len(strings.TrimSpace(args.FileReference)) == 0 {
return nil, errors.New("args.FileReference cannot be empty")
}
plugin, exists := m.pluginStore.Plugin(ctx, args.PluginID)
if !exists {
return nil, plugins.NotFoundError{PluginID: args.PluginID}
}
var includedFile *plugins.Includes
for _, include := range plugin.DashboardIncludes() {
if args.FileReference == include.Path {
includedFile = include
break
}
}
if includedFile == nil {
return nil, errors.New("plugin dashboard file not found")
}
cleanPath, err := util.CleanRelativePath(includedFile.Path)
if err != nil {
// CleanRelativePath should clean and make the path relative so this is not expected to fail
return nil, err
}
file, err := openDashboardFile(ctx, m.pluginFileStore, plugin.ID, cleanPath)
if err != nil {
return nil, err
}
return &GetPluginDashboardFileContentsResult{
Content: file.Content,
}, nil
}
pkg/services/pluginsintegration/dashboards/filestore_test.go
+228
View File
@@ -0,0 +1,228 @@
package dashboards
import (
"context"
"io"
"testing"
"testing/fstest"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
)
func TestDashboardFileStore(t *testing.T) {
m := setupPluginDashboardsForTest(t)
t.Run("Input validation", func(t *testing.T) {
t.Run("ListPluginDashboardFiles", func(t *testing.T) {
testCases := []struct {
name string
args *ListPluginDashboardFilesArgs
}{
{
name: "nil args should return error",
},
{
name: "empty args.PluginID should return error",
args: &ListPluginDashboardFilesArgs{},
},
{
name: "args.PluginID with only space should return error",
args: &ListPluginDashboardFilesArgs{PluginID: " \t "},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
res, err := m.ListPluginDashboardFiles(context.Background(), tc.args)
assert.Error(t, err)
assert.Nil(t, res)
})
}
})
t.Run("GetPluginDashboardFileContents", func(t *testing.T) {
testCases := []struct {
name string
args *GetPluginDashboardFileContentsArgs
}{
{
name: "nil args should return error",
},
{
name: "empty args.PluginID should return error",
args: &GetPluginDashboardFileContentsArgs{},
},
{
name: "args.PluginID with only space should return error",
args: &GetPluginDashboardFileContentsArgs{PluginID: " "},
},
{
name: "empty args.FileReference should return error",
args: &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithDashboards",
},
},
{
name: "args.FileReference with only space should return error",
args: &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithDashboard",
FileReference: " \t",
},
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
res, err := m.GetPluginDashboardFileContents(context.Background(), tc.args)
assert.Error(t, err)
assert.Nil(t, res)
})
}
})
})
t.Run("Plugin without dashboards", func(t *testing.T) {
t.Run("Should return zero file references", func(t *testing.T) {
res, err := m.ListPluginDashboardFiles(context.Background(), &ListPluginDashboardFilesArgs{
PluginID: "pluginWithoutDashboards",
})
require.NoError(t, err)
require.NotNil(t, res)
require.Len(t, res.FileReferences, 0)
})
t.Run("Should return file not found error when trying to get non-existing plugin dashboard file content", func(t *testing.T) {
res, err := m.GetPluginDashboardFileContents(context.Background(), &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithoutDashboards",
FileReference: "dashboards/dash2.json",
})
require.Error(t, err)
require.EqualError(t, err, "plugin dashboard file not found")
require.Nil(t, res)
})
})
t.Run("Plugin with dashboards", func(t *testing.T) {
t.Run("Should return two file references", func(t *testing.T) {
res, err := m.ListPluginDashboardFiles(context.Background(), &ListPluginDashboardFilesArgs{
PluginID: "pluginWithDashboards",
})
require.NoError(t, err)
require.NotNil(t, res)
require.Len(t, res.FileReferences, 2)
})
t.Run("With filesystem", func(t *testing.T) {
origOpenDashboardFile := openDashboardFile
mapFs := fstest.MapFS{
"dashboards/dash1.json": {
Data: []byte("dash1"),
},
"dashboards/dash2.json": {
Data: []byte("dash2"),
},
"dashboards/dash3.json": {
Data: []byte("dash3"),
},
"dash2.json": {
Data: []byte("dash2"),
},
}
openDashboardFile = func(ctx context.Context, pluginFiles plugins.FileStore, pluginID, name string) (*plugins.File, error) {
f, err := mapFs.Open(name)
require.NoError(t, err)
b, err := io.ReadAll(f)
require.NoError(t, err)
return &plugins.File{Content: b}, nil
}
t.Cleanup(func() {
openDashboardFile = origOpenDashboardFile
})
t.Run("Should return file not found error when trying to get non-existing plugin dashboard file content", func(t *testing.T) {
res, err := m.GetPluginDashboardFileContents(context.Background(), &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithDashboards",
FileReference: "dashboards/dash3.json",
})
require.Error(t, err)
require.EqualError(t, err, "plugin dashboard file not found")
require.Nil(t, res)
})
t.Run("Should return file content for dashboards/dash1.json", func(t *testing.T) {
res, err := m.GetPluginDashboardFileContents(context.Background(), &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithDashboards",
FileReference: "dashboards/dash1.json",
})
require.NoError(t, err)
require.NotNil(t, res)
require.Equal(t, "dash1", string(res.Content))
})
t.Run("Should return file content for dashboards/dash2.json", func(t *testing.T) {
res, err := m.GetPluginDashboardFileContents(context.Background(), &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithDashboards",
FileReference: "dashboards/dash2.json",
})
require.NoError(t, err)
require.NotNil(t, res)
require.Equal(t, "dash2", string(res.Content))
})
t.Run("Should return error when trying to read relative file", func(t *testing.T) {
res, err := m.GetPluginDashboardFileContents(context.Background(), &GetPluginDashboardFileContentsArgs{
PluginID: "pluginWithDashboards",
FileReference: "dashboards/../dash2.json",
})
require.Error(t, err)
require.EqualError(t, err, "plugin dashboard file not found")
require.Nil(t, res)
})
})
})
}
func setupPluginDashboardsForTest(t *testing.T) *FileStoreManager {
t.Helper()
p1 := &plugins.Plugin{
JSONData: plugins.JSONData{
ID: "pluginWithoutDashboards",
Includes: []*plugins.Includes{
{
Type: "page",
},
},
},
}
p2 := &plugins.Plugin{
JSONData: plugins.JSONData{
ID: "pluginWithDashboards",
Includes: []*plugins.Includes{
{
Type: "page",
},
{
Type: "dashboard",
Path: "dashboards/dash1.json",
},
{
Type: "dashboard",
Path: "dashboards/dash2.json",
},
},
},
}
return &FileStoreManager{
pluginStore: &pluginstore.FakePluginStore{
PluginList: []pluginstore.Plugin{pluginstore.ToGrafanaDTO(p1), pluginstore.ToGrafanaDTO(p2)},
},
}
}
pkg/services/pluginsintegration/dashboards/ifaces.go
+34
View File
@@ -0,0 +1,34 @@
package dashboards
import (
"context"
)
// FileStore is the interface for plugin dashboard file storage.
type FileStore interface {
// ListPluginDashboardFiles lists plugin dashboard files.
ListPluginDashboardFiles(ctx context.Context, args *ListPluginDashboardFilesArgs) (*ListPluginDashboardFilesResult, error)
// GetPluginDashboardFileContents gets the referenced plugin dashboard file content.
GetPluginDashboardFileContents(ctx context.Context, args *GetPluginDashboardFileContentsArgs) (*GetPluginDashboardFileContentsResult, error)
}
// ListPluginDashboardFilesArgs list plugin dashboard files argument model.
type ListPluginDashboardFilesArgs struct {
PluginID string
}
// ListPluginDashboardFilesResult list plugin dashboard files result model.
type ListPluginDashboardFilesResult struct {
FileReferences []string
}
// GetPluginDashboardFileContentsArgs get plugin dashboard file content argument model.
type GetPluginDashboardFileContentsArgs struct {
PluginID string
FileReference string
}
// GetPluginDashboardFileContentsResult get plugin dashboard file content result model.
type GetPluginDashboardFileContentsResult struct {
Content []byte
}
pkg/services/pluginsintegration/plugincontext/plugincontext.go
+3 -3
View File
@@ -10,16 +10,16 @@ import (
"github.com/grafana/grafana-plugin-sdk-go/backend"
"github.com/grafana/grafana/pkg/infra/localcache"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/services/auth/identity"
"github.com/grafana/grafana/pkg/services/datasources"
"github.com/grafana/grafana/pkg/services/pluginsintegration/adapters"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginsettings"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
)
var ErrPluginNotFound = errors.New("plugin not found")
func ProvideService(cacheService *localcache.CacheService, pluginStore plugins.Store,
func ProvideService(cacheService *localcache.CacheService, pluginStore pluginstore.Store,
dataSourceService datasources.DataSourceService, pluginSettingsService pluginsettings.Service) *Provider {
return &Provider{
cacheService: cacheService,
@@ -31,7 +31,7 @@ func ProvideService(cacheService *localcache.CacheService, pluginStore plugins.S
type Provider struct {
cacheService *localcache.CacheService
pluginStore plugins.Store
pluginStore pluginstore.Store
dataSourceService datasources.DataSourceService
pluginSettingsService pluginsettings.Service
}
pkg/services/pluginsintegration/plugins_integration_test.go
+6 -6
View File
@@ -18,9 +18,9 @@ import (
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/plugins/backendplugin/coreplugin"
"github.com/grafana/grafana/pkg/plugins/manager/registry"
"github.com/grafana/grafana/pkg/plugins/manager/store"
"github.com/grafana/grafana/pkg/services/accesscontrol/acimpl"
"github.com/grafana/grafana/pkg/services/featuremgmt"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
"github.com/grafana/grafana/pkg/services/searchV2"
"github.com/grafana/grafana/pkg/setting"
"github.com/grafana/grafana/pkg/tsdb/azuremonitor"
@@ -134,7 +134,7 @@ func verifyPluginQuery(t *testing.T, ctx context.Context, c plugins.Client) {
require.JSONEq(t, `{"results":{"A":{"frames":[{"schema":{"refId":"A","fields":[{"name":"time","type":"time","typeInfo":{"frame":"time.Time"}},{"name":"A-series","type":"number","typeInfo":{"frame":"int64","nullable":true}}]},"data":{"values":[[1661420570000,1661420630000,1661420690000,1661420750000,1661420810000,1661420870000],[1,20,90,30,5,0]]}}],"status":200}}}`, string(payload))
}
func verifyCorePluginCatalogue(t *testing.T, ctx context.Context, ps *store.Service) {
func verifyCorePluginCatalogue(t *testing.T, ctx context.Context, ps *pluginstore.Service) {
t.Helper()
expPanels := map[string]struct{}{
@@ -207,7 +207,7 @@ func verifyCorePluginCatalogue(t *testing.T, ctx context.Context, ps *store.Serv
require.Equal(t, len(expPanels), len(panels))
for _, p := range panels {
p, exists := ps.Plugin(ctx, p.ID)
require.NotEqual(t, plugins.PluginDTO{}, p)
require.NotEqual(t, pluginstore.Plugin{}, p)
require.True(t, exists)
require.Contains(t, expPanels, p.ID)
}
@@ -216,7 +216,7 @@ func verifyCorePluginCatalogue(t *testing.T, ctx context.Context, ps *store.Serv
require.Equal(t, len(expDataSources), len(dataSources))
for _, ds := range dataSources {
p, exists := ps.Plugin(ctx, ds.ID)
require.NotEqual(t, plugins.PluginDTO{}, p)
require.NotEqual(t, pluginstore.Plugin{}, p)
require.True(t, exists)
require.Contains(t, expDataSources, ds.ID)
}
@@ -233,7 +233,7 @@ func verifyCorePluginCatalogue(t *testing.T, ctx context.Context, ps *store.Serv
require.Equal(t, len(expPanels)+len(expDataSources)+len(expApps), len(ps.Plugins(ctx)))
}
func verifyBundledPlugins(t *testing.T, ctx context.Context, ps *store.Service) {
func verifyBundledPlugins(t *testing.T, ctx context.Context, ps *pluginstore.Service) {
t.Helper()
dsPlugins := make(map[string]struct{})
@@ -243,7 +243,7 @@ func verifyBundledPlugins(t *testing.T, ctx context.Context, ps *store.Service)
inputPlugin, exists := ps.Plugin(ctx, "input")
require.True(t, exists)
require.NotEqual(t, plugins.PluginDTO{}, inputPlugin)
require.NotEqual(t, pluginstore.Plugin{}, inputPlugin)
require.NotNil(t, dsPlugins["input"])
pluginRoutes := make(map[string]*plugins.StaticRoute)
pkg/services/pluginsintegration/pluginsintegration.go
+6 -6
View File
@@ -24,7 +24,6 @@ import (
"github.com/grafana/grafana/pkg/plugins/manager/registry"
"github.com/grafana/grafana/pkg/plugins/manager/signature"
"github.com/grafana/grafana/pkg/plugins/manager/sources"
"github.com/grafana/grafana/pkg/plugins/manager/store"
"github.com/grafana/grafana/pkg/plugins/oauth"
"github.com/grafana/grafana/pkg/plugins/pluginscdn"
"github.com/grafana/grafana/pkg/plugins/repo"
@@ -46,6 +45,7 @@ import (
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginerrs"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginsettings"
pluginSettings "github.com/grafana/grafana/pkg/services/pluginsintegration/pluginsettings/service"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
"github.com/grafana/grafana/pkg/services/pluginsintegration/serviceregistration"
"github.com/grafana/grafana/pkg/setting"
)
@@ -53,11 +53,11 @@ import (
// WireSet provides a wire.ProviderSet of plugin providers.
var WireSet = wire.NewSet(
config.ProvideConfig,
store.ProvideService,
wire.Bind(new(plugins.Store), new(*store.Service)),
wire.Bind(new(plugins.RendererManager), new(*store.Service)),
wire.Bind(new(plugins.SecretsPluginManager), new(*store.Service)),
wire.Bind(new(plugins.StaticRouteResolver), new(*store.Service)),
pluginstore.ProvideService,
wire.Bind(new(pluginstore.Store), new(*pluginstore.Service)),
wire.Bind(new(plugins.RendererManager), new(*pluginstore.Service)),
wire.Bind(new(plugins.SecretsPluginManager), new(*pluginstore.Service)),
wire.Bind(new(plugins.StaticRouteResolver), new(*pluginstore.Service)),
ProvideClientDecorator,
wire.Bind(new(plugins.Client), new(*client.Decorator)),
process.ProvideService,
pkg/services/pluginsintegration/pluginstore/fake.go
+38
View File
@@ -0,0 +1,38 @@
package pluginstore
import (
"context"
"github.com/grafana/grafana/pkg/plugins"
)
type FakePluginStore struct {
PluginList []Plugin
}
func (pr *FakePluginStore) Plugin(_ context.Context, pluginID string) (Plugin, bool) {
for _, v := range pr.PluginList {
if v.ID == pluginID {
return v, true
}
}
return Plugin{}, false
}
func (pr *FakePluginStore) Plugins(_ context.Context, pluginTypes ...plugins.Type) []Plugin {
var result []Plugin
if len(pluginTypes) == 0 {
pluginTypes = plugins.PluginTypes
}
for _, v := range pr.PluginList {
for _, t := range pluginTypes {
if v.Type == t {
result = append(result, v)
}
}
}
return result
}
pkg/services/pluginsintegration/pluginstore/plugins.go
+78
View File
@@ -0,0 +1,78 @@
package pluginstore
import (
"github.com/grafana/grafana-plugin-sdk-go/backend"
"github.com/grafana/grafana/pkg/plugins"
)
type Plugin struct {
plugins.JSONData
fs plugins.FS
supportsStreaming bool
Class plugins.Class
// App fields
IncludedInAppID string
DefaultNavURL string
Pinned bool
// Signature fields
Signature plugins.SignatureStatus
SignatureType plugins.SignatureType
SignatureOrg string
SignatureError *plugins.SignatureError
// SystemJS fields
Module string
BaseURL string
AngularDetected bool
// This will be moved to plugin.json when we have general support in gcom
Alias string `json:"alias,omitempty"`
}
func (p Plugin) SupportsStreaming() bool {
return p.supportsStreaming
}
func (p Plugin) Base() string {
return p.fs.Base()
}
func (p Plugin) IsApp() bool {
return p.Type == plugins.TypeApp
}
func (p Plugin) IsCorePlugin() bool {
return p.Class == plugins.ClassCore
}
func ToGrafanaDTO(p *plugins.Plugin) Plugin {
supportsStreaming := false
pc, exists := p.Client()
if exists && pc != nil && pc.(backend.StreamHandler) != nil {
supportsStreaming = false
}
return Plugin{
fs: p.FS,
supportsStreaming: supportsStreaming,
Class: p.Class,
JSONData: p.JSONData,
IncludedInAppID: p.IncludedInAppID,
DefaultNavURL: p.DefaultNavURL,
Pinned: p.Pinned,
Signature: p.Signature,
SignatureType: p.SignatureType,
SignatureOrg: p.SignatureOrg,
SignatureError: p.SignatureError,
Module: p.Module,
BaseURL: p.BaseURL,
AngularDetected: p.AngularDetected,
Alias: p.Alias,
}
}
pkg/services/pluginsintegration/pluginstore/store.go
+155
View File
@@ -0,0 +1,155 @@
package pluginstore
import (
"context"
"sort"
"sync"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/plugins/manager/loader"
"github.com/grafana/grafana/pkg/plugins/manager/registry"
"github.com/grafana/grafana/pkg/plugins/manager/sources"
)
var _ Store = (*Service)(nil)
// Store is the publicly accessible storage for plugins.
type Store interface {
// Plugin finds a plugin by its ID.
Plugin(ctx context.Context, pluginID string) (Plugin, bool)
// Plugins returns plugins by their requested type.
Plugins(ctx context.Context, pluginTypes ...plugins.Type) []Plugin
}
type Service struct {
pluginRegistry registry.Service
pluginLoader loader.Service
}
func ProvideService(pluginRegistry registry.Service, pluginSources sources.Registry,
pluginLoader loader.Service) (*Service, error) {
ctx := context.Background()
for _, ps := range pluginSources.List(ctx) {
if _, err := pluginLoader.Load(ctx, ps); err != nil {
return nil, err
}
}
return New(pluginRegistry, pluginLoader), nil
}
func (s *Service) Run(ctx context.Context) error {
<-ctx.Done()
s.shutdown(ctx)
return ctx.Err()
}
func New(pluginRegistry registry.Service, pluginLoader loader.Service) *Service {
return &Service{
pluginRegistry: pluginRegistry,
pluginLoader: pluginLoader,
}
}
func (s *Service) Plugin(ctx context.Context, pluginID string) (Plugin, bool) {
p, exists := s.plugin(ctx, pluginID)
if !exists {
return Plugin{}, false
}
return ToGrafanaDTO(p), true
}
func (s *Service) Plugins(ctx context.Context, pluginTypes ...plugins.Type) []Plugin {
// if no types passed, assume all
if len(pluginTypes) == 0 {
pluginTypes = plugins.PluginTypes
}
var requestedTypes = make(map[plugins.Type]struct{})
for _, pt := range pluginTypes {
requestedTypes[pt] = struct{}{}
}
pluginsList := make([]Plugin, 0)
for _, p := range s.availablePlugins(ctx) {
if _, exists := requestedTypes[p.Type]; exists {
pluginsList = append(pluginsList, ToGrafanaDTO(p))
}
}
return pluginsList
}
func (s *Service) Renderer(ctx context.Context) *plugins.Plugin {
for _, p := range s.availablePlugins(ctx) {
if p.IsRenderer() {
return p
}
}
return nil
}
func (s *Service) SecretsManager(ctx context.Context) *plugins.Plugin {
for _, p := range s.availablePlugins(ctx) {
if p.IsSecretsManager() {
return p
}
}
return nil
}
// plugin finds a plugin with `pluginID` from the registry that is not decommissioned
func (s *Service) plugin(ctx context.Context, pluginID string) (*plugins.Plugin, bool) {
p, exists := s.pluginRegistry.Plugin(ctx, pluginID)
if !exists {
return nil, false
}
if p.IsDecommissioned() {
return nil, false
}
return p, true
}
// availablePlugins returns all non-decommissioned plugins from the registry sorted by alphabetic order on `plugin.ID`
func (s *Service) availablePlugins(ctx context.Context) []*plugins.Plugin {
ps := s.pluginRegistry.Plugins(ctx)
res := make([]*plugins.Plugin, 0, len(ps))
for _, p := range ps {
if !p.IsDecommissioned() {
res = append(res, p)
}
}
sort.SliceStable(res, func(i, j int) bool {
return res[i].ID < res[j].ID
})
return res
}
func (s *Service) Routes(ctx context.Context) []*plugins.StaticRoute {
staticRoutes := make([]*plugins.StaticRoute, 0)
for _, p := range s.availablePlugins(ctx) {
if p.StaticRoute() != nil {
staticRoutes = append(staticRoutes, p.StaticRoute())
}
}
return staticRoutes
}
func (s *Service) shutdown(ctx context.Context) {
var wg sync.WaitGroup
for _, plugin := range s.pluginRegistry.Plugins(ctx) {
wg.Add(1)
go func(ctx context.Context, p *plugins.Plugin) {
defer wg.Done()
p.Logger().Debug("Stopping plugin")
if _, err := s.pluginLoader.Unload(ctx, p); err != nil {
p.Logger().Error("Failed to stop plugin", "error", err)
}
p.Logger().Debug("Plugin stopped")
}(ctx, plugin)
}
wg.Wait()
}
pkg/services/pluginsintegration/pluginstore/store_test.go
+255
View File
@@ -0,0 +1,255 @@
package pluginstore
import (
"context"
"sync"
"testing"
"github.com/stretchr/testify/require"
"github.com/grafana/grafana/pkg/plugins"
"github.com/grafana/grafana/pkg/plugins/backendplugin"
"github.com/grafana/grafana/pkg/plugins/log"
"github.com/grafana/grafana/pkg/plugins/manager/fakes"
)
func TestStore_ProvideService(t *testing.T) {
t.Run("Plugin sources are added in order", func(t *testing.T) {
var addedPaths []string
l := &fakes.FakeLoader{
LoadFunc: func(ctx context.Context, src plugins.PluginSource) ([]*plugins.Plugin, error) {
addedPaths = append(addedPaths, src.PluginURIs(ctx)...)
return nil, nil
},
}
srcs := &fakes.FakeSourceRegistry{ListFunc: func(_ context.Context) []plugins.PluginSource {
return []plugins.PluginSource{
&fakes.FakePluginSource{
PluginClassFunc: func(ctx context.Context) plugins.Class {
return plugins.ClassBundled
},
PluginURIsFunc: func(ctx context.Context) []string {
return []string{"path1"}
},
},
&fakes.FakePluginSource{
PluginClassFunc: func(ctx context.Context) plugins.Class {
return plugins.ClassExternal
},
PluginURIsFunc: func(ctx context.Context) []string {
return []string{"path2", "path3"}
},
},
}
}}
_, err := ProvideService(fakes.NewFakePluginRegistry(), srcs, l)
require.NoError(t, err)
require.Equal(t, []string{"path1", "path2", "path3"}, addedPaths)
})
}
func TestStore_Plugin(t *testing.T) {
t.Run("Plugin returns all non-decommissioned plugins", func(t *testing.T) {
p1 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-datasource"}}
p1.RegisterClient(&DecommissionedPlugin{})
p2 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-panel"}}
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p1.ID: p1,
p2.ID: p2,
},
}, &fakes.FakeLoader{})
p, exists := ps.Plugin(context.Background(), p1.ID)
require.False(t, exists)
require.Equal(t, Plugin{}, p)
p, exists = ps.Plugin(context.Background(), p2.ID)
require.True(t, exists)
require.Equal(t, p, ToGrafanaDTO(p2))
})
}
func TestStore_Plugins(t *testing.T) {
t.Run("Plugin returns all non-decommissioned plugins by type", func(t *testing.T) {
p1 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "a-test-datasource", Type: plugins.TypeDataSource}}
p2 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "b-test-panel", Type: plugins.TypePanel}}
p3 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "c-test-panel", Type: plugins.TypePanel}}
p4 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "d-test-app", Type: plugins.TypeApp}}
p5 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "e-test-panel", Type: plugins.TypePanel}}
p5.RegisterClient(&DecommissionedPlugin{})
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p1.ID: p1,
p2.ID: p2,
p3.ID: p3,
p4.ID: p4,
p5.ID: p5,
},
}, &fakes.FakeLoader{})
ToGrafanaDTO(p1)
pss := ps.Plugins(context.Background())
require.Equal(t, pss, []Plugin{
ToGrafanaDTO(p1), ToGrafanaDTO(p2),
ToGrafanaDTO(p3), ToGrafanaDTO(p4),
})
pss = ps.Plugins(context.Background(), plugins.TypeApp)
require.Equal(t, pss, []Plugin{ToGrafanaDTO(p4)})
pss = ps.Plugins(context.Background(), plugins.TypePanel)
require.Equal(t, pss, []Plugin{ToGrafanaDTO(p2), ToGrafanaDTO(p3)})
pss = ps.Plugins(context.Background(), plugins.TypeDataSource)
require.Equal(t, pss, []Plugin{ToGrafanaDTO(p1)})
pss = ps.Plugins(context.Background(), plugins.TypeDataSource, plugins.TypeApp, plugins.TypePanel)
require.Equal(t, pss, []Plugin{
ToGrafanaDTO(p1), ToGrafanaDTO(p2),
ToGrafanaDTO(p3), ToGrafanaDTO(p4),
})
})
}
func TestStore_Routes(t *testing.T) {
t.Run("Routes returns all static routes for non-decommissioned plugins", func(t *testing.T) {
p1 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "a-test-renderer", Type: plugins.TypeRenderer}, FS: fakes.NewFakePluginFiles("/some/dir")}
p2 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "b-test-panel", Type: plugins.TypePanel}, FS: fakes.NewFakePluginFiles("/grafana/")}
p3 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "c-test-secrets", Type: plugins.TypeSecretsManager}, FS: fakes.NewFakePluginFiles("./secrets"), Class: plugins.ClassCore}
p4 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "d-test-datasource", Type: plugins.TypeDataSource}, FS: fakes.NewFakePluginFiles("../test")}
p5 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "e-test-app", Type: plugins.TypeApp}, FS: fakes.NewFakePluginFiles("any/path")}
p6 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "f-test-app", Type: plugins.TypeApp}}
p6.RegisterClient(&DecommissionedPlugin{})
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p1.ID: p1,
p2.ID: p2,
p3.ID: p3,
p4.ID: p4,
p5.ID: p5,
p6.ID: p6,
},
}, &fakes.FakeLoader{})
sr := func(p *plugins.Plugin) *plugins.StaticRoute {
return &plugins.StaticRoute{PluginID: p.ID, Directory: p.FS.Base()}
}
rs := ps.Routes(context.Background())
require.Equal(t, []*plugins.StaticRoute{sr(p1), sr(p2), sr(p4), sr(p5)}, rs)
})
}
func TestStore_Renderer(t *testing.T) {
t.Run("Renderer returns a single (non-decommissioned) renderer plugin", func(t *testing.T) {
p1 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-renderer", Type: plugins.TypeRenderer}}
p2 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-panel", Type: plugins.TypePanel}}
p3 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-app", Type: plugins.TypeApp}}
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p1.ID: p1,
p2.ID: p2,
p3.ID: p3,
},
}, &fakes.FakeLoader{})
r := ps.Renderer(context.Background())
require.Equal(t, p1, r)
})
}
func TestStore_SecretsManager(t *testing.T) {
t.Run("Renderer returns a single (non-decommissioned) secrets manager plugin", func(t *testing.T) {
p1 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-renderer", Type: plugins.TypeRenderer}}
p2 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-panel", Type: plugins.TypePanel}}
p3 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-secrets", Type: plugins.TypeSecretsManager}}
p4 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-datasource", Type: plugins.TypeDataSource}}
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p1.ID: p1,
p2.ID: p2,
p3.ID: p3,
p4.ID: p4,
},
}, &fakes.FakeLoader{})
r := ps.SecretsManager(context.Background())
require.Equal(t, p3, r)
})
}
func TestProcessManager_shutdown(t *testing.T) {
p := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-datasource", Type: plugins.TypeDataSource}} // Backend: true
backend := &fakes.FakeBackendPlugin{}
p.RegisterClient(backend)
p.SetLogger(log.NewTestLogger())
unloaded := false
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p.ID: p,
},
}, &fakes.FakeLoader{
UnloadFunc: func(_ context.Context, plugin *plugins.Plugin) (*plugins.Plugin, error) {
require.Equal(t, p, plugin)
unloaded = true
return nil, nil
},
})
pCtx := context.Background()
cCtx, cancel := context.WithCancel(pCtx)
var wgRun sync.WaitGroup
wgRun.Add(1)
var runErr error
go func() {
runErr = ps.Run(cCtx)
wgRun.Done()
}()
t.Run("When context is cancelled the plugin is stopped", func(t *testing.T) {
cancel()
wgRun.Wait()
require.ErrorIs(t, runErr, context.Canceled)
require.True(t, unloaded)
})
}
func TestStore_availablePlugins(t *testing.T) {
t.Run("Decommissioned plugins are excluded from availablePlugins", func(t *testing.T) {
p1 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-datasource"}}
p1.RegisterClient(&DecommissionedPlugin{})
p2 := &plugins.Plugin{JSONData: plugins.JSONData{ID: "test-app"}}
ps := New(&fakes.FakePluginRegistry{
Store: map[string]*plugins.Plugin{
p1.ID: p1,
p2.ID: p2,
},
}, &fakes.FakeLoader{})
aps := ps.availablePlugins(context.Background())
require.Len(t, aps, 1)
require.Equal(t, p2, aps[0])
})
}
type DecommissionedPlugin struct {
backendplugin.Plugin
}
func (p *DecommissionedPlugin) Decommission() error {
return nil
}
func (p *DecommissionedPlugin) IsDecommissioned() bool {
return true
}
pkg/services/pluginsintegration/test_helper.go
+3 -3
View File
@@ -26,18 +26,18 @@ import (
"github.com/grafana/grafana/pkg/plugins/manager/signature"
"github.com/grafana/grafana/pkg/plugins/manager/signature/statickey"
"github.com/grafana/grafana/pkg/plugins/manager/sources"
"github.com/grafana/grafana/pkg/plugins/manager/store"
"github.com/grafana/grafana/pkg/plugins/pluginscdn"
"github.com/grafana/grafana/pkg/services/featuremgmt"
"github.com/grafana/grafana/pkg/services/pluginsintegration/config"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pipeline"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginerrs"
"github.com/grafana/grafana/pkg/services/pluginsintegration/pluginstore"
"github.com/grafana/grafana/pkg/setting"
)
type IntegrationTestCtx struct {
PluginClient plugins.Client
PluginStore *store.Service
PluginStore *pluginstore.Service
PluginRegistry registry.Service
}
@@ -66,7 +66,7 @@ func CreateIntegrationTestCtx(t *testing.T, cfg *setting.Cfg, coreRegistry *core
Terminator: term,
})
ps, err := store.ProvideService(reg, sources.ProvideService(cfg, pCfg), l)
ps, err := pluginstore.ProvideService(reg, sources.ProvideService(cfg, pCfg), l)
require.NoError(t, err)
return &IntegrationTestCtx{