diff --git a/pkg/services/ngalert/api/api.go b/pkg/services/ngalert/api/api.go index 71e55096b9c..cf21d0f48a7 100644 --- a/pkg/services/ngalert/api/api.go +++ b/pkg/services/ngalert/api/api.go @@ -92,16 +92,19 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) { NewLotexRuler(proxy, logger), RulerSrv{DatasourceCache: api.DatasourceCache, QuotaService: api.QuotaService, manager: api.StateManager, store: api.RuleStore, log: logger}, ), m) - api.RegisterTestingApiEndpoints(TestingApiSrv{ - AlertingProxy: proxy, - Cfg: api.Cfg, - ExpressionService: api.ExpressionService, - DatasourceCache: api.DatasourceCache, - log: logger, - }, m) - api.RegisterConfigurationApiEndpoints(AdminSrv{ - store: api.AdminConfigStore, - log: logger, - scheduler: api.Schedule, - }, m) + api.RegisterTestingApiEndpoints(NewForkedTestingApi( + TestingApiSrv{ + AlertingProxy: proxy, + Cfg: api.Cfg, + ExpressionService: api.ExpressionService, + DatasourceCache: api.DatasourceCache, + log: logger, + }), m) + api.RegisterConfigurationApiEndpoints(NewForkedConfiguration( + AdminSrv{ + store: api.AdminConfigStore, + log: logger, + scheduler: api.Schedule, + }, + ), m) } diff --git a/pkg/services/ngalert/api/fork_ruler.go b/pkg/services/ngalert/api/fork_ruler.go index 24ef67314a0..cfd9cc386f4 100644 --- a/pkg/services/ngalert/api/fork_ruler.go +++ b/pkg/services/ngalert/api/fork_ruler.go @@ -9,98 +9,98 @@ import ( apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" ) -// ForkedRuler will validate and proxy requests to the correct backend type depending on the datasource. -type ForkedRuler struct { +// ForkedRulerApi will validate and proxy requests to the correct backend type depending on the datasource. +type ForkedRulerApi struct { LotexRuler, GrafanaRuler RulerApiService DatasourceCache datasources.CacheService } // NewForkedRuler implements a set of routes that proxy to various Cortex Ruler-compatible backends. -func NewForkedRuler(datasourceCache datasources.CacheService, lotex, grafana RulerApiService) *ForkedRuler { - return &ForkedRuler{ +func NewForkedRuler(datasourceCache datasources.CacheService, lotex, grafana RulerApiService) *ForkedRulerApi { + return &ForkedRulerApi{ LotexRuler: lotex, GrafanaRuler: grafana, DatasourceCache: datasourceCache, } } -func (r *ForkedRuler) RouteDeleteNamespaceRulesConfig(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, r.DatasourceCache) +func (f *ForkedRulerApi) forkRouteDeleteNamespaceRulesConfig(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return r.GrafanaRuler.RouteDeleteNamespaceRulesConfig(ctx) + return f.GrafanaRuler.RouteDeleteNamespaceRulesConfig(ctx) case apimodels.LoTexRulerBackend: - return r.LotexRuler.RouteDeleteNamespaceRulesConfig(ctx) + return f.LotexRuler.RouteDeleteNamespaceRulesConfig(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } } -func (r *ForkedRuler) RouteDeleteRuleGroupConfig(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, r.DatasourceCache) +func (f *ForkedRulerApi) forkRouteDeleteRuleGroupConfig(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return r.GrafanaRuler.RouteDeleteRuleGroupConfig(ctx) + return f.GrafanaRuler.RouteDeleteRuleGroupConfig(ctx) case apimodels.LoTexRulerBackend: - return r.LotexRuler.RouteDeleteRuleGroupConfig(ctx) + return f.LotexRuler.RouteDeleteRuleGroupConfig(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } } -func (r *ForkedRuler) RouteGetNamespaceRulesConfig(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, r.DatasourceCache) +func (f *ForkedRulerApi) forkRouteGetNamespaceRulesConfig(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return r.GrafanaRuler.RouteGetNamespaceRulesConfig(ctx) + return f.GrafanaRuler.RouteGetNamespaceRulesConfig(ctx) case apimodels.LoTexRulerBackend: - return r.LotexRuler.RouteGetNamespaceRulesConfig(ctx) + return f.LotexRuler.RouteGetNamespaceRulesConfig(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } } -func (r *ForkedRuler) RouteGetRulegGroupConfig(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, r.DatasourceCache) +func (f *ForkedRulerApi) forkRouteGetRulegGroupConfig(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return r.GrafanaRuler.RouteGetRulegGroupConfig(ctx) + return f.GrafanaRuler.RouteGetRulegGroupConfig(ctx) case apimodels.LoTexRulerBackend: - return r.LotexRuler.RouteGetRulegGroupConfig(ctx) + return f.LotexRuler.RouteGetRulegGroupConfig(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } } -func (r *ForkedRuler) RouteGetRulesConfig(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, r.DatasourceCache) +func (f *ForkedRulerApi) forkRouteGetRulesConfig(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return r.GrafanaRuler.RouteGetRulesConfig(ctx) + return f.GrafanaRuler.RouteGetRulesConfig(ctx) case apimodels.LoTexRulerBackend: - return r.LotexRuler.RouteGetRulesConfig(ctx) + return f.LotexRuler.RouteGetRulesConfig(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } } -func (r *ForkedRuler) RoutePostNameRulesConfig(ctx *models.ReqContext, conf apimodels.PostableRuleGroupConfig) response.Response { - backendType, err := backendType(ctx, r.DatasourceCache) +func (f *ForkedRulerApi) forkRoutePostNameRulesConfig(ctx *models.ReqContext, conf apimodels.PostableRuleGroupConfig) response.Response { + backendType, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } @@ -112,9 +112,9 @@ func (r *ForkedRuler) RoutePostNameRulesConfig(ctx *models.ReqContext, conf apim switch backendType { case apimodels.GrafanaBackend: - return r.GrafanaRuler.RoutePostNameRulesConfig(ctx, conf) + return f.GrafanaRuler.RoutePostNameRulesConfig(ctx, conf) case apimodels.LoTexRulerBackend: - return r.LotexRuler.RoutePostNameRulesConfig(ctx, conf) + return f.LotexRuler.RoutePostNameRulesConfig(ctx, conf) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", backendType), "") } diff --git a/pkg/services/ngalert/api/forked_admin.go b/pkg/services/ngalert/api/forked_admin.go new file mode 100644 index 00000000000..5f74f05de00 --- /dev/null +++ b/pkg/services/ngalert/api/forked_admin.go @@ -0,0 +1,35 @@ +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 ConfigurationApiService +} + +// NewForkedConfiguration creates a new ForkedConfigurationApi instance +func NewForkedConfiguration(grafana ConfigurationApiService) *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) +} diff --git a/pkg/services/ngalert/api/forked_am.go b/pkg/services/ngalert/api/forked_am.go index 3fffb6b5eb7..99569cb07c0 100644 --- a/pkg/services/ngalert/api/forked_am.go +++ b/pkg/services/ngalert/api/forked_am.go @@ -9,38 +9,38 @@ import ( apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" ) -type ForkedAMSvc struct { +type ForkedAlertmanagerApi struct { AMSvc, GrafanaSvc AlertmanagerApiService DatasourceCache datasources.CacheService } // NewForkedAM implements a set of routes that proxy to various Alertmanager-compatible backends. -func NewForkedAM(datasourceCache datasources.CacheService, proxy, grafana AlertmanagerApiService) *ForkedAMSvc { - return &ForkedAMSvc{ +func NewForkedAM(datasourceCache datasources.CacheService, proxy, grafana AlertmanagerApiService) *ForkedAlertmanagerApi { + return &ForkedAlertmanagerApi{ AMSvc: proxy, GrafanaSvc: grafana, DatasourceCache: datasourceCache, } } -func (am *ForkedAMSvc) getService(ctx *models.ReqContext) (AlertmanagerApiService, error) { - t, err := backendType(ctx, am.DatasourceCache) +func (f *ForkedAlertmanagerApi) getService(ctx *models.ReqContext) (AlertmanagerApiService, error) { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return nil, err } switch t { case apimodels.GrafanaBackend: - return am.GrafanaSvc, nil + return f.GrafanaSvc, nil case apimodels.AlertmanagerBackend: - return am.AMSvc, nil + return f.AMSvc, nil default: return nil, fmt.Errorf("unexpected backend type (%v)", t) } } -func (am *ForkedAMSvc) RouteGetAMStatus(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteGetAMStatus(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return response.Error(400, err.Error(), nil) } @@ -48,8 +48,8 @@ func (am *ForkedAMSvc) RouteGetAMStatus(ctx *models.ReqContext) response.Respons return s.RouteGetAMStatus(ctx) } -func (am *ForkedAMSvc) RouteCreateSilence(ctx *models.ReqContext, body apimodels.PostableSilence) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteCreateSilence(ctx *models.ReqContext, body apimodels.PostableSilence) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -57,8 +57,8 @@ func (am *ForkedAMSvc) RouteCreateSilence(ctx *models.ReqContext, body apimodels return s.RouteCreateSilence(ctx, body) } -func (am *ForkedAMSvc) RouteDeleteAlertingConfig(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteDeleteAlertingConfig(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -66,8 +66,8 @@ func (am *ForkedAMSvc) RouteDeleteAlertingConfig(ctx *models.ReqContext) respons return s.RouteDeleteAlertingConfig(ctx) } -func (am *ForkedAMSvc) RouteDeleteSilence(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteDeleteSilence(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -75,8 +75,8 @@ func (am *ForkedAMSvc) RouteDeleteSilence(ctx *models.ReqContext) response.Respo return s.RouteDeleteSilence(ctx) } -func (am *ForkedAMSvc) RouteGetAlertingConfig(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteGetAlertingConfig(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -84,8 +84,8 @@ func (am *ForkedAMSvc) RouteGetAlertingConfig(ctx *models.ReqContext) response.R return s.RouteGetAlertingConfig(ctx) } -func (am *ForkedAMSvc) RouteGetAMAlertGroups(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteGetAMAlertGroups(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -93,8 +93,8 @@ func (am *ForkedAMSvc) RouteGetAMAlertGroups(ctx *models.ReqContext) response.Re return s.RouteGetAMAlertGroups(ctx) } -func (am *ForkedAMSvc) RouteGetAMAlerts(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteGetAMAlerts(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -102,8 +102,8 @@ func (am *ForkedAMSvc) RouteGetAMAlerts(ctx *models.ReqContext) response.Respons return s.RouteGetAMAlerts(ctx) } -func (am *ForkedAMSvc) RouteGetSilence(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteGetSilence(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -111,8 +111,8 @@ func (am *ForkedAMSvc) RouteGetSilence(ctx *models.ReqContext) response.Response return s.RouteGetSilence(ctx) } -func (am *ForkedAMSvc) RouteGetSilences(ctx *models.ReqContext) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRouteGetSilences(ctx *models.ReqContext) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -120,13 +120,13 @@ func (am *ForkedAMSvc) RouteGetSilences(ctx *models.ReqContext) response.Respons return s.RouteGetSilences(ctx) } -func (am *ForkedAMSvc) RoutePostAlertingConfig(ctx *models.ReqContext, body apimodels.PostableUserConfig) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRoutePostAlertingConfig(ctx *models.ReqContext, body apimodels.PostableUserConfig) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } - b, err := backendType(ctx, am.DatasourceCache) + b, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } @@ -138,8 +138,8 @@ func (am *ForkedAMSvc) RoutePostAlertingConfig(ctx *models.ReqContext, body apim return s.RoutePostAlertingConfig(ctx, body) } -func (am *ForkedAMSvc) RoutePostAMAlerts(ctx *models.ReqContext, body apimodels.PostableAlerts) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRoutePostAMAlerts(ctx *models.ReqContext, body apimodels.PostableAlerts) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } @@ -147,8 +147,8 @@ func (am *ForkedAMSvc) RoutePostAMAlerts(ctx *models.ReqContext, body apimodels. return s.RoutePostAMAlerts(ctx, body) } -func (am *ForkedAMSvc) RoutePostTestReceivers(ctx *models.ReqContext, body apimodels.TestReceiversConfigBodyParams) response.Response { - s, err := am.getService(ctx) +func (f *ForkedAlertmanagerApi) forkRoutePostTestReceivers(ctx *models.ReqContext, body apimodels.TestReceiversConfigBodyParams) response.Response { + s, err := f.getService(ctx) if err != nil { return ErrResp(400, err, "") } diff --git a/pkg/services/ngalert/api/forked_prom.go b/pkg/services/ngalert/api/forked_prom.go index a9a48649480..2fc8fd2714f 100644 --- a/pkg/services/ngalert/api/forked_prom.go +++ b/pkg/services/ngalert/api/forked_prom.go @@ -9,47 +9,47 @@ import ( apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" ) -type ForkedPromSvc struct { +type ForkedPrometheusApi struct { ProxySvc, GrafanaSvc PrometheusApiService DatasourceCache datasources.CacheService } // NewForkedProm implements a set of routes that proxy to various Prometheus-compatible backends. -func NewForkedProm(datasourceCache datasources.CacheService, proxy, grafana PrometheusApiService) *ForkedPromSvc { - return &ForkedPromSvc{ +func NewForkedProm(datasourceCache datasources.CacheService, proxy, grafana PrometheusApiService) *ForkedPrometheusApi { + return &ForkedPrometheusApi{ ProxySvc: proxy, GrafanaSvc: grafana, DatasourceCache: datasourceCache, } } -func (p *ForkedPromSvc) RouteGetAlertStatuses(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, p.DatasourceCache) +func (f *ForkedPrometheusApi) forkRouteGetAlertStatuses(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return p.GrafanaSvc.RouteGetAlertStatuses(ctx) + return f.GrafanaSvc.RouteGetAlertStatuses(ctx) case apimodels.LoTexRulerBackend: - return p.ProxySvc.RouteGetAlertStatuses(ctx) + return f.ProxySvc.RouteGetAlertStatuses(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } } -func (p *ForkedPromSvc) RouteGetRuleStatuses(ctx *models.ReqContext) response.Response { - t, err := backendType(ctx, p.DatasourceCache) +func (f *ForkedPrometheusApi) forkRouteGetRuleStatuses(ctx *models.ReqContext) response.Response { + t, err := backendType(ctx, f.DatasourceCache) if err != nil { return ErrResp(400, err, "") } switch t { case apimodels.GrafanaBackend: - return p.GrafanaSvc.RouteGetRuleStatuses(ctx) + return f.GrafanaSvc.RouteGetRuleStatuses(ctx) case apimodels.LoTexRulerBackend: - return p.ProxySvc.RouteGetRuleStatuses(ctx) + return f.ProxySvc.RouteGetRuleStatuses(ctx) default: return ErrResp(400, fmt.Errorf("unexpected backend type (%v)", t), "") } diff --git a/pkg/services/ngalert/api/forked_testing.go b/pkg/services/ngalert/api/forked_testing.go new file mode 100644 index 00000000000..1f348702a9f --- /dev/null +++ b/pkg/services/ngalert/api/forked_testing.go @@ -0,0 +1,27 @@ +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 { + grafana TestingApiService +} + +// NewForkedTestingApi creates a new ForkedTestingApi instance +func NewForkedTestingApi(grafana TestingApiService) *ForkedTestingApi { + return &ForkedTestingApi{ + grafana: grafana, + } +} + +func (f *ForkedTestingApi) forkRouteTestRuleConfig(c *models.ReqContext, body apimodels.TestRulePayload) response.Response { + return f.grafana.RouteTestRuleConfig(c, body) +} + +func (f *ForkedTestingApi) forkRouteEvalQueries(c *models.ReqContext, body apimodels.EvalQueriesPayload) response.Response { + return f.grafana.RouteEvalQueries(c, body) +} diff --git a/pkg/services/ngalert/api/generated_base_api_alertmanager.go b/pkg/services/ngalert/api/generated_base_api_alertmanager.go index 6c786dc3aa2..95974825392 100644 --- a/pkg/services/ngalert/api/generated_base_api_alertmanager.go +++ b/pkg/services/ngalert/api/generated_base_api_alertmanager.go @@ -4,21 +4,36 @@ * *Do not manually edit these files, please find ngalert/api/swagger-codegen/ for commands on how to generate them. */ + package api import ( "net/http" - "github.com/go-macaron/binding" - "github.com/grafana/grafana/pkg/api/response" "github.com/grafana/grafana/pkg/api/routing" "github.com/grafana/grafana/pkg/middleware" "github.com/grafana/grafana/pkg/models" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" "github.com/grafana/grafana/pkg/services/ngalert/metrics" + "github.com/grafana/grafana/pkg/web" ) +type AlertmanagerApiForkingService interface { + RouteCreateSilence(*models.ReqContext) response.Response + RouteDeleteAlertingConfig(*models.ReqContext) response.Response + RouteDeleteSilence(*models.ReqContext) response.Response + RouteGetAMAlertGroups(*models.ReqContext) response.Response + RouteGetAMAlerts(*models.ReqContext) response.Response + RouteGetAMStatus(*models.ReqContext) response.Response + RouteGetAlertingConfig(*models.ReqContext) response.Response + RouteGetSilence(*models.ReqContext) response.Response + RouteGetSilences(*models.ReqContext) response.Response + RoutePostAMAlerts(*models.ReqContext) response.Response + RoutePostAlertingConfig(*models.ReqContext) response.Response + RoutePostTestReceivers(*models.ReqContext) response.Response +} + type AlertmanagerApiService interface { RouteCreateSilence(*models.ReqContext, apimodels.PostableSilence) response.Response RouteDeleteAlertingConfig(*models.ReqContext) response.Response @@ -34,11 +49,74 @@ type AlertmanagerApiService interface { RoutePostTestReceivers(*models.ReqContext, apimodels.TestReceiversConfigBodyParams) response.Response } -func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApiService, m *metrics.API) { +func (f *ForkedAlertmanagerApi) RouteCreateSilence(ctx *models.ReqContext) response.Response { + conf := apimodels.PostableSilence{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRouteCreateSilence(ctx, conf) +} + +func (f *ForkedAlertmanagerApi) RouteDeleteAlertingConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteDeleteAlertingConfig(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteDeleteSilence(ctx *models.ReqContext) response.Response { + return f.forkRouteDeleteSilence(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteGetAMAlertGroups(ctx *models.ReqContext) response.Response { + return f.forkRouteGetAMAlertGroups(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteGetAMAlerts(ctx *models.ReqContext) response.Response { + return f.forkRouteGetAMAlerts(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteGetAMStatus(ctx *models.ReqContext) response.Response { + return f.forkRouteGetAMStatus(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteGetAlertingConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteGetAlertingConfig(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteGetSilence(ctx *models.ReqContext) response.Response { + return f.forkRouteGetSilence(ctx) +} + +func (f *ForkedAlertmanagerApi) RouteGetSilences(ctx *models.ReqContext) response.Response { + return f.forkRouteGetSilences(ctx) +} + +func (f *ForkedAlertmanagerApi) RoutePostAMAlerts(ctx *models.ReqContext) response.Response { + conf := apimodels.PostableAlerts{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRoutePostAMAlerts(ctx, conf) +} + +func (f *ForkedAlertmanagerApi) RoutePostAlertingConfig(ctx *models.ReqContext) response.Response { + conf := apimodels.PostableUserConfig{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRoutePostAlertingConfig(ctx, conf) +} + +func (f *ForkedAlertmanagerApi) RoutePostTestReceivers(ctx *models.ReqContext) response.Response { + conf := apimodels.TestReceiversConfigBodyParams{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRoutePostTestReceivers(ctx, conf) +} + +func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApiForkingService, m *metrics.API) { api.RouteRegister.Group("", func(group routing.RouteRegister) { group.Post( toMacaronPath("/api/alertmanager/{Recipient}/api/v2/silences"), - binding.Bind(apimodels.PostableSilence{}), metrics.Instrument( http.MethodPost, "/api/alertmanager/{Recipient}/api/v2/silences", @@ -120,7 +198,6 @@ func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApiService, m * ) group.Post( toMacaronPath("/api/alertmanager/{Recipient}/api/v2/alerts"), - binding.Bind(apimodels.PostableAlerts{}), metrics.Instrument( http.MethodPost, "/api/alertmanager/{Recipient}/api/v2/alerts", @@ -130,7 +207,6 @@ func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApiService, m * ) group.Post( toMacaronPath("/api/alertmanager/{Recipient}/config/api/v1/alerts"), - binding.Bind(apimodels.PostableUserConfig{}), metrics.Instrument( http.MethodPost, "/api/alertmanager/{Recipient}/config/api/v1/alerts", @@ -140,7 +216,6 @@ func (api *API) RegisterAlertmanagerApiEndpoints(srv AlertmanagerApiService, m * ) group.Post( toMacaronPath("/api/alertmanager/{Recipient}/config/api/v1/receivers/test"), - binding.Bind(apimodels.TestReceiversConfigBodyParams{}), metrics.Instrument( http.MethodPost, "/api/alertmanager/{Recipient}/config/api/v1/receivers/test", diff --git a/pkg/services/ngalert/api/generated_base_api_configuration.go b/pkg/services/ngalert/api/generated_base_api_configuration.go index dfa3a9e804d..0e4cf9c61cf 100644 --- a/pkg/services/ngalert/api/generated_base_api_configuration.go +++ b/pkg/services/ngalert/api/generated_base_api_configuration.go @@ -4,21 +4,28 @@ * *Do not manually edit these files, please find ngalert/api/swagger-codegen/ for commands on how to generate them. */ + package api import ( "net/http" - "github.com/go-macaron/binding" - "github.com/grafana/grafana/pkg/api/response" "github.com/grafana/grafana/pkg/api/routing" "github.com/grafana/grafana/pkg/middleware" "github.com/grafana/grafana/pkg/models" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" "github.com/grafana/grafana/pkg/services/ngalert/metrics" + "github.com/grafana/grafana/pkg/web" ) +type ConfigurationApiForkingService interface { + RouteDeleteNGalertConfig(*models.ReqContext) response.Response + RouteGetAlertmanagers(*models.ReqContext) response.Response + RouteGetNGalertConfig(*models.ReqContext) response.Response + RoutePostNGalertConfig(*models.ReqContext) response.Response +} + type ConfigurationApiService interface { RouteDeleteNGalertConfig(*models.ReqContext) response.Response RouteGetAlertmanagers(*models.ReqContext) response.Response @@ -26,7 +33,27 @@ type ConfigurationApiService interface { RoutePostNGalertConfig(*models.ReqContext, apimodels.PostableNGalertConfig) response.Response } -func (api *API) RegisterConfigurationApiEndpoints(srv ConfigurationApiService, m *metrics.API) { +func (f *ForkedConfigurationApi) RouteDeleteNGalertConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteDeleteNGalertConfig(ctx) +} + +func (f *ForkedConfigurationApi) RouteGetAlertmanagers(ctx *models.ReqContext) response.Response { + return f.forkRouteGetAlertmanagers(ctx) +} + +func (f *ForkedConfigurationApi) RouteGetNGalertConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteGetNGalertConfig(ctx) +} + +func (f *ForkedConfigurationApi) RoutePostNGalertConfig(ctx *models.ReqContext) response.Response { + conf := apimodels.PostableNGalertConfig{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRoutePostNGalertConfig(ctx, conf) +} + +func (api *API) RegisterConfigurationApiEndpoints(srv ConfigurationApiForkingService, m *metrics.API) { api.RouteRegister.Group("", func(group routing.RouteRegister) { group.Delete( toMacaronPath("/api/v1/ngalert/admin_config"), @@ -57,7 +84,6 @@ func (api *API) RegisterConfigurationApiEndpoints(srv ConfigurationApiService, m ) group.Post( toMacaronPath("/api/v1/ngalert/admin_config"), - binding.Bind(apimodels.PostableNGalertConfig{}), metrics.Instrument( http.MethodPost, "/api/v1/ngalert/admin_config", diff --git a/pkg/services/ngalert/api/generated_base_api_prometheus.go b/pkg/services/ngalert/api/generated_base_api_prometheus.go index 844d2a2a61e..89a70dc16bb 100644 --- a/pkg/services/ngalert/api/generated_base_api_prometheus.go +++ b/pkg/services/ngalert/api/generated_base_api_prometheus.go @@ -4,6 +4,7 @@ * *Do not manually edit these files, please find ngalert/api/swagger-codegen/ for commands on how to generate them. */ + package api import ( @@ -16,12 +17,25 @@ import ( "github.com/grafana/grafana/pkg/services/ngalert/metrics" ) +type PrometheusApiForkingService interface { + RouteGetAlertStatuses(*models.ReqContext) response.Response + RouteGetRuleStatuses(*models.ReqContext) response.Response +} + type PrometheusApiService interface { RouteGetAlertStatuses(*models.ReqContext) response.Response RouteGetRuleStatuses(*models.ReqContext) response.Response } -func (api *API) RegisterPrometheusApiEndpoints(srv PrometheusApiService, m *metrics.API) { +func (f *ForkedPrometheusApi) RouteGetAlertStatuses(ctx *models.ReqContext) response.Response { + return f.forkRouteGetAlertStatuses(ctx) +} + +func (f *ForkedPrometheusApi) RouteGetRuleStatuses(ctx *models.ReqContext) response.Response { + return f.forkRouteGetRuleStatuses(ctx) +} + +func (api *API) RegisterPrometheusApiEndpoints(srv PrometheusApiForkingService, m *metrics.API) { api.RouteRegister.Group("", func(group routing.RouteRegister) { group.Get( toMacaronPath("/api/prometheus/{Recipient}/api/v1/alerts"), diff --git a/pkg/services/ngalert/api/generated_base_api_ruler.go b/pkg/services/ngalert/api/generated_base_api_ruler.go index a63b0da586c..e953ff61a7d 100644 --- a/pkg/services/ngalert/api/generated_base_api_ruler.go +++ b/pkg/services/ngalert/api/generated_base_api_ruler.go @@ -4,21 +4,30 @@ * *Do not manually edit these files, please find ngalert/api/swagger-codegen/ for commands on how to generate them. */ + package api import ( "net/http" - "github.com/go-macaron/binding" - "github.com/grafana/grafana/pkg/api/response" "github.com/grafana/grafana/pkg/api/routing" "github.com/grafana/grafana/pkg/middleware" "github.com/grafana/grafana/pkg/models" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" "github.com/grafana/grafana/pkg/services/ngalert/metrics" + "github.com/grafana/grafana/pkg/web" ) +type RulerApiForkingService interface { + RouteDeleteNamespaceRulesConfig(*models.ReqContext) response.Response + RouteDeleteRuleGroupConfig(*models.ReqContext) response.Response + RouteGetNamespaceRulesConfig(*models.ReqContext) response.Response + RouteGetRulegGroupConfig(*models.ReqContext) response.Response + RouteGetRulesConfig(*models.ReqContext) response.Response + RoutePostNameRulesConfig(*models.ReqContext) response.Response +} + type RulerApiService interface { RouteDeleteNamespaceRulesConfig(*models.ReqContext) response.Response RouteDeleteRuleGroupConfig(*models.ReqContext) response.Response @@ -28,7 +37,35 @@ type RulerApiService interface { RoutePostNameRulesConfig(*models.ReqContext, apimodels.PostableRuleGroupConfig) response.Response } -func (api *API) RegisterRulerApiEndpoints(srv RulerApiService, m *metrics.API) { +func (f *ForkedRulerApi) RouteDeleteNamespaceRulesConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteDeleteNamespaceRulesConfig(ctx) +} + +func (f *ForkedRulerApi) RouteDeleteRuleGroupConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteDeleteRuleGroupConfig(ctx) +} + +func (f *ForkedRulerApi) RouteGetNamespaceRulesConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteGetNamespaceRulesConfig(ctx) +} + +func (f *ForkedRulerApi) RouteGetRulegGroupConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteGetRulegGroupConfig(ctx) +} + +func (f *ForkedRulerApi) RouteGetRulesConfig(ctx *models.ReqContext) response.Response { + return f.forkRouteGetRulesConfig(ctx) +} + +func (f *ForkedRulerApi) RoutePostNameRulesConfig(ctx *models.ReqContext) response.Response { + conf := apimodels.PostableRuleGroupConfig{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRoutePostNameRulesConfig(ctx, conf) +} + +func (api *API) RegisterRulerApiEndpoints(srv RulerApiForkingService, m *metrics.API) { api.RouteRegister.Group("", func(group routing.RouteRegister) { group.Delete( toMacaronPath("/api/ruler/{Recipient}/api/v1/rules/{Namespace}"), @@ -77,7 +114,6 @@ func (api *API) RegisterRulerApiEndpoints(srv RulerApiService, m *metrics.API) { ) group.Post( toMacaronPath("/api/ruler/{Recipient}/api/v1/rules/{Namespace}"), - binding.Bind(apimodels.PostableRuleGroupConfig{}), metrics.Instrument( http.MethodPost, "/api/ruler/{Recipient}/api/v1/rules/{Namespace}", diff --git a/pkg/services/ngalert/api/generated_base_api_testing.go b/pkg/services/ngalert/api/generated_base_api_testing.go index e5e36336b8e..d82d4fb090c 100644 --- a/pkg/services/ngalert/api/generated_base_api_testing.go +++ b/pkg/services/ngalert/api/generated_base_api_testing.go @@ -4,31 +4,51 @@ * *Do not manually edit these files, please find ngalert/api/swagger-codegen/ for commands on how to generate them. */ + package api import ( "net/http" - "github.com/go-macaron/binding" - "github.com/grafana/grafana/pkg/api/response" "github.com/grafana/grafana/pkg/api/routing" "github.com/grafana/grafana/pkg/middleware" "github.com/grafana/grafana/pkg/models" apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" "github.com/grafana/grafana/pkg/services/ngalert/metrics" + "github.com/grafana/grafana/pkg/web" ) +type TestingApiForkingService interface { + RouteEvalQueries(*models.ReqContext) response.Response + RouteTestRuleConfig(*models.ReqContext) response.Response +} + type TestingApiService interface { RouteEvalQueries(*models.ReqContext, apimodels.EvalQueriesPayload) response.Response RouteTestRuleConfig(*models.ReqContext, apimodels.TestRulePayload) response.Response } -func (api *API) RegisterTestingApiEndpoints(srv TestingApiService, m *metrics.API) { +func (f *ForkedTestingApi) RouteEvalQueries(ctx *models.ReqContext) response.Response { + conf := apimodels.EvalQueriesPayload{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRouteEvalQueries(ctx, conf) +} + +func (f *ForkedTestingApi) RouteTestRuleConfig(ctx *models.ReqContext) response.Response { + conf := apimodels.TestRulePayload{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.forkRouteTestRuleConfig(ctx, conf) +} + +func (api *API) RegisterTestingApiEndpoints(srv TestingApiForkingService, m *metrics.API) { api.RouteRegister.Group("", func(group routing.RouteRegister) { group.Post( toMacaronPath("/api/v1/eval"), - binding.Bind(apimodels.EvalQueriesPayload{}), metrics.Instrument( http.MethodPost, "/api/v1/eval", @@ -38,7 +58,6 @@ func (api *API) RegisterTestingApiEndpoints(srv TestingApiService, m *metrics.AP ) group.Post( toMacaronPath("/api/v1/rule/test/{Recipient}"), - binding.Bind(apimodels.TestRulePayload{}), metrics.Instrument( http.MethodPost, "/api/v1/rule/test/{Recipient}", diff --git a/pkg/services/ngalert/api/tooling/spec.json b/pkg/services/ngalert/api/tooling/spec.json index 5088e59149c..11d6a457d0f 100644 --- a/pkg/services/ngalert/api/tooling/spec.json +++ b/pkg/services/ngalert/api/tooling/spec.json @@ -3680,8 +3680,9 @@ "x-go-package": "github.com/prometheus/alertmanager/timeinterval" }, "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.", "type": "object", - "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).", "properties": { "ForceQuery": { "type": "boolean" @@ -3714,7 +3715,7 @@ "$ref": "#/definitions/Userinfo" } }, - "x-go-package": "github.com/prometheus/common/config" + "x-go-package": "net/url" }, "Userinfo": { "description": "The Userinfo type is an immutable encapsulation of username and\npassword details for a URL. An existing Userinfo value is guaranteed\nto have a username set (potentially empty, as allowed by RFC 2396),\nand optionally a password.", @@ -4135,6 +4136,7 @@ "$ref": "#/definitions/gettableAlerts" }, "gettableSilence": { + "description": "GettableSilence gettable silence", "type": "object", "required": [ "comment", @@ -4187,8 +4189,6 @@ "x-go-name": "UpdatedAt" } }, - "x-go-name": "GettableSilence", - "x-go-package": "github.com/prometheus/alertmanager/api/v2/models", "$ref": "#/definitions/gettableSilence" }, "gettableSilences": { @@ -4371,7 +4371,6 @@ "$ref": "#/definitions/postableSilence" }, "receiver": { - "description": "Receiver receiver", "type": "object", "required": [ "name" @@ -4383,6 +4382,8 @@ "x-go-name": "Name" } }, + "x-go-name": "Receiver", + "x-go-package": "github.com/prometheus/alertmanager/api/v2/models", "$ref": "#/definitions/receiver" }, "silence": { diff --git a/pkg/services/ngalert/api/tooling/swagger-codegen/templates/controller-api.mustache b/pkg/services/ngalert/api/tooling/swagger-codegen/templates/controller-api.mustache index 47b3690e67a..be0ff5487dc 100644 --- a/pkg/services/ngalert/api/tooling/swagger-codegen/templates/controller-api.mustache +++ b/pkg/services/ngalert/api/tooling/swagger-codegen/templates/controller-api.mustache @@ -13,15 +13,33 @@ import ( "github.com/grafana/grafana/pkg/middleware" ) +type {{classname}}ForkingService interface { {{#operation}} + {{nickname}}(*models.ReqContext) response.Response{{/operation}} +} + type {{classname}}Service interface { {{#operation}} {{nickname}}(*models.ReqContext{{#bodyParams}}, apimodels.{{dataType}}{{/bodyParams}}) response.Response{{/operation}} } -func (api *API) Register{{classname}}Endpoints(srv {{classname}}Service, m *metrics.API) { +{{#operations}}{{#operation}} +func (f *Forked{{classname}}) {{nickname}}(ctx *models.ReqContext) response.Response { + {{#bodyParams}} + conf := apimodels.{{dataType}}{} + if err := web.Bind(ctx.Req, &conf); err != nil { + return response.Error(http.StatusBadRequest, "bad request data", err) + } + return f.fork{{nickname}}(ctx, conf) + {{/bodyParams}} + {{^bodyParams}} + return f.fork{{nickname}}(ctx) + {{/bodyParams}} +} +{{/operation}}{{/operations}} + +func (api *API) Register{{classname}}Endpoints(srv {{classname}}ForkingService, m *metrics.API) { api.RouteRegister.Group("", func(group routing.RouteRegister){ {{#operations}}{{#operation}} group.{{httpMethod}}( - toMacaronPath("{{{path}}}"){{#bodyParams}}, - binding.Bind(apimodels.{{dataType}}{}){{/bodyParams}}, + toMacaronPath("{{{path}}}"), metrics.Instrument( http.Method{{httpMethod}}, "{{{path}}}", @@ -31,4 +49,4 @@ func (api *API) Register{{classname}}Endpoints(srv {{classname}}Service, m *metr ){{/operation}}{{/operations}} }, middleware.ReqSignedIn) }{{#operation}} -{{/operation}}{{/operations}} +{{/operation}}{{/operations}} \ No newline at end of file