Merge pull request #8016 from ioito/optimized/cloud-resource-sync

fix: 优化同步，避免长时间加锁

pkg/cloudcommon/db/db_dispatcher.go

@@ -1204,8 +1204,11 @@ func _doCreateItem(
 			generateName, _ = dataDict.GetString("generate_name")
 			if len(generateName) > 0 {
 				if manager.EnableGenerateName() {
+					lockman.LockRawObject(ctx, manager.Keyword(), "name")
+					defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
 					// if enable generateName, alway generate name
-					newName, err := GenerateName2(manager, ownerId, generateName, nil, baseIndex)
+					newName, err := GenerateName2(ctx, manager, ownerId, generateName, nil, baseIndex)
 					if err != nil {
 						return nil, errors.Wrap(err, "GenerateName2")
 					}

pkg/cloudcommon/db/namevalidator.go

@@ -15,6 +15,7 @@
 package db
 
 import (
+	"context"
 	"fmt"
 	"regexp"
 
@@ -111,18 +112,18 @@ func alterNameValidator(model IModel, name string) error {
 	return nil
 }
 
-func GenerateName(manager IModelManager, ownerId mcclient.IIdentityProvider, hint string) (string, error) {
-	return GenerateName2(manager, ownerId, hint, nil, 1)
+func GenerateName(ctx context.Context, manager IModelManager, ownerId mcclient.IIdentityProvider, hint string) (string, error) {
+	return GenerateName2(ctx, manager, ownerId, hint, nil, 1)
 }
 
 func GenerateAlterName(model IModel, hint string) (string, error) {
 	if hint == model.GetName() {
 		return hint, nil
 	}
-	return GenerateName2(nil, nil, hint, model, 1)
+	return GenerateName2(nil, nil, nil, hint, model, 1)
 }
 
-func GenerateName2(manager IModelManager, ownerId mcclient.IIdentityProvider, hint string, model IModel, baseIndex int) (string, error) {
+func GenerateName2(ctx context.Context, manager IModelManager, ownerId mcclient.IIdentityProvider, hint string, model IModel, baseIndex int) (string, error) {
 	_, pattern, patternLen, offset := stringutils2.ParseNamePattern2(hint)
 	var name string
 	if patternLen == 0 {

pkg/cloudcommon/db/virtualresource.go

@@ -492,12 +492,12 @@ func (model *SVirtualResourceBase) MarkCancelPendingDelete(ctx context.Context,
 	manager := model.GetModelManager()
 	ownerId := model.GetOwnerId()
 
-	lockman.LockClass(ctx, manager, GetLockClassKey(manager, ownerId))
-	defer lockman.ReleaseClass(ctx, manager, GetLockClassKey(manager, ownerId))
+	lockman.LockRawObject(ctx, manager.Keyword(), "name")
+	defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
 
-	newName, err := GenerateName(manager, ownerId, model.Name)
+	newName, err := GenerateName(ctx, manager, ownerId, model.Name)
 	if err != nil {
-		return err
+		return errors.Wrapf(err, "GenerateNam")
 	}
 	diff, err := Update(model, func() error {
 		model.Name = newName
@@ -506,8 +506,7 @@ func (model *SVirtualResourceBase) MarkCancelPendingDelete(ctx context.Context,
 		return nil
 	})
 	if err != nil {
-		log.Errorf("MarkCancelPendingDelete fail %s", err)
-		return err
+		return errors.Wrapf(err, "MarkCancelPendingDelete.Update")
 	}
 	OpsLog.LogEvent(model, ACT_CANCEL_DELETE, diff, userCred)
 	return nil

pkg/cloudid/models/cloudgroup.go

@@ -205,21 +205,24 @@ func (self *SCloudgroup) PostCreate(ctx context.Context, userCred mcclient.Token
 }
 
 func (manager *SCloudgroupManager) newCloudgroup(ctx context.Context, userCred mcclient.TokenCredential, ownerId mcclient.IIdentityProvider, iGroup cloudprovider.ICloudgroup, provider string) (*SCloudgroup, error) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-
-	var err error
 	group := &SCloudgroup{}
-	group.Name, err = db.GenerateName(manager, ownerId, iGroup.GetName())
-	if err != nil {
-		return nil, errors.Wrapf(err, "db.GenerateName")
-	}
 	group.Description = iGroup.GetDescription()
 	group.Provider = provider
 	group.DomainId = ownerId.GetProjectDomainId()
 	group.Status = api.CLOUD_GROUP_STATUS_AVAILABLE
 	group.SetModelManager(manager, group)
-	err = manager.TableSpec().Insert(ctx, group)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		var err error
+		group.Name, err = db.GenerateName(ctx, manager, ownerId, iGroup.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+
+		return manager.TableSpec().Insert(ctx, group)
+	}()
 	if err != nil {
 		return nil, errors.Wrap(err, "Insert")
 	}

pkg/compute/models/access_group_caches.go

@@ -373,15 +373,23 @@ func (self *SCloudprovider) newFromCloudAccessGroup(ctx context.Context, userCre
 	}
 	group := &SAccessGroup{}
 	group.SetModelManager(AccessGroupManager, group)
-	group.Name, _ = db.GenerateName(AccessGroupManager, self.GetOwnerId(), iAccessGroup.GetName())
 	group.Status = api.ACCESS_GROUP_STATUS_AVAILABLE
 	group.DomainId = self.DomainId
-	err = AccessGroupManager.TableSpec().Insert(ctx, group)
+
+	err = func() error {
+		lockman.LockRawObject(ctx, AccessGroupManager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, AccessGroupManager.Keyword(), "name")
+
+		group.Name, err = db.GenerateName(ctx, AccessGroupManager, self.GetOwnerId(), iAccessGroup.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+		return AccessGroupManager.TableSpec().Insert(ctx, group)
+	}()
 	if err != nil {
-		return errors.Wrapf(err, "AccessGroupManager.Insert")
+		return errors.Wrapf(err, "Insert")
 	}
-	err = group.SyncRules(ctx, userCred, src)
-	return nil
+	return group.SyncRules(ctx, userCred, src)
 }
 
 func (self *SAccessGroup) GetAccessGroupCaches() ([]SAccessGroupCache, error) {

pkg/compute/models/buckets.go

@@ -17,6 +17,7 @@ package models
 import (
 	"context"
 	"database/sql"
+	"fmt"
 	"net/http"
 	"strconv"
 	"strings"
@@ -116,8 +117,8 @@ func (manager *SBucketManager) fetchBuckets(provider *SCloudprovider, region *SC
 }
 
 func (manager *SBucketManager) syncBuckets(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, buckets []cloudprovider.ICloudBucket) compare.SyncResult {
-	lockman.LockClass(ctx, manager, "")
-	defer lockman.ReleaseClass(ctx, manager, "")
+	lockman.LockRawObject(ctx, "buckets", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "buckets", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	syncResult := compare.SyncResult{}
 
@@ -173,6 +174,7 @@ func (manager *SBucketManager) newFromCloudBucket(
 	provider *SCloudprovider,
 	region *SCloudregion,
 ) (*SBucket, error) {
+
 	bucket := SBucket{}
 	bucket.SetModelManager(manager, &bucket)
 
@@ -181,13 +183,6 @@ func (manager *SBucketManager) newFromCloudBucket(
 	bucket.CloudregionId = region.Id
 	bucket.Status = api.BUCKET_STATUS_READY
 
-	newName, err := db.GenerateName(manager, nil, extBucket.GetName())
-	if err != nil {
-		return nil, errors.Wrap(err, "db.GenerateName")
-	}
-
-	bucket.Name = newName
-
 	created := extBucket.GetCreateAt()
 	if !created.IsZero() {
 		bucket.CreatedAt = created
@@ -220,9 +215,20 @@ func (manager *SBucketManager) newFromCloudBucket(
 
 	bucket.IsEmulated = false
 
-	err = manager.TableSpec().Insert(ctx, &bucket)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		var err error
+		bucket.Name, err = db.GenerateName(ctx, manager, nil, extBucket.GetName())
+		if err != nil {
+			return errors.Wrap(err, "db.GenerateName")
+		}
+
+		return manager.TableSpec().Insert(ctx, &bucket)
+	}()
 	if err != nil {
-		return nil, errors.Wrap(err, "Insert")
+		return nil, err
 	}
 
 	SyncCloudProject(userCred, &bucket, provider.GetOwnerId(), extBucket, provider.Id)

pkg/compute/models/cachedimages.go

@@ -196,8 +196,8 @@ func (self *SCachedimage) GetImage() (*cloudprovider.SImage, error) {
 }
 
 func (manager *SCachedimageManager) cacheGlanceImageInfo(ctx context.Context, userCred mcclient.TokenCredential, info jsonutils.JSONObject) (*SCachedimage, error) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, manager.Keyword(), "name")
+	defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
 
 	img := struct {
 		Id          string
@@ -222,7 +222,7 @@ func (manager *SCachedimageManager) cacheGlanceImageInfo(ctx context.Context, us
 	imageCache := SCachedimage{}
 	imageCache.SetModelManager(manager, &imageCache)
 
-	img.Name, err = db.GenerateName(manager, nil, img.Name)
+	img.Name, err = db.GenerateName(ctx, manager, nil, img.Name)
 	if err != nil {
 		return nil, errors.Wrapf(err, "db.GenerateName(%s)", img.Name)
 	}
@@ -519,18 +519,9 @@ func (self *SCachedimage) syncWithCloudImage(ctx context.Context, userCred mccli
 }
 
 func (manager *SCachedimageManager) newFromCloudImage(ctx context.Context, userCred mcclient.TokenCredential, ownerId mcclient.IIdentityProvider, image cloudprovider.ICloudImage, managerId string) (*SCachedimage, error) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-
 	cachedImage := SCachedimage{}
 	cachedImage.SetModelManager(manager, &cachedImage)
 
-	newName, err := db.GenerateName(manager, nil, image.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	cachedImage.Name = newName
 	cachedImage.Size = image.GetSizeByte()
 	cachedImage.UEFI = tristate.NewFromBool(image.UEFI())
 	sImage := cloudprovider.CloudImage2Image(image)
@@ -546,7 +537,17 @@ func (manager *SCachedimageManager) newFromCloudImage(ctx context.Context, userC
 		cachedImage.IsPublic = true
 	}
 
-	err = manager.TableSpec().Insert(ctx, &cachedImage)
+	var err error
+	err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		cachedImage.Name, err = db.GenerateName(ctx, manager, nil, image.GetName())
+		if err != nil {
+			return err
+		}
+		return manager.TableSpec().Insert(ctx, &cachedImage)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/cloudaccounts.go

@@ -954,13 +954,6 @@ func (self *SCloudaccount) importSubAccount(ctx context.Context, userCred mcclie
 	isNew = true
 
 	newCloudprovider, err := func() (*SCloudprovider, error) {
-		lockman.LockClass(ctx, CloudproviderManager, "")
-		defer lockman.ReleaseClass(ctx, CloudproviderManager, "")
-
-		newName, err := db.GenerateName(CloudproviderManager, nil, subAccount.Name)
-		if err != nil {
-			return nil, err
-		}
 		newCloudprovider := SCloudprovider{}
 		newCloudprovider.Account = subAccount.Account
 		newCloudprovider.Secret = self.Secret
@@ -978,7 +971,6 @@ func (self *SCloudaccount) importSubAccount(ctx context.Context, userCred mcclie
 			newCloudprovider.SetEnabled(false)
 			newCloudprovider.Status = api.CLOUD_PROVIDER_DISCONNECTED
 		}
-		newCloudprovider.Name = newName
 		if !self.AutoCreateProject || len(self.ProjectId) > 0 {
 			ownerId := self.GetOwnerId()
 			if len(self.ProjectId) > 0 {
@@ -1011,12 +1003,20 @@ func (self *SCloudaccount) importSubAccount(ctx context.Context, userCred mcclie
 
 		newCloudprovider.SetModelManager(CloudproviderManager, &newCloudprovider)
 
-		err = CloudproviderManager.TableSpec().Insert(ctx, &newCloudprovider)
+		err = func() error {
+			lockman.LockRawObject(ctx, CloudproviderManager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, CloudproviderManager.Keyword(), "name")
+
+			newCloudprovider.Name, err = db.GenerateName(ctx, CloudproviderManager, nil, subAccount.Name)
+			if err != nil {
+				return err
+			}
+			return CloudproviderManager.TableSpec().Insert(ctx, &newCloudprovider)
+		}()
 		if err != nil {
 			return nil, err
-		} else {
-			return &newCloudprovider, nil
 		}
+		return &newCloudprovider, nil
 	}()
 	if err != nil {
 		log.Errorf("insert new cloudprovider fail %s", err)

pkg/compute/models/cloudprovider_quotas.go

@@ -16,6 +16,7 @@ package models
 
 import (
 	"context"
+	"fmt"
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/pkg/errors"
@@ -205,8 +206,8 @@ func (manager *SCloudproviderQuotaManager) GetQuotas(provider *SCloudprovider, r
 }
 
 func (manager *SCloudproviderQuotaManager) SyncQuotas(ctx context.Context, userCred mcclient.TokenCredential, syncOwnerId mcclient.IIdentityProvider, provider *SCloudprovider, region *SCloudregion, quotaRange string, iQuotas []cloudprovider.ICloudQuota) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "quotas", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "quotas", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 	result := compare.SyncResult{}
 
 	dbQuotas, err := manager.GetQuotas(provider, region, quotaRange)
@@ -265,9 +266,6 @@ func (self *SCloudproviderQuota) SyncWithCloudQuota(ctx context.Context, userCre
 }
 
 func (manager *SCloudproviderQuotaManager) newFromCloudQuota(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, quotaRange string, iQuota cloudprovider.ICloudQuota) error {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-
 	quota := SCloudproviderQuota{}
 	quota.SetModelManager(manager, &quota)
 

pkg/compute/models/cloudproviders.go

@@ -1052,7 +1052,7 @@ func (manager *SCloudproviderManager) migrateVCenterInfo(vc *SVCenter) error {
 	cp := SCloudprovider{}
 	cp.SetModelManager(manager, &cp)
 
-	newName, err := db.GenerateName(manager, nil, vc.Name)
+	newName, err := db.GenerateName(context.Background(), manager, nil, vc.Name)
 	if err != nil {
 		return err
 	}

pkg/compute/models/cloudregions.go

@@ -379,8 +379,8 @@ func (manager *SCloudregionManager) SyncRegions(
 	[]SCloudproviderregion,
 	compare.SyncResult,
 ) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "cloudregions", externalIdPrefix)
+	defer lockman.ReleaseRawObject(ctx, "cloudregions", externalIdPrefix)
 
 	syncResult := compare.SyncResult{}
 	localRegions := make([]SCloudregion, 0)
@@ -515,12 +515,7 @@ func (manager *SCloudregionManager) newFromCloudRegion(ctx context.Context, user
 	region := SCloudregion{}
 	region.SetModelManager(manager, &region)
 
-	newName, err := db.GenerateName(manager, nil, cloudRegion.GetName())
-	if err != nil {
-		return nil, err
-	}
 	region.ExternalId = cloudRegion.GetGlobalId()
-	region.Name = newName
 	region.SGeographicInfo = cloudRegion.GetGeographicInfo()
 	region.Status = cloudRegion.GetStatus()
 	region.SetEnabled(true)
@@ -537,9 +532,18 @@ func (manager *SCloudregionManager) newFromCloudRegion(ctx context.Context, user
 		region.ManagerId = provider.Id
 	}
 
-	err = manager.TableSpec().Insert(ctx, &region)
+	err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		region.Name, err = db.GenerateName(ctx, manager, nil, cloudRegion.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+
+		return manager.TableSpec().Insert(ctx, &region)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudRegion fail %s", err)
 		return nil, err
 	}
 

pkg/compute/models/dbinstance_accounts.go

@@ -630,8 +630,8 @@ func (self *SDBInstanceAccount) GetDBInstanceDatabaseByName(dbName string) (*SDB
 }
 
 func (manager *SDBInstanceAccountManager) SyncDBInstanceAccounts(ctx context.Context, userCred mcclient.TokenCredential, instance *SDBInstance, cloudAccounts []cloudprovider.ICloudDBInstanceAccount) ([]SDBInstanceAccount, []cloudprovider.ICloudDBInstanceAccount, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, instance.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, instance.GetOwnerId()))
+	lockman.LockRawObject(ctx, "dbinstance-accounts", instance.Id)
+	defer lockman.ReleaseRawObject(ctx, "dbinstance-accounts", instance.Id)
 
 	result := compare.SyncResult{}
 	localAccounts := []SDBInstanceAccount{}

pkg/compute/models/dbinstance_backups.go

@@ -400,8 +400,8 @@ func (backup *SDBInstanceBackup) GetIDBInstanceBackup() (cloudprovider.ICloudDBI
 }
 
 func (manager *SDBInstanceBackupManager) SyncDBInstanceBackups(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, instance *SDBInstance, region *SCloudregion, cloudBackups []cloudprovider.ICloudDBInstanceBackup) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "dbinstance-backups", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "dbinstance-backups", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	result := compare.SyncResult{}
 	dbBackups, err := region.GetDBInstanceBackups(provider, instance)
@@ -500,18 +500,9 @@ func (manager *SDBInstanceBackupManager) newFromCloudDBInstanceBackup(
 	region *SCloudregion,
 	extBackup cloudprovider.ICloudDBInstanceBackup,
 ) error {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-
 	backup := SDBInstanceBackup{}
 	backup.SetModelManager(manager, &backup)
 
-	newName, err := db.GenerateName(manager, provider.GetOwnerId(), extBackup.GetName())
-	if err != nil {
-		return errors.Wrap(err, "newFromCloudDBInstanceBackup.GenerateName")
-	}
-
-	backup.Name = newName
 	backup.CloudregionId = region.Id
 	backup.ManagerId = provider.Id
 	backup.Status = extBackup.GetStatus()
@@ -539,7 +530,17 @@ func (manager *SDBInstanceBackupManager) newFromCloudDBInstanceBackup(
 		}
 	}
 
-	err = manager.TableSpec().Insert(ctx, &backup)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, provider.GetOwnerId(), extBackup.GetName())
+		if err != nil {
+			return errors.Wrap(err, "newFromCloudDBInstanceBackup.GenerateName")
+		}
+		backup.Name = newName
+		return manager.TableSpec().Insert(ctx, &backup)
+	}()
 	if err != nil {
 		return errors.Wrapf(err, "newFromCloudDBInstanceBackup.Insert")
 	}

pkg/compute/models/dbinstance_databases.go

@@ -370,8 +370,8 @@ func (self *SDBInstanceDatabase) getMoreDetails(ctx context.Context, userCred mc
 }
 
 func (manager *SDBInstanceDatabaseManager) SyncDBInstanceDatabases(ctx context.Context, userCred mcclient.TokenCredential, instance *SDBInstance, cloudDatabases []cloudprovider.ICloudDBInstanceDatabase) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, instance.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, instance.GetOwnerId()))
+	lockman.LockRawObject(ctx, "dbinstance-databases", instance.Id)
+	defer lockman.ReleaseRawObject(ctx, "dbinstance-databases", instance.Id)
 
 	result := compare.SyncResult{}
 	dbDatabases, err := instance.GetDBInstanceDatabases()

pkg/compute/models/dbinstance_parameters.go

@@ -137,8 +137,8 @@ func (manager *SDBInstanceParameterManager) ValidateCreateData(ctx context.Conte
 }
 
 func (manager *SDBInstanceParameterManager) SyncDBInstanceParameters(ctx context.Context, userCred mcclient.TokenCredential, instance *SDBInstance, cloudParameters []cloudprovider.ICloudDBInstanceParameter) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, instance.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, instance.GetOwnerId()))
+	lockman.LockRawObject(ctx, "dbinstance-parameters", instance.Id)
+	defer lockman.ReleaseRawObject(ctx, "dbinstance-parameters", instance.Id)
 
 	result := compare.SyncResult{}
 	dbParameters, err := instance.GetDBInstanceParameters()

pkg/compute/models/dbinstance_privileges.go

@@ -136,8 +136,8 @@ func (manager *SDBInstancePrivilegeManager) ValidateCreateData(ctx context.Conte
 }
 
 func (manager *SDBInstancePrivilegeManager) SyncDBInstanceAccountPrivileges(ctx context.Context, userCred mcclient.TokenCredential, account *SDBInstanceAccount, cloudPrivileges []cloudprovider.ICloudDBInstanceAccountPrivilege) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, account.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, account.GetOwnerId()))
+	lockman.LockRawObject(ctx, "dbinstance-privileges", account.Id)
+	defer lockman.ReleaseRawObject(ctx, "dbinstance-privileges", account.Id)
 
 	result := compare.SyncResult{}
 	dbPrivileges, err := account.GetDBInstancePrivileges()

pkg/compute/models/dbinstance_skus.go

@@ -502,8 +502,8 @@ func (manager *SDBInstanceSkuManager) GetDBInstanceSkus(provider, cloudregionId,
 }
 
 func (manager *SDBInstanceSkuManager) SyncDBInstanceSkus(ctx context.Context, userCred mcclient.TokenCredential, region *SCloudregion, meta *SSkuResourcesMeta) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "dbinstance-skus", region.Id)
+	defer lockman.ReleaseRawObject(ctx, "dbinstance-skus", region.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/dbinstances.go

@@ -1399,8 +1399,8 @@ func (manager *SDBInstanceManager) SyncDBInstanceMasterId(ctx context.Context, u
 }
 
 func (manager *SDBInstanceManager) SyncDBInstances(ctx context.Context, userCred mcclient.TokenCredential, syncOwnerId mcclient.IIdentityProvider, provider *SCloudprovider, region *SCloudregion, cloudDBInstances []cloudprovider.ICloudDBInstance) ([]SDBInstance, []cloudprovider.ICloudDBInstance, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "dbinstances", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "dbinstances", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	localDBInstances := []SDBInstance{}
 	remoteDBInstances := []cloudprovider.ICloudDBInstance{}
@@ -1684,18 +1684,10 @@ func (self *SDBInstance) GetSlaveDBInstances() ([]SDBInstance, error) {
 }
 
 func (manager *SDBInstanceManager) newFromCloudDBInstance(ctx context.Context, userCred mcclient.TokenCredential, ownerId mcclient.IIdentityProvider, provider *SCloudprovider, region *SCloudregion, extInstance cloudprovider.ICloudDBInstance) (*SDBInstance, error) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
 
 	instance := SDBInstance{}
 	instance.SetModelManager(manager, &instance)
 
-	newName, err := db.GenerateName(manager, ownerId, extInstance.GetName())
-	if err != nil {
-		return nil, err
-	}
-	instance.Name = newName
-
 	instance.ExternalId = extInstance.GetGlobalId()
 	instance.CloudregionId = region.Id
 	instance.ManagerId = provider.Id
@@ -1753,7 +1745,16 @@ func (manager *SDBInstanceManager) newFromCloudDBInstance(ctx context.Context, u
 		instance.AutoRenew = extInstance.IsAutoRenew()
 	}
 
-	err = manager.TableSpec().Insert(ctx, &instance)
+	err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		instance.Name, err = db.GenerateName(ctx, manager, ownerId, extInstance.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+		return manager.TableSpec().Insert(ctx, &instance)
+	}()
 	if err != nil {
 		return nil, errors.Wrapf(err, "newFromCloudDBInstance.Insert")
 	}

pkg/compute/models/disks.go

@@ -1289,8 +1289,8 @@ func (manager *SDiskManager) syncCloudDisk(ctx context.Context, userCred mcclien
 func (manager *SDiskManager) SyncDisks(ctx context.Context, userCred mcclient.TokenCredential, provider cloudprovider.ICloudProvider, storage *SStorage, disks []cloudprovider.ICloudDisk, syncOwnerId mcclient.IIdentityProvider) ([]SDisk, []cloudprovider.ICloudDisk, compare.SyncResult) {
 	// syncOwnerId := projectId
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "disks", storage.Id)
+	defer lockman.ReleaseRawObject(ctx, "disks", storage.Id)
 
 	localDisks := make([]SDisk, 0)
 	remoteDisks := make([]cloudprovider.ICloudDisk, 0)
@@ -1543,11 +1543,6 @@ func (manager *SDiskManager) newFromCloudDisk(ctx context.Context, userCred mccl
 	disk := SDisk{}
 	disk.SetModelManager(manager, &disk)
 
-	newName, err := db.GenerateName(manager, syncOwnerId, extDisk.GetName())
-	if err != nil {
-		return nil, err
-	}
-	disk.Name = newName
 	disk.Status = extDisk.GetStatus()
 	disk.ExternalId = extDisk.GetGlobalId()
 	disk.StorageId = storage.Id
@@ -1575,10 +1570,20 @@ func (manager *SDiskManager) newFromCloudDisk(ctx context.Context, userCred mccl
 		disk.CreatedAt = createAt
 	}
 
-	err = manager.TableSpec().Insert(ctx, &disk)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, syncOwnerId, extDisk.GetName())
+		if err != nil {
+			return err
+		}
+		disk.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &disk)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudZone fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "newFromCloudDisk")
 	}
 
 	// create new joint model aboutsnapshotpolicy and disk
@@ -2588,8 +2593,8 @@ func (self *SDisk) syncSnapshots(ctx context.Context, userCred mcclient.TokenCre
 	}
 	localSnapshots := SnapshotManager.GetDiskSnapshots(self.Id)
 
-	lockman.LockClass(ctx, SnapshotManager, db.GetLockClassKey(SnapshotManager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, SnapshotManager, db.GetLockClassKey(SnapshotManager, syncOwnerId))
+	lockman.LockRawObject(ctx, "snapshots", self.Id)
+	defer lockman.ReleaseRawObject(ctx, "snapshots", self.Id)
 
 	removed := make([]SSnapshot, 0)
 	commondb := make([]SSnapshot, 0)

pkg/compute/models/dns_trafficpolicy.go

@@ -25,6 +25,7 @@ import (
 
 	api "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
 	"yunion.io/x/onecloud/pkg/cloudprovider"
 	"yunion.io/x/onecloud/pkg/httperrors"
 	"yunion.io/x/onecloud/pkg/mcclient"
@@ -160,13 +161,19 @@ func (manager *SDnsTrafficPolicyManager) Register(ctx context.Context, userCred
 	}
 	policy := &SDnsTrafficPolicy{}
 	policy.SetModelManager(manager, policy)
-	policy.Name, err = db.GenerateName(manager, userCred, fmt.Sprintf("%s-%s", provider, policyType))
-	if err != nil {
-		return nil, errors.Wrapf(err, "db.GenerateName")
-	}
 	policy.PolicyType = string(policyType)
 	policy.PolicyValue = string(policyValue)
 	policy.Provider = provider
 	policy.Options = options
-	return policy, manager.TableSpec().Insert(ctx, policy)
+	return func() (*SDnsTrafficPolicy, error) {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		policy.Name, err = db.GenerateName(ctx, manager, userCred, fmt.Sprintf("%s-%s", provider, policyType))
+		if err != nil {
+			return nil, errors.Wrapf(err, "db.GenerateName")
+		}
+
+		return policy, manager.TableSpec().Insert(ctx, policy)
+	}()
 }

pkg/compute/models/elasticcache_accounts.go

@@ -75,8 +75,8 @@ type SElasticcacheAccount struct {
 }
 
 func (manager *SElasticcacheAccountManager) SyncElasticcacheAccounts(ctx context.Context, userCred mcclient.TokenCredential, elasticcache *SElasticcache, cloudElasticcacheAccounts []cloudprovider.ICloudElasticcacheAccount) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
+	lockman.LockRawObject(ctx, "elastic-cache-accounts", elasticcache.Id)
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache-accounts", elasticcache.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/elasticcache_acls.go

@@ -71,8 +71,8 @@ type SElasticcacheAcl struct {
 }
 
 func (manager *SElasticcacheAclManager) SyncElasticcacheAcls(ctx context.Context, userCred mcclient.TokenCredential, elasticcache *SElasticcache, cloudElasticcacheAcls []cloudprovider.ICloudElasticcacheAcl) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
+	lockman.LockRawObject(ctx, "elastic-cache-acls", elasticcache.Id)
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache-acls", elasticcache.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/elasticcache_backups.go

@@ -84,8 +84,8 @@ type SElasticcacheBackup struct {
 }
 
 func (manager *SElasticcacheBackupManager) SyncElasticcacheBackups(ctx context.Context, userCred mcclient.TokenCredential, elasticcache *SElasticcache, cloudElasticcacheBackups []cloudprovider.ICloudElasticcacheBackup) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
+	lockman.LockRawObject(ctx, "elastic-cache-backups", elasticcache.Id)
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache-backups", elasticcache.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/elasticcache_instances.go

@@ -503,8 +503,8 @@ func (manager *SElasticcacheManager) QueryDistinctExtraField(q *sqlchemy.SQuery,
 }
 
 func (manager *SElasticcacheManager) SyncElasticcaches(ctx context.Context, userCred mcclient.TokenCredential, syncOwnerId mcclient.IIdentityProvider, provider *SCloudprovider, region *SCloudregion, cloudElasticcaches []cloudprovider.ICloudElasticcache) ([]SElasticcache, []cloudprovider.ICloudElasticcache, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "elastic-cache", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	localElasticcaches := []SElasticcache{}
 	remoteElasticcaches := []cloudprovider.ICloudElasticcache{}
@@ -628,17 +628,10 @@ func (self *SElasticcache) SyncWithCloudElasticcache(ctx context.Context, userCr
 }
 
 func (manager *SElasticcacheManager) newFromCloudElasticcache(ctx context.Context, userCred mcclient.TokenCredential, ownerId mcclient.IIdentityProvider, provider *SCloudprovider, region *SCloudregion, extInstance cloudprovider.ICloudElasticcache) (*SElasticcache, error) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
 
 	instance := SElasticcache{}
 	instance.SetModelManager(manager, &instance)
 
-	newName, err := db.GenerateName(manager, ownerId, extInstance.GetName())
-	if err != nil {
-		return nil, err
-	}
-	instance.Name = newName
 	instance.ExternalId = extInstance.GetGlobalId()
 	// instance.CloudregionId = region.Id
 	// instance.ManagerId = provider.Id
@@ -732,7 +725,17 @@ func (manager *SElasticcacheManager) newFromCloudElasticcache(ctx context.Contex
 		instance.AutoRenew = extInstance.IsAutoRenew()
 	}
 
-	err = manager.TableSpec().Insert(ctx, &instance)
+	err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		instance.Name, err = db.GenerateName(ctx, manager, ownerId, extInstance.GetName())
+		if err != nil {
+			return err
+		}
+
+		return manager.TableSpec().Insert(ctx, &instance)
+	}()
 	if err != nil {
 		return nil, errors.Wrapf(err, "newFromCloudElasticcache.Insert")
 	}

pkg/compute/models/elasticcache_parameters.go

@@ -79,8 +79,8 @@ type SElasticcacheParameter struct {
 }
 
 func (manager *SElasticcacheParameterManager) SyncElasticcacheParameters(ctx context.Context, userCred mcclient.TokenCredential, elasticcache *SElasticcache, cloudElasticcacheParameters []cloudprovider.ICloudElasticcacheParameter) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, elasticcache.GetOwnerId()))
+	lockman.LockRawObject(ctx, "elastic-cache-parameters", elasticcache.Id)
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache-parameters", elasticcache.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/elasticcache_skus.go

@@ -413,8 +413,8 @@ func (manager *SElasticcacheSkuManager) FetchSkusByRegion(regionID string) ([]SE
 }
 
 func (manager *SElasticcacheSkuManager) SyncElasticcacheSkus(ctx context.Context, userCred mcclient.TokenCredential, region *SCloudregion, extSkuMeta *SSkuResourcesMeta) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "elastic-cache-skus", region.Id)
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache-skus", region.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/elasticips.go

@@ -335,8 +335,8 @@ func (self *SElasticip) GetShortDesc(ctx context.Context) *jsonutils.JSONDict {
 func (manager *SElasticipManager) SyncEips(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, eips []cloudprovider.ICloudEIP, syncOwnerId mcclient.IIdentityProvider) compare.SyncResult {
 	// ownerProjId := projectId
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "elasticip", region.Id)
+	defer lockman.ReleaseRawObject(ctx, "elasticip", region.Id)
 
 	// localEips := make([]SElasticip, 0)
 	// remoteEips := make([]cloudprovider.ICloudEIP, 0)
@@ -511,11 +511,6 @@ func (manager *SElasticipManager) newFromCloudEip(ctx context.Context, userCred
 	eip := SElasticip{}
 	eip.SetModelManager(manager, &eip)
 
-	newName, err := db.GenerateName(manager, syncOwnerId, extEip.GetName())
-	if err != nil {
-		return nil, err
-	}
-	eip.Name = newName
 	eip.Status = extEip.GetStatus()
 	eip.ExternalId = extEip.GetGlobalId()
 	eip.IpAddr = extEip.GetIpAddr()
@@ -544,10 +539,20 @@ func (manager *SElasticipManager) newFromCloudEip(ctx context.Context, userCred
 		eip.NetworkId = network.GetId()
 	}
 
-	err = manager.TableSpec().Insert(ctx, &eip)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, syncOwnerId, extEip.GetName())
+		if err != nil {
+			return err
+		}
+		eip.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &eip)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudEip fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "newFromCloudEip")
 	}
 
 	SyncCloudProject(userCred, &eip, syncOwnerId, extEip, eip.ManagerId)
@@ -1317,13 +1322,18 @@ func (manager *SElasticipManager) NewEipForVMOnHost(ctx context.Context, userCre
 		eip.NetworkId = net.Id
 	}
 
-	var err error
-	eip.Name, err = db.GenerateName(manager, userCred, eip.Name)
-	if err != nil {
-		return nil, errors.Wrap(err, "db.GenerateName")
-	}
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
 
-	err = manager.TableSpec().Insert(ctx, eip)
+		var err error
+		eip.Name, err = db.GenerateName(ctx, manager, userCred, eip.Name)
+		if err != nil {
+			return errors.Wrap(err, "db.GenerateName")
+		}
+
+		return manager.TableSpec().Insert(ctx, eip)
+	}()
 	if err != nil {
 		return nil, errors.Wrapf(err, "TableSpec().Insert")
 	}

pkg/compute/models/external_projects.go

@@ -143,8 +143,8 @@ func (manager *SExternalProjectManager) GetProject(externalId string, providerId
 }
 
 func (manager *SExternalProjectManager) SyncProjects(ctx context.Context, userCred mcclient.TokenCredential, account *SCloudaccount, projects []cloudprovider.ICloudProject) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "external-projects", account.Id)
+	defer lockman.ReleaseRawObject(ctx, "external-projects", account.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/filesystem.go

@@ -472,11 +472,6 @@ func (self *SCloudregion) getZoneIdBySuffix(zoneId string) (string, error) {
 func (self *SCloudregion) newFromCloudFileSystem(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, fs cloudprovider.ICloudFileSystem) (*SFileSystem, error) {
 	nas := SFileSystem{}
 	nas.SetModelManager(FileSystemManager, &nas)
-	var err error
-	nas.Name, err = db.GenerateName(FileSystemManager, userCred, fs.GetName())
-	if err != nil {
-		return nil, errors.Wrapf(err, "db.GenerateName")
-	}
 	nas.ExternalId = fs.GetGlobalId()
 	nas.CloudregionId = self.Id
 	nas.ManagerId = provider.Id
@@ -491,7 +486,18 @@ func (self *SCloudregion) newFromCloudFileSystem(ctx context.Context, userCred m
 	if zoneId := fs.GetZoneId(); len(zoneId) > 0 {
 		nas.ZoneId, _ = self.getZoneIdBySuffix(zoneId)
 	}
-	return &nas, FileSystemManager.TableSpec().Insert(ctx, &nas)
+	return func() (*SFileSystem, error) {
+		lockman.LockRawObject(ctx, FileSystemManager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, FileSystemManager.Keyword(), "name")
+
+		var err error
+		nas.Name, err = db.GenerateName(ctx, FileSystemManager, userCred, fs.GetName())
+		if err != nil {
+			return nil, errors.Wrapf(err, "db.GenerateName")
+		}
+
+		return &nas, FileSystemManager.TableSpec().Insert(ctx, &nas)
+	}()
 }
 
 func (self *SFileSystem) AllowPerformSyncstatus(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) bool {

pkg/compute/models/guest_actions.go

@@ -4672,7 +4672,7 @@ func (self *SGuest) validateCreateInstanceSnapshot(
 	dataDict := data.(*jsonutils.JSONDict)
 	nameHint, err := dataDict.GetString("generate_name")
 	if err == nil {
-		name, err = db.GenerateName(InstanceSnapshotManager, ownerId, nameHint)
+		name, err = db.GenerateName(ctx, InstanceSnapshotManager, ownerId, nameHint)
 		if err != nil {
 			return nil, err
 		}
@@ -4824,8 +4824,8 @@ func (self *SGuest) PerformSnapshotAndClone(
 		return nil, httperrors.NewInputParameterError("count must > 0")
 	}
 
-	lockman.LockClass(ctx, InstanceSnapshotManager, self.ProjectId)
-	defer lockman.ReleaseClass(ctx, InstanceSnapshotManager, self.ProjectId)
+	lockman.LockRawObject(ctx, InstanceSnapshotManager.Keyword(), "name")
+	defer lockman.ReleaseRawObject(ctx, InstanceSnapshotManager.Keyword(), "name")
 
 	// validate create instance snapshot and set snapshot pending usage
 	snapshotUsage, err := self.validateCreateInstanceSnapshot(ctx, userCred, query, data)
@@ -4861,7 +4861,7 @@ func (self *SGuest) PerformSnapshotAndClone(
 	// migrate snapshotUsage into regionUsage, then discard snapshotUsage
 	pendingRegionUsage.Snapshot = snapshotUsage.Snapshot
 
-	instanceSnapshotName, err := db.GenerateName(InstanceSnapshotManager, self.GetOwnerId(),
+	instanceSnapshotName, err := db.GenerateName(ctx, InstanceSnapshotManager, self.GetOwnerId(),
 		fmt.Sprintf("%s-%s", newlyGuestName, rand.String(8)))
 	if err != nil {
 		quotas.CancelPendingUsage(ctx, userCred, &pendingUsage, &pendingUsage, false)
@@ -4909,14 +4909,14 @@ func (self *SGuest) StartInstanceSnapshotAndCloneTask(
 func (manager *SGuestManager) CreateGuestFromInstanceSnapshot(
 	ctx context.Context, userCred mcclient.TokenCredential, guestParams *jsonutils.JSONDict, isp *SInstanceSnapshot,
 ) (*SGuest, *jsonutils.JSONDict, error) {
-	lockman.LockClass(ctx, manager, isp.ProjectId)
-	defer lockman.ReleaseClass(ctx, manager, isp.ProjectId)
+	lockman.LockRawObject(ctx, manager.Keyword(), "name")
+	defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
 
 	guestName, err := guestParams.GetString("name")
 	if err != nil {
 		return nil, nil, fmt.Errorf("No new guest name provider")
 	}
-	if guestName, err = db.GenerateName(manager, isp.GetOwnerId(), guestName); err != nil {
+	if guestName, err = db.GenerateName(ctx, manager, isp.GetOwnerId(), guestName); err != nil {
 		return nil, nil, err
 	}
 

pkg/compute/models/guests.go

@@ -2595,15 +2595,6 @@ func (manager *SGuestManager) newCloudVM(ctx context.Context, userCred mcclient.
 
 	guest.Status = extVM.GetStatus()
 	guest.ExternalId = extVM.GetGlobalId()
-	if options.NameSyncResources.Contains(manager.Keyword()) {
-		guest.Name = extVM.GetName()
-	} else {
-		newName, err := db.GenerateName(manager, syncOwnerId, extVM.GetName())
-		if err != nil {
-			return nil, err
-		}
-		guest.Name = newName
-	}
 	guest.VcpuCount = extVM.GetVcpuCount()
 	guest.BootOrder = extVM.GetBootOrder()
 	guest.Vga = extVM.GetVga()
@@ -2660,10 +2651,24 @@ func (manager *SGuestManager) newCloudVM(ctx context.Context, userCred mcclient.
 		guest.VmemSize = extVM.GetVmemSizeMB()
 	}
 
-	err := manager.TableSpec().Insert(ctx, &guest)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		if options.NameSyncResources.Contains(manager.Keyword()) {
+			guest.Name = extVM.GetName()
+		} else {
+			newName, err := db.GenerateName(ctx, manager, syncOwnerId, extVM.GetName())
+			if err != nil {
+				return errors.Wrapf(err, "db.GenerateName")
+			}
+			guest.Name = newName
+		}
+
+		return manager.TableSpec().Insert(ctx, &guest)
+	}()
 	if err != nil {
-		log.Errorf("Insert fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, &guest, syncOwnerId, extVM, host.ManagerId)

pkg/compute/models/hosts.go

@@ -1645,8 +1645,8 @@ func (manager *SHostManager) getHostsByZoneProvider(zone *SZone, provider *SClou
 }
 
 func (manager *SHostManager) SyncHosts(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, zone *SZone, hosts []cloudprovider.ICloudHost) ([]SHost, []cloudprovider.ICloudHost, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "hosts", fmt.Sprintf("%s-%s", zone.Id, provider.Id))
+	defer lockman.ReleaseRawObject(ctx, "hosts", fmt.Sprintf("%s-%s", zone.Id, provider.Id))
 
 	localHosts := make([]SHost, 0)
 	remoteHosts := make([]cloudprovider.ICloudHost, 0)
@@ -1963,11 +1963,6 @@ func (manager *SHostManager) newFromCloudHost(ctx context.Context, userCred mccl
 		izone = wire.GetZone()
 	}
 
-	newName, err := db.GenerateName(manager, userCred, extHost.GetName())
-	if err != nil {
-		return nil, fmt.Errorf("generate name fail %s", err)
-	}
-	host.Name = newName
 	host.ExternalId = extHost.GetGlobalId()
 	host.ZoneId = izone.Id
 
@@ -2010,10 +2005,20 @@ func (manager *SHostManager) newFromCloudHost(ctx context.Context, userCred mccl
 	host.IsPublic = false
 	host.PublicScope = string(rbacutils.ScopeNone)
 
-	err = manager.TableSpec().Insert(ctx, &host)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, extHost.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+		host.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &host)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudHost fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	db.OpsLog.LogEvent(&host, db.ACT_CREATE, host.GetShortDesc(ctx), userCred)
@@ -2037,8 +2042,8 @@ func (manager *SHostManager) newFromCloudHost(ctx context.Context, userCred mccl
 }
 
 func (self *SHost) SyncHostStorages(ctx context.Context, userCred mcclient.TokenCredential, storages []cloudprovider.ICloudStorage, provider *SCloudprovider) ([]SStorage, []cloudprovider.ICloudStorage, compare.SyncResult) {
-	lockman.LockClass(ctx, StorageManager, db.GetLockClassKey(StorageManager, userCred))
-	defer lockman.ReleaseClass(ctx, StorageManager, db.GetLockClassKey(StorageManager, userCred))
+	lockman.LockRawObject(ctx, "storages", self.Id)
+	defer lockman.ReleaseRawObject(ctx, "storages", self.Id)
 
 	localStorages := make([]SStorage, 0)
 	remoteStorages := make([]cloudprovider.ICloudStorage, 0)
@@ -2170,12 +2175,10 @@ func (self *SHost) newCloudHostStorage(ctx context.Context, userCred mcclient.To
 			// create the storage right now
 			storageObj, err = StorageManager.newFromCloudStorage(ctx, userCred, extStorage, provider, self.GetZone())
 			if err != nil {
-				log.Errorf("create by cloud storage fail %s", err)
-				return nil, err
+				return nil, errors.Wrapf(err, "StorageManager.newFromCloudStorage")
 			}
 		} else {
-			log.Errorf("%s", err)
-			return nil, err
+			return nil, errors.Wrapf(err, "FetchByExternalIdAndManagerId(%s)", extStorage.GetGlobalId())
 		}
 	}
 	storage := storageObj.(*SStorage)
@@ -2184,8 +2187,8 @@ func (self *SHost) newCloudHostStorage(ctx context.Context, userCred mcclient.To
 }
 
 func (self *SHost) SyncHostWires(ctx context.Context, userCred mcclient.TokenCredential, wires []cloudprovider.ICloudWire) compare.SyncResult {
-	lockman.LockObject(ctx, self)
-	defer lockman.ReleaseObject(ctx, self)
+	lockman.LockRawObject(ctx, "wires", self.Id)
+	defer lockman.ReleaseRawObject(ctx, "wires", self.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -2298,8 +2301,8 @@ type SGuestSyncResult struct {
 }
 
 func (self *SHost) SyncHostVMs(ctx context.Context, userCred mcclient.TokenCredential, iprovider cloudprovider.ICloudProvider, vms []cloudprovider.ICloudVM, syncOwnerId mcclient.IIdentityProvider) ([]SGuestSyncResult, compare.SyncResult) {
-	lockman.LockClass(ctx, GuestManager, db.GetLockClassKey(GuestManager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, GuestManager, db.GetLockClassKey(GuestManager, syncOwnerId))
+	lockman.LockRawObject(ctx, "guests", self.Id)
+	defer lockman.ReleaseRawObject(ctx, "guests", self.Id)
 
 	syncVMPairs := make([]SGuestSyncResult, 0)
 	syncResult := compare.SyncResult{}

pkg/compute/models/instance_snapshots.go

@@ -593,16 +593,22 @@ func (is *SInstanceSnapshot) SyncWithCloudInstanceSnapshot(ctx context.Context,
 func (manager *SInstanceSnapshotManager) newFromCloudInstanceSnapshot(ctx context.Context, userCred mcclient.TokenCredential, extSnapshot cloudprovider.ICloudInstanceSnapshot, guest *SGuest) (*SInstanceSnapshot, error) {
 	instanceSnapshot := SInstanceSnapshot{}
 	instanceSnapshot.SetModelManager(manager, &instanceSnapshot)
-	newName, err := db.GenerateName(manager, nil, extSnapshot.GetName())
-	if err == nil {
-		instanceSnapshot.Name = extSnapshot.GetName()
-	} else {
-		instanceSnapshot.Name = newName
-	}
+
 	instanceSnapshot.ExternalId = extSnapshot.GetGlobalId()
 	instanceSnapshot.Status = extSnapshot.GetStatus()
 	manager.fillInstanceSnapshot(userCred, guest, &instanceSnapshot)
-	err = manager.TableSpec().Insert(ctx, &instanceSnapshot)
+	var err = func() error {
+		lockman.LockClass(ctx, manager, "name")
+		defer lockman.ReleaseClass(ctx, manager, "name")
+
+		newName, err := db.GenerateName(ctx, manager, nil, extSnapshot.GetName())
+		if err == nil {
+			instanceSnapshot.Name = extSnapshot.GetName()
+		} else {
+			instanceSnapshot.Name = newName
+		}
+		return manager.TableSpec().Insert(ctx, &instanceSnapshot)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/loadbalancerawscachedlbb.go

@@ -80,20 +80,24 @@ func (man *SAwsCachedLbManager) CreateAwsCachedLb(ctx context.Context, userCred
 	cachedlbb.BackendId = lbb.GetId()
 	cachedlbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	cachedlbb.Name = newName
-
 	if err := cachedlbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, cachedlbb)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+		cachedlbb.Name = newName
+
+		return man.TableSpec().Insert(ctx, cachedlbb)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, cachedLbbg.ManagerId)
@@ -124,8 +128,8 @@ func (man *SAwsCachedLbManager) getLoadbalancerBackendsByLoadbalancerBackendgrou
 func (man *SAwsCachedLbManager) SyncLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, loadbalancerBackendgroup *SAwsCachedLbbg, lbbs []cloudprovider.ICloudLoadbalancerBackend, syncRange *SSyncRange) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
+	defer lockman.ReleaseRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -261,20 +265,21 @@ func (man *SAwsCachedLbManager) newFromCloudLoadbalancerBackend(ctx context.Cont
 	lbb.BackendId = locallbb.GetId()
 	lbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbb.Name = newName
-
 	if err := lbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, lbb)
-
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+		lbb.Name, err = db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+		return man.TableSpec().Insert(ctx, lbb)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, loadbalancerBackendgroup.ManagerId)

pkg/compute/models/loadbalancerawscachedlbbg.go

@@ -197,8 +197,8 @@ func (man *SAwsCachedLbbgManager) getLoadbalancerBackendgroupsByRegion(managerId
 func (man *SAwsCachedLbbgManager) SyncLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, lbbgs []cloudprovider.ICloudLoadbalancerBackendGroup, syncRange *SSyncRange) ([]SAwsCachedLbbg, []cloudprovider.ICloudLoadbalancerBackendGroup, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	localLbgs := []SAwsCachedLbbg{}
 	remoteLbbgs := []cloudprovider.ICloudLoadbalancerBackendGroup{}
@@ -427,17 +427,21 @@ func (man *SAwsCachedLbbgManager) newFromCloudLoadbalancerBackendgroup(ctx conte
 			lbbg.HealthCheckInterval = intervalNum
 		}
 	}
-	newName, err := db.GenerateName(man, syncOwnerId, LocalLbbg.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	lbbg.Name = newName
 	lbbg.Status = extLoadbalancerBackendgroup.GetStatus()
 
-	err = man.TableSpec().Insert(ctx, lbbg)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		lbbg.Name, err = db.GenerateName(ctx, man, syncOwnerId, LocalLbbg.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, lbbg)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbbg, syncOwnerId, extLoadbalancerBackendgroup, provider.Id)

pkg/compute/models/loadbalancerbackendgroups.go

@@ -897,8 +897,8 @@ func (man *SLoadbalancerBackendGroupManager) getLoadbalancerBackendgroupsByLoadb
 func (man *SLoadbalancerBackendGroupManager) SyncLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, lb *SLoadbalancer, lbbgs []cloudprovider.ICloudLoadbalancerBackendGroup, syncRange *SSyncRange) ([]SLoadbalancerBackendGroup, []cloudprovider.ICloudLoadbalancerBackendGroup, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backendgroups", lb.Id)
+	defer lockman.ReleaseRawObject(ctx, "backendgroups", lb.Id)
 
 	localLbgs := []SLoadbalancerBackendGroup{}
 	remoteLbbgs := []cloudprovider.ICloudLoadbalancerBackendGroup{}
@@ -1034,18 +1034,22 @@ func (man *SLoadbalancerBackendGroupManager) newFromCloudLoadbalancerBackendgrou
 
 	}*/
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackendgroup.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	lbbg.Name = newName
-
 	lbbg.Type = extLoadbalancerBackendgroup.GetType()
 	lbbg.Status = extLoadbalancerBackendgroup.GetStatus()
-	err = man.TableSpec().Insert(ctx, lbbg)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackendgroup.GetName())
+		if err != nil {
+			return err
+		}
+		lbbg.Name = newName
+
+		return man.TableSpec().Insert(ctx, lbbg)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbbg, syncOwnerId, extLoadbalancerBackendgroup, provider.Id)

pkg/compute/models/loadbalancerbackends.go

@@ -472,8 +472,8 @@ func (lbb *SLoadbalancerBackend) ValidateDeleteCondition(ctx context.Context) er
 func (man *SLoadbalancerBackendManager) SyncLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, loadbalancerBackendgroup *SLoadbalancerBackendGroup, lbbs []cloudprovider.ICloudLoadbalancerBackend, syncRange *SSyncRange) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
+	defer lockman.ReleaseRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -611,20 +611,24 @@ func (man *SLoadbalancerBackendManager) newFromCloudLoadbalancerBackend(ctx cont
 	// lbb.CloudregionId = loadbalancerBackendgroup.CloudregionId
 	// lbb.ManagerId = loadbalancerBackendgroup.ManagerId
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbb.Name = newName
-
 	if err := lbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend, provider.Id); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, lbb)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+		lbb.Name = newName
+
+		return man.TableSpec().Insert(ctx, lbb)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, provider.Id)

pkg/compute/models/loadbalancercachedacls.go

@@ -149,7 +149,7 @@ func (man *SCachedLoadbalancerAclManager) ValidateCreateData(ctx context.Context
 
 	provider := providerV.Model.(*SCloudprovider)
 	data.Set("manager_id", jsonutils.NewString(provider.Id))
-	name, _ := db.GenerateName(man, ownerId, aclV.Model.GetName())
+	name, _ := db.GenerateName(ctx, man, ownerId, aclV.Model.GetName())
 	data.Set("name", jsonutils.NewString(name))
 
 	input := apis.VirtualResourceCreateInput{}
@@ -441,10 +441,8 @@ func (man *SCachedLoadbalancerAclManager) getLoadbalancerAclByRegion(provider *S
 }
 
 func (man *SCachedLoadbalancerAclManager) SyncLoadbalancerAcls(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, acls []cloudprovider.ICloudLoadbalancerAcl, syncRange *SSyncRange) compare.SyncResult {
-	ownerProjId := provider.ProjectId
-
-	lockman.LockClass(ctx, man, ownerProjId)
-	defer lockman.ReleaseClass(ctx, man, ownerProjId)
+	lockman.LockRawObject(ctx, "acls", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "acls", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	syncResult := compare.SyncResult{}
 
@@ -498,12 +496,7 @@ func (man *SCachedLoadbalancerAclManager) newFromCloudLoadbalancerAcl(ctx contex
 	acl := SCachedLoadbalancerAcl{}
 	acl.SetModelManager(man, &acl)
 
-	newName, err := db.GenerateName(man, projectId, extAcl.GetName())
-	if err != nil {
-		return nil, errors.Wrap(err, "cachedLoadbalancerAclManager.new.GenerateName")
-	}
 	acl.ExternalId = extAcl.GetGlobalId()
-	acl.Name = newName
 	acl.ManagerId = provider.Id
 	acl.CloudregionId = region.Id
 
@@ -539,10 +532,19 @@ func (man *SCachedLoadbalancerAclManager) newFromCloudLoadbalancerAcl(ctx contex
 		acl.AclId = localAcl.GetId()
 	}
 
-	err = man.TableSpec().Insert(ctx, &acl)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, man, projectId, extAcl.GetName())
+		if err != nil {
+			return errors.Wrap(err, "cachedLoadbalancerAclManager.new.GenerateName")
+		}
+		acl.Name = newName
+		return man.TableSpec().Insert(ctx, &acl)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudLoadbalancerAcl fail %s", err)
-		return nil, errors.Wrap(err, "cachedLoadbalancerAclManager.new.InsertCachedAcl")
+		return nil, errors.Wrap(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, &acl, projectId, extAcl, acl.ManagerId)

pkg/compute/models/loadbalancercachedcertificates.go

@@ -176,7 +176,7 @@ func (man *SCachedLoadbalancerCertificateManager) ValidateCreateData(ctx context
 
 	provider := providerV.Model.(*SCloudprovider)
 	data.Set("manager_id", jsonutils.NewString(provider.Id))
-	name, _ := db.GenerateName(man, ownerId, certificateV.Model.GetName())
+	name, _ := db.GenerateName(ctx, man, ownerId, certificateV.Model.GetName())
 	data.Set("name", jsonutils.NewString(name))
 
 	input := apis.VirtualResourceCreateInput{}
@@ -308,11 +308,6 @@ func (man *SCachedLoadbalancerCertificateManager) newFromCloudLoadbalancerCertif
 	lbcert := SCachedLoadbalancerCertificate{}
 	lbcert.SetModelManager(man, &lbcert)
 
-	newName, err := db.GenerateName(man, projectId, extCertificate.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbcert.Name = newName
 	lbcert.ExternalId = extCertificate.GetGlobalId()
 	lbcert.ManagerId = provider.Id
 	lbcert.CloudregionId = region.Id
@@ -321,7 +316,7 @@ func (man *SCachedLoadbalancerCertificateManager) newFromCloudLoadbalancerCertif
 	q1 := LoadbalancerCertificateManager.Query().IsFalse("pending_deleted")
 	q1 = q1.Equals("fingerprint", extCertificate.GetFingerprint())
 	q1 = q1.Equals("tenant_id", provider.ProjectId)
-	err = q1.First(&c)
+	err := q1.First(&c)
 	if err != nil {
 		switch err {
 		case sql.ErrNoRows:
@@ -338,10 +333,20 @@ func (man *SCachedLoadbalancerCertificateManager) newFromCloudLoadbalancerCertif
 		lbcert.CertificateId = c.Id
 	}
 
-	err = man.TableSpec().Insert(ctx, &lbcert)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, man, projectId, extCertificate.GetName())
+		if err != nil {
+			return err
+		}
+		lbcert.Name = newName
+
+		return man.TableSpec().Insert(ctx, &lbcert)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudLoadbalancerCertificate fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, &lbcert, projectId, extCertificate, lbcert.ManagerId)
@@ -419,10 +424,8 @@ func (man *SCachedLoadbalancerCertificateManager) getLoadbalancerCertificatesByR
 }
 
 func (man *SCachedLoadbalancerCertificateManager) SyncLoadbalancerCertificates(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, certificates []cloudprovider.ICloudLoadbalancerCertificate, syncRange *SSyncRange) compare.SyncResult {
-	ownerProjId := provider.ProjectId
-
-	lockman.LockClass(ctx, man, ownerProjId)
-	defer lockman.ReleaseClass(ctx, man, ownerProjId)
+	lockman.LockRawObject(ctx, "certificates", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "certificates", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/loadbalancerhuaweicachedlbb.go

@@ -83,20 +83,24 @@ func (man *SHuaweiCachedLbManager) CreateHuaweiCachedLb(ctx context.Context, use
 	cachedlbb.BackendId = lbb.GetId()
 	cachedlbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	cachedlbb.Name = newName
-
 	if err := cachedlbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, cachedlbb)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+		cachedlbb.Name = newName
+
+		return man.TableSpec().Insert(ctx, cachedlbb)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, cachedLbbg.ManagerId)
@@ -127,8 +131,8 @@ func (man *SHuaweiCachedLbManager) getLoadbalancerBackendsByLoadbalancerBackendg
 func (man *SHuaweiCachedLbManager) SyncLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, loadbalancerBackendgroup *SHuaweiCachedLbbg, lbbs []cloudprovider.ICloudLoadbalancerBackend, syncRange *SSyncRange) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
+	defer lockman.ReleaseRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -264,20 +268,24 @@ func (man *SHuaweiCachedLbManager) newFromCloudLoadbalancerBackend(ctx context.C
 	lbb.BackendId = locallbb.GetId()
 	lbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbb.Name = newName
-
 	if err := lbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, lbb)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+		lbb.Name = newName
+
+		return man.TableSpec().Insert(ctx, lbb)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, loadbalancerBackendgroup.ManagerId)
@@ -348,20 +356,24 @@ func newLocalBackendFromCloudLoadbalancerBackend(ctx context.Context, userCred m
 			baseName = "backend"
 		}
 
-		newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-		if err != nil {
-			return nil, err
-		}
-		lbb.Name = newName
-
 		if err := lbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend, lbbgProvider.Id); err != nil {
 			return nil, err
 		}
 
-		err = man.TableSpec().Insert(ctx, lbb)
+		err = func() error {
+			lockman.LockRawObject(ctx, man.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+			newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+			if err != nil {
+				return err
+			}
+			lbb.Name = newName
+
+			return man.TableSpec().Insert(ctx, lbb)
+		}()
 		if err != nil {
-			return nil, err
+			return nil, errors.Wrapf(err, "Insert")
 		}
 
 		SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, lbbgProvider.Id)

pkg/compute/models/loadbalancerhuaweicachedlbbg.go

@@ -185,8 +185,8 @@ func (man *SHuaweiCachedLbbgManager) getLoadbalancerBackendgroupsByLoadbalancer(
 func (man *SHuaweiCachedLbbgManager) SyncLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, lb *SLoadbalancer, lbbgs []cloudprovider.ICloudLoadbalancerBackendGroup, syncRange *SSyncRange) ([]SHuaweiCachedLbbg, []cloudprovider.ICloudLoadbalancerBackendGroup, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, lb.Id))
+	defer lockman.ReleaseRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, lb.Id))
 
 	localLbgs := []SHuaweiCachedLbbg{}
 	remoteLbbgs := []cloudprovider.ICloudLoadbalancerBackendGroup{}
@@ -349,17 +349,22 @@ func (man *SHuaweiCachedLbbgManager) newFromCloudLoadbalancerBackendgroup(ctx co
 	lbbg.ExternalId = extLoadbalancerBackendgroup.GetGlobalId()
 	lbbg.ProtocolType = extLoadbalancerBackendgroup.GetProtocolType()
 
-	newName, err := db.GenerateName(man, syncOwnerId, LocalLbbg.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	lbbg.Name = newName
 	lbbg.Status = extLoadbalancerBackendgroup.GetStatus()
 
-	err = man.TableSpec().Insert(ctx, lbbg)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, LocalLbbg.GetName())
+		if err != nil {
+			return err
+		}
+		lbbg.Name = newName
+
+		return man.TableSpec().Insert(ctx, lbbg)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbbg, syncOwnerId, extLoadbalancerBackendgroup, provider.Id)
@@ -378,18 +383,23 @@ func newLocalBackendgroupFromCloudLoadbalancerBackendgroup(ctx context.Context,
 	// lbbg.ManagerId = lb.ManagerId
 	lbbg.ExternalId = ""
 
-	newName, err := db.GenerateName(localman, syncOwnerId, extLoadbalancerBackendgroup.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	lbbg.Name = newName
 	lbbg.Type = extLoadbalancerBackendgroup.GetType()
 	lbbg.Status = extLoadbalancerBackendgroup.GetStatus()
 
-	err = localman.TableSpec().Insert(ctx, lbbg)
+	var err = func() error {
+		lockman.LockRawObject(ctx, localman.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, localman.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, localman, syncOwnerId, extLoadbalancerBackendgroup.GetName())
+		if err != nil {
+			return err
+		}
+		lbbg.Name = newName
+
+		return localman.TableSpec().Insert(ctx, lbbg)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbbg, syncOwnerId, extLoadbalancerBackendgroup, provider.Id)

pkg/compute/models/loadbalancerlistenerrules.go

@@ -679,8 +679,8 @@ func (man *SLoadbalancerListenerRuleManager) getLoadbalancerListenerRulesByListe
 func (man *SLoadbalancerListenerRuleManager) SyncLoadbalancerListenerRules(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, listener *SLoadbalancerListener, rules []cloudprovider.ICloudLoadbalancerListenerRule, syncRange *SSyncRange) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "listener-rules", listener.Id)
+	defer lockman.ReleaseRawObject(ctx, "listener-rules", listener.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -870,17 +870,21 @@ func (man *SLoadbalancerListenerRuleManager) newFromCloudLoadbalancerListenerRul
 	//lbr.ManagerId = listener.ManagerId
 	//lbr.CloudregionId = listener.CloudregionId
 
-	newName, err := db.GenerateName(man, syncOwnerId, extRule.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbr.Name = newName
 	lbr.constructFieldsFromCloudListenerRule(userCred, extRule)
-	err = man.TableSpec().Insert(ctx, lbr)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extRule.GetName())
+		if err != nil {
+			return err
+		}
+		lbr.Name = newName
+
+		return man.TableSpec().Insert(ctx, lbr)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudLoadbalancerListenerRule fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	err = lbr.updateCachedLoadbalancerBackendGroupAssociate(ctx, extRule)

pkg/compute/models/loadbalancerlisteners.go

@@ -906,8 +906,8 @@ func (man *SLoadbalancerListenerManager) getLoadbalancerListenersByLoadbalancer(
 func (man *SLoadbalancerListenerManager) SyncLoadbalancerListeners(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, lb *SLoadbalancer, listeners []cloudprovider.ICloudLoadbalancerListener, syncRange *SSyncRange) ([]SLoadbalancerListener, []cloudprovider.ICloudLoadbalancerListener, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "listeners", lb.Id)
+	defer lockman.ReleaseRawObject(ctx, "listeners", lb.Id)
 
 	localListeners := []SLoadbalancerListener{}
 	remoteListeners := []cloudprovider.ICloudLoadbalancerListener{}
@@ -1271,17 +1271,22 @@ func (man *SLoadbalancerListenerManager) newFromCloudLoadbalancerListener(ctx co
 	lblis.LoadbalancerId = lb.Id
 	lblis.ExternalId = extListener.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extListener.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lblis.Name = newName
-
 	lblis.constructFieldsFromCloudListener(userCred, lb, extListener)
 
-	err = man.TableSpec().Insert(ctx, lblis)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extListener.GetName())
+		if err != nil {
+			return err
+		}
+		lblis.Name = newName
+
+		return man.TableSpec().Insert(ctx, lblis)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	err = lblis.updateCachedLoadbalancerBackendGroupAssociate(ctx, extListener, lb.ManagerId)

pkg/compute/models/loadbalanceropenstackcachedlbb.go

@@ -79,20 +79,24 @@ func (man *SOpenstackCachedLbManager) CreateOpenstackCachedLb(ctx context.Contex
 	cachedlbb.BackendId = lbb.GetId()
 	cachedlbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	cachedlbb.Name = newName
-
 	if err := cachedlbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, cachedlbb)
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		newName, err := db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+		cachedlbb.Name = newName
+
+		return man.TableSpec().Insert(ctx, cachedlbb)
+	}()
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, lbb, syncOwnerId, extLoadbalancerBackend, cachedLbbg.ManagerId)
@@ -123,8 +127,8 @@ func (man *SOpenstackCachedLbManager) getLoadbalancerBackendsByLoadbalancerBacke
 func (man *SOpenstackCachedLbManager) SyncLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, loadbalancerBackendgroup *SOpenstackCachedLbbg, lbbs []cloudprovider.ICloudLoadbalancerBackend, syncRange *SSyncRange) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
+	defer lockman.ReleaseRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -263,18 +267,21 @@ func (man *SOpenstackCachedLbManager) newFromCloudLoadbalancerBackend(ctx contex
 	lbb.BackendId = locallbb.GetId()
 	lbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbb.Name = newName
-
 	if err := lbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, lbb)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		lbb.Name, err = db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, lbb)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/loadbalanceropenstackcachedlbbg.go

@@ -208,8 +208,8 @@ func (man *SOpenstackCachedLbbgManager) getLoadbalancerBackendgroupsByLoadbalanc
 func (man *SOpenstackCachedLbbgManager) SyncLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, lb *SLoadbalancer, lbbgs []cloudprovider.ICloudLoadbalancerBackendGroup, syncRange *SSyncRange) ([]SOpenstackCachedLbbg, []cloudprovider.ICloudLoadbalancerBackendGroup, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, lb.Id))
+	defer lockman.ReleaseRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, lb.Id))
 
 	localLbgs := []SOpenstackCachedLbbg{}
 	remoteLbbgs := []cloudprovider.ICloudLoadbalancerBackendGroup{}
@@ -375,15 +375,19 @@ func (man *SOpenstackCachedLbbgManager) newFromCloudLoadbalancerBackendgroup(ctx
 	lbbg.ExternalId = extLoadbalancerBackendgroup.GetGlobalId()
 	lbbg.ProtocolType = extLoadbalancerBackendgroup.GetProtocolType()
 
-	newName, err := db.GenerateName(man, syncOwnerId, LocalLbbg.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	lbbg.Name = newName
 	lbbg.Status = extLoadbalancerBackendgroup.GetStatus()
 
-	err = man.TableSpec().Insert(ctx, lbbg)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		lbbg.Name, err = db.GenerateName(ctx, man, syncOwnerId, LocalLbbg.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, lbbg)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/loadbalancerqcloudcachedlbb.go

@@ -164,18 +164,21 @@ func (man *SQcloudCachedLbManager) newFromCloudLoadbalancerBackend(ctx context.C
 	lbb.BackendId = locallbb.GetId()
 	lbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lbb.Name = newName
-
 	if err := lbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, lbb)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		lbb.Name, err = db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, lbb)
+	}()
 	if err != nil {
 		return nil, err
 	}
@@ -199,8 +202,8 @@ func (man *SQcloudCachedLbManager) getLoadbalancerBackendsByLoadbalancerBackendg
 func (man *SQcloudCachedLbManager) SyncLoadbalancerBackends(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, loadbalancerBackendgroup *SQcloudCachedLbbg, lbbs []cloudprovider.ICloudLoadbalancerBackend, syncRange *SSyncRange) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
+	defer lockman.ReleaseRawObject(ctx, "backends", loadbalancerBackendgroup.Id)
 
 	syncResult := compare.SyncResult{}
 
@@ -267,18 +270,22 @@ func (man *SQcloudCachedLbManager) CreateQcloudCachedLb(ctx context.Context, use
 	cachedlbb.BackendId = lbb.GetId()
 	cachedlbb.ExternalId = extLoadbalancerBackend.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLoadbalancerBackend.GetName())
-	if err != nil {
-		return nil, err
-	}
-	cachedlbb.Name = newName
-
 	if err := cachedlbb.constructFieldsFromCloudLoadbalancerBackend(extLoadbalancerBackend); err != nil {
 		return nil, err
 	}
 
-	err = man.TableSpec().Insert(ctx, cachedlbb)
+	var err error
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
 
+		cachedlbb.Name, err = db.GenerateName(ctx, man, syncOwnerId, extLoadbalancerBackend.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, cachedlbb)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/loadbalancerqcloudcachedlbbg.go

@@ -257,8 +257,8 @@ func (man *SQcloudCachedLbbgManager) getLoadbalancerBackendgroupsByLoadbalancer(
 func (man *SQcloudCachedLbbgManager) SyncLoadbalancerBackendgroups(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, lb *SLoadbalancer, lbbgs []cloudprovider.ICloudLoadbalancerBackendGroup, syncRange *SSyncRange) ([]SQcloudCachedLbbg, []cloudprovider.ICloudLoadbalancerBackendGroup, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, lb.Id))
+	defer lockman.ReleaseRawObject(ctx, "backendgroups", fmt.Sprintf("%s-%s", provider.Id, lb.Id))
 
 	localLbgs := []SQcloudCachedLbbg{}
 	remoteLbbgs := []cloudprovider.ICloudLoadbalancerBackendGroup{}
@@ -331,15 +331,19 @@ func (man *SQcloudCachedLbbgManager) newFromCloudLoadbalancerBackendgroup(ctx co
 	lbbg.BackendGroupId = LocalLbbg.GetId()
 	lbbg.ExternalId = extLoadbalancerBackendgroup.GetGlobalId()
 
-	newName, err := db.GenerateName(man, syncOwnerId, LocalLbbg.GetName())
-	if err != nil {
-		return nil, err
-	}
-
-	lbbg.Name = newName
 	lbbg.Status = extLoadbalancerBackendgroup.GetStatus()
 
-	err = man.TableSpec().Insert(ctx, lbbg)
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		lbbg.Name, err = db.GenerateName(ctx, man, syncOwnerId, LocalLbbg.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, lbbg)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/loadbalancers.go

@@ -864,8 +864,8 @@ func (man *SLoadbalancerManager) getLocalLoadbalancers(ctx context.Context, user
 func (man *SLoadbalancerManager) SyncLoadbalancers(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, lbs []cloudprovider.ICloudLoadbalancer, syncRange *SSyncRange) ([]SLoadbalancer, []cloudprovider.ICloudLoadbalancer, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, syncOwnerId))
+	lockman.LockRawObject(ctx, "loadbalance", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "loadbalance", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	localLbs := []SLoadbalancer{}
 	remoteLbs := []cloudprovider.ICloudLoadbalancer{}
@@ -957,11 +957,6 @@ func (man *SLoadbalancerManager) newFromCloudLoadbalancer(ctx context.Context, u
 	lb.AddressType = extLb.GetAddressType()
 	lb.NetworkType = extLb.GetNetworkType()
 
-	newName, err := db.GenerateName(man, syncOwnerId, extLb.GetName())
-	if err != nil {
-		return nil, err
-	}
-	lb.Name = newName
 	lb.Status = extLb.GetStatus()
 	lb.LoadbalancerSpec = extLb.GetLoadbalancerSpec()
 	lb.ChargeType = extLb.GetChargeType()
@@ -1001,9 +996,20 @@ func (man *SLoadbalancerManager) newFromCloudLoadbalancer(ctx context.Context, u
 		lb.LBInfo = jsonutils.Marshal(extLb.GetSysTags())
 	}
 
-	if err := man.TableSpec().Insert(ctx, &lb); err != nil {
-		log.Errorf("newFromCloudRegion fail %s", err)
-		return nil, err
+	var err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		var err error
+		lb.Name, err = db.GenerateName(ctx, man, syncOwnerId, extLb.GetName())
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, &lb)
+	}()
+	if err != nil {
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudProject(userCred, &lb, syncOwnerId, extLb, provider.Id)

pkg/compute/models/natdtable.go

@@ -18,7 +18,6 @@ import (
 	"context"
 
 	"yunion.io/x/jsonutils"
-	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 	"yunion.io/x/pkg/util/compare"
 	"yunion.io/x/pkg/util/regutils"
@@ -180,8 +179,8 @@ func (man *SNatDEntryManager) ValidateCreateData(ctx context.Context, userCred m
 func (manager *SNatDEntryManager) SyncNatDTable(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, nat *SNatGateway, extDTable []cloudprovider.ICloudNatDEntry) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "dtable", nat.Id)
+	defer lockman.ReleaseRawObject(ctx, "dtable", nat.Id)
 
 	result := compare.SyncResult{}
 	dbNatDTables, err := nat.GetDTable()
@@ -273,7 +272,6 @@ func (manager *SNatDEntryManager) newFromCloudNatDTable(ctx context.Context, use
 	table := SNatDEntry{}
 	table.SetModelManager(manager, &table)
 
-	table.Name, _ = db.GenerateName(manager, ownerId, extEntry.GetName())
 	table.Status = extEntry.GetStatus()
 	table.ExternalId = extEntry.GetGlobalId()
 	table.IsEmulated = extEntry.IsEmulated()
@@ -284,10 +282,20 @@ func (manager *SNatDEntryManager) newFromCloudNatDTable(ctx context.Context, use
 	table.InternalPort = extEntry.GetInternalPort()
 	table.IpProtocol = extEntry.GetIpProtocol()
 
-	err := manager.TableSpec().Insert(ctx, &table)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		var err error
+		table.Name, err = db.GenerateName(ctx, manager, ownerId, extEntry.GetName())
+		if err != nil {
+			return err
+		}
+
+		return manager.TableSpec().Insert(ctx, &table)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudNatDTable fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudDomain(userCred, &table, ownerId)

pkg/compute/models/natgateways.go

@@ -393,8 +393,8 @@ func (manager SNatGatewayManager) FetchCustomizeColumns(
 }
 
 func (manager *SNatGatewayManager) SyncNatGateways(ctx context.Context, userCred mcclient.TokenCredential, syncOwnerId mcclient.IIdentityProvider, provider *SCloudprovider, vpc *SVpc, cloudNatGateways []cloudprovider.ICloudNatGateway) ([]SNatGateway, []cloudprovider.ICloudNatGateway, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "natgateways", vpc.Id)
+	defer lockman.ReleaseRawObject(ctx, "natgateways", vpc.Id)
 
 	localNatGateways := make([]SNatGateway, 0)
 	remoteNatGateways := make([]cloudprovider.ICloudNatGateway, 0)
@@ -519,11 +519,6 @@ func (manager *SNatGatewayManager) newFromCloudNatGateway(ctx context.Context, u
 	nat := SNatGateway{}
 	nat.SetModelManager(manager, &nat)
 
-	newName, err := db.GenerateName(manager, ownerId, extNat.GetName())
-	if err != nil {
-		return nil, errors.Wrap(err, "db.GenerateName")
-	}
-	nat.Name = newName
 	nat.VpcId = vpc.Id
 	nat.Status = extNat.GetStatus()
 	nat.NatSpec = extNat.GetNatSpec()
@@ -556,9 +551,19 @@ func (manager *SNatGatewayManager) newFromCloudNatGateway(ctx context.Context, u
 		}
 	}
 
-	err = manager.TableSpec().Insert(ctx, &nat)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, ownerId, extNat.GetName())
+		if err != nil {
+			return errors.Wrap(err, "db.GenerateName")
+		}
+		nat.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &nat)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudNatGateway fail %s", err)
 		return nil, errors.Wrap(err, "Insert")
 	}
 
@@ -621,6 +626,9 @@ func (self *SNatGateway) GetEips() ([]SElasticip, error) {
 }
 
 func (self *SNatGateway) SyncNatGatewayEips(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, extEips []cloudprovider.ICloudEIP) compare.SyncResult {
+	lockman.LockRawObject(ctx, "elasticip", self.Id)
+	defer lockman.ReleaseRawObject(ctx, "elasticip", self.Id)
+
 	result := compare.SyncResult{}
 
 	dbEips, err := self.GetEips()

pkg/compute/models/natstable.go

@@ -18,7 +18,6 @@ import (
 	"context"
 
 	"yunion.io/x/jsonutils"
-	"yunion.io/x/log"
 	"yunion.io/x/pkg/errors"
 	"yunion.io/x/pkg/util/compare"
 	"yunion.io/x/pkg/util/netutils"
@@ -234,8 +233,8 @@ func (man *SNatSEntryManager) ValidateCreateData(ctx context.Context, userCred m
 func (manager *SNatSEntryManager) SyncNatSTable(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, nat *SNatGateway, extTable []cloudprovider.ICloudNatSEntry) compare.SyncResult {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "stable", nat.Id)
+	defer lockman.ReleaseRawObject(ctx, "stable", nat.Id)
 
 	result := compare.SyncResult{}
 	dbNatSTables, err := nat.GetSTable()
@@ -329,7 +328,6 @@ func (manager *SNatSEntryManager) newFromCloudNatSTable(ctx context.Context, use
 	table := SNatSEntry{}
 	table.SetModelManager(manager, &table)
 
-	table.Name, _ = db.GenerateName(manager, ownerId, extEntry.GetName())
 	table.Status = extEntry.GetStatus()
 	table.ExternalId = extEntry.GetGlobalId()
 	table.IsEmulated = extEntry.IsEmulated()
@@ -351,10 +349,20 @@ func (manager *SNatSEntryManager) newFromCloudNatSTable(ctx context.Context, use
 		table.NetworkId = network.GetId()
 	}
 
-	err := manager.TableSpec().Insert(ctx, &table)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		var err error
+		table.Name, err = db.GenerateName(ctx, manager, ownerId, extEntry.GetName())
+		if err != nil {
+			return err
+		}
+
+		return manager.TableSpec().Insert(ctx, &table)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudNatSTable fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudDomain(userCred, &table, ownerId)

pkg/compute/models/networkinterfacenetwork.go

@@ -107,8 +107,8 @@ func (self *SNetworkinterfacenetwork) Detach(ctx context.Context, userCred mccli
 }
 
 func (manager *SNetworkinterfacenetworkManager) SyncInterfaceAddresses(ctx context.Context, userCred mcclient.TokenCredential, networkinterface *SNetworkInterface, exts []cloudprovider.ICloudInterfaceAddress) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, networkinterface.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, networkinterface.GetOwnerId()))
+	lockman.LockRawObject(ctx, "interface-addrs", networkinterface.Id)
+	defer lockman.ReleaseRawObject(ctx, "interface-addrs", networkinterface.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/networkinterfaces.go

@@ -16,6 +16,7 @@ package models
 
 import (
 	"context"
+	"fmt"
 
 	"yunion.io/x/jsonutils"
 	"yunion.io/x/log"
@@ -223,8 +224,8 @@ func (manager *SNetworkInterfaceManager) getNetworkInterfacesByProviderId(provid
 }
 
 func (manager *SNetworkInterfaceManager) SyncNetworkInterfaces(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, exts []cloudprovider.ICloudNetworkInterface) ([]SNetworkInterface, []cloudprovider.ICloudNetworkInterface, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "network-interfaces", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "network-interfaces", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	localResources := make([]SNetworkInterface, 0)
 	remoteResources := make([]cloudprovider.ICloudNetworkInterface, 0)
@@ -342,12 +343,6 @@ func (manager *SNetworkInterfaceManager) newFromCloudNetworkInterface(ctx contex
 	networkinterface := SNetworkInterface{}
 	networkinterface.SetModelManager(manager, &networkinterface)
 
-	newName, err := db.GenerateName(manager, provider.GetOwnerId(), ext.GetName())
-	if err != nil {
-		return nil, err
-	}
-	networkinterface.Name = newName
-
 	networkinterface.Status = ext.GetStatus()
 	networkinterface.ExternalId = ext.GetGlobalId()
 	networkinterface.CloudregionId = region.Id
@@ -363,9 +358,20 @@ func (manager *SNetworkInterfaceManager) newFromCloudNetworkInterface(ctx contex
 		}
 	}
 
-	err = manager.TableSpec().Insert(ctx, &networkinterface)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, provider.GetOwnerId(), ext.GetName())
+		if err != nil {
+			return err
+		}
+		networkinterface.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &networkinterface)
+	}()
 	if err != nil {
-		return nil, errors.Wrap(err, "TableSpec().Insert(&networkinterface)")
+		return nil, errors.Wrap(err, "Insert")
 	}
 
 	SyncCloudDomain(userCred, &networkinterface, provider.GetOwnerId())

pkg/compute/models/networks.go

@@ -659,8 +659,8 @@ func (manager *SNetworkManager) getNetworksByWire(wire *SWire) ([]SNetwork, erro
 func (manager *SNetworkManager) SyncNetworks(ctx context.Context, userCred mcclient.TokenCredential, wire *SWire, nets []cloudprovider.ICloudNetwork, provider *SCloudprovider) ([]SNetwork, []cloudprovider.ICloudNetwork, compare.SyncResult) {
 	syncOwnerId := provider.GetOwnerId()
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "networks", wire.Id)
+	defer lockman.ReleaseRawObject(ctx, "networks", wire.Id)
 
 	localNets := make([]SNetwork, 0)
 	remoteNets := make([]cloudprovider.ICloudNetwork, 0)
@@ -783,11 +783,6 @@ func (manager *SNetworkManager) newFromCloudNetwork(ctx context.Context, userCre
 	net := SNetwork{}
 	net.SetModelManager(manager, &net)
 
-	newName, err := db.GenerateName(manager, syncOwnerId, extNet.GetName())
-	if err != nil {
-		return nil, err
-	}
-	net.Name = newName
 	net.Status = extNet.GetStatus()
 	net.ExternalId = extNet.GetGlobalId()
 	net.WireId = wire.Id
@@ -805,10 +800,20 @@ func (manager *SNetworkManager) newFromCloudNetwork(ctx context.Context, userCre
 
 	net.AllocTimoutSeconds = extNet.GetAllocTimeoutSeconds()
 
-	err = manager.TableSpec().Insert(ctx, &net)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, syncOwnerId, extNet.GetName())
+		if err != nil {
+			return err
+		}
+		net.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &net)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudZone fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	vpc := wire.GetVpc()
@@ -2429,26 +2434,7 @@ func (self *SNetwork) PerformSplit(ctx context.Context, userCred mcclient.TokenC
 		return nil, httperrors.NewInputParameterError("Split IP %s out of range", input.SplitIp)
 	}
 
-	lockman.LockClass(ctx, NetworkManager, db.GetLockClassKey(NetworkManager, userCred))
-	defer lockman.ReleaseClass(ctx, NetworkManager, db.GetLockClassKey(NetworkManager, userCred))
-
-	if len(input.Name) > 0 {
-		if err := db.NewNameValidator(NetworkManager, userCred, input.Name, nil); err != nil {
-			return nil, httperrors.NewInputParameterError("Duplicate name %s", input.Name)
-		}
-	} else {
-		input.Name, err = db.GenerateName(NetworkManager, userCred, fmt.Sprintf("%s#", self.Name))
-		if err != nil {
-			return nil, httperrors.NewInternalServerError("GenerateName fail %s", err)
-		}
-	}
-
 	network := &SNetwork{}
-	network.Name = input.Name
-	network.IfnameHint, err = NetworkManager.newIfnameHint(input.Name)
-	if err != nil {
-		return nil, httperrors.NewBadRequestError("Generate ifname hint failed %s", err)
-	}
 	network.GuestIpStart = input.SplitIp
 	network.GuestIpEnd = self.GuestIpEnd
 	network.GuestIpMask = self.GuestIpMask
@@ -2468,7 +2454,29 @@ func (self *SNetwork) PerformSplit(ctx context.Context, userCred mcclient.TokenC
 	network.Description = self.Description
 	network.IsAutoAlloc = self.IsAutoAlloc
 
-	err = NetworkManager.TableSpec().Insert(ctx, network)
+	err = func() error {
+		lockman.LockRawObject(ctx, NetworkManager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, NetworkManager.Keyword(), "name")
+
+		if len(input.Name) > 0 {
+			if err := db.NewNameValidator(NetworkManager, userCred, input.Name, nil); err != nil {
+				return httperrors.NewInputParameterError("Duplicate name %s", input.Name)
+			}
+		} else {
+			input.Name, err = db.GenerateName(ctx, NetworkManager, userCred, fmt.Sprintf("%s#", self.Name))
+			if err != nil {
+				return httperrors.NewInternalServerError("GenerateName fail %s", err)
+			}
+		}
+
+		network.Name = input.Name
+		network.IfnameHint, err = NetworkManager.newIfnameHint(input.Name)
+		if err != nil {
+			return httperrors.NewBadRequestError("Generate ifname hint failed %s", err)
+		}
+
+		return NetworkManager.TableSpec().Insert(ctx, network)
+	}()
 	if err != nil {
 		return nil, err
 	}
@@ -2592,13 +2600,18 @@ func (manager *SNetworkManager) PerformTryCreateNetwork(ctx context.Context, use
 		newNetwork.IsPublic = nm.IsPublic
 		newNetwork.ProjectId = userCred.GetProjectId()
 		newNetwork.DomainId = userCred.GetProjectDomainId()
-		newName, err := db.GenerateName(NetworkManager, userCred, fmt.Sprintf("%s#", nm.Name))
-		if err != nil {
-			return nil, httperrors.NewInternalServerError("GenerateName fail %s", err)
-		}
-		newNetwork.Name = newName
 
-		err = NetworkManager.TableSpec().Insert(ctx, newNetwork)
+		err = func() error {
+			lockman.LockRawObject(ctx, NetworkManager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, NetworkManager.Keyword(), "name")
+
+			newNetwork.Name, err = db.GenerateName(ctx, NetworkManager, userCred, fmt.Sprintf("%s#", nm.Name))
+			if err != nil {
+				return httperrors.NewInternalServerError("GenerateName fail %s", err)
+			}
+
+			return NetworkManager.TableSpec().Insert(ctx, newNetwork)
+		}()
 		if err != nil {
 			return nil, err
 		}

pkg/compute/models/routetable_routesets.go

@@ -390,16 +390,22 @@ func (manager *SRouteTableRouteSetManager) newRouteSetFromCloud(ctx context.Cont
 			}
 		}
 	}
-	{
+
+	var err = func() error {
 		basename := routeSetBasename(cloudRouteSet.GetName(), cloudRouteSet.GetCidr())
-		newName, err := db.GenerateName(manager, userCred, basename)
+
+		lockman.LockClass(ctx, manager, "name")
+		defer lockman.ReleaseClass(ctx, manager, "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, basename)
 		if err != nil {
-			return nil, err
+			return err
 		}
 		routeSet.Name = newName
-	}
 
-	if err := manager.TableSpec().Insert(ctx, routeSet); err != nil {
+		return manager.TableSpec().Insert(ctx, routeSet)
+	}()
+	if err != nil {
 		return nil, err
 	}
 

pkg/compute/models/routetables.go

@@ -373,8 +373,8 @@ func (manager *SRouteTableManager) FetchCustomizeColumns(
 }
 
 func (man *SRouteTableManager) SyncRouteTables(ctx context.Context, userCred mcclient.TokenCredential, vpc *SVpc, cloudRouteTables []cloudprovider.ICloudRouteTable, provider *SCloudprovider) ([]SRouteTable, []cloudprovider.ICloudRouteTable, compare.SyncResult) {
-	lockman.LockClass(ctx, man, db.GetLockClassKey(man, userCred))
-	defer lockman.ReleaseClass(ctx, man, db.GetLockClassKey(man, userCred))
+	lockman.LockRawObject(ctx, "route-tables", vpc.Id)
+	defer lockman.ReleaseRawObject(ctx, "route-tables", vpc.Id)
 
 	localRouteTables := make([]SRouteTable, 0)
 	remoteRouteTables := make([]cloudprovider.ICloudRouteTable, 0)
@@ -429,7 +429,7 @@ func (man *SRouteTableManager) SyncRouteTables(ctx context.Context, userCred mcc
 	return localRouteTables, remoteRouteTables, syncResult
 }
 
-func (man *SRouteTableManager) newRouteTableFromCloud(userCred mcclient.TokenCredential, vpc *SVpc, cloudRouteTable cloudprovider.ICloudRouteTable) (*SRouteTable, error) {
+func (man *SRouteTableManager) newRouteTableFromCloud(ctx context.Context, userCred mcclient.TokenCredential, vpc *SVpc, cloudRouteTable cloudprovider.ICloudRouteTable) (*SRouteTable, error) {
 	routes := api.SRoutes{}
 	{
 		cloudRoutes, err := cloudRouteTable.GetIRoutes()
@@ -453,7 +453,7 @@ func (man *SRouteTableManager) newRouteTableFromCloud(userCred mcclient.TokenCre
 	routeTable.VpcId = vpc.Id
 	{
 		basename := routeTableBasename(cloudRouteTable.GetName(), vpc.Name)
-		newName, err := db.GenerateName(man, userCred, basename)
+		newName, err := db.GenerateName(ctx, man, userCred, basename)
 		if err != nil {
 			return nil, err
 		}
@@ -480,13 +480,22 @@ func routeTableBasename(name, vpcName string) string {
 }
 
 func (man *SRouteTableManager) insertFromCloud(ctx context.Context, userCred mcclient.TokenCredential, vpc *SVpc, cloudRouteTable cloudprovider.ICloudRouteTable, provider *SCloudprovider) (*SRouteTable, error) {
-	routeTable, err := man.newRouteTableFromCloud(userCred, vpc, cloudRouteTable)
+	var routeTable *SRouteTable
+	var err error
+	err = func() error {
+		lockman.LockRawObject(ctx, man.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+		routeTable, err = man.newRouteTableFromCloud(ctx, userCred, vpc, cloudRouteTable)
+		if err != nil {
+			return err
+		}
+
+		return man.TableSpec().Insert(ctx, routeTable)
+	}()
 	if err != nil {
 		return nil, err
 	}
-	if err := man.TableSpec().Insert(ctx, routeTable); err != nil {
-		return nil, err
-	}
 	if provider != nil {
 		SyncCloudDomain(userCred, routeTable, provider.GetOwnerId())
 		routeTable.SyncShareState(ctx, userCred, provider.getAccountShareInfo())
@@ -510,7 +519,7 @@ func (self *SRouteTable) syncRemoveCloudRouteTable(ctx context.Context, userCred
 
 func (self *SRouteTable) SyncWithCloudRouteTable(ctx context.Context, userCred mcclient.TokenCredential, vpc *SVpc, cloudRouteTable cloudprovider.ICloudRouteTable, provider *SCloudprovider) error {
 	man := self.GetModelManager().(*SRouteTableManager)
-	routeTable, err := man.newRouteTableFromCloud(userCred, vpc, cloudRouteTable)
+	routeTable, err := man.newRouteTableFromCloud(ctx, userCred, vpc, cloudRouteTable)
 	if err != nil {
 		return err
 	}

pkg/compute/models/secgroupcache.go

@@ -432,8 +432,8 @@ func (self *SSecurityGroupCache) syncWithCloudSecurityGroup(ctx context.Context,
 }
 
 func (manager *SSecurityGroupCacheManager) SyncSecurityGroupCaches(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, secgroups []cloudprovider.ICloudSecurityGroup, vpc *SVpc) ([]SSecurityGroup, []cloudprovider.ICloudSecurityGroup, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "secgroups", vpc.Id)
+	defer lockman.ReleaseRawObject(ctx, "secgroups", vpc.Id)
 
 	localSecgroups := []SSecurityGroup{}
 	remoteSecgroups := []cloudprovider.ICloudSecurityGroup{}

pkg/compute/models/secgroups.go

@@ -788,16 +788,10 @@ func (self *SSecurityGroup) PerformClone(ctx context.Context, userCred mcclient.
 		DomainId:  userCred.GetProjectDomainId(),
 		ProjectId: userCred.GetProjectId(),
 	}
-	var err error
-	input.Name, err = db.GenerateName(SecurityGroupManager, ownerId, input.Name)
-	if err != nil {
-		return input, err
-	}
-
 	pendingUsage := SProjectQuota{Secgroup: 1}
 	quotaKey := quotas.OwnerIdProjectQuotaKeys(rbacutils.ScopeProject, ownerId)
 	pendingUsage.SetKeys(quotaKey)
-	err = quotas.CheckSetPendingQuota(ctx, userCred, &pendingUsage)
+	err := quotas.CheckSetPendingQuota(ctx, userCred, &pendingUsage)
 	if err != nil {
 		return input, httperrors.NewOutOfQuotaError("%s", err)
 	}
@@ -811,7 +805,17 @@ func (self *SSecurityGroup) PerformClone(ctx context.Context, userCred mcclient.
 	secgroup.ProjectId = userCred.GetProjectId()
 	secgroup.DomainId = userCred.GetProjectDomainId()
 
-	err = SecurityGroupManager.TableSpec().Insert(ctx, secgroup)
+	err = func() error {
+		lockman.LockClass(ctx, SecurityGroupManager, "name")
+		defer lockman.ReleaseClass(ctx, SecurityGroupManager, "name")
+
+		input.Name, err = db.GenerateName(ctx, SecurityGroupManager, ownerId, input.Name)
+		if err != nil {
+			return err
+		}
+
+		return SecurityGroupManager.TableSpec().Insert(ctx, secgroup)
+	}()
 	if err != nil {
 		return input, httperrors.NewGeneralError(errors.Wrapf(err, "Insert"))
 	}
@@ -1070,22 +1074,25 @@ func (manager *SSecurityGroupManager) newFromCloudSecgroup(ctx context.Context,
 		}
 	}
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-
 	secgroup := SSecurityGroup{}
 	secgroup.SetModelManager(manager, &secgroup)
-	secgroup.Name, err = db.GenerateName(manager, userCred, extSec.GetName())
-	if err != nil {
-		return nil, nil, err
-	}
 
 	secgroup.Status = api.SECGROUP_STATUS_READY
 	secgroup.Description = extSec.GetDescription()
 	secgroup.ProjectId = provider.ProjectId
 	secgroup.DomainId = provider.DomainId
 
-	err = manager.TableSpec().Insert(ctx, &secgroup)
+	err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		secgroup.Name, err = db.GenerateName(ctx, manager, userCred, extSec.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+
+		return manager.TableSpec().Insert(ctx, &secgroup)
+	}()
 	if err != nil {
 		return nil, nil, errors.Wrapf(err, "Insert")
 	}

pkg/compute/models/skus.go

@@ -1032,8 +1032,8 @@ func (manager *SServerSkuManager) PendingDeleteInvalidSku() error {
 }
 
 func (manager *SServerSkuManager) SyncPrivateCloudSkus(ctx context.Context, userCred mcclient.TokenCredential, region *SCloudregion, skus []cloudprovider.ICloudSku) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "serverskus", region.Id)
+	defer lockman.ReleaseRawObject(ctx, "serverskus", region.Id)
 
 	result := compare.SyncResult{}
 
@@ -1144,6 +1144,7 @@ func (self *SServerSku) setPrepaidPostpaidStatus(userCred mcclient.TokenCredenti
 
 func (manager *SServerSkuManager) newFromCloudSku(ctx context.Context, userCred mcclient.TokenCredential, region *SCloudregion, extSku cloudprovider.ICloudSku) error {
 	sku := &SServerSku{Provider: region.Provider}
+
 	sku.SetModelManager(manager, sku)
 	// 第一次同步新建的套餐是启用状态
 	sku.Enabled = tristate.True
@@ -1151,10 +1152,22 @@ func (manager *SServerSkuManager) newFromCloudSku(ctx context.Context, userCred
 	sku.constructSku(extSku)
 
 	sku.CloudregionId = region.Id
+
 	sku.SetModelManager(manager, sku)
-	err := manager.TableSpec().Insert(ctx, sku)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		var err error
+		sku.Name, err = db.GenerateName(ctx, manager, userCred, extSku.GetName())
+		if err != nil {
+			return errors.Wrap(err, "db.GenerateName")
+		}
+
+		return manager.TableSpec().Insert(ctx, sku)
+	}()
 	if err != nil {
-		return errors.Wrapf(err, "newFromCloudSku.Insert")
+		return errors.Wrapf(err, "Insert")
 	}
 	db.OpsLog.LogEvent(sku, db.ACT_CREATE, sku.GetShortDesc(ctx), userCred)
 
@@ -1205,8 +1218,8 @@ func (manager *SServerSkuManager) FetchSkusByRegion(regionID string) ([]SServerS
 }
 
 func (manager *SServerSkuManager) SyncServerSkus(ctx context.Context, userCred mcclient.TokenCredential, region *SCloudregion, extSkuMeta *SSkuResourcesMeta) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "serverskus", region.Id)
+	defer lockman.ReleaseRawObject(ctx, "serverskus", region.Id)
 
 	syncResult := compare.SyncResult{}
 

pkg/compute/models/snapshotpolicy.go

@@ -404,8 +404,8 @@ func (manager *SSnapshotPolicyManager) SyncSnapshotPolicies(ctx context.Context,
 	provider *SCloudprovider, region *SCloudregion, cloudSPs []cloudprovider.ICloudSnapshotPolicy,
 	syncOwnerId mcclient.IIdentityProvider) compare.SyncResult {
 
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "snapshotpolicies", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "snapshotpolicies", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 	syncResult := compare.SyncResult{}
 
 	// Fetch allsnapshotpolicy caches
@@ -546,7 +546,6 @@ func (manager *SSnapshotPolicyManager) newFromCloudSnapshotPolicy(
 	ctx context.Context, userCred mcclient.TokenCredential, snapshotpolicyCluster map[uint64][]*SSnapshotPolicy,
 	ext cloudprovider.ICloudSnapshotPolicy, region *SCloudregion, syncOwnerId mcclient.IIdentityProvider, provider *SCloudprovider,
 ) (*SSnapshotPolicy, error) {
-
 	snapshotPolicyTmp := SSnapshotPolicy{}
 	snapshotPolicyTmp.RetentionDays = ext.GetRetentionDays()
 	arw, err := ext.GetRepeatWeekdays()
@@ -598,17 +597,22 @@ func (manager *SSnapshotPolicyManager) newFromCloudSnapshotPolicy(
 	// no such suitable snapshotpolicy
 	if snapshotPolicy == nil {
 		snapshotPolicyTmp.SetModelManager(manager, &snapshotPolicyTmp)
-		newName, err := db.GenerateName(manager, syncOwnerId, ext.GetName())
-		if err != nil {
-			return nil, err
-		}
-		snapshotPolicyTmp.Name = newName
 		snapshotPolicyTmp.Status = ext.GetStatus()
 
-		err = manager.TableSpec().Insert(ctx, &snapshotPolicyTmp)
+		var err = func() error {
+			lockman.LockRawObject(ctx, manager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+			newName, err := db.GenerateName(ctx, manager, syncOwnerId, ext.GetName())
+			if err != nil {
+				return err
+			}
+			snapshotPolicyTmp.Name = newName
+
+			return manager.TableSpec().Insert(ctx, &snapshotPolicyTmp)
+		}()
 		if err != nil {
-			log.Errorf("newFromCloudEip fail %s", err)
-			return nil, err
+			return nil, errors.Wrapf(err, "Insert")
 		}
 		// sync project
 		SyncCloudProject(userCred, &snapshotPolicyTmp, syncOwnerId, ext, provider.GetId())

pkg/compute/models/snapshotpolicydisks.go

@@ -356,8 +356,8 @@ func (m *SSnapshotPolicyDiskManager) SyncByDisk(ctx context.Context, userCred mc
 func (m *SSnapshotPolicyDiskManager) SyncAttachDisk(ctx context.Context, userCred mcclient.TokenCredential,
 	Snapshotpolicies []string, syncOwnerID mcclient.IIdentityProvider, disk *SDisk) error {
 
-	lockman.LockClass(ctx, m, db.GetLockClassKey(m, syncOwnerID))
-	defer lockman.ReleaseClass(ctx, m, db.GetLockClassKey(m, syncOwnerID))
+	lockman.LockRawObject(ctx, "snapshot-policies", disk.Id)
+	defer lockman.ReleaseRawObject(ctx, "snapshot-policies", disk.Id)
 
 	failRecord := make([]string, 0, 1)
 	for _, spId := range Snapshotpolicies {

pkg/compute/models/snapshots.go

@@ -906,11 +906,6 @@ func (manager *SSnapshotManager) newFromCloudSnapshot(ctx context.Context, userC
 	snapshot := SSnapshot{}
 	snapshot.SetModelManager(manager, &snapshot)
 
-	newName, err := db.GenerateName(manager, syncOwnerId, extSnapshot.GetName())
-	if err != nil {
-		return nil, err
-	}
-	snapshot.Name = newName
 	snapshot.Status = extSnapshot.GetStatus()
 	snapshot.ExternalId = extSnapshot.GetGlobalId()
 	var localDisk *SDisk
@@ -932,10 +927,20 @@ func (manager *SSnapshotManager) newFromCloudSnapshot(ctx context.Context, userC
 	snapshot.ManagerId = provider.Id
 	snapshot.CloudregionId = region.Id
 
-	err = manager.TableSpec().Insert(ctx, &snapshot)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, syncOwnerId, extSnapshot.GetName())
+		if err != nil {
+			return err
+		}
+		snapshot.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &snapshot)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudEip fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	// bugfix for now:
@@ -964,8 +969,8 @@ func (manager *SSnapshotManager) getProviderSnapshotsByRegion(region *SCloudregi
 }
 
 func (manager *SSnapshotManager) SyncSnapshots(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, snapshots []cloudprovider.ICloudSnapshot, syncOwnerId mcclient.IIdentityProvider) compare.SyncResult {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, syncOwnerId))
+	lockman.LockRawObject(ctx, "snapshots", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "snapshots", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	syncResult := compare.SyncResult{}
 	dbSnapshots, err := manager.getProviderSnapshotsByRegion(region, provider)

pkg/compute/models/storagecaches.go

@@ -214,8 +214,7 @@ func (manager *SStoragecacheManager) SyncWithCloudStoragecache(ctx context.Conte
 				return localCache, true, nil
 			}
 		} else {
-			log.Errorf("%s", err)
-			return nil, false, err
+			return nil, false, errors.Wrapf(err, "db.FetchByExternalIdAndManagerId(%s)", cloudCache.GetGlobalId())
 		}
 	} else {
 		localCache := localCacheObj.(*SStoragecache)
@@ -228,11 +227,6 @@ func (manager *SStoragecacheManager) newFromCloudStoragecache(ctx context.Contex
 	local := SStoragecache{}
 	local.SetModelManager(manager, &local)
 
-	newName, err := db.GenerateName(manager, userCred, cloudCache.GetName())
-	if err != nil {
-		return nil, err
-	}
-	local.Name = newName
 	local.ExternalId = cloudCache.GetGlobalId()
 
 	local.IsEmulated = cloudCache.IsEmulated()
@@ -240,7 +234,18 @@ func (manager *SStoragecacheManager) newFromCloudStoragecache(ctx context.Contex
 
 	local.Path = cloudCache.GetPath()
 
-	err = manager.TableSpec().Insert(ctx, &local)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, cloudCache.GetName())
+		if err != nil {
+			return err
+		}
+		local.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &local)
+	}()
 	if err != nil {
 		return nil, err
 	}

pkg/compute/models/storages.go

@@ -674,8 +674,8 @@ func (manager *SStorageManager) scanLegacyStorages() error {
 }
 
 func (manager *SStorageManager) SyncStorages(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, zone *SZone, storages []cloudprovider.ICloudStorage) ([]SStorage, []cloudprovider.ICloudStorage, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "storages", fmt.Sprintf("%s-%s", provider.Id, zone.Id))
+	defer lockman.ReleaseRawObject(ctx, "storages", fmt.Sprintf("%s-%s", provider.Id, zone.Id))
 
 	localStorages := make([]SStorage, 0)
 	remoteStorages := make([]cloudprovider.ICloudStorage, 0)
@@ -905,11 +905,6 @@ func (manager *SStorageManager) newFromCloudStorage(ctx context.Context, userCre
 	storage := SStorage{}
 	storage.SetModelManager(manager, &storage)
 
-	newName, err := db.GenerateName(manager, userCred, extStorage.GetName())
-	if err != nil {
-		return nil, err
-	}
-	storage.Name = newName
 	storage.Status = extStorage.GetStatus()
 	storage.ExternalId = extStorage.GetGlobalId()
 	storage.ZoneId = zone.Id
@@ -927,10 +922,20 @@ func (manager *SStorageManager) newFromCloudStorage(ctx context.Context, userCre
 
 	storage.IsSysDiskStore = tristate.NewFromBool(extStorage.IsSysDiskStore())
 
-	err = manager.TableSpec().Insert(ctx, &storage)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, extStorage.GetName())
+		if err != nil {
+			return err
+		}
+		storage.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &storage)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudStorage fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudDomain(userCred, &storage, provider.GetOwnerId())

pkg/compute/models/vpcs.go

@@ -438,8 +438,8 @@ func (self *SVpc) setDefault(def bool) error {
 }
 
 func (manager *SVpcManager) SyncVPCs(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, region *SCloudregion, vpcs []cloudprovider.ICloudVpc) ([]SVpc, []cloudprovider.ICloudVpc, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "vpcs", fmt.Sprintf("%s-%s", provider.Id, region.Id))
+	defer lockman.ReleaseRawObject(ctx, "vpcs", fmt.Sprintf("%s-%s", provider.Id, region.Id))
 
 	localVPCs := make([]SVpc, 0)
 	remoteVPCs := make([]cloudprovider.ICloudVpc, 0)
@@ -568,14 +568,20 @@ func (self *SVpc) SyncGlobalVpc(ctx context.Context, userCred mcclient.TokenCred
 			if idx > 0 {
 				gv.Name = gv.Name[:idx]
 			}
-			gv.Name, err = db.GenerateName(GlobalVpcManager, userCred, gv.Name)
-			if err != nil {
-				return errors.Wrap(err, "db.GenerateName")
-			}
 			gv.SetEnabled(true)
 			gv.Status = api.GLOBAL_VPC_STATUS_AVAILABLE
 			gv.SetModelManager(GlobalVpcManager, gv)
-			err = GlobalVpcManager.TableSpec().Insert(ctx, gv)
+			err = func() error {
+				lockman.LockRawObject(ctx, GlobalVpcManager.Keyword(), "name")
+				defer lockman.ReleaseRawObject(ctx, GlobalVpcManager.Keyword(), "name")
+
+				gv.Name, err = db.GenerateName(ctx, GlobalVpcManager, userCred, gv.Name)
+				if err != nil {
+					return errors.Wrap(err, "db.GenerateName")
+				}
+
+				return GlobalVpcManager.TableSpec().Insert(ctx, gv)
+			}()
 			if err != nil {
 				return errors.Wrap(err, "GlobalVpcManager.Insert")
 			}
@@ -623,11 +629,6 @@ func (manager *SVpcManager) newFromCloudVpc(ctx context.Context, userCred mcclie
 	vpc := SVpc{}
 	vpc.SetModelManager(manager, &vpc)
 
-	newName, err := db.GenerateName(manager, userCred, extVPC.GetName())
-	if err != nil {
-		return nil, err
-	}
-	vpc.Name = newName
 	vpc.Status = extVPC.GetStatus()
 	vpc.ExternalId = extVPC.GetGlobalId()
 	vpc.IsDefault = extVPC.GetIsDefault()
@@ -639,10 +640,20 @@ func (manager *SVpcManager) newFromCloudVpc(ctx context.Context, userCred mcclie
 
 	vpc.IsEmulated = extVPC.IsEmulated()
 
-	err = manager.TableSpec().Insert(ctx, &vpc)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, extVPC.GetName())
+		if err != nil {
+			return err
+		}
+		vpc.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &vpc)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudVpc fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	SyncCloudDomain(userCred, &vpc, provider.GetOwnerId())
@@ -1701,7 +1712,6 @@ func (self *SVpc) SyncVpcPeeringConnections(ctx context.Context, userCred mcclie
 func (self *SVpc) newFromCloudPeerConnection(ctx context.Context, userCred mcclient.TokenCredential, ext cloudprovider.ICloudVpcPeeringConnection, provider *SCloudprovider) (*SVpcPeeringConnection, error) {
 	peer := &SVpcPeeringConnection{}
 	peer.SetModelManager(VpcPeeringConnectionManager, peer)
-	peer.Name, _ = db.GenerateName(VpcPeeringConnectionManager, provider.GetOwnerId(), ext.GetName())
 	peer.ExternalId = ext.GetGlobalId()
 	peer.Status = ext.GetStatus()
 	peer.VpcId = self.Id
@@ -1716,7 +1726,18 @@ func (self *SVpc) newFromCloudPeerConnection(ctx context.Context, userCred mccli
 		peer.PeerVpcId = peerVpc.GetId()
 	}
 	peer.ExtPeerAccountId = ext.GetPeerAccountId()
-	err := VpcPeeringConnectionManager.TableSpec().Insert(ctx, peer)
+	var err = func() error {
+		lockman.LockClass(ctx, VpcPeeringConnectionManager, "name")
+		defer lockman.ReleaseClass(ctx, VpcPeeringConnectionManager, "name")
+
+		var err error
+		peer.Name, err = db.GenerateName(ctx, VpcPeeringConnectionManager, provider.GetOwnerId(), ext.GetName())
+		if err != nil {
+			return errors.Wrapf(err, "db.GenerateName")
+		}
+
+		return VpcPeeringConnectionManager.TableSpec().Insert(ctx, peer)
+	}()
 	if err != nil {
 		return nil, errors.Wrapf(err, "Insert")
 	}

pkg/compute/models/wires.go

@@ -281,8 +281,8 @@ func (manager *SWireManager) getWiresByVpcAndZone(vpc *SVpc, zone *SZone) ([]SWi
 }
 
 func (manager *SWireManager) SyncWires(ctx context.Context, userCred mcclient.TokenCredential, vpc *SVpc, wires []cloudprovider.ICloudWire, provider *SCloudprovider) ([]SWire, []cloudprovider.ICloudWire, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "wires", vpc.Id)
+	defer lockman.ReleaseRawObject(ctx, "wires", vpc.Id)
 
 	localWires := make([]SWire, 0)
 	remoteWires := make([]cloudprovider.ICloudWire, 0)
@@ -423,11 +423,6 @@ func (manager *SWireManager) newFromCloudWire(ctx context.Context, userCred mccl
 	wire := SWire{}
 	wire.SetModelManager(manager, &wire)
 
-	newName, err := db.GenerateName(manager, userCred, extWire.GetName())
-	if err != nil {
-		return nil, err
-	}
-	wire.Name = newName
 	wire.ExternalId = extWire.GetGlobalId()
 	wire.Bandwidth = extWire.GetBandwidth()
 	wire.Status = extWire.GetStatus()
@@ -455,10 +450,20 @@ func (manager *SWireManager) newFromCloudWire(ctx context.Context, userCred mccl
 	wire.PublicScope = vpc.PublicScope
 	wire.PublicSrc = vpc.PublicSrc
 
-	err = manager.TableSpec().Insert(ctx, &wire)
+	err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, extWire.GetName())
+		if err != nil {
+			return err
+		}
+		wire.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &wire)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudWire fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	if provider != nil && !wire.IsEmulated {

pkg/compute/models/zones.go

@@ -191,8 +191,8 @@ func (zone *SZone) GetI18N(ctx context.Context) *jsonutils.JSONDict {
 }
 
 func (manager *SZoneManager) SyncZones(ctx context.Context, userCred mcclient.TokenCredential, region *SCloudregion, zones []cloudprovider.ICloudZone) ([]SZone, []cloudprovider.ICloudZone, compare.SyncResult) {
-	lockman.LockClass(ctx, manager, db.GetLockClassKey(manager, userCred))
-	defer lockman.ReleaseClass(ctx, manager, db.GetLockClassKey(manager, userCred))
+	lockman.LockRawObject(ctx, "zones", region.Id)
+	defer lockman.ReleaseRawObject(ctx, "zones", region.Id)
 
 	localZones := make([]SZone, 0)
 	remoteZones := make([]cloudprovider.ICloudZone, 0)
@@ -294,11 +294,6 @@ func (manager *SZoneManager) newFromCloudZone(ctx context.Context, userCred mccl
 	zone := SZone{}
 	zone.SetModelManager(manager, &zone)
 
-	newName, err := db.GenerateName(manager, userCred, extZone.GetName())
-	if err != nil {
-		return nil, err
-	}
-	zone.Name = newName
 	zone.Status = extZone.GetStatus()
 	zone.ExternalId = extZone.GetGlobalId()
 
@@ -306,10 +301,20 @@ func (manager *SZoneManager) newFromCloudZone(ctx context.Context, userCred mccl
 
 	zone.CloudregionId = region.Id
 
-	err = manager.TableSpec().Insert(ctx, &zone)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, manager, userCred, extZone.GetName())
+		if err != nil {
+			return err
+		}
+		zone.Name = newName
+
+		return manager.TableSpec().Insert(ctx, &zone)
+	}()
 	if err != nil {
-		log.Errorf("newFromCloudZone fail %s", err)
-		return nil, err
+		return nil, errors.Wrapf(err, "Insert")
 	}
 
 	err = manager.SyncI18ns(ctx, userCred, &zone, extZone.GetI18n())

pkg/compute/regiondrivers/kvm.go

@@ -1072,18 +1072,20 @@ func (self *SKVMRegionDriver) RequestCreateInstanceSnapshot(ctx context.Context,
 		return nil
 	}
 
-	lockman.LockClass(ctx, models.SnapshotManager, task.GetUserCred().GetProjectId())
-	defer lockman.ReleaseClass(ctx, models.SnapshotManager, task.GetUserCred().GetProjectId())
+	snapshot, err := func() (*models.SSnapshot, error) {
+		lockman.LockClass(ctx, models.SnapshotManager, "name")
+		defer lockman.ReleaseClass(ctx, models.SnapshotManager, "name")
 
-	snapshotName, err := db.GenerateName(models.SnapshotManager, task.GetUserCred(),
-		fmt.Sprintf("%s-%s", isp.Name, rand.String(8)))
-	if err != nil {
-		return errors.Wrap(err, "Generate snapshot name")
-	}
+		snapshotName, err := db.GenerateName(ctx, models.SnapshotManager, task.GetUserCred(),
+			fmt.Sprintf("%s-%s", isp.Name, rand.String(8)))
+		if err != nil {
+			return nil, errors.Wrap(err, "Generate snapshot name")
+		}
 
-	snapshot, err := models.SnapshotManager.CreateSnapshot(
-		ctx, task.GetUserCred(), api.SNAPSHOT_MANUAL, disks[diskIndex].DiskId,
-		guest.Id, "", snapshotName, -1)
+		return models.SnapshotManager.CreateSnapshot(
+			ctx, task.GetUserCred(), api.SNAPSHOT_MANUAL, disks[diskIndex].DiskId,
+			guest.Id, "", snapshotName, -1)
+	}()
 	if err != nil {
 		return err
 	}

pkg/compute/regiondrivers/managedvirtual.go

@@ -1905,8 +1905,8 @@ func (self *SManagedVirtualizationRegionDriver) RequestSyncElasticcache(ctx cont
 		return errors.Wrap(fmt.Errorf("provider is nil"), "managedVirtualizationRegionDriver.RequestSyncElasticcache.GetCloudprovider")
 	}
 
-	lockman.LockClass(ctx, models.ElasticcacheManager, db.GetLockClassKey(models.ElasticcacheManager, provider.GetOwnerId()))
-	defer lockman.ReleaseClass(ctx, models.ElasticcacheManager, db.GetLockClassKey(models.ElasticcacheManager, provider.GetOwnerId()))
+	lockman.LockRawObject(ctx, "elastic-cache", ec.Id)
+	defer lockman.ReleaseRawObject(ctx, "elastic-cache", ec.Id)
 
 	err = ec.SyncWithCloudElasticcache(ctx, userCred, provider, iec)
 	if err != nil {

pkg/compute/tasks/baremetal_sync_status_task.go

@@ -23,6 +23,7 @@ import (
 
 	api "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/compute/models"
 	"yunion.io/x/onecloud/pkg/util/logclient"
@@ -76,14 +77,20 @@ func (self *BaremetalSyncAllGuestsStatusTask) OnInit(ctx context.Context, obj db
 		bs := baremetal.GetBaremetalstorage().GetStorage()
 		bs.SetStatus(self.UserCred, api.STORAGE_OFFLINE, "")
 		if first && baremetal.Name != guest.Name {
-			db.Update(baremetal, func() error {
-				newName, err := db.GenerateName(baremetal.GetModelManager(), nil, guest.Name)
-				if err != nil {
-					return err
-				}
-				baremetal.Name = newName
-				return nil
-			})
+
+			func() {
+				lockman.LockRawObject(ctx, models.HostManager.Keyword(), "name")
+				defer lockman.ReleaseRawObject(ctx, models.HostManager.Keyword(), "name")
+
+				db.Update(baremetal, func() error {
+					newName, err := db.GenerateName(ctx, baremetal.GetModelManager(), nil, guest.Name)
+					if err != nil {
+						return err
+					}
+					baremetal.Name = newName
+					return nil
+				})
+			}()
 		}
 		if first {
 			db.OpsLog.LogEvent(guest, db.ACT_CONVERT_COMPLETE, "", self.UserCred)

pkg/compute/tasks/guest_batch_create_task.go

@@ -25,6 +25,7 @@ import (
 	schedapi "yunion.io/x/onecloud/pkg/apis/scheduler"
 	"yunion.io/x/onecloud/pkg/cloudcommon/cmdline"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/quotas"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/cloudcommon/notifyclient"
@@ -114,19 +115,24 @@ func (self *GuestBatchCreateTask) allocateGuestOnHost(ctx context.Context, guest
 		}
 		newGenName, err := conditionparser.EvalTemplate(generateName, guestInfo)
 		if err == nil {
-			newName, err := db.GenerateName2(models.GuestManager,
-				guest.GetOwnerId(), newGenName, guest, 1)
-			if err == nil {
-				_, err = db.Update(guest, func() error {
-					guest.Name = newName
-					return nil
-				})
-				if err != nil {
-					log.Errorf("guest update name fail %s", err)
+			func() {
+				lockman.LockRawObject(ctx, models.GuestManager.Keyword(), "name")
+				defer lockman.ReleaseRawObject(ctx, models.GuestManager.Keyword(), "name")
+
+				newName, err := db.GenerateName2(ctx, models.GuestManager,
+					guest.GetOwnerId(), newGenName, guest, 1)
+				if err == nil {
+					_, err = db.Update(guest, func() error {
+						guest.Name = newName
+						return nil
+					})
+					if err != nil {
+						log.Errorf("guest update name fail %s", err)
+					}
+				} else {
+					log.Errorf("db.GenerateName2 fail %s", err)
 				}
-			} else {
-				log.Errorf("db.GenerateName2 fail %s", err)
-			}
+			}()
 		} else {
 			log.Errorf("conditionparser.EvalTemplate fail %s", err)
 		}

pkg/compute/tasks/host_import_libvirt_servers_task.go

@@ -25,6 +25,7 @@ import (
 	"yunion.io/x/onecloud/pkg/apis/compute"
 	api "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/compute/models"
 	"yunion.io/x/onecloud/pkg/util/logclient"
@@ -95,31 +96,36 @@ func (self *HostImportLibvirtServersTask) StartImportServers(
 			originId string         = guestsDesc[i].Id
 		)
 
-		err := self.FillLibvirtGuestDesc(ctx, host, &guestsDesc[i])
-		if err != nil {
-			note = fmt.Sprintf("Guest %s desc fill failed: %s", guestsDesc[i].Id, err)
-			success = false
-		} else {
-			guest, err = models.GuestManager.DoImport(ctx, self.UserCred, &guestsDesc[i])
+		func() {
+			lockman.LockRawObject(ctx, models.GuestManager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, models.GuestManager.Keyword(), "name")
+
+			err := self.FillLibvirtGuestDesc(ctx, host, &guestsDesc[i])
 			if err != nil {
-				note = fmt.Sprintf("Guest %s import failed: %s", guestsDesc[i].Id, err)
+				note = fmt.Sprintf("Guest %s desc fill failed: %s", guestsDesc[i].Id, err)
 				success = false
 			} else {
-				meta := map[string]interface{}{
-					"__is_import":    "true",
-					"__origin_id":    originId,
-					"__monitor_path": guestsDesc[i].MonitorPath,
-				}
-				guest.SetAllMetadata(ctx, meta, self.UserCred)
-				if err := self.CreateImportedLibvirtGuestOnHost(ctx, host, guest, &guestsDesc[i]); err != nil {
-					note = fmt.Sprintf("Guest  %s create on host failed: %s", guestsDesc[i].Id, err)
+				guest, err = models.GuestManager.DoImport(ctx, self.UserCred, &guestsDesc[i])
+				if err != nil {
+					note = fmt.Sprintf("Guest %s import failed: %s", guestsDesc[i].Id, err)
 					success = false
 				} else {
-					note = fmt.Sprintf("Guest %s import success, started create on host", guestsDesc[i].Id)
-					success = true
+					meta := map[string]interface{}{
+						"__is_import":    "true",
+						"__origin_id":    originId,
+						"__monitor_path": guestsDesc[i].MonitorPath,
+					}
+					guest.SetAllMetadata(ctx, meta, self.UserCred)
+					if err := self.CreateImportedLibvirtGuestOnHost(ctx, host, guest, &guestsDesc[i]); err != nil {
+						note = fmt.Sprintf("Guest  %s create on host failed: %s", guestsDesc[i].Id, err)
+						success = false
+					} else {
+						note = fmt.Sprintf("Guest %s import success, started create on host", guestsDesc[i].Id)
+						success = true
+					}
 				}
 			}
-		}
+		}()
 
 		if success {
 			db.OpsLog.LogEvent(host, db.ACT_HOST_IMPORT_LIBVIRT_SERVERS, note, self.UserCred)
@@ -142,7 +148,7 @@ func (self *HostImportLibvirtServersTask) FillLibvirtGuestDesc(
 	// Generate new uuid for guest to prevent duplicate
 	guestDesc.Id = stringutils.UUID4()
 	guestDesc.HostId = host.Id
-	newName, err := db.GenerateName(models.GuestManager, self.UserCred, guestDesc.Name)
+	newName, err := db.GenerateName(ctx, models.GuestManager, self.UserCred, guestDesc.Name)
 	if err != nil {
 		return err
 	}

pkg/image/models/image_guest.go

@@ -419,8 +419,11 @@ func (self *SGuestImage) genUpdateImage(ctx context.Context, userCred mcclient.T
 			return nil, false
 		}
 		return func() error {
+			lockman.LockRawObject(ctx, ImageManager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, ImageManager.Keyword(), "name")
+
 			name, _ := dict.GetString("name")
-			name, err := db.GenerateName(ImageManager, userCred, fmt.Sprintf("%s-%s-%d", name, "data", index))
+			name, err := db.GenerateName(ctx, ImageManager, userCred, fmt.Sprintf("%s-%s-%d", name, "data", index))
 			if err != nil {
 				return errors.Wrap(err, "fail to generate unique name")
 			}
@@ -437,8 +440,11 @@ func (self *SGuestImage) genUpdateImage(ctx context.Context, userCred mcclient.T
 
 	return func() error {
 		if dict.Contains("name") {
+			lockman.LockRawObject(ctx, ImageManager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, ImageManager.Keyword(), "name")
+
 			name, _ := dict.GetString("name")
-			name, err := db.GenerateName(ImageManager, userCred, fmt.Sprintf("%s-%s", name, "root"))
+			name, err := db.GenerateName(ctx, ImageManager, userCred, fmt.Sprintf("%s-%s", name, "root"))
 			if err != nil {
 				return errors.Wrap(err, "fail to generate unique name")
 			}

pkg/keystone/models/identity_provider.go

@@ -986,6 +986,7 @@ func (self *SIdentityProvider) GetSingleDomain(ctx context.Context, extId string
 
 func (self *SIdentityProvider) SyncOrCreateDomain(ctx context.Context, extId string, extName string, extDesc string, createDefaultProject bool) (*SDomain, error) {
 	log.Debugf("SyncOrCreateDomain extId: %s extName: %s", extId, extName)
+
 	domainId, err := IdmappingManager.RegisterIdMap(ctx, self.Id, extId, api.IdMappingEntityDomain)
 	if err != nil {
 		return nil, errors.Wrap(err, "IdmappingManager.RegisterIdMap")
@@ -998,7 +999,7 @@ func (self *SIdentityProvider) SyncOrCreateDomain(ctx context.Context, extId str
 		// find the domain
 		if domain.Name != extName {
 			// sync domain name
-			newName, err := db.GenerateName2(DomainManager, nil, extName, domain, 1)
+			newName, err := db.GenerateName2(ctx, DomainManager, nil, extName, domain, 1)
 			if err != nil {
 				log.Errorf("sync existing domain name (%s=%s) generate fail %s", domain.Name, extName, err)
 			} else {
@@ -1015,22 +1016,26 @@ func (self *SIdentityProvider) SyncOrCreateDomain(ctx context.Context, extId str
 	}
 
 	// otherwise, create the domain
-	lockman.LockClass(ctx, DomainManager, "")
-	defer lockman.ReleaseClass(ctx, DomainManager, "")
-
 	domain = &SDomain{}
 	domain.SetModelManager(DomainManager, domain)
 	domain.Id = domainId
-	newName, err := db.GenerateName(DomainManager, nil, extName)
-	if err != nil {
-		return nil, errors.Wrap(err, "GenerateName")
-	}
-	domain.Name = newName
 	domain.Enabled = tristate.True
 	domain.IsDomain = tristate.True
 	domain.DomainId = api.KeystoneDomainRoot
 	domain.Description = fmt.Sprintf("domain for %s", extDesc)
-	err = DomainManager.TableSpec().Insert(ctx, domain)
+
+	err = func() error {
+		lockman.LockClass(ctx, DomainManager, "name")
+		defer lockman.ReleaseClass(ctx, DomainManager, "name")
+
+		newName, err := db.GenerateName(ctx, DomainManager, nil, extName)
+		if err != nil {
+			return errors.Wrap(err, "GenerateName")
+		}
+		domain.Name = newName
+
+		return DomainManager.TableSpec().Insert(ctx, domain)
+	}()
 	if err != nil {
 		return nil, errors.Wrap(err, "insert")
 	}
@@ -1105,14 +1110,20 @@ func (self *SIdentityProvider) SyncOrCreateUser(ctx context.Context, extId strin
 			user.Enabled = tristate.False
 		}
 		domainOwnerId := &db.SOwnerId{DomainId: domainId}
-		newName, err := db.GenerateName(UserManager, domainOwnerId, extName)
-		if err != nil {
-			return nil, errors.Wrapf(err, "db.GenerateName %s", extName)
-		}
+
 		user.Id = userId
-		user.Name = newName
 		user.DomainId = domainId
-		err = UserManager.TableSpec().Insert(ctx, user)
+		err = func() error {
+			lockman.LockRawObject(ctx, UserManager.Keyword(), "name")
+			defer lockman.ReleaseRawObject(ctx, UserManager.Keyword(), "name")
+
+			user.Name, err = db.GenerateName(ctx, UserManager, domainOwnerId, extName)
+			if err != nil {
+				return errors.Wrapf(err, "db.GenerateName %s", extName)
+			}
+
+			return UserManager.TableSpec().Insert(ctx, user)
+		}()
 		if err != nil {
 			return nil, errors.Wrap(err, "Insert")
 		}

pkg/keystone/models/projects.go

@@ -657,27 +657,30 @@ func (project *SProject) GetUsages() []db.IUsage {
 }
 
 func (manager *SProjectManager) NewProject(ctx context.Context, projectName string, desc string, domainId string) (*SProject, error) {
-	lockman.LockClass(ctx, manager, domainId)
-	defer lockman.ReleaseClass(ctx, manager, domainId)
-
 	project := &SProject{}
 	project.SetModelManager(ProjectManager, project)
 	ownerId := &db.SOwnerId{}
 	if manager.NamespaceScope() == rbacutils.ScopeDomain {
 		ownerId.DomainId = domainId
 	}
-	newName, err := db.GenerateName(ProjectManager, ownerId, projectName)
-	if err != nil {
-		// ignore the error
-		log.Errorf("db.GenerateName error %s for default domain project %s", err, projectName)
-		newName = projectName
-	}
-	project.Name = newName
 	project.DomainId = domainId
 	project.Description = desc
 	project.IsDomain = tristate.False
 	project.ParentId = domainId
-	err = ProjectManager.TableSpec().Insert(ctx, project)
+	var err = func() error {
+		lockman.LockRawObject(ctx, manager.Keyword(), "name")
+		defer lockman.ReleaseRawObject(ctx, manager.Keyword(), "name")
+
+		newName, err := db.GenerateName(ctx, ProjectManager, ownerId, projectName)
+		if err != nil {
+			// ignore the error
+			log.Errorf("db.GenerateName error %s for default domain project %s", err, projectName)
+			newName = projectName
+		}
+		project.Name = newName
+
+		return ProjectManager.TableSpec().Insert(ctx, project)
+	}()
 	if err != nil {
 		return nil, errors.Wrap(err, "Insert")
 	}

pkg/monitor/models/alertdashboard.go

@@ -93,7 +93,7 @@ func (man *SAlertDashBoardManager) ValidateCreateData(
 		return data, httperrors.NewInputParameterError("Invalid refresh format: %s", data.Refresh)
 	}
 
-	generateName, err := db.GenerateName(man, ownerId, data.Name)
+	generateName, err := db.GenerateName(ctx, man, ownerId, data.Name)
 	if err != nil {
 		return data, err
 	}

pkg/monitor/models/alertpannel.go

@@ -117,7 +117,7 @@ func (man *SAlertPanelManager) ValidateCreateData(
 		}
 	}
 
-	name, err := db.GenerateName(man, ownerId, data.Name)
+	name, err := db.GenerateName(ctx, man, ownerId, data.Name)
 	if err != nil {
 		return data, err
 	}

pkg/monitor/models/commonalert.go

@@ -19,6 +19,7 @@ import (
 	"yunion.io/x/onecloud/pkg/apis"
 	"yunion.io/x/onecloud/pkg/apis/monitor"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
+	"yunion.io/x/onecloud/pkg/cloudcommon/db/lockman"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db/taskman"
 	"yunion.io/x/onecloud/pkg/hostman/hostinfo/hostconsts"
 	"yunion.io/x/onecloud/pkg/httperrors"
@@ -157,7 +158,7 @@ func (man *SCommonAlertManager) ValidateCreateData(
 		return data, errors.Wrap(err, "metric query error")
 	}
 
-	name, err := man.genName(ownerId, data.Name)
+	name, err := man.genName(ctx, ownerId, data.Name)
 	if err != nil {
 		return data, err
 	}
@@ -173,9 +174,12 @@ func (man *SCommonAlertManager) ValidateCreateData(
 
 }
 
-func (man *SCommonAlertManager) genName(ownerId mcclient.IIdentityProvider, name string) (string,
+func (man *SCommonAlertManager) genName(ctx context.Context, ownerId mcclient.IIdentityProvider, name string) (string,
 	error) {
-	name, err := db.GenerateName(man, ownerId, name)
+	lockman.LockRawObject(ctx, man.Keyword(), "name")
+	defer lockman.ReleaseRawObject(ctx, man.Keyword(), "name")
+
+	name, err := db.GenerateName(ctx, man, ownerId, name)
 	if err != nil {
 		return "", err
 	}
@@ -793,7 +797,7 @@ func (alert *SCommonAlert) ValidateUpdateData(
 ) (*jsonutils.JSONDict, error) {
 	generateName, _ := data.GetString("generate_name")
 	if len(generateName) != 0 && alert.Name != generateName {
-		name, err := db.GenerateName(CommonAlertManager, userCred, generateName)
+		name, err := db.GenerateName(ctx, CommonAlertManager, userCred, generateName)
 		if err != nil {
 			return data, err
 		}

pkg/monitor/models/meteralert.go

@@ -95,8 +95,8 @@ func (man *SMeterAlertManager) GetDriver(typ string) IMeterAlertDriver {
 	return man.drivers[typ]
 }
 
-func (man *SMeterAlertManager) genName(ownerId mcclient.IIdentityProvider, hint string) (string, error) {
-	return db.GenerateName(man, ownerId, hint)
+func (man *SMeterAlertManager) genName(ctx context.Context, ownerId mcclient.IIdentityProvider, hint string) (string, error) {
+	return db.GenerateName(ctx, man, ownerId, hint)
 }
 
 func (man *SMeterAlertManager) getAllBillAccounts(ctx context.Context) ([]jsonutils.JSONObject, error) {
@@ -146,7 +146,7 @@ func (man *SMeterAlertManager) ValidateCreateData(
 	if drv == nil {
 		return nil, httperrors.NewInputParameterError("not support type %q", data.Type)
 	}
-	name, err := man.genName(ownerId, drv.GetName())
+	name, err := man.genName(ctx, ownerId, drv.GetName())
 	if err != nil {
 		return nil, err
 	}

pkg/monitor/models/nodealert.go

@@ -118,7 +118,7 @@ func (man *SNodeAlertManager) ValidateCreateData(
 		return nil, err
 	}
 	data.NodeName = nodeName
-	name, err := man.genName(ownerId, resType, nodeName, data.Metric)
+	name, err := man.genName(ctx, ownerId, resType, nodeName, data.Metric)
 	if err != nil {
 		return nil, err
 	}
@@ -131,9 +131,9 @@ func (man *SNodeAlertManager) ValidateCreateData(
 	return &data, nil
 }
 
-func (man *SNodeAlertManager) genName(ownerId mcclient.IIdentityProvider, resType string, nodeName string, metric string) (string, error) {
+func (man *SNodeAlertManager) genName(ctx context.Context, ownerId mcclient.IIdentityProvider, resType string, nodeName string, metric string) (string, error) {
 	nameHint := fmt.Sprintf("%s %s %s", resType, nodeName, metric)
-	name, err := db.GenerateName(man, ownerId, nameHint)
+	name, err := db.GenerateName(ctx, man, ownerId, nameHint)
 	if err != nil {
 		return "", err
 	}
@@ -786,7 +786,7 @@ func (alert *SNodeAlert) ValidateUpdateData(
 
 	name := alert.Name
 	if nameChange {
-		name, err = NodeAlertManager.genName(userCred, resType, details.NodeName, details.Metric)
+		name, err = NodeAlertManager.genName(ctx, userCred, resType, details.NodeName, details.Metric)
 		if err != nil {
 			return input, err
 		}

pkg/monitor/models/notification.go

@@ -170,7 +170,8 @@ func (man *SNotificationManager) CreateOneCloudNotification(
 		Channel: channel,
 		UserIds: userIds,
 	}
-	newName, err := db.GenerateName(man, userCred, alertName)
+
+	newName, err := db.GenerateName(ctx, man, userCred, alertName)
 	if err != nil {
 		return nil, errors.Wrapf(err, "generate name: %s", alertName)
 	}

pkg/notify/models/notification.go

@@ -138,7 +138,7 @@ func (nm *SNotificationManager) ValidateCreateData(ctx context.Context, userCred
 		length = len(input.Topic)
 	}
 	name := fmt.Sprintf("%s-%s-%s", input.Topic[:length], input.ContactType, nowStr)
-	input.Name, err = db.GenerateName(nm, ownerId, name)
+	input.Name, err = db.GenerateName(ctx, nm, ownerId, name)
 	if err != nil {
 		return input, errors.Wrapf(err, "unable to generate name for %s", name)
 	}