Plugins: Refactor plugin dashboards (#44315)
Moves/refactor Grafana specific functionality related to plugin dashboards out to specific services for importing dashboards and keep app plugin dashboards up-to-date. Fixes #44257
This commit is contained in:
Marcus Efraimsson
@@ -0,0 +1,89 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
|
||||
"github.com/grafana/grafana/pkg/api/apierrors"
|
||||
"github.com/grafana/grafana/pkg/api/response"
|
||||
"github.com/grafana/grafana/pkg/api/routing"
|
||||
"github.com/grafana/grafana/pkg/components/simplejson"
|
||||
"github.com/grafana/grafana/pkg/middleware"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
"github.com/grafana/grafana/pkg/plugins"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/grafana/grafana/pkg/web"
|
||||
)
|
||||
|
||||
type ImportDashboardAPI struct {
|
||||
dashboardImportService dashboardimport.Service
|
||||
quotaService QuotaService
|
||||
schemaLoaderService SchemaLoaderService
|
||||
pluginStore plugins.Store
|
||||
}
|
||||
|
||||
func New(dashboardImportService dashboardimport.Service, quotaService QuotaService,
|
||||
schemaLoaderService SchemaLoaderService, pluginStore plugins.Store) *ImportDashboardAPI {
|
||||
return &ImportDashboardAPI{
|
||||
dashboardImportService: dashboardImportService,
|
||||
quotaService: quotaService,
|
||||
schemaLoaderService: schemaLoaderService,
|
||||
pluginStore: pluginStore,
|
||||
}
|
||||
}
|
||||
|
||||
func (api *ImportDashboardAPI) RegisterAPIEndpoints(routeRegister routing.RouteRegister) {
|
||||
routeRegister.Group("/api/dashboards", func(route routing.RouteRegister) {
|
||||
route.Post("/import", routing.Wrap(api.ImportDashboard))
|
||||
}, middleware.ReqSignedIn)
|
||||
}
|
||||
|
||||
func (api *ImportDashboardAPI) ImportDashboard(c *models.ReqContext) response.Response {
|
||||
req := dashboardimport.ImportDashboardRequest{}
|
||||
if err := web.Bind(c.Req, &req); err != nil {
|
||||
return response.Error(http.StatusBadRequest, "bad request data", err)
|
||||
}
|
||||
|
||||
if req.PluginId == "" && req.Dashboard == nil {
|
||||
return response.Error(http.StatusUnprocessableEntity, "Dashboard must be set", nil)
|
||||
}
|
||||
|
||||
limitReached, err := api.quotaService.QuotaReached(c, "dashboard")
|
||||
if err != nil {
|
||||
return response.Error(500, "failed to get quota", err)
|
||||
}
|
||||
|
||||
if limitReached {
|
||||
return response.Error(403, "Quota reached", nil)
|
||||
}
|
||||
|
||||
trimDefaults := c.QueryBoolWithDefault("trimdefaults", true)
|
||||
if trimDefaults && !api.schemaLoaderService.IsDisabled() {
|
||||
req.Dashboard, err = api.schemaLoaderService.DashboardApplyDefaults(req.Dashboard)
|
||||
if err != nil {
|
||||
return response.Error(http.StatusInternalServerError, "Error while applying default value to the dashboard json", err)
|
||||
}
|
||||
}
|
||||
|
||||
req.User = c.SignedInUser
|
||||
resp, err := api.dashboardImportService.ImportDashboard(c.Req.Context(), &req)
|
||||
if err != nil {
|
||||
return apierrors.ToDashboardErrorResponse(c.Req.Context(), api.pluginStore, err)
|
||||
}
|
||||
|
||||
return response.JSON(http.StatusOK, resp)
|
||||
}
|
||||
|
||||
type QuotaService interface {
|
||||
QuotaReached(c *models.ReqContext, target string) (bool, error)
|
||||
}
|
||||
|
||||
type quotaServiceFunc func(c *models.ReqContext, target string) (bool, error)
|
||||
|
||||
func (fn quotaServiceFunc) QuotaReached(c *models.ReqContext, target string) (bool, error) {
|
||||
return fn(c, target)
|
||||
}
|
||||
|
||||
type SchemaLoaderService interface {
|
||||
IsDisabled() bool
|
||||
DashboardApplyDefaults(input *simplejson.Json) (*simplejson.Json, error)
|
||||
}
|
||||
@@ -0,0 +1,209 @@
|
||||
package api
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"testing"
|
||||
|
||||
"github.com/grafana/grafana/pkg/api/routing"
|
||||
"github.com/grafana/grafana/pkg/components/simplejson"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/grafana/grafana/pkg/web/webtest"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestImportDashboardAPI(t *testing.T) {
|
||||
t.Run("Quota not reached, schema loader service disabled", func(t *testing.T) {
|
||||
importDashboardServiceCalled := false
|
||||
service := &serviceMock{
|
||||
importDashboardFunc: func(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error) {
|
||||
importDashboardServiceCalled = true
|
||||
return nil, nil
|
||||
},
|
||||
}
|
||||
|
||||
schemaLoaderServiceCalled := false
|
||||
schemaLoaderService := &schemaLoaderServiceMock{
|
||||
dashboardApplyDefaultsFunc: func(input *simplejson.Json) (*simplejson.Json, error) {
|
||||
schemaLoaderServiceCalled = true
|
||||
return input, nil
|
||||
},
|
||||
}
|
||||
|
||||
importDashboardAPI := New(service, quotaServiceFunc(quotaNotReached), schemaLoaderService, nil)
|
||||
routeRegister := routing.NewRouteRegister()
|
||||
importDashboardAPI.RegisterAPIEndpoints(routeRegister)
|
||||
s := webtest.NewServer(t, routeRegister)
|
||||
|
||||
t.Run("Not signed in should return 404", func(t *testing.T) {
|
||||
cmd := &dashboardimport.ImportDashboardRequest{}
|
||||
jsonBytes, err := json.Marshal(cmd)
|
||||
require.NoError(t, err)
|
||||
req := s.NewRequest(http.MethodPost, "/api/dashboards/import", bytes.NewReader(jsonBytes))
|
||||
resp, err := s.Send(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusUnauthorized, resp.StatusCode)
|
||||
})
|
||||
|
||||
t.Run("Signed in, empty plugin id and dashboard model empty should return error", func(t *testing.T) {
|
||||
cmd := &dashboardimport.ImportDashboardRequest{
|
||||
PluginId: "",
|
||||
Dashboard: nil,
|
||||
}
|
||||
jsonBytes, err := json.Marshal(cmd)
|
||||
require.NoError(t, err)
|
||||
req := s.NewRequest(http.MethodPost, "/api/dashboards/import", bytes.NewReader(jsonBytes))
|
||||
webtest.RequestWithSignedInUser(req, &models.SignedInUser{
|
||||
UserId: 1,
|
||||
})
|
||||
resp, err := s.Send(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusUnprocessableEntity, resp.StatusCode)
|
||||
})
|
||||
|
||||
t.Run("Signed in, dashboard model set should call import dashboard service", func(t *testing.T) {
|
||||
cmd := &dashboardimport.ImportDashboardRequest{
|
||||
Dashboard: simplejson.New(),
|
||||
}
|
||||
jsonBytes, err := json.Marshal(cmd)
|
||||
require.NoError(t, err)
|
||||
req := s.NewRequest(http.MethodPost, "/api/dashboards/import", bytes.NewReader(jsonBytes))
|
||||
webtest.RequestWithSignedInUser(req, &models.SignedInUser{
|
||||
UserId: 1,
|
||||
})
|
||||
resp, err := s.Send(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusOK, resp.StatusCode)
|
||||
require.True(t, importDashboardServiceCalled)
|
||||
})
|
||||
|
||||
t.Run("Signed in, dashboard model set, trimdefaults enabled should not call schema loader service", func(t *testing.T) {
|
||||
cmd := &dashboardimport.ImportDashboardRequest{
|
||||
Dashboard: simplejson.New(),
|
||||
}
|
||||
jsonBytes, err := json.Marshal(cmd)
|
||||
require.NoError(t, err)
|
||||
req := s.NewRequest(http.MethodPost, "/api/dashboards/import?trimdefaults=true", bytes.NewReader(jsonBytes))
|
||||
webtest.RequestWithSignedInUser(req, &models.SignedInUser{
|
||||
UserId: 1,
|
||||
})
|
||||
resp, err := s.Send(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusOK, resp.StatusCode)
|
||||
require.False(t, schemaLoaderServiceCalled)
|
||||
require.True(t, importDashboardServiceCalled)
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("Quota not reached, schema loader service enabled", func(t *testing.T) {
|
||||
importDashboardServiceCalled := false
|
||||
service := &serviceMock{
|
||||
importDashboardFunc: func(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error) {
|
||||
importDashboardServiceCalled = true
|
||||
return nil, nil
|
||||
},
|
||||
}
|
||||
|
||||
schemaLoaderServiceCalled := false
|
||||
schemaLoaderService := &schemaLoaderServiceMock{
|
||||
enabled: true,
|
||||
dashboardApplyDefaultsFunc: func(input *simplejson.Json) (*simplejson.Json, error) {
|
||||
schemaLoaderServiceCalled = true
|
||||
return input, nil
|
||||
},
|
||||
}
|
||||
|
||||
importDashboardAPI := New(service, quotaServiceFunc(quotaNotReached), schemaLoaderService, nil)
|
||||
routeRegister := routing.NewRouteRegister()
|
||||
importDashboardAPI.RegisterAPIEndpoints(routeRegister)
|
||||
s := webtest.NewServer(t, routeRegister)
|
||||
|
||||
t.Run("Signed in, dashboard model set, trimdefaults enabled should call schema loader service", func(t *testing.T) {
|
||||
cmd := &dashboardimport.ImportDashboardRequest{
|
||||
Dashboard: simplejson.New(),
|
||||
}
|
||||
jsonBytes, err := json.Marshal(cmd)
|
||||
require.NoError(t, err)
|
||||
req := s.NewRequest(http.MethodPost, "/api/dashboards/import?trimdefaults=true", bytes.NewReader(jsonBytes))
|
||||
webtest.RequestWithSignedInUser(req, &models.SignedInUser{
|
||||
UserId: 1,
|
||||
})
|
||||
resp, err := s.Send(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusOK, resp.StatusCode)
|
||||
require.True(t, schemaLoaderServiceCalled)
|
||||
require.True(t, importDashboardServiceCalled)
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("Quota reached", func(t *testing.T) {
|
||||
service := &serviceMock{}
|
||||
schemaLoaderService := &schemaLoaderServiceMock{}
|
||||
importDashboardAPI := New(service, quotaServiceFunc(quotaReached), schemaLoaderService, nil)
|
||||
|
||||
routeRegister := routing.NewRouteRegister()
|
||||
importDashboardAPI.RegisterAPIEndpoints(routeRegister)
|
||||
s := webtest.NewServer(t, routeRegister)
|
||||
|
||||
t.Run("Signed in, dashboard model set, should return 403 forbidden/quota reached", func(t *testing.T) {
|
||||
cmd := &dashboardimport.ImportDashboardRequest{
|
||||
Dashboard: simplejson.New(),
|
||||
}
|
||||
jsonBytes, err := json.Marshal(cmd)
|
||||
require.NoError(t, err)
|
||||
req := s.NewRequest(http.MethodPost, "/api/dashboards/import", bytes.NewReader(jsonBytes))
|
||||
webtest.RequestWithSignedInUser(req, &models.SignedInUser{
|
||||
UserId: 1,
|
||||
})
|
||||
resp, err := s.Send(req)
|
||||
require.NoError(t, err)
|
||||
require.NoError(t, resp.Body.Close())
|
||||
require.Equal(t, http.StatusForbidden, resp.StatusCode)
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
type serviceMock struct {
|
||||
importDashboardFunc func(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error)
|
||||
}
|
||||
|
||||
func (s *serviceMock) ImportDashboard(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error) {
|
||||
if s.importDashboardFunc != nil {
|
||||
return s.importDashboardFunc(ctx, req)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type schemaLoaderServiceMock struct {
|
||||
enabled bool
|
||||
dashboardApplyDefaultsFunc func(input *simplejson.Json) (*simplejson.Json, error)
|
||||
}
|
||||
|
||||
func (s *schemaLoaderServiceMock) IsDisabled() bool {
|
||||
return !s.enabled
|
||||
}
|
||||
|
||||
func (s *schemaLoaderServiceMock) DashboardApplyDefaults(input *simplejson.Json) (*simplejson.Json, error) {
|
||||
if s.dashboardApplyDefaultsFunc != nil {
|
||||
return s.dashboardApplyDefaultsFunc(input)
|
||||
}
|
||||
|
||||
return input, nil
|
||||
}
|
||||
|
||||
func quotaReached(c *models.ReqContext, target string) (bool, error) {
|
||||
return true, nil
|
||||
}
|
||||
|
||||
func quotaNotReached(c *models.ReqContext, target string) (bool, error) {
|
||||
return false, nil
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package dashboardimport
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/grafana/grafana/pkg/components/simplejson"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
)
|
||||
|
||||
// ImportDashboardInput definition of input parameters when importing a dashboard.
|
||||
type ImportDashboardInput struct {
|
||||
Type string `json:"type"`
|
||||
PluginId string `json:"pluginId"`
|
||||
Name string `json:"name"`
|
||||
Value string `json:"value"`
|
||||
}
|
||||
|
||||
// ImportDashboardRequest request object for importing a dashboard.
|
||||
type ImportDashboardRequest struct {
|
||||
PluginId string `json:"pluginId"`
|
||||
Path string `json:"path"`
|
||||
Overwrite bool `json:"overwrite"`
|
||||
Dashboard *simplejson.Json `json:"dashboard"`
|
||||
Inputs []ImportDashboardInput `json:"inputs"`
|
||||
FolderId int64 `json:"folderId"`
|
||||
FolderUid string `json:"folderUid"`
|
||||
|
||||
User *models.SignedInUser `json:"-"`
|
||||
}
|
||||
|
||||
// ImportDashboardResponse response object returned when importing a dashboard.
|
||||
type ImportDashboardResponse struct {
|
||||
UID string `json:"uid"`
|
||||
PluginId string `json:"pluginId"`
|
||||
Title string `json:"title"`
|
||||
Imported bool `json:"imported"`
|
||||
ImportedUri string `json:"importedUri"`
|
||||
ImportedUrl string `json:"importedUrl"`
|
||||
Slug string `json:"slug"`
|
||||
DashboardId int64 `json:"dashboardId"`
|
||||
FolderId int64 `json:"folderId"`
|
||||
ImportedRevision int64 `json:"importedRevision"`
|
||||
Revision int64 `json:"revision"`
|
||||
Description string `json:"description"`
|
||||
Path string `json:"path"`
|
||||
Removed bool `json:"removed"`
|
||||
}
|
||||
|
||||
// Service service interface for importing dashboards.
|
||||
type Service interface {
|
||||
ImportDashboard(ctx context.Context, req *ImportDashboardRequest) (*ImportDashboardResponse, error)
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"github.com/grafana/grafana/pkg/api/routing"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
"github.com/grafana/grafana/pkg/plugins"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport/api"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport/utils"
|
||||
"github.com/grafana/grafana/pkg/services/dashboards"
|
||||
"github.com/grafana/grafana/pkg/services/librarypanels"
|
||||
"github.com/grafana/grafana/pkg/services/quota"
|
||||
"github.com/grafana/grafana/pkg/services/schemaloader"
|
||||
"github.com/grafana/grafana/pkg/services/sqlstore"
|
||||
)
|
||||
|
||||
func ProvideService(sqlStore *sqlstore.SQLStore, routeRegister routing.RouteRegister,
|
||||
quotaService *quota.QuotaService, schemaLoaderService *schemaloader.SchemaLoaderService,
|
||||
pluginDashboardManager plugins.PluginDashboardManager, pluginStore plugins.Store,
|
||||
libraryPanelService librarypanels.Service) *ImportDashboardService {
|
||||
s := &ImportDashboardService{
|
||||
pluginDashboardManager: pluginDashboardManager,
|
||||
dashboardService: dashboards.NewService(sqlStore),
|
||||
libraryPanelService: libraryPanelService,
|
||||
}
|
||||
|
||||
dashboardImportAPI := api.New(s, quotaService, schemaLoaderService, pluginStore)
|
||||
dashboardImportAPI.RegisterAPIEndpoints(routeRegister)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
type ImportDashboardService struct {
|
||||
pluginDashboardManager plugins.PluginDashboardManager
|
||||
dashboardService dashboards.DashboardService
|
||||
libraryPanelService librarypanels.Service
|
||||
}
|
||||
|
||||
func (s *ImportDashboardService) ImportDashboard(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error) {
|
||||
var dashboard *models.Dashboard
|
||||
if req.PluginId != "" {
|
||||
var err error
|
||||
if dashboard, err = s.pluginDashboardManager.LoadPluginDashboard(ctx, req.PluginId, req.Path); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
} else {
|
||||
dashboard = models.NewDashboardFromJson(req.Dashboard)
|
||||
}
|
||||
|
||||
evaluator := utils.NewDashTemplateEvaluator(dashboard.Data, req.Inputs)
|
||||
generatedDash, err := evaluator.Eval()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
saveCmd := models.SaveDashboardCommand{
|
||||
Dashboard: generatedDash,
|
||||
OrgId: req.User.OrgId,
|
||||
UserId: req.User.UserId,
|
||||
Overwrite: req.Overwrite,
|
||||
PluginId: req.PluginId,
|
||||
FolderId: req.FolderId,
|
||||
}
|
||||
|
||||
dto := &dashboards.SaveDashboardDTO{
|
||||
OrgId: saveCmd.OrgId,
|
||||
Dashboard: saveCmd.GetDashboardModel(),
|
||||
Overwrite: saveCmd.Overwrite,
|
||||
User: req.User,
|
||||
}
|
||||
|
||||
savedDash, err := s.dashboardService.ImportDashboard(ctx, dto)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = s.libraryPanelService.ImportLibraryPanelsForDashboard(ctx, req.User, savedDash, req.FolderId)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
err = s.libraryPanelService.ConnectLibraryPanelsForDashboard(ctx, req.User, dashboard)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &dashboardimport.ImportDashboardResponse{
|
||||
UID: savedDash.Uid,
|
||||
PluginId: req.PluginId,
|
||||
Title: savedDash.Title,
|
||||
Path: req.Path,
|
||||
Revision: savedDash.Data.Get("revision").MustInt64(1),
|
||||
FolderId: savedDash.FolderId,
|
||||
ImportedUri: "db/" + savedDash.Slug,
|
||||
ImportedUrl: savedDash.GetUrl(),
|
||||
ImportedRevision: dashboard.Data.Get("revision").MustInt64(1),
|
||||
Imported: true,
|
||||
DashboardId: savedDash.Id,
|
||||
Slug: savedDash.Slug,
|
||||
}, nil
|
||||
}
|
||||
@@ -0,0 +1,201 @@
|
||||
package service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"io/ioutil"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"github.com/grafana/grafana/pkg/components/simplejson"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
"github.com/grafana/grafana/pkg/plugins"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/grafana/grafana/pkg/services/dashboards"
|
||||
"github.com/grafana/grafana/pkg/services/librarypanels"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestImportDashboardService(t *testing.T) {
|
||||
t.Run("When importing a plugin dashboard should save dashboard and sync library panels", func(t *testing.T) {
|
||||
pluginDashboardManager := &pluginDashboardManagerMock{
|
||||
loadPluginDashboardFunc: loadTestDashboard,
|
||||
}
|
||||
|
||||
var importDashboardArg *dashboards.SaveDashboardDTO
|
||||
dashboardService := &dashboardServiceMock{
|
||||
importDashboardFunc: func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
|
||||
importDashboardArg = dto
|
||||
return &models.Dashboard{
|
||||
Id: 4,
|
||||
Uid: dto.Dashboard.Uid,
|
||||
Slug: dto.Dashboard.Slug,
|
||||
OrgId: 3,
|
||||
Version: dto.Dashboard.Version,
|
||||
PluginId: "prometheus",
|
||||
FolderId: dto.Dashboard.FolderId,
|
||||
Title: dto.Dashboard.Title,
|
||||
Data: dto.Dashboard.Data,
|
||||
}, nil
|
||||
},
|
||||
}
|
||||
|
||||
importLibraryPanelsForDashboard := false
|
||||
connectLibraryPanelsForDashboardCalled := false
|
||||
libraryPanelService := &libraryPanelServiceMock{
|
||||
importLibraryPanelsForDashboardFunc: func(ctx context.Context, signedInUser *models.SignedInUser, dash *models.Dashboard, folderID int64) error {
|
||||
importLibraryPanelsForDashboard = true
|
||||
return nil
|
||||
},
|
||||
connectLibraryPanelsForDashboardFunc: func(ctx context.Context, signedInUser *models.SignedInUser, dash *models.Dashboard) error {
|
||||
connectLibraryPanelsForDashboardCalled = true
|
||||
return nil
|
||||
},
|
||||
}
|
||||
s := &ImportDashboardService{
|
||||
pluginDashboardManager: pluginDashboardManager,
|
||||
dashboardService: dashboardService,
|
||||
libraryPanelService: libraryPanelService,
|
||||
}
|
||||
|
||||
req := &dashboardimport.ImportDashboardRequest{
|
||||
PluginId: "prometheus",
|
||||
Path: "dashboard.json",
|
||||
Inputs: []dashboardimport.ImportDashboardInput{
|
||||
{Name: "*", Type: "datasource", Value: "prom"},
|
||||
},
|
||||
User: &models.SignedInUser{UserId: 2, OrgRole: models.ROLE_ADMIN, OrgId: 3},
|
||||
FolderId: 5,
|
||||
}
|
||||
resp, err := s.ImportDashboard(context.Background(), req)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, resp)
|
||||
require.Equal(t, "UDdpyzz7z", resp.UID)
|
||||
|
||||
require.NotNil(t, importDashboardArg)
|
||||
require.Equal(t, int64(3), importDashboardArg.OrgId)
|
||||
require.Equal(t, int64(2), importDashboardArg.User.UserId)
|
||||
require.Equal(t, "prometheus", importDashboardArg.Dashboard.PluginId)
|
||||
require.Equal(t, int64(5), importDashboardArg.Dashboard.FolderId)
|
||||
|
||||
panel := importDashboardArg.Dashboard.Data.Get("panels").GetIndex(0)
|
||||
require.Equal(t, "prom", panel.Get("datasource").MustString())
|
||||
|
||||
require.True(t, importLibraryPanelsForDashboard)
|
||||
require.True(t, connectLibraryPanelsForDashboardCalled)
|
||||
})
|
||||
|
||||
t.Run("When importing a non-plugin dashboard should save dashboard and sync library panels", func(t *testing.T) {
|
||||
var importDashboardArg *dashboards.SaveDashboardDTO
|
||||
dashboardService := &dashboardServiceMock{
|
||||
importDashboardFunc: func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
|
||||
importDashboardArg = dto
|
||||
return &models.Dashboard{
|
||||
Id: 4,
|
||||
Uid: dto.Dashboard.Uid,
|
||||
Slug: dto.Dashboard.Slug,
|
||||
OrgId: 3,
|
||||
Version: dto.Dashboard.Version,
|
||||
PluginId: "prometheus",
|
||||
FolderId: dto.Dashboard.FolderId,
|
||||
Title: dto.Dashboard.Title,
|
||||
Data: dto.Dashboard.Data,
|
||||
}, nil
|
||||
},
|
||||
}
|
||||
libraryPanelService := &libraryPanelServiceMock{}
|
||||
s := &ImportDashboardService{
|
||||
dashboardService: dashboardService,
|
||||
libraryPanelService: libraryPanelService,
|
||||
}
|
||||
|
||||
dash, err := loadTestDashboard(context.Background(), "", "dashboard.json")
|
||||
require.NoError(t, err)
|
||||
|
||||
req := &dashboardimport.ImportDashboardRequest{
|
||||
Dashboard: dash.Data,
|
||||
Path: "plugin_dashboard.json",
|
||||
Inputs: []dashboardimport.ImportDashboardInput{
|
||||
{Name: "*", Type: "datasource", Value: "prom"},
|
||||
},
|
||||
User: &models.SignedInUser{UserId: 2, OrgRole: models.ROLE_ADMIN, OrgId: 3},
|
||||
FolderId: 5,
|
||||
}
|
||||
resp, err := s.ImportDashboard(context.Background(), req)
|
||||
require.NoError(t, err)
|
||||
require.NotNil(t, resp)
|
||||
require.Equal(t, "UDdpyzz7z", resp.UID)
|
||||
|
||||
require.NotNil(t, importDashboardArg)
|
||||
require.Equal(t, int64(3), importDashboardArg.OrgId)
|
||||
require.Equal(t, int64(2), importDashboardArg.User.UserId)
|
||||
require.Equal(t, "", importDashboardArg.Dashboard.PluginId)
|
||||
require.Equal(t, int64(5), importDashboardArg.Dashboard.FolderId)
|
||||
|
||||
panel := importDashboardArg.Dashboard.Data.Get("panels").GetIndex(0)
|
||||
require.Equal(t, "prom", panel.Get("datasource").MustString())
|
||||
})
|
||||
}
|
||||
|
||||
func loadTestDashboard(ctx context.Context, pluginID, path string) (*models.Dashboard, error) {
|
||||
// It's safe to ignore gosec warning G304 since this is a test and arguments comes from test configuration.
|
||||
// nolint:gosec
|
||||
bytes, err := ioutil.ReadFile(filepath.Join("testdata", path))
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
dashboardJSON, err := simplejson.NewJson(bytes)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return models.NewDashboardFromJson(dashboardJSON), nil
|
||||
}
|
||||
|
||||
type pluginDashboardManagerMock struct {
|
||||
plugins.PluginDashboardManager
|
||||
loadPluginDashboardFunc func(ctx context.Context, pluginID, path string) (*models.Dashboard, error)
|
||||
}
|
||||
|
||||
func (m *pluginDashboardManagerMock) LoadPluginDashboard(ctx context.Context, pluginID, path string) (*models.Dashboard, error) {
|
||||
if m.loadPluginDashboardFunc != nil {
|
||||
return m.loadPluginDashboardFunc(ctx, pluginID, path)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type dashboardServiceMock struct {
|
||||
dashboards.DashboardService
|
||||
importDashboardFunc func(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error)
|
||||
}
|
||||
|
||||
func (s *dashboardServiceMock) ImportDashboard(ctx context.Context, dto *dashboards.SaveDashboardDTO) (*models.Dashboard, error) {
|
||||
if s.importDashboardFunc != nil {
|
||||
return s.importDashboardFunc(ctx, dto)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type libraryPanelServiceMock struct {
|
||||
librarypanels.Service
|
||||
connectLibraryPanelsForDashboardFunc func(ctx context.Context, signedInUser *models.SignedInUser, dash *models.Dashboard) error
|
||||
importLibraryPanelsForDashboardFunc func(ctx context.Context, signedInUser *models.SignedInUser, dash *models.Dashboard, folderID int64) error
|
||||
}
|
||||
|
||||
func (s *libraryPanelServiceMock) ConnectLibraryPanelsForDashboard(ctx context.Context, signedInUser *models.SignedInUser, dash *models.Dashboard) error {
|
||||
if s.connectLibraryPanelsForDashboardFunc != nil {
|
||||
return s.connectLibraryPanelsForDashboardFunc(ctx, signedInUser, dash)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *libraryPanelServiceMock) ImportLibraryPanelsForDashboard(ctx context.Context, signedInUser *models.SignedInUser, dash *models.Dashboard, folderID int64) error {
|
||||
if s.importLibraryPanelsForDashboardFunc != nil {
|
||||
return s.importLibraryPanelsForDashboardFunc(ctx, signedInUser, dash, folderID)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,220 @@
|
||||
{
|
||||
"__inputs": [
|
||||
{
|
||||
"name": "DS_GDEV-PROMETHEUS",
|
||||
"label": "gdev-prometheus",
|
||||
"description": "",
|
||||
"type": "datasource",
|
||||
"pluginId": "prometheus",
|
||||
"pluginName": "Prometheus"
|
||||
}
|
||||
],
|
||||
"__requires": [
|
||||
{
|
||||
"type": "grafana",
|
||||
"id": "grafana",
|
||||
"name": "Grafana",
|
||||
"version": "8.1.0-pre"
|
||||
},
|
||||
{
|
||||
"type": "datasource",
|
||||
"id": "prometheus",
|
||||
"name": "Prometheus",
|
||||
"version": "1.0.0"
|
||||
},
|
||||
{
|
||||
"type": "panel",
|
||||
"id": "stat",
|
||||
"name": "Stat",
|
||||
"version": ""
|
||||
},
|
||||
{
|
||||
"type": "panel",
|
||||
"id": "timeseries",
|
||||
"name": "Time series",
|
||||
"version": ""
|
||||
}
|
||||
],
|
||||
"annotations": {
|
||||
"list": [
|
||||
{
|
||||
"builtIn": 1,
|
||||
"datasource": "-- Grafana --",
|
||||
"enable": true,
|
||||
"hide": true,
|
||||
"iconColor": "rgba(0, 211, 255, 1)",
|
||||
"name": "Annotations & Alerts",
|
||||
"type": "dashboard"
|
||||
}
|
||||
]
|
||||
},
|
||||
"editable": true,
|
||||
"gnetId": null,
|
||||
"graphTooltip": 1,
|
||||
"id": null,
|
||||
"links": [
|
||||
{
|
||||
"icon": "info",
|
||||
"tags": [],
|
||||
"targetBlank": true,
|
||||
"title": "Grafana Docs",
|
||||
"tooltip": "",
|
||||
"type": "link",
|
||||
"url": "https://grafana.com/docs/grafana/latest/"
|
||||
},
|
||||
{
|
||||
"icon": "info",
|
||||
"tags": [],
|
||||
"targetBlank": true,
|
||||
"title": "Prometheus Docs",
|
||||
"type": "link",
|
||||
"url": "http://prometheus.io/docs/introduction/overview/"
|
||||
}
|
||||
],
|
||||
"panels": [
|
||||
{
|
||||
"datasource": "${DS_GDEV-PROMETHEUS}",
|
||||
"fieldConfig": {
|
||||
"defaults": {
|
||||
"color": {
|
||||
"mode": "palette-classic"
|
||||
},
|
||||
"custom": {
|
||||
"axisLabel": "",
|
||||
"axisPlacement": "auto",
|
||||
"barAlignment": 0,
|
||||
"drawStyle": "line",
|
||||
"fillOpacity": 0,
|
||||
"gradientMode": "none",
|
||||
"hideFrom": {
|
||||
"legend": false,
|
||||
"tooltip": false,
|
||||
"viz": false
|
||||
},
|
||||
"lineInterpolation": "linear",
|
||||
"lineWidth": 1,
|
||||
"pointSize": 5,
|
||||
"scaleDistribution": {
|
||||
"type": "linear"
|
||||
},
|
||||
"showPoints": "never",
|
||||
"spanNulls": false,
|
||||
"stacking": {
|
||||
"group": "A",
|
||||
"mode": "none"
|
||||
},
|
||||
"thresholdsStyle": {
|
||||
"mode": "off"
|
||||
}
|
||||
},
|
||||
"links": [],
|
||||
"mappings": [],
|
||||
"min": 0,
|
||||
"thresholds": {
|
||||
"mode": "absolute",
|
||||
"steps": [
|
||||
{
|
||||
"color": "green",
|
||||
"value": null
|
||||
},
|
||||
{
|
||||
"color": "red",
|
||||
"value": 80
|
||||
}
|
||||
]
|
||||
},
|
||||
"unit": "short"
|
||||
},
|
||||
"overrides": [
|
||||
{
|
||||
"matcher": {
|
||||
"id": "byName",
|
||||
"options": "prometheus"
|
||||
},
|
||||
"properties": [
|
||||
{
|
||||
"id": "color",
|
||||
"value": {
|
||||
"fixedColor": "#C15C17",
|
||||
"mode": "fixed"
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
"matcher": {
|
||||
"id": "byName",
|
||||
"options": "{instance=\"localhost:9090\",job=\"prometheus\"}"
|
||||
},
|
||||
"properties": [
|
||||
{
|
||||
"id": "color",
|
||||
"value": {
|
||||
"fixedColor": "#CCA300",
|
||||
"mode": "fixed"
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
},
|
||||
"gridPos": {
|
||||
"h": 6,
|
||||
"w": 6,
|
||||
"x": 0,
|
||||
"y": 0
|
||||
},
|
||||
"id": 3,
|
||||
"links": [],
|
||||
"options": {
|
||||
"legend": {
|
||||
"calcs": [],
|
||||
"displayMode": "list",
|
||||
"placement": "bottom"
|
||||
},
|
||||
"tooltip": {
|
||||
"mode": "single"
|
||||
}
|
||||
},
|
||||
"pluginVersion": "8.1.0-pre",
|
||||
"targets": [
|
||||
{
|
||||
"expr": "sum(irate(prometheus_tsdb_head_samples_appended_total{job=\"prometheus\"}[5m]))",
|
||||
"format": "time_series",
|
||||
"hide": false,
|
||||
"interval": "",
|
||||
"intervalFactor": 2,
|
||||
"legendFormat": "samples",
|
||||
"metric": "",
|
||||
"refId": "A",
|
||||
"step": 20
|
||||
}
|
||||
],
|
||||
"timeFrom": null,
|
||||
"timeShift": null,
|
||||
"title": "Samples Appended",
|
||||
"type": "timeseries"
|
||||
}
|
||||
],
|
||||
"refresh": "1m",
|
||||
"revision": "1.0",
|
||||
"schemaVersion": 30,
|
||||
"style": "dark",
|
||||
"tags": ["prometheus"],
|
||||
"templating": {
|
||||
"list": []
|
||||
},
|
||||
"time": {
|
||||
"from": "now-1h",
|
||||
"to": "now"
|
||||
},
|
||||
"timepicker": {
|
||||
"now": true,
|
||||
"refresh_intervals": ["5s", "10s", "30s", "1m", "5m", "15m", "30m", "1h", "2h", "1d"],
|
||||
"time_options": ["5m", "15m", "1h", "6h", "12h", "24h", "2d", "7d", "30d"]
|
||||
},
|
||||
"timezone": "browser",
|
||||
"title": "Prometheus 2.0 Stats",
|
||||
"uid": "UDdpyzz7z",
|
||||
"version": 1
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
package utils
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"regexp"
|
||||
|
||||
"github.com/grafana/grafana/pkg/components/simplejson"
|
||||
"github.com/grafana/grafana/pkg/expr"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
)
|
||||
|
||||
var varRegex = regexp.MustCompile(`(\$\{.+?\})`)
|
||||
|
||||
type DashboardInputMissingError struct {
|
||||
VariableName string
|
||||
}
|
||||
|
||||
func (e DashboardInputMissingError) Error() string {
|
||||
return fmt.Sprintf("Dashboard input variable: %v missing from import command", e.VariableName)
|
||||
}
|
||||
|
||||
type DashTemplateEvaluator struct {
|
||||
template *simplejson.Json
|
||||
inputs []dashboardimport.ImportDashboardInput
|
||||
variables map[string]string
|
||||
result *simplejson.Json
|
||||
}
|
||||
|
||||
func NewDashTemplateEvaluator(template *simplejson.Json, inputs []dashboardimport.ImportDashboardInput) *DashTemplateEvaluator {
|
||||
return &DashTemplateEvaluator{
|
||||
template: template,
|
||||
inputs: inputs,
|
||||
}
|
||||
}
|
||||
|
||||
func (e *DashTemplateEvaluator) findInput(varName string, varType string) *dashboardimport.ImportDashboardInput {
|
||||
for _, input := range e.inputs {
|
||||
if varType == input.Type && (input.Name == varName || input.Name == "*") {
|
||||
return &input
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (e *DashTemplateEvaluator) Eval() (*simplejson.Json, error) {
|
||||
e.result = simplejson.New()
|
||||
e.variables = make(map[string]string)
|
||||
|
||||
// check that we have all inputs we need
|
||||
for _, inputDef := range e.template.Get("__inputs").MustArray() {
|
||||
inputDefJson := simplejson.NewFromAny(inputDef)
|
||||
inputName := inputDefJson.Get("name").MustString()
|
||||
inputType := inputDefJson.Get("type").MustString()
|
||||
input := e.findInput(inputName, inputType)
|
||||
|
||||
// force expressions value to `__expr__`
|
||||
if inputDefJson.Get("pluginId").MustString() == expr.DatasourceType {
|
||||
input = &dashboardimport.ImportDashboardInput{
|
||||
Value: expr.DatasourceType,
|
||||
}
|
||||
}
|
||||
|
||||
if input == nil {
|
||||
return nil, &DashboardInputMissingError{VariableName: inputName}
|
||||
}
|
||||
|
||||
e.variables["${"+inputName+"}"] = input.Value
|
||||
}
|
||||
|
||||
return simplejson.NewFromAny(e.evalObject(e.template)), nil
|
||||
}
|
||||
|
||||
func (e *DashTemplateEvaluator) evalValue(source *simplejson.Json) interface{} {
|
||||
sourceValue := source.Interface()
|
||||
|
||||
switch v := sourceValue.(type) {
|
||||
case string:
|
||||
interpolated := varRegex.ReplaceAllStringFunc(v, func(match string) string {
|
||||
replacement, exists := e.variables[match]
|
||||
if exists {
|
||||
return replacement
|
||||
}
|
||||
return match
|
||||
})
|
||||
return interpolated
|
||||
case bool:
|
||||
return v
|
||||
case json.Number:
|
||||
return v
|
||||
case map[string]interface{}:
|
||||
return e.evalObject(source)
|
||||
case []interface{}:
|
||||
array := make([]interface{}, 0)
|
||||
for _, item := range v {
|
||||
array = append(array, e.evalValue(simplejson.NewFromAny(item)))
|
||||
}
|
||||
return array
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (e *DashTemplateEvaluator) evalObject(source *simplejson.Json) interface{} {
|
||||
result := make(map[string]interface{})
|
||||
|
||||
for key, value := range source.MustMap() {
|
||||
if key == "__inputs" {
|
||||
continue
|
||||
}
|
||||
result[key] = e.evalValue(simplejson.NewFromAny(value))
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package utils
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"github.com/grafana/grafana/pkg/components/simplejson"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestDashTemplateEvaluator(t *testing.T) {
|
||||
template, err := simplejson.NewJson([]byte(`{
|
||||
"__inputs": [
|
||||
{
|
||||
"name": "DS_NAME",
|
||||
"type": "datasource"
|
||||
}
|
||||
],
|
||||
"test": {
|
||||
"prop": "${DS_NAME}_${DS_NAME}"
|
||||
}
|
||||
}`))
|
||||
require.NoError(t, err)
|
||||
|
||||
evaluator := &DashTemplateEvaluator{
|
||||
template: template,
|
||||
inputs: []dashboardimport.ImportDashboardInput{
|
||||
{Name: "*", Type: "datasource", Value: "my-server"},
|
||||
},
|
||||
}
|
||||
|
||||
res, err := evaluator.Eval()
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Equal(t, "my-server_my-server", res.GetPath("test", "prop").MustString())
|
||||
|
||||
inputs := res.Get("__inputs")
|
||||
require.Nil(t, inputs.Interface())
|
||||
}
|
||||
@@ -0,0 +1,171 @@
|
||||
package plugindashboards
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/grafana/grafana/pkg/bus"
|
||||
"github.com/grafana/grafana/pkg/infra/log"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
"github.com/grafana/grafana/pkg/plugins"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/grafana/grafana/pkg/services/sqlstore"
|
||||
)
|
||||
|
||||
type pluginSettingsStore interface {
|
||||
GetPluginSettings(ctx context.Context, orgID int64) ([]*models.PluginSettingInfoDTO, error)
|
||||
}
|
||||
|
||||
func ProvideService(sqlStore *sqlstore.SQLStore, bus bus.Bus, pluginStore plugins.Store,
|
||||
pluginDashboardManager plugins.PluginDashboardManager, dashboardImportService dashboardimport.Service) *Service {
|
||||
s := new(sqlStore, bus, pluginStore, pluginDashboardManager, dashboardImportService)
|
||||
s.updateAppDashboards()
|
||||
return s
|
||||
}
|
||||
|
||||
func new(pluginSettingsStore pluginSettingsStore, bus bus.Bus, pluginStore plugins.Store,
|
||||
pluginDashboardManager plugins.PluginDashboardManager, dashboardImportService dashboardimport.Service) *Service {
|
||||
s := &Service{
|
||||
pluginSettingsStore: pluginSettingsStore,
|
||||
bus: bus,
|
||||
pluginStore: pluginStore,
|
||||
pluginDashboardManager: pluginDashboardManager,
|
||||
dashboardImportService: dashboardImportService,
|
||||
logger: log.New("plugindashboards"),
|
||||
}
|
||||
bus.AddEventListener(s.handlePluginStateChanged)
|
||||
|
||||
return s
|
||||
}
|
||||
|
||||
type Service struct {
|
||||
pluginSettingsStore pluginSettingsStore
|
||||
bus bus.Bus
|
||||
pluginStore plugins.Store
|
||||
pluginDashboardManager plugins.PluginDashboardManager
|
||||
dashboardImportService dashboardimport.Service
|
||||
logger log.Logger
|
||||
}
|
||||
|
||||
func (s *Service) updateAppDashboards() {
|
||||
s.logger.Debug("Looking for app dashboard updates")
|
||||
|
||||
pluginSettings, err := s.pluginSettingsStore.GetPluginSettings(context.Background(), 0)
|
||||
if err != nil {
|
||||
s.logger.Error("Failed to get all plugin settings", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
for _, pluginSetting := range pluginSettings {
|
||||
// ignore disabled plugins
|
||||
if !pluginSetting.Enabled {
|
||||
continue
|
||||
}
|
||||
|
||||
if pluginDef, exists := s.pluginStore.Plugin(context.Background(), pluginSetting.PluginId); exists {
|
||||
if pluginDef.Info.Version != pluginSetting.PluginVersion {
|
||||
s.syncPluginDashboards(context.Background(), pluginDef, pluginSetting.OrgId)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) syncPluginDashboards(ctx context.Context, plugin plugins.PluginDTO, orgID int64) {
|
||||
s.logger.Info("Syncing plugin dashboards to DB", "pluginId", plugin.ID)
|
||||
|
||||
// Get plugin dashboards
|
||||
dashboards, err := s.pluginDashboardManager.GetPluginDashboards(ctx, orgID, plugin.ID)
|
||||
if err != nil {
|
||||
s.logger.Error("Failed to load app dashboards", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
// Update dashboards with updated revisions
|
||||
for _, dash := range dashboards {
|
||||
// remove removed ones
|
||||
if dash.Removed {
|
||||
s.logger.Info("Deleting plugin dashboard", "pluginId", plugin.ID, "dashboard", dash.Slug)
|
||||
|
||||
deleteCmd := models.DeleteDashboardCommand{OrgId: orgID, Id: dash.DashboardId}
|
||||
if err := s.bus.Dispatch(ctx, &deleteCmd); err != nil {
|
||||
s.logger.Error("Failed to auto update app dashboard", "pluginId", plugin.ID, "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
continue
|
||||
}
|
||||
|
||||
// update updated ones
|
||||
if dash.ImportedRevision != dash.Revision {
|
||||
if err := s.autoUpdateAppDashboard(ctx, dash, orgID); err != nil {
|
||||
s.logger.Error("Failed to auto update app dashboard", "pluginId", plugin.ID, "error", err)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// update version in plugin_setting table to mark that we have processed the update
|
||||
query := models.GetPluginSettingByIdQuery{PluginId: plugin.ID, OrgId: orgID}
|
||||
if err := s.bus.Dispatch(ctx, &query); err != nil {
|
||||
s.logger.Error("Failed to read plugin setting by ID", "error", err)
|
||||
return
|
||||
}
|
||||
|
||||
appSetting := query.Result
|
||||
cmd := models.UpdatePluginSettingVersionCmd{
|
||||
OrgId: appSetting.OrgId,
|
||||
PluginId: appSetting.PluginId,
|
||||
PluginVersion: plugin.Info.Version,
|
||||
}
|
||||
|
||||
if err := s.bus.Dispatch(ctx, &cmd); err != nil {
|
||||
s.logger.Error("Failed to update plugin setting version", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
func (s *Service) handlePluginStateChanged(ctx context.Context, event *models.PluginStateChangedEvent) error {
|
||||
s.logger.Info("Plugin state changed", "pluginId", event.PluginId, "enabled", event.Enabled)
|
||||
|
||||
if event.Enabled {
|
||||
p, exists := s.pluginStore.Plugin(ctx, event.PluginId)
|
||||
if !exists {
|
||||
return fmt.Errorf("plugin %s not found. Could not sync plugin dashboards", event.PluginId)
|
||||
}
|
||||
|
||||
s.syncPluginDashboards(ctx, p, event.OrgId)
|
||||
} else {
|
||||
query := models.GetDashboardsByPluginIdQuery{PluginId: event.PluginId, OrgId: event.OrgId}
|
||||
if err := s.bus.Dispatch(ctx, &query); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
for _, dash := range query.Result {
|
||||
s.logger.Info("Deleting plugin dashboard", "pluginId", event.PluginId, "dashboard", dash.Slug)
|
||||
deleteCmd := models.DeleteDashboardCommand{OrgId: dash.OrgId, Id: dash.Id}
|
||||
if err := s.bus.Dispatch(ctx, &deleteCmd); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) autoUpdateAppDashboard(ctx context.Context, pluginDashInfo *plugins.PluginDashboardInfoDTO, orgID int64) error {
|
||||
dash, err := s.pluginDashboardManager.LoadPluginDashboard(ctx, pluginDashInfo.PluginId, pluginDashInfo.Path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
s.logger.Info("Auto updating App dashboard", "dashboard", dash.Title, "newRev",
|
||||
pluginDashInfo.Revision, "oldRev", pluginDashInfo.ImportedRevision)
|
||||
_, err = s.dashboardImportService.ImportDashboard(ctx, &dashboardimport.ImportDashboardRequest{
|
||||
PluginId: pluginDashInfo.PluginId,
|
||||
User: &models.SignedInUser{UserId: 0, OrgRole: models.ROLE_ADMIN, OrgId: orgID},
|
||||
Path: pluginDashInfo.Path,
|
||||
FolderId: 0,
|
||||
Dashboard: dash.Data,
|
||||
Overwrite: true,
|
||||
Inputs: nil,
|
||||
})
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,575 @@
|
||||
package plugindashboards
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"testing"
|
||||
|
||||
"github.com/grafana/grafana/pkg/bus"
|
||||
"github.com/grafana/grafana/pkg/models"
|
||||
"github.com/grafana/grafana/pkg/plugins"
|
||||
"github.com/grafana/grafana/pkg/services/dashboardimport"
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestService(t *testing.T) {
|
||||
t.Run("updateAppDashboards", func(t *testing.T) {
|
||||
scenario(t, "Without any stored plugin settings shouldn't delete/import any dashboards",
|
||||
scenarioInput{}, func(ctx *scenarioContext) {
|
||||
ctx.s.updateAppDashboards()
|
||||
|
||||
require.Len(t, ctx.getPluginSettingsArgs, 1)
|
||||
require.Equal(t, int64(0), ctx.getPluginSettingsArgs[0])
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
require.Empty(t, ctx.importDashboardArgs)
|
||||
})
|
||||
|
||||
scenario(t, "Without any stored enabled plugin shouldn't delete/import any dashboards",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: false,
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Path: "dashboard.json",
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
ctx.s.updateAppDashboards()
|
||||
|
||||
require.NotEmpty(t, ctx.getPluginSettingsArgs)
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
require.Empty(t, ctx.importDashboardArgs)
|
||||
})
|
||||
|
||||
scenario(t, "With stored enabled plugin, but not installed shouldn't delete/import any dashboards",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: true,
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Path: "dashboard.json",
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
ctx.s.updateAppDashboards()
|
||||
|
||||
require.NotEmpty(t, ctx.getPluginSettingsArgs)
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
require.Empty(t, ctx.importDashboardArgs)
|
||||
})
|
||||
|
||||
scenario(t, "With stored enabled plugin and installed with same version shouldn't delete/import any dashboards",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: true,
|
||||
PluginVersion: "1.0.0",
|
||||
},
|
||||
},
|
||||
installedPlugins: []plugins.PluginDTO{
|
||||
{
|
||||
JSONData: plugins.JSONData{
|
||||
Info: plugins.Info{
|
||||
Version: "1.0.0",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Path: "dashboard.json",
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
ctx.s.updateAppDashboards()
|
||||
|
||||
require.NotEmpty(t, ctx.getPluginSettingsArgs)
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
require.Empty(t, ctx.importDashboardArgs)
|
||||
})
|
||||
|
||||
scenario(t, "With stored enabled plugin and installed with different versions, but no dashboard updates shouldn't delete/import dashboards",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: true,
|
||||
PluginVersion: "1.0.0",
|
||||
},
|
||||
},
|
||||
installedPlugins: []plugins.PluginDTO{
|
||||
{
|
||||
JSONData: plugins.JSONData{
|
||||
Info: plugins.Info{
|
||||
Version: "1.0.1",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Path: "dashboard.json",
|
||||
Removed: false,
|
||||
Revision: 1,
|
||||
ImportedRevision: 1,
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
ctx.s.updateAppDashboards()
|
||||
|
||||
require.NotEmpty(t, ctx.getPluginSettingsArgs)
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
require.Empty(t, ctx.importDashboardArgs)
|
||||
})
|
||||
|
||||
scenario(t, "With stored enabled plugin and installed with different versions and with dashboard updates should delete/import dashboards",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: true,
|
||||
PluginVersion: "1.0.0",
|
||||
OrgId: 2,
|
||||
},
|
||||
},
|
||||
installedPlugins: []plugins.PluginDTO{
|
||||
{
|
||||
JSONData: plugins.JSONData{
|
||||
ID: "test",
|
||||
Info: plugins.Info{
|
||||
Version: "1.0.1",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
DashboardId: 3,
|
||||
PluginId: "test",
|
||||
Path: "removed.json",
|
||||
Removed: true,
|
||||
},
|
||||
{
|
||||
DashboardId: 4,
|
||||
PluginId: "test",
|
||||
Path: "not-updated.json",
|
||||
},
|
||||
{
|
||||
DashboardId: 5,
|
||||
PluginId: "test",
|
||||
Path: "updated.json",
|
||||
Revision: 1,
|
||||
ImportedRevision: 2,
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
ctx.s.updateAppDashboards()
|
||||
|
||||
require.NotEmpty(t, ctx.getPluginSettingsArgs)
|
||||
require.Len(t, ctx.deleteDashboardArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.deleteDashboardArgs[0].OrgId)
|
||||
require.Equal(t, int64(3), ctx.deleteDashboardArgs[0].Id)
|
||||
|
||||
require.Len(t, ctx.importDashboardArgs, 1)
|
||||
require.Equal(t, "test", ctx.importDashboardArgs[0].PluginId)
|
||||
require.Equal(t, "updated.json", ctx.importDashboardArgs[0].Path)
|
||||
require.Equal(t, int64(2), ctx.importDashboardArgs[0].User.OrgId)
|
||||
require.Equal(t, models.ROLE_ADMIN, ctx.importDashboardArgs[0].User.OrgRole)
|
||||
require.Equal(t, int64(0), ctx.importDashboardArgs[0].FolderId)
|
||||
require.True(t, ctx.importDashboardArgs[0].Overwrite)
|
||||
|
||||
require.Len(t, ctx.getPluginSettingsByIdArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.getPluginSettingsByIdArgs[0].OrgId)
|
||||
require.Equal(t, "test", ctx.getPluginSettingsByIdArgs[0].PluginId)
|
||||
|
||||
require.Len(t, ctx.updatePluginSettingVersionArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.updatePluginSettingVersionArgs[0].OrgId)
|
||||
require.Equal(t, "test", ctx.updatePluginSettingVersionArgs[0].PluginId)
|
||||
require.Equal(t, "1.0.1", ctx.updatePluginSettingVersionArgs[0].PluginVersion)
|
||||
})
|
||||
})
|
||||
|
||||
t.Run("handlePluginStateChanged", func(t *testing.T) {
|
||||
scenario(t, "When app plugin is disabled that doesn't have any imported dashboards shouldn't delete any",
|
||||
scenarioInput{}, func(ctx *scenarioContext) {
|
||||
err := ctx.bus.Publish(context.Background(), &models.PluginStateChangedEvent{
|
||||
PluginId: "test",
|
||||
OrgId: 2,
|
||||
Enabled: false,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Len(t, ctx.getDashboardsByPluginIdQueryArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.getDashboardsByPluginIdQueryArgs[0].OrgId)
|
||||
require.Equal(t, "test", ctx.getDashboardsByPluginIdQueryArgs[0].PluginId)
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
})
|
||||
})
|
||||
|
||||
scenario(t, "When app plugin is disabled that have imported dashboards should delete them",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: true,
|
||||
OrgId: 2,
|
||||
},
|
||||
},
|
||||
installedPlugins: []plugins.PluginDTO{
|
||||
{
|
||||
JSONData: plugins.JSONData{
|
||||
ID: "test",
|
||||
},
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
DashboardId: 3,
|
||||
PluginId: "test",
|
||||
Path: "dashboard1.json",
|
||||
},
|
||||
{
|
||||
DashboardId: 4,
|
||||
PluginId: "test",
|
||||
Path: "dashboard2.json",
|
||||
},
|
||||
{
|
||||
DashboardId: 5,
|
||||
PluginId: "test",
|
||||
Path: "dashboard3.json",
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
err := ctx.bus.Publish(context.Background(), &models.PluginStateChangedEvent{
|
||||
PluginId: "test",
|
||||
OrgId: 2,
|
||||
Enabled: false,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Len(t, ctx.getDashboardsByPluginIdQueryArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.getDashboardsByPluginIdQueryArgs[0].OrgId)
|
||||
require.Equal(t, "test", ctx.getDashboardsByPluginIdQueryArgs[0].PluginId)
|
||||
require.Len(t, ctx.deleteDashboardArgs, 3)
|
||||
})
|
||||
|
||||
scenario(t, "When app plugin is enabled, stored disabled plugin and with dashboard updates should import dashboards",
|
||||
scenarioInput{
|
||||
storedPluginSettings: []*models.PluginSettingInfoDTO{
|
||||
{
|
||||
PluginId: "test",
|
||||
Enabled: false,
|
||||
OrgId: 2,
|
||||
PluginVersion: "1.0.0",
|
||||
},
|
||||
},
|
||||
installedPlugins: []plugins.PluginDTO{
|
||||
{
|
||||
JSONData: plugins.JSONData{
|
||||
ID: "test",
|
||||
Info: plugins.Info{
|
||||
Version: "1.0.0",
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
pluginDashboards: []*plugins.PluginDashboardInfoDTO{
|
||||
{
|
||||
DashboardId: 3,
|
||||
PluginId: "test",
|
||||
Path: "dashboard1.json",
|
||||
Revision: 1,
|
||||
ImportedRevision: 0,
|
||||
},
|
||||
{
|
||||
DashboardId: 4,
|
||||
PluginId: "test",
|
||||
Path: "dashboard2.json",
|
||||
Revision: 1,
|
||||
ImportedRevision: 0,
|
||||
},
|
||||
{
|
||||
DashboardId: 5,
|
||||
PluginId: "test",
|
||||
Path: "dashboard3.json",
|
||||
Revision: 1,
|
||||
ImportedRevision: 0,
|
||||
},
|
||||
},
|
||||
}, func(ctx *scenarioContext) {
|
||||
err := ctx.bus.Publish(context.Background(), &models.PluginStateChangedEvent{
|
||||
PluginId: "test",
|
||||
OrgId: 2,
|
||||
Enabled: true,
|
||||
})
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Empty(t, ctx.deleteDashboardArgs)
|
||||
|
||||
require.Len(t, ctx.importDashboardArgs, 3)
|
||||
require.Equal(t, "test", ctx.importDashboardArgs[0].PluginId)
|
||||
require.Equal(t, "dashboard1.json", ctx.importDashboardArgs[0].Path)
|
||||
require.Equal(t, int64(2), ctx.importDashboardArgs[0].User.OrgId)
|
||||
require.Equal(t, models.ROLE_ADMIN, ctx.importDashboardArgs[0].User.OrgRole)
|
||||
require.Equal(t, int64(0), ctx.importDashboardArgs[0].FolderId)
|
||||
require.True(t, ctx.importDashboardArgs[0].Overwrite)
|
||||
|
||||
require.Equal(t, "test", ctx.importDashboardArgs[1].PluginId)
|
||||
require.Equal(t, "dashboard2.json", ctx.importDashboardArgs[1].Path)
|
||||
require.Equal(t, int64(2), ctx.importDashboardArgs[1].User.OrgId)
|
||||
require.Equal(t, models.ROLE_ADMIN, ctx.importDashboardArgs[1].User.OrgRole)
|
||||
require.Equal(t, int64(0), ctx.importDashboardArgs[1].FolderId)
|
||||
require.True(t, ctx.importDashboardArgs[1].Overwrite)
|
||||
|
||||
require.Equal(t, "test", ctx.importDashboardArgs[2].PluginId)
|
||||
require.Equal(t, "dashboard3.json", ctx.importDashboardArgs[2].Path)
|
||||
require.Equal(t, int64(2), ctx.importDashboardArgs[2].User.OrgId)
|
||||
require.Equal(t, models.ROLE_ADMIN, ctx.importDashboardArgs[2].User.OrgRole)
|
||||
require.Equal(t, int64(0), ctx.importDashboardArgs[2].FolderId)
|
||||
require.True(t, ctx.importDashboardArgs[2].Overwrite)
|
||||
|
||||
require.Len(t, ctx.getPluginSettingsByIdArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.getPluginSettingsByIdArgs[0].OrgId)
|
||||
require.Equal(t, "test", ctx.getPluginSettingsByIdArgs[0].PluginId)
|
||||
|
||||
require.Len(t, ctx.updatePluginSettingVersionArgs, 1)
|
||||
require.Equal(t, int64(2), ctx.updatePluginSettingVersionArgs[0].OrgId)
|
||||
require.Equal(t, "test", ctx.updatePluginSettingVersionArgs[0].PluginId)
|
||||
require.Equal(t, "1.0.0", ctx.updatePluginSettingVersionArgs[0].PluginVersion)
|
||||
})
|
||||
}
|
||||
|
||||
type pluginSettingsStoreMock struct {
|
||||
getPluginSettingsFunc func(ctx context.Context, orgID int64) ([]*models.PluginSettingInfoDTO, error)
|
||||
}
|
||||
|
||||
func (m *pluginSettingsStoreMock) GetPluginSettings(ctx context.Context, orgID int64) ([]*models.PluginSettingInfoDTO, error) {
|
||||
if m.getPluginSettingsFunc != nil {
|
||||
return m.getPluginSettingsFunc(ctx, orgID)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type pluginStoreMock struct {
|
||||
plugins.Store
|
||||
pluginFunc func(ctx context.Context, pluginID string) (plugins.PluginDTO, bool)
|
||||
}
|
||||
|
||||
func (m *pluginStoreMock) Plugin(ctx context.Context, pluginID string) (plugins.PluginDTO, bool) {
|
||||
if m.pluginFunc != nil {
|
||||
return m.pluginFunc(ctx, pluginID)
|
||||
}
|
||||
|
||||
return plugins.PluginDTO{}, false
|
||||
}
|
||||
|
||||
type pluginDashboardManagerMock struct {
|
||||
plugins.PluginDashboardManager
|
||||
getPluginDashboardsFunc func(ctx context.Context, orgID int64, pluginID string) ([]*plugins.PluginDashboardInfoDTO, error)
|
||||
loadPluginDashboardFunc func(ctx context.Context, pluginID, path string) (*models.Dashboard, error)
|
||||
}
|
||||
|
||||
func (m *pluginDashboardManagerMock) GetPluginDashboards(ctx context.Context, orgID int64, pluginID string) ([]*plugins.PluginDashboardInfoDTO, error) {
|
||||
if m.getPluginDashboardsFunc != nil {
|
||||
return m.getPluginDashboardsFunc(ctx, orgID, pluginID)
|
||||
}
|
||||
|
||||
return []*plugins.PluginDashboardInfoDTO{}, nil
|
||||
}
|
||||
|
||||
func (m *pluginDashboardManagerMock) LoadPluginDashboard(ctx context.Context, pluginID, path string) (*models.Dashboard, error) {
|
||||
if m.loadPluginDashboardFunc != nil {
|
||||
return m.loadPluginDashboardFunc(ctx, pluginID, path)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type importDashboardServiceMock struct {
|
||||
dashboardimport.Service
|
||||
importDashboardFunc func(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error)
|
||||
}
|
||||
|
||||
func (m *importDashboardServiceMock) ImportDashboard(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error) {
|
||||
if m.importDashboardFunc != nil {
|
||||
return m.importDashboardFunc(ctx, req)
|
||||
}
|
||||
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
type scenarioInput struct {
|
||||
storedPluginSettings []*models.PluginSettingInfoDTO
|
||||
installedPlugins []plugins.PluginDTO
|
||||
pluginDashboards []*plugins.PluginDashboardInfoDTO
|
||||
}
|
||||
|
||||
type scenarioContext struct {
|
||||
t *testing.T
|
||||
bus bus.Bus
|
||||
pluginSettingsStore pluginSettingsStore
|
||||
getPluginSettingsArgs []int64
|
||||
pluginStore plugins.Store
|
||||
pluginDashboardManager plugins.PluginDashboardManager
|
||||
importDashboardService dashboardimport.Service
|
||||
importDashboardArgs []*dashboardimport.ImportDashboardRequest
|
||||
deleteDashboardArgs []*models.DeleteDashboardCommand
|
||||
getPluginSettingsByIdArgs []*models.GetPluginSettingByIdQuery
|
||||
updatePluginSettingVersionArgs []*models.UpdatePluginSettingVersionCmd
|
||||
getDashboardsByPluginIdQueryArgs []*models.GetDashboardsByPluginIdQuery
|
||||
s *Service
|
||||
}
|
||||
|
||||
func scenario(t *testing.T, desc string, input scenarioInput, f func(ctx *scenarioContext)) {
|
||||
t.Helper()
|
||||
|
||||
sCtx := &scenarioContext{
|
||||
t: t,
|
||||
bus: bus.New(),
|
||||
getPluginSettingsArgs: []int64{},
|
||||
importDashboardArgs: []*dashboardimport.ImportDashboardRequest{},
|
||||
deleteDashboardArgs: []*models.DeleteDashboardCommand{},
|
||||
getPluginSettingsByIdArgs: []*models.GetPluginSettingByIdQuery{},
|
||||
updatePluginSettingVersionArgs: []*models.UpdatePluginSettingVersionCmd{},
|
||||
getDashboardsByPluginIdQueryArgs: []*models.GetDashboardsByPluginIdQuery{},
|
||||
}
|
||||
|
||||
getPluginSettings := func(_ context.Context, orgID int64) ([]*models.PluginSettingInfoDTO, error) {
|
||||
sCtx.getPluginSettingsArgs = append(sCtx.getPluginSettingsArgs, orgID)
|
||||
return input.storedPluginSettings, nil
|
||||
}
|
||||
|
||||
sCtx.pluginSettingsStore = &pluginSettingsStoreMock{
|
||||
getPluginSettingsFunc: getPluginSettings,
|
||||
}
|
||||
|
||||
getPlugin := func(ctx context.Context, pluginID string) (plugins.PluginDTO, bool) {
|
||||
for _, p := range input.installedPlugins {
|
||||
if p.ID == pluginID {
|
||||
return p, true
|
||||
}
|
||||
}
|
||||
|
||||
return plugins.PluginDTO{}, false
|
||||
}
|
||||
|
||||
sCtx.pluginStore = &pluginStoreMock{
|
||||
pluginFunc: getPlugin,
|
||||
}
|
||||
|
||||
getPluginDashboards := func(ctx context.Context, orgID int64, pluginID string) ([]*plugins.PluginDashboardInfoDTO, error) {
|
||||
dashboards := []*plugins.PluginDashboardInfoDTO{}
|
||||
|
||||
for _, d := range input.pluginDashboards {
|
||||
if d.PluginId == pluginID {
|
||||
dashboards = append(dashboards, d)
|
||||
}
|
||||
}
|
||||
|
||||
return dashboards, nil
|
||||
}
|
||||
|
||||
loadPluginDashboard := func(ctx context.Context, pluginID, path string) (*models.Dashboard, error) {
|
||||
for _, d := range input.pluginDashboards {
|
||||
if d.PluginId == pluginID && path == d.Path {
|
||||
return &models.Dashboard{}, nil
|
||||
}
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("no match for loading plugin dashboard")
|
||||
}
|
||||
|
||||
sCtx.pluginDashboardManager = &pluginDashboardManagerMock{
|
||||
getPluginDashboardsFunc: getPluginDashboards,
|
||||
loadPluginDashboardFunc: loadPluginDashboard,
|
||||
}
|
||||
|
||||
importDashboard := func(ctx context.Context, req *dashboardimport.ImportDashboardRequest) (*dashboardimport.ImportDashboardResponse, error) {
|
||||
sCtx.importDashboardArgs = append(sCtx.importDashboardArgs, req)
|
||||
|
||||
return &dashboardimport.ImportDashboardResponse{
|
||||
PluginId: req.PluginId,
|
||||
}, nil
|
||||
}
|
||||
|
||||
sCtx.importDashboardService = &importDashboardServiceMock{
|
||||
importDashboardFunc: importDashboard,
|
||||
}
|
||||
|
||||
sCtx.bus.AddHandler(func(ctx context.Context, cmd *models.DeleteDashboardCommand) error {
|
||||
sCtx.deleteDashboardArgs = append(sCtx.deleteDashboardArgs, cmd)
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
sCtx.bus.AddHandler(func(ctx context.Context, query *models.GetPluginSettingByIdQuery) error {
|
||||
for _, p := range input.storedPluginSettings {
|
||||
if p.PluginId == query.PluginId {
|
||||
query.Result = &models.PluginSetting{
|
||||
PluginId: p.PluginId,
|
||||
OrgId: p.OrgId,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sCtx.getPluginSettingsByIdArgs = append(sCtx.getPluginSettingsByIdArgs, query)
|
||||
return nil
|
||||
})
|
||||
|
||||
sCtx.bus.AddHandler(func(ctx context.Context, cmd *models.UpdatePluginSettingVersionCmd) error {
|
||||
sCtx.updatePluginSettingVersionArgs = append(sCtx.updatePluginSettingVersionArgs, cmd)
|
||||
return nil
|
||||
})
|
||||
|
||||
sCtx.bus.AddHandler(func(ctx context.Context, query *models.GetDashboardsByPluginIdQuery) error {
|
||||
sCtx.getDashboardsByPluginIdQueryArgs = append(sCtx.getDashboardsByPluginIdQueryArgs, query)
|
||||
dashboards := []*models.Dashboard{}
|
||||
|
||||
var plugin *models.PluginSettingInfoDTO
|
||||
|
||||
for _, p := range input.storedPluginSettings {
|
||||
if p.PluginId == query.PluginId {
|
||||
plugin = p
|
||||
}
|
||||
}
|
||||
|
||||
if plugin == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
for _, d := range input.pluginDashboards {
|
||||
if d.PluginId == plugin.PluginId {
|
||||
dashboards = append(dashboards, &models.Dashboard{
|
||||
Id: d.DashboardId,
|
||||
OrgId: plugin.OrgId,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
query.Result = dashboards
|
||||
|
||||
return nil
|
||||
})
|
||||
|
||||
sCtx.s = new(sCtx.pluginSettingsStore, sCtx.bus, sCtx.pluginStore, sCtx.pluginDashboardManager, sCtx.importDashboardService)
|
||||
|
||||
t.Cleanup(bus.ClearBusHandlers)
|
||||
|
||||
t.Run(desc, func(t *testing.T) {
|
||||
f(sCtx)
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user