From 1112036edc7506c80693467b5345d99887aa13cc Mon Sep 17 00:00:00 2001 From: Scaleway Bot Date: Wed, 19 Jun 2024 15:22:17 +0200 Subject: [PATCH] feat(cockpit): create route to list all alerts OP-1289 (#2110) --- api/cockpit/v1/cockpit_sdk.go | 149 ++++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) diff --git a/api/cockpit/v1/cockpit_sdk.go b/api/cockpit/v1/cockpit_sdk.go index 03008d054..7f977d3d6 100644 --- a/api/cockpit/v1/cockpit_sdk.go +++ b/api/cockpit/v1/cockpit_sdk.go @@ -250,6 +250,51 @@ func (enum *ListGrafanaUsersRequestOrderBy) UnmarshalJSON(data []byte) error { return nil } +type ListManagedAlertsRequestOrderBy string + +const ( + ListManagedAlertsRequestOrderByCreatedAtAsc = ListManagedAlertsRequestOrderBy("created_at_asc") + ListManagedAlertsRequestOrderByCreatedAtDesc = ListManagedAlertsRequestOrderBy("created_at_desc") + ListManagedAlertsRequestOrderByNameAsc = ListManagedAlertsRequestOrderBy("name_asc") + ListManagedAlertsRequestOrderByNameDesc = ListManagedAlertsRequestOrderBy("name_desc") + ListManagedAlertsRequestOrderByTypeAsc = ListManagedAlertsRequestOrderBy("type_asc") + ListManagedAlertsRequestOrderByTypeDesc = ListManagedAlertsRequestOrderBy("type_desc") +) + +func (enum ListManagedAlertsRequestOrderBy) String() string { + if enum == "" { + // return default value if empty + return "created_at_asc" + } + return string(enum) +} + +func (enum ListManagedAlertsRequestOrderBy) Values() []ListManagedAlertsRequestOrderBy { + return []ListManagedAlertsRequestOrderBy{ + "created_at_asc", + "created_at_desc", + "name_asc", + "name_desc", + "type_asc", + "type_desc", + } +} + +func (enum ListManagedAlertsRequestOrderBy) MarshalJSON() ([]byte, error) { + return []byte(fmt.Sprintf(`"%s"`, enum)), nil +} + +func (enum *ListManagedAlertsRequestOrderBy) UnmarshalJSON(data []byte) error { + tmp := "" + + if err := json.Unmarshal(data, &tmp); err != nil { + return err + } + + *enum = ListManagedAlertsRequestOrderBy(ListManagedAlertsRequestOrderBy(tmp).String()) + return nil +} + type ListPlansRequestOrderBy string const ( @@ -555,6 +600,19 @@ type GrafanaUser struct { Password *string `json:"password"` } +// Alert: alert. +type Alert struct { + ProductFamily string `json:"product_family"` + + Product string `json:"product"` + + Name string `json:"name"` + + Rule string `json:"rule"` + + Description string `json:"description"` +} + // Plan: Type of pricing plan. type Plan struct { // Name: name of a given pricing plan. @@ -890,6 +948,34 @@ func (r *ListGrafanaUsersResponse) UnsafeAppend(res interface{}) (uint64, error) return uint64(len(results.GrafanaUsers)), nil } +// ListManagedAlertsResponse: Response returned when listing data sources. +type ListManagedAlertsResponse struct { + // TotalCount: total count of data sources matching the request. + TotalCount uint64 `json:"total_count"` + + // Alerts: alerts matching the request within the pagination. + Alerts []*Alert `json:"alerts"` +} + +// UnsafeGetTotalCount should not be used +// Internal usage only +func (r *ListManagedAlertsResponse) UnsafeGetTotalCount() uint64 { + return r.TotalCount +} + +// UnsafeAppend should not be used +// Internal usage only +func (r *ListManagedAlertsResponse) UnsafeAppend(res interface{}) (uint64, error) { + results, ok := res.(*ListManagedAlertsResponse) + if !ok { + return 0, errors.New("%T type cannot be appended to type %T", res, r) + } + + r.Alerts = append(r.Alerts, results.Alerts...) + r.TotalCount += uint64(len(results.Alerts)) + return uint64(len(results.Alerts)), nil +} + // ListPlansResponse: Output returned when listing pricing plans. type ListPlansResponse struct { // TotalCount: total count of available pricing plans. @@ -1135,6 +1221,25 @@ type RegionalAPIListDataSourcesRequest struct { Types []DataSourceType `json:"-"` } +// RegionalAPIListManagedAlertsRequest: Enable the sending of managed alerts. +type RegionalAPIListManagedAlertsRequest struct { + // Region: region to target. If none is passed will use default region from the config. + Region scw.Region `json:"-"` + + // Page: page number to return, from the paginated results. + Page *int32 `json:"-"` + + // PageSize: number of data sources to return per page. + PageSize *uint32 `json:"-"` + + // OrderBy: sort order for data sources in the response. + // Default value: created_at_asc + OrderBy ListManagedAlertsRequestOrderBy `json:"-"` + + // ProjectID: project ID to filter for, only data sources from this Project will be returned. + ProjectID string `json:"-"` +} + // RegionalAPIListTokensRequest: List tokens. type RegionalAPIListTokensRequest struct { // Region: region to target. If none is passed will use default region from the config. @@ -2094,6 +2199,50 @@ func (s *RegionalAPI) DeleteContactPoint(req *RegionalAPIDeleteContactPointReque return nil } +// ListManagedAlerts: List all managed alerts for the specified Project. +func (s *RegionalAPI) ListManagedAlerts(req *RegionalAPIListManagedAlertsRequest, opts ...scw.RequestOption) (*ListManagedAlertsResponse, error) { + var err error + + if req.Region == "" { + defaultRegion, _ := s.client.GetDefaultRegion() + req.Region = defaultRegion + } + + defaultPageSize, exist := s.client.GetDefaultPageSize() + if (req.PageSize == nil || *req.PageSize == 0) && exist { + req.PageSize = &defaultPageSize + } + + if req.ProjectID == "" { + defaultProjectID, _ := s.client.GetDefaultProjectID() + req.ProjectID = defaultProjectID + } + + query := url.Values{} + parameter.AddToQuery(query, "page", req.Page) + parameter.AddToQuery(query, "page_size", req.PageSize) + parameter.AddToQuery(query, "order_by", req.OrderBy) + parameter.AddToQuery(query, "project_id", req.ProjectID) + + if fmt.Sprint(req.Region) == "" { + return nil, errors.New("field Region cannot be empty in request") + } + + scwReq := &scw.ScalewayRequest{ + Method: "GET", + Path: "/cockpit/v1/regions/" + fmt.Sprint(req.Region) + "/managed-alerts", + Query: query, + } + + var resp ListManagedAlertsResponse + + err = s.client.Do(scwReq, &resp, opts...) + if err != nil { + return nil, err + } + return &resp, nil +} + // EnableManagedAlerts: Enable the sending of managed alerts for the specified Project. Managed alerts are predefined alerts that apply to Scaleway recources integrated with Cockpit by default. func (s *RegionalAPI) EnableManagedAlerts(req *RegionalAPIEnableManagedAlertsRequest, opts ...scw.RequestOption) (*AlertManager, error) { var err error