Merge pull request #6026 from zhaoxiangchun/automated-cherry-pick-of-#6024-upstream-release-3.2

Automated cherry pick of #6024: lb 负载均衡优化建议

pkg/apis/monitor/suggestsys_const.go

@@ -17,6 +17,7 @@ package monitor
 const (
 	EIP_UN_USED  = "EIP_UNUSED"
 	DISK_UN_USED = "DISK_UNUSED"
+	LB_UN_USED   = "LB_UNUSED"
 
 	DRIVER_ACTION = "DELETE"
 
@@ -31,9 +32,11 @@ type MonitorResourceType string
 const (
 	EIP_MONITOR_RES_TYPE  = MonitorResourceType("弹性EIP")
 	DISK_MONITOR_RES_TYPE = MonitorResourceType("云硬盘")
+	LB_MONITOR_RES_TYPE   = MonitorResourceType("负载均衡实例")
 )
 
 const (
 	EIP_MONITOR_SUGGEST  = MonitorSuggest("释放未使用的EIP")
 	DISK_MONITOR_SUGGEST = MonitorSuggest("释放未使用的Disk")
+	LB_MONITOR_SUGGEST   = MonitorSuggest("释放未使用的LB")
 )

pkg/apis/monitor/suggestsysalert.go

@@ -51,6 +51,7 @@ type SuggestSysAlertDetails struct {
 	apis.VirtualResourceDetails
 	compute.CloudregionResourceInfo
 	RuleName string `json:"rule_name"`
+	ShowName string `json:"show_name"`
 	ResType  string `json:"res_type"`
 	Suggest  string `json:"suggest"`
 	Brand    string `json:"brand"`

pkg/apis/monitor/suggestsysrule.go

@@ -59,6 +59,7 @@ type SuggestSysRuleDetails struct {
 type SSuggestSysAlertSetting struct {
 	EIPUnused  *EIPUnused  `json:"eip_unused"`
 	DiskUnused *DiskUnused `json:"disk_unused"`
+	LBUnused   *LBUnused   `json:"lb_unused"`
 }
 
 type EIPUnused struct {
@@ -67,3 +68,6 @@ type EIPUnused struct {
 
 type DiskUnused struct {
 }
+
+type LBUnused struct {
+}

pkg/mcclient/options/monitor/suggestsysrule.go

@@ -38,7 +38,7 @@ type SuggestSysRuleAlertSettingOptions struct {
 type SuggestRuleCreateOptions struct {
 	SuggestSysRuleAlertSettingOptions
 	Name    string `help:"Name of the alert"`
-	Type    string `help:"Type of suggest rule" choices:"EIP_UNUSED|DISK_UNUSED"`
+	Type    string `help:"Type of suggest rule" choices:"EIP_UNUSED|DISK_UNUSED|LB_UNUSED"`
 	Enabled bool   `help:"Enable rule"`
 	Period  string `help:"Period of suggest rule e.g. '5s', '1m'" default:"30s""`
 }
@@ -49,11 +49,7 @@ func (opt SuggestRuleCreateOptions) Params() (jsonutils.JSONObject, error) {
 	input.Period = opt.Period
 	input.Type = strings.ToUpper(opt.Type)
 	input.Enabled = &opt.Enabled
-	if input.Type == monitor.EIP_UN_USED {
-		input.Setting = &monitor.SSuggestSysAlertSetting{
-			EIPUnused: &monitor.EIPUnused{},
-		}
-	}
+	input.Setting = newSuggestSysAlertSetting(input.Type)
 	return input.JSON(input), nil
 }
 
@@ -71,12 +67,27 @@ func (opt SuggestRuleUpdateOptions) Params() (jsonutils.JSONObject, error) {
 	input.Period = opt.Period
 	input.Enabled = &opt.Enabled
 	input.Name = opt.Name
-	if input.Type == monitor.EIP_UN_USED {
-		input.Setting = &monitor.SSuggestSysAlertSetting{
+	input.Setting = newSuggestSysAlertSetting(input.Type)
+	return input.JSON(input), nil
+}
+
+func newSuggestSysAlertSetting(tp string) *monitor.SSuggestSysAlertSetting {
+	setting := new(monitor.SSuggestSysAlertSetting)
+	switch tp {
+	case monitor.EIP_UN_USED:
+		setting = &monitor.SSuggestSysAlertSetting{
 			EIPUnused: &monitor.EIPUnused{},
 		}
+	case monitor.DISK_UN_USED:
+		setting = &monitor.SSuggestSysAlertSetting{
+			DiskUnused: &monitor.DiskUnused{},
+		}
+	case monitor.LB_UN_USED:
+		setting = &monitor.SSuggestSysAlertSetting{
+			LBUnused: &monitor.LBUnused{},
+		}
 	}
-	return input.JSON(input), nil
+	return setting
 }
 
 type SuggestRuleDeleteOptions struct {

pkg/monitor/models/suggestsysalart.go

@@ -16,6 +16,7 @@ package models
 
 import (
 	"context"
+	"fmt"
 	"strings"
 
 	"yunion.io/x/jsonutils"
@@ -184,17 +185,22 @@ func (self *SSuggestSysAlert) getMoreDetails(out monitor.SuggestSysAlertDetails)
 		log.Errorln("SSuggestSysAlert getMoreDetails's error:", err)
 	}
 	out.Account = self.Cloudaccount
-	suggestSysSettingMap, _ := SuggestSysRuleManager.FetchSuggestSysAlartSettings(self.Type)
 	out.ResType = GetSuggestSysRuleDrivers()[self.Type].GetResourceType()
 	out.RuleName = strings.ToLower(GetSuggestSysRuleDrivers()[self.Type].GetType())
-	if _, ok := suggestSysSettingMap[self.Type]; ok {
-		out.RuleName = suggestSysSettingMap[self.Type].Name
+	rule, _ := SuggestSysRuleManager.GetRules(self.Type)
+	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)
+
 	}
 	return out
 }
@@ -266,3 +272,28 @@ func (self *SSuggestSysAlert) StartDeleteTask(
 	self.SetStatus(userCred, api.EIP_UNUSED_START_DELETE, "")
 	return GetSuggestSysRuleDrivers()[self.Type].StartResolveTask(ctx, userCred, self, params)
 }
+
+func (self *SSuggestSysAlertManager) GetResources(tp ...string) ([]SSuggestSysAlert, error) {
+	resources := make([]SSuggestSysAlert, 0)
+	query := self.Query()
+	if len(tp) > 0 {
+		query.In("type", tp)
+	}
+	err := db.FetchModelObjects(self, query, &resources)
+	if err != nil {
+		return resources, err
+	}
+	return resources, nil
+}
+
+func (manager *SSuggestSysAlertManager) GetExportExtraKeys(ctx context.Context, keys stringutils2.SSortedStrings, rowMap map[string]string) *jsonutils.JSONDict {
+	alert := new(SSuggestSysAlert)
+	manager.Query().RowMap2Struct(rowMap, alert)
+	input := monitor.SuggestSysAlertDetails{}
+	input = alert.getMoreDetails(input)
+	res := jsonutils.Marshal(&input)
+	dic := res.(*jsonutils.JSONDict)
+	dic.Add(jsonutils.NewString(input.Account), "manager")
+	dic.Add(jsonutils.NewString(alert.Provider), "hypervisor")
+	return dic
+}

pkg/monitor/models/suggestsysrule.go

@@ -17,7 +17,6 @@ package models
 import (
 	"context"
 	"database/sql"
-	"fmt"
 	"time"
 
 	"yunion.io/x/jsonutils"
@@ -66,20 +65,13 @@ type SSuggestSysRule struct {
 }
 
 func (man *SSuggestSysRuleManager) FetchSuggestSysAlartSettings(ruleTypes ...string) (map[string]*monitor.SuggestSysRuleDetails, error) {
-	objs := make([]SSuggestSysRule, 0)
 	suggestSysAlerSettingMap := make(map[string]*monitor.SuggestSysRuleDetails, 0)
-	q := man.Query()
-	if q == nil {
-		fmt.Println(" query is nil")
-	}
-	if len(ruleTypes) != 0 {
-		q.Equals("type", ruleTypes)
-	}
-	err := db.FetchModelObjects(man, q, &objs)
-	if err != nil && err != sql.ErrNoRows {
+
+	rules, err := man.GetRules(ruleTypes...)
+	if err != nil {
 		return suggestSysAlerSettingMap, errors.Wrap(err, "FetchSuggestSysAlartSettings")
 	}
-	for _, config := range objs {
+	for _, config := range rules {
 		suggestSysRuleDetails := config.getMoreDetails(monitor.SuggestSysRuleDetails{})
 		if err != nil {
 			return suggestSysAlerSettingMap, errors.Wrap(err, "FetchSuggestSysAlartSettings")
@@ -132,6 +124,10 @@ func (man *SSuggestSysRuleManager) ValidateCreateData(
 		// default 30s
 		data.Period = "30s"
 	}
+	if data.Enabled == nil {
+		enable := true
+		data.Enabled = &enable
+	}
 	if _, err := time.ParseDuration(data.Period); err != nil {
 		return data, httperrors.NewInputParameterError("Invalid period format: %s", data.Period)
 	}
@@ -254,3 +250,35 @@ func (self *SSuggestSysRule) PerformEnable(ctx context.Context, userCred mcclien
 	}
 	return nil, nil
 }
+
+func (self *SSuggestSysRuleManager) AllowGetPropertyRuleType(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject) bool {
+	return true
+}
+
+func (self *SSuggestSysRuleManager) GetPropertyRuleType(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject) (jsonutils.JSONObject, error) {
+	ret := jsonutils.NewDict()
+	ruleArr := jsonutils.NewArray()
+	ret.Add(ruleArr, "rule-type")
+	rules, err := self.GetRules()
+	if err != nil {
+		return ret, err
+	}
+	for _, rule := range rules {
+		ruleArr.Add(jsonutils.NewString(rule.Type))
+	}
+	return ret, nil
+}
+
+func (self *SSuggestSysRuleManager) GetRules(tp ...string) ([]SSuggestSysRule, error) {
+	rules := make([]SSuggestSysRule, 0)
+	query := self.Query()
+	if len(tp) > 0 {
+		query.In("type", tp)
+	}
+	err := db.FetchModelObjects(self, query, &rules)
+	if err != nil && err != sql.ErrNoRows {
+		log.Errorln(errors.Wrap(err, "db.FetchModelObjects"))
+		return rules, err
+	}
+	return rules, nil
+}

pkg/monitor/suggestsysdrivers/common.go

@@ -0,0 +1,98 @@
+package suggestsysdrivers
+
+import (
+	"context"
+	"fmt"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
+	"yunion.io/x/pkg/errors"
+
+	"yunion.io/x/onecloud/pkg/apis/monitor"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/mcclient/auth"
+	"yunion.io/x/onecloud/pkg/monitor/models"
+)
+
+func DealAlertData(oldAlerts []models.SSuggestSysAlert, newAlerts []jsonutils.JSONObject) {
+	oldMap := make(map[string]models.SSuggestSysAlert, 0)
+	for _, alert := range oldAlerts {
+		oldMap[alert.ResId] = alert
+	}
+	for _, newAlert := range newAlerts {
+		res_id, _ := newAlert.GetString("res_id")
+		if oldAlert, ok := oldMap[res_id]; ok {
+			//更新的alert
+			_, err := db.Update(&oldAlert, func() error {
+				err := newAlert.Unmarshal(&oldAlert)
+				if err != nil {
+					errMsg := fmt.Sprintf("unmarshal fail: %s", err)
+					log.Errorf(errMsg)
+				}
+				return nil
+			})
+			if err != nil {
+				log.Errorln("更新alert失败", err)
+			}
+			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)
+			}
+		}
+	}
+
+	for _, oldAlert := range oldMap {
+		err := oldAlert.RealDelete(context.Background(), auth.AdminCredential())
+		if err != nil {
+			log.Errorln("删除旧alert数据失败", err)
+		}
+	}
+}
+
+func doSuggestSysRule(ctx context.Context, userCred mcclient.TokenCredential, isStart bool, rule models.ISuggestSysRuleDriver) {
+	var instance *monitor.SSuggestSysAlertSetting
+	suggestSysSettingMap, err := models.SuggestSysRuleManager.FetchSuggestSysAlartSettings(rule.GetType())
+	if err != nil {
+		log.Errorln("DoSuggestSysRule error :", err)
+		return
+	}
+	if details, ok := suggestSysSettingMap[rule.GetType()]; ok {
+		instance = details.Setting
+	}
+	rule.Run(instance)
+}
+
+func getLastAlerts(rule models.ISuggestSysRuleDriver) ([]models.SSuggestSysAlert, error) {
+	oldAlert, err := models.SuggestSysAlertManager.GetResources(rule.GetType())
+	if err != nil {
+		log.Errorln(errors.Wrap(err, "db.FetchModelObjects"))
+		return oldAlert, err
+	}
+	return oldAlert, nil
+}
+
+func getSuggestSysAlertFromJson(obj jsonutils.JSONObject, rule models.ISuggestSysRuleDriver) (*models.SSuggestSysAlert, error) {
+	suggestSysAlert := new(models.SSuggestSysAlert)
+	alertData := jsonutils.DeepCopy(obj).(*jsonutils.JSONDict)
+	id, _ := alertData.GetString("id")
+	alertData.Add(jsonutils.NewString(id), "res_id")
+	alertData.Remove("id")
+
+	err := alertData.Unmarshal(suggestSysAlert)
+	if err != nil {
+		return nil, errors.Wrap(err, "getSuggestSysAlertFromJson's alertData Unmarshal error")
+	}
+	if val, err := alertData.GetString("account"); err == nil {
+		suggestSysAlert.Cloudaccount = val
+	}
+	suggestSysAlert.Type = rule.GetType()
+	suggestSysAlert.ResMeta = obj
+	suggestSysAlert.Action = monitor.DRIVER_ACTION
+	return suggestSysAlert, nil
+}

pkg/monitor/suggestsysdrivers/diskunused.go

@@ -2,14 +2,12 @@ package suggestsysdrivers
 
 import (
 	"context"
-	"database/sql"
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 
 	"yunion.io/x/onecloud/pkg/apis/monitor"
-	"yunion.io/x/onecloud/pkg/cloudcommon/db"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/auth"
@@ -23,7 +21,7 @@ type DiskUnused struct {
 
 func NewDiskUnusedDriver() models.ISuggestSysRuleDriver {
 	return &DiskUnused{
-		monitor.DiskUnused{},
+		DiskUnused: monitor.DiskUnused{},
 	}
 }
 
@@ -36,20 +34,11 @@ func (rule *DiskUnused) GetResourceType() string {
 }
 
 func (rule *DiskUnused) DoSuggestSysRule(ctx context.Context, userCred mcclient.TokenCredential, isStart bool) {
-	var instance *monitor.SSuggestSysAlertSetting
-	suggestSysSettingMap, err := models.SuggestSysRuleManager.FetchSuggestSysAlartSettings(rule.GetType())
-	if err != nil {
-		log.Errorln("DoSuggestSysRule error :", err)
-		return
-	}
-	if details, ok := suggestSysSettingMap[rule.GetType()]; ok {
-		instance = details.Setting
-	}
-	rule.Run(instance)
+	doSuggestSysRule(ctx, userCred, isStart, rule)
 }
 
 func (rule *DiskUnused) Run(instance *monitor.SSuggestSysAlertSetting) {
-	oldAlert, err := rule.getLastAlerts()
+	oldAlert, err := getLastAlerts(rule)
 	if err != nil {
 		log.Errorln(err)
 		return
@@ -62,18 +51,6 @@ func (rule *DiskUnused) Run(instance *monitor.SSuggestSysAlertSetting) {
 	DealAlertData(oldAlert, newAlerts.Value())
 }
 
-func (rule *DiskUnused) getLastAlerts() ([]models.SSuggestSysAlert, error) {
-	oldAlert := make([]models.SSuggestSysAlert, 0)
-	q := models.SuggestSysAlertManager.Query()
-	q.Equals("type", monitor.DISK_UN_USED)
-	err := db.FetchModelObjects(models.SuggestSysAlertManager, q, &oldAlert)
-	if err != nil && err != sql.ErrNoRows {
-		log.Errorln(errors.Wrap(err, "db.FetchModelObjects"))
-		return oldAlert, err
-	}
-	return oldAlert, nil
-}
-
 func (rule *DiskUnused) getLatestAlerts(instance *monitor.SSuggestSysAlertSetting) (*jsonutils.JSONArray, error) {
 	session := auth.GetAdminSession(context.Background(), "", "")
 	query := jsonutils.NewDict()
@@ -86,16 +63,11 @@ func (rule *DiskUnused) getLatestAlerts(instance *monitor.SSuggestSysAlertSettin
 	}
 	DiskUnusedArr := jsonutils.NewArray()
 	for _, disk := range disks.Data {
-		suggestSysAlert := new(models.SSuggestSysAlert)
-		alertData := jsonutils.DeepCopy(disk).(*jsonutils.JSONDict)
-		id, _ := alertData.GetString("id")
-		alertData.Add(jsonutils.NewString(id), "res_id")
-		alertData.Remove("id")
-
-		err := alertData.Unmarshal(suggestSysAlert)
+		suggestSysAlert, err := getSuggestSysAlertFromJson(disk, rule)
 		if err != nil {
 			return DiskUnusedArr, errors.Wrap(err, "getEIPUnused's alertData Unmarshal error")
 		}
+
 		input := &monitor.SSuggestSysAlertSetting{
 			DiskUnused: &monitor.DiskUnused{},
 		}
@@ -107,11 +79,6 @@ func (rule *DiskUnused) getLatestAlerts(instance *monitor.SSuggestSysAlertSettin
 		problem := jsonutils.NewDict()
 		problem.Add(jsonutils.NewString(rule.GetType()), "disk")
 		suggestSysAlert.Problem = problem
-
-		suggestSysAlert.Type = rule.GetType()
-
-		suggestSysAlert.Action = monitor.DRIVER_ACTION
-		suggestSysAlert.ResMeta = disk
 		DiskUnusedArr.Add(jsonutils.Marshal(suggestSysAlert))
 	}
 	return DiskUnusedArr, nil

pkg/monitor/suggestsysdrivers/driverconfig.go

@@ -15,39 +15,25 @@
 package suggestsysdrivers
 
 import (
-	"context"
 	"database/sql"
-	"fmt"
 	"time"
 
-	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
 
 	"yunion.io/x/onecloud/pkg/cloudcommon/cronman"
-	"yunion.io/x/onecloud/pkg/cloudcommon/db"
-	"yunion.io/x/onecloud/pkg/mcclient/auth"
 	"yunion.io/x/onecloud/pkg/monitor/models"
 )
 
 func init() {
-	models.RegisterSuggestSysRuleDrivers(NewEIPUsedDriver(), NewDiskUnusedDriver())
+	models.RegisterSuggestSysRuleDrivers(NewEIPUsedDriver(), NewDiskUnusedDriver(), NewLBUnusedDriver())
 }
 
 func InitSuggestSysRuleCronjob() {
-	objs := make([]models.SSuggestSysRule, 0)
-	q := models.SuggestSysRuleManager.Query()
-	if q == nil {
-		fmt.Println(" query is nil")
-	}
-	err := db.FetchModelObjects(models.SuggestSysRuleManager, q, &objs)
+	rules, err := models.SuggestSysRuleManager.GetRules()
 	if err != nil && err != sql.ErrNoRows {
 		log.Errorln("InitSuggestSysRuleCronjob db.FetchModelObjects error")
 	}
-	for _, driver := range models.GetSuggestSysRuleDrivers() {
-		cronman.GetCronJobManager().AddJobAtIntervalsWithStartRun(driver.GetType(), time.Duration(30)*time.Second,
-			driver.DoSuggestSysRule, true)
-	}
-	for _, suggestSysRuleConfig := range objs {
+	for _, suggestSysRuleConfig := range rules {
 		cronman.GetCronJobManager().Remove(suggestSysRuleConfig.Type)
 		if suggestSysRuleConfig.Enabled.Bool() {
 			dur, _ := time.ParseDuration(suggestSysRuleConfig.Period)
@@ -56,43 +42,3 @@ func InitSuggestSysRuleCronjob() {
 		}
 	}
 }
-
-func DealAlertData(oldAlerts []models.SSuggestSysAlert, newAlerts []jsonutils.JSONObject) {
-	oldMap := make(map[string]models.SSuggestSysAlert, 0)
-	for _, alert := range oldAlerts {
-		oldMap[alert.ResId] = alert
-	}
-	for _, newAlert := range newAlerts {
-		res_id, _ := newAlert.GetString("res_id")
-		if oldAlert, ok := oldMap[res_id]; ok {
-			//更新的alert
-			_, err := db.Update(&oldAlert, func() error {
-				err := newAlert.Unmarshal(&oldAlert)
-				if err != nil {
-					errMsg := fmt.Sprintf("unmarshal fail: %s", err)
-					log.Errorf(errMsg)
-				}
-				return nil
-			})
-			if err != nil {
-				log.Errorln("更新alert失败", err)
-			}
-			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)
-			}
-		}
-	}
-
-	for _, oldAlert := range oldMap {
-		err := oldAlert.Delete(context.Background(), auth.AdminCredential())
-		if err != nil {
-			log.Errorln("删除旧alert数据失败", err)
-		}
-	}
-}

pkg/monitor/suggestsysdrivers/eipunused.go

@@ -16,14 +16,12 @@ package suggestsysdrivers
 
 import (
 	"context"
-	"database/sql"
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 
 	"yunion.io/x/onecloud/pkg/apis/monitor"
-	"yunion.io/x/onecloud/pkg/cloudcommon/db"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/mcclient/auth"
@@ -45,9 +43,7 @@ func (_ *EIPUnused) GetResourceType() string {
 
 func NewEIPUsedDriver() models.ISuggestSysRuleDriver {
 	return &EIPUnused{
-		monitor.EIPUnused{
-			//Status: "",
-		},
+		EIPUnused: monitor.EIPUnused{},
 	}
 }
 
@@ -58,12 +54,9 @@ func (dri *EIPUnused) ValidateSetting(input *monitor.SSuggestSysAlertSetting) er
 }
 
 func (rule *EIPUnused) Run(instance *monitor.SSuggestSysAlertSetting) {
-	oldAlert := make([]models.SSuggestSysAlert, 0)
-	q := models.SuggestSysAlertManager.Query()
-	q.Equals("type", monitor.EIP_UN_USED)
-	err := db.FetchModelObjects(models.SuggestSysAlertManager, q, &oldAlert)
-	if err != nil && err != sql.ErrNoRows {
-		log.Errorln(errors.Wrap(err, "db.FetchModelObjects"))
+	oldAlert, err := getLastAlerts(rule)
+	if err != nil {
+		log.Errorln(err)
 		return
 	}
 	newAlert, err := rule.getEIPUnused(instance)
@@ -90,19 +83,10 @@ func (rule *EIPUnused) getEIPUnused(instance *monitor.SSuggestSysAlertSetting) (
 		if row.ContainsIgnoreCases("associate_type") || row.ContainsIgnoreCases("associate_id") {
 			continue
 		}
-		suggestSysAlert := new(models.SSuggestSysAlert)
-		alertData := jsonutils.DeepCopy(row).(*jsonutils.JSONDict)
-		id, _ := alertData.GetString("id")
-		alertData.Add(jsonutils.NewString(id), "res_id")
-		alertData.Remove("id")
-
-		err := alertData.Unmarshal(suggestSysAlert)
+		suggestSysAlert, err := getSuggestSysAlertFromJson(row, rule)
 		if err != nil {
 			return EIPUnsedArr, errors.Wrap(err, "getEIPUnused's alertData Unmarshal error")
 		}
-		if val, err := alertData.GetString("account"); err == nil {
-			suggestSysAlert.Cloudaccount = val
-		}
 
 		input := &monitor.SSuggestSysAlertSetting{
 			EIPUnused: &monitor.EIPUnused{},
@@ -116,10 +100,6 @@ func (rule *EIPUnused) getEIPUnused(instance *monitor.SSuggestSysAlertSetting) (
 		problem.Add(jsonutils.NewString(rule.GetType()), "eip")
 		suggestSysAlert.Problem = problem
 
-		suggestSysAlert.Type = rule.GetType()
-
-		suggestSysAlert.Action = monitor.DRIVER_ACTION
-		suggestSysAlert.ResMeta = row
 		EIPUnsedArr.Add(jsonutils.Marshal(suggestSysAlert))
 	}
 	return EIPUnsedArr, nil

pkg/monitor/suggestsysdrivers/lbunused.go

@@ -0,0 +1,163 @@
+package suggestsysdrivers
+
+import (
+	"context"
+
+	"yunion.io/x/jsonutils"
+	"yunion.io/x/log"
+	"yunion.io/x/pkg/errors"
+
+	"yunion.io/x/onecloud/pkg/apis/monitor"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
+	"yunion.io/x/onecloud/pkg/mcclient"
+	"yunion.io/x/onecloud/pkg/mcclient/auth"
+	"yunion.io/x/onecloud/pkg/mcclient/modules"
+	"yunion.io/x/onecloud/pkg/monitor/models"
+)
+
+type LBUnused struct {
+	monitor.LBUnused
+}
+
+func NewLBUnusedDriver() models.ISuggestSysRuleDriver {
+	return &LBUnused{
+		LBUnused: monitor.LBUnused{},
+	}
+}
+
+func (_ *LBUnused) GetType() string {
+	return monitor.LB_UN_USED
+}
+
+func (rule *LBUnused) GetResourceType() string {
+	return string(monitor.LB_MONITOR_RES_TYPE)
+}
+
+func (rule *LBUnused) ValidateSetting(input *monitor.SSuggestSysAlertSetting) error {
+	obj := new(monitor.LBUnused)
+	input.LBUnused = obj
+	return nil
+}
+
+func (rule *LBUnused) DoSuggestSysRule(ctx context.Context, userCred mcclient.TokenCredential, isStart bool) {
+	doSuggestSysRule(ctx, userCred, isStart, rule)
+}
+
+func (rule *LBUnused) Run(instance *monitor.SSuggestSysAlertSetting) {
+	oldAlert, err := getLastAlerts(rule)
+	if err != nil {
+		log.Errorln(err)
+		return
+	}
+	newAlert, err := rule.getLatestAlerts(instance)
+	if err != nil {
+		log.Errorln(errors.Wrap(err, "getEIPUnused error"))
+		return
+	}
+	DealAlertData(oldAlert, newAlert.Value())
+}
+
+func (rule *LBUnused) getLatestAlerts(instance *monitor.SSuggestSysAlertSetting) (*jsonutils.JSONArray, error) {
+	session := auth.GetAdminSession(context.Background(), "", "")
+	query := jsonutils.NewDict()
+	query.Add(jsonutils.NewString("0"), "limit")
+	query.Add(jsonutils.NewString("system"), "scope")
+	lbs, err := modules.Loadbalancers.List(session, query)
+	if err != nil {
+		return nil, err
+	}
+	lbArr := jsonutils.NewArray()
+	for _, lb := range lbs.Data {
+		lbId, _ := lb.GetString("id")
+		contains, err := containsLbBackEndGroups(lbId)
+		if err != nil {
+			return lbArr, err
+		}
+		if *contains {
+			continue
+		}
+
+		suggestSysAlert, err := getSuggestSysAlertFromJson(lb, rule)
+		if err != nil {
+			return lbArr, errors.Wrap(err, "getLatestAlerts's alertData Unmarshal error")
+		}
+
+		input := &monitor.SSuggestSysAlertSetting{
+			LBUnused: &monitor.LBUnused{},
+		}
+		suggestSysAlert.MonitorConfig = jsonutils.Marshal(input)
+		if instance != nil {
+			suggestSysAlert.MonitorConfig = jsonutils.Marshal(instance)
+		}
+
+		problem := jsonutils.NewDict()
+		problem.Add(jsonutils.NewString(rule.GetType()), "lb")
+		suggestSysAlert.Problem = problem
+
+		lbArr.Add(jsonutils.Marshal(suggestSysAlert))
+	}
+	return lbArr, nil
+}
+
+func containsLbBackEndGroups(lbId string) (*bool, error) {
+	contains := false
+	session := auth.GetAdminSession(context.Background(), "", "")
+	query := jsonutils.NewDict()
+	query.Add(jsonutils.NewString("0"), "limit")
+	query.Add(jsonutils.NewString("system"), "scope")
+	query.Add(jsonutils.NewString(lbId), "loadbalancer")
+	groups, err := modules.LoadbalancerBackendGroups.List(session, query)
+	if err != nil {
+		return nil, err
+	}
+	for _, group := range groups.Data {
+		groupId, _ := group.GetString("id")
+		backEnds, err := containsLbBackEnd(groupId)
+		if err != nil {
+			return nil, err
+		}
+		if *backEnds {
+			return backEnds, nil
+		}
+	}
+	return &contains, nil
+}
+
+func containsLbBackEnd(groupId string) (*bool, error) {
+	contains := false
+	session := auth.GetAdminSession(context.Background(), "", "")
+	query := jsonutils.NewDict()
+	query.Add(jsonutils.NewString("0"), "limit")
+	query.Add(jsonutils.NewString("system"), "scope")
+	query.Add(jsonutils.NewString(groupId), "backend_group")
+	backEnds, err := modules.LoadbalancerBackends.List(session, query)
+	if err != nil {
+		return nil, err
+	}
+	if len(backEnds.Data) > 0 {
+		contains = true
+		return &contains, nil
+	}
+	return &contains, nil
+}
+
+func (rule *LBUnused) StartResolveTask(ctx context.Context, userCred mcclient.TokenCredential,
+	suggestSysAlert *models.SSuggestSysAlert,
+	params *jsonutils.JSONDict) error {
+	task, err := taskman.TaskManager.NewTask(ctx, "ResolveUnusedTask", suggestSysAlert, userCred, params, "", "", nil)
+	if err != nil {
+		return err
+	}
+	task.ScheduleRun(nil)
+	return nil
+}
+
+func (rule *LBUnused) Resolve(data *models.SSuggestSysAlert) error {
+	session := auth.GetAdminSession(context.Background(), "", "")
+	_, err := modules.Loadbalancers.Delete(session, data.ResId, jsonutils.NewDict())
+	if err != nil {
+		log.Errorln("delete unused lb error", err)
+		return err
+	}
+	return nil
+}