Dashboard: Adds support for a global minimum dashboard refresh interval (#19416)

This feature would provide a way for administrators to limit the minimum 
dashboard refresh interval globally.
Filters out the refresh intervals available in the time picker that are lower 
than the set minimum refresh interval in the configuration .ini file
Adds the minimum refresh interval as available in the time picker.
If the user tries to enter a refresh interval that is lower than the minimum 
in the URL, defaults to the minimum interval.
When trying to update the JSON via the API, rejects the update if the 
dashboard's refresh interval is lower than the minimum.
When trying to update a dashboard via provisioning having a lower 
refresh interval than the minimum, defaults to the minimum interval 
and logs a warning. 

Fixes #3356

Co-authored-by: Marcus Efraimsson <marcus.efraimsson@gmail.com>

pkg/services/dashboards/dashboard_service.go

@@ -1,6 +1,8 @@
 package dashboards
 
 import (
+	"github.com/grafana/grafana/pkg/components/gtime"
+	"github.com/grafana/grafana/pkg/setting"
 	"strings"
 	"time"
 
@@ -103,6 +105,10 @@ func (dr *dashboardServiceImpl) buildSaveDashboardCommand(dto *SaveDashboardDTO,
 		return nil, models.ErrDashboardUidToLong
 	}
 
+	if err := validateDashboardRefreshInterval(dash); err != nil {
+		return nil, err
+	}
+
 	if validateAlerts {
 		validateAlertsCmd := models.ValidateDashboardAlertsCommand{
 			OrgId:     dto.OrgId,
@@ -172,6 +178,33 @@ func (dr *dashboardServiceImpl) buildSaveDashboardCommand(dto *SaveDashboardDTO,
 	return cmd, nil
 }
 
+func validateDashboardRefreshInterval(dash *models.Dashboard) error {
+	if setting.MinRefreshInterval == "" {
+		return nil
+	}
+
+	refresh := dash.Data.Get("refresh").MustString("")
+	if refresh == "" {
+		// since no refresh is set it is a valid refresh rate
+		return nil
+	}
+
+	minRefreshInterval, err := gtime.ParseInterval(setting.MinRefreshInterval)
+	if err != nil {
+		return err
+	}
+	d, err := gtime.ParseInterval(refresh)
+	if err != nil {
+		return err
+	}
+
+	if d < minRefreshInterval {
+		return models.ErrDashboardRefreshIntervalTooShort
+	}
+
+	return nil
+}
+
 func (dr *dashboardServiceImpl) updateAlerting(cmd *models.SaveDashboardCommand, dto *SaveDashboardDTO) error {
 	alertCmd := models.UpdateDashboardAlertsCommand{
 		OrgId:     dto.OrgId,
@@ -183,6 +216,11 @@ func (dr *dashboardServiceImpl) updateAlerting(cmd *models.SaveDashboardCommand,
 }
 
 func (dr *dashboardServiceImpl) SaveProvisionedDashboard(dto *SaveDashboardDTO, provisioning *models.DashboardProvisioning) (*models.Dashboard, error) {
+	if err := validateDashboardRefreshInterval(dto.Dashboard); err != nil {
+		dr.log.Warn("Changing refresh interval for provisioned dashboard to minimum refresh interval", "dashboardUid", dto.Dashboard.Uid, "dashboardTitle", dto.Dashboard.Title, "minRefreshInterval", setting.MinRefreshInterval)
+		dto.Dashboard.Data.Set("refresh", setting.MinRefreshInterval)
+	}
+
 	dto.User = &models.SignedInUser{
 		UserId:  0,
 		OrgRole: models.ROLE_ADMIN,

pkg/services/dashboards/dashboard_service_test.go

@@ -1,6 +1,8 @@
 package dashboards
 
 import (
+	"github.com/grafana/grafana/pkg/infra/log"
+	"github.com/grafana/grafana/pkg/setting"
 	"testing"
 
 	"github.com/grafana/grafana/pkg/bus"
@@ -14,7 +16,9 @@ func TestDashboardService(t *testing.T) {
 	Convey("Dashboard service tests", t, func() {
 		bus.ClearBusHandlers()
 
-		service := &dashboardServiceImpl{}
+		service := &dashboardServiceImpl{
+			log: log.New("test.logger"),
+		}
 
 		origNewDashboardGuardian := guardian.New
 		guardian.MockDashboardGuardian(&guardian.FakeDashboardGuardian{CanSaveValue: true})
@@ -184,6 +188,43 @@ func TestDashboardService(t *testing.T) {
 				So(err, ShouldBeNil)
 				So(provisioningValidated, ShouldBeFalse)
 			})
+
+			Convey("Should override invalid refresh interval if dashboard is provisioned", func() {
+				oldRefreshInterval := setting.MinRefreshInterval
+				setting.MinRefreshInterval = "5m"
+				defer func() { setting.MinRefreshInterval = oldRefreshInterval }()
+
+				bus.AddHandler("test", func(cmd *models.GetProvisionedDashboardDataByIdQuery) error {
+					cmd.Result = &models.DashboardProvisioning{}
+					return nil
+				})
+
+				bus.AddHandler("test", func(cmd *models.ValidateDashboardAlertsCommand) error {
+					return nil
+				})
+
+				bus.AddHandler("test", func(cmd *models.ValidateDashboardBeforeSaveCommand) error {
+					cmd.Result = &models.ValidateDashboardBeforeSaveResult{}
+					return nil
+				})
+
+				bus.AddHandler("test", func(cmd *models.SaveProvisionedDashboardCommand) error {
+					return nil
+				})
+
+				bus.AddHandler("test", func(cmd *models.UpdateDashboardAlertsCommand) error {
+					return nil
+				})
+
+				dto.Dashboard = models.NewDashboard("Dash")
+				dto.Dashboard.SetId(3)
+				dto.User = &models.SignedInUser{UserId: 1}
+				dto.Dashboard.Data.Set("refresh", "1s")
+				_, err := service.SaveProvisionedDashboard(dto, nil)
+				So(err, ShouldBeNil)
+				So(dto.Dashboard.Data.Get("refresh").MustString(), ShouldEqual, "5m")
+
+			})
 		})
 
 		Convey("Import dashboard validation", func() {

pkg/services/sqlstore/dashboard.go

@@ -623,6 +623,7 @@ func getExistingDashboardByTitleAndFolder(sess *DBSession, cmd *models.ValidateD
 
 func ValidateDashboardBeforeSave(cmd *models.ValidateDashboardBeforeSaveCommand) (err error) {
 	cmd.Result = &models.ValidateDashboardBeforeSaveResult{}
+
 	return inTransaction(func(sess *DBSession) error {
 		if err = getExistingDashboardByIdOrUidForUpdate(sess, cmd); err != nil {
 			return err