apitech
/
grafana
mirror of https://github.com/grafana/grafana
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

[Alerting]: Delete obsolete database table and code (#32595)

Browse Source 
* Delete obsolete migration

* Remove redundant code
pull/32575/head
Sofia Papagiannaki 4 years ago committed by GitHub
parent e34b2c13d3
commit 8793f5c7f8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 0 additions and 293 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 119
      pkg/services/ngalert/models/silence.go
  2. 3
      pkg/services/ngalert/ngalert.go
  3. 6
      pkg/services/ngalert/store/database.go
  4. 165
      pkg/services/ngalert/store/silence.go

119
pkg/services/ngalert/models/silence.go
Unescape View File

@ -1,119 +0,0 @@
package models
import (
"encoding/json"
"errors"
"fmt"
"github.com/go-openapi/strfmt"
amv2 "github.com/prometheus/alertmanager/api/v2/models"
)
var (
// ErrSilenceNotFound is an error for an unknown silence.
ErrSilenceNotFound = fmt.Errorf("could not find silence")
// ErrSilenceFailedGenerateUniqueUID is an error for failure to generate silence UID
ErrSilenceFailedGenerateUniqueUID = errors.New("failed to generate silence UID")
)
type SilenceSettings amv2.GettableSilence
type SilenceStatus amv2.SilenceStatus
// FromDB loads silence status stored in the database.
// FromDB is part of the xorm Conversion interface.
func (st *SilenceStatus) FromDB(b []byte) error {
str := string(b)
*st = SilenceStatus{State: &str}
return nil
}
// ToDB serializes silence status to be stored in the database.
// ToDB is part of the xorm Conversion interface.
func (st *SilenceStatus) ToDB() ([]byte, error) {
return []byte(*st.State), nil
}
type Matchers amv2.Matchers
// FromDB loads matchers stored in the database.
// FromDB is part of the xorm Conversion interface.
func (m *Matchers) FromDB(b []byte) error {
err := json.Unmarshal(b, &m)
if err != nil {
return fmt.Errorf("failed to convert matchers from database: %w", err)
}
return nil
}
// ToDB serializes matchers to be stored in the database.
// ToDB is part of the xorm Conversion interface.
func (m *Matchers) ToDB() ([]byte, error) {
blobMatchers, err := json.Marshal(m)
if err != nil {
return nil, fmt.Errorf("failed to convert matchers to send to the database: %w", err)
}
return blobMatchers, nil
}
type Silence struct {
ID int64 `xorm:"pk autoincr 'id'"`
OrgID int64 `xorm:"org_id" json:"orgId"`
UID string `xorm:"uid" json:"uid"`
Status SilenceStatus `json:"status"`
UpdatedAt strfmt.DateTime `json:"updatedAt"`
Comment string `json:"comment"`
CreatedBy string `json:"createdBy"`
EndsAt strfmt.DateTime `json:"endsAt"`
Matchers Matchers `json:"matchers"`
StartsAt strfmt.DateTime `json:"startsAt"`
}
func (s Silence) ToGettableSilence() amv2.GettableSilence {
gettableSilence := amv2.GettableSilence{
ID: &s.UID,
Status: &amv2.SilenceStatus{State: s.Status.State},
UpdatedAt: &s.UpdatedAt,
}
gettableSilence.Comment = &s.Comment
gettableSilence.CreatedBy = &s.CreatedBy
gettableSilence.EndsAt = &s.EndsAt
gettableSilence.Matchers = amv2.Matchers(s.Matchers)
gettableSilence.StartsAt = &s.StartsAt
return gettableSilence
}
type SaveSilenceCommand struct {
amv2.Silence
UID string
OrgID int64
}
type DeleteSilenceByUIDCommand struct {
UID string
OrgID int64
}
type DeleteSilenceByIDCommand struct {
ID int64
}
type GetSilenceByUIDQuery struct {
UID string
OrgID int64
Result *Silence
}
type GetSilenceByIDQuery struct {
ID int64
Result *Silence
}
type GetSilencesQuery struct {
OrgID int64
Result []*Silence
}

3
pkg/services/ngalert/ngalert.go
Unescape View File

@ -118,7 +118,4 @@ func (ng *AlertNG) AddMigration(mg *migrator.Migrator) {
// Create alert_rule
store.AddAlertRuleMigrations(mg, defaultIntervalSeconds)
store.AddAlertRuleVersionMigrations(mg)
// Create silence table
store.SilenceMigration(mg)
}

6
pkg/services/ngalert/store/database.go
Unescape View File

@ -42,12 +42,6 @@ type AlertingStore interface {
GetLatestAlertmanagerConfiguration(*models.GetLatestAlertmanagerConfigurationQuery) error
GetAlertmanagerConfiguration(*models.GetAlertmanagerConfigurationQuery) error
SaveAlertmanagerConfiguration(*models.SaveAlertmanagerConfigurationCmd) error
GetOrgSilences(*models.GetSilencesQuery) error
GetSilenceByUID(*models.GetSilenceByUIDQuery) error
GetSilenceByID(*models.GetSilenceByIDQuery) error
SaveSilence(*models.SaveSilenceCommand) error
DeleteSilenceByUID(*models.DeleteSilenceByUIDCommand) error
DeleteSilenceByID(*models.DeleteSilenceByIDCommand) error
}
// DBstore stores the alert definitions and instances in the database.

165
pkg/services/ngalert/store/silence.go
Unescape View File

@ -1,165 +0,0 @@
package store
import (
"context"
"errors"
"fmt"
"github.com/go-openapi/strfmt"
"github.com/grafana/grafana/pkg/services/ngalert/models"
"github.com/grafana/grafana/pkg/services/sqlstore"
"github.com/grafana/grafana/pkg/util"
amv2 "github.com/prometheus/alertmanager/api/v2/models"
)
func getSilenceByUID(sess *sqlstore.DBSession, silenceUID string, orgID int64) (*models.Silence, error) {
silence := &models.Silence{
OrgID: orgID,
UID: silenceUID,
}
has, err := sess.Get(silence)
if err != nil {
return nil, err
}
if !has {
return nil, models.ErrSilenceNotFound
}
return silence, nil
}
func getSilenceByID(sess *sqlstore.DBSession, id int64) (*models.Silence, error) {
silence := &models.Silence{}
has, err := sess.ID(id).Get(silence)
if err != nil {
return nil, err
}
if !has {
return nil, ErrNoAlertmanagerConfiguration
}
return silence, nil
}
func (st DBstore) GetOrgSilences(query *models.GetSilencesQuery) error {
return st.SQLStore.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
silences := make([]*models.Silence, 0)
q := "SELECT * FROM silence WHERE org_id = ?"
if err := sess.SQL(q, query.OrgID).Find(&silences); err != nil {
return err
}
query.Result = silences
return nil
})
}
func (st DBstore) GetSilenceByUID(query *models.GetSilenceByUIDQuery) error {
return st.SQLStore.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
silence, err := getSilenceByUID(sess, query.UID, query.OrgID)
if err != nil {
return err
}
query.Result = silence
return nil
})
}
func (st DBstore) GetSilenceByID(query *models.GetSilenceByIDQuery) error {
return st.SQLStore.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
silence, err := getSilenceByID(sess, query.ID)
if err != nil {
return err
}
query.Result = silence
return nil
})
}
func (st DBstore) DeleteSilenceByUID(cmd *models.DeleteSilenceByUIDCommand) error {
return st.SQLStore.WithDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
_, err := getSilenceByUID(sess, cmd.UID, cmd.OrgID)
if err != nil && errors.Is(err, models.ErrSilenceNotFound) {
return err
}
_, err = sess.Exec("DELETE FROM silence WHERE uid = ? AND org_id = ?", cmd.UID, cmd.OrgID)
if err != nil {
return err
}
return nil
})
}
func (st DBstore) DeleteSilenceByID(cmd *models.DeleteSilenceByIDCommand) error {
return st.SQLStore.WithTransactionalDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
_, err := getSilenceByID(sess, cmd.ID)
if err != nil && errors.Is(err, models.ErrSilenceNotFound) {
return err
}
_, err = sess.Exec("DELETE FROM silence WHERE id ?", cmd.ID)
if err != nil {
return err
}
return nil
})
}
func (st DBstore) SaveSilence(cmd *models.SaveSilenceCommand) error {
return st.SQLStore.WithTransactionalDbSession(context.Background(), func(sess *sqlstore.DBSession) error {
var firstSeen bool
existingSilence, err := getSilenceByUID(sess, cmd.UID, cmd.OrgID)
if err != nil {
if !errors.Is(err, models.ErrSilenceNotFound) {
return err
}
firstSeen = true
}
statusPending := amv2.SilenceStatusStatePending
updatedAt := strfmt.DateTime(TimeNow())
silenceModel := models.Silence{
OrgID: cmd.OrgID,
UID: cmd.UID,
Status: models.SilenceStatus{State: &statusPending},
UpdatedAt: updatedAt,
Comment: *cmd.Comment,
CreatedBy: *cmd.CreatedBy,
EndsAt: *cmd.EndsAt,
Matchers: models.Matchers(cmd.Matchers),
StartsAt: *cmd.StartsAt,
}
switch firstSeen {
case true:
if _, err := sess.Insert(&silenceModel); err != nil {
return fmt.Errorf("failed to insert silence: %w", err)
}
default:
if _, err := sess.ID(existingSilence.ID).Update(&silenceModel); err != nil {
return fmt.Errorf("failed to update silence: %w", err)
}
}
return nil
})
}
func GenerateNewSilenceUID(sess *sqlstore.DBSession, orgID int64) (string, error) {
for i := 0; i < 3; i++ {
uid := util.GenerateShortUID()
exists, err := sess.Where("org_id=? AND uid=?", orgID, uid).Get(&models.Silence{})
if err != nil {
return "", err
}
if !exists {
return uid, nil
}
}
return "", models.ErrSilenceFailedGenerateUniqueUID
}
Write Preview
Loading…
Cancel
Save