Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 api.go // Copyright 2018 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package v2 import ( "errors" "fmt" "log/slog" "net/http" "regexp" "sort" "sync" "time" "github.com/go-openapi/analysis" "github.com/go-openapi/loads" "github.com/go-openapi/runtime/middleware" "github.com/go-openapi/strfmt" "github.com/prometheus/client_golang/prometheus" prometheus_model "github.com/prometheus/common/model" "github.com/prometheus/common/version" "github.com/rs/cors" "github.com/prometheus/alertmanager/api/metrics" open_api_models "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/api/v2/restapi" "github.com/prometheus/alertmanager/api/v2/restapi/operations" alert_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/alert" alertgroup_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/alertgroup" general_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/general" receiver_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/receiver" silence_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/silence" "github.com/prometheus/alertmanager/cluster" "github.com/prometheus/alertmanager/config" "github.com/prometheus/alertmanager/dispatch" "github.com/prometheus/alertmanager/matcher/compat" "github.com/prometheus/alertmanager/pkg/labels" "github.com/prometheus/alertmanager/provider" "github.com/prometheus/alertmanager/silence" "github.com/prometheus/alertmanager/silence/silencepb" "github.com/prometheus/alertmanager/types" ) // API represents an Alertmanager API v2. type API struct { peer cluster.ClusterPeer silences silence.Silences alerts provider.Alerts alertGroups groupsFn getAlertStatus getAlertStatusFn groupMutedFunc groupMutedFunc uptime time.Time // mtx protects alertmanagerConfig, setAlertStatus and route. mtx sync.RWMutex // resolveTimeout represents the default resolve timeout that an alert is // assigned if no end time is specified. alertmanagerConfig config.Config route dispatch.Route setAlertStatus setAlertStatusFn logger slog.Logger m metrics.Alerts Handler http.Handler } type ( groupsFn func(func(dispatch.Route) bool, func(types.Alert, time.Time) bool) (dispatch.AlertGroups, map[prometheus_model.Fingerprint][]string) groupMutedFunc func(routeID, groupKey string) ([]string, bool) getAlertStatusFn func(prometheus_model.Fingerprint) types.AlertStatus setAlertStatusFn func(prometheus_model.LabelSet) ) // NewAPI returns a new Alertmanager API v2. func NewAPI( alerts provider.Alerts, gf groupsFn, asf getAlertStatusFn, gmf groupMutedFunc, silences silence.Silences, peer cluster.ClusterPeer, l slog.Logger, r prometheus.Registerer, ) (API, error) { api := API{ alerts: alerts, getAlertStatus: asf, alertGroups: gf, groupMutedFunc: gmf, peer: peer, silences: silences, logger: l, m: metrics.NewAlerts(r), uptime: time.Now(), } // Load embedded swagger file. swaggerSpec, swaggerSpecAnalysis, err := getSwaggerSpec() if err != nil { return nil, err } // Create new service API. openAPI := operations.NewAlertmanagerAPI(swaggerSpec) // Skip the redoc middleware, only serving the OpenAPI specification and // the API itself via RoutesHandler. See: // https://github.com/go-swagger/go-swagger/issues/1779 openAPI.Middleware = func(b middleware.Builder) http.Handler { // Manually create the context so that we can use the singleton swaggerSpecAnalysis. swaggerContext := middleware.NewRoutableContextWithAnalyzedSpec(swaggerSpec, swaggerSpecAnalysis, openAPI, nil) return middleware.Spec("", swaggerSpec.Raw(), swaggerContext.RoutesHandler(b)) } openAPI.AlertGetAlertsHandler = alert_ops.GetAlertsHandlerFunc(api.getAlertsHandler) openAPI.AlertPostAlertsHandler = alert_ops.PostAlertsHandlerFunc(api.postAlertsHandler) openAPI.AlertgroupGetAlertGroupsHandler = alertgroup_ops.GetAlertGroupsHandlerFunc(api.getAlertGroupsHandler) openAPI.GeneralGetStatusHandler = general_ops.GetStatusHandlerFunc(api.getStatusHandler) openAPI.ReceiverGetReceiversHandler = receiver_ops.GetReceiversHandlerFunc(api.getReceiversHandler) openAPI.SilenceDeleteSilenceHandler = silence_ops.DeleteSilenceHandlerFunc(api.deleteSilenceHandler) openAPI.SilenceGetSilenceHandler = silence_ops.GetSilenceHandlerFunc(api.getSilenceHandler) openAPI.SilenceGetSilencesHandler = silence_ops.GetSilencesHandlerFunc(api.getSilencesHandler) openAPI.SilencePostSilencesHandler = silence_ops.PostSilencesHandlerFunc(api.postSilencesHandler) handleCORS := cors.Default().Handler api.Handler = handleCORS(setResponseHeaders(openAPI.Serve(nil))) return &api, nil } var responseHeaders = map[string]string{ "Cache-Control": "no-store", } func setResponseHeaders(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r http.Request) { for h, v := range responseHeaders { w.Header().Set(h, v) } h.ServeHTTP(w, r) }) } func (api API) requestLogger(req http.Request) slog.Logger { return api.logger.With("path", req.URL.Path, "method", req.Method) } // Update sets the API struct members that may change between reloads of alertmanager. func (api API) Update(cfg config.Config, setAlertStatus setAlertStatusFn) { api.mtx.Lock() defer api.mtx.Unlock() api.alertmanagerConfig = cfg api.route = dispatch.NewRoute(cfg.Route, nil) api.setAlertStatus = setAlertStatus } func (api API) getStatusHandler(params general_ops.GetStatusParams) middleware.Responder { api.mtx.RLock() defer api.mtx.RUnlock() original := api.alertmanagerConfig.String() uptime := strfmt.DateTime(api.uptime) status := open_api_models.ClusterStatusStatusDisabled resp := open_api_models.AlertmanagerStatus{ Uptime: &uptime, VersionInfo: &open_api_models.VersionInfo{ Version: &version.Version, Revision: &version.Revision, Branch: &version.Branch, BuildUser: &version.BuildUser, BuildDate: &version.BuildDate, GoVersion: &version.GoVersion, }, Config: &open_api_models.AlertmanagerConfig{ Original: &original, }, Cluster: &open_api_models.ClusterStatus{ Status: &status, Peers: []open_api_models.PeerStatus{}, }, } // If alertmanager cluster feature is disabled, then api.peers == nil. if api.peer != nil { status := api.peer.Status() peers := []open_api_models.PeerStatus{} for _, n := range api.peer.Peers() { address := n.Address() name := n.Name() peers = append(peers, &open_api_models.PeerStatus{ Name: &name, Address: &address, }) } sort.Slice(peers, func(i, j int) bool { return peers[i].Name < peers[j].Name }) resp.Cluster = &open_api_models.ClusterStatus{ Name: api.peer.Name(), Status: &status, Peers: peers, } } return general_ops.NewGetStatusOK().WithPayload(&resp) } func (api API) getReceiversHandler(params receiver_ops.GetReceiversParams) middleware.Responder { api.mtx.RLock() defer api.mtx.RUnlock() receivers := make([]open_api_models.Receiver, 0, len(api.alertmanagerConfig.Receivers)) for i := range api.alertmanagerConfig.Receivers { receivers = append(receivers, &open_api_models.Receiver{Name: &api.alertmanagerConfig.Receivers[i].Name}) } return receiver_ops.NewGetReceiversOK().WithPayload(receivers) } func (api API) getAlertsHandler(params alert_ops.GetAlertsParams) middleware.Responder { var ( receiverFilter regexp.Regexp // Initialize result slice to prevent api returning `null` when there // are no alerts present res = open_api_models.GettableAlerts{} ctx = params.HTTPRequest.Context() logger = api.requestLogger(params.HTTPRequest) ) matchers, err := parseFilter(params.Filter) if err != nil { logger.Debug("Failed to parse matchers", "err", err) return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error()) } if params.Receiver != nil { receiverFilter, err = regexp.Compile("^(?:" + params.Receiver + ")$") if err != nil { logger.Debug("Failed to compile receiver regex", "err", err) return alert_ops. NewGetAlertsBadRequest(). WithPayload( fmt.Sprintf("failed to parse receiver param: %v", err.Error()), ) } } alerts := api.alerts.GetPending() defer alerts.Close() alertFilter := api.alertFilter(matchers, params.Silenced, params.Inhibited, params.Active) now := time.Now() api.mtx.RLock() for a := range alerts.Next() { if err = alerts.Err(); err != nil { break } if err = ctx.Err(); err != nil { break } routes := api.route.Match(a.Labels) receivers := make([]string, 0, len(routes)) for _, r := range routes { receivers = append(receivers, r.RouteOpts.Receiver) } if receiverFilter != nil && !receiversMatchFilter(receivers, receiverFilter) { continue } if !alertFilter(a, now) { continue } alert := AlertToOpenAPIAlert(a, api.getAlertStatus(a.Fingerprint()), receivers, nil) res = append(res, alert) } api.mtx.RUnlock() if err != nil { logger.Error("Failed to get alerts", "err", err) return alert_ops.NewGetAlertsInternalServerError().WithPayload(err.Error()) } sort.Slice(res, func(i, j int) bool { return res[i].Fingerprint < res[j].Fingerprint }) return alert_ops.NewGetAlertsOK().WithPayload(res) } func (api API) postAlertsHandler(params alert_ops.PostAlertsParams) middleware.Responder { logger := api.requestLogger(params.HTTPRequest) alerts := OpenAPIAlertsToAlerts(params.Alerts) now := time.Now() api.mtx.RLock() resolveTimeout := time.Duration(api.alertmanagerConfig.Global.ResolveTimeout) api.mtx.RUnlock() for _, alert := range alerts { alert.UpdatedAt = now // Ensure StartsAt is set. if alert.StartsAt.IsZero() { if alert.EndsAt.IsZero() { alert.StartsAt = now } else { alert.StartsAt = alert.EndsAt } } // If no end time is defined, set a timeout after which an alert // is marked resolved if it is not updated. if alert.EndsAt.IsZero() { alert.Timeout = true alert.EndsAt = now.Add(resolveTimeout) } if alert.EndsAt.After(time.Now()) { api.m.Firing().Inc() } else { api.m.Resolved().Inc() } } // Make a best effort to insert all alerts that are valid. var ( validAlerts = make([]types.Alert, 0, len(alerts)) validationErrs = &types.MultiError{} ) for _, a := range alerts { removeEmptyLabels(a.Labels) if err := a.Validate(); err != nil { validationErrs.Add(err) api.m.Invalid().Inc() continue } validAlerts = append(validAlerts, a) } if err := api.alerts.Put(validAlerts...); err != nil { logger.Error("Failed to create alerts", "err", err) return alert_ops.NewPostAlertsInternalServerError().WithPayload(err.Error()) } if validationErrs.Len() > 0 { logger.Error("Failed to validate alerts", "err", validationErrs.Error()) return alert_ops.NewPostAlertsBadRequest().WithPayload(validationErrs.Error()) } return alert_ops.NewPostAlertsOK() } func (api API) getAlertGroupsHandler(params alertgroup_ops.GetAlertGroupsParams) middleware.Responder { logger := api.requestLogger(params.HTTPRequest) matchers, err := parseFilter(params.Filter) if err != nil { logger.Debug("Failed to parse matchers", "err", err) return alertgroup_ops.NewGetAlertGroupsBadRequest().WithPayload(err.Error()) } var receiverFilter regexp.Regexp if params.Receiver != nil { receiverFilter, err = regexp.Compile("^(?:" + params.Receiver + ")$") if err != nil { logger.Error("Failed to compile receiver regex", "err", err) return alertgroup_ops. NewGetAlertGroupsBadRequest(). WithPayload( fmt.Sprintf("failed to parse receiver param: %v", err.Error()), ) } } rf := func(receiverFilter regexp.Regexp) func(r dispatch.Route) bool { return func(r dispatch.Route) bool { receiver := r.RouteOpts.Receiver if receiverFilter != nil && !receiverFilter.MatchString(receiver) { return false } return true } }(receiverFilter) af := api.alertFilter(matchers, params.Silenced, params.Inhibited, params.Active) alertGroups, allReceivers := api.alertGroups(rf, af) res := make(open_api_models.AlertGroups, 0, len(alertGroups)) for _, alertGroup := range alertGroups { mutedBy, isMuted := api.groupMutedFunc(alertGroup.RouteID, alertGroup.GroupKey) if !params.Muted && isMuted { continue } ag := &open_api_models.AlertGroup{ Receiver: &open_api_models.Receiver{Name: &alertGroup.Receiver}, Labels: ModelLabelSetToAPILabelSet(alertGroup.Labels), Alerts: make([]open_api_models.GettableAlert, 0, len(alertGroup.Alerts)), } for _, alert := range alertGroup.Alerts { fp := alert.Fingerprint() receivers := allReceivers[fp] status := api.getAlertStatus(fp) apiAlert := AlertToOpenAPIAlert(alert, status, receivers, mutedBy) ag.Alerts = append(ag.Alerts, apiAlert) } res = append(res, ag) } return alertgroup_ops.NewGetAlertGroupsOK().WithPayload(res) } func (api API) alertFilter(matchers []labels.Matcher, silenced, inhibited, active bool) func(a types.Alert, now time.Time) bool { return func(a types.Alert, now time.Time) bool { if !a.EndsAt.IsZero() && a.EndsAt.Before(now) { return false } // Set alert's current status based on its label set. api.setAlertStatus(a.Labels) // Get alert's current status after seeing if it is suppressed. status := api.getAlertStatus(a.Fingerprint()) if !active && status.State == types.AlertStateActive { return false } if !silenced && len(status.SilencedBy) != 0 { return false } if !inhibited && len(status.InhibitedBy) != 0 { return false } return alertMatchesFilterLabels(&a.Alert, matchers) } } func removeEmptyLabels(ls prometheus_model.LabelSet) { for k, v := range ls { if string(v) == "" { delete(ls, k) } } } func receiversMatchFilter(receivers []string, filter regexp.Regexp) bool { for _, r := range receivers { if filter.MatchString(r) { return true } } return false } func alertMatchesFilterLabels(a prometheus_model.Alert, matchers []labels.Matcher) bool { sms := make(map[string]string) for name, value := range a.Labels { sms[string(name)] = string(value) } return matchFilterLabels(matchers, sms) } func matchFilterLabels(matchers []labels.Matcher, sms map[string]string) bool { for _, m := range matchers { v, prs := sms[m.Name] switch m.Type { case labels.MatchNotRegexp, labels.MatchNotEqual: if m.Value == "" && prs { continue } if !m.Matches(v) { return false } default: if m.Value == "" && !prs { continue } if !m.Matches(v) { return false } } } return true } func (api API) getSilencesHandler(params silence_ops.GetSilencesParams) middleware.Responder { logger := api.requestLogger(params.HTTPRequest) matchers, err := parseFilter(params.Filter) if err != nil { logger.Debug("Failed to parse matchers", "err", err) return silence_ops.NewGetSilencesBadRequest().WithPayload(err.Error()) } psils, _, err := api.silences.Query() if err != nil { logger.Error("Failed to get silences", "err", err) return silence_ops.NewGetSilencesInternalServerError().WithPayload(err.Error()) } sils := open_api_models.GettableSilences{} for _, ps := range psils { if !CheckSilenceMatchesFilterLabels(ps, matchers) { continue } silence, err := GettableSilenceFromProto(ps) if err != nil { logger.Error("Failed to unmarshal silence from proto", "err", err) return silence_ops.NewGetSilencesInternalServerError().WithPayload(err.Error()) } sils = append(sils, &silence) } SortSilences(sils) return silence_ops.NewGetSilencesOK().WithPayload(sils) } var silenceStateOrder = map[types.SilenceState]int{ types.SilenceStateActive: 1, types.SilenceStatePending: 2, types.SilenceStateExpired: 3, } // SortSilences sorts first according to the state "active, pending, expired" // then by end time or start time depending on the state. // Active silences should show the next to expire first // pending silences are ordered based on which one starts next // expired are ordered based on which one expired most recently. func SortSilences(sils open_api_models.GettableSilences) { sort.Slice(sils, func(i, j int) bool { state1 := types.SilenceState(sils[i].Status.State) state2 := types.SilenceState(sils[j].Status.State) if state1 != state2 { return silenceStateOrder[state1] < silenceStateOrder[state2] } switch state1 { case types.SilenceStateActive: endsAt1 := time.Time(sils[i].Silence.EndsAt) endsAt2 := time.Time(sils[j].Silence.EndsAt) return endsAt1.Before(endsAt2) case types.SilenceStatePending: startsAt1 := time.Time(sils[i].Silence.StartsAt) startsAt2 := time.Time(sils[j].Silence.StartsAt) return startsAt1.Before(startsAt2) case types.SilenceStateExpired: endsAt1 := time.Time(sils[i].Silence.EndsAt) endsAt2 := time.Time(sils[j].Silence.EndsAt) return endsAt1.After(endsAt2) } return false }) } // CheckSilenceMatchesFilterLabels returns true if // a given silence matches a list of matchers. // A silence matches a filter (list of matchers) if // for all matchers in the filter, there exists a matcher in the silence // such that their names, types, and values are equivalent. func CheckSilenceMatchesFilterLabels(s silencepb.Silence, matchers []labels.Matcher) bool { for _, matcher := range matchers { found := false for _, m := range s.Matchers { if matcher.Name == m.Name && (matcher.Type == labels.MatchEqual && m.Type == silencepb.Matcher_EQUAL \|\| matcher.Type == labels.MatchRegexp && m.Type == silencepb.Matcher_REGEXP \|\| matcher.Type == labels.MatchNotEqual && m.Type == silencepb.Matcher_NOT_EQUAL \|\| matcher.Type == labels.MatchNotRegexp && m.Type == silencepb.Matcher_NOT_REGEXP) && matcher.Value == m.Pattern { found = true break } } if !found { return false } } return true } func (api API) getSilenceHandler(params silence_ops.GetSilenceParams) middleware.Responder { logger := api.requestLogger(params.HTTPRequest) sils, _, err := api.silences.Query(silence.QIDs(params.SilenceID.String())) if err != nil { logger.Error("Failed to get silence by id", "err", err, "id", params.SilenceID.String()) return silence_ops.NewGetSilenceInternalServerError().WithPayload(err.Error()) } if len(sils) == 0 { logger.Error("Failed to find silence", "err", err, "id", params.SilenceID.String()) return silence_ops.NewGetSilenceNotFound() } sil, err := GettableSilenceFromProto(sils[0]) if err != nil { logger.Error("Failed to convert unmarshal from proto", "err", err) return silence_ops.NewGetSilenceInternalServerError().WithPayload(err.Error()) } return silence_ops.NewGetSilenceOK().WithPayload(&sil) } func (api API) deleteSilenceHandler(params silence_ops.DeleteSilenceParams) middleware.Responder { logger := api.requestLogger(params.HTTPRequest) sid := params.SilenceID.String() if err := api.silences.Expire(sid); err != nil { logger.Error("Failed to expire silence", "err", err) if errors.Is(err, silence.ErrNotFound) { return silence_ops.NewDeleteSilenceNotFound() } return silence_ops.NewDeleteSilenceInternalServerError().WithPayload(err.Error()) } return silence_ops.NewDeleteSilenceOK() } func (api API) postSilencesHandler(params silence_ops.PostSilencesParams) middleware.Responder { logger := api.requestLogger(params.HTTPRequest) sil, err := PostableSilenceToProto(params.Silence) if err != nil { logger.Error("Failed to marshal silence to proto", "err", err) return silence_ops.NewPostSilencesBadRequest().WithPayload( fmt.Sprintf("failed to convert API silence to internal silence: %v", err.Error()), ) } if sil.StartsAt.After(sil.EndsAt) \|\| sil.StartsAt.Equal(sil.EndsAt) { msg := "Failed to create silence: start time must be before end time" logger.Error(msg, "starts_at", sil.StartsAt, "ends_at", sil.EndsAt) return silence_ops.NewPostSilencesBadRequest().WithPayload(msg) } if sil.EndsAt.Before(time.Now()) { msg := "Failed to create silence: end time can't be in the past" logger.Error(msg, "ends_at", sil.EndsAt) return silence_ops.NewPostSilencesBadRequest().WithPayload(msg) } if err = api.silences.Set(sil); err != nil { logger.Error("Failed to create silence", "err", err) if errors.Is(err, silence.ErrNotFound) { return silence_ops.NewPostSilencesNotFound().WithPayload(err.Error()) } return silence_ops.NewPostSilencesBadRequest().WithPayload(err.Error()) } return silence_ops.NewPostSilencesOK().WithPayload(&silence_ops.PostSilencesOKBody{ SilenceID: sil.Id, }) } func parseFilter(filter []string) ([]labels.Matcher, error) { matchers := make([]labels.Matcher, 0, len(filter)) for _, matcherString := range filter { matcher, err := compat.Matcher(matcherString, "api") if err != nil { return nil, err } matchers = append(matchers, matcher) } return matchers, nil } var ( swaggerSpecCacheMx sync.Mutex swaggerSpecCache loads.Document swaggerSpecAnalysisCache analysis.Spec ) // getSwaggerSpec loads and caches the swagger spec. If a cached version already exists, // it returns the cached one. The reason why we cache it is because some downstream projects // (e.g. Grafana Mimir) creates many Alertmanager instances in the same process, so they would // incur in a significant memory penalty if we would reload the swagger spec each time. func getSwaggerSpec() (loads.Document, analysis.Spec, error) { swaggerSpecCacheMx.Lock() defer swaggerSpecCacheMx.Unlock() // Check if a cached version exists. if swaggerSpecCache != nil { return swaggerSpecCache, swaggerSpecAnalysisCache, nil } // Load embedded swagger file. swaggerSpec, err := loads.Analyzed(restapi.SwaggerJSON, "") if err != nil { return nil, nil, fmt.Errorf("failed to load embedded swagger file: %w", err) } swaggerSpecCache = swaggerSpec swaggerSpecAnalysisCache = analysis.New(swaggerSpec.Spec()) return swaggerSpec, swaggerSpecAnalysisCache, nil }	22.19 KB	2025-05-25 12:27
📄 api_test.go // Copyright 2019 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package v2 import ( "bytes" "encoding/json" "fmt" "io" "net/http" "net/http/httptest" "strconv" "testing" "time" "github.com/go-openapi/runtime" "github.com/go-openapi/runtime/middleware" "github.com/go-openapi/strfmt" "github.com/prometheus/common/model" "github.com/prometheus/common/promslog" "github.com/stretchr/testify/require" open_api_models "github.com/prometheus/alertmanager/api/v2/models" general_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/general" receiver_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/receiver" silence_ops "github.com/prometheus/alertmanager/api/v2/restapi/operations/silence" "github.com/prometheus/alertmanager/config" "github.com/prometheus/alertmanager/pkg/labels" "github.com/prometheus/alertmanager/silence" "github.com/prometheus/alertmanager/silence/silencepb" "github.com/prometheus/alertmanager/types" ) // If api.peers == nil, Alertmanager cluster feature is disabled. Make sure to // not try to access properties of peer, which would trigger a nil pointer // dereference. func TestGetStatusHandlerWithNilPeer(t testing.T) { api := API{ uptime: time.Now(), peer: nil, alertmanagerConfig: &config.Config{}, } // Test ensures this method call does not panic. status := api.getStatusHandler(general_ops.GetStatusParams{}).(general_ops.GetStatusOK) c := status.Payload.Cluster if c == nil \|\| c.Status == nil { t.Fatal("expected cluster status not to be nil, violating the openapi specification") } if c.Peers == nil { t.Fatal("expected cluster peers to be not nil when api.peer is nil, violating the openapi specification") } if len(c.Peers) != 0 { t.Fatal("expected cluster peers to be empty when api.peer is nil, violating the openapi specification") } if c.Name != "" { t.Fatal("expected cluster name to be empty, violating the openapi specification") } } func assertEqualStrings(t testing.T, expected, actual string) { if expected != actual { t.Fatal("expected: ", expected, ", actual: ", actual) } } var ( testComment = "comment" createdBy = "test" ) func newSilences(t testing.T) silence.Silences { silences, err := silence.New(silence.Options{}) require.NoError(t, err) return silences } func gettableSilence(id, state string, updatedAt, start, end string, ) open_api_models.GettableSilence { updAt, err := strfmt.ParseDateTime(updatedAt) if err != nil { panic(err) } strAt, err := strfmt.ParseDateTime(start) if err != nil { panic(err) } endAt, err := strfmt.ParseDateTime(end) if err != nil { panic(err) } return &open_api_models.GettableSilence{ Silence: open_api_models.Silence{ StartsAt: &strAt, EndsAt: &endAt, Comment: &testComment, CreatedBy: &createdBy, }, ID: &id, UpdatedAt: &updAt, Status: &open_api_models.SilenceStatus{ State: &state, }, } } func TestGetSilencesHandler(t testing.T) { updateTime := "2019-01-01T12:00:00+00:00" silences := []open_api_models.GettableSilence{ gettableSilence("silence-6-expired", "expired", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T11:00:00+00:00"), gettableSilence("silence-1-active", "active", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T13:00:00+00:00"), gettableSilence("silence-7-expired", "expired", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T10:00:00+00:00"), gettableSilence("silence-5-expired", "expired", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T12:00:00+00:00"), gettableSilence("silence-0-active", "active", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T12:00:00+00:00"), gettableSilence("silence-4-pending", "pending", updateTime, "2019-01-01T13:00:00+00:00", "2019-01-01T12:00:00+00:00"), gettableSilence("silence-3-pending", "pending", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T12:00:00+00:00"), gettableSilence("silence-2-active", "active", updateTime, "2019-01-01T12:00:00+00:00", "2019-01-01T14:00:00+00:00"), } SortSilences(open_api_models.GettableSilences(silences)) for i, sil := range silences { assertEqualStrings(t, "silence-"+strconv.Itoa(i)+"-"+sil.Status.State, sil.ID) } } func TestDeleteSilenceHandler(t testing.T) { now := time.Now() silences := newSilences(t) m := &silencepb.Matcher{Type: silencepb.Matcher_EQUAL, Name: "a", Pattern: "b"} unexpiredSil := &silencepb.Silence{ Matchers: []silencepb.Matcher{m}, StartsAt: now, EndsAt: now.Add(time.Hour), UpdatedAt: now, } require.NoError(t, silences.Set(unexpiredSil)) expiredSil := &silencepb.Silence{ Matchers: []silencepb.Matcher{m}, StartsAt: now.Add(-time.Hour), EndsAt: now.Add(time.Hour), UpdatedAt: now, } require.NoError(t, silences.Set(expiredSil)) require.NoError(t, silences.Expire(expiredSil.Id)) for i, tc := range []struct { sid string expectedCode int }{ { "unknownSid", 404, }, { unexpiredSil.Id, 200, }, { expiredSil.Id, 200, }, } { api := API{ uptime: time.Now(), silences: silences, logger: promslog.NewNopLogger(), } r, err := http.NewRequest("DELETE", "/api/v2/silence/${tc.sid}", nil) require.NoError(t, err) w := httptest.NewRecorder() p := runtime.TextProducer() responder := api.deleteSilenceHandler(silence_ops.DeleteSilenceParams{ SilenceID: strfmt.UUID(tc.sid), HTTPRequest: r, }) responder.WriteResponse(w, p) body, _ := io.ReadAll(w.Result().Body) require.Equal(t, tc.expectedCode, w.Code, fmt.Sprintf("test case: %d, response: %s", i, string(body))) } } func TestPostSilencesHandler(t testing.T) { now := time.Now() silences := newSilences(t) m := &silencepb.Matcher{Type: silencepb.Matcher_EQUAL, Name: "a", Pattern: "b"} unexpiredSil := &silencepb.Silence{ Matchers: []silencepb.Matcher{m}, StartsAt: now, EndsAt: now.Add(time.Hour), UpdatedAt: now, } require.NoError(t, silences.Set(unexpiredSil)) expiredSil := &silencepb.Silence{ Matchers: []silencepb.Matcher{m}, StartsAt: now.Add(-time.Hour), EndsAt: now.Add(time.Hour), UpdatedAt: now, } require.NoError(t, silences.Set(expiredSil)) require.NoError(t, silences.Expire(expiredSil.Id)) t.Run("Silences CRUD", func(t testing.T) { for i, tc := range []struct { name string sid string start, end time.Time expectedCode int }{ { "with an non-existent silence ID - it returns 404", "unknownSid", now.Add(time.Hour), now.Add(time.Hour 2), 404, }, { "with no silence ID - it creates the silence", "", now.Add(time.Hour), now.Add(time.Hour * 2), 200, }, { "with an active silence ID - it extends the silence", unexpiredSil.Id, now.Add(time.Hour), now.Add(time.Hour * 2), 200, }, { "with an expired silence ID - it re-creates the silence", expiredSil.Id, now.Add(time.Hour), now.Add(time.Hour * 2), 200, }, } { t.Run(tc.name, func(t testing.T) { api := API{ uptime: time.Now(), silences: silences, logger: promslog.NewNopLogger(), } sil := createSilence(t, tc.sid, "silenceCreator", tc.start, tc.end) w := httptest.NewRecorder() postSilences(t, w, api.postSilencesHandler, sil) body, _ := io.ReadAll(w.Result().Body) require.Equal(t, tc.expectedCode, w.Code, fmt.Sprintf("test case: %d, response: %s", i, string(body))) }) } }) } func TestPostSilencesHandlerMissingIdCreatesSilence(t testing.T) { now := time.Now() silences := newSilences(t) api := API{ uptime: time.Now(), silences: silences, logger: promslog.NewNopLogger(), } // Create a new silence. It should be assigned a random UUID. sil := createSilence(t, "", "silenceCreator", now.Add(time.Hour), now.Add(time.Hour2)) w := httptest.NewRecorder() postSilences(t, w, api.postSilencesHandler, sil) require.Equal(t, http.StatusOK, w.Code) // Get the silences from the API. w = httptest.NewRecorder() getSilences(t, w, api.getSilencesHandler) require.Equal(t, http.StatusOK, w.Code) var resp []open_api_models.GettableSilence require.NoError(t, json.NewDecoder(w.Body).Decode(&resp)) require.Len(t, resp, 1) // Change the ID. It should return 404 Not Found. sil = open_api_models.PostableSilence{ ID: "unknownID", Silence: resp[0].Silence, } w = httptest.NewRecorder() postSilences(t, w, api.postSilencesHandler, sil) require.Equal(t, http.StatusNotFound, w.Code) // Remove the ID. It should duplicate the silence with a different UUID. sil = open_api_models.PostableSilence{ ID: "", Silence: resp[0].Silence, } w = httptest.NewRecorder() postSilences(t, w, api.postSilencesHandler, sil) require.Equal(t, http.StatusOK, w.Code) // Get the silences from the API. There should now be 2 silences. w = httptest.NewRecorder() getSilences(t, w, api.getSilencesHandler) require.Equal(t, http.StatusOK, w.Code) require.NoError(t, json.NewDecoder(w.Body).Decode(&resp)) require.Len(t, resp, 2) require.NotEqual(t, resp[0].ID, resp[1].ID) } func getSilences( t testing.T, w httptest.ResponseRecorder, handlerFunc func(params silence_ops.GetSilencesParams) middleware.Responder, ) { r, err := http.NewRequest("GET", "/api/v2/silences", nil) require.NoError(t, err) p := runtime.TextProducer() responder := handlerFunc(silence_ops.GetSilencesParams{ HTTPRequest: r, Filter: nil, }) responder.WriteResponse(w, p) } func postSilences( t testing.T, w httptest.ResponseRecorder, handlerFunc func(params silence_ops.PostSilencesParams) middleware.Responder, sil open_api_models.PostableSilence, ) { b, err := json.Marshal(sil) require.NoError(t, err) r, err := http.NewRequest("POST", "/api/v2/silences", bytes.NewReader(b)) require.NoError(t, err) p := runtime.TextProducer() responder := handlerFunc(silence_ops.PostSilencesParams{ HTTPRequest: r, Silence: &sil, }) responder.WriteResponse(w, p) } func TestCheckSilenceMatchesFilterLabels(t testing.T) { type test struct { silenceMatchers []silencepb.Matcher filterMatchers []labels.Matcher expected bool } tests := []test{ { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_EQUAL)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchEqual)}, true, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_EQUAL)}, []labels.Matcher{createLabelMatcher(t, "label", "novalue", labels.MatchEqual)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "(foo\|bar)", silencepb.Matcher_REGEXP)}, []labels.Matcher{createLabelMatcher(t, "label", "(foo\|bar)", labels.MatchRegexp)}, true, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "foo", silencepb.Matcher_REGEXP)}, []labels.Matcher{createLabelMatcher(t, "label", "(foo\|bar)", labels.MatchRegexp)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_EQUAL)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchRegexp)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_REGEXP)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchEqual)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_NOT_EQUAL)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchNotEqual)}, true, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_NOT_REGEXP)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchNotRegexp)}, true, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_EQUAL)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchNotEqual)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_REGEXP)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchNotRegexp)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_NOT_EQUAL)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchNotRegexp)}, false, }, { []silencepb.Matcher{createSilenceMatcher(t, "label", "value", silencepb.Matcher_NOT_REGEXP)}, []labels.Matcher{createLabelMatcher(t, "label", "value", labels.MatchNotEqual)}, false, }, { []silencepb.Matcher{ createSilenceMatcher(t, "label", "(foo\|bar)", silencepb.Matcher_REGEXP), createSilenceMatcher(t, "label", "value", silencepb.Matcher_EQUAL), }, []labels.Matcher{createLabelMatcher(t, "label", "(foo\|bar)", labels.MatchRegexp)}, true, }, } for _, test := range tests { silence := silencepb.Silence{ Matchers: test.silenceMatchers, } actual := CheckSilenceMatchesFilterLabels(&silence, test.filterMatchers) if test.expected != actual { t.Fatal("unexpected match result between silence and filter. expected:", test.expected, ", actual:", actual) } } } func convertDateTime(ts time.Time) strfmt.DateTime { dt := strfmt.DateTime(ts) return &dt } func TestAlertToOpenAPIAlert(t testing.T) { var ( start = time.Now().Add(-time.Minute) updated = time.Now() active = "active" fp = "0223b772b51c29e1" receivers = []string{"receiver1", "receiver2"} alert = &types.Alert{ Alert: model.Alert{ Labels: model.LabelSet{"severity": "critical", "alertname": "alert1"}, StartsAt: start, }, UpdatedAt: updated, } ) openAPIAlert := AlertToOpenAPIAlert(alert, types.AlertStatus{State: types.AlertStateActive}, receivers, nil) require.Equal(t, &open_api_models.GettableAlert{ Annotations: open_api_models.LabelSet{}, Alert: open_api_models.Alert{ Labels: open_api_models.LabelSet{"severity": "critical", "alertname": "alert1"}, }, StartsAt: convertDateTime(start), EndsAt: convertDateTime(time.Time{}), UpdatedAt: convertDateTime(updated), Fingerprint: &fp, Receivers: []open_api_models.Receiver{ {Name: &receivers[0]}, {Name: &receivers[1]}, }, Status: &open_api_models.AlertStatus{ State: &active, InhibitedBy: []string{}, SilencedBy: []string{}, MutedBy: []string{}, }, }, openAPIAlert) } func TestMatchFilterLabels(t testing.T) { sms := map[string]string{ "foo": "bar", } testCases := []struct { matcher labels.MatchType name string val string expected bool }{ {labels.MatchEqual, "foo", "bar", true}, {labels.MatchEqual, "baz", "", true}, {labels.MatchEqual, "baz", "qux", false}, {labels.MatchEqual, "baz", "qux\|", false}, {labels.MatchRegexp, "foo", "bar", true}, {labels.MatchRegexp, "baz", "", true}, {labels.MatchRegexp, "baz", "qux", false}, {labels.MatchRegexp, "baz", "qux\|", true}, {labels.MatchNotEqual, "foo", "bar", false}, {labels.MatchNotEqual, "baz", "", false}, {labels.MatchNotEqual, "baz", "qux", true}, {labels.MatchNotEqual, "baz", "qux\|", true}, {labels.MatchNotRegexp, "foo", "bar", false}, {labels.MatchNotRegexp, "baz", "", false}, {labels.MatchNotRegexp, "baz", "qux", true}, {labels.MatchNotRegexp, "baz", "qux\|", false}, } for _, tc := range testCases { m, err := labels.NewMatcher(tc.matcher, tc.name, tc.val) require.NoError(t, err) ms := []labels.Matcher{m} require.Equal(t, tc.expected, matchFilterLabels(ms, sms)) } } func TestGetReceiversHandler(t testing.T) { in := ` route: receiver: team-X receivers: - name: 'team-X' - name: 'team-Y' ` cfg, _ := config.Load(in) api := API{ uptime: time.Now(), logger: promslog.NewNopLogger(), alertmanagerConfig: cfg, } for _, tc := range []struct { body string expectedCode int }{ { `[{"name":"team-X"},{"name":"team-Y"}]`, 200, }, } { r, err := http.NewRequest("GET", "/api/v2/receivers", nil) require.NoError(t, err) w := httptest.NewRecorder() p := runtime.TextProducer() responder := api.getReceiversHandler(receiver_ops.GetReceiversParams{ HTTPRequest: r, }) responder.WriteResponse(w, p) body, _ := io.ReadAll(w.Result().Body) require.Equal(t, tc.expectedCode, w.Code) require.Equal(t, tc.body, string(body)) } }	16.62 KB	2025-05-25 12:27
📁 client	-	2025-05-25 12:27
📄 compat.go // Copyright 2021 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package v2 import ( "fmt" "time" "github.com/go-openapi/strfmt" prometheus_model "github.com/prometheus/common/model" open_api_models "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/silence/silencepb" "github.com/prometheus/alertmanager/types" ) // GettableSilenceFromProto converts silencepb.Silence to open_api_models.GettableSilence. func GettableSilenceFromProto(s silencepb.Silence) (open_api_models.GettableSilence, error) { start := strfmt.DateTime(s.StartsAt) end := strfmt.DateTime(s.EndsAt) updated := strfmt.DateTime(s.UpdatedAt) state := string(types.CalcSilenceState(s.StartsAt, s.EndsAt)) sil := open_api_models.GettableSilence{ Silence: open_api_models.Silence{ StartsAt: &start, EndsAt: &end, Comment: &s.Comment, CreatedBy: &s.CreatedBy, }, ID: &s.Id, UpdatedAt: &updated, Status: &open_api_models.SilenceStatus{ State: &state, }, } for _, m := range s.Matchers { matcher := &open_api_models.Matcher{ Name: &m.Name, Value: &m.Pattern, } f := false t := true switch m.Type { case silencepb.Matcher_EQUAL: matcher.IsEqual = &t matcher.IsRegex = &f case silencepb.Matcher_NOT_EQUAL: matcher.IsEqual = &f matcher.IsRegex = &f case silencepb.Matcher_REGEXP: matcher.IsEqual = &t matcher.IsRegex = &t case silencepb.Matcher_NOT_REGEXP: matcher.IsEqual = &f matcher.IsRegex = &t default: return sil, fmt.Errorf( "unknown matcher type for matcher '%v' in silence '%v'", m.Name, s.Id, ) } sil.Matchers = append(sil.Matchers, matcher) } return sil, nil } // PostableSilenceToProto converts open_api_models.PostableSilenc to silencepb.Silence. func PostableSilenceToProto(s open_api_models.PostableSilence) (silencepb.Silence, error) { sil := &silencepb.Silence{ Id: s.ID, StartsAt: time.Time(s.StartsAt), EndsAt: time.Time(s.EndsAt), Comment: s.Comment, CreatedBy: s.CreatedBy, } for _, m := range s.Matchers { matcher := &silencepb.Matcher{ Name: m.Name, Pattern: m.Value, } isEqual := true if m.IsEqual != nil { isEqual = m.IsEqual } isRegex := false if m.IsRegex != nil { isRegex = m.IsRegex } switch { case isEqual && !isRegex: matcher.Type = silencepb.Matcher_EQUAL case !isEqual && !isRegex: matcher.Type = silencepb.Matcher_NOT_EQUAL case isEqual && isRegex: matcher.Type = silencepb.Matcher_REGEXP case !isEqual && isRegex: matcher.Type = silencepb.Matcher_NOT_REGEXP } sil.Matchers = append(sil.Matchers, matcher) } return sil, nil } // AlertToOpenAPIAlert converts internal alerts, alert types, and receivers to open_api_models.GettableAlert. func AlertToOpenAPIAlert(alert types.Alert, status types.AlertStatus, receivers, mutedBy []string) open_api_models.GettableAlert { startsAt := strfmt.DateTime(alert.StartsAt) updatedAt := strfmt.DateTime(alert.UpdatedAt) endsAt := strfmt.DateTime(alert.EndsAt) apiReceivers := make([]open_api_models.Receiver, 0, len(receivers)) for i := range receivers { apiReceivers = append(apiReceivers, &open_api_models.Receiver{Name: &receivers[i]}) } fp := alert.Fingerprint().String() state := string(status.State) if len(mutedBy) > 0 { // If the alert is muted, change the state to suppressed. state = open_api_models.AlertStatusStateSuppressed } aa := &open_api_models.GettableAlert{ Alert: open_api_models.Alert{ GeneratorURL: strfmt.URI(alert.GeneratorURL), Labels: ModelLabelSetToAPILabelSet(alert.Labels), }, Annotations: ModelLabelSetToAPILabelSet(alert.Annotations), StartsAt: &startsAt, UpdatedAt: &updatedAt, EndsAt: &endsAt, Fingerprint: &fp, Receivers: apiReceivers, Status: &open_api_models.AlertStatus{ State: &state, SilencedBy: status.SilencedBy, InhibitedBy: status.InhibitedBy, MutedBy: mutedBy, }, } if aa.Status.SilencedBy == nil { aa.Status.SilencedBy = []string{} } if aa.Status.InhibitedBy == nil { aa.Status.InhibitedBy = []string{} } if aa.Status.MutedBy == nil { aa.Status.MutedBy = []string{} } return aa } // OpenAPIAlertsToAlerts converts open_api_models.PostableAlerts to []types.Alert. func OpenAPIAlertsToAlerts(apiAlerts open_api_models.PostableAlerts) []types.Alert { alerts := []*types.Alert{} for _, apiAlert := range apiAlerts { alert := types.Alert{ Alert: prometheus_model.Alert{ Labels: APILabelSetToModelLabelSet(apiAlert.Labels), Annotations: APILabelSetToModelLabelSet(apiAlert.Annotations), StartsAt: time.Time(apiAlert.StartsAt), EndsAt: time.Time(apiAlert.EndsAt), GeneratorURL: string(apiAlert.GeneratorURL), }, } alerts = append(alerts, &alert) } return alerts } // ModelLabelSetToAPILabelSet converts prometheus_model.LabelSet to open_api_models.LabelSet. func ModelLabelSetToAPILabelSet(modelLabelSet prometheus_model.LabelSet) open_api_models.LabelSet { apiLabelSet := open_api_models.LabelSet{} for key, value := range modelLabelSet { apiLabelSet[string(key)] = string(value) } return apiLabelSet } // APILabelSetToModelLabelSet converts open_api_models.LabelSet to prometheus_model.LabelSet. func APILabelSetToModelLabelSet(apiLabelSet open_api_models.LabelSet) prometheus_model.LabelSet { modelLabelSet := prometheus_model.LabelSet{} for key, value := range apiLabelSet { modelLabelSet[prometheus_model.LabelName(key)] = prometheus_model.LabelValue(value) } return modelLabelSet }	5.99 KB	2025-05-25 12:27
📁 models	-	2025-05-25 12:27
📄 openapi.yaml --- swagger: '2.0' info: version: 0.0.1 title: Alertmanager API description: API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) license: name: Apache 2.0 url: http://www.apache.org/licenses/LICENSE-2.0.html consumes: - "application/json" produces: - "application/json" basePath: "/api/v2/" paths: /status: get: tags: - general operationId: getStatus description: Get current status of an Alertmanager instance and its cluster responses: '200': description: Get status response schema: $ref: '#/definitions/alertmanagerStatus' /receivers: get: tags: - receiver operationId: getReceivers description: Get list of all receivers (name of notification integrations) responses: '200': description: Get receivers response schema: type: array items: $ref: '#/definitions/receiver' /silences: get: tags: - silence operationId: getSilences description: Get a list of silences responses: '200': description: Get silences response schema: $ref: '#/definitions/gettableSilences' '400': $ref: '#/responses/BadRequest' '500': $ref: '#/responses/InternalServerError' parameters: - name: filter in: query description: A list of matchers to filter silences by required: false type: array collectionFormat: multi items: type: string post: tags: - silence operationId: postSilences description: Post a new silence or update an existing one parameters: - in: body name: silence description: The silence to create required: true schema: $ref: '#/definitions/postableSilence' responses: '200': description: Create / update silence response schema: type: object properties: silenceID: type: string '400': $ref: '#/responses/BadRequest' '404': description: A silence with the specified ID was not found schema: type: string /silence/{silenceID}: parameters: - in: path name: silenceID type: string format: uuid required: true description: ID of the silence to get get: tags: - silence operationId: getSilence description: Get a silence by its ID responses: '200': description: Get silence response schema: $ref: '#/definitions/gettableSilence' '404': description: A silence with the specified ID was not found '500': $ref: '#/responses/InternalServerError' delete: tags: - silence operationId: deleteSilence description: Delete a silence by its ID parameters: - in: path name: silenceID type: string format: uuid required: true description: ID of the silence to get responses: '200': description: Delete silence response '404': description: A silence with the specified ID was not found '500': $ref: '#/responses/InternalServerError' /alerts: get: tags: - alert operationId: getAlerts description: Get a list of alerts parameters: - in: query name: active type: boolean description: Show active alerts default: true - in: query name: silenced type: boolean description: Show silenced alerts default: true - in: query name: inhibited type: boolean description: Show inhibited alerts default: true - in: query name: unprocessed type: boolean description: Show unprocessed alerts default: true - name: filter in: query description: A list of matchers to filter alerts by required: false type: array collectionFormat: multi items: type: string - name: receiver in: query description: A regex matching receivers to filter alerts by required: false type: string responses: '200': description: Get alerts response schema: '$ref': '#/definitions/gettableAlerts' '400': $ref: '#/responses/BadRequest' '500': $ref: '#/responses/InternalServerError' post: tags: - alert operationId: postAlerts description: Create new Alerts parameters: - in: body name: alerts description: The alerts to create required: true schema: $ref: '#/definitions/postableAlerts' responses: '200': description: Create alerts response '500': $ref: '#/responses/InternalServerError' '400': $ref: '#/responses/BadRequest' /alerts/groups: get: tags: - alertgroup operationId: getAlertGroups description: Get a list of alert groups parameters: - in: query name: active type: boolean description: Show active alerts default: true - in: query name: silenced type: boolean description: Show silenced alerts default: true - in: query name: inhibited type: boolean description: Show inhibited alerts default: true - in: query name: muted type: boolean description: Show muted alerts default: true - name: filter in: query description: A list of matchers to filter alerts by required: false type: array collectionFormat: multi items: type: string - name: receiver in: query description: A regex matching receivers to filter alerts by required: false type: string responses: '200': description: Get alert groups response schema: '$ref': '#/definitions/alertGroups' '400': $ref: '#/responses/BadRequest' '500': $ref: '#/responses/InternalServerError' responses: BadRequest: description: Bad request schema: type: string InternalServerError: description: Internal server error schema: type: string definitions: alertmanagerStatus: type: object properties: cluster: $ref: '#/definitions/clusterStatus' versionInfo: $ref: '#/definitions/versionInfo' config: $ref: '#/definitions/alertmanagerConfig' uptime: type: string format: date-time required: - cluster - versionInfo - config - uptime clusterStatus: type: object properties: name: type: string status: type: string enum: ["ready", "settling", "disabled"] peers: type: array items: $ref: '#/definitions/peerStatus' required: - status alertmanagerConfig: type: object properties: original: type: string required: - original versionInfo: type: object properties: version: type: string revision: type: string branch: type: string buildUser: type: string buildDate: type: string goVersion: type: string required: - version - revision - branch - buildUser - buildDate - goVersion peerStatus: type: object properties: name: type: string address: type: string required: - name - address silence: type: object properties: matchers: $ref: '#/definitions/matchers' startsAt: type: string format: date-time endsAt: type: string format: date-time createdBy: type: string comment: type: string required: - matchers - startsAt - endsAt - createdBy - comment gettableSilence: allOf: - type: object properties: id: type: string status: $ref: '#/definitions/silenceStatus' updatedAt: type: string format: date-time required: - id - status - updatedAt - $ref: '#/definitions/silence' postableSilence: allOf: - type: object properties: id: type: string - $ref: '#/definitions/silence' silenceStatus: type: object properties: state: type: string enum: ["expired", "active", "pending"] required: - state gettableSilences: type: array items: $ref: '#/definitions/gettableSilence' matchers: type: array items: $ref: '#/definitions/matcher' minItems: 1 matcher: type: object properties: name: type: string value: type: string isRegex: type: boolean isEqual: type: boolean default: true required: - name - value - isRegex alert: type: object properties: labels: $ref: '#/definitions/labelSet' generatorURL: type: string format: uri required: - labels gettableAlerts: type: array items: $ref: '#/definitions/gettableAlert' gettableAlert: allOf: - type: object properties: annotations: $ref: '#/definitions/labelSet' receivers: type: array items: $ref: '#/definitions/receiver' fingerprint: type: string startsAt: type: string format: date-time updatedAt: type: string format: date-time endsAt: type: string format: date-time status: $ref: '#/definitions/alertStatus' required: - receivers - fingerprint - startsAt - updatedAt - endsAt - annotations - status - $ref: '#/definitions/alert' postableAlerts: type: array items: $ref: '#/definitions/postableAlert' postableAlert: allOf: - type: object properties: startsAt: type: string format: date-time endsAt: type: string format: date-time annotations: $ref: '#/definitions/labelSet' - $ref: '#/definitions/alert' alertGroups: type: array items: $ref: '#/definitions/alertGroup' alertGroup: type: object properties: labels: $ref: '#/definitions/labelSet' receiver: $ref: '#/definitions/receiver' alerts: type: array items: $ref: '#/definitions/gettableAlert' required: - labels - receiver - alerts alertStatus: type: object properties: state: type: string enum: ['unprocessed', 'active', 'suppressed'] silencedBy: type: array items: type: string inhibitedBy: type: array items: type: string mutedBy: type: array items: type: string required: - state - silencedBy - inhibitedBy - mutedBy receiver: type: object properties: name: type: string required: - name labelSet: type: object additionalProperties: type: string tags: - name: general description: General Alertmanager operations - name: receiver description: Everything related to Alertmanager receivers - name: silence description: Everything related to Alertmanager silences - name: alert description: Everything related to Alertmanager alerts	12.24 KB	2025-05-25 12:27
📁 restapi	-	2025-05-25 12:27
📄 testing.go // Copyright 2022 Prometheus Team // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package v2 import ( "testing" "time" "github.com/go-openapi/strfmt" open_api_models "github.com/prometheus/alertmanager/api/v2/models" "github.com/prometheus/alertmanager/pkg/labels" "github.com/prometheus/alertmanager/silence/silencepb" ) func createSilence(t testing.T, ID, creator string, start, ends time.Time) open_api_models.PostableSilence { t.Helper() comment := "test" matcherName := "a" matcherValue := "b" isRegex := false startsAt := strfmt.DateTime(start) endsAt := strfmt.DateTime(ends) sil := open_api_models.PostableSilence{ ID: ID, Silence: open_api_models.Silence{ Matchers: open_api_models.Matchers{&open_api_models.Matcher{Name: &matcherName, Value: &matcherValue, IsRegex: &isRegex}}, StartsAt: &startsAt, EndsAt: &endsAt, CreatedBy: &creator, Comment: &comment, }, } return sil } func createSilenceMatcher(t testing.T, name, pattern string, matcherType silencepb.Matcher_Type) silencepb.Matcher { t.Helper() return &silencepb.Matcher{ Name: name, Pattern: pattern, Type: matcherType, } } func createLabelMatcher(t testing.T, name, value string, matchType labels.MatchType) *labels.Matcher { t.Helper() matcher, _ := labels.NewMatcher(matchType, name, value) return matcher }	1.82 KB	2025-05-25 12:27

Terminal