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: Remove Result field from datasources (#63048)

Browse Source 
* Remove Result field from AddDataSourceCommand
* Remove DatasourcesPermissionFilterQuery Result
* Remove GetDataSourceQuery Result
* Remove GetDataSourcesByTypeQuery Result
* Remove GetDataSourcesQuery Result
* Remove GetDefaultDataSourceQuery Result
* Remove UpdateDataSourceCommand Result
This commit is contained in:
suntala 2023-02-09 15:49:44 +01:00 committed by GitHub
parent 8048a66e90
commit 49b3027049
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
47 changed files with 371 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
pkg/api/datasources.go
View File

@ -45,11 +45,12 @@ var secretsPluginError datasources.ErrDatasourceSecretsPluginUserFriendly
func (hs *HTTPServer) GetDataSources(c *contextmodel.ReqContext) response.Response {
query := datasources.GetDataSourcesQuery{OrgID: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
if err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query); err != nil {
dataSources, err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
if err != nil {
return response.Error(500, "Failed to query datasources", err)
}
filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, query.Result)
filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, dataSources)
if err != nil {
return response.Error(500, "Failed to query datasources", err)
}
@ -116,7 +117,8 @@ func (hs *HTTPServer) GetDataSourceById(c *contextmodel.ReqContext) response.Res
OrgID: c.OrgID,
}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
}
@ -126,7 +128,7 @@ func (hs *HTTPServer) GetDataSourceById(c *contextmodel.ReqContext) response.Res
return response.Error(500, "Failed to query datasources", err)
}
dto := hs.convertModelToDtos(c.Req.Context(), query.Result)
dto := hs.convertModelToDtos(c.Req.Context(), dataSource)
// Add accesscontrol metadata
dto.AccessControl = hs.getAccessControlMetadata(c, c.OrgID, datasources.ScopePrefix, dto.UID)
@ -291,19 +293,20 @@ func (hs *HTTPServer) DeleteDataSourceByName(c *contextmodel.ReqContext) respons
}
getCmd := &datasources.GetDataSourceQuery{Name: name, OrgID: c.OrgID}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), getCmd); err != nil {
dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), getCmd)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
}
return response.Error(500, "Failed to delete datasource", err)
}
if getCmd.Result.ReadOnly {
if dataSource.ReadOnly {
return response.Error(403, "Cannot delete read-only data source", nil)
}
cmd := &datasources.DeleteDataSourceCommand{Name: name, OrgID: c.OrgID}
err := hs.DataSourcesService.DeleteDataSource(c.Req.Context(), cmd)
err = hs.DataSourcesService.DeleteDataSource(c.Req.Context(), cmd)
if err != nil {
if errors.As(err, &secretsPluginError) {
return response.Error(500, "Failed to delete datasource: "+err.Error(), err)
@ -311,11 +314,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, dataSource.UID)
return response.JSON(http.StatusOK, util.DynMap{
"message": "Data source deleted",
"id": getCmd.Result.ID,
"id": dataSource.ID,
})
}
@ -383,7 +386,8 @@ func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Respons
return response.Error(http.StatusBadRequest, "Failed to add datasource", err)
}
if err := hs.DataSourcesService.AddDataSource(c.Req.Context(), &cmd); err != nil {
dataSource, err := hs.DataSourcesService.AddDataSource(c.Req.Context(), &cmd)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNameExists) || errors.Is(err, datasources.ErrDataSourceUidExists) {
return response.Error(409, err.Error(), err)
}
@ -401,11 +405,11 @@ func (hs *HTTPServer) AddDataSource(c *contextmodel.ReqContext) response.Respons
hs.accesscontrolService.ClearUserPermissionCache(c.SignedInUser)
}
ds := hs.convertModelToDtos(c.Req.Context(), cmd.Result)
ds := hs.convertModelToDtos(c.Req.Context(), dataSource)
return response.JSON(http.StatusOK, util.DynMap{
"message": "Datasource added",
"id": cmd.Result.ID,
"name": cmd.Result.Name,
"id": dataSource.ID,
"name": dataSource.Name,
"datasource": ds,
})
}
@ -505,7 +509,7 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
return response.Error(403, "Cannot update read-only data source", nil)
}
err := hs.DataSourcesService.UpdateDataSource(c.Req.Context(), &cmd)
_, err := hs.DataSourcesService.UpdateDataSource(c.Req.Context(), &cmd)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceUpdatingOldVersion) {
return response.Error(409, "Datasource has already been updated by someone else. Please reload and try again", err)
@ -522,14 +526,15 @@ func (hs *HTTPServer) updateDataSourceByID(c *contextmodel.ReqContext, ds *datas
OrgID: c.OrgID,
}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
}
return response.Error(500, "Failed to query datasource", err)
}
datasourceDTO := hs.convertModelToDtos(c.Req.Context(), query.Result)
datasourceDTO := hs.convertModelToDtos(c.Req.Context(), dataSource)
hs.Live.HandleDatasourceUpdate(c.OrgID, datasourceDTO.UID)
@ -547,11 +552,12 @@ func (hs *HTTPServer) getRawDataSourceById(ctx context.Context, id int64, orgID
OrgID: orgID,
}
if err := hs.DataSourcesService.GetDataSource(ctx, &query); err != nil {
dataSource, err := hs.DataSourcesService.GetDataSource(ctx, &query)
if err != nil {
return nil, err
}
return query.Result, nil
return dataSource, nil
}
func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, orgID int64) (*datasources.DataSource, error) {
@ -560,11 +566,12 @@ func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, org
OrgID: orgID,
}
if err := hs.DataSourcesService.GetDataSource(ctx, &query); err != nil {
dataSource, err := hs.DataSourcesService.GetDataSource(ctx, &query)
if err != nil {
return nil, err
}
return query.Result, nil
return dataSource, nil
}
// swagger:route GET /datasources/name/{name} datasources getDataSourceByName
@ -582,14 +589,15 @@ func (hs *HTTPServer) getRawDataSourceByUID(ctx context.Context, uid string, org
func (hs *HTTPServer) GetDataSourceByName(c *contextmodel.ReqContext) response.Response {
query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgID: c.OrgID}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
dataSource, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
}
return response.Error(500, "Failed to query datasources", err)
}
dto := hs.convertModelToDtos(c.Req.Context(), query.Result)
dto := hs.convertModelToDtos(c.Req.Context(), dataSource)
return response.JSON(http.StatusOK, &dto)
}
@ -609,14 +617,14 @@ func (hs *HTTPServer) GetDataSourceByName(c *contextmodel.ReqContext) response.R
func (hs *HTTPServer) GetDataSourceIdByName(c *contextmodel.ReqContext) response.Response {
query := datasources.GetDataSourceQuery{Name: web.Params(c.Req)[":name"], OrgID: c.OrgID}
if err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query); err != nil {
ds, err := hs.DataSourcesService.GetDataSource(c.Req.Context(), &query)
if err != nil {
if errors.Is(err, datasources.ErrDataSourceNotFound) {
return response.Error(404, "Data source not found", nil)
}
return response.Error(500, "Failed to query datasources", err)
}
ds := query.Result
dtos := dtos.AnyId{
Id: ds.ID,
}
@ -861,16 +869,16 @@ func (hs *HTTPServer) filterDatasourcesByQueryPermission(ctx context.Context, us
User: user,
Datasources: ds,
}
query.Result = ds
if err := hs.DatasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &query); err != nil {
dataSources, err := hs.DatasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &query)
if err != nil {
if !errors.Is(err, permissions.ErrNotImplemented) {
return nil, err
}
return ds, nil
}
return query.Result, nil
return dataSources, nil
}
// swagger:parameters checkDatasourceHealthByID

28
pkg/api/datasources_test.go
View File

@ -361,36 +361,32 @@ type dataSourcesServiceMock struct {
expectedError error
}
func (m *dataSourcesServiceMock) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
query.Result = m.expectedDatasource
return m.expectedError
func (m *dataSourcesServiceMock) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
return m.expectedDatasource, m.expectedError
}
func (m *dataSourcesServiceMock) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
query.Result = m.expectedDatasources
return m.expectedError
func (m *dataSourcesServiceMock) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
return m.expectedDatasources, m.expectedError
}
func (m *dataSourcesServiceMock) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
return m.expectedError
func (m *dataSourcesServiceMock) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
return m.expectedDatasources, m.expectedError
}
func (m *dataSourcesServiceMock) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
return m.expectedError
func (m *dataSourcesServiceMock) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
return nil, m.expectedError
}
func (m *dataSourcesServiceMock) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
return m.expectedError
}
func (m *dataSourcesServiceMock) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
cmd.Result = m.expectedDatasource
return m.expectedError
func (m *dataSourcesServiceMock) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
return m.expectedDatasource, m.expectedError
}
func (m *dataSourcesServiceMock) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
cmd.Result = m.expectedDatasource
return m.expectedError
func (m *dataSourcesServiceMock) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
return m.expectedDatasource, m.expectedError
}
func (m *dataSourcesServiceMock) DecryptedValues(ctx context.Context, ds *datasources.DataSource) (map[string]string, error) {

6
pkg/api/frontendsettings.go
View File

@ -262,16 +262,16 @@ func (hs *HTTPServer) getFSDataSources(c *contextmodel.ReqContext, availablePlug
orgDataSources := make([]*datasources.DataSource, 0)
if c.OrgID != 0 {
query := datasources.GetDataSourcesQuery{OrgID: c.OrgID, DataSourceLimit: hs.Cfg.DataSourceLimit}
err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
dataSources, err := hs.DataSourcesService.GetDataSources(c.Req.Context(), &query)
if err != nil {
return nil, err
}
if c.IsPublicDashboardView {
// If RBAC is enabled, it will filter out all datasources for a public user, so we need to skip it
orgDataSources = query.Result
orgDataSources = dataSources
} else {
filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, query.Result)
filtered, err := hs.filterDatasourcesByQueryPermission(c.Req.Context(), c.SignedInUser, dataSources)
if err != nil {
return nil, err
}

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

@ -38,14 +38,14 @@ func (s *Service) detectPrometheusVariants(ctx context.Context) (map[string]int6
}
dsProm := &datasources.GetDataSourcesByTypeQuery{Type: "prometheus"}
err := s.datasources.GetDataSourcesByType(ctx, dsProm)
dataSources, err := s.datasources.GetDataSourcesByType(ctx, dsProm)
if err != nil {
s.log.Error("Failed to read all Prometheus data sources", "error", err)
return nil, err
}
variants := map[string]int64{}
for _, ds := range dsProm.Result {
for _, ds := range dataSources {
variant, err := s.detectPrometheusVariant(ctx, ds)
if err != nil {
return nil, err

5
pkg/infra/usagestats/statscollector/service.go
View File

@ -239,11 +239,12 @@ func (s *Service) collectDatasourceStats(ctx context.Context) (map[string]interf
func (s *Service) collectElasticStats(ctx context.Context) (map[string]interface{}, error) {
m := map[string]interface{}{}
esDataSourcesQuery := datasources.GetDataSourcesByTypeQuery{Type: datasources.DS_ES}
if err := s.datasources.GetDataSourcesByType(ctx, &esDataSourcesQuery); err != nil {
dataSources, err := s.datasources.GetDataSourcesByType(ctx, &esDataSourcesQuery)
if err != nil {
s.log.Error("Failed to get elasticsearch json data", "error", err)
return nil, err
}
for _, data := range esDataSourcesQuery.Result {
for _, data := range dataSources {
esVersion, err := data.JsonData.Get("esVersion").String()
if err != nil {
continue

5
pkg/infra/usagestats/statscollector/service_test.go
View File

@ -460,9 +460,8 @@ type mockDatasourceService struct {
datasources []*datasources.DataSource
}
func (s mockDatasourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
query.Result = s.datasources
return nil
func (s mockDatasourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
return s.datasources, nil
}
func (s mockDatasourceService) GetHTTPTransport(ctx context.Context, ds *datasources.DataSource, provider httpclient.Provider, customMiddlewares ...sdkhttpclient.Middleware) (http.RoundTripper, error) {

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

@ -56,7 +56,7 @@ func setupFilterBenchmark(b *testing.B, numDs, numPermissions int) (db.DB, []acc
sqlStore := db.InitTestDB(b)
store := dsService.CreateStore(sqlStore, log.New("accesscontrol.test"))
for i := 1; i <= numDs; i++ {
err := store.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := store.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
Name: fmt.Sprintf("ds:%d", i),
OrgID: 1,
})

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)
}

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

@ -90,8 +90,8 @@ func GenerateDatasourcePermissions(b *testing.B, db *sqlstore.SQLStore, ac *stor
URL: "http://test",
}
dsStore := datasourcesService.CreateStore(db, log.New("publicdashboards.test"))
_ = dsStore.AddDataSource(context.Background(), addDSCommand)
dataSources = append(dataSources, addDSCommand.Result.ID)
dataSource, _ := dsStore.AddDataSource(context.Background(), addDSCommand)
dataSources = append(dataSources, dataSource.ID)
}
userIds, teamIds := generateTeamsAndUsers(b, db, usersNum)

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

@ -64,13 +64,13 @@ func (e *AlertEngine) mapRulesToUsageStats(ctx context.Context, rules []*models.
result := map[string]int{}
for k, v := range typeCount {
query := &datasources.GetDataSourceQuery{ID: k}
err := e.datasourceService.GetDataSource(ctx, query)
dataSource, err := e.datasourceService.GetDataSource(ctx, query)
if err != nil {
return map[string]int{}, nil
}
// aggregate datasource usages based on datasource type
result[query.Result.Type] += v
result[dataSource.Type] += v
}
return result, nil

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

@ -146,16 +146,17 @@ func (c *QueryCondition) executeQuery(context *alerting.EvalContext, timeRange l
OrgID: context.Rule.OrgID,
}
if err := context.GetDataSource(context.Ctx, getDsInfo); err != nil {
dataSource, err := context.GetDataSource(context.Ctx, getDsInfo)
if err != nil {
return nil, fmt.Errorf("could not find datasource: %w", err)
}
err := context.RequestValidator.Validate(getDsInfo.Result.URL, nil)
err = context.RequestValidator.Validate(dataSource.URL, nil)
if err != nil {
return nil, fmt.Errorf("access denied: %w", err)
}
req, err := c.getRequestForAlertRule(getDsInfo.Result, timeRange, context.IsDebug)
req, err := c.getRequestForAlertRule(dataSource, timeRange, context.IsDebug)
if err != nil {
return nil, fmt.Errorf("interval calculation failed: %w", err)
}
@ -198,7 +199,7 @@ func (c *QueryCondition) executeQuery(context *alerting.EvalContext, timeRange l
})
}
resp, err := requestHandler.HandleRequest(context.Ctx, getDsInfo.Result, req)
resp, err := requestHandler.HandleRequest(context.Ctx, dataSource, req)
if err != nil {
return nil, toCustomError(err)
}

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

@ -228,7 +228,7 @@ func (c *EvalContext) evaluateNotificationTemplateFields() error {
return nil
}
func (c *EvalContext) GetDataSource(ctx context.Context, q *datasources.GetDataSourceQuery) error {
func (c *EvalContext) GetDataSource(ctx context.Context, q *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
return c.DatasourceService.GetDataSource(ctx, q)
}

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

@ -39,32 +39,34 @@ func (e *DashAlertExtractorService) lookupQueryDataSource(ctx context.Context, p
dsName := ""
dsUid := ""
datasource, ok := panelQuery.CheckGet("datasource")
ds, ok := panelQuery.CheckGet("datasource")
if !ok {
datasource = panel.Get("datasource")
ds = panel.Get("datasource")
}
if name, err := datasource.String(); err == nil {
if name, err := ds.String(); err == nil {
dsName = name
} else if uid, ok := datasource.CheckGet("uid"); ok {
} else if uid, ok := ds.CheckGet("uid"); ok {
dsUid = uid.MustString()
}
if dsName == "" && dsUid == "" {
query := &datasources.GetDefaultDataSourceQuery{OrgID: orgID}
if err := e.datasourceService.GetDefaultDataSource(ctx, query); err != nil {
dataSource, err := e.datasourceService.GetDefaultDataSource(ctx, query)
if err != nil {
return nil, err
}
return query.Result, nil
return dataSource, nil
}
query := &datasources.GetDataSourceQuery{Name: dsName, UID: dsUid, OrgID: orgID}
if err := e.datasourceService.GetDataSource(ctx, query); err != nil {
dataSource, err := e.datasourceService.GetDataSource(ctx, query)
if err != nil {
return nil, err
}
return query.Result, nil
return dataSource, nil
}
func findPanelQueryByRefID(panel *simplejson.Json, refID string) *simplejson.Json {
@ -213,11 +215,12 @@ func (e *DashAlertExtractorService) getAlertFromPanels(ctx context.Context, json
Datasources: []*datasources.DataSource{datasource},
}
if err := e.datasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &dsFilterQuery); err != nil {
dataSources, err := e.datasourcePermissionsService.FilterDatasourcesBasedOnQueryPermissions(ctx, &dsFilterQuery)
if err != nil {
if !errors.Is(err, permissions.ErrNotImplemented) {
return nil, err
}
} else if len(dsFilterQuery.Result) == 0 {
} else if len(dataSources) == 0 {
return nil, datasources.ErrDataSourceAccessDenied
}

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

@ -372,12 +372,10 @@ type fakeDatasourceService struct {
datasources.DataSourceService
}
func (f *fakeDatasourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
query.Result = f.ExpectedDatasource
return nil
func (f *fakeDatasourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
return f.ExpectedDatasource, nil
}
func (f *fakeDatasourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
query.Result = f.ExpectedDatasource
return nil
func (f *fakeDatasourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
return f.ExpectedDatasource, nil
}

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

@ -26,16 +26,17 @@ func (s CorrelationsService) createCorrelation(ctx context.Context, cmd CreateCo
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err = s.DataSourceService.GetDataSource(ctx, query); err != nil {
dataSource, err := s.DataSourceService.GetDataSource(ctx, query)
if err != nil {
return ErrSourceDataSourceDoesNotExists
}
if !cmd.SkipReadOnlyCheck && query.Result.ReadOnly {
if !cmd.SkipReadOnlyCheck && dataSource.ReadOnly {
return ErrSourceDataSourceReadOnly
}
if cmd.TargetUID != nil {
if err = s.DataSourceService.GetDataSource(ctx, &datasources.GetDataSourceQuery{
if _, err = s.DataSourceService.GetDataSource(ctx, &datasources.GetDataSourceQuery{
OrgID: cmd.OrgId,
UID: *cmd.TargetUID,
}); err != nil {
@ -64,11 +65,12 @@ func (s CorrelationsService) deleteCorrelation(ctx context.Context, cmd DeleteCo
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
dataSource, err := s.DataSourceService.GetDataSource(ctx, query)
if err != nil {
return ErrSourceDataSourceDoesNotExists
}
if query.Result.ReadOnly {
if dataSource.ReadOnly {
return ErrSourceDataSourceReadOnly
}
@ -91,11 +93,12 @@ func (s CorrelationsService) updateCorrelation(ctx context.Context, cmd UpdateCo
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
dataSource, err := s.DataSourceService.GetDataSource(ctx, query)
if err != nil {
return ErrSourceDataSourceDoesNotExists
}
if query.Result.ReadOnly {
if dataSource.ReadOnly {
return ErrSourceDataSourceReadOnly
}
@ -153,7 +156,7 @@ func (s CorrelationsService) getCorrelation(ctx context.Context, cmd GetCorrelat
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
if _, err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists
}
@ -179,7 +182,7 @@ func (s CorrelationsService) getCorrelationsBySourceUID(ctx context.Context, cmd
OrgID: cmd.OrgId,
UID: cmd.SourceUID,
}
if err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
if _, err := s.DataSourceService.GetDataSource(ctx, query); err != nil {
return ErrSourceDataSourceDoesNotExists
}

12
pkg/services/datasources/datasources.go
View File

@ -13,28 +13,28 @@ import (
// DataSourceService interface for interacting with datasources.
type DataSourceService interface {
// GetDataSource gets a datasource.
GetDataSource(ctx context.Context, query *GetDataSourceQuery) error
GetDataSource(ctx context.Context, query *GetDataSourceQuery) (*DataSource, error)
// GetDataSources gets datasources.
GetDataSources(ctx context.Context, query *GetDataSourcesQuery) error
GetDataSources(ctx context.Context, query *GetDataSourcesQuery) ([]*DataSource, error)
// GetAllDataSources gets all datasources.
GetAllDataSources(ctx context.Context, query *GetAllDataSourcesQuery) error
// GetDataSourcesByType gets datasources by type.
GetDataSourcesByType(ctx context.Context, query *GetDataSourcesByTypeQuery) error
GetDataSourcesByType(ctx context.Context, query *GetDataSourcesByTypeQuery) ([]*DataSource, error)
// AddDataSource adds a new datasource.
AddDataSource(ctx context.Context, cmd *AddDataSourceCommand) error
AddDataSource(ctx context.Context, cmd *AddDataSourceCommand) (*DataSource, error)
// DeleteDataSource deletes an existing datasource.
DeleteDataSource(ctx context.Context, cmd *DeleteDataSourceCommand) error
// UpdateDataSource updates an existing datasource.
UpdateDataSource(ctx context.Context, cmd *UpdateDataSourceCommand) error
UpdateDataSource(ctx context.Context, cmd *UpdateDataSourceCommand) (*DataSource, error)
// GetDefaultDataSource gets the default datasource.
GetDefaultDataSource(ctx context.Context, query *GetDefaultDataSourceQuery) error
GetDefaultDataSource(ctx context.Context, query *GetDefaultDataSourceQuery) (*DataSource, error)
// GetHTTPTransport gets a datasource specific HTTP transport.
GetHTTPTransport(ctx context.Context, ds *DataSource, provider httpclient.Provider, customMiddlewares ...sdkhttpclient.Middleware) (http.RoundTripper, error)

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

@ -18,28 +18,27 @@ type FakeDataSourceService struct {
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
nameMatch := query.Name != "" && query.Name == datasource.Name
func (s *FakeDataSourceService) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
for _, dataSource := range s.DataSources {
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
return nil
return dataSource, nil
}
}
return datasources.ErrDataSourceNotFound
return nil, datasources.ErrDataSourceNotFound
}
func (s *FakeDataSourceService) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
func (s *FakeDataSourceService) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
var dataSources []*datasources.DataSource
for _, datasource := range s.DataSources {
orgMatch := query.OrgID != 0 && query.OrgID == datasource.OrgID
if orgMatch {
query.Result = append(query.Result, datasource)
dataSources = append(dataSources, datasource)
}
}
return nil
return dataSources, nil
}
func (s *FakeDataSourceService) GetAllDataSources(ctx context.Context, query *datasources.GetAllDataSourcesQuery) error {
@ -47,32 +46,33 @@ func (s *FakeDataSourceService) GetAllDataSources(ctx context.Context, query *da
return nil
}
func (s *FakeDataSourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
func (s *FakeDataSourceService) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
var dataSources []*datasources.DataSource
for _, datasource := range s.DataSources {
if query.OrgID > 0 && datasource.OrgID != query.OrgID {
continue
}
typeMatch := query.Type != "" && query.Type == datasource.Type
if typeMatch {
query.Result = append(query.Result, datasource)
dataSources = append(dataSources, datasource)
}
}
return nil
return dataSources, nil
}
func (s *FakeDataSourceService) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
func (s *FakeDataSourceService) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
if s.lastID == 0 {
s.lastID = int64(len(s.DataSources) - 1)
}
cmd.Result = &datasources.DataSource{
dataSource := &datasources.DataSource{
ID: s.lastID + 1,
Name: cmd.Name,
Type: cmd.Type,
UID: cmd.UID,
OrgID: cmd.OrgID,
}
s.DataSources = append(s.DataSources, cmd.Result)
return nil
s.DataSources = append(s.DataSources, dataSource)
return dataSource, nil
}
func (s *FakeDataSourceService) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
@ -88,7 +88,7 @@ func (s *FakeDataSourceService) DeleteDataSource(ctx context.Context, cmd *datas
return datasources.ErrDataSourceNotFound
}
func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
for _, datasource := range s.DataSources {
idMatch := cmd.ID != 0 && cmd.ID == datasource.ID
uidMatch := cmd.UID != "" && cmd.UID == datasource.UID
@ -97,14 +97,14 @@ func (s *FakeDataSourceService) UpdateDataSource(ctx context.Context, cmd *datas
if cmd.Name != "" {
datasource.Name = cmd.Name
}
return nil
return datasource, nil
}
}
return datasources.ErrDataSourceNotFound
return nil, datasources.ErrDataSourceNotFound
}
func (s *FakeDataSourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
return nil
func (s *FakeDataSourceService) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
return nil, nil
}
func (s *FakeDataSourceService) GetHTTPTransport(ctx context.Context, ds *datasources.DataSource, provider httpclient.Provider, customMiddlewares ...sdkhttpclient.Middleware) (http.RoundTripper, error) {

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

@ -105,8 +105,6 @@ type AddDataSourceCommand struct {
ReadOnly bool `json:"-"`
EncryptedSecureJsonData map[string][]byte `json:"-"`
UpdateSecretFn UpdateSecretFn `json:"-"`
Result *DataSource `json:"-"`
}
// Also acts as api DTO
@ -131,8 +129,6 @@ type UpdateDataSourceCommand struct {
ReadOnly bool `json:"-"`
EncryptedSecureJsonData map[string][]byte `json:"-"`
UpdateSecretFn UpdateSecretFn `json:"-"`
Result *DataSource `json:"-"`
}
// DeleteDataSourceCommand will delete a DataSource based on OrgID as well as the UID (preferred), ID, or Name.
@ -159,7 +155,6 @@ type GetDataSourcesQuery struct {
OrgID int64
DataSourceLimit int
User *user.SignedInUser
Result []*DataSource
}
type GetAllDataSourcesQuery struct {
@ -167,15 +162,13 @@ type GetAllDataSourcesQuery struct {
}
type GetDataSourcesByTypeQuery struct {
OrgID int64 // optional: filter by org_id
Type string
Result []*DataSource
OrgID int64 // optional: filter by org_id
Type string
}
type GetDefaultDataSourceQuery struct {
OrgID int64
User *user.SignedInUser
Result *DataSource
OrgID int64
User *user.SignedInUser
}
// GetDataSourceQuery will get a DataSource based on OrgID as well as the UID (preferred), ID, or Name.
@ -186,14 +179,11 @@ type GetDataSourceQuery struct {
Name string
OrgID int64
Result *DataSource
}
type DatasourcesPermissionFilterQuery struct {
User *user.SignedInUser
Datasources []*DataSource
Result []*DataSource
}
const (

6
pkg/services/datasources/permissions/datasource_permissions.go
View File

@ -11,13 +11,13 @@ import (
var ErrNotImplemented = errors.New("not implemented")
type DatasourcePermissionsService interface {
FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) error
FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) ([]*datasources.DataSource, error)
FilterDatasourceUidsBasedOnQueryPermissions(ctx context.Context, user *user.SignedInUser, datasourceUids []string) ([]string, error)
}
// dummy method
func (hs *OSSDatasourcePermissionsService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) error {
return ErrNotImplemented
func (hs *OSSDatasourcePermissionsService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) ([]*datasources.DataSource, error) {
return nil, ErrNotImplemented
}
func (hs *OSSDatasourcePermissionsService) FilterDatasourceUidsBasedOnQueryPermissions(ctx context.Context, user *user.SignedInUser, datasourceUids []string) ([]string, error) {

5
pkg/services/datasources/permissions/datasource_permissions_mocks.go
View File

@ -17,9 +17,8 @@ func (m *mockDatasourcePermissionService) FilterDatasourceUidsBasedOnQueryPermis
return m.DsUidResult, m.ErrResult
}
func (m *mockDatasourcePermissionService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) error {
cmd.Result = m.DsResult
return m.ErrResult
func (m *mockDatasourcePermissionService) FilterDatasourcesBasedOnQueryPermissions(ctx context.Context, cmd *datasources.DatasourcesPermissionFilterQuery) ([]*datasources.DataSource, error) {
return m.DsResult, m.ErrResult
}
func NewMockDatasourcePermissionService() *mockDatasourcePermissionService {

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

@ -53,13 +53,11 @@ func (dc *CacheServiceImpl) GetDatasource(
query := &datasources.GetDataSourceQuery{ID: datasourceID, OrgID: user.OrgID}
ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
err := ss.GetDataSource(ctx, query)
ds, err := ss.GetDataSource(ctx, query)
if err != nil {
return nil, err
}
ds := query.Result
if ds.UID != "" {
dc.CacheService.Set(uidKey(ds.OrgID, ds.UID), ds, time.Second*5)
}
@ -93,13 +91,11 @@ func (dc *CacheServiceImpl) GetDatasourceByUID(
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}
ss := SqlStore{db: dc.SQLStore, logger: dc.logger}
err := ss.GetDataSource(ctx, query)
ds, err := ss.GetDataSource(ctx, query)
if err != nil {
return nil, err
}
ds := query.Result
dc.CacheService.Set(uidCacheKey, ds, dc.cacheTTL)
dc.CacheService.Set(idKey(ds.ID), ds, dc.cacheTTL)
return ds, nil

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

@ -97,7 +97,7 @@ func (s *Service) Usage(ctx context.Context, scopeParams *quota.ScopeParameters)
// DataSourceRetriever interface for retrieving a datasource.
type DataSourceRetriever interface {
// GetDataSource gets a datasource.
GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error
GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error)
}
// NewNameScopeResolver provides an ScopeAttributeResolver able to
@ -115,11 +115,12 @@ func NewNameScopeResolver(db DataSourceRetriever) (string, accesscontrol.ScopeAt
}
query := datasources.GetDataSourceQuery{Name: dsName, OrgID: orgID}
if err := db.GetDataSource(ctx, &query); err != nil {
dataSource, err := db.GetDataSource(ctx, &query)
if err != nil {
return nil, err
}
return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.UID)}, nil
return []string{datasources.ScopeProvider.GetResourceScopeUID(dataSource.UID)}, nil
})
}
@ -143,19 +144,20 @@ func NewIDScopeResolver(db DataSourceRetriever) (string, accesscontrol.ScopeAttr
}
query := datasources.GetDataSourceQuery{ID: dsID, OrgID: orgID}
if err := db.GetDataSource(ctx, &query); err != nil {
dataSource, err := db.GetDataSource(ctx, &query)
if err != nil {
return nil, err
}
return []string{datasources.ScopeProvider.GetResourceScopeUID(query.Result.UID)}, nil
return []string{datasources.ScopeProvider.GetResourceScopeUID(dataSource.UID)}, nil
})
}
func (s *Service) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
func (s *Service) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
return s.SQLStore.GetDataSource(ctx, query)
}
func (s *Service) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
func (s *Service) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
return s.SQLStore.GetDataSources(ctx, query)
}
@ -163,12 +165,14 @@ func (s *Service) GetAllDataSources(ctx context.Context, query *datasources.GetA
return s.SQLStore.GetAllDataSources(ctx, query)
}
func (s *Service) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
func (s *Service) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
return s.SQLStore.GetDataSourcesByType(ctx, query)
}
func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
return s.db.InTransaction(ctx, func(ctx context.Context) error {
func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
var dataSource *datasources.DataSource
return dataSource, s.db.InTransaction(ctx, func(ctx context.Context) error {
var err error
cmd.EncryptedSecureJsonData = make(map[string][]byte)
@ -188,7 +192,8 @@ func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSou
return s.SecretsStore.Set(ctx, cmd.OrgID, cmd.Name, kvstore.DataSourceSecretType, string(secret))
}
if err := s.SQLStore.AddDataSource(ctx, cmd); err != nil {
dataSource, err = s.SQLStore.AddDataSource(ctx, cmd)
if err != nil {
return err
}
@ -205,7 +210,7 @@ func (s *Service) AddDataSource(ctx context.Context, cmd *datasources.AddDataSou
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, dataSource.UID, permissions...); err != nil {
return err
}
}
@ -224,20 +229,21 @@ func (s *Service) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteD
})
}
func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
return s.db.InTransaction(ctx, func(ctx context.Context) error {
func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
var dataSource *datasources.DataSource
return dataSource, s.db.InTransaction(ctx, func(ctx context.Context) error {
var err error
query := &datasources.GetDataSourceQuery{
ID: cmd.ID,
OrgID: cmd.OrgID,
}
err = s.SQLStore.GetDataSource(ctx, query)
dataSource, err = s.SQLStore.GetDataSource(ctx, query)
if err != nil {
return err
}
err = s.fillWithSecureJSONData(ctx, cmd, query.Result)
err = s.fillWithSecureJSONData(ctx, cmd, dataSource)
if err != nil {
return err
}
@ -249,8 +255,8 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
return err
}
if query.Result.Name != cmd.Name {
err := s.SecretsStore.Rename(ctx, cmd.OrgID, query.Result.Name, kvstore.DataSourceSecretType, cmd.Name)
if dataSource.Name != cmd.Name {
err := s.SecretsStore.Rename(ctx, cmd.OrgID, dataSource.Name, kvstore.DataSourceSecretType, cmd.Name)
if err != nil {
return err
}
@ -260,11 +266,12 @@ func (s *Service) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateD
}
}
return s.SQLStore.UpdateDataSource(ctx, cmd)
dataSource, err = s.SQLStore.UpdateDataSource(ctx, cmd)
return err
})
}
func (s *Service) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) error {
func (s *Service) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
return s.SQLStore.GetDefaultDataSource(ctx, query)
}

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

@ -33,18 +33,16 @@ type dataSourceMockRetriever struct {
res []*datasources.DataSource
}
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
nameMatch := query.Name != "" && query.Name == datasource.Name
func (d *dataSourceMockRetriever) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
for _, dataSource := range d.res {
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
return nil
return dataSource, nil
}
}
return datasources.ErrDataSourceNotFound
return nil, datasources.ErrDataSourceNotFound
}
func TestService_NameScopeResolver(t *testing.T) {

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

@ -23,13 +23,13 @@ import (
// Store is the interface for the datasource Service's storage.
type Store interface {
GetDataSource(context.Context, *datasources.GetDataSourceQuery) error
GetDataSources(context.Context, *datasources.GetDataSourcesQuery) error
GetDataSourcesByType(context.Context, *datasources.GetDataSourcesByTypeQuery) error
GetDefaultDataSource(context.Context, *datasources.GetDefaultDataSourceQuery) error
GetDataSource(context.Context, *datasources.GetDataSourceQuery) (*datasources.DataSource, error)
GetDataSources(context.Context, *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error)
GetDataSourcesByType(context.Context, *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error)
GetDefaultDataSource(context.Context, *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error)
DeleteDataSource(context.Context, *datasources.DeleteDataSourceCommand) error
AddDataSource(context.Context, *datasources.AddDataSourceCommand) error
UpdateDataSource(context.Context, *datasources.UpdateDataSourceCommand) error
AddDataSource(context.Context, *datasources.AddDataSourceCommand) (*datasources.DataSource, error)
UpdateDataSource(context.Context, *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error)
GetAllDataSources(ctx context.Context, query *datasources.GetAllDataSourcesQuery) error
Count(context.Context, *quota.ScopeParameters) (*quota.Map, error)
@ -46,17 +46,22 @@ func CreateStore(db db.DB, logger log.Logger) *SqlStore {
// GetDataSource adds a datasource to the query model by querying by org_id as well as
// either uid (preferred), id, or name and is added to the bus.
func (ss *SqlStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
func (ss *SqlStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
metrics.MDBDataSourceQueryByID.Inc()
return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
return ss.getDataSource(ctx, query, sess)
var (
dataSource *datasources.DataSource
err error
)
return dataSource, ss.db.WithDbSession(ctx, func(sess *db.Session) error {
dataSource, err = ss.getDataSource(ctx, query, sess)
return err
})
}
func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDataSourceQuery, sess *db.Session) error {
func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDataSourceQuery, sess *db.Session) (*datasources.DataSource, error) {
if query.OrgID == 0 || (query.ID == 0 && len(query.Name) == 0 && len(query.UID) == 0) {
return datasources.ErrDataSourceIdentifierNotSet
return nil, datasources.ErrDataSourceIdentifierNotSet
}
datasource := &datasources.DataSource{Name: query.Name, OrgID: query.OrgID, ID: query.ID, UID: query.UID}
@ -64,27 +69,27 @@ func (ss *SqlStore) getDataSource(ctx context.Context, query *datasources.GetDat
if err != nil {
ss.logger.Error("Failed getting data source", "err", err, "uid", query.UID, "id", query.ID, "name", query.Name, "orgId", query.OrgID)
return err
return nil, err
} else if !has {
return datasources.ErrDataSourceNotFound
return nil, datasources.ErrDataSourceNotFound
}
query.Result = datasource
return nil
return datasource, nil
}
func (ss *SqlStore) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) error {
var sess *xorm.Session
return ss.db.WithDbSession(ctx, func(dbSess *db.Session) error {
func (ss *SqlStore) GetDataSources(ctx context.Context, query *datasources.GetDataSourcesQuery) ([]*datasources.DataSource, error) {
var (
sess *xorm.Session
dataSources []*datasources.DataSource
)
return dataSources, ss.db.WithDbSession(ctx, func(dbSess *db.Session) error {
if query.DataSourceLimit <= 0 {
sess = dbSess.Where("org_id=?", query.OrgID).Asc("name")
} else {
sess = dbSess.Limit(query.DataSourceLimit, 0).Where("org_id=?", query.OrgID).Asc("name")
}
query.Result = make([]*datasources.DataSource, 0)
return sess.Find(&query.Result)
return sess.Find(&dataSources)
})
}
@ -96,31 +101,30 @@ func (ss *SqlStore) GetAllDataSources(ctx context.Context, query *datasources.Ge
}
// GetDataSourcesByType returns all datasources for a given type or an error if the specified type is an empty string
func (ss *SqlStore) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) error {
func (ss *SqlStore) GetDataSourcesByType(ctx context.Context, query *datasources.GetDataSourcesByTypeQuery) ([]*datasources.DataSource, error) {
if query.Type == "" {
return fmt.Errorf("datasource type cannot be empty")
return nil, fmt.Errorf("datasource type cannot be empty")
}
query.Result = make([]*datasources.DataSource, 0)
return ss.db.WithDbSession(ctx, func(sess *db.Session) error {
dataSources := make([]*datasources.DataSource, 0)
return dataSources, 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)
return sess.Where("type=? AND org_id=?", query.Type, query.OrgID).Asc("id").Find(&dataSources)
}
return sess.Where("type=?", query.Type).Asc("id").Find(&query.Result)
return sess.Where("type=?", query.Type).Asc("id").Find(&dataSources)
})
}
// GetDefaultDataSource is used to get the default datasource of organization
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)
func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources.GetDefaultDataSourceQuery) (*datasources.DataSource, error) {
dataSource := datasources.DataSource{}
return &dataSource, ss.db.WithDbSession(ctx, func(sess *db.Session) error {
exists, err := sess.Where("org_id=? AND is_default=?", query.OrgID, true).Get(&dataSource)
if !exists {
return datasources.ErrDataSourceNotFound
}
query.Result = &datasource
return err
})
}
@ -130,13 +134,12 @@ func (ss *SqlStore) GetDefaultDataSource(ctx context.Context, query *datasources
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}
errGettingDS := ss.getDataSource(ctx, dsQuery, sess)
ds, errGettingDS := ss.getDataSource(ctx, dsQuery, sess)
if errGettingDS != nil && !errors.Is(errGettingDS, datasources.ErrDataSourceNotFound) {
return errGettingDS
}
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)
@ -148,7 +151,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(ds.UID))); errDeletingPerms != nil {
return errDeletingPerms
}
}
@ -219,8 +222,10 @@ func (ss *SqlStore) Count(ctx context.Context, scopeParams *quota.ScopeParameter
return u, nil
}
func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
var ds *datasources.DataSource
return ds, ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
existing := datasources.DataSource{OrgID: cmd.OrgID, Name: cmd.Name}
has, _ := sess.Get(&existing)
@ -240,7 +245,7 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
cmd.UID = uid
}
ds := &datasources.DataSource{
ds = &datasources.DataSource{
OrgID: cmd.OrgID,
Name: cmd.Name,
Type: cmd.Type,
@ -278,8 +283,6 @@ func (ss *SqlStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataS
}
}
cmd.Result = ds
sess.PublishAfterCommit(&events.DataSourceCreated{
Timestamp: time.Now(),
Name: cmd.Name,
@ -302,13 +305,14 @@ func updateIsDefaultFlag(ds *datasources.DataSource, sess *db.Session) error {
return nil
}
func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
return ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
var ds *datasources.DataSource
return ds, ss.db.WithTransactionalDbSession(ctx, func(sess *db.Session) error {
if cmd.JsonData == nil {
cmd.JsonData = simplejson.New()
}
ds := &datasources.DataSource{
ds = &datasources.DataSource{
ID: cmd.ID,
OrgID: cmd.OrgID,
Name: cmd.Name,
@ -372,7 +376,6 @@ func (ss *SqlStore) UpdateDataSource(ctx context.Context, cmd *datasources.Updat
}
}
cmd.Result = ds
return err
})
}

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

@ -39,22 +39,22 @@ func TestIntegrationDataAccess(t *testing.T) {
initDatasource := func(db db.DB) *datasources.DataSource {
cmd := defaultAddDatasourceCommand
ss := SqlStore{db: db}
err := ss.AddDataSource(context.Background(), &cmd)
_, err := ss.AddDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
require.Equal(t, 1, len(dataSources))
return query.Result[0]
return dataSources[0]
}
t.Run("AddDataSource", func(t *testing.T) {
t.Run("Can add datasource", func(t *testing.T) {
db := db.InitTestDB(t)
ss := SqlStore{db: db}
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: 10,
Name: "laban",
Type: datasources.DS_GRAPHITE,
@ -66,11 +66,11 @@ func TestIntegrationDataAccess(t *testing.T) {
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
ds := query.Result[0]
require.Equal(t, 1, len(dataSources))
ds := dataSources[0]
require.EqualValues(t, 10, ds.OrgID)
require.Equal(t, "site", ds.Database)
@ -90,9 +90,9 @@ func TestIntegrationDataAccess(t *testing.T) {
cmd2 := defaultAddDatasourceCommand
cmd1.UID = "test"
cmd2.UID = "test"
err := ss.AddDataSource(context.Background(), &cmd1)
_, err := ss.AddDataSource(context.Background(), &cmd1)
require.NoError(t, err)
err = ss.AddDataSource(context.Background(), &cmd2)
_, err = ss.AddDataSource(context.Background(), &cmd2)
require.Error(t, err)
require.IsType(t, datasources.ErrDataSourceUidExists, err)
})
@ -106,7 +106,7 @@ func TestIntegrationDataAccess(t *testing.T) {
return nil
})
err := sqlStore.AddDataSource(context.Background(), &defaultAddDatasourceCommand)
_, err := sqlStore.AddDataSource(context.Background(), &defaultAddDatasourceCommand)
require.NoError(t, err)
require.Eventually(t, func() bool {
@ -114,12 +114,12 @@ func TestIntegrationDataAccess(t *testing.T) {
}, time.Second, time.Millisecond)
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = sqlStore.GetDataSources(context.Background(), &query)
dataSources, err := sqlStore.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
require.Equal(t, 1, len(dataSources))
require.Equal(t, query.Result[0].ID, created.ID)
require.Equal(t, query.Result[0].UID, created.UID)
require.Equal(t, dataSources[0].ID, created.ID)
require.Equal(t, dataSources[0].UID, created.UID)
require.Equal(t, int64(10), created.OrgID)
require.Equal(t, "nisse", created.Name)
})
@ -133,7 +133,7 @@ func TestIntegrationDataAccess(t *testing.T) {
cmd.ID = ds.ID
cmd.Version = ds.Version
ss := SqlStore{db: db}
err := ss.UpdateDataSource(context.Background(), &cmd)
_, err := ss.UpdateDataSource(context.Background(), &cmd)
require.NoError(t, err)
})
@ -145,13 +145,13 @@ func TestIntegrationDataAccess(t *testing.T) {
cmd := defaultUpdateDatasourceCommand
cmd.ID = ds.ID
err := ss.UpdateDataSource(context.Background(), &cmd)
_, err := ss.UpdateDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDataSourceQuery{ID: ds.ID, OrgID: 10}
err = ss.GetDataSource(context.Background(), &query)
dataSource, err := ss.GetDataSource(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, ds.UID, query.Result.UID)
require.Equal(t, ds.UID, dataSource.UID)
})
t.Run("prevents update if version changed", func(t *testing.T) {
@ -171,10 +171,10 @@ func TestIntegrationDataAccess(t *testing.T) {
// Make a copy as UpdateDataSource modifies it
cmd2 := cmd
err := ss.UpdateDataSource(context.Background(), &cmd)
_, err := ss.UpdateDataSource(context.Background(), &cmd)
require.NoError(t, err)
err = ss.UpdateDataSource(context.Background(), &cmd2)
_, err = ss.UpdateDataSource(context.Background(), &cmd2)
require.Error(t, err)
})
@ -192,7 +192,7 @@ func TestIntegrationDataAccess(t *testing.T) {
URL: "http://test",
}
err := ss.UpdateDataSource(context.Background(), cmd)
_, err := ss.UpdateDataSource(context.Background(), cmd)
require.NoError(t, err)
})
@ -211,7 +211,7 @@ func TestIntegrationDataAccess(t *testing.T) {
Version: 90000,
}
err := ss.UpdateDataSource(context.Background(), cmd)
_, err := ss.UpdateDataSource(context.Background(), cmd)
require.NoError(t, err)
})
})
@ -226,13 +226,13 @@ func TestIntegrationDataAccess(t *testing.T) {
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 0, len(query.Result))
require.Equal(t, 0, len(dataSources))
})
t.Run("Can not delete datasource with wrong orgId", func(t *testing.T) {
t.Run("Can not delete datasource with wrong orgID", func(t *testing.T) {
db := db.InitTestDB(t)
ds := initDatasource(db)
ss := SqlStore{db: db}
@ -242,10 +242,10 @@ func TestIntegrationDataAccess(t *testing.T) {
require.NoError(t, err)
query := datasources.GetDataSourcesQuery{OrgID: 10}
err = ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
require.Equal(t, 1, len(dataSources))
})
})
@ -302,10 +302,10 @@ func TestIntegrationDataAccess(t *testing.T) {
err := ss.DeleteDataSource(context.Background(), &datasources.DeleteDataSourceCommand{Name: ds.Name, OrgID: ds.OrgID})
require.NoError(t, err)
err = ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 0, len(query.Result))
require.Equal(t, 0, len(dataSources))
})
t.Run("DeleteDataSourceAccessControlPermissions", func(t *testing.T) {
@ -342,7 +342,10 @@ func TestIntegrationDataAccess(t *testing.T) {
require.NoError(t, errGetPermissions)
require.Zero(t, permCount, "permissions associated to the data source should have been removed")
require.Equal(t, 0, len(query.Result))
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 0, len(dataSources))
})
t.Run("GetDataSources", func(t *testing.T) {
@ -351,7 +354,7 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
datasourceLimit := 6
for i := 0; i < datasourceLimit+1; i++ {
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: 10,
Name: "laban" + strconv.Itoa(i),
Type: datasources.DS_GRAPHITE,
@ -364,10 +367,10 @@ func TestIntegrationDataAccess(t *testing.T) {
}
query := datasources.GetDataSourcesQuery{OrgID: 10, DataSourceLimit: datasourceLimit}
err := ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, datasourceLimit, len(query.Result))
require.Equal(t, datasourceLimit, len(dataSources))
})
t.Run("No limit should be applied on the returned data sources if the limit is not set", func(t *testing.T) {
@ -375,7 +378,7 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
numberOfDatasource := 5100
for i := 0; i < numberOfDatasource; i++ {
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: 10,
Name: "laban" + strconv.Itoa(i),
Type: datasources.DS_GRAPHITE,
@ -388,10 +391,10 @@ func TestIntegrationDataAccess(t *testing.T) {
}
query := datasources.GetDataSourcesQuery{OrgID: 10}
err := ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, numberOfDatasource, len(query.Result))
require.Equal(t, numberOfDatasource, len(dataSources))
})
t.Run("No limit should be applied on the returned data sources if the limit is negative", func(t *testing.T) {
@ -399,7 +402,7 @@ func TestIntegrationDataAccess(t *testing.T) {
ss := SqlStore{db: db}
numberOfDatasource := 5100
for i := 0; i < numberOfDatasource; i++ {
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: 10,
Name: "laban" + strconv.Itoa(i),
Type: datasources.DS_GRAPHITE,
@ -412,10 +415,10 @@ func TestIntegrationDataAccess(t *testing.T) {
}
query := datasources.GetDataSourcesQuery{OrgID: 10, DataSourceLimit: -1}
err := ss.GetDataSources(context.Background(), &query)
dataSources, err := ss.GetDataSources(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, numberOfDatasource, len(query.Result))
require.Equal(t, numberOfDatasource, len(dataSources))
})
})
@ -424,7 +427,7 @@ func TestIntegrationDataAccess(t *testing.T) {
db := db.InitTestDB(t)
ss := SqlStore{db: db}
err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: 10,
Name: "Elasticsearch",
Type: datasources.DS_ES,
@ -435,7 +438,7 @@ func TestIntegrationDataAccess(t *testing.T) {
})
require.NoError(t, err)
err = ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err = ss.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: 10,
Name: "Graphite",
Type: datasources.DS_GRAPHITE,
@ -448,10 +451,10 @@ func TestIntegrationDataAccess(t *testing.T) {
query := datasources.GetDataSourcesByTypeQuery{Type: datasources.DS_ES}
err = ss.GetDataSourcesByType(context.Background(), &query)
dataSources, err := ss.GetDataSourcesByType(context.Background(), &query)
require.NoError(t, err)
require.Equal(t, 1, len(query.Result))
require.Equal(t, 1, len(dataSources))
})
t.Run("Returns an error if no type specified", func(t *testing.T) {
@ -460,7 +463,7 @@ func TestIntegrationDataAccess(t *testing.T) {
query := datasources.GetDataSourcesByTypeQuery{}
err := ss.GetDataSourcesByType(context.Background(), &query)
_, err := ss.GetDataSourcesByType(context.Background(), &query)
require.Error(t, err)
})
@ -484,11 +487,11 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
URL: "http://test",
}
err := ss.AddDataSource(context.Background(), &cmd)
_, err := ss.AddDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDefaultDataSourceQuery{OrgID: 10}
err = ss.GetDefaultDataSource(context.Background(), &query)
_, err = ss.GetDefaultDataSource(context.Background(), &query)
require.Error(t, err)
assert.True(t, errors.Is(err, datasources.ErrDataSourceNotFound))
})
@ -506,20 +509,20 @@ func TestIntegrationGetDefaultDataSource(t *testing.T) {
IsDefault: true,
}
err := ss.AddDataSource(context.Background(), &cmd)
_, err := ss.AddDataSource(context.Background(), &cmd)
require.NoError(t, err)
query := datasources.GetDefaultDataSourceQuery{OrgID: 10}
err = ss.GetDefaultDataSource(context.Background(), &query)
dataSource, err := ss.GetDefaultDataSource(context.Background(), &query)
require.NoError(t, err)
assert.Equal(t, "default datasource", query.Result.Name)
assert.Equal(t, "default datasource", dataSource.Name)
})
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}
err := ss.GetDefaultDataSource(context.Background(), &query)
_, err := ss.GetDefaultDataSource(context.Background(), &query)
require.Error(t, err)
assert.True(t, errors.Is(err, datasources.ErrDataSourceNotFound))
})

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

@ -12,16 +12,16 @@ func exportDataSources(helper *commitHelper, job *gitExportJob) error {
cmd := &datasources.GetDataSourcesQuery{
OrgID: helper.orgID,
}
err := job.datasourceService.GetDataSources(helper.ctx, cmd)
dataSources, err := job.datasourceService.GetDataSources(helper.ctx, cmd)
if err != nil {
return nil
}
sort.SliceStable(cmd.Result, func(i, j int) bool {
return cmd.Result[i].Created.After(cmd.Result[j].Created)
sort.SliceStable(dataSources, func(i, j int) bool {
return dataSources[i].Created.After(dataSources[j].Created)
})
for _, ds := range cmd.Result {
for _, ds := range dataSources {
ds.OrgID = 0
ds.Version = 0
ds.SecureJsonData = map[string][]byte{

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

@ -121,11 +121,11 @@ func (srv ConfigSrv) externalAlertmanagers(ctx context.Context, orgID int64) ([]
OrgID: orgID,
Type: datasources.DS_ALERTMANAGER,
}
err := srv.datasourceService.GetDataSourcesByType(ctx, query)
dataSources, err := srv.datasourceService.GetDataSourcesByType(ctx, query)
if err != nil {
return nil, fmt.Errorf("failed to fetch datasources for org: %w", err)
}
for _, ds := range query.Result {
for _, ds := range dataSources {
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

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

@ -214,11 +214,11 @@ func (d *AlertsRouter) alertmanagersFromDatasources(orgID int64) ([]string, erro
}
ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
defer cancel()
err := d.datasourceService.GetDataSourcesByType(ctx, query)
dataSources, err := d.datasourceService.GetDataSourcesByType(ctx, query)
if err != nil {
return nil, fmt.Errorf("failed to fetch datasources for org: %w", err)
}
for _, ds := range query.Result {
for _, ds := range dataSources {
if !ds.JsonData.Get(definitions.HandleGrafanaManagedAlerts).MustBool(false) {
continue
}

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

@ -367,14 +367,13 @@ type spyStore struct {
items []*datasources.DataSource
}
func (s *spyStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error {
func (s *spyStore) GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error) {
for _, v := range s.items {
if query.Name == v.Name && query.OrgID == v.OrgID {
query.Result = v
return nil
return v, nil
}
}
return datasources.ErrDataSourceNotFound
return nil, datasources.ErrDataSourceNotFound
}
func (s *spyStore) DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error {
@ -388,15 +387,12 @@ func (s *spyStore) DeleteDataSource(ctx context.Context, cmd *datasources.Delete
return nil
}
func (s *spyStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error {
func (s *spyStore) AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error) {
s.inserted = append(s.inserted, cmd)
cmd.Result = &datasources.DataSource{
UID: cmd.UID,
}
return nil
return &datasources.DataSource{UID: cmd.UID}, nil
}
func (s *spyStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error {
func (s *spyStore) UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error) {
s.updated = append(s.updated, cmd)
return nil
return nil, nil
}

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

@ -14,9 +14,9 @@ import (
)
type Store interface {
GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) error
AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) error
UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) error
GetDataSource(ctx context.Context, query *datasources.GetDataSourceQuery) (*datasources.DataSource, error)
AddDataSource(ctx context.Context, cmd *datasources.AddDataSourceCommand) (*datasources.DataSource, error)
UpdateDataSource(ctx context.Context, cmd *datasources.UpdateDataSourceCommand) (*datasources.DataSource, error)
DeleteDataSource(ctx context.Context, cmd *datasources.DeleteDataSourceCommand) error
}
@ -66,7 +66,7 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
for _, ds := range cfg.Datasources {
cmd := &datasources.GetDataSourceQuery{OrgID: ds.OrgID, Name: ds.Name}
err := dc.store.GetDataSource(ctx, cmd)
dataSource, err := dc.store.GetDataSource(ctx, cmd)
if err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
return err
}
@ -74,12 +74,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)
if err := dc.store.AddDataSource(ctx, insertCmd); err != nil {
dataSource, err := dc.store.AddDataSource(ctx, insertCmd)
if 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, dataSource.UID, insertCmd.OrgID); err == nil {
correlationsToInsert = append(correlationsToInsert, insertCorrelationCmd)
} else {
dc.log.Error("failed to parse correlation", "correlation", correlation)
@ -87,22 +88,22 @@ func (dc *DatasourceProvisioner) apply(ctx context.Context, cfg *configs) error
}
}
} else {
updateCmd := createUpdateCommand(ds, cmd.Result.ID)
updateCmd := createUpdateCommand(ds, dataSource.ID)
dc.log.Debug("updating datasource from configuration", "name", updateCmd.Name, "uid", updateCmd.UID)
if err := dc.store.UpdateDataSource(ctx, updateCmd); err != nil {
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: dataSource.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, dataSource.UID, updateCmd.OrgID); err == nil {
correlationsToInsert = append(correlationsToInsert, insertCorrelationCmd)
} else {
dc.log.Error("failed to parse correlation", "correlation", correlation)
@ -180,7 +181,8 @@ func (dc *DatasourceProvisioner) deleteDatasources(ctx context.Context, dsToDele
for _, ds := range dsToDelete {
cmd := &datasources.DeleteDataSourceCommand{OrgID: ds.OrgID, Name: ds.Name}
getDsQuery := &datasources.GetDataSourceQuery{Name: ds.Name, OrgID: ds.OrgID}
if err := dc.store.GetDataSource(ctx, getDsQuery); err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
dataSource, err := dc.store.GetDataSource(ctx, getDsQuery)
if err != nil && !errors.Is(err, datasources.ErrDataSourceNotFound) {
return err
}
@ -188,15 +190,15 @@ func (dc *DatasourceProvisioner) deleteDatasources(ctx context.Context, dsToDele
return err
}
if getDsQuery.Result != nil {
if dataSource != nil {
if err := dc.correlationsStore.DeleteCorrelationsBySourceUID(ctx, correlations.DeleteCorrelationsBySourceUIDCommand{
SourceUID: getDsQuery.Result.UID,
SourceUID: dataSource.UID,
}); err != nil {
return err
}
if err := dc.correlationsStore.DeleteCorrelationsByTargetUID(ctx, correlations.DeleteCorrelationsByTargetUIDCommand{
TargetUID: getDsQuery.Result.UID,
TargetUID: dataSource.UID,
}); err != nil {
return err
}

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

@ -267,7 +267,7 @@ func TestIntegrationUnauthenticatedUserCanGetPubdashPanelQueryData(t *testing.T)
cacheService := datasourcesService.ProvideCacheService(localcache.ProvideService(), db)
qds := buildQueryDataService(t, cacheService, nil, db)
dsStore := datasourcesService.CreateStore(db, log.New("publicdashboards.test"))
_ = dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, _ = dsStore.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
UID: "ds1",
OrgID: 1,
Name: "laban",

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

@ -68,7 +68,7 @@ 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{
_, err = s.dataSourcesService.UpdateDataSource(ctx, &datasources.UpdateDataSourceCommand{
ID: ds.ID,
OrgID: ds.OrgID,
UID: ds.UID,

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

@ -46,7 +46,7 @@ func TestMigrate(t *testing.T) {
ds := dsservice.CreateStore(sqlStore, log.NewNopLogger())
dataSourceName := "Test"
dataSourceOrg := int64(1)
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
@ -60,10 +60,10 @@ func TestMigrate(t *testing.T) {
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err := ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the migration status key is empty
value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@ -83,10 +83,10 @@ func TestMigrate(t *testing.T) {
// Check if the secure json data was deleted
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.Empty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.Empty(t, dataSource.SecureJsonData)
// Check if the secret was added to the secret store
value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@ -112,7 +112,7 @@ func TestMigrate(t *testing.T) {
dataSourceOrg := int64(1)
// Add test data source
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
@ -126,10 +126,10 @@ func TestMigrate(t *testing.T) {
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err := ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the migration status key is empty
value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@ -149,10 +149,10 @@ func TestMigrate(t *testing.T) {
// Check if the secure json data was maintained for compatibility
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the secret was added to the secret store
value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@ -180,7 +180,7 @@ func TestMigrate(t *testing.T) {
dataSourceOrg := int64(1)
// Add test data source
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
@ -194,10 +194,10 @@ func TestMigrate(t *testing.T) {
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err := ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the migration status key is empty
value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@ -217,10 +217,10 @@ func TestMigrate(t *testing.T) {
// Check if the secure json data was deleted
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.Empty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.Empty(t, dataSource.SecureJsonData)
// Check if the secret was added to the secret store
value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@ -241,10 +241,10 @@ func TestMigrate(t *testing.T) {
// Check if the secure json data was re-added for compatibility
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the secret was added to the secret store
value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@ -271,7 +271,7 @@ func TestMigrate(t *testing.T) {
dataSourceOrg := int64(1)
// Add test data source
err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
_, err := ds.AddDataSource(context.Background(), &datasources.AddDataSourceCommand{
OrgID: dataSourceOrg,
Name: dataSourceName,
Type: datasources.DS_MYSQL,
@ -285,10 +285,10 @@ func TestMigrate(t *testing.T) {
// Check if the secret json data was added
query := &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err := ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the migration status key is empty
value, exist, err := kvStore.Get(context.Background(), 0, secretskvs.DataSourceSecretType, secretMigrationStatusKey)
@ -308,10 +308,10 @@ func TestMigrate(t *testing.T) {
// Check if the secure json data was maintained for compatibility
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.NotEmpty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.NotEmpty(t, dataSource.SecureJsonData)
// Check if the secret was added to the secret store
value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)
@ -332,10 +332,10 @@ func TestMigrate(t *testing.T) {
// Check if the secure json data was deleted
query = &datasources.GetDataSourceQuery{OrgID: dataSourceOrg, Name: dataSourceName}
err = ds.GetDataSource(context.Background(), query)
dataSource, err = ds.GetDataSource(context.Background(), query)
assert.NoError(t, err)
assert.NotNil(t, query.Result)
assert.Empty(t, query.Result.SecureJsonData)
assert.NotNil(t, dataSource)
assert.Empty(t, dataSource.SecureJsonData)
// Check if the secret was added to the secret store
value, exist, err = secretsStore.Get(context.Background(), dataSourceOrg, dataSourceName, secretskvs.DataSourceSecretType)

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

@ -66,7 +66,7 @@ func TestBacktesting(t *testing.T) {
UserID: userId,
OrgID: 1,
}
err := env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), dsCmd)
_, err := env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), dsCmd)
require.NoError(t, err)
break
}

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

@ -64,7 +64,7 @@ func TestIntegrationAzureMonitor(t *testing.T) {
}
uid := "azuremonitor"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Azure Monitor",

5
pkg/tests/api/correlations/common_test.go
View File

@ -149,11 +149,12 @@ func (c TestContext) createUser(cmd user.CreateUserCommand) {
require.NoError(c.t, err)
}
func (c TestContext) createDs(cmd *datasources.AddDataSourceCommand) {
func (c TestContext) createDs(cmd *datasources.AddDataSourceCommand) *datasources.DataSource {
c.t.Helper()
err := c.env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), cmd)
dataSource, err := c.env.Server.HTTPServer.DataSourcesService.AddDataSource(context.Background(), cmd)
require.NoError(c.t, err)
return dataSource
}
func (c TestContext) createCorrelation(cmd correlations.CreateCorrelationCommand) correlations.Correlation {

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

@ -47,16 +47,16 @@ func TestIntegrationCreateCorrelation(t *testing.T) {
ReadOnly: true,
OrgID: 1,
}
ctx.createDs(createDsCommand)
readOnlyDS := createDsCommand.Result.UID
dataSource := ctx.createDs(createDsCommand)
readOnlyDS := dataSource.UID
createDsCommand = &datasources.AddDataSourceCommand{
Name: "writable",
Type: "loki",
OrgID: 1,
}
ctx.createDs(createDsCommand)
writableDs := createDsCommand.Result.UID
dataSource = ctx.createDs(createDsCommand)
writableDs := dataSource.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

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

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

@ -70,8 +70,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
Type: "loki",
OrgID: 1,
}
ctx.createDs(createDsCommand)
dsWithCorrelations := createDsCommand.Result
dsWithCorrelations := ctx.createDs(createDsCommand)
correlation := ctx.createCorrelation(correlations.CreateCorrelationCommand{
SourceUID: dsWithCorrelations.UID,
TargetUID: &dsWithCorrelations.UID,
@ -88,8 +87,7 @@ func TestIntegrationReadCorrelation(t *testing.T) {
Type: "loki",
OrgID: 1,
}
ctx.createDs(createDsCommand)
dsWithoutCorrelations := createDsCommand.Result
dsWithoutCorrelations := ctx.createDs(createDsCommand)
// This creates 2 records in the correlation table that should never be returned by the API.
// Given all tests in this file work on the assumption that only a single correlation exists,

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

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

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

@ -56,7 +56,7 @@ func TestIntegrationElasticsearch(t *testing.T) {
}
uid := "es"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Elasticsearch",

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

@ -54,7 +54,7 @@ func TestIntegrationGraphite(t *testing.T) {
}
uid := "graphite"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "graphite",

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

@ -54,7 +54,7 @@ func TestIntegrationInflux(t *testing.T) {
}
uid := "influxdb"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "InfluxDB",

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

@ -54,7 +54,7 @@ func TestIntegrationLoki(t *testing.T) {
}
uid := "loki"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Loki",

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

@ -54,7 +54,7 @@ func TestIntegrationOpenTSDB(t *testing.T) {
}
uid := "influxdb"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "opentsdb",

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

@ -302,17 +302,17 @@ func newTestScenario(t *testing.T, name string, opts []testScenarioOption, callb
tsCtx.modifyIncomingRequest = in.modifyIncomingRequest
tsCtx.testEnv.OAuthTokenService.Token = in.token
err = testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, cmd)
_, err = testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, cmd)
require.NoError(t, err)
getDataSourceQuery := &datasources.GetDataSourceQuery{
OrgID: 1,
UID: tsCtx.uid,
}
err = testEnv.Server.HTTPServer.DataSourcesService.GetDataSource(ctx, getDataSourceQuery)
dataSource, err := testEnv.Server.HTTPServer.DataSourcesService.GetDataSource(ctx, getDataSourceQuery)
require.NoError(t, err)
rt, err := testEnv.Server.HTTPServer.DataSourcesService.GetHTTPTransport(ctx, getDataSourceQuery.Result, testEnv.HTTPClientProvider)
rt, err := testEnv.Server.HTTPServer.DataSourcesService.GetHTTPTransport(ctx, dataSource, testEnv.HTTPClientProvider)
require.NoError(t, err)
tsCtx.rt = rt

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

@ -55,7 +55,7 @@ func TestIntegrationPrometheus(t *testing.T) {
}
uid := "prometheus"
err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
_, err := testEnv.Server.HTTPServer.DataSourcesService.AddDataSource(ctx, &datasources.AddDataSourceCommand{
OrgID: 1,
Access: datasources.DS_ACCESS_PROXY,
Name: "Prometheus",