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
2022-01-28 10:28:33 +01:00
parent 7e26dbb5ff
commit 94edd7a762
24 changed files with 1814 additions and 319 deletions
@@ -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
+}