public/grafana
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

datasource as cfg: rename feature to provisioning

Browse Source
This commit is contained in:
bergquist
2017-11-15 14:30:32 +01:00
parent c9bfa781fd
commit 665df676a5
9 changed files with 27 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/setting/datasources/datasources.go
-174
View File
@@ -1,174 +0,0 @@
package datasources
import (
"errors"
"io/ioutil"
"path/filepath"
"github.com/grafana/grafana/pkg/bus"
"github.com/grafana/grafana/pkg/log"
"github.com/grafana/grafana/pkg/models"
yaml "gopkg.in/yaml.v2"
)
var (
ErrInvalidConfigToManyDefault = errors.New("datasource.yaml config is invalid. Only one datasource can be marked as default")
)
func Apply(configPath string) error {
dc := NewDatasourceConfiguration()
return dc.applyChanges(configPath)
}
type DatasourceConfigurator struct {
log log.Logger
cfgProvider configProvider
repository datasourceRepository
}
func NewDatasourceConfiguration() DatasourceConfigurator {
return newDatasourceConfiguration(log.New("setting.datasource"), sqlDatasourceRepository{})
}
func newDatasourceConfiguration(log log.Logger, repo datasourceRepository) DatasourceConfigurator {
return DatasourceConfigurator{
log: log,
repository: repo,
cfgProvider: configProvider{},
}
}
func (dc *DatasourceConfigurator) applyChanges(configPath string) error {
cfg, err := dc.cfgProvider.readConfig(configPath)
if err != nil {
return err
}
defaultCount := 0
for i := range cfg.Datasources {
if cfg.Datasources[i].OrgId == 0 {
cfg.Datasources[i].OrgId = 1
}
if cfg.Datasources[i].IsDefault {
defaultCount++
if defaultCount > 1 {
return ErrInvalidConfigToManyDefault
}
}
}
allDatasources, err := dc.repository.loadAllDatasources()
if err != nil {
return err
}
if err := dc.deleteDatasourcesNotInConfiguration(cfg, allDatasources); err != nil {
return err
}
for _, ds := range cfg.Datasources {
var dbDatasource *models.DataSource
for _, ddd := range allDatasources {
if ddd.Name == ds.Name && ddd.OrgId == ds.OrgId {
dbDatasource = ddd
break
}
}
if dbDatasource == nil {
dc.log.Info("inserting datasource from configuration ", "name", ds.Name)
insertCmd := createInsertCommand(ds)
err := dc.repository.insert(insertCmd)
if err != nil {
return err
}
} else {
dc.log.Debug("updating datasource from configuration", "name", ds.Name)
updateCmd := createUpdateCommand(ds, dbDatasource.Id)
if err := dc.repository.update(updateCmd); err != nil {
return err
}
}
}
return nil
}
func (dc *DatasourceConfigurator) deleteDatasourcesNotInConfiguration(cfg *DatasourcesAsConfig, allDatasources []*models.DataSource) error {
if cfg.PurgeOtherDatasources {
for _, dbDS := range allDatasources {
delete := true
for _, cfgDS := range cfg.Datasources {
if dbDS.Name == cfgDS.Name && dbDS.OrgId == cfgDS.OrgId {
delete = false
}
}
if delete {
dc.log.Info("deleting datasource from configuration", "name", dbDS.Name)
cmd := &models.DeleteDataSourceByIdCommand{Id: dbDS.Id, OrgId: dbDS.OrgId}
if err := dc.repository.delete(cmd); err != nil {
return err
}
}
}
}
return nil
}
type datasourceRepository interface {
insert(*models.AddDataSourceCommand) error
update(*models.UpdateDataSourceCommand) error
delete(*models.DeleteDataSourceByIdCommand) error
get(*models.GetDataSourceByNameQuery) error
loadAllDatasources() ([]*models.DataSource, error)
}
type sqlDatasourceRepository struct{}
type configProvider struct{}
func (configProvider) readConfig(path string) (*DatasourcesAsConfig, error) {
filename, _ := filepath.Abs(path)
yamlFile, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
var datasources *DatasourcesAsConfig
err = yaml.Unmarshal(yamlFile, &datasources)
if err != nil {
return nil, err
}
return datasources, nil
}
func (sqlDatasourceRepository) delete(cmd *models.DeleteDataSourceByIdCommand) error {
return bus.Dispatch(cmd)
}
func (sqlDatasourceRepository) update(cmd *models.UpdateDataSourceCommand) error {
return bus.Dispatch(cmd)
}
func (sqlDatasourceRepository) insert(cmd *models.AddDataSourceCommand) error {
return bus.Dispatch(cmd)
}
func (sqlDatasourceRepository) get(cmd *models.GetDataSourceByNameQuery) error {
return bus.Dispatch(cmd)
}
func (sqlDatasourceRepository) loadAllDatasources() ([]*models.DataSource, error) {
dss := &models.GetAllDataSourcesQuery{}
if err := bus.Dispatch(dss); err != nil {
return nil, err
}
return dss.Result, nil
}
pkg/setting/datasources/datasources_test.go
-144
View File
@@ -1,144 +0,0 @@
package datasources
import (
"testing"
"github.com/grafana/grafana/pkg/log"
"github.com/grafana/grafana/pkg/models"
. "github.com/smartystreets/goconvey/convey"
)
var (
logger log.Logger = log.New("fake.logger")
oneDatasourcesConfig string = ""
twoDatasourcesConfig string = "./test-configs/two-datasources.yaml"
twoDatasourcesConfigPurgeOthers string = "./test-configs/two-datasources-purge-others.yaml"
doubleDatasourcesConfig string = "./test-configs/double-default-datasources.yaml"
)
func TestDatasourceAsConfig(t *testing.T) {
Convey("Testing datasource as configuration", t, func() {
fakeRepo := &fakeRepository{}
Convey("One configured datasource", func() {
Convey("no datasource in database", func() {
dc := newDatasourceConfiguration(logger, fakeRepo)
err := dc.applyChanges(twoDatasourcesConfig)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 0)
So(len(fakeRepo.inserted), ShouldEqual, 2)
So(len(fakeRepo.updated), ShouldEqual, 0)
})
Convey("One datasource in database with same name", func() {
fakeRepo.loadAll = []*models.DataSource{
{Name: "Graphite", OrgId: 1, Id: 1},
}
Convey("should update one datasource", func() {
dc := newDatasourceConfiguration(logger, fakeRepo)
err := dc.applyChanges(twoDatasourcesConfig)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 0)
So(len(fakeRepo.inserted), ShouldEqual, 1)
So(len(fakeRepo.updated), ShouldEqual, 1)
})
})
Convey("Two datasources with is_default", func() {
dc := newDatasourceConfiguration(logger, fakeRepo)
err := dc.applyChanges(doubleDatasourcesConfig)
Convey("should raise error", func() {
So(err, ShouldEqual, ErrInvalidConfigToManyDefault)
})
})
})
Convey("Two configured datasource and purge others ", func() {
Convey("two other datasources in database", func() {
fakeRepo.loadAll = []*models.DataSource{
{Name: "old-graphite", OrgId: 1, Id: 1},
{Name: "old-graphite2", OrgId: 1, Id: 2},
}
Convey("should have two new datasources", func() {
dc := newDatasourceConfiguration(logger, fakeRepo)
err := dc.applyChanges(twoDatasourcesConfigPurgeOthers)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 2)
So(len(fakeRepo.inserted), ShouldEqual, 2)
So(len(fakeRepo.updated), ShouldEqual, 0)
})
})
})
Convey("Two configured datasource and purge others = false", func() {
Convey("two other datasources in database", func() {
fakeRepo.loadAll = []*models.DataSource{
{Name: "Graphite", OrgId: 1, Id: 1},
{Name: "old-graphite2", OrgId: 1, Id: 2},
}
Convey("should have two new datasources", func() {
dc := newDatasourceConfiguration(logger, fakeRepo)
err := dc.applyChanges(twoDatasourcesConfig)
if err != nil {
t.Fatalf("applyChanges return an error %v", err)
}
So(len(fakeRepo.deleted), ShouldEqual, 0)
So(len(fakeRepo.inserted), ShouldEqual, 1)
So(len(fakeRepo.updated), ShouldEqual, 1)
})
})
})
})
}
type fakeRepository struct {
inserted []*models.AddDataSourceCommand
deleted []*models.DeleteDataSourceByIdCommand
updated []*models.UpdateDataSourceCommand
loadAll []*models.DataSource
}
func (fc *fakeRepository) delete(cmd *models.DeleteDataSourceByIdCommand) error {
fc.deleted = append(fc.deleted, cmd)
return nil
}
func (fc *fakeRepository) update(cmd *models.UpdateDataSourceCommand) error {
fc.updated = append(fc.updated, cmd)
return nil
}
func (fc *fakeRepository) insert(cmd *models.AddDataSourceCommand) error {
fc.inserted = append(fc.inserted, cmd)
return nil
}
func (fc *fakeRepository) loadAllDatasources() ([]*models.DataSource, error) {
return fc.loadAll, nil
}
func (fc *fakeRepository) get(cmd *models.GetDataSourceByNameQuery) error {
for _, v := range fc.loadAll {
if cmd.Name == v.Name && cmd.OrgId == v.OrgId {
cmd.Result = v
return nil
}
}
return models.ErrDataSourceNotFound
}
pkg/setting/datasources/test-configs/double-default-datasources.yaml
-12
View File
@@ -1,12 +0,0 @@
purge_other_datasources: false
datasources:
- name: Graphite
type: graphite
access: proxy
url: http://localhost:8080
is_default: true
- name: Prometheus
type: prometheus
access: proxy
url: http://localhost:9090
is_default: true
pkg/setting/datasources/test-configs/two-datasources-purge-others.yaml
-10
View File
@@ -1,10 +0,0 @@
purge_other_datasources: true
datasources:
- name: Graphite
type: graphite
access: proxy
url: http://localhost:8080
- name: Prometheus
type: prometheus
access: proxy
url: http://localhost:9090
pkg/setting/datasources/test-configs/two-datasources.yaml
-10
View File
@@ -1,10 +0,0 @@
purge_other_datasources: false
datasources:
- name: Graphite
type: graphite
access: proxy
url: http://localhost:8080
- name: Prometheus
type: prometheus
access: proxy
url: http://localhost:9090
pkg/setting/datasources/test-configs/zero-datasources.yaml
-2
View File
@@ -1,2 +0,0 @@
purge_other_datasources: false
datasources:
pkg/setting/datasources/types.go
-80
View File
@@ -1,80 +0,0 @@
package datasources
import "github.com/grafana/grafana/pkg/models"
import "github.com/grafana/grafana/pkg/components/simplejson"
type DatasourcesAsConfig struct {
PurgeOtherDatasources bool `json:"purge_other_datasources" yaml:"purge_other_datasources"`
Datasources []DataSourceFromConfig `json:"datasources" yaml:"datasources"`
}
type DataSourceFromConfig struct {
OrgId int64 `json:"org_id" yaml:"org_id"`
Version int `json:"version" yaml:"version"`
Name string `json:"name" yaml:"name"`
Type string `json:"type" yaml:"type"`
Access string `json:"access" yaml:"access"`
Url string `json:"url" yaml:"url"`
Password string `json:"password" yaml:"password"`
User string `json:"user" yaml:"user"`
Database string `json:"database" yaml:"database"`
BasicAuth bool `json:"basic_auth" yaml:"basic_auth"`
BasicAuthUser string `json:"basic_auth_user" yaml:"basic_auth_user"`
BasicAuthPassword string `json:"basic_auth_password" yaml:"basic_auth_password"`
WithCredentials bool `json:"with_credentials" yaml:"with_credentials"`
IsDefault bool `json:"is_default" yaml:"is_default"`
JsonData string `json:"json_data" yaml:"json_data"`
SecureJsonData map[string]string `json:"secure_json_data" yaml:"secure_json_data"`
}
func createInsertCommand(ds DataSourceFromConfig) *models.AddDataSourceCommand {
jsonData, err := simplejson.NewJson([]byte(ds.JsonData))
if err != nil {
jsonData = simplejson.New()
}
return &models.AddDataSourceCommand{
OrgId: ds.OrgId,
Name: ds.Name,
Type: ds.Type,
Access: models.DsAccess(ds.Access),
Url: ds.Url,
Password: ds.Password,
User: ds.User,
Database: ds.Database,
BasicAuth: ds.BasicAuth,
BasicAuthUser: ds.BasicAuthUser,
BasicAuthPassword: ds.BasicAuthPassword,
WithCredentials: ds.WithCredentials,
IsDefault: ds.IsDefault,
JsonData: jsonData,
SecureJsonData: ds.SecureJsonData,
}
}
func createUpdateCommand(ds DataSourceFromConfig, id int64) *models.UpdateDataSourceCommand {
jsonData, err := simplejson.NewJson([]byte(ds.JsonData))
if err != nil {
jsonData = simplejson.New()
}
return &models.UpdateDataSourceCommand{
Id: id,
OrgId: ds.OrgId,
Name: ds.Name,
Type: ds.Type,
Access: models.DsAccess(ds.Access),
Url: ds.Url,
Password: ds.Password,
User: ds.User,
Database: ds.Database,
BasicAuth: ds.BasicAuth,
BasicAuthUser: ds.BasicAuthUser,
BasicAuthPassword: ds.BasicAuthPassword,
WithCredentials: ds.WithCredentials,
IsDefault: ds.IsDefault,
JsonData: jsonData,
SecureJsonData: ds.SecureJsonData,
}
}