fix(region): elastic cache purge

pkg/compute/models/elasticcache_instances.go

@@ -577,22 +577,11 @@ func (self *SElasticcache) syncRemoveCloudElasticcache(ctx context.Context, user
 
 	self.SetDisableDelete(userCred, false)
 
-	self.DeleteSubResources(ctx, userCred)
-
-	err := self.ValidatePurgeCondition(ctx)
-	if err != nil {
-		self.SetStatus(userCred, api.ELASTIC_CACHE_STATUS_ERROR, "sync to delete")
-		return errors.Wrap(err, "ValidateDeleteCondition")
-	}
-	err = self.SVirtualResourceBase.Delete(ctx, userCred)
-	if err != nil {
-		return err
-	}
 	notifyclient.EventNotify(ctx, userCred, notifyclient.SEventNotifyParam{
 		Obj:    self,
 		Action: notifyclient.ActionSyncDelete,
 	})
-	return nil
+	return self.RealDelete(ctx, userCred)
 }
 
 func (self *SElasticcache) SyncWithCloudElasticcache(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, extInstance cloudprovider.ICloudElasticcache) error {
@@ -1418,53 +1407,63 @@ func (self *SElasticcache) StartSyncTask(ctx context.Context, userCred mcclient.
 }
 
 // 清理所有关联资源记录
-func (self *SElasticcache) DeleteSubResources(ctx context.Context, userCred mcclient.TokenCredential) {
+func (self *SElasticcache) DeleteSubResources(ctx context.Context, userCred mcclient.TokenCredential) error {
 	ms := []db.IResourceModelManager{
+		ElasticcachesecgroupManager,
 		ElasticcacheAccountManager,
 		ElasticcacheAclManager,
 		ElasticcacheBackupManager,
 		ElasticcacheParameterManager,
 	}
-
 	ownerId := self.GetOwnerId()
-	for _, m := range ms {
-		func(man db.IResourceModelManager) {
-			lockman.LockClass(ctx, man, db.GetLockClassKey(man, ownerId))
-			defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, ownerId))
-			q := man.Query().IsFalse("deleted").Equals("elasticcache_id", self.GetId())
+	delFunc := func(man db.IResourceModelManager) error {
+		lockman.LockClass(ctx, man, db.GetLockClassKey(man, ownerId))
+		defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, ownerId))
+		q := man.Query().IsFalse("deleted").Equals("elasticcache_id", self.GetId())
 
-			models := make([]interface{}, 0)
-			err := db.FetchModelObjects(man, q, &models)
+		models := make([]interface{}, 0)
+		err := db.FetchModelObjects(man, q, &models)
+		if err != nil {
+			return errors.Wrapf(err, "db.FetchModelObjects")
+		}
+
+		for i := range models {
+			var imodel db.IModel
+			switch models[i].(type) {
+			case SElasticcachesecgroup:
+				_m := models[i].(SElasticcachesecgroup)
+				imodel = &_m
+			case SElasticcacheAccount:
+				_m := models[i].(SElasticcacheAccount)
+				imodel = &_m
+			case SElasticcacheAcl:
+				_m := models[i].(SElasticcacheAcl)
+				imodel = &_m
+			case SElasticcacheBackup:
+				_m := models[i].(SElasticcacheBackup)
+				imodel = &_m
+			case SElasticcacheParameter:
+				_m := models[i].(SElasticcacheParameter)
+				imodel = &_m
+			default:
+				log.Errorf("elasticcache.DeleteSubResources.UnknownModelType %s", models[i])
+			}
+
+			err = db.DeleteModel(ctx, userCred, imodel)
 			if err != nil {
-				log.Errorf("elasticcache.DeleteSubResources.FetchModelObjects %s", err)
+				return errors.Wrapf(err, "db.DeleteModel")
 			}
-
-			for i := range models {
-				var imodel db.IModel
-				switch models[i].(type) {
-				case SElasticcacheAccount:
-					_m := models[i].(SElasticcacheAccount)
-					imodel = &_m
-				case SElasticcacheAcl:
-					_m := models[i].(SElasticcacheAcl)
-					imodel = &_m
-				case SElasticcacheBackup:
-					_m := models[i].(SElasticcacheBackup)
-					imodel = &_m
-				case SElasticcacheParameter:
-					_m := models[i].(SElasticcacheParameter)
-					imodel = &_m
-				default:
-					log.Errorf("elasticcache.DeleteSubResources.UnknownModelType %s", models[i])
-				}
-
-				err = db.DeleteModel(ctx, userCred, imodel)
-				if err != nil {
-					log.Errorf("elasticcache.DeleteSubResources.DeleteModel %s", err)
-				}
-			}
-		}(m)
+		}
+		return nil
 	}
+
+	for i := range ms {
+		err := delFunc(ms[i])
+		if err != nil {
+			return errors.Wrapf(err, "delFunc")
+		}
+	}
+	return nil
 }
 
 func (man *SElasticcacheManager) TotalCount(
@@ -1615,10 +1614,17 @@ func (self *SElasticcache) doExternalSync(ctx context.Context, userCred mcclient
 }
 
 func (self *SElasticcache) Delete(ctx context.Context, userCred mcclient.TokenCredential) error {
-	log.Infof("elasticcache delete do nothing. Do delete in StartDeleteElasticcacheTask")
 	return nil
 }
 
+func (self *SElasticcache) RealDelete(ctx context.Context, userCred mcclient.TokenCredential) error {
+	err := self.DeleteSubResources(ctx, userCred)
+	if err != nil {
+		return err
+	}
+	return self.SVirtualResourceBase.Delete(ctx, userCred)
+}
+
 func (manager *SElasticcacheManager) DeleteExpiredPostpaids(ctx context.Context, userCred mcclient.TokenCredential, isStart bool) {
 	ecs := manager.getExpiredPostpaids()
 	if ecs == nil {

pkg/compute/models/purge.go

@@ -1591,142 +1591,13 @@ func (manager *SDBInstanceBackupManager) purgeAll(ctx context.Context, userCred
 	return nil
 }
 
-func (instance *SElasticcache) purgeAccounts(ctx context.Context, userCred mcclient.TokenCredential) error {
-	accounts, err := instance.GetElasticcacheAccounts()
-	if err != nil {
-		return err
-	}
-
-	for i := range accounts {
-		err = accounts[i].purge(ctx, userCred)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (instance *SElasticcacheAccount) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
-	lockman.LockObject(ctx, instance)
-	defer lockman.ReleaseObject(ctx, instance)
-
-	err := instance.ValidatePurgeCondition(ctx)
-	if err != nil {
-		return err
-	}
-	return instance.Delete(ctx, userCred)
-}
-
-func (instance *SElasticcache) purgeAcls(ctx context.Context, userCred mcclient.TokenCredential) error {
-	acls, err := instance.GetElasticcacheAcls()
-	if err != nil {
-		return err
-	}
-
-	for i := range acls {
-		err = acls[i].purge(ctx, userCred)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (instance *SElasticcacheAcl) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
-	lockman.LockObject(ctx, instance)
-	defer lockman.ReleaseObject(ctx, instance)
-
-	err := instance.ValidatePurgeCondition(ctx)
-	if err != nil {
-		return err
-	}
-	return instance.Delete(ctx, userCred)
-}
-
-func (instance *SElasticcache) purgeBackups(ctx context.Context, userCred mcclient.TokenCredential) error {
-	backups, err := instance.GetElasticcacheBackups()
-	if err != nil {
-		return err
-	}
-
-	for i := range backups {
-		err = backups[i].purge(ctx, userCred)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (instance *SElasticcacheBackup) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
-	lockman.LockObject(ctx, instance)
-	defer lockman.ReleaseObject(ctx, instance)
-
-	err := instance.ValidatePurgeCondition(ctx)
-	if err != nil {
-		return err
-	}
-	return instance.Delete(ctx, userCred)
-}
-
-func (instance *SElasticcache) purgeParameters(ctx context.Context, userCred mcclient.TokenCredential) error {
-	parameters, err := instance.GetElasticcacheParameters()
-	if err != nil {
-		return err
-	}
-
-	for i := range parameters {
-		err = parameters[i].purge(ctx, userCred)
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func (instance *SElasticcacheParameter) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
-	lockman.LockObject(ctx, instance)
-	defer lockman.ReleaseObject(ctx, instance)
-
-	err := instance.ValidatePurgeCondition(ctx)
-	if err != nil {
-		return err
-	}
-	return instance.Delete(ctx, userCred)
-}
-
 func (instance *SElasticcache) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
 	lockman.LockObject(ctx, instance)
 	defer lockman.ReleaseObject(ctx, instance)
 
 	instance.DeletePreventionOff(instance, userCred)
 
-	err := instance.purgeAccounts(ctx, userCred)
-	if err != nil {
-		return err
-	}
-
-	err = instance.purgeAcls(ctx, userCred)
-	if err != nil {
-		return err
-	}
-
-	err = instance.purgeBackups(ctx, userCred)
-	if err != nil {
-		return err
-	}
-
-	err = instance.purgeParameters(ctx, userCred)
-	if err != nil {
-		return err
-	}
-
-	err = instance.ValidatePurgeCondition(ctx)
-	if err != nil {
-		return err
-	}
-
-	return instance.SVirtualResourceBase.Delete(ctx, userCred)
+	return instance.RealDelete(ctx, userCred)
 }
 
 func (manager *SElasticcacheManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {

pkg/compute/tasks/elasticcache_delete_task.go

@@ -62,9 +62,7 @@ func (self *ElasticcacheDeleteTask) OnInit(ctx context.Context, obj db.IStandalo
 		return
 	} else {
 		ec.SetStatus(self.GetUserCred(), api.ELASTIC_CACHE_STATUS_RELEASED, "")
-		// delete related resources
-		ec.DeleteSubResources(ctx, self.UserCred)
-		ec.SVirtualResourceBase.Delete(ctx, self.UserCred)
+		ec.RealDelete(ctx, self.UserCred)
 		logclient.AddActionLogWithStartable(self, ec, logclient.ACT_DELETE, "", self.UserCred, true)
 		notifyclient.EventNotify(ctx, self.UserCred, notifyclient.SEventNotifyParam{
 			Obj:    ec,