diff --git a/pkg/services/ngalert/api/api.go b/pkg/services/ngalert/api/api.go index 64ac0ed1501..8056a453342 100644 --- a/pkg/services/ngalert/api/api.go +++ b/pkg/services/ngalert/api/api.go @@ -93,19 +93,19 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) { } // Register endpoints for proxying to Alertmanager-compatible backends. - api.RegisterAlertmanagerApiEndpoints(NewForkedAM( + api.RegisterAlertmanagerApiEndpoints(NewForkingAM( api.DatasourceCache, NewLotexAM(proxy, logger), &AlertmanagerSrv{crypto: api.MultiOrgAlertmanager.Crypto, log: logger, ac: api.AccessControl, mam: api.MultiOrgAlertmanager}, ), m) // Register endpoints for proxying to Prometheus-compatible backends. - api.RegisterPrometheusApiEndpoints(NewForkedProm( + api.RegisterPrometheusApiEndpoints(NewForkingProm( api.DatasourceCache, NewLotexProm(proxy, logger), &PrometheusSrv{log: logger, manager: api.StateManager, store: api.RuleStore, ac: api.AccessControl}, ), m) // Register endpoints for proxying to Cortex Ruler-compatible backends. - api.RegisterRulerApiEndpoints(NewForkedRuler( + api.RegisterRulerApiEndpoints(NewForkingRuler( api.DatasourceCache, NewLotexRuler(proxy, logger), &RulerSrv{ @@ -120,7 +120,7 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) { ac: api.AccessControl, }, ), m) - api.RegisterTestingApiEndpoints(NewForkedTestingApi( + api.RegisterTestingApiEndpoints(NewTestingApi( &TestingApiSrv{ AlertingProxy: proxy, DatasourceCache: api.DatasourceCache, @@ -128,15 +128,15 @@ func (api *API) RegisterAPIEndpoints(m *metrics.API) { accessControl: api.AccessControl, evaluator: eval.NewEvaluator(api.Cfg, log.New("ngalert.eval"), api.DatasourceCache, api.SecretsService, api.ExpressionService), }), m) - api.RegisterConfigurationApiEndpoints(NewForkedConfiguration( - &AdminSrv{ + api.RegisterConfigurationApiEndpoints(NewConfiguration( + &ConfigSrv{ store: api.AdminConfigStore, log: logger, alertmanagerProvider: api.AlertsRouter, }, ), m) - api.RegisterProvisioningApiEndpoints(NewForkedProvisioningApi(&ProvisioningSrv{ + api.RegisterProvisioningApiEndpoints(NewProvisioningApi(&ProvisioningSrv{ log: logger, policies: api.Policies, contactPointService: api.ContactPointService, diff --git a/pkg/services/ngalert/api/api_admin.go b/pkg/services/ngalert/api/api_configuration.go similarity index 88% rename from pkg/services/ngalert/api/api_admin.go rename to pkg/services/ngalert/api/api_configuration.go index e3f33f221dd..3e1ab1dd84d 100644 --- a/pkg/services/ngalert/api/api_admin.go +++ b/pkg/services/ngalert/api/api_configuration.go @@ -15,13 +15,13 @@ import ( v1 "github.com/prometheus/client_golang/api/prometheus/v1" ) -type AdminSrv struct { +type ConfigSrv struct { alertmanagerProvider ExternalAlertmanagerProvider store store.AdminConfigurationStore 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) droppedURLs := srv.alertmanagerProvider.DroppedAlertmanagersFor(c.OrgId) 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 { return accessForbiddenResp() } @@ -61,7 +61,7 @@ func (srv AdminSrv) RouteGetNGalertConfig(c *models.ReqContext) response.Respons 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 { 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"}) } -func (srv AdminSrv) RouteDeleteNGalertConfig(c *models.ReqContext) response.Response { +func (srv ConfigSrv) RouteDeleteNGalertConfig(c *models.ReqContext) response.Response { if c.OrgRole != models.ROLE_ADMIN { return accessForbiddenResp() } diff --git a/pkg/services/ngalert/api/configuration.go b/pkg/services/ngalert/api/configuration.go new file mode 100644 index 00000000000..070025e51ea --- /dev/null +++ b/pkg/services/ngalert/api/configuration.go @@ -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) +} diff --git a/pkg/services/ngalert/api/forked_admin.go b/pkg/services/ngalert/api/forked_admin.go deleted file mode 100644 index 00c7b421546..00000000000 --- a/pkg/services/ngalert/api/forked_admin.go +++ /dev/null @@ -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) -} diff --git a/pkg/services/ngalert/api/forked_provisioning.go b/pkg/services/ngalert/api/forked_provisioning.go deleted file mode 100644 index 28457980df8..00000000000 --- a/pkg/services/ngalert/api/forked_provisioning.go +++ /dev/null @@ -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) -} diff --git a/pkg/services/ngalert/api/forked_testing.go b/pkg/services/ngalert/api/forked_testing.go deleted file mode 100644 index 6b41961e770..00000000000 --- a/pkg/services/ngalert/api/forked_testing.go +++ /dev/null @@ -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) -} diff --git a/pkg/services/ngalert/api/forked_am.go b/pkg/services/ngalert/api/forking_alertmanager.go similarity index 50% rename from pkg/services/ngalert/api/forked_am.go rename to pkg/services/ngalert/api/forking_alertmanager.go index 28ad7442f7d..32c835217af 100644 --- a/pkg/services/ngalert/api/forked_am.go +++ b/pkg/services/ngalert/api/forking_alertmanager.go @@ -9,22 +9,22 @@ import ( apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" ) -type ForkedAlertmanagerApi struct { +type AlertmanagerApiHandler struct { AMSvc *LotexAM GrafanaSvc *AlertmanagerSrv DatasourceCache datasources.CacheService } -// NewForkedAM implements a set of routes that proxy to various Alertmanager-compatible backends. -func NewForkedAM(datasourceCache datasources.CacheService, proxy *LotexAM, grafana *AlertmanagerSrv) *ForkedAlertmanagerApi { - return &ForkedAlertmanagerApi{ +// NewForkingAM implements a set of routes that proxy to various Alertmanager-compatible backends. +func NewForkingAM(datasourceCache datasources.CacheService, proxy *LotexAM, grafana *AlertmanagerSrv) *AlertmanagerApiHandler { + return &AlertmanagerApiHandler{ AMSvc: proxy, GrafanaSvc: grafana, 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) if err != nil { 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) if err != nil { return response.Error(400, err.Error(), nil) @@ -47,7 +47,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAMStatus(ctx *models.ReqContext, dsU 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) if err != nil { return ErrResp(400, err, "") @@ -56,7 +56,7 @@ func (f *ForkedAlertmanagerApi) forkRouteCreateSilence(ctx *models.ReqContext, b 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) if err != nil { return ErrResp(400, err, "") @@ -65,7 +65,7 @@ func (f *ForkedAlertmanagerApi) forkRouteDeleteAlertingConfig(ctx *models.ReqCon 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) if err != nil { return ErrResp(400, err, "") @@ -74,7 +74,7 @@ func (f *ForkedAlertmanagerApi) forkRouteDeleteSilence(ctx *models.ReqContext, s 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) if err != nil { return ErrResp(400, err, "") @@ -83,7 +83,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAlertingConfig(ctx *models.ReqContex 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) if err != nil { return ErrResp(400, err, "") @@ -92,7 +92,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAMAlertGroups(ctx *models.ReqContext 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) if err != nil { return ErrResp(400, err, "") @@ -101,7 +101,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetAMAlerts(ctx *models.ReqContext, dsU 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) if err != nil { return ErrResp(400, err, "") @@ -110,7 +110,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetSilence(ctx *models.ReqContext, sile 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) if err != nil { return ErrResp(400, err, "") @@ -119,7 +119,7 @@ func (f *ForkedAlertmanagerApi) forkRouteGetSilences(ctx *models.ReqContext, dsU 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) if err != nil { return ErrResp(400, err, "") @@ -137,7 +137,7 @@ func (f *ForkedAlertmanagerApi) forkRoutePostAlertingConfig(ctx *models.ReqConte 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) if err != nil { return ErrResp(400, err, "") @@ -146,7 +146,7 @@ func (f *ForkedAlertmanagerApi) forkRoutePostAMAlerts(ctx *models.ReqContext, bo 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) if err != nil { return ErrResp(400, err, "") @@ -155,50 +155,50 @@ func (f *ForkedAlertmanagerApi) forkRoutePostTestReceivers(ctx *models.ReqContex 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) } -func (f *ForkedAlertmanagerApi) forkRouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { +func (f *AlertmanagerApiHandler) handleRouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { 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) } -func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response { +func (f *AlertmanagerApiHandler) handleRouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response { 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) } -func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response { +func (f *AlertmanagerApiHandler) handleRouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response { 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) } -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) } -func (f *ForkedAlertmanagerApi) forkRouteGetGrafanaSilences(ctx *models.ReqContext) response.Response { +func (f *AlertmanagerApiHandler) handleRouteGetGrafanaSilences(ctx *models.ReqContext) response.Response { 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) } -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) } -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) } diff --git a/pkg/services/ngalert/api/forked_prom.go b/pkg/services/ngalert/api/forking_prometheus.go similarity index 60% rename from pkg/services/ngalert/api/forked_prom.go rename to pkg/services/ngalert/api/forking_prometheus.go index 7009969c43a..c192e696de6 100644 --- a/pkg/services/ngalert/api/forked_prom.go +++ b/pkg/services/ngalert/api/forking_prometheus.go @@ -9,22 +9,22 @@ import ( apimodels "github.com/grafana/grafana/pkg/services/ngalert/api/tooling/definitions" ) -type ForkedPrometheusApi struct { +type PrometheusApiHandler struct { ProxySvc *LotexProm GrafanaSvc *PrometheusSrv DatasourceCache datasources.CacheService } -// NewForkedProm implements a set of routes that proxy to various Prometheus-compatible backends. -func NewForkedProm(datasourceCache datasources.CacheService, proxy *LotexProm, grafana *PrometheusSrv) *ForkedPrometheusApi { - return &ForkedPrometheusApi{ +// NewForkingProm implements a set of routes that proxy to various Prometheus-compatible backends. +func NewForkingProm(datasourceCache datasources.CacheService, proxy *LotexProm, grafana *PrometheusSrv) *PrometheusApiHandler { + return &PrometheusApiHandler{ ProxySvc: proxy, GrafanaSvc: grafana, 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) if err != nil { 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) if err != nil { 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) } -func (f *ForkedPrometheusApi) forkRouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response { +func (f *PrometheusApiHandler) handleRouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response { return f.GrafanaSvc.RouteGetRuleStatuses(ctx) } diff --git a/pkg/services/ngalert/api/fork_ruler.go b/pkg/services/ngalert/api/forking_ruler.go similarity index 64% rename from pkg/services/ngalert/api/fork_ruler.go rename to pkg/services/ngalert/api/forking_ruler.go index 739370d3a04..44b06c85a4f 100644 --- a/pkg/services/ngalert/api/fork_ruler.go +++ b/pkg/services/ngalert/api/forking_ruler.go @@ -9,23 +9,22 @@ import ( 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. -type ForkedRulerApi struct { +// RulerApiHandler will validate and proxy requests to the correct backend type depending on the datasource. +type RulerApiHandler struct { LotexRuler *LotexRuler GrafanaRuler *RulerSrv DatasourceCache datasources.CacheService } -// NewForkedRuler implements a set of routes that proxy to various Cortex Ruler-compatible backends. -func NewForkedRuler(datasourceCache datasources.CacheService, lotex *LotexRuler, grafana *RulerSrv) *ForkedRulerApi { - return &ForkedRulerApi{ +func NewForkingRuler(datasourceCache datasources.CacheService, lotex *LotexRuler, grafana *RulerSrv) *RulerApiHandler { + return &RulerApiHandler{ LotexRuler: lotex, GrafanaRuler: grafana, 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) if err != nil { 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) if err != nil { 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) if err != nil { 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) if err != nil { 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) if err != nil { 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) if err != nil { 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, "") } -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) } -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) } -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) } -func (f *ForkedRulerApi) forkRouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response { +func (f *RulerApiHandler) handleRouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response { 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() if payloadType != apimodels.GrafanaBackend { return ErrResp(400, fmt.Errorf("unexpected backend type (%v) vs payload type (%v)", apimodels.GrafanaBackend, payloadType), "") diff --git a/pkg/services/ngalert/api/generated_base_api_alertmanager.go b/pkg/services/ngalert/api/generated_base_api_alertmanager.go index c983f3f85fd..21f1c3cdc64 100644 --- a/pkg/services/ngalert/api/generated_base_api_alertmanager.go +++ b/pkg/services/ngalert/api/generated_base_api_alertmanager.go @@ -18,7 +18,7 @@ import ( "github.com/grafana/grafana/pkg/web" ) -type AlertmanagerApiForkingService interface { +type AlertmanagerApi interface { RouteCreateGrafanaSilence(*models.ReqContext) response.Response RouteCreateSilence(*models.ReqContext) response.Response RouteDeleteAlertingConfig(*models.ReqContext) response.Response @@ -45,128 +45,150 @@ type AlertmanagerApiForkingService interface { 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body 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, 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"] - return f.forkRouteDeleteAlertingConfig(ctx, datasourceUIDParam) + return f.handleRouteDeleteAlertingConfig(ctx, datasourceUIDParam) } -func (f *ForkedAlertmanagerApi) RouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { - return f.forkRouteDeleteGrafanaAlertingConfig(ctx) +func (f *AlertmanagerApiHandler) RouteDeleteGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { + 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"] - 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"] 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"] - 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"] - 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"] - 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"] - return f.forkRouteGetAlertingConfig(ctx, datasourceUIDParam) + return f.handleRouteGetAlertingConfig(ctx, datasourceUIDParam) } -func (f *ForkedAlertmanagerApi) RouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaAMAlertGroups(ctx) +func (f *AlertmanagerApiHandler) RouteGetGrafanaAMAlertGroups(ctx *models.ReqContext) response.Response { + return f.handleRouteGetGrafanaAMAlertGroups(ctx) } -func (f *ForkedAlertmanagerApi) RouteGetGrafanaAMAlerts(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaAMAlerts(ctx) +func (f *AlertmanagerApiHandler) RouteGetGrafanaAMAlerts(ctx *models.ReqContext) response.Response { + return f.handleRouteGetGrafanaAMAlerts(ctx) } -func (f *ForkedAlertmanagerApi) RouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaAMStatus(ctx) +func (f *AlertmanagerApiHandler) RouteGetGrafanaAMStatus(ctx *models.ReqContext) response.Response { + return f.handleRouteGetGrafanaAMStatus(ctx) } -func (f *ForkedAlertmanagerApi) RouteGetGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaAlertingConfig(ctx) +func (f *AlertmanagerApiHandler) RouteGetGrafanaAlertingConfig(ctx *models.ReqContext) response.Response { + 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"] - return f.forkRouteGetGrafanaSilence(ctx, silenceIdParam) + return f.handleRouteGetGrafanaSilence(ctx, silenceIdParam) } -func (f *ForkedAlertmanagerApi) RouteGetGrafanaSilences(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaSilences(ctx) +func (f *AlertmanagerApiHandler) RouteGetGrafanaSilences(ctx *models.ReqContext) response.Response { + 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"] 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"] - 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"] + // Parse Request Body 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, 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"] + // Parse Request Body 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, 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body 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, 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) { group.Post( toMacaronPath("/api/alertmanager/grafana/api/v2/silences"), diff --git a/pkg/services/ngalert/api/generated_base_api_configuration.go b/pkg/services/ngalert/api/generated_base_api_configuration.go index 084c27dec82..d4b1788082e 100644 --- a/pkg/services/ngalert/api/generated_base_api_configuration.go +++ b/pkg/services/ngalert/api/generated_base_api_configuration.go @@ -18,31 +18,32 @@ import ( "github.com/grafana/grafana/pkg/web" ) -type ConfigurationApiForkingService interface { +type ConfigurationApi interface { RouteDeleteNGalertConfig(*models.ReqContext) response.Response RouteGetAlertmanagers(*models.ReqContext) response.Response RouteGetNGalertConfig(*models.ReqContext) response.Response RoutePostNGalertConfig(*models.ReqContext) response.Response } -func (f *ForkedConfigurationApi) RouteDeleteNGalertConfig(ctx *models.ReqContext) response.Response { - return f.forkRouteDeleteNGalertConfig(ctx) +func (f *ConfigurationApiHandler) RouteDeleteNGalertConfig(ctx *models.ReqContext) response.Response { + return f.handleRouteDeleteNGalertConfig(ctx) } -func (f *ForkedConfigurationApi) RouteGetAlertmanagers(ctx *models.ReqContext) response.Response { - return f.forkRouteGetAlertmanagers(ctx) +func (f *ConfigurationApiHandler) RouteGetAlertmanagers(ctx *models.ReqContext) response.Response { + return f.handleRouteGetAlertmanagers(ctx) } -func (f *ForkedConfigurationApi) RouteGetNGalertConfig(ctx *models.ReqContext) response.Response { - return f.forkRouteGetNGalertConfig(ctx) +func (f *ConfigurationApiHandler) RouteGetNGalertConfig(ctx *models.ReqContext) response.Response { + 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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) { group.Delete( toMacaronPath("/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 f9018b7b6ff..05297027bc3 100644 --- a/pkg/services/ngalert/api/generated_base_api_prometheus.go +++ b/pkg/services/ngalert/api/generated_base_api_prometheus.go @@ -17,29 +17,31 @@ import ( "github.com/grafana/grafana/pkg/web" ) -type PrometheusApiForkingService interface { +type PrometheusApi interface { RouteGetAlertStatuses(*models.ReqContext) response.Response RouteGetGrafanaAlertStatuses(*models.ReqContext) response.Response RouteGetGrafanaRuleStatuses(*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"] - return f.forkRouteGetAlertStatuses(ctx, datasourceUIDParam) + return f.handleRouteGetAlertStatuses(ctx, datasourceUIDParam) } -func (f *ForkedPrometheusApi) RouteGetGrafanaAlertStatuses(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaAlertStatuses(ctx) +func (f *PrometheusApiHandler) RouteGetGrafanaAlertStatuses(ctx *models.ReqContext) response.Response { + return f.handleRouteGetGrafanaAlertStatuses(ctx) } -func (f *ForkedPrometheusApi) RouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response { - return f.forkRouteGetGrafanaRuleStatuses(ctx) +func (f *PrometheusApiHandler) RouteGetGrafanaRuleStatuses(ctx *models.ReqContext) response.Response { + 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"] - 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) { group.Get( toMacaronPath("/api/prometheus/{DatasourceUID}/api/v1/alerts"), diff --git a/pkg/services/ngalert/api/generated_base_api_provisioning.go b/pkg/services/ngalert/api/generated_base_api_provisioning.go index e3efd6a1713..484524672b1 100644 --- a/pkg/services/ngalert/api/generated_base_api_provisioning.go +++ b/pkg/services/ngalert/api/generated_base_api_provisioning.go @@ -18,7 +18,7 @@ import ( "github.com/grafana/grafana/pkg/web" ) -type ProvisioningApiForkingService interface { +type ProvisioningApi interface { RouteDeleteAlertRule(*models.ReqContext) response.Response RouteDeleteContactpoints(*models.ReqContext) response.Response RouteDeleteMuteTiming(*models.ReqContext) response.Response @@ -43,125 +43,147 @@ type ProvisioningApiForkingService interface { 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"] - 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"] - 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"] - 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"] - 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"] - 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"] 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 { - return f.forkRouteGetContactpoints(ctx) +func (f *ProvisioningApiHandler) RouteGetContactpoints(ctx *models.ReqContext) response.Response { + 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"] - return f.forkRouteGetMuteTiming(ctx, nameParam) + return f.handleRouteGetMuteTiming(ctx, nameParam) } -func (f *ForkedProvisioningApi) RouteGetMuteTimings(ctx *models.ReqContext) response.Response { - return f.forkRouteGetMuteTimings(ctx) +func (f *ProvisioningApiHandler) RouteGetMuteTimings(ctx *models.ReqContext) response.Response { + return f.handleRouteGetMuteTimings(ctx) } -func (f *ForkedProvisioningApi) RouteGetPolicyTree(ctx *models.ReqContext) response.Response { - return f.forkRouteGetPolicyTree(ctx) +func (f *ProvisioningApiHandler) RouteGetPolicyTree(ctx *models.ReqContext) response.Response { + 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"] - return f.forkRouteGetTemplate(ctx, nameParam) + return f.handleRouteGetTemplate(ctx, nameParam) } -func (f *ForkedProvisioningApi) RouteGetTemplates(ctx *models.ReqContext) response.Response { - return f.forkRouteGetTemplates(ctx) +func (f *ProvisioningApiHandler) RouteGetTemplates(ctx *models.ReqContext) response.Response { + 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body conf := apimodels.ProvisionedAlertRule{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] groupParam := web.Params(ctx.Req)[":Group"] + // Parse Request Body conf := apimodels.AlertRuleGroupMetadata{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body conf := apimodels.EmbeddedContactPoint{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body conf := apimodels.MuteTimeInterval{} if err := web.Bind(ctx.Req, &conf); err != nil { 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body conf := apimodels.MessageTemplateContent{} if err := web.Bind(ctx.Req, &conf); err != nil { 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 { - return f.forkRouteResetPolicyTree(ctx) +func (f *ProvisioningApiHandler) RouteResetPolicyTree(ctx *models.ReqContext) response.Response { + 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) { group.Delete( toMacaronPath("/api/v1/provisioning/alert-rules/{UID}"), diff --git a/pkg/services/ngalert/api/generated_base_api_ruler.go b/pkg/services/ngalert/api/generated_base_api_ruler.go index 3c2ac808b9b..ac584615874 100644 --- a/pkg/services/ngalert/api/generated_base_api_ruler.go +++ b/pkg/services/ngalert/api/generated_base_api_ruler.go @@ -18,7 +18,7 @@ import ( "github.com/grafana/grafana/pkg/web" ) -type RulerApiForkingService interface { +type RulerApi interface { RouteDeleteGrafanaRuleGroupConfig(*models.ReqContext) response.Response RouteDeleteNamespaceGrafanaRulesConfig(*models.ReqContext) response.Response RouteDeleteNamespaceRulesConfig(*models.ReqContext) response.Response @@ -33,72 +33,85 @@ type RulerApiForkingService interface { 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"] 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"] - 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"] 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"] namespaceParam := web.Params(ctx.Req)[":Namespace"] 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"] 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 { - return f.forkRouteGetGrafanaRulesConfig(ctx) +func (f *RulerApiHandler) RouteGetGrafanaRulesConfig(ctx *models.ReqContext) response.Response { + 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"] - 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"] 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"] namespaceParam := web.Params(ctx.Req)[":Namespace"] 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"] - 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"] + // Parse Request Body conf := apimodels.PostableRuleGroupConfig{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] namespaceParam := web.Params(ctx.Req)[":Namespace"] + // Parse Request Body 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, 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) { group.Delete( toMacaronPath("/api/ruler/grafana/api/v1/rules/{Namespace}/{Groupname}"), diff --git a/pkg/services/ngalert/api/generated_base_api_testing.go b/pkg/services/ngalert/api/generated_base_api_testing.go index b181e73ba49..c25842a1e6f 100644 --- a/pkg/services/ngalert/api/generated_base_api_testing.go +++ b/pkg/services/ngalert/api/generated_base_api_testing.go @@ -18,36 +18,40 @@ import ( "github.com/grafana/grafana/pkg/web" ) -type TestingApiForkingService interface { +type TestingApi interface { RouteEvalQueries(*models.ReqContext) response.Response RouteTestRuleConfig(*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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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"] + // Parse Request Body 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, 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{} if err := web.Bind(ctx.Req, &conf); err != nil { 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) { group.Post( toMacaronPath("/api/v1/eval"), diff --git a/pkg/services/ngalert/api/provisioning.go b/pkg/services/ngalert/api/provisioning.go new file mode 100644 index 00000000000..192f8c1c3f0 --- /dev/null +++ b/pkg/services/ngalert/api/provisioning.go @@ -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) +} diff --git a/pkg/services/ngalert/api/testing_api.go b/pkg/services/ngalert/api/testing_api.go new file mode 100644 index 00000000000..7a84a1e1bf0 --- /dev/null +++ b/pkg/services/ngalert/api/testing_api.go @@ -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) +} diff --git a/pkg/services/ngalert/api/tooling/Makefile b/pkg/services/ngalert/api/tooling/Makefile index 279f0632116..2cf406d766e 100644 --- a/pkg/services/ngalert/api/tooling/Makefile +++ b/pkg/services/ngalert/api/tooling/Makefile @@ -65,4 +65,6 @@ serve: post.json serve-stable: api.json 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 diff --git a/pkg/services/ngalert/api/tooling/api.json b/pkg/services/ngalert/api/tooling/api.json index 4b5b7c14432..e59a028322e 100644 --- a/pkg/services/ngalert/api/tooling/api.json +++ b/pkg/services/ngalert/api/tooling/api.json @@ -2702,6 +2702,7 @@ "type": "object" }, "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": { "ForceQuery": { "type": "boolean" @@ -2734,7 +2735,7 @@ "$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" }, "Userinfo": { @@ -3295,6 +3296,7 @@ "type": "object" }, "receiver": { + "description": "Receiver receiver", "properties": { "name": { "description": "name", diff --git a/pkg/services/ngalert/api/tooling/spec.json b/pkg/services/ngalert/api/tooling/spec.json index 289e18c7b3f..19ec03f7f72 100644 --- a/pkg/services/ngalert/api/tooling/spec.json +++ b/pkg/services/ngalert/api/tooling/spec.json @@ -5289,6 +5289,7 @@ } }, "alertGroup": { + "description": "AlertGroup alert group", "type": "object", "required": [ "alerts", @@ -5487,7 +5488,6 @@ "$ref": "#/definitions/gettableAlerts" }, "gettableSilence": { - "description": "GettableSilence gettable silence", "type": "object", "required": [ "comment", @@ -5537,7 +5537,6 @@ "$ref": "#/definitions/gettableSilence" }, "gettableSilences": { - "description": "GettableSilences gettable silences", "type": "array", "items": { "$ref": "#/definitions/gettableSilence" @@ -5688,6 +5687,7 @@ "$ref": "#/definitions/postableSilence" }, "receiver": { + "description": "Receiver receiver", "type": "object", "required": [ "name" 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 0ab26e5596a..34dfce4f1ad 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,26 +13,25 @@ import ( "github.com/grafana/grafana/pkg/middleware" ) -type {{classname}}ForkingService interface { {{#operation}} +type {{classname}} interface { {{#operation}} {{nickname}}(*models.ReqContext) response.Response{{/operation}} } {{#operations}}{{#operation}} -func (f *Forked{{classname}}) {{nickname}}(ctx *models.ReqContext) response.Response { - {{#pathParams}} - {{paramName}}Param := web.Params(ctx.Req)[":{{baseName}}"] - {{/pathParams}} +func (f *{{classname}}Handler) {{nickname}}(ctx *models.ReqContext) response.Response { {{#hasPathParams}} + // Parse Path Parameters{{/hasPathParams}}{{#pathParams}} + {{paramName}}Param := web.Params(ctx.Req)[":{{baseName}}"]{{/pathParams}} {{#bodyParams}} + // Parse Request Body conf := apimodels.{{dataType}}{} if err := web.Bind(ctx.Req, &conf); err != nil { return response.Error(http.StatusBadRequest, "bad request data", err) } - {{/bodyParams}} - return f.fork{{nickname}}(ctx{{#bodyParams}}, conf{{/bodyParams}}{{#pathParams}}, {{paramName}}Param{{/pathParams}}) + {{/bodyParams}}return f.handle{{nickname}}(ctx{{#bodyParams}}, conf{{/bodyParams}}{{#pathParams}}, {{paramName}}Param{{/pathParams}}) } {{/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}} group.{{httpMethod}}( toMacaronPath("{{{path}}}"), @@ -46,4 +45,4 @@ func (api *API) Register{{classname}}Endpoints(srv {{classname}}ForkingService, ){{/operation}}{{/operations}} }, middleware.ReqSignedIn) }{{#operation}} -{{/operation}}{{/operations}} \ No newline at end of file +{{/operation}}{{/operations}}