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

Chore: Moves common and response into separate packages (#30298)

Browse Source 
* Chore: moves common and response into separate packages

* Chore: moves common and response into separate packages

* Update pkg/api/utils/common.go

Co-authored-by: Arve Knudsen <arve.knudsen@gmail.com>

* Chore: changes after PR comments

* Chore: move wrap to routing package

* Chore: move functions in common to response package

* Chore: move functions in common to response package

* Chore: formats imports

Co-authored-by: Arve Knudsen <arve.knudsen@gmail.com>
This commit is contained in:
Hugo Häggmark
2021-01-15 14:43:20 +01:00
committed by GitHub
co-authored by Arve Knudsen
parent a94c256516
commit 3d41267fc4
51 changed files with 1321 additions and 1248 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/api/datasources.go
+62 -61
View File
@@ -9,6 +9,7 @@ import (
"github.com/grafana/grafana-plugin-sdk-go/backend"
"github.com/grafana/grafana/pkg/api/datasource"
"github.com/grafana/grafana/pkg/api/dtos"
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/bus"
"github.com/grafana/grafana/pkg/infra/log"
"github.com/grafana/grafana/pkg/models"
@@ -19,11 +20,11 @@ import (
var datasourcesLogger = log.New("datasources")
func (hs *HTTPServer) GetDataSources(c *models.ReqContext) Response {
func (hs *HTTPServer) GetDataSources(c *models.ReqContext) response.Response {
query := models.GetDataSourcesQuery{OrgId: c.OrgId, DataSourceLimit: hs.Cfg.DataSourceLimit}
if err := bus.Dispatch(&query); err != nil {
return Error(500, "Failed to query datasources", err)
return response.Error(500, "Failed to query datasources", err)
}
result := make(dtos.DataSourceList, 0)
@@ -56,10 +57,10 @@ func (hs *HTTPServer) GetDataSources(c *models.ReqContext) Response {
sort.Sort(result)
return JSON(200, &result)
return response.JSON(200, &result)
}
func GetDataSourceById(c *models.ReqContext) Response {
func GetDataSourceById(c *models.ReqContext) response.Response {
query := models.GetDataSourceQuery{
Id: c.ParamsInt64(":id"),
OrgId: c.OrgId,
@@ -67,135 +68,135 @@ func GetDataSourceById(c *models.ReqContext) Response {
if err := bus.Dispatch(&query); err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(500, "Failed to query datasources", err)
return response.Error(500, "Failed to query datasources", err)
}
ds := query.Result
dtos := convertModelToDtos(ds)
return JSON(200, &dtos)
return response.JSON(200, &dtos)
}
func DeleteDataSourceById(c *models.ReqContext) Response {
func DeleteDataSourceById(c *models.ReqContext) response.Response {
id := c.ParamsInt64(":id")
if id <= 0 {
return Error(400, "Missing valid datasource id", nil)
return response.Error(400, "Missing valid datasource id", nil)
}
ds, err := getRawDataSourceById(id, c.OrgId)
if err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(400, "Failed to delete datasource", nil)
return response.Error(400, "Failed to delete datasource", nil)
}
if ds.ReadOnly {
return Error(403, "Cannot delete read-only data source", nil)
return response.Error(403, "Cannot delete read-only data source", nil)
}
cmd := &models.DeleteDataSourceCommand{ID: id, OrgID: c.OrgId}
err = bus.Dispatch(cmd)
if err != nil {
return Error(500, "Failed to delete datasource", err)
return response.Error(500, "Failed to delete datasource", err)
}
return Success("Data source deleted")
return response.Success("Data source deleted")
}
// GET /api/datasources/uid/:uid
func GetDataSourceByUID(c *models.ReqContext) Response {
func GetDataSourceByUID(c *models.ReqContext) response.Response {
ds, err := getRawDataSourceByUID(c.Params(":uid"), c.OrgId)
if err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(500, "Failed to query datasources", err)
return response.Error(500, "Failed to query datasources", err)
}
dtos := convertModelToDtos(ds)
return JSON(200, &dtos)
return response.JSON(200, &dtos)
}
// DELETE /api/datasources/uid/:uid
func DeleteDataSourceByUID(c *models.ReqContext) Response {
func DeleteDataSourceByUID(c *models.ReqContext) response.Response {
uid := c.Params(":uid")
if uid == "" {
return Error(400, "Missing datasource uid", nil)
return response.Error(400, "Missing datasource uid", nil)
}
ds, err := getRawDataSourceByUID(uid, c.OrgId)
if err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(400, "Failed to delete datasource", nil)
return response.Error(400, "Failed to delete datasource", nil)
}
if ds.ReadOnly {
return Error(403, "Cannot delete read-only data source", nil)
return response.Error(403, "Cannot delete read-only data source", nil)
}
cmd := &models.DeleteDataSourceCommand{UID: uid, OrgID: c.OrgId}
err = bus.Dispatch(cmd)
if err != nil {
return Error(500, "Failed to delete datasource", err)
return response.Error(500, "Failed to delete datasource", err)
}
return Success("Data source deleted")
return response.Success("Data source deleted")
}
func DeleteDataSourceByName(c *models.ReqContext) Response {
func DeleteDataSourceByName(c *models.ReqContext) response.Response {
name := c.Params(":name")
if name == "" {
return Error(400, "Missing valid datasource name", nil)
return response.Error(400, "Missing valid datasource name", nil)
}
getCmd := &models.GetDataSourceQuery{Name: name, OrgId: c.OrgId}
if err := bus.Dispatch(getCmd); err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(500, "Failed to delete datasource", err)
return response.Error(500, "Failed to delete datasource", err)
}
if getCmd.Result.ReadOnly {
return Error(403, "Cannot delete read-only data source", nil)
return response.Error(403, "Cannot delete read-only data source", nil)
}
cmd := &models.DeleteDataSourceCommand{Name: name, OrgID: c.OrgId}
err := bus.Dispatch(cmd)
if err != nil {
return Error(500, "Failed to delete datasource", err)
return response.Error(500, "Failed to delete datasource", err)
}
return JSON(200, util.DynMap{
return response.JSON(200, util.DynMap{
"message": "Data source deleted",
"id": getCmd.Result.Id,
})
}
func validateURL(tp string, u string) Response {
func validateURL(tp string, u string) response.Response {
if u != "" {
if _, err := datasource.ValidateURL(tp, u); err != nil {
datasourcesLogger.Error("Received invalid data source URL as part of data source command",
"url", u)
return Error(400, fmt.Sprintf("Validation error, invalid URL: %q", u), err)
return response.Error(400, fmt.Sprintf("Validation error, invalid URL: %q", u), err)
}
}
return nil
}
func AddDataSource(c *models.ReqContext, cmd models.AddDataSourceCommand) Response {
func AddDataSource(c *models.ReqContext, cmd models.AddDataSourceCommand) response.Response {
datasourcesLogger.Debug("Received command to add data source", "url", cmd.Url)
cmd.OrgId = c.OrgId
if resp := validateURL(cmd.Type, cmd.Url); resp != nil {
@@ -204,14 +205,14 @@ func AddDataSource(c *models.ReqContext, cmd models.AddDataSourceCommand) Respon
if err := bus.Dispatch(&cmd); err != nil {
if errors.Is(err, models.ErrDataSourceNameExists) || errors.Is(err, models.ErrDataSourceUidExists) {
return Error(409, err.Error(), err)
return response.Error(409, err.Error(), err)
}
return Error(500, "Failed to add datasource", err)
return response.Error(500, "Failed to add datasource", err)
}
ds := convertModelToDtos(cmd.Result)
return JSON(200, util.DynMap{
return response.JSON(200, util.DynMap{
"message": "Datasource added",
"id": cmd.Result.Id,
"name": cmd.Result.Name,
@@ -219,7 +220,7 @@ func AddDataSource(c *models.ReqContext, cmd models.AddDataSourceCommand) Respon
})
}
func UpdateDataSource(c *models.ReqContext, cmd models.UpdateDataSourceCommand) Response {
func UpdateDataSource(c *models.ReqContext, cmd models.UpdateDataSourceCommand) response.Response {
datasourcesLogger.Debug("Received command to update data source", "url", cmd.Url)
cmd.OrgId = c.OrgId
cmd.Id = c.ParamsInt64(":id")
@@ -229,15 +230,15 @@ func UpdateDataSource(c *models.ReqContext, cmd models.UpdateDataSourceCommand)
err := fillWithSecureJSONData(&cmd)
if err != nil {
return Error(500, "Failed to update datasource", err)
return response.Error(500, "Failed to update datasource", err)
}
err = bus.Dispatch(&cmd)
if err != nil {
if errors.Is(err, models.ErrDataSourceUpdatingOldVersion) {
return Error(500, "Failed to update datasource. Reload new version and try again", err)
return response.Error(500, "Failed to update datasource. Reload new version and try again", err)
}
return Error(500, "Failed to update datasource", err)
return response.Error(500, "Failed to update datasource", err)
}
query := models.GetDataSourceQuery{
@@ -247,14 +248,14 @@ func UpdateDataSource(c *models.ReqContext, cmd models.UpdateDataSourceCommand)
if err := bus.Dispatch(&query); err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(500, "Failed to query datasources", err)
return response.Error(500, "Failed to query datasources", err)
}
dtos := convertModelToDtos(query.Result)
return JSON(200, util.DynMap{
return response.JSON(200, util.DynMap{
"message": "Datasource updated",
"id": cmd.Id,
"name": cmd.Name,
@@ -313,29 +314,29 @@ func getRawDataSourceByUID(uid string, orgID int64) (*models.DataSource, error)
}
// Get /api/datasources/name/:name
func GetDataSourceByName(c *models.ReqContext) Response {
func GetDataSourceByName(c *models.ReqContext) response.Response {
query := models.GetDataSourceQuery{Name: c.Params(":name"), OrgId: c.OrgId}
if err := bus.Dispatch(&query); err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(500, "Failed to query datasources", err)
return response.Error(500, "Failed to query datasources", err)
}
dtos := convertModelToDtos(query.Result)
return JSON(200, &dtos)
return response.JSON(200, &dtos)
}
// Get /api/datasources/id/:name
func GetDataSourceIdByName(c *models.ReqContext) Response {
func GetDataSourceIdByName(c *models.ReqContext) response.Response {
query := models.GetDataSourceQuery{Name: c.Params(":name"), OrgId: c.OrgId}
if err := bus.Dispatch(&query); err != nil {
if errors.Is(err, models.ErrDataSourceNotFound) {
return Error(404, "Data source not found", nil)
return response.Error(404, "Data source not found", nil)
}
return Error(500, "Failed to query datasources", err)
return response.Error(500, "Failed to query datasources", err)
}
ds := query.Result
@@ -343,7 +344,7 @@ func GetDataSourceIdByName(c *models.ReqContext) Response {
Id: ds.Id,
}
return JSON(200, &dtos)
return response.JSON(200, &dtos)
}
// /api/datasources/:id/resources/*
@@ -414,25 +415,25 @@ func convertModelToDtos(ds *models.DataSource) dtos.DataSource {
// CheckDatasourceHealth sends a health check request to the plugin datasource
// /api/datasource/:id/health
func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) Response {
func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) response.Response {
datasourceID := c.ParamsInt64("id")
ds, err := hs.DatasourceCache.GetDatasource(datasourceID, c.SignedInUser, c.SkipCache)
if err != nil {
if errors.Is(err, models.ErrDataSourceAccessDenied) {
return Error(403, "Access denied to datasource", err)
return response.Error(403, "Access denied to datasource", err)
}
return Error(500, "Unable to load datasource metadata", err)
return response.Error(500, "Unable to load datasource metadata", err)
}
plugin, ok := hs.PluginManager.GetDatasource(ds.Type)
if !ok {
return Error(500, "Unable to find datasource plugin", err)
return response.Error(500, "Unable to find datasource plugin", err)
}
dsInstanceSettings, err := wrapper.ModelToInstanceSettings(ds)
if err != nil {
return Error(500, "Unable to get datasource model", err)
return response.Error(500, "Unable to get datasource model", err)
}
pCtx := backend.PluginContext{
User: wrapper.BackendUserFromSignedInUser(c.SignedInUser),
@@ -456,15 +457,15 @@ func (hs *HTTPServer) CheckDatasourceHealth(c *models.ReqContext) Response {
var jsonDetails map[string]interface{}
err = json.Unmarshal(resp.JSONDetails, &jsonDetails)
if err != nil {
return Error(500, "Failed to unmarshal detailed response from backend plugin", err)
return response.Error(500, "Failed to unmarshal detailed response from backend plugin", err)
}
payload["details"] = jsonDetails
}
if resp.Status != backend.HealthStatusOk {
return JSON(503, payload)
return response.JSON(503, payload)
}
return JSON(200, payload)
return response.JSON(200, payload)
}