IntenseWebs/grafana
3
0
Fork 0
mirror of https://github.com/grafana/grafana.git synced 2025-02-25 18:55:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

Chore: Rename Id to ID in alerting models (#62777)

Browse Source 
* Chore: Rename Id to ID in alerting models

* Add xorm tags for datasource

* Add xorm tag for uid
This commit is contained in:
idafurjes 2023-02-02 17:22:43 +01:00 committed by GitHub
parent 48a374f50b
commit 23c27cffb3
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
88 changed files with 698 additions and 698 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
pkg/api/alerting.go
View File

@ -30,7 +30,7 @@ func (hs *HTTPServer) ValidateOrgAlert(c *contextmodel.ReqContext) {
c.JsonApiErr(http.StatusBadRequest, "alertId is invalid", nil)
return
}
query := alertmodels.GetAlertByIdQuery{Id: id}
query := alertmodels.GetAlertByIdQuery{ID: id}
res, err := hs.AlertEngine.AlertStore.GetAlertById(c.Req.Context(), &query)
if err != nil {
@ -38,7 +38,7 @@ func (hs *HTTPServer) ValidateOrgAlert(c *contextmodel.ReqContext) {
return
}
if c.OrgID != res.OrgId {
if c.OrgID != res.OrgID {
c.JsonApiErr(403, "You are not allowed to edit/view alert", nil)
return
}
@ -61,8 +61,8 @@ func (hs *HTTPServer) GetAlertStatesForDashboard(c *contextmodel.ReqContext) res
}
query := alertmodels.GetAlertStatesForDashboardQuery{
OrgId: c.OrgID,
DashboardId: c.QueryInt64("dashboardId"),
OrgID: c.OrgID,
DashboardID: c.QueryInt64("dashboardId"),
}
res, err := hs.AlertEngine.AlertStore.GetAlertStatesForDashboard(c.Req.Context(), &query)
@ -134,9 +134,9 @@ func (hs *HTTPServer) GetAlerts(c *contextmodel.ReqContext) response.Response {
}
query := alertmodels.GetAlertsQuery{
OrgId: c.OrgID,
OrgID: c.OrgID,
DashboardIDs: dashboardIDs,
PanelId: c.QueryInt64("panelId"),
PanelID: c.QueryInt64("panelId"),
Limit: c.QueryInt64("limit"),
User: c.SignedInUser,
Query: c.Query("query"),
@ -153,7 +153,7 @@ func (hs *HTTPServer) GetAlerts(c *contextmodel.ReqContext) response.Response {
}
for _, alert := range res {
alert.Url = dashboards.GetDashboardURL(alert.DashboardUid, alert.DashboardSlug)
alert.URL = dashboards.GetDashboardURL(alert.DashboardUID, alert.DashboardSlug)
}
return response.JSON(http.StatusOK, res)
@ -228,7 +228,7 @@ func (hs *HTTPServer) GetAlert(c *contextmodel.ReqContext) response.Response {
if err != nil {
return response.Error(http.StatusBadRequest, "alertId is invalid", err)
}
query := alertmodels.GetAlertByIdQuery{Id: id}
query := alertmodels.GetAlertByIdQuery{ID: id}
res, err := hs.AlertEngine.AlertStore.GetAlertById(c.Req.Context(), &query)
if err != nil {
@ -698,13 +698,13 @@ func (hs *HTTPServer) PauseAlert(legacyAlertingEnabled *bool) func(c *contextmod
result := make(map[string]interface{})
result["alertId"] = alertID
query := alertmodels.GetAlertByIdQuery{Id: alertID}
query := alertmodels.GetAlertByIdQuery{ID: alertID}
res, err := hs.AlertEngine.AlertStore.GetAlertById(c.Req.Context(), &query)
if err != nil {
return response.Error(500, "Get Alert failed", err)
}
guardian, err := guardian.New(c.Req.Context(), res.DashboardId, c.OrgID, c.SignedInUser)
guardian, err := guardian.New(c.Req.Context(), res.DashboardID, c.OrgID, c.SignedInUser)
if err != nil {
return response.ErrOrFallback(http.StatusInternalServerError, "Error while creating permission guardian", err)
}
@ -728,8 +728,8 @@ func (hs *HTTPServer) PauseAlert(legacyAlertingEnabled *bool) func(c *contextmod
}
cmd := alertmodels.PauseAlertCommand{
OrgId: c.OrgID,
AlertIds: []int64{alertID},
OrgID: c.OrgID,
AlertIDs: []int64{alertID},
Paused: dto.Paused,
}

84
pkg/api/datasources.go
View File

@ -43,7 +43,7 @@ var secretsPluginError datasources.ErrDatasourceSecretsPluginUserFriendly
// 403: forbiddenError
// 500: internalServerError
func (hs *HTTPServer) GetDataSources(c *contextmodel.ReqContext) response.Response {
query := datasources.GetDataSourcesQuery{OrgId: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
query := datasources.GetDataSourcesQuery{OrgID: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
if err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query); err != nil {
return response.Error(500, "Failed to query datasources", err)
@ -57,11 +57,11 @@ func (hs *HTTPServer) GetDataSources(c *contextmodel.ReqContext) response.Respon
result := make(dtos.DataSourceList, 0)
for _, ds := range filtered {
dsItem := dtos.DataSourceListItemDTO{
OrgId: ds.OrgId,
Id: ds.Id,
UID: ds.Uid,
OrgId: ds.OrgID,
Id: ds.ID,
UID: ds.UID,
Name: ds.Name,
Url: ds.Url,
Url: ds.URL,
Type: ds.Type,
TypeName: ds.Type,
Access: ds.Access,
@ -112,8 +112,8 @@ func (hs *HTTPServer) GetDataSourceById(c *contextmodel.ReqContext) response.Res
return response.Error(http.StatusBadRequest, "id is invalid", nil)
}
query := datasources.GetDataSourceQuery{
Id: id,
OrgId: c.OrgID,
ID: id,
OrgID: c.OrgID,
}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
@ -183,7 +183,7 @@ func (hs *HTTPServer) DeleteDataSourceById(c *contextmodel.ReqContext) response.
return response.Error(500, "Failed to delete datasource", err)
}
hs.Live.HandleDatasourceDelete(c.OrgID, ds.Uid)
hs.Live.HandleDatasourceDelete(c.OrgID, ds.UID)
return response.Success("Data source deleted")
}
@ -262,11 +262,11 @@ func (hs *HTTPServer) DeleteDataSourceByUID(c *contextmodel.ReqContext) response
return response.Error(500, "Failed to delete datasource", err)
}
hs.Live.HandleDatasourceDelete(c.OrgID, ds.Uid)
hs.Live.HandleDatasourceDelete(c.OrgID, ds.UID)
return response.JSON(http.StatusOK, util.DynMap{
"message": "Data source deleted",
"id": ds.Id,
"id": ds.ID,
})
}
@ -290,7 +290,7 @@ func (hs *HTTPServer) DeleteDataSourceByName(c *contextmodel.ReqContext) respons
return response.Error(400, "Missing valid datasource name", nil)
}
getCmd := &datasources.GetDataSourceQuery{Name: name, OrgId: c.OrgID}
getCmd := &datasources.GetDataSourceQuery{Name: name, OrgID: c.OrgID}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), getCmd); err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
@ -311,11 +311,11 @@ func (hs *HTTPServer) DeleteDataSourceByName(c *contextmodel.ReqContext) respons
return response.Error(500, "Failed to delete datasource", err)
}
hs.Live.HandleDatasourceDelete(c.OrgID, getCmd.Result.Uid)
hs.Live.HandleDatasourceDelete(c.OrgID, getCmd.Result.UID)
return response.JSON(http.StatusOK, util.DynMap{
"message": "Data source deleted",
"id": getCmd.Result.Id,
"id": getCmd.Result.ID,
})
}
@ -371,11 +371,11 @@ func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Respons
return response.Error(http.StatusBadRequest, "bad request data", err)
}
datasourcesLogger.Debug("Received command to add data source", "url", cmd.Url)
cmd.OrgId = c.OrgID
cmd.UserId = c.UserID
if cmd.Url != "" {
if resp := validateURL(cmd.Type, cmd.Url); resp != nil {
datasourcesLogger.Debug("Received command to add data source", "url", cmd.URL)
cmd.OrgID = c.OrgID
cmd.UserID = c.UserID
if cmd.URL != "" {
if resp := validateURL(cmd.Type, cmd.URL); resp != nil {
return resp
}
}
@ -404,7 +404,7 @@ func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Respons
ds := hs.convertModelToDtos(c.Req.Context(), cmd.Result)
return response.JSON(http.StatusOK, util.DynMap{
"message": "Datasource added",
"id": cmd.Result.Id,
"id": cmd.Result.ID,
"name": cmd.Result.Name,
"datasource": ds,
})
@ -436,20 +436,20 @@ func (hs *HTTPServer) UpdateDataSourceByID(c *contextmodel.ReqContext) response.
if err := web.Bind(c.Req, &cmd); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err)
}
datasourcesLogger.Debug("Received command to update data source", "url", cmd.Url)
cmd.OrgId = c.OrgID
datasourcesLogger.Debug("Received command to update data source", "url", cmd.URL)
cmd.OrgID = c.OrgID
var err error
if cmd.Id, err = strconv.ParseInt(web.Params(c.Req)[":id"], 10, 64); err != nil {
if cmd.ID, err = strconv.ParseInt(web.Params(c.Req)[":id"], 10, 64); err != nil {
return response.Error(http.StatusBadRequest, "id is invalid", err)
}
if resp := validateURL(cmd.Type, cmd.Url); resp != nil {
if resp := validateURL(cmd.Type, cmd.URL); resp != nil {
return resp
}
if err := validateJSONData(cmd.JsonData, hs.Cfg); err != nil {
return response.Error(http.StatusBadRequest, "Failed to update datasource", err)
}
ds, err := hs.getRawDataSourceById(c.Req.Context(), cmd.Id, cmd.OrgId)
ds, err := hs.getRawDataSourceById(c.Req.Context(), cmd.ID, cmd.OrgID)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
@ -480,9 +480,9 @@ func (hs *HTTPServer) UpdateDataSourceByUID(c *contextmodel.ReqContext) response
if err := web.Bind(c.Req, &cmd); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err)
}
datasourcesLogger.Debug("Received command to update data source", "url", cmd.Url)
cmd.OrgId = c.OrgID
if resp := validateURL(cmd.Type, cmd.Url); resp != nil {
datasourcesLogger.Debug("Received command to update data source", "url", cmd.URL)
cmd.OrgID = c.OrgID
if resp := validateURL(cmd.Type, cmd.URL); resp != nil {
return resp
}
if err := validateJSONData(cmd.JsonData, hs.Cfg); err != nil {
@ -496,7 +496,7 @@ func (hs *HTTPServer) UpdateDataSourceByUID(c *contextmodel.ReqContext) response
}
return response.Error(http.StatusInternalServerError, "Failed to update datasource", err)
}
cmd.Id = ds.Id
cmd.ID = ds.ID
return hs.updateDataSourceByID(c, ds, cmd)
}
@ -518,8 +518,8 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
}
query := datasources.GetDataSourceQuery{
Id: cmd.Id,
OrgId: c.OrgID,
ID: cmd.ID,
OrgID: c.OrgID,
}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
@ -535,7 +535,7 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
return response.JSON(http.StatusOK, util.DynMap{
"message": "Datasource updated",
"id": cmd.Id,
"id": cmd.ID,
"name": cmd.Name,
"datasource": datasourceDTO,
})
@ -543,8 +543,8 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
func (hs *HTTPServer) getRawDataSourceById(ctx context.Context, id int64, orgID int64) (*datasources.DataSource, error) {
query := datasources.GetDataSourceQuery{
Id: id,
OrgId: orgID,
ID: id,
OrgID: orgID,
}
if err := hs.DataSourcesService.GetDataSource(ctx, &query); err != nil {
@ -556,8 +556,8 @@ func (hs *HTTPServer) getRawDataSourceById(ctx context.Context, id int64, orgID
func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, orgID int64) (*datasources.DataSource, error) {
query := datasources.GetDataSourceQuery{
Uid: uid,
OrgId: orgID,
UID: uid,
OrgID: orgID,
}
if err := hs.DataSourcesService.GetDataSource(ctx, &query); err != nil {
@ -580,7 +580,7 @@ func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, org
// 403: forbiddenError
// 500: internalServerError
func (hs *HTTPServer) GetDataSourceByName(c *contextmodel.ReqContext) response.Response {
query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgId: c.OrgID}
query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgID: c.OrgID}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
@ -607,7 +607,7 @@ func (hs *HTTPServer) GetDataSourceByName(c *contextmodel.ReqContext) response.R
// 404: notFoundError
// 500: internalServerError
func (hs *HTTPServer) GetDataSourceIdByName(c *contextmodel.ReqContext) response.Response {
query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgId: c.OrgID}
query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgID: c.OrgID}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
@ -618,7 +618,7 @@ func (hs *HTTPServer) GetDataSourceIdByName(c *contextmodel.ReqContext) response
ds := query.Result
dtos := dtos.AnyId{
Id: ds.Id,
Id: ds.ID,
}
return response.JSON(http.StatusOK, &dtos)
@ -703,11 +703,11 @@ func (hs *HTTPServer) CallDatasourceResourceWithUID(c *contextmodel.ReqContext)
func (hs *HTTPServer) convertModelToDtos(ctx context.Context, ds *datasources.DataSource) dtos.DataSource {
dto := dtos.DataSource{
Id: ds.Id,
UID: ds.Uid,
OrgId: ds.OrgId,
Id: ds.ID,
UID: ds.UID,
OrgId: ds.OrgID,
Name: ds.Name,
Url: ds.Url,
Url: ds.URL,
Type: ds.Type,
Access: ds.Access,
Database: ds.Database,

12
pkg/api/datasources_test.go
View File

@ -91,7 +91,7 @@ func TestAddDataSource_InvalidURL(t *testing.T) {
sc.m.Post(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
Name: "Test",
Url: "invalid:url",
URL: "invalid:url",
Access: "direct",
Type: "test",
})
@ -122,7 +122,7 @@ func TestAddDataSource_URLWithoutProtocol(t *testing.T) {
sc.m.Post(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
Name: name,
Url: url,
URL: url,
Access: "direct",
Type: "test",
})
@ -152,7 +152,7 @@ func TestAddDataSource_InvalidJSONData(t *testing.T) {
sc.m.Post(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
Name: "Test",
Url: "localhost:5432",
URL: "localhost:5432",
Access: "direct",
Type: "test",
JsonData: jsonData,
@ -176,7 +176,7 @@ func TestUpdateDataSource_InvalidURL(t *testing.T) {
sc.m.Put(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
Name: "Test",
Url: "invalid:url",
URL: "invalid:url",
Access: "direct",
Type: "test",
})
@ -204,7 +204,7 @@ func TestUpdateDataSource_InvalidJSONData(t *testing.T) {
sc.m.Put(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
Name: "Test",
Url: "localhost:5432",
URL: "localhost:5432",
Access: "direct",
Type: "test",
JsonData: jsonData,
@ -236,7 +236,7 @@ func TestUpdateDataSource_URLWithoutProtocol(t *testing.T) {
sc.m.Put(sc.url, routing.Wrap(func(c *contextmodel.ReqContext) response.Response {
c.Req.Body = mockRequestBody(datasources.AddDataSourceCommand{
Name: name,
Url: url,
URL: url,
Access: "direct",
Type: "test",
})

12
pkg/api/frontendsettings.go
View File

@ -262,7 +262,7 @@ func isSupportBundlesEnabled(hs *HTTPServer) bool {
func (hs *HTTPServer) getFSDataSources(c *contextmodel.ReqContext, enabledPlugins EnabledPlugins) (map[string]plugins.DataSourceDTO, error) {
orgDataSources := make([]*datasources.DataSource, 0)
if c.OrgID != 0 {
query := datasources.GetDataSourcesQuery{OrgId: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
query := datasources.GetDataSourcesQuery{OrgID: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
if err != nil {
return nil, err
@ -283,15 +283,15 @@ func (hs *HTTPServer) getFSDataSources(c *contextmodel.ReqContext, enabledPlugin
dataSources := make(map[string]plugins.DataSourceDTO)
for _, ds := range orgDataSources {
url := ds.Url
url := ds.URL
if ds.Access == datasources.DS_ACCESS_PROXY {
url = "/api/datasources/proxy/uid/" + ds.Uid
url = "/api/datasources/proxy/uid/" + ds.UID
}
dsDTO := plugins.DataSourceDTO{
ID: ds.Id,
UID: ds.Uid,
ID: ds.ID,
UID: ds.UID,
Type: ds.Type,
Name: ds.Name,
URL: url,
@ -365,7 +365,7 @@ func (hs *HTTPServer) getFSDataSources(c *contextmodel.ReqContext, enabledPlugin
if ds.Type == datasources.DS_PROMETHEUS {
// add unproxied server URL for link to Prometheus web UI
ds.JsonData.Set("directUrl", ds.Url)
ds.JsonData.Set("directUrl", ds.URL)
}
dataSources[ds.Name] = dsDTO

4
pkg/api/pluginproxy/ds_proxy.go
View File

@ -54,7 +54,7 @@ func NewDataSourceProxy(ds *datasources.DataSource, pluginRoutes []*plugins.Rout
proxyPath string, cfg *setting.Cfg, clientProvider httpclient.Provider,
oAuthTokenService oauthtoken.OAuthTokenService, dsService datasources.DataSourceService,
tracer tracing.Tracer) (*DataSourceProxy, error) {
targetURL, err := datasource.ValidateURL(ds.Type, ds.Url)
targetURL, err := datasource.ValidateURL(ds.Type, ds.URL)
if err != nil {
return nil, err
}
@ -244,7 +244,7 @@ func (proxy *DataSourceProxy) director(req *http.Request) {
}
ApplyRoute(req.Context(), req, proxy.proxyPath, proxy.matchedRoute, DSInfo{
ID: proxy.ds.Id,
ID: proxy.ds.ID,
Updated: proxy.ds.Updated,
JSONData: jsonData,
DecryptedSecureJSONData: decryptedValues,

38
pkg/api/pluginproxy/ds_proxy_test.go
View File

@ -121,7 +121,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
jd, err := ds.JsonData.Map()
require.NoError(t, err)
dsInfo := DSInfo{
ID: ds.Id,
ID: ds.ID,
Updated: ds.Updated,
JSONData: jd,
DecryptedSecureJSONData: map[string]string{
@ -307,7 +307,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
jd, err := ds.JsonData.Map()
require.NoError(t, err)
dsInfo := DSInfo{
ID: ds.Id,
ID: ds.ID,
Updated: ds.Updated,
JSONData: jd,
DecryptedSecureJSONData: map[string]string{
@ -372,7 +372,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
t.Run("When proxying graphite", func(t *testing.T) {
var routes []*plugins.Route
ds := &datasources.DataSource{Url: "htttp://graphite:8080", Type: datasources.DS_GRAPHITE}
ds := &datasources.DataSource{URL: "htttp://graphite:8080", Type: datasources.DS_GRAPHITE}
ctx := &contextmodel.ReqContext{}
sqlStore := db.InitTestDB(t)
@ -397,7 +397,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
t.Run("When proxying InfluxDB", func(t *testing.T) {
ds := &datasources.DataSource{
Type: datasources.DS_INFLUXDB_08,
Url: "http://influxdb:8083",
URL: "http://influxdb:8083",
Database: "site",
User: "user",
}
@ -426,7 +426,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
ds := &datasources.DataSource{
Type: datasources.DS_GRAPHITE,
Url: "http://graphite:8086",
URL: "http://graphite:8086",
JsonData: json,
}
@ -458,7 +458,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
ds := &datasources.DataSource{
Type: datasources.DS_GRAPHITE,
Url: "http://graphite:8086",
URL: "http://graphite:8086",
JsonData: json,
}
@ -487,7 +487,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
t.Run("When proxying a custom datasource", func(t *testing.T) {
ds := &datasources.DataSource{
Type: "custom-datasource",
Url: "http://host/root/",
URL: "http://host/root/",
}
ctx := &contextmodel.ReqContext{}
var routes []*plugins.Route
@ -515,7 +515,7 @@ func TestDataSourceProxy_routeRule(t *testing.T) {
t.Run("When proxying a datasource that has OAuth token pass-through enabled", func(t *testing.T) {
ds := &datasources.DataSource{
Type: "custom-datasource",
Url: "http://host/root/",
URL: "http://host/root/",
JsonData: simplejson.NewFromAny(map[string]interface{}{
"oauthPassThru": true,
}),
@ -657,7 +657,7 @@ func TestDataSourceProxy_requestHandling(t *testing.T) {
}))
t.Cleanup(backend.Close)
ds := &datasources.DataSource{Url: backend.URL, Type: datasources.DS_GRAPHITE}
ds := &datasources.DataSource{URL: backend.URL, Type: datasources.DS_GRAPHITE}
responseWriter := web.NewResponseWriter("GET", httptest.NewRecorder())
@ -829,7 +829,7 @@ func TestNewDataSourceProxy_InvalidURL(t *testing.T) {
}
ds := datasources.DataSource{
Type: "test",
Url: "://host/root",
URL: "://host/root",
}
cfg := &setting.Cfg{}
tracer := tracing.InitializeTracerForTest()
@ -853,7 +853,7 @@ func TestNewDataSourceProxy_ProtocolLessURL(t *testing.T) {
}
ds := datasources.DataSource{
Type: "test",
Url: "127.0.01:5432",
URL: "127.0.01:5432",
}
cfg := &setting.Cfg{}
tracer := tracing.InitializeTracerForTest()
@ -901,7 +901,7 @@ func TestNewDataSourceProxy_MSSQL(t *testing.T) {
cfg := &setting.Cfg{}
ds := datasources.DataSource{
Type: "mssql",
Url: tc.url,
URL: tc.url,
}
var routes []*plugins.Route
@ -916,7 +916,7 @@ func TestNewDataSourceProxy_MSSQL(t *testing.T) {
require.NoError(t, err)
assert.Equal(t, &url.URL{
Scheme: "sqlserver",
Host: ds.Url,
Host: ds.URL,
}, p.targetUrl)
} else {
require.Error(t, err)
@ -930,7 +930,7 @@ func TestNewDataSourceProxy_MSSQL(t *testing.T) {
func getDatasourceProxiedRequest(t *testing.T, ctx *contextmodel.ReqContext, cfg *setting.Cfg) *http.Request {
ds := &datasources.DataSource{
Type: "custom",
Url: "http://host/root/",
URL: "http://host/root/",
}
tracer := tracing.InitializeTracerForTest()
@ -999,12 +999,12 @@ func createAuthTest(t *testing.T, secretsStore secretskvs.SecretsKVStore, dsType
test := &testCase{
datasource: &datasources.DataSource{
Id: 1,
OrgId: 1,
ID: 1,
OrgID: 1,
Name: fmt.Sprintf("%s,%s,%s,%s", dsType, url, authType, authCheck),
Type: dsType,
JsonData: simplejson.New(),
Url: url,
URL: url,
},
}
var message string
@ -1017,7 +1017,7 @@ func createAuthTest(t *testing.T, secretsStore secretskvs.SecretsKVStore, dsType
})
require.NoError(t, err)
err = secretsStore.Set(context.Background(), test.datasource.OrgId, test.datasource.Name, "datasource", string(secureJsonData))
err = secretsStore.Set(context.Background(), test.datasource.OrgID, test.datasource.Name, "datasource", string(secureJsonData))
require.NoError(t, err)
} else {
message = fmt.Sprintf("%v should add basic auth username and password", dsType)
@ -1028,7 +1028,7 @@ func createAuthTest(t *testing.T, secretsStore secretskvs.SecretsKVStore, dsType
})
require.NoError(t, err)
err = secretsStore.Set(context.Background(), test.datasource.OrgId, test.datasource.Name, "datasource", string(secureJsonData))
err = secretsStore.Set(context.Background(), test.datasource.OrgID, test.datasource.Name, "datasource", string(secureJsonData))
require.NoError(t, err)
}
require.NoError(t, err)

8
pkg/cmd/grafana-cli/commands/datamigrations/encrypt_datasource_passwords_test.go
View File

@ -27,10 +27,10 @@ func TestPasswordMigrationCommand(t *testing.T) {
func passwordMigration(t *testing.T, session *db.Session, sqlstore db.DB) {
ds := []*datasources.DataSource{
{Type: "influxdb", Name: "influxdb", Password: "foobar", Uid: "influx"},
{Type: "graphite", Name: "graphite", BasicAuthPassword: "foobar", Uid: "graphite"},
{Type: "prometheus", Name: "prometheus", Uid: "prom"},
{Type: "elasticsearch", Name: "elasticsearch", Password: "pwd", Uid: "elastic"},
{Type: "influxdb", Name: "influxdb", Password: "foobar", UID: "influx"},
{Type: "graphite", Name: "graphite", BasicAuthPassword: "foobar", UID: "graphite"},
{Type: "prometheus", Name: "prometheus", UID: "prom"},
{Type: "elasticsearch", Name: "elasticsearch", Password: "pwd", UID: "elastic"},
}
// set required default values

4
pkg/expr/graph.go
View File

@ -131,7 +131,7 @@ func (s *Service) buildGraph(req *Request) (*simple.DirectedGraph, error) {
dp := simple.NewDirectedGraph()
for _, query := range req.Queries {
if query.DataSource == nil || query.DataSource.Uid == "" {
if query.DataSource == nil || query.DataSource.UID == "" {
return nil, fmt.Errorf("missing datasource uid in query with refId %v", query.RefID)
}
@ -157,7 +157,7 @@ func (s *Service) buildGraph(req *Request) (*simple.DirectedGraph, error) {
var node Node
if IsDataSource(rn.DataSource.Uid) {
if IsDataSource(rn.DataSource.UID) {
node, err = buildCMDNode(dp, rn)
} else {
node, err = s.buildDSNode(dp, rn, req)

8
pkg/expr/graph_test.go
View File

@ -32,7 +32,7 @@ func TestServicebuildPipeLine(t *testing.T) {
{
RefID: "B",
DataSource: &datasources.DataSource{
Uid: "Fake",
UID: "Fake",
},
TimeRange: AbsoluteTimeRange{},
},
@ -143,7 +143,7 @@ func TestServicebuildPipeLine(t *testing.T) {
{
RefID: "C",
DataSource: &datasources.DataSource{
Uid: "Fake",
UID: "Fake",
},
TimeRange: AbsoluteTimeRange{},
},
@ -198,7 +198,7 @@ func TestServicebuildPipeLine(t *testing.T) {
{
RefID: "C",
DataSource: &datasources.DataSource{
Uid: "Fake",
UID: "Fake",
},
TimeRange: AbsoluteTimeRange{},
},
@ -222,7 +222,7 @@ func TestServicebuildPipeLine(t *testing.T) {
{
RefID: "B",
DataSource: &datasources.DataSource{
Uid: "Fake",
UID: "Fake",
},
TimeRange: AbsoluteTimeRange{},
},

2
pkg/expr/nodes.go
View File

@ -201,7 +201,7 @@ func (s *Service) buildDSNode(dp *simple.DirectedGraph, rn *rawNode, req *Reques
// other nodes they must have already been executed and their results must
// already by in vars.
func (dn *DSNode) Execute(ctx context.Context, now time.Time, _ mathexp.Vars, s *Service) (r mathexp.Results, e error) {
logger := logger.FromContext(ctx).New("datasourceType", dn.datasource.Type, "queryRefId", dn.refID, "datasourceUid", dn.datasource.Uid, "datasourceVersion", dn.datasource.Version)
logger := logger.FromContext(ctx).New("datasourceType", dn.datasource.Type, "queryRefId", dn.refID, "datasourceUid", dn.datasource.UID, "datasourceVersion", dn.datasource.Version)
dsInstanceSettings, err := adapters.ModelToInstanceSettings(dn.datasource, s.decryptSecureJsonDataFn(ctx))
if err != nil {
return mathexp.Results{}, fmt.Errorf("%v: %w", "failed to convert datasource instance settings", err)

4
pkg/expr/service.go
View File

@ -79,8 +79,8 @@ func (s *Service) ExecutePipeline(ctx context.Context, now time.Time, pipeline D
func DataSourceModel() *datasources.DataSource {
return &datasources.DataSource{
Id: DatasourceID,
Uid: DatasourceUID,
ID: DatasourceID,
UID: DatasourceUID,
Name: DatasourceUID,
Type: DatasourceType,
JsonData: simplejson.New(),

4
pkg/expr/service_test.go
View File

@ -38,8 +38,8 @@ func TestService(t *testing.T) {
{
RefID: "A",
DataSource: &datasources.DataSource{
OrgId: 1,
Uid: "test",
OrgID: 1,
UID: "test",
Type: "test",
},
JSON: json.RawMessage(`{ "datasource": { "uid": "1" }, "intervalMs": 1000, "maxDataPoints": 1000 }`),

2
pkg/infra/usagestats/statscollector/prometheus_flavor.go
View File

@ -79,7 +79,7 @@ func (s *Service) detectPrometheusVariant(ctx context.Context, ds *datasources.D
return "", err
}
req, err := http.NewRequestWithContext(ctx, http.MethodGet, ds.Url+"/api/v1/status/buildinfo", nil)
req, err := http.NewRequestWithContext(ctx, http.MethodGet, ds.URL+"/api/v1/status/buildinfo", nil)
if err != nil {
s.log.Error("Failed to create Prometheus build info request", "error", err)
return "", err

24
pkg/infra/usagestats/statscollector/prometheus_flavor_test.go
View File

@ -41,40 +41,40 @@ func TestDetectPrometheusVariant(t *testing.T) {
statsService,
withDatasources(mockDatasourceService{datasources: []*datasources.DataSource{
{
Id: 1,
OrgId: 1,
ID: 1,
OrgID: 1,
Version: 1,
Name: "Vanilla",
Type: "prometheus",
Access: "proxy",
Url: vanilla.URL,
URL: vanilla.URL,
},
{
Id: 2,
OrgId: 1,
ID: 2,
OrgID: 1,
Version: 1,
Name: "Mimir",
Type: "prometheus",
Access: "proxy",
Url: mimir.URL,
URL: mimir.URL,
},
{
Id: 3,
OrgId: 1,
ID: 3,
OrgID: 1,
Version: 1,
Name: "Another Mimir",
Type: "prometheus",
Access: "proxy",
Url: mimir.URL,
URL: mimir.URL,
},
{
Id: 4,
OrgId: 1,
ID: 4,
OrgID: 1,
Version: 1,
Name: "Cortex",
Type: "prometheus",
Access: "proxy",
Url: cortex.URL,
URL: cortex.URL,
},
}}),
)

6
pkg/plugins/adapters/adapters.go
View File

@ -29,10 +29,10 @@ func ModelToInstanceSettings(ds *datasources.DataSource, decryptFn func(ds *data
return &backend.DataSourceInstanceSettings{
Type: ds.Type,
ID: ds.Id,
ID: ds.ID,
Name: ds.Name,
URL: ds.Url,
UID: ds.Uid,
URL: ds.URL,
UID: ds.UID,
Database: ds.Database,
User: ds.User,
BasicAuthEnabled: ds.BasicAuth,

2
pkg/services/accesscontrol/filter_bench_test.go
View File

@ -58,7 +58,7 @@ func setupFilterBenchmark(b *testing.B, numDs, numPermissions int) (db.DB, []acc
for i := 1; i <= numDs; i++ {
err := store.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
Name: fmt.Sprintf("ds:%d", i),
OrgId: 1,
OrgID: 1,
})
require.NoError(b, err)
}

2
pkg/services/accesscontrol/filter_test.go
View File

@ -172,7 +172,7 @@ func TestFilter_Datasources(t *testing.T) {
// seed 10 data sources
for i := 1; i <= 10; i++ {
dsStore := dsService.CreateStore(store, log.New("accesscontrol.test"))
err := dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{Name: fmt.Sprintf("ds:%d", i), Uid: fmt.Sprintf("uid%d", i)})
err := dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{Name: fmt.Sprintf("ds:%d", i), UID: fmt.Sprintf("uid%d", i)})
require.NoError(t, err)
}

6
pkg/services/accesscontrol/resourcepermissions/store_bench_test.go
View File

@ -82,15 +82,15 @@ func GenerateDatasourcePermissions(b *testing.B, db *sqlstore.SQLStore, ac *stor
dataSources := make([]int64, 0)
for i := 0; i < dsNum; i++ {
addDSCommand := &datasources.AddDataSourceCommand{
OrgId: 0,
OrgID: 0,
Name: fmt.Sprintf("ds_%d", i),
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
}
dsStore := datasourcesService.CreateStore(db, log.New("publicdashboards.test"))
_ = dsStore.AddDataSource(context.Background(), addDSCommand)
dataSources = append(dataSources, addDSCommand.Result.Id)
dataSources = append(dataSources, addDSCommand.Result.ID)
}
userIds, teamIds := generateTeamsAndUsers(b, db, usersNum)

4
pkg/services/alerting/alerting_usage.go
View File

@ -50,7 +50,7 @@ func (e *AlertEngine) mapRulesToUsageStats(ctx context.Context, rules []*models.
for _, a := range rules {
dss, err := e.parseAlertRuleModel(a.Settings)
if err != nil {
e.log.Debug("could not parse settings for alert rule", "id", a.Id)
e.log.Debug("could not parse settings for alert rule", "id", a.ID)
continue
}
@ -63,7 +63,7 @@ func (e *AlertEngine) mapRulesToUsageStats(ctx context.Context, rules []*models.
// map of datsource types and frequency
result := map[string]int{}
for k, v := range typeCount {
query := &datasources.GetDataSourceQuery{Id: k}
query := &datasources.GetDataSourceQuery{ID: k}
err := e.datasourceService.GetDataSource(ctx, query)
if err != nil {
return map[string]int{}, nil

16
pkg/services/alerting/alerting_usage_test.go
View File

@ -19,10 +19,10 @@ func TestAlertingUsageStats(t *testing.T) {
store := &AlertStoreMock{}
dsMock := &fd.FakeDataSourceService{
DataSources: []*datasources.DataSource{
{Id: 1, Type: datasources.DS_INFLUXDB},
{Id: 2, Type: datasources.DS_GRAPHITE},
{Id: 3, Type: datasources.DS_PROMETHEUS},
{Id: 4, Type: datasources.DS_PROMETHEUS},
{ID: 1, Type: datasources.DS_INFLUXDB},
{ID: 2, Type: datasources.DS_GRAPHITE},
{ID: 3, Type: datasources.DS_PROMETHEUS},
{ID: 4, Type: datasources.DS_PROMETHEUS},
},
}
ae := &AlertEngine{
@ -43,10 +43,10 @@ func TestAlertingUsageStats(t *testing.T) {
}
return []*models.Alert{
{Id: 1, Settings: createFake("testdata/settings/one_condition.json")},
{Id: 2, Settings: createFake("testdata/settings/two_conditions.json")},
{Id: 2, Settings: createFake("testdata/settings/three_conditions.json")},
{Id: 3, Settings: createFake("testdata/settings/empty.json")},
{ID: 1, Settings: createFake("testdata/settings/one_condition.json")},
{ID: 2, Settings: createFake("testdata/settings/two_conditions.json")},
{ID: 2, Settings: createFake("testdata/settings/three_conditions.json")},
{ID: 3, Settings: createFake("testdata/settings/empty.json")},
}, nil
}

8
pkg/services/alerting/conditions/query.go
View File

@ -142,15 +142,15 @@ func calculateInterval(timeRange legacydata.DataTimeRange, model *simplejson.Jso
func (c *QueryCondition) executeQuery(context *alerting.EvalContext, timeRange legacydata.DataTimeRange,
requestHandler legacydata.RequestHandler) (legacydata.DataTimeSeriesSlice, error) {
getDsInfo := &datasources.GetDataSourceQuery{
Id: c.Query.DatasourceID,
OrgId: context.Rule.OrgID,
ID: c.Query.DatasourceID,
OrgID: context.Rule.OrgID,
}
if err := context.GetDataSource(context.Ctx, getDsInfo); err != nil {
return nil, fmt.Errorf("could not find datasource: %w", err)
}
err := context.RequestValidator.Validate(getDsInfo.Result.Url, nil)
err := context.RequestValidator.Validate(getDsInfo.Result.URL, nil)
if err != nil {
return nil, fmt.Errorf("access denied: %w", err)
}
@ -182,7 +182,7 @@ func (c *QueryCondition) executeQuery(context *alerting.EvalContext, timeRange l
RefID: q.RefID,
Model: q.Model,
Datasource: simplejson.NewFromAny(map[string]interface{}{
"id": q.DataSource.Id,
"id": q.DataSource.ID,
"name": q.DataSource.Name,
}),
MaxDataPoints: q.MaxDataPoints,

2
pkg/services/alerting/conditions/query_interval_test.go
View File

@ -151,7 +151,7 @@ func applyScenario(t *testing.T, timeRange string, dataSourceJsonData *simplejso
Store: store,
DatasourceService: &fd.FakeDataSourceService{
DataSources: []*datasources.DataSource{
{Id: 1, Type: datasources.DS_GRAPHITE, JsonData: dataSourceJsonData},
{ID: 1, Type: datasources.DS_GRAPHITE, JsonData: dataSourceJsonData},
},
},
}

2
pkg/services/alerting/conditions/query_test.go
View File

@ -48,7 +48,7 @@ func TestQueryCondition(t *testing.T) {
Store: store,
DatasourceService: &fd.FakeDataSourceService{
DataSources: []*datasources.DataSource{
{Id: 1, Type: datasources.DS_GRAPHITE},
{ID: 1, Type: datasources.DS_GRAPHITE},
},
},
}

2
pkg/services/alerting/engine_test.go
View File

@ -129,7 +129,7 @@ func TestEngineProcessJob(t *testing.T) {
store := &AlertStoreMock{}
dsMock := &fd.FakeDataSourceService{
DataSources: []*datasources.DataSource{{Id: 1, Type: datasources.DS_PROMETHEUS}},
DataSources: []*datasources.DataSource{{ID: 1, Type: datasources.DS_PROMETHEUS}},
}
engine := ProvideAlertEngine(nil, nil, nil, usMock, encService, nil, tracer, store, setting.NewCfg(), nil, nil, localcache.New(time.Minute, time.Minute), dsMock, annotationstest.NewFakeAnnotationsRepo())
setting.AlertingEvaluationTimeout = 30 * time.Second

22
pkg/services/alerting/extractor.go
View File

@ -52,14 +52,14 @@ func (e *DashAlertExtractorService) lookupQueryDataSource(ctx context.Context, p
}
if dsName == "" && dsUid == "" {
query := &datasources.GetDefaultDataSourceQuery{OrgId: orgID}
query := &datasources.GetDefaultDataSourceQuery{OrgID: orgID}
if err := e.datasourceService.GetDefaultDataSource(ctx, query); err != nil {
return nil, err
}
return query.Result, nil
}
query := &datasources.GetDataSourceQuery{Name: dsName, Uid: dsUid, OrgId: orgID}
query := &datasources.GetDataSourceQuery{Name: dsName, UID: dsUid, OrgID: orgID}
if err := e.datasourceService.GetDataSource(ctx, query); err != nil {
return nil, err
}
@ -175,10 +175,10 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
}
alert := &models.Alert{
DashboardId: dashAlertInfo.Dash.ID,
OrgId: dashAlertInfo.OrgID,
PanelId: panelID,
Id: jsonAlert.Get("id").MustInt64(),
DashboardID: dashAlertInfo.Dash.ID,
OrgID: dashAlertInfo.OrgID,
PanelID: panelID,
ID: jsonAlert.Get("id").MustInt64(),
Name: jsonAlert.Get("name").MustString(),
Handler: jsonAlert.Get("handler").MustInt64(),
Message: jsonAlert.Get("message").MustString(),
@ -196,9 +196,9 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
if panelQuery == nil {
var reason string
if UAEnabled(ctx) {
reason = fmt.Sprintf("Alert on PanelId: %v refers to query(%s) that cannot be found. Legacy alerting queries are not able to be removed at this time in order to preserve the ability to rollback to previous versions of Grafana", alert.PanelId, queryRefID)
reason = fmt.Sprintf("Alert on PanelId: %v refers to query(%s) that cannot be found. Legacy alerting queries are not able to be removed at this time in order to preserve the ability to rollback to previous versions of Grafana", alert.PanelID, queryRefID)
} else {
reason = fmt.Sprintf("Alert on PanelId: %v refers to query(%s) that cannot be found", alert.PanelId, queryRefID)
reason = fmt.Sprintf("Alert on PanelId: %v refers to query(%s) that cannot be found", alert.PanelID, queryRefID)
}
return nil, ValidationError{Reason: reason}
}
@ -221,7 +221,7 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
return nil, datasources.ErrDataSourceAccessDenied
}
jsonQuery.SetPath([]string{"datasourceId"}, datasource.Id)
jsonQuery.SetPath([]string{"datasourceId"}, datasource.ID)
if interval, err := panel.Get("interval").String(); err == nil {
panelQuery.Set("interval", interval)
@ -250,7 +250,7 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
func validateAlertRule(alert *models.Alert) error {
if !alert.ValidDashboardPanel() {
return ValidationError{Reason: fmt.Sprintf("Panel id is not correct, alertName=%v, panelId=%v", alert.Name, alert.PanelId)}
return ValidationError{Reason: fmt.Sprintf("Panel id is not correct, alertName=%v, panelId=%v", alert.Name, alert.PanelID)}
}
if !alert.ValidTags() {
return ValidationError{Reason: "Invalid tags, must be less than 100 characters"}
@ -301,7 +301,7 @@ func (e *DashAlertExtractorService) extractAlerts(ctx context.Context, validateF
// in the first validation pass.
func (e *DashAlertExtractorService) ValidateAlerts(ctx context.Context, dashAlertInfo DashAlertInfo) error {
_, err := e.extractAlerts(ctx, func(alert *models.Alert) error {
if alert.OrgId == 0 || alert.PanelId == 0 {
if alert.OrgID == 0 || alert.PanelID == 0 {
return errors.New("missing OrgId, PanelId or both")
}
return nil

20
pkg/services/alerting/extractor_test.go
View File

@ -27,8 +27,8 @@ func TestAlertRuleExtraction(t *testing.T) {
})
// mock data
defaultDs := &datasources.DataSource{Id: 12, OrgId: 1, Name: "I am default", IsDefault: true, Uid: "def-uid"}
graphite2Ds := &datasources.DataSource{Id: 15, OrgId: 1, Name: "graphite2", Uid: "graphite2-uid"}
defaultDs := &datasources.DataSource{ID: 12, OrgID: 1, Name: "I am default", IsDefault: true, UID: "def-uid"}
graphite2Ds := &datasources.DataSource{ID: 15, OrgID: 1, Name: "graphite2", UID: "graphite2-uid"}
json, err := os.ReadFile("./testdata/graphite-alert.json")
require.Nil(t, err)
@ -36,7 +36,7 @@ func TestAlertRuleExtraction(t *testing.T) {
dsPermissions := permissions.NewMockDatasourcePermissionService()
dsPermissions.DsResult = []*datasources.DataSource{
{
Id: 1,
ID: 1,
},
}
@ -74,7 +74,7 @@ func TestAlertRuleExtraction(t *testing.T) {
dashJSON, err := simplejson.NewJson(json)
require.Nil(t, err)
dsService.ExpectedDatasource = &datasources.DataSource{Id: 12}
dsService.ExpectedDatasource = &datasources.DataSource{ID: 12}
alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
User: nil,
Dash: dashboards.NewDashboardFromJson(dashJSON),
@ -86,7 +86,7 @@ func TestAlertRuleExtraction(t *testing.T) {
require.Len(t, alerts, 2)
for _, v := range alerts {
require.EqualValues(t, v.DashboardId, 57)
require.EqualValues(t, v.DashboardID, 57)
require.NotEmpty(t, v.Name)
require.NotEmpty(t, v.Message)
@ -100,8 +100,8 @@ func TestAlertRuleExtraction(t *testing.T) {
require.EqualValues(t, alerts[0].Frequency, 60)
require.EqualValues(t, alerts[1].Frequency, 60)
require.EqualValues(t, alerts[0].PanelId, 3)
require.EqualValues(t, alerts[1].PanelId, 4)
require.EqualValues(t, alerts[0].PanelID, 3)
require.EqualValues(t, alerts[1].PanelID, 4)
require.Equal(t, alerts[0].For, time.Minute*2)
require.Equal(t, alerts[1].For, time.Duration(0))
@ -173,7 +173,7 @@ func TestAlertRuleExtraction(t *testing.T) {
dashJSON, err := simplejson.NewJson(panelWithoutSpecifiedDatasource)
require.Nil(t, err)
dsService.ExpectedDatasource = &datasources.DataSource{Id: 12}
dsService.ExpectedDatasource = &datasources.DataSource{ID: 12}
alerts, err := extractor.GetAlerts(context.Background(), DashAlertInfo{
User: nil,
Dash: dashboards.NewDashboardFromJson(dashJSON),
@ -230,7 +230,7 @@ func TestAlertRuleExtraction(t *testing.T) {
require.Len(t, alerts, 1)
for _, alert := range alerts {
require.EqualValues(t, alert.DashboardId, 4)
require.EqualValues(t, alert.DashboardID, 4)
conditions := alert.Settings.Get("conditions").MustArray()
cond := simplejson.NewFromAny(conditions[0])
@ -310,7 +310,7 @@ func TestFilterPermissionsErrors(t *testing.T) {
})
// mock data
defaultDs := &datasources.DataSource{Id: 12, OrgId: 1, Name: "I am default", IsDefault: true, Uid: "def-uid"}
defaultDs := &datasources.DataSource{ID: 12, OrgID: 1, Name: "I am default", IsDefault: true, UID: "def-uid"}
json, err := os.ReadFile("./testdata/graphite-alert.json")
require.Nil(t, err)

46
pkg/services/alerting/models/alert.go
View File

@ -67,11 +67,11 @@ func (s ExecutionErrorOption) ToAlertState() AlertStateType {
// swagger:model LegacyAlert
type Alert struct {
Id int64
ID int64 `xorm:"pk autoincr 'id'"`
Version int64
OrgId int64
DashboardId int64
PanelId int64
OrgID int64 `xorm:"org_id"`
DashboardID int64 `xorm:"dashboard_id"`
PanelID int64 `xorm:"panel_id"`
Name string
Message string
Severity string // Unused
@ -93,7 +93,7 @@ type Alert struct {
}
func (a *Alert) ValidDashboardPanel() bool {
return a.OrgId != 0 && a.DashboardId != 0 && a.PanelId != 0
return a.OrgID != 0 && a.DashboardID != 0 && a.PanelID != 0
}
func (a *Alert) ValidTags() bool {
@ -141,8 +141,8 @@ func (a *Alert) GetTagsFromSettings() []*tag.Tag {
}
type PauseAlertCommand struct {
OrgId int64
AlertIds []int64
OrgID int64 `xorm:"org_id"`
AlertIDs []int64 `xorm:"alert_ids"`
ResultCount int64
Paused bool
}
@ -153,8 +153,8 @@ type PauseAllAlertCommand struct {
}
type SetAlertStateCommand struct {
AlertId int64
OrgId int64
AlertID int64 `xorm:"alert_id"`
OrgID int64 `xorm:"org_id"`
State AlertStateType
Error string
EvalData *simplejson.Json
@ -162,10 +162,10 @@ type SetAlertStateCommand struct {
// Queries
type GetAlertsQuery struct {
OrgId int64
OrgID int64 `xorm:"org_id"`
State []string
DashboardIDs []int64
PanelId int64
DashboardIDs []int64 `xorm:"dashboard_ids"`
PanelID int64 `xorm:"panel_id"`
Limit int64
Query string
User *user.SignedInUser
@ -174,33 +174,33 @@ type GetAlertsQuery struct {
type GetAllAlertsQuery struct{}
type GetAlertByIdQuery struct {
Id int64
ID int64 `xorm:"id"`
}
type GetAlertStatesForDashboardQuery struct {
OrgId int64
DashboardId int64
OrgID int64 `xorm:"org_id"`
DashboardID int64 `xorm:"dashboard_id"`
}
type AlertListItemDTO struct {
Id int64 `json:"id"`
DashboardId int64 `json:"dashboardId"`
DashboardUid string `json:"dashboardUid"`
ID int64 `json:"id" xorm:"id"`
DashboardID int64 `json:"dashboardId" xorm:"dashboard_id"`
DashboardUID string `json:"dashboardUid" xorm:"dashboard_uid"`
DashboardSlug string `json:"dashboardSlug"`
PanelId int64 `json:"panelId"`
PanelID int64 `json:"panelId" xorm:"panel_id"`
Name string `json:"name"`
State AlertStateType `json:"state"`
NewStateDate time.Time `json:"newStateDate"`
EvalDate time.Time `json:"evalDate"`
EvalData *simplejson.Json `json:"evalData"`
ExecutionError string `json:"executionError"`
Url string `json:"url"`
URL string `json:"url" xorm:"url"`
}
type AlertStateInfoDTO struct {
Id int64 `json:"id"`
DashboardId int64 `json:"dashboardId"`
PanelId int64 `json:"panelId"`
ID int64 `json:"id" xorm:"id"`
DashboardID int64 `json:"dashboardId" xorm:"dashboard_id"`
PanelID int64 `json:"panelId" xorm:"panel_id"`
State AlertStateType `json:"state"`
NewStateDate time.Time `json:"newStateDate"`
}

2
pkg/services/alerting/reader.go
View File

@ -40,7 +40,7 @@ func (arr *defaultRuleReader) fetch(ctx context.Context) []*Rule {
res := make([]*Rule, 0)
for _, ruleDef := range alerts {
if model, err := NewRuleFromDBAlert(ctx, arr.sqlStore, ruleDef, false); err != nil {
arr.log.Error("Could not build alert model for rule", "ruleId", ruleDef.Id, "error", err)
arr.log.Error("Could not build alert model for rule", "ruleId", ruleDef.ID, "error", err)
} else {
res = append(res, model)
}

4
pkg/services/alerting/result_handler.go
View File

@ -52,8 +52,8 @@ func (handler *defaultResultHandler) handle(evalContext *EvalContext) error {
handler.log.Info("New state change", "ruleId", evalContext.Rule.ID, "newState", evalContext.Rule.State, "prev state", evalContext.PrevAlertState)
cmd := &models.SetAlertStateCommand{
AlertId: evalContext.Rule.ID,
OrgId: evalContext.Rule.OrgID,
AlertID: evalContext.Rule.ID,
OrgID: evalContext.Rule.OrgID,
State: evalContext.Rule.State,
Error: executionError,
EvalData: annotationData,

10
pkg/services/alerting/rule.go
View File

@ -147,10 +147,10 @@ func getForValue(rawFor string) (time.Duration, error) {
// alert to an in-memory version.
func NewRuleFromDBAlert(ctx context.Context, store AlertStore, ruleDef *models.Alert, logTranslationFailures bool) (*Rule, error) {
model := &Rule{}
model.ID = ruleDef.Id
model.OrgID = ruleDef.OrgId
model.DashboardID = ruleDef.DashboardId
model.PanelID = ruleDef.PanelId
model.ID = ruleDef.ID
model.OrgID = ruleDef.OrgID
model.DashboardID = ruleDef.DashboardID
model.PanelID = ruleDef.PanelID
model.Name = ruleDef.Name
model.Message = ruleDef.Message
model.State = ruleDef.State
@ -170,7 +170,7 @@ func NewRuleFromDBAlert(ctx context.Context, store AlertStore, ruleDef *models.A
for _, v := range ruleDef.Settings.Get("notifications").MustArray() {
jsonModel := simplejson.NewFromAny(v)
if id, err := jsonModel.Get("id").Int64(); err == nil {
uid, err := translateNotificationIDToUID(ctx, store, id, ruleDef.OrgId)
uid, err := translateNotificationIDToUID(ctx, store, id, ruleDef.OrgID)
if err != nil {
if !errors.Is(err, models.ErrAlertNotificationFailedTranslateUniqueID) {
logger.Error("Failed to translate notification id to uid", "error", err.Error(), "dashboardId", model.DashboardID, "alert", model.Name, "panelId", model.PanelID, "notificationId", id)

32
pkg/services/alerting/rule_test.go
View File

@ -124,10 +124,10 @@ func TestAlertRuleModel(t *testing.T) {
require.Nil(t, jsonErr)
alert := &models.Alert{
Id: 1,
OrgId: 1,
DashboardId: 1,
PanelId: 1,
ID: 1,
OrgID: 1,
DashboardID: 1,
PanelID: 1,
Settings: alertJSON,
}
@ -163,10 +163,10 @@ func TestAlertRuleModel(t *testing.T) {
require.Nil(t, jsonErr)
alert := &models.Alert{
Id: 1,
OrgId: 1,
DashboardId: 1,
PanelId: 1,
ID: 1,
OrgID: 1,
DashboardID: 1,
PanelID: 1,
Settings: alertJSON,
}
@ -193,10 +193,10 @@ func TestAlertRuleModel(t *testing.T) {
require.Nil(t, jsonErr)
alert := &models.Alert{
Id: 1,
OrgId: 1,
DashboardId: 1,
PanelId: 1,
ID: 1,
OrgID: 1,
DashboardID: 1,
PanelID: 1,
Frequency: 0,
Settings: alertJSON,
@ -231,10 +231,10 @@ func TestAlertRuleModel(t *testing.T) {
require.Nil(t, jsonErr)
alert := &models.Alert{
Id: 1,
OrgId: 1,
DashboardId: 1,
PanelId: 1,
ID: 1,
OrgID: 1,
DashboardID: 1,
PanelID: 1,
Frequency: 0,
Settings: alertJSON,

38
pkg/services/alerting/store.go
View File

@ -56,7 +56,7 @@ func ProvideAlertStore(
func (ss *sqlStore) GetAlertById(ctx context.Context, query *alertmodels.GetAlertByIdQuery) (res *alertmodels.Alert, err error) {
err = ss.db.WithDbSession(ctx, func(sess *db.Session) error {
alert := alertmodels.Alert{}
has, err := sess.ID(query.Id).Get(&alert)
has, err := sess.ID(query.ID).Get(&alert)
if !has {
return fmt.Errorf("could not find alert")
}
@ -125,7 +125,7 @@ func (ss *sqlStore) HandleAlertsQuery(ctx context.Context, query *alertmodels.Ge
FROM alert
INNER JOIN dashboard on dashboard.id = alert.dashboard_id `)
builder.Write(`WHERE alert.org_id = ?`, query.OrgId)
builder.Write(`WHERE alert.org_id = ?`, query.OrgID)
if len(strings.TrimSpace(query.Query)) > 0 {
builder.Write(" AND alert.name "+ss.db.GetDialect().LikeStr()+" ?", "%"+query.Query+"%")
@ -139,8 +139,8 @@ func (ss *sqlStore) HandleAlertsQuery(ctx context.Context, query *alertmodels.Ge
}
}
if query.PanelId != 0 {
builder.Write(` AND alert.panel_id = ?`, query.PanelId)
if query.PanelID != 0 {
builder.Write(` AND alert.panel_id = ?`, query.PanelID)
}
if len(query.State) > 0 && query.State[0] != "all" {
@ -212,9 +212,9 @@ func (ss *sqlStore) UpdateAlerts(ctx context.Context, existingAlerts []*alertmod
var alertToUpdate *alertmodels.Alert
for _, k := range existingAlerts {
if alert.PanelId == k.PanelId {
if alert.PanelID == k.PanelID {
update = true
alert.Id = k.Id
alert.ID = k.ID
alertToUpdate = k
break
}
@ -226,12 +226,12 @@ func (ss *sqlStore) UpdateAlerts(ctx context.Context, existingAlerts []*alertmod
alert.State = alertToUpdate.State
sess.MustCols("message", "for")
_, err := sess.ID(alert.Id).Update(alert)
_, err := sess.ID(alert.ID).Update(alert)
if err != nil {
return err
}
log.Debug("Alert updated", "name", alert.Name, "id", alert.Id)
log.Debug("Alert updated", "name", alert.Name, "id", alert.ID)
}
} else {
alert.Updated = timeNow()
@ -244,10 +244,10 @@ func (ss *sqlStore) UpdateAlerts(ctx context.Context, existingAlerts []*alertmod
return err
}
log.Debug("Alert inserted", "name", alert.Name, "id", alert.Id)
log.Debug("Alert inserted", "name", alert.Name, "id", alert.ID)
}
tags := alert.GetTagsFromSettings()
if _, err := sess.Exec("DELETE FROM alert_rule_tag WHERE alert_id = ?", alert.Id); err != nil {
if _, err := sess.Exec("DELETE FROM alert_rule_tag WHERE alert_id = ?", alert.ID); err != nil {
return err
}
if tags != nil {
@ -256,7 +256,7 @@ func (ss *sqlStore) UpdateAlerts(ctx context.Context, existingAlerts []*alertmod
return err
}
for _, tag := range tags {
if _, err := sess.Exec("INSERT INTO alert_rule_tag (alert_id, tag_id) VALUES(?,?)", alert.Id, tag.Id); err != nil {
if _, err := sess.Exec("INSERT INTO alert_rule_tag (alert_id, tag_id) VALUES(?,?)", alert.ID, tag.Id); err != nil {
return err
}
}
@ -271,14 +271,14 @@ func deleteMissingAlerts(alerts []*alertmodels.Alert, existingAlerts []*alertmod
missing := true
for _, k := range existingAlerts {
if missingAlert.PanelId == k.PanelId {
if missingAlert.PanelID == k.PanelID {
missing = false
break
}
}
if missing {
if err := deleteAlertByIdInternal(missingAlert.Id, "Removed from dashboard", sess, log); err != nil {
if err := deleteAlertByIdInternal(missingAlert.ID, "Removed from dashboard", sess, log); err != nil {
// No use trying to delete more, since we're in a transaction and it will be
// rolled back on error.
return err
@ -304,7 +304,7 @@ func (ss *sqlStore) SetAlertState(ctx context.Context, cmd *alertmodels.SetAlert
err = ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
alert := alertmodels.Alert{}
if has, err := sess.ID(cmd.AlertId).Get(&alert); err != nil {
if has, err := sess.ID(cmd.AlertID).Get(&alert); err != nil {
return err
} else if !has {
return fmt.Errorf("could not find alert")
@ -329,7 +329,7 @@ func (ss *sqlStore) SetAlertState(ctx context.Context, cmd *alertmodels.SetAlert
alert.ExecutionError = cmd.Error
}
_, err := sess.ID(alert.Id).Update(&alert)
_, err := sess.ID(alert.ID).Update(&alert)
if err != nil {
return err
}
@ -342,7 +342,7 @@ func (ss *sqlStore) SetAlertState(ctx context.Context, cmd *alertmodels.SetAlert
func (ss *sqlStore) PauseAlert(ctx context.Context, cmd *alertmodels.PauseAlertCommand) error {
return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
if len(cmd.AlertIds) == 0 {
if len(cmd.AlertIDs) == 0 {
return fmt.Errorf("command contains no alertids")
}
@ -358,8 +358,8 @@ func (ss *sqlStore) PauseAlert(ctx context.Context, cmd *alertmodels.PauseAlertC
params = append(params, timeNow().UTC())
}
buffer.WriteString(` WHERE id IN (?` + strings.Repeat(",?", len(cmd.AlertIds)-1) + `)`)
for _, v := range cmd.AlertIds {
buffer.WriteString(` WHERE id IN (?` + strings.Repeat(",?", len(cmd.AlertIDs)-1) + `)`)
for _, v := range cmd.AlertIDs {
params = append(params, v)
}
@ -404,7 +404,7 @@ func (ss *sqlStore) GetAlertStatesForDashboard(ctx context.Context, query *alert
WHERE org_id = ? AND dashboard_id = ?`
res = make([]*alertmodels.AlertStateInfoDTO, 0)
return sess.SQL(rawSQL, query.OrgId, query.DashboardId).Find(&res)
return sess.SQL(rawSQL, query.OrgID, query.DashboardID).Find(&res)
})
return res, err
}

84
pkg/services/alerting/store_test.go
View File

@ -62,9 +62,9 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
require.Nil(t, err)
items = []*models.Alert{
{
PanelId: 1,
DashboardId: testDash.ID,
OrgId: testDash.OrgID,
PanelID: 1,
DashboardID: testDash.ID,
OrgID: testDash.OrgID,
Name: "Alerting title",
Message: "Alerting message",
Settings: simplejson.New(),
@ -81,7 +81,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
setup(t)
// Get alert so we can use its ID in tests
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelId: 1, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelID: 1, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
result, err2 := store.HandleAlertsQuery(context.Background(), &alertQuery)
require.Nil(t, err2)
@ -89,7 +89,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
t.Run("new state ok", func(t *testing.T) {
cmd := &models.SetAlertStateCommand{
AlertId: insertedAlert.Id,
AlertID: insertedAlert.ID,
State: models.AlertStateOK,
}
@ -97,7 +97,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
require.Nil(t, err)
})
alert, _ := getAlertById(t, insertedAlert.Id, store)
alert, _ := getAlertById(t, insertedAlert.ID, store)
stateDateBeforePause := alert.NewStateDate
t.Run("can pause all alerts", func(t *testing.T) {
@ -106,7 +106,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
t.Run("cannot updated paused alert", func(t *testing.T) {
cmd := &models.SetAlertStateCommand{
AlertId: insertedAlert.Id,
AlertID: insertedAlert.ID,
State: models.AlertStateOK,
}
@ -115,13 +115,13 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
})
t.Run("alert is paused", func(t *testing.T) {
alert, _ = getAlertById(t, insertedAlert.Id, store)
alert, _ = getAlertById(t, insertedAlert.ID, store)
currentState := alert.State
require.Equal(t, models.AlertStatePaused, currentState)
})
t.Run("pausing alerts should update their NewStateDate", func(t *testing.T) {
alert, _ = getAlertById(t, insertedAlert.Id, store)
alert, _ = getAlertById(t, insertedAlert.ID, store)
stateDateAfterPause := alert.NewStateDate
require.True(t, stateDateBeforePause.Before(stateDateAfterPause))
})
@ -129,7 +129,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
t.Run("unpausing alerts should update their NewStateDate again", func(t *testing.T) {
err := store.pauseAllAlerts(t, false)
require.Nil(t, err)
alert, _ = getAlertById(t, insertedAlert.Id, store)
alert, _ = getAlertById(t, insertedAlert.ID, store)
stateDateAfterUnpause := alert.NewStateDate
require.True(t, stateDateBeforePause.Before(stateDateAfterUnpause))
})
@ -138,14 +138,14 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
t.Run("Can read properties", func(t *testing.T) {
setup(t)
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelId: 1, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelID: 1, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
result, err2 := store.HandleAlertsQuery(context.Background(), &alertQuery)
alert := result[0]
require.Nil(t, err2)
require.Greater(t, alert.Id, int64(0))
require.Equal(t, testDash.ID, alert.DashboardId)
require.Equal(t, int64(1), alert.PanelId)
require.Greater(t, alert.ID, int64(0))
require.Equal(t, testDash.ID, alert.DashboardID)
require.Equal(t, int64(1), alert.PanelID)
require.Equal(t, "Alerting title", alert.Name)
require.Equal(t, models.AlertStateUnknown, alert.State)
require.NotNil(t, alert.NewStateDate)
@ -153,14 +153,14 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
require.Equal(t, "test", alert.EvalData.Get("test").MustString())
require.NotNil(t, alert.EvalDate)
require.Equal(t, "", alert.ExecutionError)
require.NotNil(t, alert.DashboardUid)
require.NotNil(t, alert.DashboardUID)
require.Equal(t, "dashboard-with-alerts", alert.DashboardSlug)
})
t.Run("Viewer can read alerts", func(t *testing.T) {
setup(t)
viewerUser := &user.SignedInUser{OrgRole: org.RoleViewer, OrgID: 1}
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelId: 1, OrgId: 1, User: viewerUser}
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelID: 1, OrgID: 1, User: viewerUser}
res, err2 := store.HandleAlertsQuery(context.Background(), &alertQuery)
require.Nil(t, err2)
@ -179,7 +179,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
})
t.Run("Alerts should be updated", func(t *testing.T) {
query := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
query := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
res, err2 := store.HandleAlertsQuery(context.Background(), &query)
require.Nil(t, err2)
@ -201,24 +201,24 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
setup(t)
multipleItems := []*models.Alert{
{
DashboardId: testDash.ID,
PanelId: 1,
DashboardID: testDash.ID,
PanelID: 1,
Name: "1",
OrgId: 1,
OrgID: 1,
Settings: simplejson.New(),
},
{
DashboardId: testDash.ID,
PanelId: 2,
DashboardID: testDash.ID,
PanelID: 2,
Name: "2",
OrgId: 1,
OrgID: 1,
Settings: simplejson.New(),
},
{
DashboardId: testDash.ID,
PanelId: 3,
DashboardID: testDash.ID,
PanelID: 3,
Name: "3",
OrgId: 1,
OrgID: 1,
Settings: simplejson.New(),
},
}
@ -228,7 +228,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
t.Run("Should save 3 dashboards", func(t *testing.T) {
require.Nil(t, err)
queryForDashboard := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
queryForDashboard := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
res, err2 := store.HandleAlertsQuery(context.Background(), &queryForDashboard)
require.Nil(t, err2)
@ -241,7 +241,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
err = store.SaveAlerts(context.Background(), testDash.ID, missingOneAlert)
t.Run("should delete the missing alert", func(t *testing.T) {
query := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
query := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
res, err2 := store.HandleAlertsQuery(context.Background(), &query)
require.Nil(t, err2)
require.Equal(t, 2, len(res))
@ -253,8 +253,8 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
setup(t)
items := []*models.Alert{
{
PanelId: 1,
DashboardId: testDash.ID,
PanelID: 1,
DashboardID: testDash.ID,
Name: "Alerting title",
Message: "Alerting message",
},
@ -271,7 +271,7 @@ func TestIntegrationAlertingDataAccess(t *testing.T) {
require.Nil(t, err)
t.Run("Alerts should be removed", func(t *testing.T) {
query := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
query := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
res, err2 := store.HandleAlertsQuery(context.Background(), &query)
require.Nil(t, err2)
@ -299,18 +299,18 @@ func TestIntegrationPausingAlerts(t *testing.T) {
stateDateAfterPause := stateDateBeforePause
// Get alert so we can use its ID in tests
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelId: 1, OrgId: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
alertQuery := models.GetAlertsQuery{DashboardIDs: []int64{testDash.ID}, PanelID: 1, OrgID: 1, User: &user.SignedInUser{OrgRole: org.RoleAdmin}}
res, err2 := sqlStore.HandleAlertsQuery(context.Background(), &alertQuery)
require.Nil(t, err2)
insertedAlert := res[0]
t.Run("when paused", func(t *testing.T) {
_, err := sqlStore.pauseAlert(t, testDash.OrgID, insertedAlert.Id, true)
_, err := sqlStore.pauseAlert(t, testDash.OrgID, insertedAlert.ID, true)
require.Nil(t, err)
t.Run("the NewStateDate should be updated", func(t *testing.T) {
alert, err := getAlertById(t, insertedAlert.Id, &sqlStore)
alert, err := getAlertById(t, insertedAlert.ID, &sqlStore)
require.Nil(t, err)
stateDateAfterPause = alert.NewStateDate
@ -319,11 +319,11 @@ func TestIntegrationPausingAlerts(t *testing.T) {
})
t.Run("when unpaused", func(t *testing.T) {
_, err := sqlStore.pauseAlert(t, testDash.OrgID, insertedAlert.Id, false)
_, err := sqlStore.pauseAlert(t, testDash.OrgID, insertedAlert.ID, false)
require.Nil(t, err)
t.Run("the NewStateDate should be updated again", func(t *testing.T) {
alert, err := getAlertById(t, insertedAlert.Id, &sqlStore)
alert, err := getAlertById(t, insertedAlert.ID, &sqlStore)
require.Nil(t, err)
stateDateAfterUnpause := alert.NewStateDate
@ -335,8 +335,8 @@ func TestIntegrationPausingAlerts(t *testing.T) {
func (ss *sqlStore) pauseAlert(t *testing.T, orgId int64, alertId int64, pauseState bool) (int64, error) {
cmd := &models.PauseAlertCommand{
OrgId: orgId,
AlertIds: []int64{alertId},
OrgID: orgId,
AlertIDs: []int64{alertId},
Paused: pauseState,
}
err := ss.PauseAlert(context.Background(), cmd)
@ -347,9 +347,9 @@ func (ss *sqlStore) pauseAlert(t *testing.T, orgId int64, alertId int64, pauseSt
func insertTestAlert(title string, message string, orgId int64, dashId int64, settings *simplejson.Json, ss sqlStore) (*models.Alert, error) {
items := []*models.Alert{
{
PanelId: 1,
DashboardId: dashId,
OrgId: orgId,
PanelID: 1,
DashboardID: dashId,
OrgID: orgId,
Name: title,
Message: message,
Settings: settings,
@ -363,7 +363,7 @@ func insertTestAlert(title string, message string, orgId int64, dashId int64, se
func getAlertById(t *testing.T, id int64, ss *sqlStore) (*models.Alert, error) {
q := &models.GetAlertByIdQuery{
Id: id,
ID: id,
}
res, err := ss.GetAlertById(context.Background(), q)
require.Nil(t, err)

2
pkg/services/alerting/test_rule.go
View File

@ -24,7 +24,7 @@ func (e *AlertEngine) AlertTest(orgID int64, dashboard *simplejson.Json, panelID
}
for _, alert := range alerts {
if alert.PanelId != panelID {
if alert.PanelID != panelID {
continue
}
rule, err := NewRuleFromDBAlert(context.Background(), e.AlertStore, alert, true)

24
pkg/services/correlations/database.go
View File

@ -23,8 +23,8 @@ func (s CorrelationsService) createCorrelation(ctx context.Context, cmd CreateCo
var err error
query := &datasources.GetDataSourceQuery{
OrgId: cmd.OrgId,
Uid: cmd.SourceUID,
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err = s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists
@ -36,8 +36,8 @@ func (s CorrelationsService) createCorrelation(ctx context.Context, cmd CreateCo
if cmd.TargetUID != nil {
if err = s.DataSourceService.GetDataSource(ctx, &datasources.GetDataSourceQuery{
OrgId: cmd.OrgId,
Uid: *cmd.TargetUID,
OrgID: cmd.OrgId,
UID: *cmd.TargetUID,
}); err != nil {
return ErrTargetDataSourceDoesNotExists
}
@ -61,8 +61,8 @@ func (s CorrelationsService) createCorrelation(ctx context.Context, cmd CreateCo
func (s CorrelationsService) deleteCorrelation(ctx context.Context, cmd DeleteCorrelationCommand) error {
return s.SQLStore.WithDbSession(ctx, func(session *db.Session) error {
query := &datasources.GetDataSourceQuery{
OrgId: cmd.OrgId,
Uid: cmd.SourceUID,
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists
@ -88,8 +88,8 @@ func (s CorrelationsService) updateCorrelation(ctx context.Context, cmd UpdateCo
err := s.SQLStore.WithTransactionalDbSession(ctx, func(session *db.Session) error {
query := &datasources.GetDataSourceQuery{
OrgId: cmd.OrgId,
Uid: cmd.SourceUID,
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists
@ -150,8 +150,8 @@ func (s CorrelationsService) getCorrelation(ctx context.Context, cmd GetCorrelat
err := s.SQLStore.WithTransactionalDbSession(ctx, func(session *db.Session) error {
query := &datasources.GetDataSourceQuery{
OrgId: cmd.OrgId,
Uid: cmd.SourceUID,
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists
@ -176,8 +176,8 @@ func (s CorrelationsService) getCorrelationsBySourceUID(ctx context.Context, cmd
err := s.SQLStore.WithTransactionalDbSession(ctx, func(session *db.Session) error {
query := &datasources.GetDataSourceQuery{
OrgId: cmd.OrgId,
Uid: cmd.SourceUID,
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists

20
pkg/services/dashboards/database/database.go
View File

@ -591,9 +591,9 @@ func (d *DashboardStore) updateAlerts(ctx context.Context, existingAlerts []*ale
var alertToUpdate *alertmodels.Alert
for _, k := range existingAlerts {
if alert.PanelId == k.PanelId {
if alert.PanelID == k.PanelID {
update = true
alert.Id = k.Id
alert.ID = k.ID
alertToUpdate = k
break
}
@ -605,12 +605,12 @@ func (d *DashboardStore) updateAlerts(ctx context.Context, existingAlerts []*ale
alert.State = alertToUpdate.State
sess.MustCols("message", "for")
_, err := sess.ID(alert.Id).Update(alert)
_, err := sess.ID(alert.ID).Update(alert)
if err != nil {
return err
}
log.Debug("Alert updated", "name", alert.Name, "id", alert.Id)
log.Debug("Alert updated", "name", alert.Name, "id", alert.ID)
}
} else {
alert.Updated = time.Now()
@ -623,10 +623,10 @@ func (d *DashboardStore) updateAlerts(ctx context.Context, existingAlerts []*ale
return err
}
log.Debug("Alert inserted", "name", alert.Name, "id", alert.Id)
log.Debug("Alert inserted", "name", alert.Name, "id", alert.ID)
}
tags := alert.GetTagsFromSettings()
if _, err := sess.Exec("DELETE FROM alert_rule_tag WHERE alert_id = ?", alert.Id); err != nil {
if _, err := sess.Exec("DELETE FROM alert_rule_tag WHERE alert_id = ?", alert.ID); err != nil {
return err
}
if tags != nil {
@ -635,7 +635,7 @@ func (d *DashboardStore) updateAlerts(ctx context.Context, existingAlerts []*ale
return err
}
for _, tag := range tags {
if _, err := sess.Exec("INSERT INTO alert_rule_tag (alert_id, tag_id) VALUES(?,?)", alert.Id, tag.Id); err != nil {
if _, err := sess.Exec("INSERT INTO alert_rule_tag (alert_id, tag_id) VALUES(?,?)", alert.ID, tag.Id); err != nil {
return err
}
}
@ -650,14 +650,14 @@ func (d *DashboardStore) deleteMissingAlerts(alerts []*alertmodels.Alert, existi
missing := true
for _, k := range existingAlerts {
if missingAlert.PanelId == k.PanelId {
if missingAlert.PanelID == k.PanelID {
missing = false
break
}
}
if missing {
if err := d.deleteAlertByIdInternal(missingAlert.Id, "Removed from dashboard", sess); err != nil {
if err := d.deleteAlertByIdInternal(missingAlert.ID, "Removed from dashboard", sess); err != nil {
// No use trying to delete more, since we're in a transaction and it will be
// rolled back on error.
return err
@ -856,7 +856,7 @@ func (d *DashboardStore) deleteAlertDefinition(dashboardId int64, sess *db.Sessi
}
for _, alert := range alerts {
if err := d.deleteAlertByIdInternal(alert.Id, "Dashboard deleted", sess); err != nil {
if err := d.deleteAlertByIdInternal(alert.ID, "Dashboard deleted", sess); err != nil {
// If we return an error, the current transaction gets rolled back, so no use
// trying to delete more
return err

4
pkg/services/datasourceproxy/datasourceproxy.go
View File

@ -105,7 +105,7 @@ func toAPIError(c *contextmodel.ReqContext, err error) {
}
func (p *DataSourceProxyService) proxyDatasourceRequest(c *contextmodel.ReqContext, ds *datasources.DataSource) {
err := p.PluginRequestValidator.Validate(ds.Url, c.Req)
err := p.PluginRequestValidator.Validate(ds.URL, c.Req)
if err != nil {
c.JsonApiErr(http.StatusForbidden, "Access denied", err)
return
@ -123,7 +123,7 @@ func (p *DataSourceProxyService) proxyDatasourceRequest(c *contextmodel.ReqConte
p.OAuthTokenService, p.DataSourcesService, p.tracer)
if err != nil {
if errors.Is(err, datasource.URLValidationError{}) {
c.JsonApiErr(http.StatusBadRequest, fmt.Sprintf("Invalid data source URL: %q", ds.Url), err)
c.JsonApiErr(http.StatusBadRequest, fmt.Sprintf("Invalid data source URL: %q", ds.URL), err)
} else {
c.JsonApiErr(http.StatusInternalServerError, "Failed creating data source proxy", err)
}

4
pkg/services/datasources/fakes/fake_cache_service.go
View File

@ -15,7 +15,7 @@ var _ datasources.CacheService = &FakeCacheService{}
func (c *FakeCacheService) GetDatasource(ctx context.Context, datasourceID int64, user *user.SignedInUser, skipCache bool) (*datasources.DataSource, error) {
for _, datasource := range c.DataSources {
if datasource.Id == datasourceID {
if datasource.ID == datasourceID {
return datasource, nil
}
}
@ -24,7 +24,7 @@ func (c *FakeCacheService) GetDatasource(ctx context.Context, datasourceID int64
func (c *FakeCacheService) GetDatasourceByUID(ctx context.Context, datasourceUID string, user *user.SignedInUser, skipCache bool) (*datasources.DataSource, error) {
for _, datasource := range c.DataSources {
if datasource.Uid == datasourceUID {
if datasource.UID == datasourceUID {
return datasource, nil
}
}

28
pkg/services/datasources/fakes/fake_datasource_service.go
View File

@ -11,7 +11,7 @@ import (
)
type FakeDataSourceService struct {
lastId int64
lastID int64
DataSources []*datasources.DataSource
SimulatePluginFailure bool
}
@ -20,8 +20,8 @@ var _ datasources.DataSourceService = &FakeDataSourceService{}
func (s *FakeDataSourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
for _, datasource := range s.DataSources {
idMatch := query.Id != 0 && query.Id == datasource.Id
uidMatch := query.Uid != "" && query.Uid == datasource.Uid
idMatch := query.ID != 0 && query.ID == datasource.ID
uidMatch := query.UID != "" && query.UID == datasource.UID
nameMatch := query.Name != "" && query.Name == datasource.Name
if idMatch || nameMatch || uidMatch {
query.Result = datasource
@ -34,7 +34,7 @@ func (s *FakeDataSourceService) GetDataSource(ctx context.Context, query *dataso
func (s *FakeDataSourceService) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
for _, datasource := range s.DataSources {
orgMatch := query.OrgId != 0 && query.OrgId == datasource.OrgId
orgMatch := query.OrgID != 0 && query.OrgID == datasource.OrgID
if orgMatch {
query.Result = append(query.Result, datasource)
}
@ -49,7 +49,7 @@ func (s *FakeDataSourceService) GetAllDataSources(ctx context.Context, query *da
func (s *FakeDataSourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
for _, datasource := range s.DataSources {
if query.OrgId > 0 && datasource.OrgId != query.OrgId {
if query.OrgID > 0 && datasource.OrgID != query.OrgID {
continue
}
typeMatch := query.Type != "" && query.Type == datasource.Type
@ -61,15 +61,15 @@ func (s *FakeDataSourceService) GetDataSourcesByType(ctx context.Context, query
}
func (s *FakeDataSourceService) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
if s.lastId == 0 {
s.lastId = int64(len(s.DataSources) - 1)
if s.lastID == 0 {
s.lastID = int64(len(s.DataSources) - 1)
}
cmd.Result = &datasources.DataSource{
Id: s.lastId + 1,
ID: s.lastID + 1,
Name: cmd.Name,
Type: cmd.Type,
Uid: cmd.Uid,
OrgId: cmd.OrgId,
UID: cmd.UID,
OrgID: cmd.OrgID,
}
s.DataSources = append(s.DataSources, cmd.Result)
return nil
@ -77,8 +77,8 @@ func (s *FakeDataSourceService) AddDataSource(ctx context.Context, cmd *datasour
func (s *FakeDataSourceService) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
for i, datasource := range s.DataSources {
idMatch := cmd.ID != 0 && cmd.ID == datasource.Id
uidMatch := cmd.UID != "" && cmd.UID == datasource.Uid
idMatch := cmd.ID != 0 && cmd.ID == datasource.ID
uidMatch := cmd.UID != "" && cmd.UID == datasource.UID
nameMatch := cmd.Name != "" && cmd.Name == datasource.Name
if idMatch || nameMatch || uidMatch {
s.DataSources = append(s.DataSources[:i], s.DataSources[i+1:]...)
@ -90,8 +90,8 @@ func (s *FakeDataSourceService) DeleteDataSource(ctx context.Context, cmd *datas
func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
for _, datasource := range s.DataSources {
idMatch := cmd.Id != 0 && cmd.Id == datasource.Id
uidMatch := cmd.Uid != "" && cmd.Uid == datasource.Uid
idMatch := cmd.ID != 0 && cmd.ID == datasource.ID
uidMatch := cmd.UID != "" && cmd.UID == datasource.UID
nameMatch := cmd.Name != "" && cmd.Name == datasource.Name
if idMatch || nameMatch || uidMatch {
if cmd.Name != "" {

36
pkg/services/datasources/models.go
View File

@ -33,14 +33,14 @@ const (
type DsAccess string
type DataSource struct {
Id int64 `json:"id,omitempty"`
OrgId int64 `json:"orgId,omitempty"`
ID int64 `json:"id,omitempty" xorm:"pk autoincr 'id'"`
OrgID int64 `json:"orgId,omitempty" xorm:"org_id"`
Version int `json:"version,omitempty"`
Name string `json:"name"`
Type string `json:"type"`
Access DsAccess `json:"access"`
Url string `json:"url"`
URL string `json:"url" xorm:"url"`
// swagger:ignore
Password string `json:"-"`
User string `json:"user"`
@ -54,7 +54,7 @@ type DataSource struct {
JsonData *simplejson.Json `json:"jsonData"`
SecureJsonData map[string][]byte `json:"secureJsonData"`
ReadOnly bool `json:"readOnly"`
Uid string `json:"uid"`
UID string `json:"uid" xorm:"uid"`
Created time.Time `json:"created,omitempty"`
Updated time.Time `json:"updated,omitempty"`
@ -89,7 +89,7 @@ type AddDataSourceCommand struct {
Name string `json:"name" binding:"Required"`
Type string `json:"type" binding:"Required"`
Access DsAccess `json:"access" binding:"Required"`
Url string `json:"url"`
URL string `json:"url"`
Database string `json:"database"`
User string `json:"user"`
BasicAuth bool `json:"basicAuth"`
@ -98,10 +98,10 @@ type AddDataSourceCommand struct {
IsDefault bool `json:"isDefault"`
JsonData *simplejson.Json `json:"jsonData"`
SecureJsonData map[string]string `json:"secureJsonData"`
Uid string `json:"uid"`
UID string `json:"uid"`
OrgId int64 `json:"-"`
UserId int64 `json:"-"`
OrgID int64 `json:"-"`
UserID int64 `json:"-"`
ReadOnly bool `json:"-"`
EncryptedSecureJsonData map[string][]byte `json:"-"`
UpdateSecretFn UpdateSecretFn `json:"-"`
@ -114,7 +114,7 @@ type UpdateDataSourceCommand struct {
Name string `json:"name" binding:"Required"`
Type string `json:"type" binding:"Required"`
Access DsAccess `json:"access" binding:"Required"`
Url string `json:"url"`
URL string `json:"url"`
User string `json:"user"`
Database string `json:"database"`
BasicAuth bool `json:"basicAuth"`
@ -124,10 +124,10 @@ type UpdateDataSourceCommand struct {
JsonData *simplejson.Json `json:"jsonData"`
SecureJsonData map[string]string `json:"secureJsonData"`
Version int `json:"version"`
Uid string `json:"uid"`
UID string `json:"uid"`
OrgId int64 `json:"-"`
Id int64 `json:"-"`
OrgID int64 `json:"-"`
ID int64 `json:"-"`
ReadOnly bool `json:"-"`
EncryptedSecureJsonData map[string][]byte `json:"-"`
UpdateSecretFn UpdateSecretFn `json:"-"`
@ -156,7 +156,7 @@ type UpdateSecretFn func() error
// QUERIES
type GetDataSourcesQuery struct {
OrgId int64
OrgID int64
DataSourceLimit int
User *user.SignedInUser
Result []*DataSource
@ -167,13 +167,13 @@ type GetAllDataSourcesQuery struct {
}
type GetDataSourcesByTypeQuery struct {
OrgId int64 // optional: filter by org_id
OrgID int64 // optional: filter by org_id
Type string
Result []*DataSource
}
type GetDefaultDataSourceQuery struct {
OrgId int64
OrgID int64
User *user.SignedInUser
Result *DataSource
}
@ -181,11 +181,11 @@ type GetDefaultDataSourceQuery struct {
// GetDataSourceQuery will get a DataSource based on OrgID as well as the UID (preferred), ID, or Name.
// At least one of the UID, ID, or Name properties must be set in addition to OrgID.
type GetDataSourceQuery struct {
Id int64
Uid string
ID int64
UID string
Name string
OrgId int64
OrgID int64
Result *DataSource
}

14
pkg/services/datasources/service/cache.go
View File

@ -43,7 +43,7 @@ func (dc *CacheServiceImpl) GetDatasource(
if !skipCache {
if cached, found := dc.CacheService.Get(cacheKey); found {
ds := cached.(*datasources.DataSource)
if ds.OrgId == user.OrgID {
if ds.OrgID == user.OrgID {
return ds, nil
}
}
@ -51,7 +51,7 @@ func (dc *CacheServiceImpl) GetDatasource(
dc.logger.FromContext(ctx).Debug("Querying for data source via SQL store", "id", datasourceID, "orgId", user.OrgID)
query := &datasources.GetDataSourceQuery{Id: datasourceID, OrgId: user.OrgID}
query := &datasources.GetDataSourceQuery{ID: datasourceID, OrgID: user.OrgID}
ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
err := ss.GetDataSource(ctx, query)
if err != nil {
@ -60,8 +60,8 @@ func (dc *CacheServiceImpl) GetDatasource(
ds := query.Result
if ds.Uid != "" {
dc.CacheService.Set(uidKey(ds.OrgId, ds.Uid), ds, time.Second*5)
if ds.UID != "" {
dc.CacheService.Set(uidKey(ds.OrgID, ds.UID), ds, time.Second*5)
}
dc.CacheService.Set(cacheKey, ds, dc.cacheTTL)
return ds, nil
@ -84,14 +84,14 @@ func (dc *CacheServiceImpl) GetDatasourceByUID(
if !skipCache {
if cached, found := dc.CacheService.Get(uidCacheKey); found {
ds := cached.(*datasources.DataSource)
if ds.OrgId == user.OrgID {
if ds.OrgID == user.OrgID {
return ds, nil
}
}
}
dc.logger.FromContext(ctx).Debug("Querying for data source via SQL store", "uid", datasourceUID, "orgId", user.OrgID)
query := &datasources.GetDataSourceQuery{Uid: datasourceUID, OrgId: user.OrgID}
query := &datasources.GetDataSourceQuery{UID: datasourceUID, OrgID: user.OrgID}
ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
err := ss.GetDataSource(ctx, query)
if err != nil {
@ -101,7 +101,7 @@ func (dc *CacheServiceImpl) GetDatasourceByUID(
ds := query.Result
dc.CacheService.Set(uidCacheKey, ds, dc.cacheTTL)
dc.CacheService.Set(idKey(ds.Id), ds, dc.cacheTTL)
dc.CacheService.Set(idKey(ds.ID), ds, dc.cacheTTL)
return ds, nil
}

34
pkg/services/datasources/service/datasource.go
View File

@ -114,12 +114,12 @@ func NewNameScopeResolver(db DataSourceRetriever) (string, accesscontrol.ScopeAt
return nil, accesscontrol.ErrInvalidScope
}
query := datasources.GetDataSourceQuery{Name: dsName, OrgId: orgID}
query := datasources.GetDataSourceQuery{Name: dsName, OrgID: orgID}
if err := db.GetDataSource(ctx, &query); err != nil {
return nil, err
}
return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.Uid)}, nil
return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.UID)}, nil
})
}
@ -142,12 +142,12 @@ func NewIDScopeResolver(db DataSourceRetriever) (string, accesscontrol.ScopeAttr
return nil, accesscontrol.ErrInvalidScope
}
query := datasources.GetDataSourceQuery{Id: dsID, OrgId: orgID}
query := datasources.GetDataSourceQuery{ID: dsID, OrgID: orgID}
if err := db.GetDataSource(ctx, &query); err != nil {
return nil, err
}
return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.Uid)}, nil
return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.UID)}, nil
})
}
@ -185,7 +185,7 @@ func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSou
return err
}
return s.SecretsStore.Set(ctx, cmd.OrgId, cmd.Name, kvstore.DataSourceSecretType, string(secret))
return s.SecretsStore.Set(ctx, cmd.OrgID, cmd.Name, kvstore.DataSourceSecretType, string(secret))
}
if err := s.SQLStore.AddDataSource(ctx, cmd); err != nil {
@ -202,10 +202,10 @@ func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSou
{BuiltinRole: "Viewer", Permission: "Query"},
{BuiltinRole: "Editor", Permission: "Query"},
}
if cmd.UserId != 0 {
permissions = append(permissions, accesscontrol.SetResourcePermissionCommand{UserID: cmd.UserId, Permission: "Edit"})
if cmd.UserID != 0 {
permissions = append(permissions, accesscontrol.SetResourcePermissionCommand{UserID: cmd.UserID, Permission: "Edit"})
}
if _, err := s.permissionsService.SetPermissions(ctx, cmd.OrgId, cmd.Result.Uid, permissions...); err != nil {
if _, err := s.permissionsService.SetPermissions(ctx, cmd.OrgID, cmd.Result.UID, permissions...); err != nil {
return err
}
}
@ -229,8 +229,8 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
var err error
query := &datasources.GetDataSourceQuery{
Id: cmd.Id,
OrgId: cmd.OrgId,
ID: cmd.ID,
OrgID: cmd.OrgID,
}
err = s.SQLStore.GetDataSource(ctx, query)
if err != nil {
@ -242,7 +242,7 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
return err
}
if cmd.OrgId > 0 && cmd.Name != "" {
if cmd.OrgID > 0 && cmd.Name != "" {
cmd.UpdateSecretFn = func() error {
secret, err := json.Marshal(cmd.SecureJsonData)
if err != nil {
@ -250,13 +250,13 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
}
if query.Result.Name != cmd.Name {
err := s.SecretsStore.Rename(ctx, cmd.OrgId, query.Result.Name, kvstore.DataSourceSecretType, cmd.Name)
err := s.SecretsStore.Rename(ctx, cmd.OrgID, query.Result.Name, kvstore.DataSourceSecretType, cmd.Name)
if err != nil {
return err
}
}
return s.SecretsStore.Set(ctx, cmd.OrgId, cmd.Name, kvstore.DataSourceSecretType, string(secret))
return s.SecretsStore.Set(ctx, cmd.OrgID, cmd.Name, kvstore.DataSourceSecretType, string(secret))
}
}
@ -285,7 +285,7 @@ func (s *Service) GetHTTPTransport(ctx context.Context, ds *datasources.DataSour
s.ptc.Lock()
defer s.ptc.Unlock()
if t, present := s.ptc.cache[ds.Id]; present && ds.Updated.Equal(t.updated) {
if t, present := s.ptc.cache[ds.ID]; present && ds.Updated.Equal(t.updated) {
return t.roundTripper, nil
}
@ -301,7 +301,7 @@ func (s *Service) GetHTTPTransport(ctx context.Context, ds *datasources.DataSour
return nil, err
}
s.ptc.cache[ds.Id] = cachedRoundTripper{
s.ptc.cache[ds.ID] = cachedRoundTripper{
roundTripper: rt,
updated: ds.Updated,
}
@ -319,7 +319,7 @@ func (s *Service) GetTLSConfig(ctx context.Context, ds *datasources.DataSource,
func (s *Service) DecryptedValues(ctx context.Context, ds *datasources.DataSource) (map[string]string, error) {
decryptedValues := make(map[string]string)
secret, exist, err := s.SecretsStore.Get(ctx, ds.OrgId, ds.Name, kvstore.DataSourceSecretType)
secret, exist, err := s.SecretsStore.Get(ctx, ds.OrgID, ds.Name, kvstore.DataSourceSecretType)
if err != nil {
return nil, err
}
@ -409,7 +409,7 @@ func (s *Service) httpClientOptions(ctx context.Context, ds *datasources.DataSou
Labels: map[string]string{
"datasource_type": ds.Type,
"datasource_name": ds.Name,
"datasource_uid": ds.Uid,
"datasource_uid": ds.UID,
},
TLS: &tlsOptions,
}

66
pkg/services/datasources/service/datasource_test.go
View File

@ -35,8 +35,8 @@ type dataSourceMockRetriever struct {
func (d *dataSourceMockRetriever) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
for _, datasource := range d.res {
idMatch := query.Id != 0 && query.Id == datasource.Id
uidMatch := query.Uid != "" && query.Uid == datasource.Uid
idMatch := query.ID != 0 && query.ID == datasource.ID
uidMatch := query.UID != "" && query.UID == datasource.UID
nameMatch := query.Name != "" && query.Name == datasource.Name
if idMatch || nameMatch || uidMatch {
query.Result = datasource
@ -49,10 +49,10 @@ func (d *dataSourceMockRetriever) GetDataSource(ctx context.Context, query *data
func TestService_NameScopeResolver(t *testing.T) {
retriever := &dataSourceMockRetriever{[]*datasources.DataSource{
{Name: "test-datasource", Uid: "1"},
{Name: "*", Uid: "2"},
{Name: ":/*", Uid: "3"},
{Name: ":", Uid: "4"},
{Name: "test-datasource", UID: "1"},
{Name: "*", UID: "2"},
{Name: ":/*", UID: "3"},
{Name: ":", UID: "4"},
}}
type testCaseResolver struct {
@ -126,7 +126,7 @@ func TestService_NameScopeResolver(t *testing.T) {
func TestService_IDScopeResolver(t *testing.T) {
retriever := &dataSourceMockRetriever{[]*datasources.DataSource{
{Id: 1, Uid: "NnftN9Lnz"},
{ID: 1, UID: "NnftN9Lnz"},
}}
type testCaseResolver struct {
@ -259,8 +259,8 @@ func TestService_GetHttpTransport(t *testing.T) {
})
ds := datasources.DataSource{
Id: 1,
Url: "http://k8s:8001",
ID: 1,
URL: "http://k8s:8001",
Type: "Kubernetes",
}
@ -309,8 +309,8 @@ func TestService_GetHttpTransport(t *testing.T) {
require.NoError(t, err)
ds := datasources.DataSource{
Id: 1,
Url: "http://k8s:8001",
ID: 1,
URL: "http://k8s:8001",
Type: "Kubernetes",
SecureJsonData: map[string][]byte{"tlsCACert": []byte(caCert)},
Updated: time.Now().Add(-2 * time.Minute),
@ -360,10 +360,10 @@ func TestService_GetHttpTransport(t *testing.T) {
require.NoError(t, err)
ds := datasources.DataSource{
Id: 1,
OrgId: 1,
ID: 1,
OrgID: 1,
Name: "kubernetes",
Url: "http://k8s:8001",
URL: "http://k8s:8001",
Type: "Kubernetes",
JsonData: sjson,
}
@ -374,7 +374,7 @@ func TestService_GetHttpTransport(t *testing.T) {
})
require.NoError(t, err)
err = secretsStore.Set(context.Background(), ds.OrgId, ds.Name, secretskvs.DataSourceSecretType, string(secureJsonData))
err = secretsStore.Set(context.Background(), ds.OrgID, ds.Name, secretskvs.DataSourceSecretType, string(secureJsonData))
require.NoError(t, err)
rt, err := dsService.GetHTTPTransport(context.Background(), &ds, provider)
@ -408,10 +408,10 @@ func TestService_GetHttpTransport(t *testing.T) {
require.NoError(t, err)
ds := datasources.DataSource{
Id: 1,
OrgId: 1,
ID: 1,
OrgID: 1,
Name: "kubernetes",
Url: "http://k8s:8001",
URL: "http://k8s:8001",
Type: "Kubernetes",
JsonData: sjson,
}
@ -421,7 +421,7 @@ func TestService_GetHttpTransport(t *testing.T) {
})
require.NoError(t, err)
err = secretsStore.Set(context.Background(), ds.OrgId, ds.Name, secretskvs.DataSourceSecretType, string(secureJsonData))
err = secretsStore.Set(context.Background(), ds.OrgID, ds.Name, secretskvs.DataSourceSecretType, string(secureJsonData))
require.NoError(t, err)
rt, err := dsService.GetHTTPTransport(context.Background(), &ds, provider)
@ -460,8 +460,8 @@ func TestService_GetHttpTransport(t *testing.T) {
require.NoError(t, err)
ds := datasources.DataSource{
Id: 1,
Url: "http://k8s:8001",
ID: 1,
URL: "http://k8s:8001",
Type: "Kubernetes",
JsonData: sjson,
}
@ -495,10 +495,10 @@ func TestService_GetHttpTransport(t *testing.T) {
require.NoError(t, err)
ds := datasources.DataSource{
Id: 1,
OrgId: 1,
ID: 1,
OrgID: 1,
Name: "kubernetes",
Url: "http://k8s:8001",
URL: "http://k8s:8001",
Type: "Kubernetes",
JsonData: sjson,
}
@ -508,7 +508,7 @@ func TestService_GetHttpTransport(t *testing.T) {
})
require.NoError(t, err)
err = secretsStore.Set(context.Background(), ds.OrgId, ds.Name, secretskvs.DataSourceSecretType, string(secureJsonData))
err = secretsStore.Set(context.Background(), ds.OrgID, ds.Name, secretskvs.DataSourceSecretType, string(secureJsonData))
require.NoError(t, err)
headers := dsService.getCustomHeaders(sjson, map[string]string{"httpHeaderValue1": "Bearer xf5yhfkpsnmgo"})
@ -530,7 +530,7 @@ func TestService_GetHttpTransport(t *testing.T) {
defer backend.Close()
// 2. Get HTTP transport from datasource which uses the test server as backend
ds.Url = backend.URL
ds.URL = backend.URL
rt, err := dsService.GetHTTPTransport(context.Background(), &ds, provider)
require.NoError(t, err)
require.NotNil(t, rt)
@ -563,8 +563,8 @@ func TestService_GetHttpTransport(t *testing.T) {
dsService, err := ProvideService(sqlStore, secretsService, secretsStore, cfg, featuremgmt.WithFeatures(), acmock.New(), acmock.NewMockedPermissionsService(), quotaService)
require.NoError(t, err)
ds := datasources.DataSource{
Id: 1,
Url: "http://k8s:8001",
ID: 1,
URL: "http://k8s:8001",
Type: "Kubernetes",
JsonData: sjson,
}
@ -649,8 +649,8 @@ func TestService_getTimeout(t *testing.T) {
func TestService_GetDecryptedValues(t *testing.T) {
t.Run("should migrate and retrieve values from secure json data", func(t *testing.T) {
ds := &datasources.DataSource{
Id: 1,
Url: "https://api.example.com",
ID: 1,
URL: "https://api.example.com",
Type: "prometheus",
}
@ -677,8 +677,8 @@ func TestService_GetDecryptedValues(t *testing.T) {
t.Run("should retrieve values from secret store", func(t *testing.T) {
ds := &datasources.DataSource{
Id: 1,
Url: "https://api.example.com",
ID: 1,
URL: "https://api.example.com",
Type: "prometheus",
}
@ -695,7 +695,7 @@ func TestService_GetDecryptedValues(t *testing.T) {
jsonString, err := json.Marshal(jsonData)
require.NoError(t, err)
err = secretsStore.Set(context.Background(), ds.OrgId, ds.Name, secretskvs.DataSourceSecretType, string(jsonString))
err = secretsStore.Set(context.Background(), ds.OrgID, ds.Name, secretskvs.DataSourceSecretType, string(jsonString))
require.NoError(t, err)
values, err := dsService.DecryptedValues(context.Background(), ds)

66
pkg/services/datasources/service/store.go
View File

@ -55,15 +55,15 @@ func (ss *SqlStore) GetDataSource(ctx context.Context, query *datasources.GetDat
}
func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDataSourceQuery, sess *db.Session) error {
if query.OrgId == 0 || (query.Id == 0 && len(query.Name) == 0 && len(query.Uid) == 0) {
if query.OrgID == 0 || (query.ID == 0 && len(query.Name) == 0 && len(query.UID) == 0) {
return datasources.ErrDataSourceIdentifierNotSet
}
datasource := &datasources.DataSource{Name: query.Name, OrgId: query.OrgId, Id: query.Id, Uid: query.Uid}
datasource := &datasources.DataSource{Name: query.Name, OrgID: query.OrgID, ID: query.ID, UID: query.UID}
has, err := sess.Get(datasource)
if err != nil {
ss.logger.Error("Failed getting data source", "err", err, "uid", query.Uid, "id", query.Id, "name", query.Name, "orgId", query.OrgId)
ss.logger.Error("Failed getting data source", "err", err, "uid", query.UID, "id", query.ID, "name", query.Name, "orgId", query.OrgID)
return err
} else if !has {
return datasources.ErrDataSourceNotFound
@ -78,9 +78,9 @@ func (ss *SqlStore) GetDataSources(ctx context.Context, query *datasources.GetDa
var sess *xorm.Session
return ss.db.WithDbSession(ctx, func(dbSess *db.Session) error {
if query.DataSourceLimit <= 0 {
sess = dbSess.Where("org_id=?", query.OrgId).Asc("name")
sess = dbSess.Where("org_id=?", query.OrgID).Asc("name")
} else {
sess = dbSess.Limit(query.DataSourceLimit, 0).Where("org_id=?", query.OrgId).Asc("name")
sess = dbSess.Limit(query.DataSourceLimit, 0).Where("org_id=?", query.OrgID).Asc("name")
}
query.Result = make([]*datasources.DataSource, 0)
@ -103,8 +103,8 @@ func (ss *SqlStore) GetDataSourcesByType(ctx context.Context, query *datasources
query.Result = make([]*datasources.DataSource, 0)
return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
if query.OrgId > 0 {
return sess.Where("type=? AND org_id=?", query.Type, query.OrgId).Asc("id").Find(&query.Result)
if query.OrgID > 0 {
return sess.Where("type=? AND org_id=?", query.Type, query.OrgID).Asc("id").Find(&query.Result)
}
return sess.Where("type=?", query.Type).Asc("id").Find(&query.Result)
})
@ -114,7 +114,7 @@ func (ss *SqlStore) GetDataSourcesByType(ctx context.Context, query *datasources
func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
datasource := datasources.DataSource{}
return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
exists, err := sess.Where("org_id=? AND is_default=?", query.OrgId, true).Get(&datasource)
exists, err := sess.Where("org_id=? AND is_default=?", query.OrgID, true).Get(&datasource)
if !exists {
return datasources.ErrDataSourceNotFound
@ -129,7 +129,7 @@ func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources
// and is added to the bus. It also removes permissions related to the datasource.
func (ss *SqlStore) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
dsQuery := &datasources.GetDataSourceQuery{Id: cmd.ID, Uid: cmd.UID, Name: cmd.Name, OrgId: cmd.OrgID}
dsQuery := &datasources.GetDataSourceQuery{ID: cmd.ID, UID: cmd.UID, Name: cmd.Name, OrgID: cmd.OrgID}
errGettingDS := ss.getDataSource(ctx, dsQuery, sess)
if errGettingDS != nil && !errors.Is(errGettingDS, datasources.ErrDataSourceNotFound) {
@ -139,7 +139,7 @@ func (ss *SqlStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delet
ds := dsQuery.Result
if ds != nil {
// Delete the data source
result, err := sess.Exec("DELETE FROM data_source WHERE org_id=? AND id=?", ds.OrgId, ds.Id)
result, err := sess.Exec("DELETE FROM data_source WHERE org_id=? AND id=?", ds.OrgID, ds.ID)
if err != nil {
return err
}
@ -148,7 +148,7 @@ func (ss *SqlStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delet
// Remove associated AccessControl permissions
if _, errDeletingPerms := sess.Exec("DELETE FROM permission WHERE scope=?",
ac.Scope(datasources.ScopeProvider.GetResourceScope(dsQuery.Result.Uid))); errDeletingPerms != nil {
ac.Scope(datasources.ScopeProvider.GetResourceScope(dsQuery.Result.UID))); errDeletingPerms != nil {
return errDeletingPerms
}
}
@ -165,9 +165,9 @@ func (ss *SqlStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delet
sess.PublishAfterCommit(&events.DataSourceDeleted{
Timestamp: time.Now(),
Name: ds.Name,
ID: ds.Id,
UID: ds.Uid,
OrgID: ds.OrgId,
ID: ds.ID,
UID: ds.UID,
OrgID: ds.OrgID,
})
}
@ -221,7 +221,7 @@ func (ss *SqlStore) Count(ctx context.Context, scopeParams *quota.ScopeParameter
func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
existing := datasources.DataSource{OrgId: cmd.OrgId, Name: cmd.Name}
existing := datasources.DataSource{OrgID: cmd.OrgID, Name: cmd.Name}
has, _ := sess.Get(&existing)
if has {
@ -232,20 +232,20 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
cmd.JsonData = simplejson.New()
}
if cmd.Uid == "" {
uid, err := generateNewDatasourceUid(sess, cmd.OrgId)
if cmd.UID == "" {
uid, err := generateNewDatasourceUid(sess, cmd.OrgID)
if err != nil {
return fmt.Errorf("failed to generate UID for datasource %q: %w", cmd.Name, err)
}
cmd.Uid = uid
cmd.UID = uid
}
ds := &datasources.DataSource{
OrgId: cmd.OrgId,
OrgID: cmd.OrgID,
Name: cmd.Name,
Type: cmd.Type,
Access: cmd.Access,
Url: cmd.Url,
URL: cmd.URL,
User: cmd.User,
Database: cmd.Database,
IsDefault: cmd.IsDefault,
@ -258,7 +258,7 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
Updated: time.Now(),
Version: 1,
ReadOnly: cmd.ReadOnly,
Uid: cmd.Uid,
UID: cmd.UID,
}
if _, err := sess.Insert(ds); err != nil {
@ -273,7 +273,7 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
if cmd.UpdateSecretFn != nil {
if err := cmd.UpdateSecretFn(); err != nil {
// ss.logger.Error("Failed to update datasource secrets -- rolling back update", "name", cmd.Name, "type", cmd.Type, "orgId", cmd.OrgId)
// ss.logger.Error("Failed to update datasource secrets -- rolling back update", "name", cmd.Name, "type", cmd.Type, "orgId", cmd.OrgID)
return err
}
}
@ -283,9 +283,9 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
sess.PublishAfterCommit(&events.DataSourceCreated{
Timestamp: time.Now(),
Name: cmd.Name,
ID: ds.Id,
UID: cmd.Uid,
OrgID: cmd.OrgId,
ID: ds.ID,
UID: cmd.UID,
OrgID: cmd.OrgID,
})
return nil
})
@ -295,7 +295,7 @@ func updateIsDefaultFlag(ds *datasources.DataSource, sess *db.Session) error {
// Handle is default flag
if ds.IsDefault {
rawSQL := "UPDATE data_source SET is_default=? WHERE org_id=? AND id <> ?"
if _, err := sess.Exec(rawSQL, false, ds.OrgId, ds.Id); err != nil {
if _, err := sess.Exec(rawSQL, false, ds.OrgID, ds.ID); err != nil {
return err
}
}
@ -309,12 +309,12 @@ func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.Updat
}
ds := &datasources.DataSource{
Id: cmd.Id,
OrgId: cmd.OrgId,
ID: cmd.ID,
OrgID: cmd.OrgID,
Name: cmd.Name,
Type: cmd.Type,
Access: cmd.Access,
Url: cmd.Url,
URL: cmd.URL,
User: cmd.User,
Database: cmd.Database,
IsDefault: cmd.IsDefault,
@ -326,7 +326,7 @@ func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.Updat
Updated: time.Now(),
ReadOnly: cmd.ReadOnly,
Version: cmd.Version + 1,
Uid: cmd.Uid,
UID: cmd.UID,
}
sess.UseBool("is_default")
@ -349,9 +349,9 @@ func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.Updat
// the reason we allow cmd.version > db.version is make it possible for people to force
// updates to datasources using the datasource.yaml file without knowing exactly what version
// a datasource have in the db.
updateSession = sess.Where("id=? and org_id=? and version < ?", ds.Id, ds.OrgId, ds.Version)
updateSession = sess.Where("id=? and org_id=? and version < ?", ds.ID, ds.OrgID, ds.Version)
} else {
updateSession = sess.Where("id=? and org_id=?", ds.Id, ds.OrgId)
updateSession = sess.Where("id=? and org_id=?", ds.ID, ds.OrgID)
}
affected, err := updateSession.Update(ds)
@ -367,7 +367,7 @@ func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.Updat
if cmd.UpdateSecretFn != nil {
if err := cmd.UpdateSecretFn(); err != nil {
ss.logger.Error("Failed to update datasource secrets -- rolling back update", "UID", cmd.Uid, "name", cmd.Name, "type", cmd.Type, "orgId", cmd.OrgId)
ss.logger.Error("Failed to update datasource secrets -- rolling back update", "UID", cmd.UID, "name", cmd.Name, "type", cmd.Type, "orgId", cmd.OrgID)
return err
}
}

126
pkg/services/datasources/service/store_test.go
View File

@ -21,19 +21,19 @@ func TestIntegrationDataAccess(t *testing.T) {
t.Skip("skipping integration test")
}
defaultAddDatasourceCommand := datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "nisse",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
}
defaultUpdateDatasourceCommand := datasources.UpdateDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "nisse_updated",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
}
initDatasource := func(db db.DB) *datasources.DataSource {
@ -42,7 +42,7 @@ func TestIntegrationDataAccess(t *testing.T) {
err := ss.AddDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
@ -55,24 +55,24 @@ func TestIntegrationDataAccess(t *testing.T) {
db := db.InitTestDB(t)
ss := SqlStore{db: db}
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "laban",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
ds := query.Result[0]
require.EqualValues(t, 10, ds.OrgId)
require.EqualValues(t, 10, ds.OrgID)
require.Equal(t, "site", ds.Database)
require.True(t, ds.ReadOnly)
})
@ -80,7 +80,7 @@ func TestIntegrationDataAccess(t *testing.T) {
t.Run("generates uid if not specified", func(t *testing.T) {
db := db.InitTestDB(t)
ds := initDatasource(db)
require.NotEmpty(t, ds.Uid)
require.NotEmpty(t, ds.UID)
})
t.Run("fails to insert ds with same uid", func(t *testing.T) {
@ -88,8 +88,8 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
cmd1 := defaultAddDatasourceCommand
cmd2 := defaultAddDatasourceCommand
cmd1.Uid = "test"
cmd2.Uid = "test"
cmd1.UID = "test"
cmd2.UID = "test"
err := ss.AddDataSource(context.Background(), &cmd1)
require.NoError(t, err)
err = ss.AddDataSource(context.Background(), &cmd2)
@ -113,13 +113,13 @@ func TestIntegrationDataAccess(t *testing.T) {
return assert.NotNil(t, created)
}, time.Second, time.Millisecond)
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = sqlStore.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
require.Equal(t, query.Result[0].Id, created.ID)
require.Equal(t, query.Result[0].Uid, created.UID)
require.Equal(t, query.Result[0].ID, created.ID)
require.Equal(t, query.Result[0].UID, created.UID)
require.Equal(t, int64(10), created.OrgID)
require.Equal(t, "nisse", created.Name)
})
@ -130,28 +130,28 @@ func TestIntegrationDataAccess(t *testing.T) {
db := db.InitTestDB(t)
ds := initDatasource(db)
cmd := defaultUpdateDatasourceCommand
cmd.Id = ds.Id
cmd.ID = ds.ID
cmd.Version = ds.Version
ss := SqlStore{db: db}
err := ss.UpdateDataSource(context.Background(), &cmd)
require.NoError(t, err)
})
t.Run("does not overwrite Uid if not specified", func(t *testing.T) {
t.Run("does not overwrite UID if not specified", func(t *testing.T) {
db := db.InitTestDB(t)
ds := initDatasource(db)
ss := SqlStore{db: db}
require.NotEmpty(t, ds.Uid)
require.NotEmpty(t, ds.UID)
cmd := defaultUpdateDatasourceCommand
cmd.Id = ds.Id
cmd.ID = ds.ID
err := ss.UpdateDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDataSourceQuery{Id: ds.Id, OrgId: 10}
query := datasources.GetDataSourceQuery{ID: ds.ID, OrgID: 10}
err = ss.GetDataSource(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, ds.Uid, query.Result.Uid)
require.Equal(t, ds.UID, query.Result.UID)
})
t.Run("prevents update if version changed", func(t *testing.T) {
@ -160,12 +160,12 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
cmd := datasources.UpdateDataSourceCommand{
Id: ds.Id,
OrgId: 10,
ID: ds.ID,
OrgID: 10,
Name: "nisse",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_PROXY,
Url: "http://test",
URL: "http://test",
Version: ds.Version,
}
// Make a copy as UpdateDataSource modifies it
@ -184,12 +184,12 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
cmd := &datasources.UpdateDataSourceCommand{
Id: ds.Id,
OrgId: 10,
ID: ds.ID,
OrgID: 10,
Name: "nisse",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_PROXY,
Url: "http://test",
URL: "http://test",
}
err := ss.UpdateDataSource(context.Background(), cmd)
@ -202,12 +202,12 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
cmd := &datasources.UpdateDataSourceCommand{
Id: ds.Id,
OrgId: 10,
ID: ds.ID,
OrgID: 10,
Name: "nisse",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_PROXY,
Url: "http://test",
URL: "http://test",
Version: 90000,
}
@ -222,10 +222,10 @@ func TestIntegrationDataAccess(t *testing.T) {
ds := initDatasource(db)
ss := SqlStore{db: db}
err := ss.DeleteDataSource(context.Background(), &datasources.DeleteDataSourceCommand{ID: ds.Id, OrgID: ds.OrgId})
err := ss.DeleteDataSource(context.Background(), &datasources.DeleteDataSourceCommand{ID: ds.ID, OrgID: ds.OrgID})
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
@ -238,10 +238,10 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
err := ss.DeleteDataSource(context.Background(),
&datasources.DeleteDataSourceCommand{ID: ds.Id, OrgID: 123123})
&datasources.DeleteDataSourceCommand{ID: ds.ID, OrgID: 123123})
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
@ -261,17 +261,17 @@ func TestIntegrationDataAccess(t *testing.T) {
})
err := ss.DeleteDataSource(context.Background(),
&datasources.DeleteDataSourceCommand{ID: ds.Id, UID: ds.Uid, Name: ds.Name, OrgID: ds.OrgId})
&datasources.DeleteDataSourceCommand{ID: ds.ID, UID: ds.UID, Name: ds.Name, OrgID: ds.OrgID})
require.NoError(t, err)
require.Eventually(t, func() bool {
return assert.NotNil(t, deleted)
}, time.Second, time.Millisecond)
require.Equal(t, ds.Id, deleted.ID)
require.Equal(t, ds.OrgId, deleted.OrgID)
require.Equal(t, ds.ID, deleted.ID)
require.Equal(t, ds.OrgID, deleted.OrgID)
require.Equal(t, ds.Name, deleted.Name)
require.Equal(t, ds.Uid, deleted.UID)
require.Equal(t, ds.UID, deleted.UID)
})
t.Run("does not fire an event when the datasource is not deleted", func(t *testing.T) {
@ -297,9 +297,9 @@ func TestIntegrationDataAccess(t *testing.T) {
db := db.InitTestDB(t)
ds := initDatasource(db)
ss := SqlStore{db: db}
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err := ss.DeleteDataSource(context.Background(), &datasources.DeleteDataSourceCommand{Name: ds.Name, OrgID: ds.OrgId})
err := ss.DeleteDataSource(context.Background(), &datasources.DeleteDataSourceCommand{Name: ds.Name, OrgID: ds.OrgID})
require.NoError(t, err)
err = ss.GetDataSources(context.Background(), &query)
@ -318,17 +318,17 @@ func TestIntegrationDataAccess(t *testing.T) {
_, err := sess.Table("permission").Insert(ac.Permission{
RoleID: 1,
Action: "datasources:read",
Scope: datasources.ScopeProvider.GetResourceScope(ds.Uid),
Scope: datasources.ScopeProvider.GetResourceScope(ds.UID),
Updated: time.Now(),
Created: time.Now(),
})
return err
})
require.NoError(t, errAddPermissions)
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
errDeletingDS := ss.DeleteDataSource(context.Background(),
&datasources.DeleteDataSourceCommand{Name: ds.Name, OrgID: ds.OrgId},
&datasources.DeleteDataSourceCommand{Name: ds.Name, OrgID: ds.OrgID},
)
require.NoError(t, errDeletingDS)
@ -352,17 +352,17 @@ func TestIntegrationDataAccess(t *testing.T) {
datasourceLimit := 6
for i := 0; i < datasourceLimit+1; i++ {
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "laban" + strconv.Itoa(i),
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})
require.NoError(t, err)
}
query := datasources.GetDataSourcesQuery{OrgId: 10, DataSourceLimit: datasourceLimit}
query := datasources.GetDataSourcesQuery{OrgID: 10, DataSourceLimit: datasourceLimit}
err := ss.GetDataSources(context.Background(), &query)
@ -376,17 +376,17 @@ func TestIntegrationDataAccess(t *testing.T) {
numberOfDatasource := 5100
for i := 0; i < numberOfDatasource; i++ {
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "laban" + strconv.Itoa(i),
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})
require.NoError(t, err)
}
query := datasources.GetDataSourcesQuery{OrgId: 10}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err := ss.GetDataSources(context.Background(), &query)
@ -400,17 +400,17 @@ func TestIntegrationDataAccess(t *testing.T) {
numberOfDatasource := 5100
for i := 0; i < numberOfDatasource; i++ {
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "laban" + strconv.Itoa(i),
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})
require.NoError(t, err)
}
query := datasources.GetDataSourcesQuery{OrgId: 10, DataSourceLimit: -1}
query := datasources.GetDataSourcesQuery{OrgID: 10, DataSourceLimit: -1}
err := ss.GetDataSources(context.Background(), &query)
@ -425,22 +425,22 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "Elasticsearch",
Type: datasources.DS_ES,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})
require.NoError(t, err)
err = ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "Graphite",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})
@ -477,17 +477,17 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
ss := SqlStore{db: db}
cmd := datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "nisse",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
}
err := ss.AddDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDefaultDataSourceQuery{OrgId: 10}
query := datasources.GetDefaultDataSourceQuery{OrgID: 10}
err = ss.GetDefaultDataSource(context.Background(), &query)
require.Error(t, err)
assert.True(t, errors.Is(err, datasources.ErrDataSourceNotFound))
@ -498,18 +498,18 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
ss := SqlStore{db: db}
cmd := datasources.AddDataSourceCommand{
OrgId: 10,
OrgID: 10,
Name: "default datasource",
Type: datasources.DS_GRAPHITE,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
IsDefault: true,
}
err := ss.AddDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDefaultDataSourceQuery{OrgId: 10}
query := datasources.GetDefaultDataSourceQuery{OrgID: 10}
err = ss.GetDefaultDataSource(context.Background(), &query)
require.NoError(t, err)
assert.Equal(t, "default datasource", query.Result.Name)
@ -518,7 +518,7 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
t.Run("should not return default datasource of other organisation", func(t *testing.T) {
db := db.InitTestDB(t)
ss := SqlStore{db: db}
query := datasources.GetDefaultDataSourceQuery{OrgId: 1}
query := datasources.GetDefaultDataSourceQuery{OrgID: 1}
err := ss.GetDefaultDataSource(context.Background(), &query)
require.Error(t, err)
assert.True(t, errors.Is(err, datasources.ErrDataSourceNotFound))

6
pkg/services/export/export_ds.go
View File

@ -10,7 +10,7 @@ import (
func exportDataSources(helper *commitHelper, job *gitExportJob) error {
cmd := &datasources.GetDataSourcesQuery{
OrgId: helper.orgID,
OrgID: helper.orgID,
}
err := job.datasourceService.GetDataSources(helper.ctx, cmd)
if err != nil {
@ -22,7 +22,7 @@ func exportDataSources(helper *commitHelper, job *gitExportJob) error {
})
for _, ds := range cmd.Result {
ds.OrgId = 0
ds.OrgID = 0
ds.Version = 0
ds.SecureJsonData = map[string][]byte{
"TODO": []byte("XXX"),
@ -31,7 +31,7 @@ func exportDataSources(helper *commitHelper, job *gitExportJob) error {
err := helper.add(commitOptions{
body: []commitBody{
{
fpath: filepath.Join(helper.orgDir, "datasources", fmt.Sprintf("%s-ds.json", ds.Uid)),
fpath: filepath.Join(helper.orgDir, "datasources", fmt.Sprintf("%s-ds.json", ds.UID)),
body: prettyJSON(ds),
},
},

2
pkg/services/live/live.go
View File

@ -949,7 +949,7 @@ func (g *GrafanaLive) handleDatasourceScope(ctx context.Context, user *user.Sign
}
return features.NewPluginRunner(
ds.Type,
ds.Uid,
ds.UID,
g.runStreamManager,
g.contextGetter,
streamHandler,

4
pkg/services/ngalert/api/api_configuration.go
View File

@ -118,7 +118,7 @@ func (srv ConfigSrv) RouteDeleteNGalertConfig(c *contextmodel.ReqContext) respon
func (srv ConfigSrv) externalAlertmanagers(ctx context.Context, orgID int64) ([]string, error) {
var alertmanagers []string
query := &datasources.GetDataSourcesByTypeQuery{
OrgId: orgID,
OrgID: orgID,
Type: datasources.DS_ALERTMANAGER,
}
err := srv.datasourceService.GetDataSourcesByType(ctx, query)
@ -129,7 +129,7 @@ func (srv ConfigSrv) externalAlertmanagers(ctx context.Context, orgID int64) ([]
if ds.JsonData.Get(apimodels.HandleGrafanaManagedAlerts).MustBool(false) {
// we don't need to build the exact URL as we only need
// to know if any is set
alertmanagers = append(alertmanagers, ds.Uid)
alertmanagers = append(alertmanagers, ds.UID)
}
}
return alertmanagers, nil

8
pkg/services/ngalert/api/api_configuration_test.go
View File

@ -28,9 +28,9 @@ func TestExternalAlertmanagerChoice(t *testing.T) {
alertmanagerChoice: definitions.ExternalAlertmanagers,
datasources: []*datasources.DataSource{
{
OrgId: 1,
OrgID: 1,
Type: datasources.DS_ALERTMANAGER,
Url: "http://localhost:9000",
URL: "http://localhost:9000",
JsonData: simplejson.NewFromAny(map[string]interface{}{
definitions.HandleGrafanaManagedAlerts: true,
}),
@ -44,9 +44,9 @@ func TestExternalAlertmanagerChoice(t *testing.T) {
alertmanagerChoice: definitions.ExternalAlertmanagers,
datasources: []*datasources.DataSource{
{
OrgId: 1,
OrgID: 1,
Type: datasources.DS_ALERTMANAGER,
Url: "http://localhost:9000",
URL: "http://localhost:9000",
JsonData: simplejson.NewFromAny(map[string]interface{}{}),
},
},

12
pkg/services/ngalert/api/api_testing_test.go
View File

@ -67,8 +67,8 @@ func TestRouteTestGrafanaRuleConfig(t *testing.T) {
})
ds := &fakes.FakeCacheService{DataSources: []*datasources.DataSource{
{Uid: data1.DatasourceUID},
{Uid: data2.DatasourceUID},
{UID: data1.DatasourceUID},
{UID: data2.DatasourceUID},
}}
var result []eval.Result
@ -110,7 +110,7 @@ func TestRouteTestGrafanaRuleConfig(t *testing.T) {
data1 := models.GenerateAlertQuery()
ds := &fakes.FakeCacheService{DataSources: []*datasources.DataSource{
{Uid: data1.DatasourceUID},
{UID: data1.DatasourceUID},
}}
currentTime := time.Now()
@ -193,8 +193,8 @@ func TestRouteEvalQueries(t *testing.T) {
})
ds := &fakes.FakeCacheService{DataSources: []*datasources.DataSource{
{Uid: data1.DatasourceUID},
{Uid: data2.DatasourceUID},
{UID: data1.DatasourceUID},
{UID: data2.DatasourceUID},
}}
evaluator := &eval_mocks.ConditionEvaluatorMock{}
@ -237,7 +237,7 @@ func TestRouteEvalQueries(t *testing.T) {
data1 := models.GenerateAlertQuery()
ds := &fakes.FakeCacheService{DataSources: []*datasources.DataSource{
{Uid: data1.DatasourceUID},
{UID: data1.DatasourceUID},
}}
currentTime := time.Now()

2
pkg/services/ngalert/api/lotex_prom.go
View File

@ -87,7 +87,7 @@ func (p *LotexProm) getEndpoints(ctx *contextmodel.ReqContext) (*promEndpoints,
return nil, err
}
if ds.Url == "" {
if ds.URL == "" {
return nil, fmt.Errorf("URL for this data source is empty")
}

6
pkg/services/ngalert/api/lotex_ruler.go
View File

@ -185,7 +185,7 @@ func (r *LotexRuler) validateAndGetPrefix(ctx *contextmodel.ReqContext) (string,
}
// Validate URL
if ds.Url == "" {
if ds.URL == "" {
return "", fmt.Errorf("URL for this data source is empty")
}
@ -206,12 +206,12 @@ func (r *LotexRuler) validateAndGetPrefix(ctx *contextmodel.ReqContext) (string,
if !ok {
r.log.Debug(
"Unable to determine prometheus datasource subtype, using default prefix",
"datasource", ds.Uid, "datasourceType", ds.Type, "subtype", subtype, "prefix", prefix)
"datasource", ds.UID, "datasourceType", ds.Type, "subtype", subtype, "prefix", prefix)
return prefix, nil
}
r.log.Debug("Determined prometheus datasource subtype",
"datasource", ds.Uid, "datasourceType", ds.Type, "subtype", subtype)
"datasource", ds.UID, "datasourceType", ds.Type, "subtype", subtype)
return subTypePrefix, nil
}

14
pkg/services/ngalert/api/lotex_ruler_test.go
View File

@ -45,46 +45,46 @@ func TestLotexRuler_ValidateAndGetPrefix(t *testing.T) {
{
name: "with an unsupported datasource type",
namedParams: map[string]string{":DatasourceUID": "d164"},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com"}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com"}},
err: errors.New("unexpected datasource type. expecting loki or prometheus"),
},
{
name: "with a Loki datasource",
namedParams: map[string]string{":DatasourceUID": "d164"},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com", Type: LokiDatasourceType}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com", Type: LokiDatasourceType}},
expected: "/api/prom/rules",
},
{
name: "with a Prometheus datasource",
namedParams: map[string]string{":DatasourceUID": "d164"},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com", Type: PrometheusDatasourceType}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com", Type: PrometheusDatasourceType}},
expected: "/rules",
},
{
name: "with a Prometheus datasource and subtype of Cortex",
namedParams: map[string]string{":DatasourceUID": "d164"},
urlParams: "?subtype=cortex",
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com", Type: PrometheusDatasourceType}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com", Type: PrometheusDatasourceType}},
expected: "/rules",
},
{
name: "with a Prometheus datasource and subtype of Mimir",
namedParams: map[string]string{":DatasourceUID": "d164"},
urlParams: "?subtype=mimir",
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com", Type: PrometheusDatasourceType}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com", Type: PrometheusDatasourceType}},
expected: "/config/v1/rules",
},
{
name: "with a Prometheus datasource and subtype of Prometheus",
namedParams: map[string]string{":DatasourceUID": "d164"},
urlParams: "?subtype=prometheus",
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com", Type: PrometheusDatasourceType}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com", Type: PrometheusDatasourceType}},
expected: "/rules",
},
{
name: "with a Prometheus datasource and no subtype",
namedParams: map[string]string{":DatasourceUID": "d164"},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{Url: "http://loki.com", Type: PrometheusDatasourceType}},
datasourceCache: fakeCacheService{datasource: &datasources.DataSource{URL: "http://loki.com", Type: PrometheusDatasourceType}},
expected: "/rules",
},
}

2
pkg/services/ngalert/eval/eval.go
View File

@ -605,7 +605,7 @@ func (e *evaluatorImpl) Validate(ctx EvaluationContext, condition models.Conditi
return err
}
for _, query := range req.Queries {
if query.DataSource == nil || expr.IsDataSource(query.DataSource.Uid) {
if query.DataSource == nil || expr.IsDataSource(query.DataSource.UID) {
continue
}
p, found := e.pluginsStore.Plugin(ctx.Ctx, query.DataSource.Type)

12
pkg/services/ngalert/eval/eval_test.go
View File

@ -380,7 +380,7 @@ func TestValidate(t *testing.T) {
condition: func(services services) models.Condition {
dsQuery := models.GenerateAlertQuery()
ds := &datasources.DataSource{
Uid: dsQuery.DatasourceUID,
UID: dsQuery.DatasourceUID,
Type: util.GenerateShortUID(),
}
services.cache.DataSources = append(services.cache.DataSources, ds)
@ -406,7 +406,7 @@ func TestValidate(t *testing.T) {
condition: func(services services) models.Condition {
dsQuery := models.GenerateAlertQuery()
ds := &datasources.DataSource{
Uid: dsQuery.DatasourceUID,
UID: dsQuery.DatasourceUID,
Type: util.GenerateShortUID(),
}
services.cache.DataSources = append(services.cache.DataSources, ds)
@ -445,7 +445,7 @@ func TestValidate(t *testing.T) {
condition: func(services services) models.Condition {
dsQuery := models.GenerateAlertQuery()
ds := &datasources.DataSource{
Uid: dsQuery.DatasourceUID,
UID: dsQuery.DatasourceUID,
Type: util.GenerateShortUID(),
}
services.cache.DataSources = append(services.cache.DataSources, ds)
@ -465,11 +465,11 @@ func TestValidate(t *testing.T) {
dsQuery1 := models.GenerateAlertQuery()
dsQuery2 := models.GenerateAlertQuery()
ds1 := &datasources.DataSource{
Uid: dsQuery1.DatasourceUID,
UID: dsQuery1.DatasourceUID,
Type: util.GenerateShortUID(),
}
ds2 := &datasources.DataSource{
Uid: dsQuery2.DatasourceUID,
UID: dsQuery2.DatasourceUID,
Type: util.GenerateShortUID(),
}
services.cache.DataSources = append(services.cache.DataSources, ds1, ds2)
@ -500,7 +500,7 @@ func TestValidate(t *testing.T) {
condition: func(services services) models.Condition {
dsQuery := models.GenerateAlertQuery()
ds := &datasources.DataSource{
Uid: dsQuery.DatasourceUID,
UID: dsQuery.DatasourceUID,
Type: util.GenerateShortUID(),
}
services.cache.DataSources = append(services.cache.DataSources, ds)

8
pkg/services/ngalert/sender/router.go
View File

@ -209,7 +209,7 @@ func (d *AlertsRouter) alertmanagersFromDatasources(orgID int64) ([]string, erro
// We might have alertmanager datasources that are acting as external
// alertmanager, let's fetch them.
query := &datasources.GetDataSourcesByTypeQuery{
OrgId: orgID,
OrgID: orgID,
Type: datasources.DS_ALERTMANAGER,
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
@ -225,8 +225,8 @@ func (d *AlertsRouter) alertmanagersFromDatasources(orgID int64) ([]string, erro
amURL, err := d.buildExternalURL(ds)
if err != nil {
d.logger.Error("Failed to build external alertmanager URL",
"org", ds.OrgId,
"uid", ds.Uid,
"org", ds.OrgID,
"uid", ds.UID,
"error", err)
continue
}
@ -238,7 +238,7 @@ func (d *AlertsRouter) alertmanagersFromDatasources(orgID int64) ([]string, erro
func (d *AlertsRouter) buildExternalURL(ds *datasources.DataSource) (string, error) {
// We re-use the same parsing logic as the datasource to make sure it matches whatever output the user received
// when doing the healthcheck.
parsed, err := datasource.ValidateURL(datasources.DS_ALERTMANAGER, ds.Url)
parsed, err := datasource.ValidateURL(datasources.DS_ALERTMANAGER, ds.URL)
if err != nil {
return "", fmt.Errorf("failed to parse alertmanager datasource url: %w", err)
}

36
pkg/services/ngalert/sender/router_test.go
View File

@ -53,8 +53,8 @@ func TestIntegrationSendingToExternalAlertmanager(t *testing.T) {
}
ds1 := datasources.DataSource{
Url: fakeAM.Server.URL,
OrgId: ruleKey.OrgID,
URL: fakeAM.Server.URL,
OrgID: ruleKey.OrgID,
Type: datasources.DS_ALERTMANAGER,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
@ -123,8 +123,8 @@ func TestIntegrationSendingToExternalAlertmanager_WithMultipleOrgs(t *testing.T)
}
ds1 := datasources.DataSource{
Url: fakeAM.Server.URL,
OrgId: ruleKey1.OrgID,
URL: fakeAM.Server.URL,
OrgID: ruleKey1.OrgID,
Type: datasources.DS_ALERTMANAGER,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
@ -150,8 +150,8 @@ func TestIntegrationSendingToExternalAlertmanager_WithMultipleOrgs(t *testing.T)
// 1. Now, let's assume a new org comes along.
ds2 := datasources.DataSource{
Url: fakeAM.Server.URL,
OrgId: ruleKey2.OrgID,
URL: fakeAM.Server.URL,
OrgID: ruleKey2.OrgID,
Type: datasources.DS_ALERTMANAGER,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
@ -196,8 +196,8 @@ func TestIntegrationSendingToExternalAlertmanager_WithMultipleOrgs(t *testing.T)
// 2. Next, let's modify the configuration of an organization by adding an extra alertmanager.
fakeAM2 := NewFakeExternalAlertmanager(t)
ds3 := datasources.DataSource{
Url: fakeAM2.Server.URL,
OrgId: ruleKey2.OrgID,
URL: fakeAM2.Server.URL,
OrgID: ruleKey2.OrgID,
Type: datasources.DS_ALERTMANAGER,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
@ -225,7 +225,7 @@ func TestIntegrationSendingToExternalAlertmanager_WithMultipleOrgs(t *testing.T)
assertAlertmanagersStatusForOrg(t, alertsRouter, ruleKey2.OrgID, 2, 0)
// 3. Now, let's provide a configuration that fails for OrgID = 1.
fakeDs.DataSources[0].Url = "123://invalid.org"
fakeDs.DataSources[0].URL = "123://invalid.org"
mockedGetAdminConfigurations.Return([]*models.AdminConfiguration{
{OrgID: ruleKey1.OrgID, SendAlertsTo: models.AllAlertmanagers},
{OrgID: ruleKey2.OrgID},
@ -242,7 +242,7 @@ func TestIntegrationSendingToExternalAlertmanager_WithMultipleOrgs(t *testing.T)
require.Equal(t, 0, len(alertsRouter.AlertmanagersFor(ruleKey1.OrgID)))
// If we fix it - it should be applied.
fakeDs.DataSources[0].Url = "notarealalertmanager:3030"
fakeDs.DataSources[0].URL = "notarealalertmanager:3030"
mockedGetAdminConfigurations.Return([]*models.AdminConfiguration{
{OrgID: ruleKey1.OrgID, SendAlertsTo: models.AllAlertmanagers},
{OrgID: ruleKey2.OrgID},
@ -283,8 +283,8 @@ func TestChangingAlertmanagersChoice(t *testing.T) {
}
ds := datasources.DataSource{
Url: fakeAM.Server.URL,
OrgId: ruleKey.OrgID,
URL: fakeAM.Server.URL,
OrgID: ruleKey.OrgID,
Type: datasources.DS_ALERTMANAGER,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
@ -437,21 +437,21 @@ func TestBuildExternalURL(t *testing.T) {
{
name: "datasource without auth",
ds: &datasources.DataSource{
Url: "https://localhost:9000",
URL: "https://localhost:9000",
},
expectedURL: "https://localhost:9000",
},
{
name: "datasource without auth and with path",
ds: &datasources.DataSource{
Url: "https://localhost:9000/path/to/am",
URL: "https://localhost:9000/path/to/am",
},
expectedURL: "https://localhost:9000/path/to/am",
},
{
name: "datasource with auth",
ds: &datasources.DataSource{
Url: "https://localhost:9000",
URL: "https://localhost:9000",
BasicAuth: true,
BasicAuthUser: "johndoe",
SecureJsonData: map[string][]byte{
@ -463,7 +463,7 @@ func TestBuildExternalURL(t *testing.T) {
{
name: "datasource with auth and path",
ds: &datasources.DataSource{
Url: "https://localhost:9000/path/to/am",
URL: "https://localhost:9000/path/to/am",
BasicAuth: true,
BasicAuthUser: "johndoe",
SecureJsonData: map[string][]byte{
@ -475,7 +475,7 @@ func TestBuildExternalURL(t *testing.T) {
{
name: "with no scheme specified in the datasource",
ds: &datasources.DataSource{
Url: "localhost:9000/path/to/am",
URL: "localhost:9000/path/to/am",
BasicAuth: true,
BasicAuthUser: "johndoe",
SecureJsonData: map[string][]byte{
@ -487,7 +487,7 @@ func TestBuildExternalURL(t *testing.T) {
{
name: "with no scheme specified not auth in the datasource",
ds: &datasources.DataSource{
Url: "localhost:9000/path/to/am",
URL: "localhost:9000/path/to/am",
},
expectedURL: "http://localhost:9000/path/to/am",
},

4
pkg/services/pluginsintegration/clientmiddleware/cookies_middleware.go
View File

@ -44,8 +44,8 @@ func (m *CookiesMiddleware) applyCookies(ctx context.Context, pCtx backend.Plugi
}
ds := &datasources.DataSource{
Id: settings.ID,
OrgId: pCtx.OrgID,
ID: settings.ID,
OrgID: pCtx.OrgID,
JsonData: jsonDataBytes,
Updated: settings.Updated,
}

4
pkg/services/pluginsintegration/clientmiddleware/oauthtoken_middleware.go
View File

@ -48,8 +48,8 @@ func (m *OAuthTokenMiddleware) applyToken(ctx context.Context, pCtx backend.Plug
}
ds := &datasources.DataSource{
Id: settings.ID,
OrgId: pCtx.OrgID,
ID: settings.ID,
OrgID: pCtx.OrgID,
JsonData: jsonDataBytes,
Updated: settings.Updated,
}

28
pkg/services/provisioning/datasources/config_reader_test.go
View File

@ -44,15 +44,15 @@ func TestDatasourceAsConfig(t *testing.T) {
}
require.Equal(t, len(store.inserted), 1)
require.Equal(t, store.inserted[0].OrgId, int64(1))
require.Equal(t, store.inserted[0].OrgID, int64(1))
require.Equal(t, store.inserted[0].Access, datasources.DsAccess("proxy"))
require.Equal(t, store.inserted[0].Name, "My datasource name")
require.Equal(t, store.inserted[0].Uid, "P2AD1F727255C56BA")
require.Equal(t, store.inserted[0].UID, "P2AD1F727255C56BA")
})
t.Run("when some values missing should not change UID when updates", func(t *testing.T) {
store := &spyStore{
items: []*datasources.DataSource{{Name: "My datasource name", OrgId: 1, Id: 1, Uid: util.GenerateShortUID()}},
items: []*datasources.DataSource{{Name: "My datasource name", OrgID: 1, ID: 1, UID: util.GenerateShortUID()}},
}
orgFake := &orgtest.FakeOrgService{}
correlationsStore := &mockCorrelationsStore{}
@ -65,7 +65,7 @@ func TestDatasourceAsConfig(t *testing.T) {
require.Equal(t, len(store.deleted), 0)
require.Equal(t, len(store.inserted), 0)
require.Equal(t, len(store.updated), 1)
require.Equal(t, "", store.updated[0].Uid) // XORM will not update the field if its value is default
require.Equal(t, "", store.updated[0].UID) // XORM will not update the field if its value is default
})
t.Run("no datasource in database", func(t *testing.T) {
@ -84,7 +84,7 @@ func TestDatasourceAsConfig(t *testing.T) {
})
t.Run("One datasource in database with same name should update one datasource", func(t *testing.T) {
store := &spyStore{items: []*datasources.DataSource{{Name: "Graphite", OrgId: 1, Id: 1}}}
store := &spyStore{items: []*datasources.DataSource{{Name: "Graphite", OrgID: 1, ID: 1}}}
orgFake := &orgtest.FakeOrgService{}
correlationsStore := &mockCorrelationsStore{}
dc := newDatasourceProvisioner(logger, store, correlationsStore, orgFake)
@ -116,9 +116,9 @@ func TestDatasourceAsConfig(t *testing.T) {
require.NoError(t, err)
require.Equal(t, len(store.inserted), 4)
require.True(t, store.inserted[0].IsDefault)
require.Equal(t, store.inserted[0].OrgId, int64(1))
require.Equal(t, store.inserted[0].OrgID, int64(1))
require.True(t, store.inserted[2].IsDefault)
require.Equal(t, store.inserted[2].OrgId, int64(2))
require.Equal(t, store.inserted[2].OrgID, int64(2))
})
t.Run("Remove one datasource should have removed old datasource", func(t *testing.T) {
@ -139,7 +139,7 @@ func TestDatasourceAsConfig(t *testing.T) {
})
t.Run("Two configured datasource and purge others", func(t *testing.T) {
store := &spyStore{items: []*datasources.DataSource{{Name: "old-graphite", OrgId: 1, Id: 1}, {Name: "old-graphite2", OrgId: 1, Id: 2}}}
store := &spyStore{items: []*datasources.DataSource{{Name: "old-graphite", OrgID: 1, ID: 1}, {Name: "old-graphite2", OrgID: 1, ID: 2}}}
orgFake := &orgtest.FakeOrgService{}
correlationsStore := &mockCorrelationsStore{}
dc := newDatasourceProvisioner(logger, store, correlationsStore, orgFake)
@ -154,7 +154,7 @@ func TestDatasourceAsConfig(t *testing.T) {
})
t.Run("Two configured datasource and purge others = false", func(t *testing.T) {
store := &spyStore{items: []*datasources.DataSource{{Name: "Graphite", OrgId: 1, Id: 1}, {Name: "old-graphite2", OrgId: 1, Id: 2}}}
store := &spyStore{items: []*datasources.DataSource{{Name: "Graphite", OrgID: 1, ID: 1}, {Name: "old-graphite2", OrgID: 1, ID: 2}}}
orgFake := &orgtest.FakeOrgService{}
correlationsStore := &mockCorrelationsStore{}
dc := newDatasourceProvisioner(logger, store, correlationsStore, orgFake)
@ -255,7 +255,7 @@ func TestDatasourceAsConfig(t *testing.T) {
})
t.Run("Updating existing datasource deletes existing correlations and creates two", func(t *testing.T) {
store := &spyStore{items: []*datasources.DataSource{{Name: "Graphite", OrgId: 1, Id: 1}}}
store := &spyStore{items: []*datasources.DataSource{{Name: "Graphite", OrgID: 1, ID: 1}}}
orgFake := &orgtest.FakeOrgService{}
correlationsStore := &mockCorrelationsStore{}
dc := newDatasourceProvisioner(logger, store, correlationsStore, orgFake)
@ -270,7 +270,7 @@ func TestDatasourceAsConfig(t *testing.T) {
})
t.Run("Deleting datasource deletes existing correlations", func(t *testing.T) {
store := &spyStore{items: []*datasources.DataSource{{Name: "old-data-source", OrgId: 1, Id: 1, Uid: "some-uid"}}}
store := &spyStore{items: []*datasources.DataSource{{Name: "old-data-source", OrgID: 1, ID: 1, UID: "some-uid"}}}
orgFake := &orgtest.FakeOrgService{}
targetUid := "target-uid"
correlationsStore := &mockCorrelationsStore{items: []correlations.Correlation{{UID: "some-uid", SourceUID: "some-uid", TargetUID: &targetUid}}}
@ -369,7 +369,7 @@ type spyStore struct {
func (s *spyStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
for _, v := range s.items {
if query.Name == v.Name && query.OrgId == v.OrgId {
if query.Name == v.Name && query.OrgID == v.OrgID {
query.Result = v
return nil
}
@ -380,7 +380,7 @@ func (s *spyStore) GetDataSource(ctx context.Context, query *datasources.GetData
func (s *spyStore) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
s.deleted = append(s.deleted, cmd)
for _, v := range s.items {
if cmd.Name == v.Name && cmd.OrgID == v.OrgId {
if cmd.Name == v.Name && cmd.OrgID == v.OrgID {
cmd.DeletedDatasourcesCount = 1
return nil
}
@ -391,7 +391,7 @@ func (s *spyStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delete
func (s *spyStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
s.inserted = append(s.inserted, cmd)
cmd.Result = &datasources.DataSource{
Uid: cmd.Uid,
UID: cmd.UID,
}
return nil
}

20
pkg/services/provisioning/datasources/datasources.go
View File

@ -65,7 +65,7 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
correlationsToInsert := make([]correlations.CreateCorrelationCommand, 0)
for _, ds := range cfg.Datasources {
cmd := &datasources.GetDataSourceQuery{OrgId: ds.OrgID, Name: ds.Name}
cmd := &datasources.GetDataSourceQuery{OrgID: ds.OrgID, Name: ds.Name}
err := dc.store.GetDataSource(ctx, cmd)
if err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
return err
@ -73,13 +73,13 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
if errors.Is(err, datasources.ErrDataSourceNotFound) {
insertCmd := createInsertCommand(ds)
dc.log.Info("inserting datasource from configuration ", "name", insertCmd.Name, "uid", insertCmd.Uid)
dc.log.Info("inserting datasource from configuration ", "name", insertCmd.Name, "uid", insertCmd.UID)
if err := dc.store.AddDataSource(ctx, insertCmd); err != nil {
return err
}
for _, correlation := range ds.Correlations {
if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, insertCmd.Result.Uid, insertCmd.OrgId); err == nil {
if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, insertCmd.Result.UID, insertCmd.OrgID); err == nil {
correlationsToInsert = append(correlationsToInsert, insertCorrelationCmd)
} else {
dc.log.Error("failed to parse correlation", "correlation", correlation)
@ -87,22 +87,22 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
}
}
} else {
updateCmd := createUpdateCommand(ds, cmd.Result.Id)
dc.log.Debug("updating datasource from configuration", "name", updateCmd.Name, "uid", updateCmd.Uid)
updateCmd := createUpdateCommand(ds, cmd.Result.ID)
dc.log.Debug("updating datasource from configuration", "name", updateCmd.Name, "uid", updateCmd.UID)
if err := dc.store.UpdateDataSource(ctx, updateCmd); err != nil {
return err
}
if len(ds.Correlations) > 0 {
if err := dc.correlationsStore.DeleteCorrelationsBySourceUID(ctx, correlations.DeleteCorrelationsBySourceUIDCommand{
SourceUID: cmd.Result.Uid,
SourceUID: cmd.Result.UID,
}); err != nil {
return err
}
}
for _, correlation := range ds.Correlations {
if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, cmd.Result.Uid, updateCmd.OrgId); err == nil {
if insertCorrelationCmd, err := makeCreateCorrelationCommand(correlation, cmd.Result.UID, updateCmd.OrgID); err == nil {
correlationsToInsert = append(correlationsToInsert, insertCorrelationCmd)
} else {
dc.log.Error("failed to parse correlation", "correlation", correlation)
@ -179,7 +179,7 @@ func makeCreateCorrelationCommand(correlation map[string]interface{}, SourceUID
func (dc *DatasourceProvisioner) deleteDatasources(ctx context.Context, dsToDelete []*deleteDatasourceConfig) error {
for _, ds := range dsToDelete {
cmd := &datasources.DeleteDataSourceCommand{OrgID: ds.OrgID, Name: ds.Name}
getDsQuery := &datasources.GetDataSourceQuery{Name: ds.Name, OrgId: ds.OrgID}
getDsQuery := &datasources.GetDataSourceQuery{Name: ds.Name, OrgID: ds.OrgID}
if err := dc.store.GetDataSource(ctx, getDsQuery); err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
return err
}
@ -190,13 +190,13 @@ func (dc *DatasourceProvisioner) deleteDatasources(ctx context.Context, dsToDele
if getDsQuery.Result != nil {
if err := dc.correlationsStore.DeleteCorrelationsBySourceUID(ctx, correlations.DeleteCorrelationsBySourceUIDCommand{
SourceUID: getDsQuery.Result.Uid,
SourceUID: getDsQuery.Result.UID,
}); err != nil {
return err
}
if err := dc.correlationsStore.DeleteCorrelationsByTargetUID(ctx, correlations.DeleteCorrelationsByTargetUIDCommand{
TargetUID: getDsQuery.Result.Uid,
TargetUID: getDsQuery.Result.UID,
}); err != nil {
return err
}

18
pkg/services/provisioning/datasources/types.go
View File

@ -203,11 +203,11 @@ func createInsertCommand(ds *upsertDataSourceFromConfig) *datasources.AddDataSou
}
cmd := &datasources.AddDataSourceCommand{
OrgId: ds.OrgID,
OrgID: ds.OrgID,
Name: ds.Name,
Type: ds.Type,
Access: datasources.DsAccess(ds.Access),
Url: ds.URL,
URL: ds.URL,
User: ds.User,
Database: ds.Database,
BasicAuth: ds.BasicAuth,
@ -217,11 +217,11 @@ func createInsertCommand(ds *upsertDataSourceFromConfig) *datasources.AddDataSou
JsonData: jsonData,
SecureJsonData: ds.SecureJSONData,
ReadOnly: !ds.Editable,
Uid: ds.UID,
UID: ds.UID,
}
if cmd.Uid == "" {
cmd.Uid = safeUIDFromName(cmd.Name)
if cmd.UID == "" {
cmd.UID = safeUIDFromName(cmd.Name)
}
return cmd
}
@ -242,13 +242,13 @@ func createUpdateCommand(ds *upsertDataSourceFromConfig, id int64) *datasources.
}
return &datasources.UpdateDataSourceCommand{
Id: id,
Uid: ds.UID,
OrgId: ds.OrgID,
ID: id,
UID: ds.UID,
OrgID: ds.OrgID,
Name: ds.Name,
Type: ds.Type,
Access: datasources.DsAccess(ds.Access),
Url: ds.URL,
URL: ds.URL,
User: ds.User,
Database: ds.Database,
BasicAuth: ds.BasicAuth,

6
pkg/services/publicdashboards/api/query_test.go
View File

@ -268,12 +268,12 @@ func TestIntegrationUnauthenticatedUserCanGetPubdashPanelQueryData(t *testing.T)
qds := buildQueryDataService(t, cacheService, nil, db)
dsStore := datasourcesService.CreateStore(db, log.New("publicdashboards.test"))
_ = dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
Uid: "ds1",
OrgId: 1,
UID: "ds1",
OrgID: 1,
Name: "laban",
Type: datasources.DS_MYSQL,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
Database: "site",
ReadOnly: true,
})

18
pkg/services/query/query.go
View File

@ -202,14 +202,14 @@ func (s *Service) handleExpressions(ctx context.Context, user *user.SignedInUser
func (s *Service) handleQuerySingleDatasource(ctx context.Context, user *user.SignedInUser, parsedReq *parsedRequest) (*backend.QueryDataResponse, error) {
queries := parsedReq.getFlattenedQueries()
ds := queries[0].datasource
if err := s.pluginRequestValidator.Validate(ds.Url, nil); err != nil {
if err := s.pluginRequestValidator.Validate(ds.URL, nil); err != nil {
return nil, datasources.ErrDataSourceAccessDenied
}
// ensure that each query passed to this function has the same datasource
for _, pq := range queries {
if ds.Uid != pq.datasource.Uid {
return nil, fmt.Errorf("all queries must have the same datasource - found %s and %s", ds.Uid, pq.datasource.Uid)
if ds.UID != pq.datasource.UID {
return nil, fmt.Errorf("all queries must have the same datasource - found %s and %s", ds.UID, pq.datasource.UID)
}
}
@ -220,7 +220,7 @@ func (s *Service) handleQuerySingleDatasource(ctx context.Context, user *user.Si
req := &backend.QueryDataRequest{
PluginContext: backend.PluginContext{
OrgID: ds.OrgId,
OrgID: ds.OrgID,
PluginID: ds.Type,
User: adapters.BackendUserFromSignedInUser(user),
DataSourceInstanceSettings: instanceSettings,
@ -260,15 +260,15 @@ func (s *Service) parseMetricRequest(ctx context.Context, user *user.SignedInUse
return nil, ErrInvalidDatasourceID
}
datasourcesByUid[ds.Uid] = ds
if expr.IsDataSource(ds.Uid) {
datasourcesByUid[ds.UID] = ds
if expr.IsDataSource(ds.UID) {
req.hasExpression = true
} else {
req.dsTypes[ds.Type] = true
}
if _, ok := req.parsedQueries[ds.Uid]; !ok {
req.parsedQueries[ds.Uid] = []parsedQuery{}
if _, ok := req.parsedQueries[ds.UID]; !ok {
req.parsedQueries[ds.UID] = []parsedQuery{}
}
s.log.Debug("Processing metrics query", "query", query)
@ -278,7 +278,7 @@ func (s *Service) parseMetricRequest(ctx context.Context, user *user.SignedInUse
return nil, err
}
req.parsedQueries[ds.Uid] = append(req.parsedQueries[ds.Uid], parsedQuery{
req.parsedQueries[ds.UID] = append(req.parsedQueries[ds.UID], parsedQuery{
datasource: ds,
query: backend.DataQuery{
TimeRange: backend.TimeRange{

2
pkg/services/query/query_test.go
View File

@ -483,7 +483,7 @@ func (c *fakeDataSourceCache) GetDatasource(ctx context.Context, datasourceID in
func (c *fakeDataSourceCache) GetDatasourceByUID(ctx context.Context, datasourceUID string, user *user.SignedInUser, skipCache bool) (*datasources.DataSource, error) {
return &datasources.DataSource{
Uid: datasourceUID,
UID: datasourceUID,
}, nil
}

6
pkg/services/secrets/kvstore/migrations/datasource_mig.go
View File

@ -69,9 +69,9 @@ func (s *DataSourceSecretMigrationService) Migrate(ctx context.Context) error {
// Secrets are set by the update data source function if the SecureJsonData is set in the command
// Secrets are deleted by the update data source function if the disableSecretsCompatibility flag is enabled
err = s.dataSourcesService.UpdateDataSource(ctx, &datasources.UpdateDataSourceCommand{
Id: ds.Id,
OrgId: ds.OrgId,
Uid: ds.Uid,
ID: ds.ID,
OrgID: ds.OrgID,
UID: ds.UID,
Name: ds.Name,
JsonData: ds.JsonData,
SecureJsonData: secureJsonData,

36
pkg/services/secrets/kvstore/migrations/datasource_mig_test.go
View File

@ -47,11 +47,11 @@ func TestMigrate(t *testing.T) {
dataSourceName := "Test"
dataSourceOrg := int64(1)
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: dataSourceOrg,
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
EncryptedSecureJsonData: map[string][]byte{
"password": []byte("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"),
},
@ -59,7 +59,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -82,7 +82,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secure json data was deleted
query = &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -113,11 +113,11 @@ func TestMigrate(t *testing.T) {
// Add test data source
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: dataSourceOrg,
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
EncryptedSecureJsonData: map[string][]byte{
"password": []byte("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"),
},
@ -125,7 +125,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -148,7 +148,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secure json data was maintained for compatibility
query = &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -181,11 +181,11 @@ func TestMigrate(t *testing.T) {
// Add test data source
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: dataSourceOrg,
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
EncryptedSecureJsonData: map[string][]byte{
"password": []byte("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"),
},
@ -193,7 +193,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -216,7 +216,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secure json data was deleted
query = &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -240,7 +240,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secure json data was re-added for compatibility
query = &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -272,11 +272,11 @@ func TestMigrate(t *testing.T) {
// Add test data source
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgId: dataSourceOrg,
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
Access: datasources.DS_ACCESS_DIRECT,
Url: "http://test",
URL: "http://test",
EncryptedSecureJsonData: map[string][]byte{
"password": []byte("9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08"),
},
@ -284,7 +284,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -307,7 +307,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secure json data was maintained for compatibility
query = &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
@ -331,7 +331,7 @@ func TestMigrate(t *testing.T) {
assert.NoError(t, err)
// Check if the secure json data was deleted
query = &datasources.GetDataSourceQuery{OrgId: dataSourceOrg, Name: dataSourceName}
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)

6
pkg/services/sqlstore/migrations/external_alertmanagers.go
View File

@ -55,14 +55,14 @@ func (e externalAlertmanagerToDatasources) Exec(sess *xorm.Session, mg *migrator
return err
}
ds := &datasources.DataSource{
OrgId: result.OrgID,
OrgID: result.OrgID,
Name: fmt.Sprintf("alertmanager-%s", uid),
Type: "alertmanager",
Access: "proxy",
Url: uri,
URL: uri,
Created: time.Unix(result.CreatedAt, 0),
Updated: time.Unix(result.UpdatedAt, 0),
Uid: uid,
UID: uid,
Version: 1,
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,

12
pkg/services/sqlstore/migrations/ualert/migration_test.go
View File

@ -656,9 +656,9 @@ func createAlert(t *testing.T, orgId int64, dashboardId int64, panelsId int64, n
}
return &models.Alert{
OrgId: orgId,
DashboardId: dashboardId,
PanelId: panelsId,
OrgID: orgId,
DashboardID: dashboardId,
PanelID: panelsId,
Name: name,
Message: "message",
Frequency: int64(60),
@ -688,9 +688,9 @@ func createDashboard(t *testing.T, id int64, orgId int64, uid string) *dashboard
func createDatasource(t *testing.T, id int64, orgId int64, uid string) *datasources.DataSource {
t.Helper()
return &datasources.DataSource{
Id: id,
OrgId: orgId,
Uid: uid,
ID: id,
OrgID: orgId,
UID: uid,
Created: now,
Updated: now,
Name: uid, // Not tested, needed to satisfy contraint.

10
pkg/services/store/resolver/ds_cache.go
View File

@ -50,26 +50,26 @@ func (c *dsCache) refreshCache(ctx context.Context) error {
for _, ds := range q.Result {
val := &dsVal{
InternalID: ds.Id,
InternalID: ds.ID,
Name: ds.Name,
UID: ds.Uid,
UID: ds.UID,
Type: ds.Type,
IsDefault: ds.IsDefault,
}
_, ok := c.pluginStore.Plugin(ctx, val.Type)
val.PluginExists = ok
orgCache, ok := cache[ds.OrgId]
orgCache, ok := cache[ds.OrgID]
if !ok {
orgCache = make(map[string]*dsVal, 0)
cache[ds.OrgId] = orgCache
cache[ds.OrgID] = orgCache
}
orgCache[val.UID] = val
// Empty string or
if val.IsDefault {
defaultDS[ds.OrgId] = val
defaultDS[ds.OrgID] = val
}
}

12
pkg/services/store/resolver/service_test.go
View File

@ -20,17 +20,17 @@ func TestResolver(t *testing.T) {
ds := &fakeDatasources.FakeDataSourceService{
DataSources: []*datasources.DataSource{
{
Id: 123,
OrgId: 1,
ID: 123,
OrgID: 1,
Type: "influx",
Uid: "influx-uid",
UID: "influx-uid",
IsDefault: true,
},
{
Id: 234,
OrgId: 1,
ID: 234,
OrgID: 1,
Type: "influx",
Uid: "influx-uid2",
UID: "influx-uid2",
Name: "Influx2",
},
},

12
pkg/tests/api/alerting/api_admin_configuration_test.go
View File

@ -129,11 +129,11 @@ func TestIntegrationAdminConfiguration_SendingToExternalAlertmanagers(t *testing
// Add an alertmanager datasource
{
cmd := datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Name: "AM1",
Type: datasources.DS_ALERTMANAGER,
Access: "proxy",
Url: fakeAM1.URL(),
URL: fakeAM1.URL(),
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
"implementation": "prometheus",
@ -156,11 +156,11 @@ func TestIntegrationAdminConfiguration_SendingToExternalAlertmanagers(t *testing
// Add another alertmanager datasource
{
cmd := datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Name: "AM2",
Type: datasources.DS_ALERTMANAGER,
Access: "proxy",
Url: fakeAM2.URL(),
URL: fakeAM2.URL(),
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
"implementation": "prometheus",
@ -285,11 +285,11 @@ func TestIntegrationAdminConfiguration_SendingToExternalAlertmanagers(t *testing
// Add an alertmanager datasource fot the other organisation
{
cmd := datasources.AddDataSourceCommand{
OrgId: 2,
OrgID: 2,
Name: "AM3",
Type: datasources.DS_ALERTMANAGER,
Access: "proxy",
Url: fakeAM3.URL(),
URL: fakeAM3.URL(),
JsonData: simplejson.NewFromAny(map[string]interface{}{
"handleGrafanaManagedAlerts": true,
"implementation": "prometheus",

6
pkg/tests/api/alerting/api_backtesting_test.go
View File

@ -62,9 +62,9 @@ func TestBacktesting(t *testing.T) {
Name: "Backtesting-TestDatasource",
Type: "testdata",
Access: datasources.DS_ACCESS_PROXY,
Uid: query.DatasourceUID,
UserId: userId,
OrgId: 1,
UID: query.DatasourceUID,
UserID: userId,
OrgID: 1,
}
err := env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), dsCmd)
require.NoError(t, err)

6
pkg/tests/api/azuremonitor/azuremonitor_test.go
View File

@ -65,12 +65,12 @@ func TestIntegrationAzureMonitor(t *testing.T) {
uid := "azuremonitor"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Azure Monitor",
Type: datasources.DS_AZURE_MONITOR,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
JsonData: jsonData,
SecureJsonData: secureJSONData,
})

8
pkg/tests/api/correlations/correlations_create_test.go
View File

@ -45,18 +45,18 @@ func TestIntegrationCreateCorrelation(t *testing.T) {
Name: "read-only",
Type: "loki",
ReadOnly: true,
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
readOnlyDS := createDsCommand.Result.Uid
readOnlyDS := createDsCommand.Result.UID
createDsCommand = &datasources.AddDataSourceCommand{
Name: "writable",
Type: "loki",
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
writableDs := createDsCommand.Result.Uid
writableDs := createDsCommand.Result.UID
t.Run("Unauthenticated users shouldn't be able to create correlations", func(t *testing.T) {
res := ctx.Post(PostParams{

10
pkg/tests/api/correlations/correlations_delete_test.go
View File

@ -45,19 +45,19 @@ func TestIntegrationDeleteCorrelation(t *testing.T) {
Name: "read-only",
Type: "loki",
ReadOnly: true,
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
readOnlyDS := createDsCommand.Result.Uid
readOnlyDS := createDsCommand.Result.UID
createDsCommand = &datasources.AddDataSourceCommand{
Name: "writable",
Type: "loki",
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
writableDs := createDsCommand.Result.Uid
writableDsOrgId := createDsCommand.Result.OrgId
writableDs := createDsCommand.Result.UID
writableDsOrgId := createDsCommand.Result.OrgID
t.Run("Unauthenticated users shouldn't be able to delete correlations", func(t *testing.T) {
res := ctx.Delete(DeleteParams{

22
pkg/tests/api/correlations/correlations_read_test.go
View File

@ -68,14 +68,14 @@ func TestIntegrationReadCorrelation(t *testing.T) {
createDsCommand := &datasources.AddDataSourceCommand{
Name: "with-correlations",
Type: "loki",
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
dsWithCorrelations := createDsCommand.Result
correlation := ctx.createCorrelation(correlations.CreateCorrelationCommand{
SourceUID: dsWithCorrelations.Uid,
TargetUID: &dsWithCorrelations.Uid,
OrgId: dsWithCorrelations.OrgId,
SourceUID: dsWithCorrelations.UID,
TargetUID: &dsWithCorrelations.UID,
OrgId: dsWithCorrelations.OrgID,
Config: correlations.CorrelationConfig{
Type: correlations.ConfigTypeQuery,
Field: "foo",
@ -86,7 +86,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
createDsCommand = &datasources.AddDataSourceCommand{
Name: "without-correlations",
Type: "loki",
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
dsWithoutCorrelations := createDsCommand.Result
@ -99,13 +99,13 @@ func TestIntegrationReadCorrelation(t *testing.T) {
created, err := sess.InsertMulti(&[]correlations.Correlation{
{
UID: "uid-1",
SourceUID: dsWithoutCorrelations.Uid,
SourceUID: dsWithoutCorrelations.UID,
TargetUID: &nonExistingDsUID,
},
{
UID: "uid-2",
SourceUID: "THIS-DOES-NOT_EXIST",
TargetUID: &dsWithoutCorrelations.Uid,
TargetUID: &dsWithoutCorrelations.UID,
},
})
require.Equal(t, int64(2), created)
@ -215,7 +215,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
t.Run("If no correlation exists it should return 200", func(t *testing.T) {
res := ctx.Get(GetParams{
url: fmt.Sprintf("/api/datasources/uid/%s/correlations", dsWithoutCorrelations.Uid),
url: fmt.Sprintf("/api/datasources/uid/%s/correlations", dsWithoutCorrelations.UID),
user: adminUser,
})
require.Equal(t, http.StatusOK, res.StatusCode)
@ -234,7 +234,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
t.Run("Should correctly return correlations", func(t *testing.T) {
res := ctx.Get(GetParams{
url: fmt.Sprintf("/api/datasources/uid/%s/correlations", dsWithCorrelations.Uid),
url: fmt.Sprintf("/api/datasources/uid/%s/correlations", dsWithCorrelations.UID),
user: adminUser,
})
require.Equal(t, http.StatusOK, res.StatusCode)
@ -304,7 +304,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
t.Run("If no correlation exists it should return 404", func(t *testing.T) {
res := ctx.Get(GetParams{
url: fmt.Sprintf("/api/datasources/uid/%s/correlations/%s", dsWithoutCorrelations.Uid, "some-correlation-uid"),
url: fmt.Sprintf("/api/datasources/uid/%s/correlations/%s", dsWithoutCorrelations.UID, "some-correlation-uid"),
user: adminUser,
})
require.Equal(t, http.StatusNotFound, res.StatusCode)
@ -323,7 +323,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
t.Run("Should correctly return correlation", func(t *testing.T) {
res := ctx.Get(GetParams{
url: fmt.Sprintf("/api/datasources/uid/%s/correlations/%s", dsWithCorrelations.Uid, correlation.UID),
url: fmt.Sprintf("/api/datasources/uid/%s/correlations/%s", dsWithCorrelations.UID, correlation.UID),
user: adminUser,
})
require.Equal(t, http.StatusOK, res.StatusCode)

10
pkg/tests/api/correlations/correlations_update_test.go
View File

@ -45,19 +45,19 @@ func TestIntegrationUpdateCorrelation(t *testing.T) {
Name: "read-only",
Type: "loki",
ReadOnly: true,
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
readOnlyDS := createDsCommand.Result.Uid
readOnlyDS := createDsCommand.Result.UID
createDsCommand = &datasources.AddDataSourceCommand{
Name: "writable",
Type: "loki",
OrgId: 1,
OrgID: 1,
}
ctx.createDs(createDsCommand)
writableDs := createDsCommand.Result.Uid
writableDsOrgId := createDsCommand.Result.OrgId
writableDs := createDsCommand.Result.UID
writableDsOrgId := createDsCommand.Result.OrgID
t.Run("Unauthenticated users shouldn't be able to update correlations", func(t *testing.T) {
res := ctx.Patch(PatchParams{

6
pkg/tests/api/elasticsearch/elasticsearch_test.go
View File

@ -57,12 +57,12 @@ func TestIntegrationElasticsearch(t *testing.T) {
uid := "es"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Elasticsearch",
Type: datasources.DS_ES,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
BasicAuth: true,
BasicAuthUser: "basicAuthUser",
JsonData: jsonData,

6
pkg/tests/api/graphite/graphite_test.go
View File

@ -55,12 +55,12 @@ func TestIntegrationGraphite(t *testing.T) {
uid := "graphite"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "graphite",
Type: datasources.DS_GRAPHITE,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
BasicAuth: true,
BasicAuthUser: "basicAuthUser",
JsonData: jsonData,

6
pkg/tests/api/influxdb/influxdb_test.go
View File

@ -55,12 +55,12 @@ func TestIntegrationInflux(t *testing.T) {
uid := "influxdb"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "InfluxDB",
Type: datasources.DS_INFLUXDB,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
BasicAuth: true,
BasicAuthUser: "basicAuthUser",
JsonData: jsonData,

6
pkg/tests/api/loki/loki_test.go
View File

@ -55,12 +55,12 @@ func TestIntegrationLoki(t *testing.T) {
uid := "loki"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Loki",
Type: datasources.DS_LOKI,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
BasicAuth: true,
BasicAuthUser: "basicAuthUser",
JsonData: jsonData,

6
pkg/tests/api/opentdsb/opentdsb_test.go
View File

@ -55,12 +55,12 @@ func TestIntegrationOpenTSDB(t *testing.T) {
uid := "influxdb"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "opentsdb",
Type: datasources.DS_OPENTSDB,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
BasicAuth: true,
BasicAuthUser: "basicAuthUser",
JsonData: jsonData,

10
pkg/tests/api/plugins/backendplugin/backendplugin_test.go
View File

@ -284,12 +284,12 @@ func newTestScenario(t *testing.T, name string, opts []testScenarioOption, callb
tsCtx.uid = "test-plugin"
cmd := &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "TestPlugin",
Type: tsCtx.testPluginID,
Uid: tsCtx.uid,
Url: tsCtx.outgoingServer.URL,
UID: tsCtx.uid,
URL: tsCtx.outgoingServer.URL,
JsonData: jsonData,
SecureJsonData: secureJSONData,
}
@ -306,8 +306,8 @@ func newTestScenario(t *testing.T, name string, opts []testScenarioOption, callb
require.NoError(t, err)
getDataSourceQuery := &datasources.GetDataSourceQuery{
OrgId: 1,
Uid: tsCtx.uid,
OrgID: 1,
UID: tsCtx.uid,
}
err = testEnv.Server.HTTPServer.DataSourcesService.GetDataSource(ctx, getDataSourceQuery)
require.NoError(t, err)

6
pkg/tests/api/prometheus/prometheus_test.go
View File

@ -56,12 +56,12 @@ func TestIntegrationPrometheus(t *testing.T) {
uid := "prometheus"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgId: 1,
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Prometheus",
Type: datasources.DS_PROMETHEUS,
Uid: uid,
Url: outgoingServer.URL,
UID: uid,
URL: outgoingServer.URL,
BasicAuth: true,
BasicAuthUser: "basicAuthUser",
JsonData: jsonData,

6
pkg/tsdb/grafanads/grafana.go
View File

@ -74,11 +74,11 @@ type Service struct {
func DataSourceModel(orgId int64) *datasources.DataSource {
return &datasources.DataSource{
Id: DatasourceID,
Uid: DatasourceUID,
ID: DatasourceID,
UID: DatasourceUID,
Name: DatasourceName,
Type: "grafana",
OrgId: orgId,
OrgID: orgId,
JsonData: simplejson.New(),
SecureJsonData: make(map[string][]byte),
}

8
pkg/tsdb/legacydata/service/service.go
View File

@ -79,9 +79,9 @@ func generateRequest(ctx context.Context, ds *datasources.DataSource, decryptedJ
}
instanceSettings := &backend.DataSourceInstanceSettings{
ID: ds.Id,
ID: ds.ID,
Name: ds.Name,
URL: ds.Url,
URL: ds.URL,
Database: ds.Database,
User: ds.User,
BasicAuthEnabled: ds.BasicAuth,
@ -89,7 +89,7 @@ func generateRequest(ctx context.Context, ds *datasources.DataSource, decryptedJ
JSONData: jsonDataBytes,
DecryptedSecureJSONData: decryptedJsonData,
Updated: ds.Updated,
UID: ds.Uid,
UID: ds.UID,
}
if query.Headers == nil {
@ -98,7 +98,7 @@ func generateRequest(ctx context.Context, ds *datasources.DataSource, decryptedJ
req := &backend.QueryDataRequest{
PluginContext: backend.PluginContext{
OrgID: ds.OrgId,
OrgID: ds.OrgID,
PluginID: ds.Type,
User: adapters.BackendUserFromSignedInUser(query.User),
DataSourceInstanceSettings: instanceSettings,

6
pkg/tsdb/legacydata/service/service_test.go
View File

@ -40,12 +40,12 @@ func TestHandleRequest(t *testing.T) {
s := ProvideService(client, nil, dsService)
ds := &datasources.DataSource{Id: 12, Type: "unregisteredType", JsonData: simplejson.New()}
ds := &datasources.DataSource{ID: 12, Type: "unregisteredType", JsonData: simplejson.New()}
req := legacydata.DataQuery{
TimeRange: &legacydata.DataTimeRange{},
Queries: []legacydata.DataSubQuery{
{RefID: "A", DataSource: &datasources.DataSource{Id: 1, Type: "test"}, Model: simplejson.New()},
{RefID: "B", DataSource: &datasources.DataSource{Id: 1, Type: "test"}, Model: simplejson.New()},
{RefID: "A", DataSource: &datasources.DataSource{ID: 1, Type: "test"}, Model: simplejson.New()},
{RefID: "B", DataSource: &datasources.DataSource{ID: 1, Type: "test"}, Model: simplejson.New()},
},
}
res, err := s.HandleRequest(context.Background(), ds, req)