Dashboard provisioning: Add support for v2 schema (#113620)

pkg/services/dashboards/models.go

@@ -4,6 +4,9 @@ import (
 	"fmt"
 	"time"
 
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+
+	"github.com/grafana/authlib/types"
 	"github.com/grafana/grafana/pkg/apimachinery/identity"
 	"github.com/grafana/grafana/pkg/apimachinery/utils"
 	"github.com/grafana/grafana/pkg/components/simplejson"
@@ -95,6 +98,11 @@ func (d *Dashboard) GetTags() []string {
 }
 
 func NewDashboardFromJson(data *simplejson.Json) *Dashboard {
+	// if apiVersion is set in the json - use it as an indicator that it is in the k8s format
+	if apiVersion, err := data.Get("apiVersion").String(); err == nil && apiVersion != "" {
+		return parseK8sDashboard(data)
+	}
+
 	dash := &Dashboard{}
 	dash.Data = data
 	dash.Title = dash.Data.Get("title").MustString()
@@ -127,6 +135,66 @@ func NewDashboardFromJson(data *simplejson.Json) *Dashboard {
 	return dash
 }
 
+// parses json in the k8s format
+// i.e:
+//
+//	{
+//	  "apiVersion": "dashboard.grafana.app/v1",
+//	  "kind": "Dashboard",
+//	  "metadata": {...},
+//	  "spec": {...}
+//	}
+func parseK8sDashboard(data *simplejson.Json) *Dashboard {
+	dash := &Dashboard{}
+
+	dataMap, ok := data.Interface().(map[string]interface{})
+	if !ok {
+		return dash
+	}
+
+	item := &unstructured.Unstructured{Object: dataMap}
+	obj, err := utils.MetaAccessor(item)
+	if err != nil {
+		return dash
+	}
+	dash.APIVersion = item.GetAPIVersion()
+	info, err := types.ParseNamespace(obj.GetNamespace())
+	if err == nil && info.OrgID > 0 {
+		dash.OrgID = info.OrgID
+	}
+	dash.UID = obj.GetName()
+
+	spec, ok := item.Object["spec"].(map[string]any)
+	if !ok {
+		return dash
+	}
+	dash.Data = simplejson.NewFromAny(spec)
+
+	dash.Title = obj.FindTitle("")
+	dash.UpdateSlug()
+
+	dash.FolderUID = obj.GetFolder()
+	dash.Data.Set("uid", dash.UID)
+
+	generation := obj.GetGeneration()
+	if generation > 0 {
+		dash.Data.Set("version", generation)
+		dash.Updated = time.Now()
+	} else {
+		dash.Data.Set("version", 0)
+		dash.Created = time.Now()
+		dash.Updated = time.Now()
+	}
+
+	dash.Data.Set("id", obj.GetDeprecatedInternalID()) // nolint:staticcheck
+
+	if gnetId, err := dash.Data.Get("gnetId").Float64(); err == nil {
+		dash.GnetID = int64(gnetId)
+	}
+
+	return dash
+}
+
 // GetDashboardModel turns the command into the saveable model
 func (cmd *SaveDashboardCommand) GetDashboardModel() *Dashboard {
 	dash := NewDashboardFromJson(cmd.Dashboard)

pkg/services/dashboards/models_test.go

@@ -86,3 +86,50 @@ func TestSlugifyTitle(t *testing.T) {
 		})
 	}
 }
+
+func TestParseK8sDashboard(t *testing.T) {
+	t.Run("should parse valid K8s dashboard with all fields", func(t *testing.T) {
+		data := simplejson.NewFromAny(map[string]interface{}{
+			"apiVersion": "dashboard.grafana.app/v2alpha1",
+			"kind":       "Dashboard",
+			"metadata": map[string]interface{}{
+				"name":       "test-dashboard-uid",
+				"namespace":  "org-123",
+				"generation": int64(5),
+				"labels": map[string]interface{}{
+					"grafana.app/deprecatedInternalID": "456",
+				},
+				"annotations": map[string]interface{}{
+					"grafana.app/folder": "test-folder-uid",
+				},
+			},
+			"spec": map[string]interface{}{
+				"title":  "Test Dashboard",
+				"gnetId": float64(12345),
+			},
+		})
+
+		dash := parseK8sDashboard(data)
+		assert.Equal(t, "dashboard.grafana.app/v2alpha1", dash.APIVersion)
+		assert.Equal(t, int64(123), dash.OrgID)
+		assert.Equal(t, "test-dashboard-uid", dash.UID)
+		assert.Equal(t, "Test Dashboard", dash.Title)
+		assert.Equal(t, "test-dashboard", dash.Slug)
+		assert.Equal(t, "test-folder-uid", dash.FolderUID)
+		assert.Equal(t, int64(12345), dash.GnetID)
+		assert.Equal(t, "test-dashboard-uid", dash.Data.Get("uid").MustString())
+		assert.Equal(t, int64(5), dash.Data.Get("version").MustInt64())
+		assert.Equal(t, int64(456), dash.Data.Get("id").MustInt64())
+		assert.False(t, dash.Updated.IsZero())
+		assert.True(t, dash.Created.IsZero())
+	})
+
+	t.Run("should handle invalid input (not a map)", func(t *testing.T) {
+		data := simplejson.NewFromAny("invalid string")
+		dash := parseK8sDashboard(data)
+		assert.Empty(t, dash.UID)
+		assert.Empty(t, dash.Title) // this will fail later in the provisioning chain because its empty
+		assert.Empty(t, dash.APIVersion)
+		assert.Nil(t, dash.Data)
+	})
+}

pkg/services/dashboards/service/dashboard_service.go

@@ -745,15 +745,16 @@ func (dr *DashboardServiceImpl) BuildSaveDashboardCommand(ctx context.Context, d
 
 	metrics.MFolderIDsServiceCount.WithLabelValues(metrics.Dashboard).Inc()
 	cmd := &dashboards.SaveDashboardCommand{
-		Dashboard: dash.Data,
-		Message:   dto.Message,
-		OrgID:     dto.OrgID,
-		Overwrite: dto.Overwrite,
-		UserID:    userID,
-		FolderID:  dash.FolderID, // nolint:staticcheck
-		FolderUID: dash.FolderUID,
-		IsFolder:  dash.IsFolder,
-		PluginID:  dash.PluginID,
+		Dashboard:  dash.Data,
+		Message:    dto.Message,
+		OrgID:      dto.OrgID,
+		Overwrite:  dto.Overwrite,
+		UserID:     userID,
+		FolderID:   dash.FolderID, // nolint:staticcheck
+		FolderUID:  dash.FolderUID,
+		IsFolder:   dash.IsFolder,
+		PluginID:   dash.PluginID,
+		APIVersion: dash.APIVersion,
 	}
 
 	if !dto.UpdatedAt.IsZero() {
@@ -2288,6 +2289,10 @@ func LegacySaveCommandToUnstructured(cmd *dashboards.SaveDashboardCommand, names
 		meta.SetMessage(cmd.Message)
 	}
 
+	if cmd.APIVersion != "" {
+		finalObj.SetAPIVersion(cmd.APIVersion)
+	}
+
 	return finalObj, nil
 }