Merge pull request #2159 from tb365/bugfix/tb-elb-bugfix-0807

elb bugfix

pkg/apis/compute/loadbalancer_const.go

@@ -53,6 +53,7 @@ const (
 
 	LB_STATUS_DELETING      = "deleting"
 	LB_STATUS_DELETE_FAILED = "delete_failed"
+	LB_STATUS_DELETED       = "deleted"
 
 	LB_STATUS_START_FAILED = "start_failed"
 	LB_STATUS_STOP_FAILED  = "stop_failed"

pkg/compute/models/cloudproviders.go

@@ -1127,8 +1127,9 @@ func (self *SCloudprovider) RealDelete(ctx context.Context, userCred mcclient.To
 		StorageManager,
 		StoragecacheManager,
 		LoadbalancerManager,
-		LoadbalancerAclManager,
-		LoadbalancerCertificateManager,
+		LoadbalancerBackendGroupManager,
+		CachedLoadbalancerAclManager,
+		CachedLoadbalancerCertificateManager,
 		NatGatewayManager,
 		DBInstanceManager,
 		DBInstanceBackupManager,

pkg/compute/models/loadbalanceracls.go

@@ -347,12 +347,14 @@ func (lbacl *SLoadbalancerAcl) AllowPerformPurge(ctx context.Context, userCred m
 }
 
 func (lbacl *SLoadbalancerAcl) PerformPurge(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) (jsonutils.JSONObject, error) {
-	parasm := jsonutils.NewDict()
-	parasm.Add(jsonutils.JSONTrue, "purge")
-	return nil, lbacl.StartLoadBalancerAclDeleteTask(ctx, userCred, parasm, "")
+	return nil, lbacl.Delete(ctx, userCred)
 }
 
-func (lbacl *SLoadbalancerAcl) CustomizeDelete(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) error {
+func (lbacl *SLoadbalancerAcl) Delete(ctx context.Context, userCred mcclient.TokenCredential) error {
+	if !lbacl.PendingDeleted {
+		return lbacl.DoPendingDelete(ctx, userCred)
+	}
+
 	return nil
 }
 
@@ -365,14 +367,10 @@ func (lbacl *SLoadbalancerAcl) StartLoadBalancerAclDeleteTask(ctx context.Contex
 	return nil
 }
 
-func (lbacl *SLoadbalancerAcl) Delete(ctx context.Context, userCred mcclient.TokenCredential) error {
-	return nil
-}
-
 func (lbacl *SLoadbalancerAcl) GetCachedAcls() ([]SCachedLoadbalancerAcl, error) {
 	ret := []SCachedLoadbalancerAcl{}
-	q := CachedLoadbalancerAclManager.TableSpec().Query()
-	err := q.Equals("acl_id", lbacl.Id).All(&ret)
+	q := CachedLoadbalancerAclManager.Query().Equals("acl_id", lbacl.Id)
+	err := db.FetchModelObjects(CachedLoadbalancerAclManager, q, &ret)
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/loadbalancerawscachedlbbg.go

@@ -271,9 +271,9 @@ func (man *SAwsCachedLbbgManager) SyncLoadbalancerBackendgroups(ctx context.Cont
 		}
 
 		if len(elbId) > 0 {
-			ielb, err := db.FetchByExternalId(LoadbalancerManager, elbId)
-			if err == nil {
-				elb = ielb.(*SLoadbalancer)
+			elb, err = LoadbalancerManager.FetchByExternalId(provider.GetId(), elbId)
+			if err != nil {
+				log.Debugf("awsCachedLbbgManager.SyncLoadbalancerBackendgroups %s", err)
 			}
 		}
 

pkg/compute/models/loadbalancerbackendgroups.go

@@ -21,6 +21,7 @@ import (
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
+	"yunion.io/x/pkg/errors"
 	"yunion.io/x/pkg/util/compare"
 	"yunion.io/x/sqlchemy"
 
@@ -519,6 +520,28 @@ func (lbbg *SLoadbalancerBackendGroup) GetHuaweiBackendGroupParams(lblis *SLoadb
 	return ret, nil
 }
 
+func (lbbg *SLoadbalancerBackendGroup) GetAwsCachedlbbg() ([]SAwsCachedLbbg, error) {
+	ret := []SAwsCachedLbbg{}
+	q := AwsCachedLbbgManager.Query().Equals("backend_group_id", lbbg.GetId())
+	err := db.FetchModelObjects(AwsCachedLbbgManager, q, &ret)
+	if err != nil {
+		return nil, errors.Wrap(err, "loadbalancerBackendGroup.GetAwsCachedlbbg")
+	}
+
+	return ret, nil
+}
+
+func (lbbg *SLoadbalancerBackendGroup) GetHuaweiCachedlbbg() ([]SHuaweiCachedLbbg, error) {
+	ret := []SHuaweiCachedLbbg{}
+	q := HuaweiCachedLbbgManager.Query().Equals("backend_group_id", lbbg.GetId())
+	err := db.FetchModelObjects(AwsCachedLbbgManager, q, &ret)
+	if err != nil {
+		return nil, errors.Wrap(err, "loadbalancerBackendGroup.GetHuaweiCachedlbbg")
+	}
+
+	return ret, nil
+}
+
 func (lbbg *SLoadbalancerBackendGroup) GetAwsBackendGroupParams(lblis *SLoadbalancerListener, lbr *SLoadbalancerListenerRule) (*cloudprovider.SLoadbalancerBackendGroup, error) {
 	ret, err := lbbg.GetBackendGroupParams()
 	if err != nil {

pkg/compute/models/loadbalancerbackends.go

@@ -463,6 +463,28 @@ func (lbb *SLoadbalancerBackend) SyncWithCloudLoadbalancerBackend(ctx context.Co
 	return nil
 }
 
+func (lbb *SLoadbalancerBackend) GetAwsCachedlbb() ([]SAwsCachedLb, error) {
+	ret := []SAwsCachedLb{}
+	q := AwsCachedLbManager.Query().Equals("backend_id", lbb.GetId())
+	err := db.FetchModelObjects(AwsCachedLbManager, q, &ret)
+	if err != nil {
+		return nil, errors.Wrap(err, "loadbalancerBackend.GetAwsCachedlbb")
+	}
+
+	return ret, nil
+}
+
+func (lbb *SLoadbalancerBackend) GetHuaweiCachedlbb() ([]SHuaweiCachedLb, error) {
+	ret := []SHuaweiCachedLb{}
+	q := HuaweiCachedLbManager.Query().Equals("backend_id", lbb.GetId())
+	err := db.FetchModelObjects(HuaweiCachedLbManager, q, &ret)
+	if err != nil {
+		return nil, errors.Wrap(err, "loadbalancerBackend.GetHuaweiCachedlbb")
+	}
+
+	return ret, nil
+}
+
 func (man *SLoadbalancerBackendManager) newFromCloudLoadbalancerBackend(ctx context.Context, userCred mcclient.TokenCredential, loadbalancerBackendgroup *SLoadbalancerBackendGroup, extLoadbalancerBackend cloudprovider.ICloudLoadbalancerBackend, syncOwnerId mcclient.IIdentityProvider) (*SLoadbalancerBackend, error) {
 	lbb := &SLoadbalancerBackend{}
 	lbb.SetModelManager(man, lbb)

pkg/compute/models/loadbalancercachedacls.go

@@ -502,21 +502,16 @@ func (man *SCachedLoadbalancerAclManager) newFromCloudLoadbalancerAcl(ctx contex
 
 	f := acl.AclEntries.Fingerprint()
 	if LoadbalancerAclManager.CountByFingerPrint(f) == 0 {
-		loaclAcl := SLoadbalancerAcl{
-			SSharableVirtualResourceBase: db.SSharableVirtualResourceBase{
-				SVirtualResourceBase: db.SVirtualResourceBase{
-					SStatusStandaloneResourceBase: db.SStatusStandaloneResourceBase{
-						SStandaloneResourceBase: db.SStandaloneResourceBase{
-							Name:        acl.Name,
-							Description: acl.Description,
-						},
-					},
-				},
-			},
-			AclEntries:  acl.AclEntries,
-			Fingerprint: f,
-		}
-		err := LoadbalancerAclManager.TableSpec().Insert(&loaclAcl)
+		localAcl := SLoadbalancerAcl{}
+		localAcl.Name = acl.Name
+		localAcl.Description = acl.Description
+		localAcl.AclEntries = acl.AclEntries
+		localAcl.Fingerprint = f
+		// usercread
+		localAcl.DomainId = userCred.GetProjectDomainId()
+		localAcl.ProjectId = userCred.GetProjectId()
+		localAcl.ProjectSrc = string(db.PROJECT_SOURCE_CLOUD)
+		err := LoadbalancerAclManager.TableSpec().Insert(&localAcl)
 		if err != nil {
 			return nil, err
 		}

pkg/compute/models/loadbalancercachedcertificates.go

@@ -261,12 +261,12 @@ func (man *SCachedLoadbalancerCertificateManager) newFromCloudLoadbalancerCertif
 	c := SCachedLoadbalancerCertificate{}
 	err = CachedLoadbalancerCertificateManager.Query().IsFalse("pending_deleted").Equals("fingerprint", lbcert.Fingerprint).First(&c)
 	if err != nil && len(c.CertificateId) == 0 {
-		localcert, err := LoadbalancerCertificateManager.CreateCertificate(lbcert.Name, lbcert.Certificate, lbcert.PrivateKey, lbcert.Fingerprint)
+		localcert, err := LoadbalancerCertificateManager.CreateCertificate(userCred, lbcert.Name, lbcert.Certificate, lbcert.PrivateKey, lbcert.Fingerprint)
 		if err != nil {
 			log.Debugf("newFromCloudLoadbalancerCertificate CreateCertificate %s", err)
 		}
 
-		lbcert.Certificate = localcert.Id
+		lbcert.CertificateId = localcert.Id
 	} else {
 		lbcert.CertificateId = c.CertificateId
 	}

pkg/compute/models/loadbalancercertificates.go

@@ -78,6 +78,16 @@ type SLoadbalancerCertificate struct {
 	SubjectAlternativeNames string    `create:"optional" list:"user" update:"user"`
 }
 
+func (lbcert *SLoadbalancerCertificate) GetCachedCerts() ([]SCachedLoadbalancerCertificate, error) {
+	ret := []SCachedLoadbalancerCertificate{}
+	q := CachedLoadbalancerCertificateManager.Query().Equals("certificate_id", lbcert.Id)
+	err := db.FetchModelObjects(CachedLoadbalancerCertificateManager, q, &ret)
+	if err != nil {
+		return nil, err
+	}
+	return ret, nil
+}
+
 func (lbcert *SLoadbalancerCertificate) AllowPerformStatus(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) bool {
 	return false
 }
@@ -138,12 +148,20 @@ func (lbcert *SLoadbalancerCertificate) ValidateDeleteCondition(ctx context.Cont
 	return nil
 }
 
-func (lbcert *SLoadbalancerCertificate) Delete(ctx context.Context, userCred mcclient.TokenCredential) error {
-	return nil
+func (lbcert *SLoadbalancerCertificate) AllowPerformPurge(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) bool {
+	return db.IsAdminAllowPerform(userCred, lbcert, "purge")
 }
 
-func (lbcert *SLoadbalancerCertificate) AllowPerformPurge(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) bool {
-	return false
+func (lbcert *SLoadbalancerCertificate) PerformPurge(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) (jsonutils.JSONObject, error) {
+	return nil, lbcert.CustomizeDelete(ctx, userCred, query, data)
+}
+
+func (lbcert *SLoadbalancerCertificate) Delete(ctx context.Context, userCred mcclient.TokenCredential) error {
+	if !lbcert.PendingDeleted {
+		return lbcert.DoPendingDelete(ctx, userCred)
+	}
+
+	return nil
 }
 
 func (man *SLoadbalancerCertificateManager) validateCertKey(ctx context.Context, data *jsonutils.JSONDict) (*jsonutils.JSONDict, error) {
@@ -292,7 +310,7 @@ func (man *SLoadbalancerCertificateManager) InitializeData() error {
 	return nil
 }
 
-func (man *SLoadbalancerCertificateManager) CreateCertificate(name string, publicKey string, privateKey, fingerprint string) (*SLoadbalancerCertificate, error) {
+func (man *SLoadbalancerCertificateManager) CreateCertificate(userCred mcclient.TokenCredential, name string, publicKey string, privateKey, fingerprint string) (*SLoadbalancerCertificate, error) {
 	if len(fingerprint) == 0 {
 		return nil, fmt.Errorf("CreateCertificate fingerprint can not be empty")
 	}
@@ -310,6 +328,11 @@ func (man *SLoadbalancerCertificateManager) CreateCertificate(name string, publi
 			return nil, err
 		}
 
+		// usercred
+		cert.DomainId = userCred.GetProjectDomainId()
+		cert.ProjectId = userCred.GetProjectId()
+		cert.ProjectSrc = string(db.PROJECT_SOURCE_CLOUD)
+
 		err = man.TableSpec().Insert(cert)
 		if err != nil {
 			return nil, err

pkg/compute/models/loadbalancers.go

@@ -811,3 +811,18 @@ func (manager *SLoadbalancerManager) GetResourceCount() ([]db.SProjectResourceCo
 	virts := manager.Query().IsFalse("pending_deleted")
 	return db.CalculateProjectResourceCount(virts)
 }
+
+func (manager *SLoadbalancerManager) FetchByExternalId(providerId string, extId string) (*SLoadbalancer, error) {
+	ret := []SLoadbalancer{}
+	q := manager.Query().IsFalse("pending_deleted").Equals("manager_id", providerId).Equals("external_id", extId)
+	err := db.FetchModelObjects(manager, q, &ret)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(ret) == 1 {
+		return &ret[0], nil
+	} else {
+		return nil, fmt.Errorf("loadbalancerManager.FetchByExternalId provider %s external id %s %d found", providerId, extId, len(ret))
+	}
+}

pkg/compute/models/purge.go

@@ -154,8 +154,8 @@ func (disk *SDisk) purge(ctx context.Context, userCred mcclient.TokenCredential)
 	return disk.RealDelete(ctx, userCred)
 }
 
-func (manager *SLoadbalancerCertificateManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {
-	lbcs := make([]SLoadbalancerCertificate, 0)
+func (manager *SCachedLoadbalancerCertificateManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {
+	lbcs := make([]SCachedLoadbalancerCertificate, 0)
 	err := fetchByManagerId(manager, providerId, &lbcs)
 	if err != nil {
 		return err
@@ -169,7 +169,7 @@ func (manager *SLoadbalancerCertificateManager) purgeAll(ctx context.Context, us
 	return nil
 }
 
-func (lbcert *SLoadbalancerCertificate) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
+func (lbcert *SCachedLoadbalancerCertificate) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
 	lockman.LockObject(ctx, lbcert)
 	defer lockman.ReleaseObject(ctx, lbcert)
 
@@ -181,8 +181,8 @@ func (lbcert *SLoadbalancerCertificate) purge(ctx context.Context, userCred mccl
 	return lbcert.DoPendingDelete(ctx, userCred)
 }
 
-func (manager *SLoadbalancerAclManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {
-	lbacls := make([]SLoadbalancerAcl, 0)
+func (manager *SCachedLoadbalancerAclManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {
+	lbacls := make([]SCachedLoadbalancerAcl, 0)
 	err := fetchByManagerId(manager, providerId, &lbacls)
 	if err != nil {
 		return err
@@ -196,7 +196,7 @@ func (manager *SLoadbalancerAclManager) purgeAll(ctx context.Context, userCred m
 	return nil
 }
 
-func (lbacl *SLoadbalancerAcl) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
+func (lbacl *SCachedLoadbalancerAcl) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
 	lockman.LockObject(ctx, lbacl)
 	defer lockman.ReleaseObject(ctx, lbacl)
 
@@ -208,6 +208,21 @@ func (lbacl *SLoadbalancerAcl) purge(ctx context.Context, userCred mcclient.Toke
 	return lbacl.DoPendingDelete(ctx, userCred)
 }
 
+func (manager *SLoadbalancerBackendGroupManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {
+	lbbgs := make([]SLoadbalancerBackendGroup, 0)
+	err := fetchByManagerId(manager, providerId, &lbbgs)
+	if err != nil {
+		return err
+	}
+	for i := range lbbgs {
+		err := lbbgs[i].purge(ctx, userCred)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (manager *SLoadbalancerManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {
 	lbs := make([]SLoadbalancer, 0)
 	err := fetchByManagerId(manager, providerId, &lbs)
@@ -424,6 +439,11 @@ func (lbbg *SLoadbalancerBackendGroup) purge(ctx context.Context, userCred mccli
 		return err
 	}
 
+	err = lbbg.purgeCachedlbbg(ctx, userCred)
+	if err != nil {
+		return err
+	}
+
 	err = lbbg.ValidateDeleteCondition(ctx)
 	if err != nil {
 		return err
@@ -433,15 +453,150 @@ func (lbbg *SLoadbalancerBackendGroup) purge(ctx context.Context, userCred mccli
 	return nil
 }
 
+func (lbbg *SLoadbalancerBackendGroup) purgeCachedlbbg(ctx context.Context, userCred mcclient.TokenCredential) error {
+	switch lbbg.GetProviderName() {
+	case api.CLOUD_PROVIDER_AWS:
+		return lbbg.purgeAwsCachedlbbg(ctx, userCred)
+	case api.CLOUD_PROVIDER_HUAWEI:
+		return lbbg.purgeHuaweiCachedlbbg(ctx, userCred)
+	}
+
+	return nil
+}
+
+func (lbbg *SLoadbalancerBackendGroup) purgeAwsCachedlbbg(ctx context.Context, userCred mcclient.TokenCredential) error {
+	caches, err := lbbg.GetAwsCachedlbbg()
+	if err != nil {
+		return err
+	}
+
+	for i := range caches {
+		if err := caches[i].purge(ctx, userCred); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (lbbg *SAwsCachedLbbg) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
+	lockman.LockObject(ctx, lbbg)
+	defer lockman.ReleaseObject(ctx, lbbg)
+
+	err := lbbg.ValidateDeleteCondition(ctx)
+	if err != nil {
+		return err
+	}
+
+	return lbbg.SVirtualResourceBase.Delete(ctx, userCred)
+}
+
+func (lbbg *SLoadbalancerBackendGroup) purgeHuaweiCachedlbbg(ctx context.Context, userCred mcclient.TokenCredential) error {
+	caches, err := lbbg.GetHuaweiCachedlbbg()
+	if err != nil {
+		return err
+	}
+
+	for i := range caches {
+		if err := caches[i].purge(ctx, userCred); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (lbbg *SHuaweiCachedLbbg) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
+	lockman.LockObject(ctx, lbbg)
+	defer lockman.ReleaseObject(ctx, lbbg)
+
+	err := lbbg.ValidateDeleteCondition(ctx)
+	if err != nil {
+		return err
+	}
+
+	return lbbg.SVirtualResourceBase.Delete(ctx, userCred)
+}
+
 func (lbb *SLoadbalancerBackend) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
 	lockman.LockObject(ctx, lbb)
 	defer lockman.ReleaseObject(ctx, lbb)
 
+	err := lbb.purgeCachedlbb(ctx, userCred)
+	if err != nil {
+		return err
+	}
+
+	err = lbb.ValidateDeleteCondition(ctx)
+	if err != nil {
+		return err
+	}
+	return lbb.DoPendingDelete(ctx, userCred)
+}
+
+func (lbb *SLoadbalancerBackend) purgeCachedlbb(ctx context.Context, userCred mcclient.TokenCredential) error {
+	switch lbb.GetProviderName() {
+	case api.CLOUD_PROVIDER_AWS:
+		return lbb.purgeAwsCachedlbb(ctx, userCred)
+	case api.CLOUD_PROVIDER_HUAWEI:
+		return lbb.purgeHuaweiCachedlbb(ctx, userCred)
+	}
+
+	return nil
+}
+
+func (lbb *SLoadbalancerBackend) purgeAwsCachedlbb(ctx context.Context, userCred mcclient.TokenCredential) error {
+	caches, err := lbb.GetAwsCachedlbb()
+	if err != nil {
+		return err
+	}
+
+	for i := range caches {
+		if err := caches[i].purge(ctx, userCred); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (lbb *SAwsCachedLb) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
+	lockman.LockObject(ctx, lbb)
+	defer lockman.ReleaseObject(ctx, lbb)
+
 	err := lbb.ValidateDeleteCondition(ctx)
 	if err != nil {
 		return err
 	}
-	return lbb.DoPendingDelete(ctx, userCred)
+
+	return lbb.SVirtualResourceBase.Delete(ctx, userCred)
+}
+
+func (lbb *SLoadbalancerBackend) purgeHuaweiCachedlbb(ctx context.Context, userCred mcclient.TokenCredential) error {
+	caches, err := lbb.GetHuaweiCachedlbb()
+	if err != nil {
+		return err
+	}
+
+	for i := range caches {
+		if err := caches[i].purge(ctx, userCred); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (lbb *SHuaweiCachedLb) purge(ctx context.Context, userCred mcclient.TokenCredential) error {
+	lockman.LockObject(ctx, lbb)
+	defer lockman.ReleaseObject(ctx, lbb)
+
+	err := lbb.ValidateDeleteCondition(ctx)
+	if err != nil {
+		return err
+	}
+
+	return lbb.SVirtualResourceBase.Delete(ctx, userCred)
 }
 
 func (manager *SSnapshotManager) purgeAll(ctx context.Context, userCred mcclient.TokenCredential, providerId string) error {

pkg/multicloud/aws/aws.go

@@ -295,7 +295,7 @@ func (self *SAwsClient) GetIHostById(id string) (cloudprovider.ICloudHost, error
 		ihost, err := self.iregions[i].GetIHostById(id)
 		if err == nil {
 			return ihost, nil
-		} else if err != ErrorNotFound() {
+		} else if err != cloudprovider.ErrNotFound {
 			return nil, err
 		}
 	}
@@ -307,7 +307,7 @@ func (self *SAwsClient) GetIVpcById(id string) (cloudprovider.ICloudVpc, error)
 		ihost, err := self.iregions[i].GetIVpcById(id)
 		if err == nil {
 			return ihost, nil
-		} else if err != ErrorNotFound() {
+		} else if err != cloudprovider.ErrNotFound {
 			return nil, err
 		}
 	}
@@ -319,7 +319,7 @@ func (self *SAwsClient) GetIStorageById(id string) (cloudprovider.ICloudStorage,
 		ihost, err := self.iregions[i].GetIStorageById(id)
 		if err == nil {
 			return ihost, nil
-		} else if err != ErrorNotFound() {
+		} else if err != cloudprovider.ErrNotFound {
 			return nil, err
 		}
 	}

pkg/multicloud/aws/disk.go

@@ -188,7 +188,7 @@ func (self *SDisk) GetMountpoint() string {
 }
 
 func (self *SDisk) Delete(ctx context.Context) error {
-	if _, err := self.storage.zone.region.GetDisk(self.DiskId); err == ErrorNotFound() {
+	if _, err := self.storage.zone.region.GetDisk(self.DiskId); err == cloudprovider.ErrNotFound {
 		log.Errorf("Failed to find disk %s when delete", self.DiskId)
 		return nil
 	}

pkg/multicloud/aws/region.go

@@ -526,7 +526,7 @@ func (self *SRegion) GetIHostById(id string) (cloudprovider.ICloudHost, error) {
 		ihost, err := izones[i].GetIHostById(id)
 		if err == nil {
 			return ihost, nil
-		} else if err != ErrorNotFound() {
+		} else if err != cloudprovider.ErrNotFound {
 			return nil, err
 		}
 	}
@@ -542,7 +542,7 @@ func (self *SRegion) GetIStorageById(id string) (cloudprovider.ICloudStorage, er
 		istore, err := izones[i].GetIStorageById(id)
 		if err == nil {
 			return istore, nil
-		} else if err != ErrorNotFound() {
+		} else if err != cloudprovider.ErrNotFound {
 			return nil, err
 		}
 	}

pkg/multicloud/aws/storagecache.go

@@ -224,7 +224,7 @@ func (self *SStoragecache) uploadImage(ctx context.Context, userCred mcclient.To
 	for {
 		_, err = self.region.GetImageByName(imageName, ImageOwnerSelf)
 		if err != nil {
-			if err == ErrorNotFound() {
+			if err == cloudprovider.ErrNotFound {
 				break
 			} else {
 				return "", err

pkg/multicloud/aws/utils.go

@@ -499,6 +499,6 @@ func parseNotFoundError(err error) error {
 }
 
 func ErrorNotFound() error {
-	log.Errorf("Not found: %s", string(debug.Stack()))
+	log.Debugf("Not found: %s", string(debug.Stack()))
 	return cloudprovider.ErrNotFound
 }