monitor: refactor suggest code

pkg/apis/monitor/suggestsys_const.go

@@ -21,15 +21,20 @@ const (
 	SUGGEST_ALERT_DELETING     = "deleting"
 )
 
+type SuggestDriverType string
+
+type SuggestDriverAction string
+
 const (
-	EIP_UN_USED  = "EIP_UNUSED"
-	DISK_UN_USED = "DISK_UNUSED"
-	LB_UN_USED   = "LB_UNUSED"
-	SCALE_DOWN   = "SCALE_DOWN"
-	SCALE_UP     = "SCALE_UP"
-
-	DRIVER_ACTION            = "DELETE"
-	SCALE_DOWN_DRIVER_ACTION = "SCALE_DOWN"
+	EIP_UNUSED      SuggestDriverType = "EIP_UNUSED"
+	DISK_UNUSED     SuggestDriverType = "DISK_UNUSED"
+	LB_UNUSED       SuggestDriverType = "LB_UNUSED"
+	SNAPSHOT_UNUSED SuggestDriverType = "SNAPSHOT_UNUSED"
+	SCALE_DOWN      SuggestDriverType = "SCALE_DOWN"
+	SCALE_UP        SuggestDriverType = "SCALE_UP"
+
+	DELETE_DRIVER_ACTION     SuggestDriverAction = "DELETE"
+	SCALE_DOWN_DRIVER_ACTION SuggestDriverAction = "SCALE_DOWN"
 )
 
 type MonitorSuggest string

pkg/mcclient/options/monitor/suggestsysrule.go

@@ -73,16 +73,16 @@ func (opt SuggestRuleUpdateOptions) Params() (jsonutils.JSONObject, error) {
 
 func newSuggestSysAlertSetting(tp string) *monitor.SSuggestSysAlertSetting {
 	setting := new(monitor.SSuggestSysAlertSetting)
-	switch tp {
-	case monitor.EIP_UN_USED:
+	switch monitor.SuggestDriverType(tp) {
+	case monitor.EIP_UNUSED:
 		setting = &monitor.SSuggestSysAlertSetting{
 			EIPUnused: &monitor.EIPUnused{},
 		}
-	case monitor.DISK_UN_USED:
+	case monitor.DISK_UNUSED:
 		setting = &monitor.SSuggestSysAlertSetting{
 			DiskUnused: &monitor.DiskUnused{},
 		}
-	case monitor.LB_UN_USED:
+	case monitor.LB_UNUSED:
 		setting = &monitor.SSuggestSysAlertSetting{
 			LBUnused: &monitor.LBUnused{},
 		}

pkg/monitor/models/suggestsysalart.go → pkg/monitor/models/suggestsysalert.go

@@ -186,31 +186,34 @@ func (man *SSuggestSysAlertManager) FetchCustomizeColumns(
 	return rows
 }
 
+func (man *SSuggestSysRuleManager) GetDriver(drvType monitor.SuggestDriverType) ISuggestSysRuleDriver {
+	return GetSuggestSysRuleDrivers()[drvType]
+}
+
+func (self *SSuggestSysAlert) GetDriver() ISuggestSysRuleDriver {
+	return SuggestSysRuleManager.GetDriver(self.GetType())
+}
+
+func (self *SSuggestSysAlert) GetType() monitor.SuggestDriverType {
+	return monitor.SuggestDriverType(self.Type)
+}
+
 func (self *SSuggestSysAlert) getMoreDetails(out monitor.SuggestSysAlertDetails) monitor.SuggestSysAlertDetails {
 	err := self.ResMeta.Unmarshal(&out)
 	if err != nil {
 		log.Errorln("SSuggestSysAlert getMoreDetails's error:", err)
 	}
+	drv := self.GetDriver()
 	out.Account = self.Cloudaccount
-	out.ResType = GetSuggestSysRuleDrivers()[self.Type].GetResourceType()
-	out.RuleName = strings.ToLower(GetSuggestSysRuleDrivers()[self.Type].GetType())
-	rule, _ := SuggestSysRuleManager.GetRules(self.Type)
+	out.ResType = string(drv.GetResourceType())
+	out.RuleName = strings.ToLower(string(drv.GetType()))
+	rule, _ := SuggestSysRuleManager.GetRules(self.GetType())
 	if len(rule) != 0 {
 		out.ShowName = fmt.Sprintf("%s-%s", self.Name, rule[0].Name)
 	} else {
 		out.ShowName = fmt.Sprintf("%s-%s", self.Name, self.Type)
 	}
-	switch self.Type {
-	case monitor.EIP_UN_USED:
-		out.Suggest = string(monitor.EIP_MONITOR_SUGGEST)
-	case monitor.DISK_UN_USED:
-		out.Suggest = string(monitor.DISK_MONITOR_SUGGEST)
-	case monitor.LB_UN_USED:
-		out.Suggest = string(monitor.LB_MONITOR_SUGGEST)
-	case monitor.SCALE_DOWN:
-		out.Suggest = string(monitor.SCALE_DOWN_MONITOR_SUGGEST)
-
-	}
+	out.Suggest = string(drv.GetSuggest())
 	return out
 }
 
@@ -279,10 +282,10 @@ func (self *SSuggestSysAlert) StartDeleteTask(
 	ctx context.Context, userCred mcclient.TokenCredential) error {
 	params := jsonutils.NewDict()
 
-	return GetSuggestSysRuleDrivers()[self.Type].StartResolveTask(ctx, userCred, self, params)
+	return self.GetDriver().StartResolveTask(ctx, userCred, self, params)
 }
 
-func (self *SSuggestSysAlertManager) GetResources(tp ...string) ([]SSuggestSysAlert, error) {
+func (self *SSuggestSysAlertManager) GetResources(tp ...monitor.SuggestDriverType) ([]SSuggestSysAlert, error) {
 	resources := make([]SSuggestSysAlert, 0)
 	query := self.Query()
 	if len(tp) > 0 {

pkg/monitor/models/suggestsysrule.go

@@ -65,8 +65,8 @@ type SSuggestSysRule struct {
 	ExecTime time.Time            `list:"user" update:"user"`
 }
 
-func (man *SSuggestSysRuleManager) FetchSuggestSysAlartSettings(ruleTypes ...string) (map[string]*monitor.SuggestSysRuleDetails, error) {
-	suggestSysAlerSettingMap := make(map[string]*monitor.SuggestSysRuleDetails, 0)
+func (man *SSuggestSysRuleManager) FetchSuggestSysAlertSettings(ruleTypes ...monitor.SuggestDriverType) (map[monitor.SuggestDriverType]*monitor.SuggestSysRuleDetails, error) {
+	suggestSysAlerSettingMap := make(map[monitor.SuggestDriverType]*monitor.SuggestSysRuleDetails, 0)
 
 	rules, err := man.GetRules(ruleTypes...)
 	if err != nil {
@@ -77,15 +77,19 @@ func (man *SSuggestSysRuleManager) FetchSuggestSysAlartSettings(ruleTypes ...str
 		if err != nil {
 			return suggestSysAlerSettingMap, errors.Wrap(err, "FetchSuggestSysAlartSettings")
 		}
-		suggestSysAlerSettingMap[config.Type] = &suggestSysRuleDetails
+		suggestSysAlerSettingMap[config.GetType()] = &suggestSysRuleDetails
 	}
 	return suggestSysAlerSettingMap, nil
 }
 
+func (rule *SSuggestSysRule) GetType() monitor.SuggestDriverType {
+	return monitor.SuggestDriverType(rule.Type)
+}
+
 //根据数据库中查询得到的信息进行适配转换，同时更新drivers中的内容
-func (dConfig *SSuggestSysRule) getSuggestSysAlertSetting() (*monitor.SSuggestSysAlertSetting, error) {
+func (rule *SSuggestSysRule) getSuggestSysAlertSetting() (*monitor.SSuggestSysAlertSetting, error) {
 	setting := new(monitor.SSuggestSysAlertSetting)
-	err := dConfig.Setting.Unmarshal(setting)
+	err := rule.Setting.Unmarshal(setting)
 	if err != nil {
 		return nil, errors.Wrap(err, "SSuggestSysRule getSuggestSysAlertSetting error")
 	}
@@ -134,15 +138,16 @@ func (man *SSuggestSysRuleManager) ValidateCreateData(
 	if _, err := time.ParseDuration(data.TimeFrom); err != nil {
 		return data, httperrors.NewInputParameterError("Invalid period format: %s", data.TimeFrom)
 	}
-	if dri, ok := suggestSysRuleDrivers[data.Type]; !ok {
+	if dri, ok := suggestSysRuleDrivers[monitor.SuggestDriverType(data.Type)]; !ok {
 		return data, httperrors.NewInputParameterError("not support type %q", data.Type)
 	} else {
 		//Type is uniq
 		err := db.NewNameValidator(man, ownerId, data.Type, "")
 		if err != nil {
 			return data, err
 		}
-		if data.Type == monitor.SCALE_DOWN || data.Type == monitor.SCALE_UP {
+		drvType := monitor.SuggestDriverType(data.Type)
+		if drvType == monitor.SCALE_DOWN || drvType == monitor.SCALE_UP {
 			if data.Setting == nil {
 				return data, httperrors.NewInputParameterError("no found rule setting")
 			}
@@ -157,6 +162,10 @@ func (man *SSuggestSysRuleManager) ValidateCreateData(
 	return data, nil
 }
 
+func (rule *SSuggestSysRule) GetDriver() ISuggestSysRuleDriver {
+	return GetSuggestSysRuleDrivers()[rule.GetType()]
+}
+
 func (rule *SSuggestSysRule) ValidateUpdateData(
 	ctx context.Context, userCred mcclient.TokenCredential,
 	query jsonutils.JSONObject,
@@ -172,7 +181,7 @@ func (rule *SSuggestSysRule) ValidateUpdateData(
 		return data, httperrors.NewInputParameterError("Invalid period format: %s", data.Period)
 	}
 	if data.Setting != nil {
-		err := suggestSysRuleDrivers[rule.Type].ValidateSetting(data.Setting)
+		err := rule.GetDriver().ValidateSetting(data.Setting)
 		if err != nil {
 			return data, errors.Wrap(err, "validate setting error")
 		}
@@ -238,7 +247,7 @@ func (self *SSuggestSysRule) updateCronjob() {
 	if self.Enabled.Bool() {
 		dur, _ := time.ParseDuration(self.Period)
 		cronman.GetCronJobManager().AddJobAtIntervalsWithStartRun(self.Type, dur,
-			suggestSysRuleDrivers[self.Type].DoSuggestSysRule, true)
+			self.GetDriver().DoSuggestSysRule, true)
 	}
 }
 
@@ -323,7 +332,7 @@ func (self *SSuggestSysRuleManager) GetPropertyMetricMeasurement(ctx context.Con
 	return DataSourceManager.GetMetricMeasurement(query)
 }
 
-func (self *SSuggestSysRuleManager) GetRules(tp ...string) ([]SSuggestSysRule, error) {
+func (self *SSuggestSysRuleManager) GetRules(tp ...monitor.SuggestDriverType) ([]SSuggestSysRule, error) {
 	rules := make([]SSuggestSysRule, 0)
 	query := self.Query()
 	if len(tp) > 0 {

pkg/monitor/models/suggestsysruledrivers.go

@@ -25,12 +25,14 @@ import (
 
 var (
 	//存储初始化的内容，同时起到默认配置的作用。
-	suggestSysRuleDrivers = make(map[string]ISuggestSysRuleDriver, 0)
+	suggestSysRuleDrivers = make(map[monitor.SuggestDriverType]ISuggestSysRuleDriver, 0)
 )
 
 type ISuggestSysRuleDriver interface {
-	GetType() string
-	GetResourceType() string
+	GetType() monitor.SuggestDriverType
+	GetResourceType() monitor.MonitorResourceType
+	GetAction() monitor.SuggestDriverAction
+	GetSuggest() monitor.MonitorSuggest
 	//validate on create
 	ValidateSetting(input *monitor.SSuggestSysAlertSetting) error
 
@@ -50,6 +52,6 @@ func RegisterSuggestSysRuleDrivers(drvs ...ISuggestSysRuleDriver) {
 	}
 }
 
-func GetSuggestSysRuleDrivers() map[string]ISuggestSysRuleDriver {
+func GetSuggestSysRuleDrivers() map[monitor.SuggestDriverType]ISuggestSysRuleDriver {
 	return suggestSysRuleDrivers
 }

pkg/monitor/suggestsysdrivers/base.go

@@ -0,0 +1,56 @@
+// Copyright 2019 Yunion
+//
+// 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 suggestsysdrivers
+
+import (
+	"yunion.io/x/onecloud/pkg/apis/monitor"
+)
+
+type baseDriver struct {
+	driverType   monitor.SuggestDriverType
+	resourceType monitor.MonitorResourceType
+	action       monitor.SuggestDriverAction
+	suggest      monitor.MonitorSuggest
+}
+
+func newBaseDriver(
+	drvType monitor.SuggestDriverType,
+	resType monitor.MonitorResourceType,
+	action monitor.SuggestDriverAction,
+	suggest monitor.MonitorSuggest,
+) *baseDriver {
+	return &baseDriver{
+		driverType:   drvType,
+		resourceType: resType,
+		action:       action,
+		suggest:      suggest,
+	}
+}
+
+func (drv baseDriver) GetType() monitor.SuggestDriverType {
+	return drv.driverType
+}
+
+func (drv baseDriver) GetResourceType() monitor.MonitorResourceType {
+	return drv.resourceType
+}
+
+func (drv baseDriver) GetAction() monitor.SuggestDriverAction {
+	return drv.action
+}
+
+func (drv baseDriver) GetSuggest() monitor.MonitorSuggest {
+	return drv.suggest
+}

pkg/monitor/suggestsysdrivers/common.go

@@ -40,9 +40,19 @@ type logInput struct {
 	Limit   string `json:"limit"`
 }
 
-func DealAlertData(typ string, oldAlerts []models.SSuggestSysAlert, newAlerts []jsonutils.JSONObject) {
-	rules, _ := models.SuggestSysRuleManager.GetRules(typ)
+func DealAlertData(drvType monitor.SuggestDriverType, oldAlerts []models.SSuggestSysAlert, newAlerts []jsonutils.JSONObject) {
+	rules, err := models.SuggestSysRuleManager.GetRules(drvType)
+	if err != nil {
+		log.Errorf("get suggest rule by type %q error: %v", drvType, err)
+		return
+	}
+	if len(rules) == 0 {
+		log.Errorf("not found suggest rule by type %q", drvType)
+		return
+	}
+
 	rules[0].UpdateExecTime()
+	adminCredential := auth.AdminCredential()
 
 	oldMap := make(map[string]models.SSuggestSysAlert, 0)
 	for _, alert := range oldAlerts {
@@ -66,17 +76,16 @@ func DealAlertData(typ string, oldAlerts []models.SSuggestSysAlert, newAlerts []
 			delete(oldMap, res_id)
 		} else {
 			//新增的alert
-			adminCredential := auth.AdminCredential()
 			_, err := db.DoCreate(models.SuggestSysAlertManager, context.Background(), adminCredential, nil, newAlert,
 				adminCredential)
 			if err != nil {
-				log.Errorln(err)
+				log.Errorf("create new suggest alert %v error: %v", newAlert, err)
 			}
 		}
 	}
 
 	for _, oldAlert := range oldMap {
-		err := oldAlert.RealDelete(context.Background(), auth.AdminCredential())
+		err := oldAlert.RealDelete(context.Background(), adminCredential)
 		if err != nil {
 			log.Errorln("删除旧alert数据失败", err)
 		}
@@ -85,7 +94,7 @@ func DealAlertData(typ string, oldAlerts []models.SSuggestSysAlert, newAlerts []
 
 func doSuggestSysRule(ctx context.Context, userCred mcclient.TokenCredential, isStart bool, rule models.ISuggestSysRuleDriver) {
 	var instance *monitor.SSuggestSysAlertSetting
-	suggestSysSettingMap, err := models.SuggestSysRuleManager.FetchSuggestSysAlartSettings(rule.GetType())
+	suggestSysSettingMap, err := models.SuggestSysRuleManager.FetchSuggestSysAlertSettings(rule.GetType())
 	if err != nil {
 		log.Errorln("DoSuggestSysRule error :", err)
 		return
@@ -119,9 +128,9 @@ func getSuggestSysAlertFromJson(obj jsonutils.JSONObject, rule models.ISuggestSy
 	if val, err := alertData.GetString("account"); err == nil {
 		suggestSysAlert.Cloudaccount = val
 	}
-	suggestSysAlert.Type = rule.GetType()
+	suggestSysAlert.Type = string(rule.GetType())
 	suggestSysAlert.ResMeta = obj
-	suggestSysAlert.Action = monitor.DRIVER_ACTION
+	suggestSysAlert.Action = string(rule.GetAction())
 	suggestSysAlert.Status = monitor.SUGGEST_ALERT_READY
 	getResourceAmount(suggestSysAlert, time.Now().Add(-30*24*time.Hour))
 	return suggestSysAlert, nil

pkg/monitor/suggestsysdrivers/diskunused.go

@@ -33,34 +33,31 @@ import (
 )
 
 type DiskUnused struct {
-	monitor.DiskUnused
+	*baseDriver
 }
 
 func NewDiskUnusedDriver() models.ISuggestSysRuleDriver {
 	return &DiskUnused{
-		DiskUnused: monitor.DiskUnused{},
+		baseDriver: newBaseDriver(
+			monitor.DISK_UNUSED,
+			monitor.DISK_MONITOR_RES_TYPE,
+			monitor.DELETE_DRIVER_ACTION,
+			monitor.DISK_MONITOR_SUGGEST,
+		),
 	}
 }
 
-func (rule *DiskUnused) GetType() string {
-	return monitor.DISK_UN_USED
-}
-
-func (rule *DiskUnused) GetResourceType() string {
-	return string(monitor.DISK_MONITOR_RES_TYPE)
-}
-
 func (rule *DiskUnused) DoSuggestSysRule(ctx context.Context, userCred mcclient.TokenCredential, isStart bool) {
 	doSuggestSysRule(ctx, userCred, isStart, rule)
 }
 
-func (rule *DiskUnused) Run(instance *monitor.SSuggestSysAlertSetting) {
+func (rule *DiskUnused) Run(setting *monitor.SSuggestSysAlertSetting) {
 	oldAlert, err := getLastAlerts(rule)
 	if err != nil {
 		log.Errorln(err)
 		return
 	}
-	newAlerts, err := rule.getLatestAlerts(instance)
+	newAlerts, err := rule.getLatestAlerts(setting)
 	if err != nil {
 		log.Errorln(errors.Wrap(err, "DiskUnused getLatestAlerts error"))
 		return