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

Alerting: Refactor API types generation with different names. (#51785)

Browse Source 
This changes the API codegen template (controller-api.mustache) to simplify some names. When this package was created, most APIs "forked" to either a Grafana backend implementation or a "Lotex" remote implementation. As we have added APIs it's no longer the case. Provisioning, configuration, and testing APIs do not fork, and we are likely to add additional APIs that don't fork.

This change replaces {{classname}}ForkingService with {{classname}} for interface names, and names the concrete implementation {{classname}}Handler. It changes the implied implementation of a route handler from fork{{nickname}} to handle{{nickname}}. So PrometheusApiForkingService becomes PrometheusApi, ForkedPrometheusApi becomes PrometheusApiHandler and forkRouteGetGrafanaAlertStatuses becomes handleRouteGetGrafanaAlertStatuses

It also renames some files - APIs that do no forking go from forked_{{name}}.go to {{name}}.go and APIs that still fork go from forked_{{name}}.go to forking_{{name}}.go to capture the idea that those files a "doing forking" rather than "are a fork of something."

Signed-off-by: Joe Blubaugh <joe.blubaugh@grafana.com>
This commit is contained in:
Joe Blubaugh
2022-07-18 15:08:08 +08:00
committed by GitHub
parent 9abe9fa702
commit 689ae96a0e
21 changed files with 464 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -93,19 +93,19 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) {
} }
// Register endpoints for proxying to Alertmanager-compatible backends. // Register endpoints for proxying to Alertmanager-compatible backends.
api.RegisterAlertmanagerApiEndpoints(NewForkedAM( api.RegisterAlertmanagerApiEndpoints(NewForkingAM(
api.DatasourceCache, api.DatasourceCache,
NewLotexAM(proxy, logger), NewLotexAM(proxy, logger),
&AlertmanagerSrv{crypto: api.MultiOrgAlertmanager.Crypto, log: logger, ac: api.AccessControl, mam: api.MultiOrgAlertmanager}, &AlertmanagerSrv{crypto: api.MultiOrgAlertmanager.Crypto, log: logger, ac: api.AccessControl, mam: api.MultiOrgAlertmanager},
), m) ), m)
// Register endpoints for proxying to Prometheus-compatible backends. // Register endpoints for proxying to Prometheus-compatible backends.
api.RegisterPrometheusApiEndpoints(NewForkedProm( api.RegisterPrometheusApiEndpoints(NewForkingProm(
api.DatasourceCache, api.DatasourceCache,
NewLotexProm(proxy, logger), NewLotexProm(proxy, logger),
&PrometheusSrv{log: logger, manager: api.StateManager, store: api.RuleStore, ac: api.AccessControl}, &PrometheusSrv{log: logger, manager: api.StateManager, store: api.RuleStore, ac: api.AccessControl},
), m) ), m)
// Register endpoints for proxying to Cortex Ruler-compatible backends. // Register endpoints for proxying to Cortex Ruler-compatible backends.
api.RegisterRulerApiEndpoints(NewForkedRuler( api.RegisterRulerApiEndpoints(NewForkingRuler(
api.DatasourceCache, api.DatasourceCache,
NewLotexRuler(proxy, logger), NewLotexRuler(proxy, logger),
&RulerSrv{ &RulerSrv{
@@ -120,7 +120,7 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) {
ac: api.AccessControl, ac: api.AccessControl,
}, },
), m) ), m)
api.RegisterTestingApiEndpoints(NewForkedTestingApi( api.RegisterTestingApiEndpoints(NewTestingApi(
&TestingApiSrv{ &TestingApiSrv{
AlertingProxy: proxy, AlertingProxy: proxy,
DatasourceCache: api.DatasourceCache, DatasourceCache: api.DatasourceCache,
@@ -128,15 +128,15 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) {
accessControl: api.AccessControl, accessControl: api.AccessControl,
evaluator: eval.NewEvaluator(api.Cfg, log.New("ngalert.eval"), api.DatasourceCache, api.SecretsService, api.ExpressionService), evaluator: eval.NewEvaluator(api.Cfg, log.New("ngalert.eval"), api.DatasourceCache, api.SecretsService, api.ExpressionService),
}), m) }), m)
api.RegisterConfigurationApiEndpoints(NewForkedConfiguration( api.RegisterConfigurationApiEndpoints(NewConfiguration(
&AdminSrv{ &ConfigSrv{
store: api.AdminConfigStore, store: api.AdminConfigStore,
log: logger, log: logger,
alertmanagerProvider: api.AlertsRouter, alertmanagerProvider: api.AlertsRouter,
}, },
), m) ), m)
api.RegisterProvisioningApiEndpoints(NewForkedProvisioningApi(&ProvisioningSrv{ api.RegisterProvisioningApiEndpoints(NewProvisioningApi(&ProvisioningSrv{
log: logger, log: logger,
policies: api.Policies, policies: api.Policies,
contactPointService: api.ContactPointService, contactPointService: api.ContactPointService,

10
pkg/services/ngalert/api/api_admin.go → pkg/services/ngalert/api/api_configuration.go
View File

@@ -15,13 +15,13 @@ import (
v1 "github.com/prometheus/client_golang/api/prometheus/v1" v1 "github.com/prometheus/client_golang/api/prometheus/v1"
) )
type AdminSrv struct { type ConfigSrv struct {
alertmanagerProvider ExternalAlertmanagerProvider alertmanagerProvider ExternalAlertmanagerProvider
store store.AdminConfigurationStore store store.AdminConfigurationStore
log log.Logger log log.Logger
} }
func (srv AdminSrv) RouteGetAlertmanagers(c *models.ReqContext) response.Response { func (srv ConfigSrv) RouteGetAlertmanagers(c *models.ReqContext) response.Response {
urls := srv.alertmanagerProvider.AlertmanagersFor(c.OrgId) urls := srv.alertmanagerProvider.AlertmanagersFor(c.OrgId)
droppedURLs := srv.alertmanagerProvider.DroppedAlertmanagersFor(c.OrgId) droppedURLs := srv.alertmanagerProvider.DroppedAlertmanagersFor(c.OrgId)
ams := v1.AlertManagersResult{Active: make([]v1.AlertManager, len(urls)), Dropped: make([]v1.AlertManager, len(droppedURLs))} ams := v1.AlertManagersResult{Active: make([]v1.AlertManager, len(urls)), Dropped: make([]v1.AlertManager, len(droppedURLs))}
@@ -38,7 +38,7 @@ func (srv AdminSrv) RouteGetAlertmanagers(c *models.ReqContext) response.Respons
}) })
} }
func (srv AdminSrv) RouteGetNGalertConfig(c *models.ReqContext) response.Response { func (srv ConfigSrv) RouteGetNGalertConfig(c *models.ReqContext) response.Response {
if c.OrgRole != models.ROLE_ADMIN { if c.OrgRole != models.ROLE_ADMIN {
return accessForbiddenResp() return accessForbiddenResp()
} }
@@ -61,7 +61,7 @@ func (srv AdminSrv) RouteGetNGalertConfig(c *models.ReqContext) response.Respons
return response.JSON(http.StatusOK, resp) return response.JSON(http.StatusOK, resp)
} }
func (srv AdminSrv) RoutePostNGalertConfig(c *models.ReqContext, body apimodels.PostableNGalertConfig) response.Response { func (srv ConfigSrv) RoutePostNGalertConfig(c *models.ReqContext, body apimodels.PostableNGalertConfig) response.Response {
if c.OrgRole != models.ROLE_ADMIN { if c.OrgRole != models.ROLE_ADMIN {
return accessForbiddenResp() return accessForbiddenResp()
} }
@@ -97,7 +97,7 @@ func (srv AdminSrv) RoutePostNGalertConfig(c *models.ReqContext, body apimodels.
return response.JSON(http.StatusCreated, util.DynMap{"message": "admin configuration updated"}) return response.JSON(http.StatusCreated, util.DynMap{"message": "admin configuration updated"})
} }
func (srv AdminSrv) RouteDeleteNGalertConfig(c *models.ReqContext) response.Response { func (srv ConfigSrv) RouteDeleteNGalertConfig(c *models.ReqContext) response.Response {
if c.OrgRole != models.ROLE_ADMIN { if c.OrgRole != models.ROLE_ADMIN {
return accessForbiddenResp() return accessForbiddenResp()
} }

34
pkg/services/ngalert/api/configuration.go Normal file
View File

@@ -0,0 +1,34 @@
package api
import (
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/models"
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
)
// ConfigurationApiHandler always forwards requests to grafana backend
type ConfigurationApiHandler struct {
grafana *ConfigSrv
}
func NewConfiguration(grafana *ConfigSrv) *ConfigurationApiHandler {
return &ConfigurationApiHandler{
grafana: grafana,
}
}
func (f *ConfigurationApiHandler) handleRouteGetAlertmanagers(c *models.ReqContext) response.Response {
return f.grafana.RouteGetAlertmanagers(c)
}
func (f *ConfigurationApiHandler) handleRouteGetNGalertConfig(c *models.ReqContext) response.Response {
return f.grafana.RouteGetNGalertConfig(c)
}
func (f *ConfigurationApiHandler) handleRoutePostNGalertConfig(c *models.ReqContext, body apimodels.PostableNGalertConfig) response.Response {
return f.grafana.RoutePostNGalertConfig(c, body)
}
func (f *ConfigurationApiHandler) handleRouteDeleteNGalertConfig(c *models.ReqContext) response.Response {
return f.grafana.RouteDeleteNGalertConfig(c)
}

35
pkg/services/ngalert/api/forked_admin.go
View File

@@ -1,35 +0,0 @@
package api
import (
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/models"
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
)
// ForkedConfigurationApi always forwards requests to grafana backend
type ForkedConfigurationApi struct {
grafana *AdminSrv
}
// NewForkedConfiguration creates a new ForkedConfigurationApi instance
func NewForkedConfiguration(grafana *AdminSrv) *ForkedConfigurationApi {
return &ForkedConfigurationApi{
grafana: grafana,
}
}
func (f *ForkedConfigurationApi) forkRouteGetAlertmanagers(c *models.ReqContext) response.Response {
return f.grafana.RouteGetAlertmanagers(c)
}
func (f *ForkedConfigurationApi) forkRouteGetNGalertConfig(c *models.ReqContext) response.Response {
return f.grafana.RouteGetNGalertConfig(c)
}
func (f *ForkedConfigurationApi) forkRoutePostNGalertConfig(c *models.ReqContext, body apimodels.PostableNGalertConfig) response.Response {
return f.grafana.RoutePostNGalertConfig(c, body)
}
func (f *ForkedConfigurationApi) forkRouteDeleteNGalertConfig(c *models.ReqContext) response.Response {
return f.grafana.RouteDeleteNGalertConfig(c)
}

108
pkg/services/ngalert/api/forked_provisioning.go
View File

@@ -1,108 +0,0 @@
package api
import (
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/models"
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
)
// ForkedProvisioningApi always forwards requests to a Grafana backend.
// We do not currently support provisioning of external systems through Grafana's API.
type ForkedProvisioningApi struct {
svc *ProvisioningSrv
}
// NewForkedProvisioningApi creates a new ForkedProvisioningApi instance.
func NewForkedProvisioningApi(svc *ProvisioningSrv) *ForkedProvisioningApi {
return &ForkedProvisioningApi{
svc: svc,
}
}
func (f *ForkedProvisioningApi) forkRouteGetPolicyTree(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetPolicyTree(ctx)
}
func (f *ForkedProvisioningApi) forkRoutePutPolicyTree(ctx *models.ReqContext, route apimodels.Route) response.Response {
return f.svc.RoutePutPolicyTree(ctx, route)
}
func (f *ForkedProvisioningApi) forkRouteResetPolicyTree(ctx *models.ReqContext) response.Response {
return f.svc.RouteResetPolicyTree(ctx)
}
func (f *ForkedProvisioningApi) forkRouteGetContactpoints(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetContactPoints(ctx)
}
func (f *ForkedProvisioningApi) forkRoutePostContactpoints(ctx *models.ReqContext, cp apimodels.EmbeddedContactPoint) response.Response {
return f.svc.RoutePostContactPoint(ctx, cp)
}
func (f *ForkedProvisioningApi) forkRoutePutContactpoint(ctx *models.ReqContext, cp apimodels.EmbeddedContactPoint, UID string) response.Response {
return f.svc.RoutePutContactPoint(ctx, cp, UID)
}
func (f *ForkedProvisioningApi) forkRouteDeleteContactpoints(ctx *models.ReqContext, UID string) response.Response {
return f.svc.RouteDeleteContactPoint(ctx, UID)
}
func (f *ForkedProvisioningApi) forkRouteGetTemplates(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetTemplates(ctx)
}
func (f *ForkedProvisioningApi) forkRouteGetTemplate(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteGetTemplate(ctx, name)
}
func (f *ForkedProvisioningApi) forkRoutePutTemplate(ctx *models.ReqContext, body apimodels.MessageTemplateContent, name string) response.Response {
return f.svc.RoutePutTemplate(ctx, body, name)
}
func (f *ForkedProvisioningApi) forkRouteDeleteTemplate(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteDeleteTemplate(ctx, name)
}
func (f *ForkedProvisioningApi) forkRouteGetMuteTiming(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteGetMuteTiming(ctx, name)
}
func (f *ForkedProvisioningApi) forkRouteGetMuteTimings(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetMuteTimings(ctx)
}
func (f *ForkedProvisioningApi) forkRoutePostMuteTiming(ctx *models.ReqContext, mt apimodels.MuteTimeInterval) response.Response {
return f.svc.RoutePostMuteTiming(ctx, mt)
}
func (f *ForkedProvisioningApi) forkRoutePutMuteTiming(ctx *models.ReqContext, mt apimodels.MuteTimeInterval, name string) response.Response {
return f.svc.RoutePutMuteTiming(ctx, mt, name)
}
func (f *ForkedProvisioningApi) forkRouteDeleteMuteTiming(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteDeleteMuteTiming(ctx, name)
}
func (f *ForkedProvisioningApi) forkRouteGetAlertRule(ctx *models.ReqContext, UID string) response.Response {
return f.svc.RouteRouteGetAlertRule(ctx, UID)
}
func (f *ForkedProvisioningApi) forkRoutePostAlertRule(ctx *models.ReqContext, ar apimodels.ProvisionedAlertRule) response.Response {
return f.svc.RoutePostAlertRule(ctx, ar)
}
func (f *ForkedProvisioningApi) forkRoutePutAlertRule(ctx *models.ReqContext, ar apimodels.ProvisionedAlertRule, UID string) response.Response {
return f.svc.RoutePutAlertRule(ctx, ar, UID)
}
func (f *ForkedProvisioningApi) forkRouteDeleteAlertRule(ctx *models.ReqContext, UID string) response.Response {
return f.svc.RouteDeleteAlertRule(ctx, UID)
}
func (f *ForkedProvisioningApi) forkRouteGetAlertRuleGroup(ctx *models.ReqContext, folder, group string) response.Response {
return f.svc.RouteGetAlertRuleGroup(ctx, folder, group)
}
func (f *ForkedProvisioningApi) forkRoutePutAlertRuleGroup(ctx *models.ReqContext, ag apimodels.AlertRuleGroupMetadata, folder, group string) response.Response {
return f.svc.RoutePutAlertRuleGroup(ctx, ag, folder, group)
}

31
pkg/services/ngalert/api/forked_testing.go
View File

@@ -1,31 +0,0 @@
package api
import (
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/models"
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
)
// ForkedTestingApi always forwards requests to grafana backend
type ForkedTestingApi struct {
svc *TestingApiSrv
}
// NewForkedTestingApi creates a new ForkedTestingApi instance
func NewForkedTestingApi(svc *TestingApiSrv) *ForkedTestingApi {
return &ForkedTestingApi{
svc: svc,
}
}
func (f *ForkedTestingApi) forkRouteTestRuleConfig(c *models.ReqContext, body apimodels.TestRulePayload, dsUID string) response.Response {
return f.svc.RouteTestRuleConfig(c, body, dsUID)
}
func (f *ForkedTestingApi) forkRouteTestRuleGrafanaConfig(c *models.ReqContext, body apimodels.TestRulePayload) response.Response {
return f.svc.RouteTestGrafanaRuleConfig(c, body)
}
func (f *ForkedTestingApi) forkRouteEvalQueries(c *models.ReqContext, body apimodels.EvalQueriesPayload) response.Response {
return f.svc.RouteEvalQueries(c, body)
}

58
pkg/services/ngalert/api/forked_am.go → pkg/services/ngalert/api/forking_alertmanager.go
View File

@@ -9,22 +9,22 @@ import (
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
) )
type ForkedAlertmanagerApi struct { type AlertmanagerApiHandler struct {
AMSvc *LotexAM AMSvc *LotexAM
GrafanaSvc *AlertmanagerSrv GrafanaSvc *AlertmanagerSrv
DatasourceCache datasources.CacheService DatasourceCache datasources.CacheService
} }
// NewForkedAM implements a set of routes that proxy to various Alertmanager-compatible backends. // NewForkingAM implements a set of routes that proxy to various Alertmanager-compatible backends.
func NewForkedAM(datasourceCache datasources.CacheService, proxy *LotexAM, grafana *AlertmanagerSrv) *ForkedAlertmanagerApi { func NewForkingAM(datasourceCache datasources.CacheService, proxy *LotexAM, grafana *AlertmanagerSrv) *AlertmanagerApiHandler {
return &ForkedAlertmanagerApi{ return &AlertmanagerApiHandler{
AMSvc: proxy, AMSvc: proxy,
GrafanaSvc: grafana, GrafanaSvc: grafana,
DatasourceCache: datasourceCache, DatasourceCache: datasourceCache,
} }
} }
func (f *ForkedAlertmanagerApi) getService(ctx *models.ReqContext) (*LotexAM, error) { func (f *AlertmanagerApiHandler) getService(ctx *models.ReqContext) (*LotexAM, error) {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return nil, err return nil, err
@@ -38,7 +38,7 @@ func (f *ForkedAlertmanagerApi) getService(ctx *models.ReqContext) (*LotexAM, er
} }
} }
func (f *ForkedAlertmanagerApi) forkRouteGetAMStatus(ctx *models.ReqContext, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetAMStatus(ctx *models.ReqContext, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return response.Error(400, err.Error(), nil) return response.Error(400, err.Error(), nil)
@@ -47,7 +47,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAMStatus(ctx *models.ReqContext, dsU
return s.RouteGetAMStatus(ctx) return s.RouteGetAMStatus(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteCreateSilence(ctx *models.ReqContext, body apimodels.PostableSilence, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteCreateSilence(ctx *models.ReqContext, body apimodels.PostableSilence, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -56,7 +56,7 @@ func (f *ForkedAlertmanagerApi) forkRouteCreateSilence(ctx *models.ReqContext, b
return s.RouteCreateSilence(ctx, body) return s.RouteCreateSilence(ctx, body)
} }
func (f *ForkedAlertmanagerApi) forkRouteDeleteAlertingConfig(ctx *models.ReqContext, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteDeleteAlertingConfig(ctx *models.ReqContext, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -65,7 +65,7 @@ func (f *ForkedAlertmanagerApi) forkRouteDeleteAlertingConfig(ctx *models.ReqCon
return s.RouteDeleteAlertingConfig(ctx) return s.RouteDeleteAlertingConfig(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteDeleteSilence(ctx *models.ReqContext, silenceID string, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteDeleteSilence(ctx *models.ReqContext, silenceID string, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -74,7 +74,7 @@ func (f *ForkedAlertmanagerApi) forkRouteDeleteSilence(ctx *models.ReqContext, s
return s.RouteDeleteSilence(ctx, silenceID) return s.RouteDeleteSilence(ctx, silenceID)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetAlertingConfig(ctx *models.ReqContext, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetAlertingConfig(ctx *models.ReqContext, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -83,7 +83,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAlertingConfig(ctx *models.ReqContex
return s.RouteGetAlertingConfig(ctx) return s.RouteGetAlertingConfig(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetAMAlertGroups(ctx *models.ReqContext, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetAMAlertGroups(ctx *models.ReqContext, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -92,7 +92,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAMAlertGroups(ctx *models.ReqContext
return s.RouteGetAMAlertGroups(ctx) return s.RouteGetAMAlertGroups(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetAMAlerts(ctx *models.ReqContext, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetAMAlerts(ctx *models.ReqContext, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -101,7 +101,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAMAlerts(ctx *models.ReqContext, dsU
return s.RouteGetAMAlerts(ctx) return s.RouteGetAMAlerts(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetSilence(ctx *models.ReqContext, silenceID string, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetSilence(ctx *models.ReqContext, silenceID string, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -110,7 +110,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetSilence(ctx *models.ReqContext, sile
return s.RouteGetSilence(ctx, silenceID) return s.RouteGetSilence(ctx, silenceID)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetSilences(ctx *models.ReqContext, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetSilences(ctx *models.ReqContext, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -119,7 +119,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetSilences(ctx *models.ReqContext, dsU
return s.RouteGetSilences(ctx) return s.RouteGetSilences(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRoutePostAlertingConfig(ctx *models.ReqContext, body apimodels.PostableUserConfig, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRoutePostAlertingConfig(ctx *models.ReqContext, body apimodels.PostableUserConfig, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -137,7 +137,7 @@ func (f *ForkedAlertmanagerApi) forkRoutePostAlertingConfig(ctx *models.ReqConte
return s.RoutePostAlertingConfig(ctx, body) return s.RoutePostAlertingConfig(ctx, body)
} }
func (f *ForkedAlertmanagerApi) forkRoutePostAMAlerts(ctx *models.ReqContext, body apimodels.PostableAlerts, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRoutePostAMAlerts(ctx *models.ReqContext, body apimodels.PostableAlerts, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -146,7 +146,7 @@ func (f *ForkedAlertmanagerApi) forkRoutePostAMAlerts(ctx *models.ReqContext, bo
return s.RoutePostAMAlerts(ctx, body) return s.RoutePostAMAlerts(ctx, body)
} }
func (f *ForkedAlertmanagerApi) forkRoutePostTestReceivers(ctx *models.ReqContext, body apimodels.TestReceiversConfigBodyParams, dsUID string) response.Response { func (f *AlertmanagerApiHandler) handleRoutePostTestReceivers(ctx *models.ReqContext, body apimodels.TestReceiversConfigBodyParams, dsUID string) response.Response {
s, err := f.getService(ctx) s, err := f.getService(ctx)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -155,50 +155,50 @@ func (f *ForkedAlertmanagerApi) forkRoutePostTestReceivers(ctx *models.ReqContex
return s.RoutePostTestReceivers(ctx, body) return s.RoutePostTestReceivers(ctx, body)
} }
func (f *ForkedAlertmanagerApi) forkRouteDeleteGrafanaSilence(ctx *models.ReqContext, id string) response.Response { func (f *AlertmanagerApiHandler) handleRouteDeleteGrafanaSilence(ctx *models.ReqContext, id string) response.Response {
return f.GrafanaSvc.RouteDeleteSilence(ctx, id) return f.GrafanaSvc.RouteDeleteSilence(ctx, id)
} }
func (f *ForkedAlertmanagerApi) forkRouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) handleRouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteDeleteAlertingConfig(ctx) return f.GrafanaSvc.RouteDeleteAlertingConfig(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteCreateGrafanaSilence(ctx *models.ReqContext, body apimodels.PostableSilence) response.Response { func (f *AlertmanagerApiHandler) handleRouteCreateGrafanaSilence(ctx *models.ReqContext, body apimodels.PostableSilence) response.Response {
return f.GrafanaSvc.RouteCreateSilence(ctx, body) return f.GrafanaSvc.RouteCreateSilence(ctx, body)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetAMStatus(ctx) return f.GrafanaSvc.RouteGetAMStatus(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaAMAlerts(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetGrafanaAMAlerts(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetAMAlerts(ctx) return f.GrafanaSvc.RouteGetAMAlerts(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetAMAlertGroups(ctx) return f.GrafanaSvc.RouteGetAMAlertGroups(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetGrafanaAlertingConfig(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetAlertingConfig(ctx) return f.GrafanaSvc.RouteGetAlertingConfig(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaSilence(ctx *models.ReqContext, id string) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetGrafanaSilence(ctx *models.ReqContext, id string) response.Response {
return f.GrafanaSvc.RouteGetSilence(ctx, id) return f.GrafanaSvc.RouteGetSilence(ctx, id)
} }
func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaSilences(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) handleRouteGetGrafanaSilences(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetSilences(ctx) return f.GrafanaSvc.RouteGetSilences(ctx)
} }
func (f *ForkedAlertmanagerApi) forkRoutePostGrafanaAMAlerts(ctx *models.ReqContext, conf apimodels.PostableAlerts) response.Response { func (f *AlertmanagerApiHandler) handleRoutePostGrafanaAMAlerts(ctx *models.ReqContext, conf apimodels.PostableAlerts) response.Response {
return f.GrafanaSvc.RoutePostAMAlerts(ctx, conf) return f.GrafanaSvc.RoutePostAMAlerts(ctx, conf)
} }
func (f *ForkedAlertmanagerApi) forkRoutePostGrafanaAlertingConfig(ctx *models.ReqContext, conf apimodels.PostableUserConfig) response.Response { func (f *AlertmanagerApiHandler) handleRoutePostGrafanaAlertingConfig(ctx *models.ReqContext, conf apimodels.PostableUserConfig) response.Response {
return f.GrafanaSvc.RoutePostAlertingConfig(ctx, conf) return f.GrafanaSvc.RoutePostAlertingConfig(ctx, conf)
} }
func (f *ForkedAlertmanagerApi) forkRoutePostTestGrafanaReceivers(ctx *models.ReqContext, conf apimodels.TestReceiversConfigBodyParams) response.Response { func (f *AlertmanagerApiHandler) handleRoutePostTestGrafanaReceivers(ctx *models.ReqContext, conf apimodels.TestReceiversConfigBodyParams) response.Response {
return f.GrafanaSvc.RoutePostTestReceivers(ctx, conf) return f.GrafanaSvc.RoutePostTestReceivers(ctx, conf)
} }

16
pkg/services/ngalert/api/forked_prom.go → pkg/services/ngalert/api/forking_prometheus.go
View File

@@ -9,22 +9,22 @@ import (
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
) )
type ForkedPrometheusApi struct { type PrometheusApiHandler struct {
ProxySvc *LotexProm ProxySvc *LotexProm
GrafanaSvc *PrometheusSrv GrafanaSvc *PrometheusSrv
DatasourceCache datasources.CacheService DatasourceCache datasources.CacheService
} }
// NewForkedProm implements a set of routes that proxy to various Prometheus-compatible backends. // NewForkingProm implements a set of routes that proxy to various Prometheus-compatible backends.
func NewForkedProm(datasourceCache datasources.CacheService, proxy *LotexProm, grafana *PrometheusSrv) *ForkedPrometheusApi { func NewForkingProm(datasourceCache datasources.CacheService, proxy *LotexProm, grafana *PrometheusSrv) *PrometheusApiHandler {
return &ForkedPrometheusApi{ return &PrometheusApiHandler{
ProxySvc: proxy, ProxySvc: proxy,
GrafanaSvc: grafana, GrafanaSvc: grafana,
DatasourceCache: datasourceCache, DatasourceCache: datasourceCache,
} }
} }
func (f *ForkedPrometheusApi) forkRouteGetAlertStatuses(ctx *models.ReqContext, dsUID string) response.Response { func (f *PrometheusApiHandler) handleRouteGetAlertStatuses(ctx *models.ReqContext, dsUID string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -38,7 +38,7 @@ func (f *ForkedPrometheusApi) forkRouteGetAlertStatuses(ctx *models.ReqContext,
} }
} }
func (f *ForkedPrometheusApi) forkRouteGetRuleStatuses(ctx *models.ReqContext, dsUID string) response.Response { func (f *PrometheusApiHandler) handleRouteGetRuleStatuses(ctx *models.ReqContext, dsUID string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -52,10 +52,10 @@ func (f *ForkedPrometheusApi) forkRouteGetRuleStatuses(ctx *models.ReqContext, d
} }
} }
func (f *ForkedPrometheusApi) forkRouteGetGrafanaAlertStatuses(ctx *models.ReqContext) response.Response { func (f *PrometheusApiHandler) handleRouteGetGrafanaAlertStatuses(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetAlertStatuses(ctx) return f.GrafanaSvc.RouteGetAlertStatuses(ctx)
} }
func (f *ForkedPrometheusApi) forkRouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response { func (f *PrometheusApiHandler) handleRouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response {
return f.GrafanaSvc.RouteGetRuleStatuses(ctx) return f.GrafanaSvc.RouteGetRuleStatuses(ctx)
} }

33
pkg/services/ngalert/api/fork_ruler.go → pkg/services/ngalert/api/forking_ruler.go
View File

@@ -9,23 +9,22 @@ import (
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
) )
// ForkedRulerApi will validate and proxy requests to the correct backend type depending on the datasource. // RulerApiHandler will validate and proxy requests to the correct backend type depending on the datasource.
type ForkedRulerApi struct { type RulerApiHandler struct {
LotexRuler *LotexRuler LotexRuler *LotexRuler
GrafanaRuler *RulerSrv GrafanaRuler *RulerSrv
DatasourceCache datasources.CacheService DatasourceCache datasources.CacheService
} }
// NewForkedRuler implements a set of routes that proxy to various Cortex Ruler-compatible backends. func NewForkingRuler(datasourceCache datasources.CacheService, lotex *LotexRuler, grafana *RulerSrv) *RulerApiHandler {
func NewForkedRuler(datasourceCache datasources.CacheService, lotex *LotexRuler, grafana *RulerSrv) *ForkedRulerApi { return &RulerApiHandler{
return &ForkedRulerApi{
LotexRuler: lotex, LotexRuler: lotex,
GrafanaRuler: grafana, GrafanaRuler: grafana,
DatasourceCache: datasourceCache, DatasourceCache: datasourceCache,
} }
} }
func (f *ForkedRulerApi) forkRouteDeleteNamespaceRulesConfig(ctx *models.ReqContext, dsUID, namespace string) response.Response { func (f *RulerApiHandler) handleRouteDeleteNamespaceRulesConfig(ctx *models.ReqContext, dsUID, namespace string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -38,7 +37,7 @@ func (f *ForkedRulerApi) forkRouteDeleteNamespaceRulesConfig(ctx *models.ReqCont
} }
} }
func (f *ForkedRulerApi) forkRouteDeleteRuleGroupConfig(ctx *models.ReqContext, dsUID, namespace, group string) response.Response { func (f *RulerApiHandler) handleRouteDeleteRuleGroupConfig(ctx *models.ReqContext, dsUID, namespace, group string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -51,7 +50,7 @@ func (f *ForkedRulerApi) forkRouteDeleteRuleGroupConfig(ctx *models.ReqContext,
} }
} }
func (f *ForkedRulerApi) forkRouteGetNamespaceRulesConfig(ctx *models.ReqContext, dsUID, namespace string) response.Response { func (f *RulerApiHandler) handleRouteGetNamespaceRulesConfig(ctx *models.ReqContext, dsUID, namespace string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -64,7 +63,7 @@ func (f *ForkedRulerApi) forkRouteGetNamespaceRulesConfig(ctx *models.ReqContext
} }
} }
func (f *ForkedRulerApi) forkRouteGetRulegGroupConfig(ctx *models.ReqContext, dsUID, namespace, group string) response.Response { func (f *RulerApiHandler) handleRouteGetRulegGroupConfig(ctx *models.ReqContext, dsUID, namespace, group string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -77,7 +76,7 @@ func (f *ForkedRulerApi) forkRouteGetRulegGroupConfig(ctx *models.ReqContext, ds
} }
} }
func (f *ForkedRulerApi) forkRouteGetRulesConfig(ctx *models.ReqContext, dsUID string) response.Response { func (f *RulerApiHandler) handleRouteGetRulesConfig(ctx *models.ReqContext, dsUID string) response.Response {
t, err := backendTypeByUID(ctx, f.DatasourceCache) t, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -90,7 +89,7 @@ func (f *ForkedRulerApi) forkRouteGetRulesConfig(ctx *models.ReqContext, dsUID s
} }
} }
func (f *ForkedRulerApi) forkRoutePostNameRulesConfig(ctx *models.ReqContext, conf apimodels.PostableRuleGroupConfig, dsUID, namespace string) response.Response { func (f *RulerApiHandler) handleRoutePostNameRulesConfig(ctx *models.ReqContext, conf apimodels.PostableRuleGroupConfig, dsUID, namespace string) response.Response {
backendType, err := backendTypeByUID(ctx, f.DatasourceCache) backendType, err := backendTypeByUID(ctx, f.DatasourceCache)
if err != nil { if err != nil {
return ErrResp(400, err, "") return ErrResp(400, err, "")
@@ -109,27 +108,27 @@ func (f *ForkedRulerApi) forkRoutePostNameRulesConfig(ctx *models.ReqContext, co
} }
} }
func (f *ForkedRulerApi) forkRouteDeleteNamespaceGrafanaRulesConfig(ctx *models.ReqContext, namespace string) response.Response { func (f *RulerApiHandler) handleRouteDeleteNamespaceGrafanaRulesConfig(ctx *models.ReqContext, namespace string) response.Response {
return f.GrafanaRuler.RouteDeleteAlertRules(ctx, namespace, "") return f.GrafanaRuler.RouteDeleteAlertRules(ctx, namespace, "")
} }
func (f *ForkedRulerApi) forkRouteDeleteGrafanaRuleGroupConfig(ctx *models.ReqContext, namespace, groupName string) response.Response { func (f *RulerApiHandler) handleRouteDeleteGrafanaRuleGroupConfig(ctx *models.ReqContext, namespace, groupName string) response.Response {
return f.GrafanaRuler.RouteDeleteAlertRules(ctx, namespace, groupName) return f.GrafanaRuler.RouteDeleteAlertRules(ctx, namespace, groupName)
} }
func (f *ForkedRulerApi) forkRouteGetNamespaceGrafanaRulesConfig(ctx *models.ReqContext, namespace string) response.Response { func (f *RulerApiHandler) handleRouteGetNamespaceGrafanaRulesConfig(ctx *models.ReqContext, namespace string) response.Response {
return f.GrafanaRuler.RouteGetNamespaceRulesConfig(ctx, namespace) return f.GrafanaRuler.RouteGetNamespaceRulesConfig(ctx, namespace)
} }
func (f *ForkedRulerApi) forkRouteGetGrafanaRuleGroupConfig(ctx *models.ReqContext, namespace, group string) response.Response { func (f *RulerApiHandler) handleRouteGetGrafanaRuleGroupConfig(ctx *models.ReqContext, namespace, group string) response.Response {
return f.GrafanaRuler.RouteGetRulesGroupConfig(ctx, namespace, group) return f.GrafanaRuler.RouteGetRulesGroupConfig(ctx, namespace, group)
} }
func (f *ForkedRulerApi) forkRouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) handleRouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response {
return f.GrafanaRuler.RouteGetRulesConfig(ctx) return f.GrafanaRuler.RouteGetRulesConfig(ctx)
} }
func (f *ForkedRulerApi) forkRoutePostNameGrafanaRulesConfig(ctx *models.ReqContext, conf apimodels.PostableRuleGroupConfig, namespace string) response.Response { func (f *RulerApiHandler) handleRoutePostNameGrafanaRulesConfig(ctx *models.ReqContext, conf apimodels.PostableRuleGroupConfig, namespace string) response.Response {
payloadType := conf.Type() payloadType := conf.Type()
if payloadType != apimodels.GrafanaBackend { if payloadType != apimodels.GrafanaBackend {
return ErrResp(400, fmt.Errorf("unexpected backend type (%v) vs payload type (%v)", apimodels.GrafanaBackend, payloadType), "") return ErrResp(400, fmt.Errorf("unexpected backend type (%v) vs payload type (%v)", apimodels.GrafanaBackend, payloadType), "")

122
pkg/services/ngalert/api/generated_base_api_alertmanager.go
View File

@@ -18,7 +18,7 @@ import (
"github.com/grafana/grafana/pkg/web" "github.com/grafana/grafana/pkg/web"
) )
type AlertmanagerApiForkingService interface { type AlertmanagerApi interface {
RouteCreateGrafanaSilence(*models.ReqContext) response.Response RouteCreateGrafanaSilence(*models.ReqContext) response.Response
RouteCreateSilence(*models.ReqContext) response.Response RouteCreateSilence(*models.ReqContext) response.Response
RouteDeleteAlertingConfig(*models.ReqContext) response.Response RouteDeleteAlertingConfig(*models.ReqContext) response.Response
@@ -45,128 +45,150 @@ type AlertmanagerApiForkingService interface {
RoutePostTestReceivers(*models.ReqContext) response.Response RoutePostTestReceivers(*models.ReqContext) response.Response
} }
func (f *ForkedAlertmanagerApi) RouteCreateGrafanaSilence(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteCreateGrafanaSilence(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.PostableSilence{} conf := apimodels.PostableSilence{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRouteCreateGrafanaSilence(ctx, conf) return f.handleRouteCreateGrafanaSilence(ctx, conf)
} }
func (f *ForkedAlertmanagerApi) RouteCreateSilence(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteCreateSilence(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
// Parse Request Body
conf := apimodels.PostableSilence{} conf := apimodels.PostableSilence{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRouteCreateSilence(ctx, conf, datasourceUIDParam) return f.handleRouteCreateSilence(ctx, conf, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteDeleteAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteDeleteAlertingConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteDeleteAlertingConfig(ctx, datasourceUIDParam) return f.handleRouteDeleteAlertingConfig(ctx, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response {
return f.forkRouteDeleteGrafanaAlertingConfig(ctx) return f.handleRouteDeleteGrafanaAlertingConfig(ctx)
} }
func (f *ForkedAlertmanagerApi) RouteDeleteGrafanaSilence(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteDeleteGrafanaSilence(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
silenceIdParam := web.Params(ctx.Req)[":SilenceId"] silenceIdParam := web.Params(ctx.Req)[":SilenceId"]
return f.forkRouteDeleteGrafanaSilence(ctx, silenceIdParam) return f.handleRouteDeleteGrafanaSilence(ctx, silenceIdParam)
} }
func (f *ForkedAlertmanagerApi) RouteDeleteSilence(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteDeleteSilence(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
silenceIdParam := web.Params(ctx.Req)[":SilenceId"] silenceIdParam := web.Params(ctx.Req)[":SilenceId"]
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteDeleteSilence(ctx, silenceIdParam, datasourceUIDParam) return f.handleRouteDeleteSilence(ctx, silenceIdParam, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetAMAlertGroups(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetAMAlertGroups(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetAMAlertGroups(ctx, datasourceUIDParam) return f.handleRouteGetAMAlertGroups(ctx, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetAMAlerts(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetAMAlerts(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetAMAlerts(ctx, datasourceUIDParam) return f.handleRouteGetAMAlerts(ctx, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetAMStatus(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetAMStatus(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetAMStatus(ctx, datasourceUIDParam) return f.handleRouteGetAMStatus(ctx, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetAlertingConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetAlertingConfig(ctx, datasourceUIDParam) return f.handleRouteGetAlertingConfig(ctx, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaAMAlertGroups(ctx) return f.handleRouteGetGrafanaAMAlertGroups(ctx)
} }
func (f *ForkedAlertmanagerApi) RouteGetGrafanaAMAlerts(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetGrafanaAMAlerts(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaAMAlerts(ctx) return f.handleRouteGetGrafanaAMAlerts(ctx)
} }
func (f *ForkedAlertmanagerApi) RouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaAMStatus(ctx) return f.handleRouteGetGrafanaAMStatus(ctx)
} }
func (f *ForkedAlertmanagerApi) RouteGetGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetGrafanaAlertingConfig(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaAlertingConfig(ctx) return f.handleRouteGetGrafanaAlertingConfig(ctx)
} }
func (f *ForkedAlertmanagerApi) RouteGetGrafanaSilence(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetGrafanaSilence(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
silenceIdParam := web.Params(ctx.Req)[":SilenceId"] silenceIdParam := web.Params(ctx.Req)[":SilenceId"]
return f.forkRouteGetGrafanaSilence(ctx, silenceIdParam) return f.handleRouteGetGrafanaSilence(ctx, silenceIdParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetGrafanaSilences(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetGrafanaSilences(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaSilences(ctx) return f.handleRouteGetGrafanaSilences(ctx)
} }
func (f *ForkedAlertmanagerApi) RouteGetSilence(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetSilence(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
silenceIdParam := web.Params(ctx.Req)[":SilenceId"] silenceIdParam := web.Params(ctx.Req)[":SilenceId"]
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetSilence(ctx, silenceIdParam, datasourceUIDParam) return f.handleRouteGetSilence(ctx, silenceIdParam, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RouteGetSilences(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RouteGetSilences(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetSilences(ctx, datasourceUIDParam) return f.handleRouteGetSilences(ctx, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RoutePostAMAlerts(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RoutePostAMAlerts(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
// Parse Request Body
conf := apimodels.PostableAlerts{} conf := apimodels.PostableAlerts{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostAMAlerts(ctx, conf, datasourceUIDParam) return f.handleRoutePostAMAlerts(ctx, conf, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RoutePostAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RoutePostAlertingConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
// Parse Request Body
conf := apimodels.PostableUserConfig{} conf := apimodels.PostableUserConfig{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostAlertingConfig(ctx, conf, datasourceUIDParam) return f.handleRoutePostAlertingConfig(ctx, conf, datasourceUIDParam)
} }
func (f *ForkedAlertmanagerApi) RoutePostGrafanaAMAlerts(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RoutePostGrafanaAMAlerts(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.PostableAlerts{} conf := apimodels.PostableAlerts{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostGrafanaAMAlerts(ctx, conf) return f.handleRoutePostGrafanaAMAlerts(ctx, conf)
} }
func (f *ForkedAlertmanagerApi) RoutePostGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RoutePostGrafanaAlertingConfig(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.PostableUserConfig{} conf := apimodels.PostableUserConfig{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostGrafanaAlertingConfig(ctx, conf) return f.handleRoutePostGrafanaAlertingConfig(ctx, conf)
} }
func (f *ForkedAlertmanagerApi) RoutePostTestGrafanaReceivers(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RoutePostTestGrafanaReceivers(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.TestReceiversConfigBodyParams{} conf := apimodels.TestReceiversConfigBodyParams{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostTestGrafanaReceivers(ctx, conf) return f.handleRoutePostTestGrafanaReceivers(ctx, conf)
} }
func (f *ForkedAlertmanagerApi) RoutePostTestReceivers(ctx *models.ReqContext) response.Response { func (f *AlertmanagerApiHandler) RoutePostTestReceivers(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
// Parse Request Body
conf := apimodels.TestReceiversConfigBodyParams{} conf := apimodels.TestReceiversConfigBodyParams{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostTestReceivers(ctx, conf, datasourceUIDParam) return f.handleRoutePostTestReceivers(ctx, conf, datasourceUIDParam)
} }
func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApiForkingService, m *metrics.API) { func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApi, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister) { api.RouteRegister.Group("", func(group routing.RouteRegister) {
group.Post( group.Post(
toMacaronPath("/api/alertmanager/grafana/api/v2/silences"), toMacaronPath("/api/alertmanager/grafana/api/v2/silences"),

21
pkg/services/ngalert/api/generated_base_api_configuration.go
View File

@@ -18,31 +18,32 @@ import (
"github.com/grafana/grafana/pkg/web" "github.com/grafana/grafana/pkg/web"
) )
type ConfigurationApiForkingService interface { type ConfigurationApi interface {
RouteDeleteNGalertConfig(*models.ReqContext) response.Response RouteDeleteNGalertConfig(*models.ReqContext) response.Response
RouteGetAlertmanagers(*models.ReqContext) response.Response RouteGetAlertmanagers(*models.ReqContext) response.Response
RouteGetNGalertConfig(*models.ReqContext) response.Response RouteGetNGalertConfig(*models.ReqContext) response.Response
RoutePostNGalertConfig(*models.ReqContext) response.Response RoutePostNGalertConfig(*models.ReqContext) response.Response
} }
func (f *ForkedConfigurationApi) RouteDeleteNGalertConfig(ctx *models.ReqContext) response.Response { func (f *ConfigurationApiHandler) RouteDeleteNGalertConfig(ctx *models.ReqContext) response.Response {
return f.forkRouteDeleteNGalertConfig(ctx) return f.handleRouteDeleteNGalertConfig(ctx)
} }
func (f *ForkedConfigurationApi) RouteGetAlertmanagers(ctx *models.ReqContext) response.Response { func (f *ConfigurationApiHandler) RouteGetAlertmanagers(ctx *models.ReqContext) response.Response {
return f.forkRouteGetAlertmanagers(ctx) return f.handleRouteGetAlertmanagers(ctx)
} }
func (f *ForkedConfigurationApi) RouteGetNGalertConfig(ctx *models.ReqContext) response.Response { func (f *ConfigurationApiHandler) RouteGetNGalertConfig(ctx *models.ReqContext) response.Response {
return f.forkRouteGetNGalertConfig(ctx) return f.handleRouteGetNGalertConfig(ctx)
} }
func (f *ForkedConfigurationApi) RoutePostNGalertConfig(ctx *models.ReqContext) response.Response { func (f *ConfigurationApiHandler) RoutePostNGalertConfig(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.PostableNGalertConfig{} conf := apimodels.PostableNGalertConfig{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostNGalertConfig(ctx, conf) return f.handleRoutePostNGalertConfig(ctx, conf)
} }
func (api *API) RegisterConfigurationApiEndpoints(srv ConfigurationApiForkingService, m *metrics.API) { func (api *API) RegisterConfigurationApiEndpoints(srv ConfigurationApi, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister) { api.RouteRegister.Group("", func(group routing.RouteRegister) {
group.Delete( group.Delete(
toMacaronPath("/api/v1/ngalert/admin_config"), toMacaronPath("/api/v1/ngalert/admin_config"),

22
pkg/services/ngalert/api/generated_base_api_prometheus.go
View File

@@ -17,29 +17,31 @@ import (
"github.com/grafana/grafana/pkg/web" "github.com/grafana/grafana/pkg/web"
) )
type PrometheusApiForkingService interface { type PrometheusApi interface {
RouteGetAlertStatuses(*models.ReqContext) response.Response RouteGetAlertStatuses(*models.ReqContext) response.Response
RouteGetGrafanaAlertStatuses(*models.ReqContext) response.Response RouteGetGrafanaAlertStatuses(*models.ReqContext) response.Response
RouteGetGrafanaRuleStatuses(*models.ReqContext) response.Response RouteGetGrafanaRuleStatuses(*models.ReqContext) response.Response
RouteGetRuleStatuses(*models.ReqContext) response.Response RouteGetRuleStatuses(*models.ReqContext) response.Response
} }
func (f *ForkedPrometheusApi) RouteGetAlertStatuses(ctx *models.ReqContext) response.Response { func (f *PrometheusApiHandler) RouteGetAlertStatuses(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetAlertStatuses(ctx, datasourceUIDParam) return f.handleRouteGetAlertStatuses(ctx, datasourceUIDParam)
} }
func (f *ForkedPrometheusApi) RouteGetGrafanaAlertStatuses(ctx *models.ReqContext) response.Response { func (f *PrometheusApiHandler) RouteGetGrafanaAlertStatuses(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaAlertStatuses(ctx) return f.handleRouteGetGrafanaAlertStatuses(ctx)
} }
func (f *ForkedPrometheusApi) RouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response { func (f *PrometheusApiHandler) RouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaRuleStatuses(ctx) return f.handleRouteGetGrafanaRuleStatuses(ctx)
} }
func (f *ForkedPrometheusApi) RouteGetRuleStatuses(ctx *models.ReqContext) response.Response { func (f *PrometheusApiHandler) RouteGetRuleStatuses(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetRuleStatuses(ctx, datasourceUIDParam) return f.handleRouteGetRuleStatuses(ctx, datasourceUIDParam)
} }
func (api *API) RegisterPrometheusApiEndpoints(srv PrometheusApiForkingService, m *metrics.API) { func (api *API) RegisterPrometheusApiEndpoints(srv PrometheusApi, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister) { api.RouteRegister.Group("", func(group routing.RouteRegister) {
group.Get( group.Get(
toMacaronPath("/api/prometheus/{DatasourceUID}/api/v1/alerts"), toMacaronPath("/api/prometheus/{DatasourceUID}/api/v1/alerts"),

114
pkg/services/ngalert/api/generated_base_api_provisioning.go
View File

@@ -18,7 +18,7 @@ import (
"github.com/grafana/grafana/pkg/web" "github.com/grafana/grafana/pkg/web"
) )
type ProvisioningApiForkingService interface { type ProvisioningApi interface {
RouteDeleteAlertRule(*models.ReqContext) response.Response RouteDeleteAlertRule(*models.ReqContext) response.Response
RouteDeleteContactpoints(*models.ReqContext) response.Response RouteDeleteContactpoints(*models.ReqContext) response.Response
RouteDeleteMuteTiming(*models.ReqContext) response.Response RouteDeleteMuteTiming(*models.ReqContext) response.Response
@@ -43,125 +43,147 @@ type ProvisioningApiForkingService interface {
RouteResetPolicyTree(*models.ReqContext) response.Response RouteResetPolicyTree(*models.ReqContext) response.Response
} }
func (f *ForkedProvisioningApi) RouteDeleteAlertRule(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteDeleteAlertRule(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
uIDParam := web.Params(ctx.Req)[":UID"] uIDParam := web.Params(ctx.Req)[":UID"]
return f.forkRouteDeleteAlertRule(ctx, uIDParam) return f.handleRouteDeleteAlertRule(ctx, uIDParam)
} }
func (f *ForkedProvisioningApi) RouteDeleteContactpoints(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteDeleteContactpoints(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
uIDParam := web.Params(ctx.Req)[":UID"] uIDParam := web.Params(ctx.Req)[":UID"]
return f.forkRouteDeleteContactpoints(ctx, uIDParam) return f.handleRouteDeleteContactpoints(ctx, uIDParam)
} }
func (f *ForkedProvisioningApi) RouteDeleteMuteTiming(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteDeleteMuteTiming(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
nameParam := web.Params(ctx.Req)[":name"] nameParam := web.Params(ctx.Req)[":name"]
return f.forkRouteDeleteMuteTiming(ctx, nameParam) return f.handleRouteDeleteMuteTiming(ctx, nameParam)
} }
func (f *ForkedProvisioningApi) RouteDeleteTemplate(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteDeleteTemplate(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
nameParam := web.Params(ctx.Req)[":name"] nameParam := web.Params(ctx.Req)[":name"]
return f.forkRouteDeleteTemplate(ctx, nameParam) return f.handleRouteDeleteTemplate(ctx, nameParam)
} }
func (f *ForkedProvisioningApi) RouteGetAlertRule(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetAlertRule(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
uIDParam := web.Params(ctx.Req)[":UID"] uIDParam := web.Params(ctx.Req)[":UID"]
return f.forkRouteGetAlertRule(ctx, uIDParam) return f.handleRouteGetAlertRule(ctx, uIDParam)
} }
func (f *ForkedProvisioningApi) RouteGetAlertRuleGroup(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetAlertRuleGroup(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
folderUIDParam := web.Params(ctx.Req)[":FolderUID"] folderUIDParam := web.Params(ctx.Req)[":FolderUID"]
groupParam := web.Params(ctx.Req)[":Group"] groupParam := web.Params(ctx.Req)[":Group"]
return f.forkRouteGetAlertRuleGroup(ctx, folderUIDParam, groupParam) return f.handleRouteGetAlertRuleGroup(ctx, folderUIDParam, groupParam)
} }
func (f *ForkedProvisioningApi) RouteGetContactpoints(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetContactpoints(ctx *models.ReqContext) response.Response {
return f.forkRouteGetContactpoints(ctx) return f.handleRouteGetContactpoints(ctx)
} }
func (f *ForkedProvisioningApi) RouteGetMuteTiming(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetMuteTiming(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
nameParam := web.Params(ctx.Req)[":name"] nameParam := web.Params(ctx.Req)[":name"]
return f.forkRouteGetMuteTiming(ctx, nameParam) return f.handleRouteGetMuteTiming(ctx, nameParam)
} }
func (f *ForkedProvisioningApi) RouteGetMuteTimings(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetMuteTimings(ctx *models.ReqContext) response.Response {
return f.forkRouteGetMuteTimings(ctx) return f.handleRouteGetMuteTimings(ctx)
} }
func (f *ForkedProvisioningApi) RouteGetPolicyTree(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetPolicyTree(ctx *models.ReqContext) response.Response {
return f.forkRouteGetPolicyTree(ctx) return f.handleRouteGetPolicyTree(ctx)
} }
func (f *ForkedProvisioningApi) RouteGetTemplate(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetTemplate(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
nameParam := web.Params(ctx.Req)[":name"] nameParam := web.Params(ctx.Req)[":name"]
return f.forkRouteGetTemplate(ctx, nameParam) return f.handleRouteGetTemplate(ctx, nameParam)
} }
func (f *ForkedProvisioningApi) RouteGetTemplates(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteGetTemplates(ctx *models.ReqContext) response.Response {
return f.forkRouteGetTemplates(ctx) return f.handleRouteGetTemplates(ctx)
} }
func (f *ForkedProvisioningApi) RoutePostAlertRule(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePostAlertRule(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.ProvisionedAlertRule{} conf := apimodels.ProvisionedAlertRule{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostAlertRule(ctx, conf) return f.handleRoutePostAlertRule(ctx, conf)
} }
func (f *ForkedProvisioningApi) RoutePostContactpoints(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePostContactpoints(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.EmbeddedContactPoint{} conf := apimodels.EmbeddedContactPoint{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostContactpoints(ctx, conf) return f.handleRoutePostContactpoints(ctx, conf)
} }
func (f *ForkedProvisioningApi) RoutePostMuteTiming(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePostMuteTiming(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.MuteTimeInterval{} conf := apimodels.MuteTimeInterval{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostMuteTiming(ctx, conf) return f.handleRoutePostMuteTiming(ctx, conf)
} }
func (f *ForkedProvisioningApi) RoutePutAlertRule(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePutAlertRule(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
uIDParam := web.Params(ctx.Req)[":UID"] uIDParam := web.Params(ctx.Req)[":UID"]
// Parse Request Body
conf := apimodels.ProvisionedAlertRule{} conf := apimodels.ProvisionedAlertRule{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePutAlertRule(ctx, conf, uIDParam) return f.handleRoutePutAlertRule(ctx, conf, uIDParam)
} }
func (f *ForkedProvisioningApi) RoutePutAlertRuleGroup(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePutAlertRuleGroup(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
folderUIDParam := web.Params(ctx.Req)[":FolderUID"] folderUIDParam := web.Params(ctx.Req)[":FolderUID"]
groupParam := web.Params(ctx.Req)[":Group"] groupParam := web.Params(ctx.Req)[":Group"]
// Parse Request Body
conf := apimodels.AlertRuleGroupMetadata{} conf := apimodels.AlertRuleGroupMetadata{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePutAlertRuleGroup(ctx, conf, folderUIDParam, groupParam) return f.handleRoutePutAlertRuleGroup(ctx, conf, folderUIDParam, groupParam)
} }
func (f *ForkedProvisioningApi) RoutePutContactpoint(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePutContactpoint(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
uIDParam := web.Params(ctx.Req)[":UID"] uIDParam := web.Params(ctx.Req)[":UID"]
// Parse Request Body
conf := apimodels.EmbeddedContactPoint{} conf := apimodels.EmbeddedContactPoint{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePutContactpoint(ctx, conf, uIDParam) return f.handleRoutePutContactpoint(ctx, conf, uIDParam)
} }
func (f *ForkedProvisioningApi) RoutePutMuteTiming(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePutMuteTiming(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
nameParam := web.Params(ctx.Req)[":name"] nameParam := web.Params(ctx.Req)[":name"]
// Parse Request Body
conf := apimodels.MuteTimeInterval{} conf := apimodels.MuteTimeInterval{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePutMuteTiming(ctx, conf, nameParam) return f.handleRoutePutMuteTiming(ctx, conf, nameParam)
} }
func (f *ForkedProvisioningApi) RoutePutPolicyTree(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePutPolicyTree(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.Route{} conf := apimodels.Route{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePutPolicyTree(ctx, conf) return f.handleRoutePutPolicyTree(ctx, conf)
} }
func (f *ForkedProvisioningApi) RoutePutTemplate(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RoutePutTemplate(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
nameParam := web.Params(ctx.Req)[":name"] nameParam := web.Params(ctx.Req)[":name"]
// Parse Request Body
conf := apimodels.MessageTemplateContent{} conf := apimodels.MessageTemplateContent{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePutTemplate(ctx, conf, nameParam) return f.handleRoutePutTemplate(ctx, conf, nameParam)
} }
func (f *ForkedProvisioningApi) RouteResetPolicyTree(ctx *models.ReqContext) response.Response { func (f *ProvisioningApiHandler) RouteResetPolicyTree(ctx *models.ReqContext) response.Response {
return f.forkRouteResetPolicyTree(ctx) return f.handleRouteResetPolicyTree(ctx)
} }
func (api *API) RegisterProvisioningApiEndpoints(srv ProvisioningApiForkingService, m *metrics.API) { func (api *API) RegisterProvisioningApiEndpoints(srv ProvisioningApi, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister) { api.RouteRegister.Group("", func(group routing.RouteRegister) {
group.Delete( group.Delete(
toMacaronPath("/api/v1/provisioning/alert-rules/{UID}"), toMacaronPath("/api/v1/provisioning/alert-rules/{UID}"),

65
pkg/services/ngalert/api/generated_base_api_ruler.go
View File

@@ -18,7 +18,7 @@ import (
"github.com/grafana/grafana/pkg/web" "github.com/grafana/grafana/pkg/web"
) )
type RulerApiForkingService interface { type RulerApi interface {
RouteDeleteGrafanaRuleGroupConfig(*models.ReqContext) response.Response RouteDeleteGrafanaRuleGroupConfig(*models.ReqContext) response.Response
RouteDeleteNamespaceGrafanaRulesConfig(*models.ReqContext) response.Response RouteDeleteNamespaceGrafanaRulesConfig(*models.ReqContext) response.Response
RouteDeleteNamespaceRulesConfig(*models.ReqContext) response.Response RouteDeleteNamespaceRulesConfig(*models.ReqContext) response.Response
@@ -33,72 +33,85 @@ type RulerApiForkingService interface {
RoutePostNameRulesConfig(*models.ReqContext) response.Response RoutePostNameRulesConfig(*models.ReqContext) response.Response
} }
func (f *ForkedRulerApi) RouteDeleteGrafanaRuleGroupConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteDeleteGrafanaRuleGroupConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
groupnameParam := web.Params(ctx.Req)[":Groupname"] groupnameParam := web.Params(ctx.Req)[":Groupname"]
return f.forkRouteDeleteGrafanaRuleGroupConfig(ctx, namespaceParam, groupnameParam) return f.handleRouteDeleteGrafanaRuleGroupConfig(ctx, namespaceParam, groupnameParam)
} }
func (f *ForkedRulerApi) RouteDeleteNamespaceGrafanaRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteDeleteNamespaceGrafanaRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
return f.forkRouteDeleteNamespaceGrafanaRulesConfig(ctx, namespaceParam) return f.handleRouteDeleteNamespaceGrafanaRulesConfig(ctx, namespaceParam)
} }
func (f *ForkedRulerApi) RouteDeleteNamespaceRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteDeleteNamespaceRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
return f.forkRouteDeleteNamespaceRulesConfig(ctx, datasourceUIDParam, namespaceParam) return f.handleRouteDeleteNamespaceRulesConfig(ctx, datasourceUIDParam, namespaceParam)
} }
func (f *ForkedRulerApi) RouteDeleteRuleGroupConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteDeleteRuleGroupConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
groupnameParam := web.Params(ctx.Req)[":Groupname"] groupnameParam := web.Params(ctx.Req)[":Groupname"]
return f.forkRouteDeleteRuleGroupConfig(ctx, datasourceUIDParam, namespaceParam, groupnameParam) return f.handleRouteDeleteRuleGroupConfig(ctx, datasourceUIDParam, namespaceParam, groupnameParam)
} }
func (f *ForkedRulerApi) RouteGetGrafanaRuleGroupConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteGetGrafanaRuleGroupConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
groupnameParam := web.Params(ctx.Req)[":Groupname"] groupnameParam := web.Params(ctx.Req)[":Groupname"]
return f.forkRouteGetGrafanaRuleGroupConfig(ctx, namespaceParam, groupnameParam) return f.handleRouteGetGrafanaRuleGroupConfig(ctx, namespaceParam, groupnameParam)
} }
func (f *ForkedRulerApi) RouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response {
return f.forkRouteGetGrafanaRulesConfig(ctx) return f.handleRouteGetGrafanaRulesConfig(ctx)
} }
func (f *ForkedRulerApi) RouteGetNamespaceGrafanaRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteGetNamespaceGrafanaRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
return f.forkRouteGetNamespaceGrafanaRulesConfig(ctx, namespaceParam) return f.handleRouteGetNamespaceGrafanaRulesConfig(ctx, namespaceParam)
} }
func (f *ForkedRulerApi) RouteGetNamespaceRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteGetNamespaceRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
return f.forkRouteGetNamespaceRulesConfig(ctx, datasourceUIDParam, namespaceParam) return f.handleRouteGetNamespaceRulesConfig(ctx, datasourceUIDParam, namespaceParam)
} }
func (f *ForkedRulerApi) RouteGetRulegGroupConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteGetRulegGroupConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
groupnameParam := web.Params(ctx.Req)[":Groupname"] groupnameParam := web.Params(ctx.Req)[":Groupname"]
return f.forkRouteGetRulegGroupConfig(ctx, datasourceUIDParam, namespaceParam, groupnameParam) return f.handleRouteGetRulegGroupConfig(ctx, datasourceUIDParam, namespaceParam, groupnameParam)
} }
func (f *ForkedRulerApi) RouteGetRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RouteGetRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
return f.forkRouteGetRulesConfig(ctx, datasourceUIDParam) return f.handleRouteGetRulesConfig(ctx, datasourceUIDParam)
} }
func (f *ForkedRulerApi) RoutePostNameGrafanaRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RoutePostNameGrafanaRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
// Parse Request Body
conf := apimodels.PostableRuleGroupConfig{} conf := apimodels.PostableRuleGroupConfig{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostNameGrafanaRulesConfig(ctx, conf, namespaceParam) return f.handleRoutePostNameGrafanaRulesConfig(ctx, conf, namespaceParam)
} }
func (f *ForkedRulerApi) RoutePostNameRulesConfig(ctx *models.ReqContext) response.Response { func (f *RulerApiHandler) RoutePostNameRulesConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
namespaceParam := web.Params(ctx.Req)[":Namespace"] namespaceParam := web.Params(ctx.Req)[":Namespace"]
// Parse Request Body
conf := apimodels.PostableRuleGroupConfig{} conf := apimodels.PostableRuleGroupConfig{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRoutePostNameRulesConfig(ctx, conf, datasourceUIDParam, namespaceParam) return f.handleRoutePostNameRulesConfig(ctx, conf, datasourceUIDParam, namespaceParam)
} }
func (api *API) RegisterRulerApiEndpoints(srv RulerApiForkingService, m *metrics.API) { func (api *API) RegisterRulerApiEndpoints(srv RulerApi, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister) { api.RouteRegister.Group("", func(group routing.RouteRegister) {
group.Delete( group.Delete(
toMacaronPath("/api/ruler/grafana/api/v1/rules/{Namespace}/{Groupname}"), toMacaronPath("/api/ruler/grafana/api/v1/rules/{Namespace}/{Groupname}"),

20
pkg/services/ngalert/api/generated_base_api_testing.go
View File

@@ -18,36 +18,40 @@ import (
"github.com/grafana/grafana/pkg/web" "github.com/grafana/grafana/pkg/web"
) )
type TestingApiForkingService interface { type TestingApi interface {
RouteEvalQueries(*models.ReqContext) response.Response RouteEvalQueries(*models.ReqContext) response.Response
RouteTestRuleConfig(*models.ReqContext) response.Response RouteTestRuleConfig(*models.ReqContext) response.Response
RouteTestRuleGrafanaConfig(*models.ReqContext) response.Response RouteTestRuleGrafanaConfig(*models.ReqContext) response.Response
} }
func (f *ForkedTestingApi) RouteEvalQueries(ctx *models.ReqContext) response.Response { func (f *TestingApiHandler) RouteEvalQueries(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.EvalQueriesPayload{} conf := apimodels.EvalQueriesPayload{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRouteEvalQueries(ctx, conf) return f.handleRouteEvalQueries(ctx, conf)
} }
func (f *ForkedTestingApi) RouteTestRuleConfig(ctx *models.ReqContext) response.Response { func (f *TestingApiHandler) RouteTestRuleConfig(ctx *models.ReqContext) response.Response {
// Parse Path Parameters
datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"] datasourceUIDParam := web.Params(ctx.Req)[":DatasourceUID"]
// Parse Request Body
conf := apimodels.TestRulePayload{} conf := apimodels.TestRulePayload{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRouteTestRuleConfig(ctx, conf, datasourceUIDParam) return f.handleRouteTestRuleConfig(ctx, conf, datasourceUIDParam)
} }
func (f *ForkedTestingApi) RouteTestRuleGrafanaConfig(ctx *models.ReqContext) response.Response { func (f *TestingApiHandler) RouteTestRuleGrafanaConfig(ctx *models.ReqContext) response.Response {
// Parse Request Body
conf := apimodels.TestRulePayload{} conf := apimodels.TestRulePayload{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
return f.forkRouteTestRuleGrafanaConfig(ctx, conf) return f.handleRouteTestRuleGrafanaConfig(ctx, conf)
} }
func (api *API) RegisterTestingApiEndpoints(srv TestingApiForkingService, m *metrics.API) { func (api *API) RegisterTestingApiEndpoints(srv TestingApi, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister) { api.RouteRegister.Group("", func(group routing.RouteRegister) {
group.Post( group.Post(
toMacaronPath("/api/v1/eval"), toMacaronPath("/api/v1/eval"),

105
pkg/services/ngalert/api/provisioning.go Normal file
View File

@@ -0,0 +1,105 @@
package api
import (
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/models"
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
)
type ProvisioningApiHandler struct {
svc *ProvisioningSrv
}
func NewProvisioningApi(svc *ProvisioningSrv) *ProvisioningApiHandler {
return &ProvisioningApiHandler{
svc: svc,
}
}
func (f *ProvisioningApiHandler) handleRouteGetPolicyTree(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetPolicyTree(ctx)
}
func (f *ProvisioningApiHandler) handleRoutePutPolicyTree(ctx *models.ReqContext, route apimodels.Route) response.Response {
return f.svc.RoutePutPolicyTree(ctx, route)
}
func (f *ProvisioningApiHandler) handleRouteGetContactpoints(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetContactPoints(ctx)
}
func (f *ProvisioningApiHandler) handleRoutePostContactpoints(ctx *models.ReqContext, cp apimodels.EmbeddedContactPoint) response.Response {
return f.svc.RoutePostContactPoint(ctx, cp)
}
func (f *ProvisioningApiHandler) handleRoutePutContactpoint(ctx *models.ReqContext, cp apimodels.EmbeddedContactPoint, UID string) response.Response {
return f.svc.RoutePutContactPoint(ctx, cp, UID)
}
func (f *ProvisioningApiHandler) handleRouteDeleteContactpoints(ctx *models.ReqContext, UID string) response.Response {
return f.svc.RouteDeleteContactPoint(ctx, UID)
}
func (f *ProvisioningApiHandler) handleRouteGetTemplates(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetTemplates(ctx)
}
func (f *ProvisioningApiHandler) handleRouteGetTemplate(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteGetTemplate(ctx, name)
}
func (f *ProvisioningApiHandler) handleRoutePutTemplate(ctx *models.ReqContext, body apimodels.MessageTemplateContent, name string) response.Response {
return f.svc.RoutePutTemplate(ctx, body, name)
}
func (f *ProvisioningApiHandler) handleRouteDeleteTemplate(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteDeleteTemplate(ctx, name)
}
func (f *ProvisioningApiHandler) handleRouteGetMuteTiming(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteGetMuteTiming(ctx, name)
}
func (f *ProvisioningApiHandler) handleRouteGetMuteTimings(ctx *models.ReqContext) response.Response {
return f.svc.RouteGetMuteTimings(ctx)
}
func (f *ProvisioningApiHandler) handleRoutePostMuteTiming(ctx *models.ReqContext, mt apimodels.MuteTimeInterval) response.Response {
return f.svc.RoutePostMuteTiming(ctx, mt)
}
func (f *ProvisioningApiHandler) handleRoutePutMuteTiming(ctx *models.ReqContext, mt apimodels.MuteTimeInterval, name string) response.Response {
return f.svc.RoutePutMuteTiming(ctx, mt, name)
}
func (f *ProvisioningApiHandler) handleRouteDeleteMuteTiming(ctx *models.ReqContext, name string) response.Response {
return f.svc.RouteDeleteMuteTiming(ctx, name)
}
func (f *ProvisioningApiHandler) handleRouteGetAlertRule(ctx *models.ReqContext, UID string) response.Response {
return f.svc.RouteRouteGetAlertRule(ctx, UID)
}
func (f *ProvisioningApiHandler) handleRoutePostAlertRule(ctx *models.ReqContext, ar apimodels.ProvisionedAlertRule) response.Response {
return f.svc.RoutePostAlertRule(ctx, ar)
}
func (f *ProvisioningApiHandler) handleRoutePutAlertRule(ctx *models.ReqContext, ar apimodels.ProvisionedAlertRule, UID string) response.Response {
return f.svc.RoutePutAlertRule(ctx, ar, UID)
}
func (f *ProvisioningApiHandler) handleRouteDeleteAlertRule(ctx *models.ReqContext, UID string) response.Response {
return f.svc.RouteDeleteAlertRule(ctx, UID)
}
func (f *ProvisioningApiHandler) handleRouteResetPolicyTree(ctx *models.ReqContext) response.Response {
return f.svc.RouteResetPolicyTree(ctx)
}
func (f *ProvisioningApiHandler) handleRouteGetAlertRuleGroup(ctx *models.ReqContext, folder, group string) response.Response {
return f.svc.RouteGetAlertRuleGroup(ctx, folder, group)
}
func (f *ProvisioningApiHandler) handleRoutePutAlertRuleGroup(ctx *models.ReqContext, ag apimodels.AlertRuleGroupMetadata, folder, group string) response.Response {
return f.svc.RoutePutAlertRuleGroup(ctx, ag, folder, group)
}

30
pkg/services/ngalert/api/testing_api.go Normal file
View File

@@ -0,0 +1,30 @@
package api
import (
"github.com/grafana/grafana/pkg/api/response"
"github.com/grafana/grafana/pkg/models"
apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions"
)
// TestingApiHandler always forwards requests to grafana backend
type TestingApiHandler struct {
svc *TestingApiSrv
}
func NewTestingApi(svc *TestingApiSrv) *TestingApiHandler {
return &TestingApiHandler{
svc: svc,
}
}
func (f *TestingApiHandler) handleRouteTestRuleConfig(c *models.ReqContext, body apimodels.TestRulePayload, dsUID string) response.Response {
return f.svc.RouteTestRuleConfig(c, body, dsUID)
}
func (f *TestingApiHandler) handleRouteTestRuleGrafanaConfig(c *models.ReqContext, body apimodels.TestRulePayload) response.Response {
return f.svc.RouteTestGrafanaRuleConfig(c, body)
}
func (f *TestingApiHandler) handleRouteEvalQueries(c *models.ReqContext, body apimodels.EvalQueriesPayload) response.Response {
return f.svc.RouteEvalQueries(c, body)
}

4
pkg/services/ngalert/api/tooling/Makefile
View File

@@ -65,4 +65,6 @@ serve: post.json
serve-stable: api.json serve-stable: api.json
docker run --rm -p 80:8080 -v $$(pwd):/tmp -e SWAGGER_FILE=/tmp/$(<) swaggerapi/swagger-editor docker run --rm -p 80:8080 -v $$(pwd):/tmp -e SWAGGER_FILE=/tmp/$(<) swaggerapi/swagger-editor
all: post.json validate api.json validate-stable swagger-codegen-api fix copy-files clean gen: swagger-codegen-api fix copy-files clean
all: post.json api.json gen

4
pkg/services/ngalert/api/tooling/api.json
View File

@@ -2702,6 +2702,7 @@
"type": "object" "type": "object"
}, },
"URL": { "URL": {
"description": "The general form represented is:\n\n[scheme:][//[userinfo@]host][/]path[?query][#fragment]\n\nURLs that do not start with a slash after the scheme are interpreted as:\n\nscheme:opaque[?query][#fragment]\n\nNote that the Path field is stored in decoded form: /%47%6f%2f becomes /Go/.\nA consequence is that it is impossible to tell which slashes in the Path were\nslashes in the raw URL and which were %2f. This distinction is rarely important,\nbut when it is, the code should use RawPath, an optional field which only gets\nset if the default encoding is different from Path.\n\nURL's String method uses the EscapedPath method to obtain the path. See the\nEscapedPath method for more details.",
"properties": { "properties": {
"ForceQuery": { "ForceQuery": {
"type": "boolean" "type": "boolean"
@@ -2734,7 +2735,7 @@
"$ref": "#/definitions/Userinfo" "$ref": "#/definitions/Userinfo"
} }
}, },
"title": "URL is a custom URL type that allows validation at configuration load time.", "title": "A URL represents a parsed URL (technically, a URI reference).",
"type": "object" "type": "object"
}, },
"Userinfo": { "Userinfo": {
@@ -3295,6 +3296,7 @@
"type": "object" "type": "object"
}, },
"receiver": { "receiver": {
"description": "Receiver receiver",
"properties": { "properties": {
"name": { "name": {
"description": "name", "description": "name",

4
pkg/services/ngalert/api/tooling/spec.json
View File

@@ -5289,6 +5289,7 @@
} }
}, },
"alertGroup": { "alertGroup": {
"description": "AlertGroup alert group",
"type": "object", "type": "object",
"required": [ "required": [
"alerts", "alerts",
@@ -5487,7 +5488,6 @@
"$ref": "#/definitions/gettableAlerts" "$ref": "#/definitions/gettableAlerts"
}, },
"gettableSilence": { "gettableSilence": {
"description": "GettableSilence gettable silence",
"type": "object", "type": "object",
"required": [ "required": [
"comment", "comment",
@@ -5537,7 +5537,6 @@
"$ref": "#/definitions/gettableSilence" "$ref": "#/definitions/gettableSilence"
}, },
"gettableSilences": { "gettableSilences": {
"description": "GettableSilences gettable silences",
"type": "array", "type": "array",
"items": { "items": {
"$ref": "#/definitions/gettableSilence" "$ref": "#/definitions/gettableSilence"
@@ -5688,6 +5687,7 @@
"$ref": "#/definitions/postableSilence" "$ref": "#/definitions/postableSilence"
}, },
"receiver": { "receiver": {
"description": "Receiver receiver",
"type": "object", "type": "object",
"required": [ "required": [
"name" "name"

17
pkg/services/ngalert/api/tooling/swagger-codegen/templates/controller-api.mustache
View File

@@ -13,26 +13,25 @@ import (
"github.com/grafana/grafana/pkg/middleware" "github.com/grafana/grafana/pkg/middleware"
) )
type {{classname}}ForkingService interface { {{#operation}} type {{classname}} interface { {{#operation}}
{{nickname}}(*models.ReqContext) response.Response{{/operation}} {{nickname}}(*models.ReqContext) response.Response{{/operation}}
} }
{{#operations}}{{#operation}} {{#operations}}{{#operation}}
func (f *Forked{{classname}}) {{nickname}}(ctx *models.ReqContext) response.Response { func (f *{{classname}}Handler) {{nickname}}(ctx *models.ReqContext) response.Response { {{#hasPathParams}}
{{#pathParams}} // Parse Path Parameters{{/hasPathParams}}{{#pathParams}}
{{paramName}}Param := web.Params(ctx.Req)[":{{baseName}}"] {{paramName}}Param := web.Params(ctx.Req)[":{{baseName}}"]{{/pathParams}}
{{/pathParams}}
{{#bodyParams}} {{#bodyParams}}
// Parse Request Body
conf := apimodels.{{dataType}}{} conf := apimodels.{{dataType}}{}
if err := web.Bind(ctx.Req, &conf); err != nil { if err := web.Bind(ctx.Req, &conf); err != nil {
return response.Error(http.StatusBadRequest, "bad request data", err) return response.Error(http.StatusBadRequest, "bad request data", err)
} }
{{/bodyParams}} {{/bodyParams}}return f.handle{{nickname}}(ctx{{#bodyParams}}, conf{{/bodyParams}}{{#pathParams}}, {{paramName}}Param{{/pathParams}})
return f.fork{{nickname}}(ctx{{#bodyParams}}, conf{{/bodyParams}}{{#pathParams}}, {{paramName}}Param{{/pathParams}})
} }
{{/operation}}{{/operations}} {{/operation}}{{/operations}}
func (api *API) Register{{classname}}Endpoints(srv {{classname}}ForkingService, m *metrics.API) { func (api *API) Register{{classname}}Endpoints(srv {{classname}}, m *metrics.API) {
api.RouteRegister.Group("", func(group routing.RouteRegister){ {{#operations}}{{#operation}} api.RouteRegister.Group("", func(group routing.RouteRegister){ {{#operations}}{{#operation}}
group.{{httpMethod}}( group.{{httpMethod}}(
toMacaronPath("{{{path}}}"), toMacaronPath("{{{path}}}"),
@@ -46,4 +45,4 @@ func (api *API) Register{{classname}}Endpoints(srv {{classname}}ForkingService,
){{/operation}}{{/operations}} ){{/operation}}{{/operations}}
}, middleware.ReqSignedIn) }, middleware.ReqSignedIn)
}{{#operation}} }{{#operation}}
{{/operation}}{{/operations}} {{/operation}}{{/operations}}