From f9f0c8f3cb08b7e417bb27e5cd3b4aedf56b951c Mon Sep 17 00:00:00 2001 From: ioito Date: Wed, 23 Sep 2020 14:39:59 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E4=BC=98=E5=8C=96=E5=90=8C=E6=AD=A5?= =?UTF-8?q?=EF=BC=8C=E9=81=BF=E5=85=8D=E9=95=BF=E6=97=B6=E9=97=B4=E5=8A=A0?= =?UTF-8?q?=E9=94=81?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pkg/cloudcommon/db/db_dispatcher.go | 5 +- pkg/cloudcommon/db/namevalidator.go | 9 +- pkg/cloudcommon/db/virtualresource.go | 11 ++- pkg/cloudid/models/cloudgroup.go | 21 +++-- pkg/compute/models/access_group_caches.go | 18 ++-- pkg/compute/models/buckets.go | 28 +++--- pkg/compute/models/cachedimages.go | 27 +++--- pkg/compute/models/cloudaccounts.go | 22 ++--- pkg/compute/models/cloudprovider_quotas.go | 8 +- pkg/compute/models/cloudproviders.go | 2 +- pkg/compute/models/cloudregions.go | 22 +++-- pkg/compute/models/dbinstance_accounts.go | 4 +- pkg/compute/models/dbinstance_backups.go | 25 +++--- pkg/compute/models/dbinstance_databases.go | 4 +- pkg/compute/models/dbinstance_parameters.go | 4 +- pkg/compute/models/dbinstance_privileges.go | 4 +- pkg/compute/models/dbinstance_skus.go | 4 +- pkg/compute/models/dbinstances.go | 23 ++--- pkg/compute/models/disks.go | 29 ++++--- pkg/compute/models/dns_trafficpolicy.go | 17 ++-- pkg/compute/models/elasticcache_accounts.go | 4 +- pkg/compute/models/elasticcache_acls.go | 4 +- pkg/compute/models/elasticcache_backups.go | 4 +- pkg/compute/models/elasticcache_instances.go | 23 ++--- pkg/compute/models/elasticcache_parameters.go | 4 +- pkg/compute/models/elasticcache_skus.go | 4 +- pkg/compute/models/elasticips.go | 42 +++++---- pkg/compute/models/external_projects.go | 4 +- pkg/compute/models/filesystem.go | 18 ++-- pkg/compute/models/guest_actions.go | 14 +-- pkg/compute/models/guests.go | 29 ++++--- pkg/compute/models/hosts.go | 43 +++++----- pkg/compute/models/instance_snapshots.go | 20 +++-- .../models/loadbalancerawscachedlbb.go | 43 +++++----- .../models/loadbalancerawscachedlbbg.go | 24 +++--- .../models/loadbalancerbackendgroups.go | 26 +++--- pkg/compute/models/loadbalancerbackends.go | 24 +++--- pkg/compute/models/loadbalancercachedacls.go | 28 +++--- .../models/loadbalancercachedcertificates.go | 31 ++++--- .../models/loadbalancerhuaweicachedlbb.go | 64 ++++++++------ .../models/loadbalancerhuaweicachedlbbg.go | 46 ++++++---- .../models/loadbalancerlistenerrules.go | 24 +++--- pkg/compute/models/loadbalancerlisteners.go | 25 +++--- .../models/loadbalanceropenstackcachedlbb.go | 41 +++++---- .../models/loadbalanceropenstackcachedlbbg.go | 22 +++-- .../models/loadbalancerqcloudcachedlbb.go | 39 +++++---- .../models/loadbalancerqcloudcachedlbbg.go | 22 +++-- pkg/compute/models/loadbalancers.go | 26 +++--- pkg/compute/models/natdtable.go | 22 +++-- pkg/compute/models/natgateways.go | 26 ++++-- pkg/compute/models/natstable.go | 22 +++-- pkg/compute/models/networkinterfacenetwork.go | 4 +- pkg/compute/models/networkinterfaces.go | 26 +++--- pkg/compute/models/networks.go | 85 +++++++++++-------- pkg/compute/models/routetable_routesets.go | 16 ++-- pkg/compute/models/routetables.go | 27 ++++-- pkg/compute/models/secgroupcache.go | 4 +- pkg/compute/models/secgroups.go | 39 +++++---- pkg/compute/models/skus.go | 25 ++++-- pkg/compute/models/snapshotpolicy.go | 26 +++--- pkg/compute/models/snapshotpolicydisks.go | 4 +- pkg/compute/models/snapshots.go | 25 +++--- pkg/compute/models/storagecaches.go | 21 +++-- pkg/compute/models/storages.go | 25 +++--- pkg/compute/models/vpcs.go | 55 ++++++++---- pkg/compute/models/wires.go | 25 +++--- pkg/compute/models/zones.go | 25 +++--- pkg/compute/regiondrivers/kvm.go | 22 ++--- pkg/compute/regiondrivers/managedvirtual.go | 4 +- .../tasks/baremetal_sync_status_task.go | 23 +++-- pkg/compute/tasks/guest_batch_create_task.go | 30 ++++--- .../tasks/host_import_libvirt_servers_task.go | 44 +++++----- pkg/image/models/image_guest.go | 10 ++- pkg/keystone/models/identity_provider.go | 43 ++++++---- pkg/keystone/models/projects.go | 25 +++--- pkg/monitor/models/alertdashboard.go | 2 +- pkg/monitor/models/alertpannel.go | 2 +- pkg/monitor/models/commonalert.go | 12 ++- pkg/monitor/models/meteralert.go | 6 +- pkg/monitor/models/nodealert.go | 8 +- pkg/monitor/models/notification.go | 3 +- pkg/notify/models/notification.go | 2 +- 82 files changed, 1024 insertions(+), 699 deletions(-) diff --git a/pkg/cloudcommon/db/db_dispatcher.go b/pkg/cloudcommon/db/db_dispatcher.go index 494ecc6587..61872e37fe 100644 --- a/pkg/cloudcommon/db/db_dispatcher.go +++ b/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") } diff --git a/pkg/cloudcommon/db/namevalidator.go b/pkg/cloudcommon/db/namevalidator.go index 379c58c1d0..7d71efefb0 100644 --- a/pkg/cloudcommon/db/namevalidator.go +++ b/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 { diff --git a/pkg/cloudcommon/db/virtualresource.go b/pkg/cloudcommon/db/virtualresource.go index 5ab20a028f..a70ce8d67b 100644 --- a/pkg/cloudcommon/db/virtualresource.go +++ b/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 diff --git a/pkg/cloudid/models/cloudgroup.go b/pkg/cloudid/models/cloudgroup.go index 4dbc830b25..417402674d 100644 --- a/pkg/cloudid/models/cloudgroup.go +++ b/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") } diff --git a/pkg/compute/models/access_group_caches.go b/pkg/compute/models/access_group_caches.go index c48852d585..46441cdb85 100644 --- a/pkg/compute/models/access_group_caches.go +++ b/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) { diff --git a/pkg/compute/models/buckets.go b/pkg/compute/models/buckets.go index bc350a8b20..1b9b344ed8 100644 --- a/pkg/compute/models/buckets.go +++ b/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) diff --git a/pkg/compute/models/cachedimages.go b/pkg/compute/models/cachedimages.go index 853d90e783..52573b06bc 100644 --- a/pkg/compute/models/cachedimages.go +++ b/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 } diff --git a/pkg/compute/models/cloudaccounts.go b/pkg/compute/models/cloudaccounts.go index 66078b9ab4..9064701160 100644 --- a/pkg/compute/models/cloudaccounts.go +++ b/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) diff --git a/pkg/compute/models/cloudprovider_quotas.go b/pkg/compute/models/cloudprovider_quotas.go index 3c8bf1e41b..fb14bc2879 100644 --- a/pkg/compute/models/cloudprovider_quotas.go +++ b/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, "a) diff --git a/pkg/compute/models/cloudproviders.go b/pkg/compute/models/cloudproviders.go index eeabe71727..2aad6f56f3 100644 --- a/pkg/compute/models/cloudproviders.go +++ b/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 } diff --git a/pkg/compute/models/cloudregions.go b/pkg/compute/models/cloudregions.go index d0b0eaa3aa..868790004c 100644 --- a/pkg/compute/models/cloudregions.go +++ b/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, ®ion) - 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, ®ion) + 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, ®ion) + }() if err != nil { - log.Errorf("newFromCloudRegion fail %s", err) return nil, err } diff --git a/pkg/compute/models/dbinstance_accounts.go b/pkg/compute/models/dbinstance_accounts.go index 87d27cb4ac..32fffb0d1a 100644 --- a/pkg/compute/models/dbinstance_accounts.go +++ b/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{} diff --git a/pkg/compute/models/dbinstance_backups.go b/pkg/compute/models/dbinstance_backups.go index 80651fb105..5a3709290e 100644 --- a/pkg/compute/models/dbinstance_backups.go +++ b/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") } diff --git a/pkg/compute/models/dbinstance_databases.go b/pkg/compute/models/dbinstance_databases.go index 7c8e551c45..14b2afbb4d 100644 --- a/pkg/compute/models/dbinstance_databases.go +++ b/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() diff --git a/pkg/compute/models/dbinstance_parameters.go b/pkg/compute/models/dbinstance_parameters.go index b660dffddd..55e377dec0 100644 --- a/pkg/compute/models/dbinstance_parameters.go +++ b/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() diff --git a/pkg/compute/models/dbinstance_privileges.go b/pkg/compute/models/dbinstance_privileges.go index 47591509ce..62c5dbebc9 100644 --- a/pkg/compute/models/dbinstance_privileges.go +++ b/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() diff --git a/pkg/compute/models/dbinstance_skus.go b/pkg/compute/models/dbinstance_skus.go index 174c9fbfa7..f7be84919d 100644 --- a/pkg/compute/models/dbinstance_skus.go +++ b/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{} diff --git a/pkg/compute/models/dbinstances.go b/pkg/compute/models/dbinstances.go index e9d446996e..332aedea1c 100644 --- a/pkg/compute/models/dbinstances.go +++ b/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") } diff --git a/pkg/compute/models/disks.go b/pkg/compute/models/disks.go index 4b63b80242..d97724bbc9 100644 --- a/pkg/compute/models/disks.go +++ b/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) diff --git a/pkg/compute/models/dns_trafficpolicy.go b/pkg/compute/models/dns_trafficpolicy.go index 0620db048e..63ba0ae570 100644 --- a/pkg/compute/models/dns_trafficpolicy.go +++ b/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) + }() } diff --git a/pkg/compute/models/elasticcache_accounts.go b/pkg/compute/models/elasticcache_accounts.go index 6353102e32..11f98e4e9a 100644 --- a/pkg/compute/models/elasticcache_accounts.go +++ b/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{} diff --git a/pkg/compute/models/elasticcache_acls.go b/pkg/compute/models/elasticcache_acls.go index 230e955a8a..6dae51132f 100644 --- a/pkg/compute/models/elasticcache_acls.go +++ b/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{} diff --git a/pkg/compute/models/elasticcache_backups.go b/pkg/compute/models/elasticcache_backups.go index 292d4d9c68..07f7d1cb63 100644 --- a/pkg/compute/models/elasticcache_backups.go +++ b/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{} diff --git a/pkg/compute/models/elasticcache_instances.go b/pkg/compute/models/elasticcache_instances.go index 50fc8f1699..2799285158 100644 --- a/pkg/compute/models/elasticcache_instances.go +++ b/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") } diff --git a/pkg/compute/models/elasticcache_parameters.go b/pkg/compute/models/elasticcache_parameters.go index 02e837fd7f..4267e706e5 100644 --- a/pkg/compute/models/elasticcache_parameters.go +++ b/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{} diff --git a/pkg/compute/models/elasticcache_skus.go b/pkg/compute/models/elasticcache_skus.go index bbc6b63055..31e492f8ba 100644 --- a/pkg/compute/models/elasticcache_skus.go +++ b/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{} diff --git a/pkg/compute/models/elasticips.go b/pkg/compute/models/elasticips.go index e282cb1b09..7af765cf98 100644 --- a/pkg/compute/models/elasticips.go +++ b/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") } diff --git a/pkg/compute/models/external_projects.go b/pkg/compute/models/external_projects.go index 8a6e66c7d1..895fe3fd48 100644 --- a/pkg/compute/models/external_projects.go +++ b/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{} diff --git a/pkg/compute/models/filesystem.go b/pkg/compute/models/filesystem.go index 0407a2b0a7..1a779ba949 100644 --- a/pkg/compute/models/filesystem.go +++ b/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 { diff --git a/pkg/compute/models/guest_actions.go b/pkg/compute/models/guest_actions.go index dbeb512f76..d0abe8d10d 100644 --- a/pkg/compute/models/guest_actions.go +++ b/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 } diff --git a/pkg/compute/models/guests.go b/pkg/compute/models/guests.go index eb27a345c6..bdca14aebe 100644 --- a/pkg/compute/models/guests.go +++ b/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) diff --git a/pkg/compute/models/hosts.go b/pkg/compute/models/hosts.go index ee5631b73b..aa9791cb6a 100644 --- a/pkg/compute/models/hosts.go +++ b/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{} diff --git a/pkg/compute/models/instance_snapshots.go b/pkg/compute/models/instance_snapshots.go index 75ec98098a..69ab9f1d1c 100644 --- a/pkg/compute/models/instance_snapshots.go +++ b/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 } diff --git a/pkg/compute/models/loadbalancerawscachedlbb.go b/pkg/compute/models/loadbalancerawscachedlbb.go index b3faccdc0d..c6e04ff1bf 100644 --- a/pkg/compute/models/loadbalancerawscachedlbb.go +++ b/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) diff --git a/pkg/compute/models/loadbalancerawscachedlbbg.go b/pkg/compute/models/loadbalancerawscachedlbbg.go index 196a82bd3b..0d167b5ea3 100644 --- a/pkg/compute/models/loadbalancerawscachedlbbg.go +++ b/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) diff --git a/pkg/compute/models/loadbalancerbackendgroups.go b/pkg/compute/models/loadbalancerbackendgroups.go index 2e74fd3349..5337d67751 100644 --- a/pkg/compute/models/loadbalancerbackendgroups.go +++ b/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) diff --git a/pkg/compute/models/loadbalancerbackends.go b/pkg/compute/models/loadbalancerbackends.go index 488280fd6b..1994f2642f 100644 --- a/pkg/compute/models/loadbalancerbackends.go +++ b/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) diff --git a/pkg/compute/models/loadbalancercachedacls.go b/pkg/compute/models/loadbalancercachedacls.go index 0da4b5a09f..f654b28a4b 100644 --- a/pkg/compute/models/loadbalancercachedacls.go +++ b/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) diff --git a/pkg/compute/models/loadbalancercachedcertificates.go b/pkg/compute/models/loadbalancercachedcertificates.go index 2f5471a78a..eb4fb416a0 100644 --- a/pkg/compute/models/loadbalancercachedcertificates.go +++ b/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{} diff --git a/pkg/compute/models/loadbalancerhuaweicachedlbb.go b/pkg/compute/models/loadbalancerhuaweicachedlbb.go index 7bb32dbee3..106c90d663 100644 --- a/pkg/compute/models/loadbalancerhuaweicachedlbb.go +++ b/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) diff --git a/pkg/compute/models/loadbalancerhuaweicachedlbbg.go b/pkg/compute/models/loadbalancerhuaweicachedlbbg.go index a4ace80a36..80d33a86ad 100644 --- a/pkg/compute/models/loadbalancerhuaweicachedlbbg.go +++ b/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) diff --git a/pkg/compute/models/loadbalancerlistenerrules.go b/pkg/compute/models/loadbalancerlistenerrules.go index c51ea5ad54..008f033c44 100644 --- a/pkg/compute/models/loadbalancerlistenerrules.go +++ b/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) diff --git a/pkg/compute/models/loadbalancerlisteners.go b/pkg/compute/models/loadbalancerlisteners.go index 30d9030fc1..8ca09479c2 100644 --- a/pkg/compute/models/loadbalancerlisteners.go +++ b/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) diff --git a/pkg/compute/models/loadbalanceropenstackcachedlbb.go b/pkg/compute/models/loadbalanceropenstackcachedlbb.go index 60eb98f3cf..658e0eb282 100644 --- a/pkg/compute/models/loadbalanceropenstackcachedlbb.go +++ b/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 } diff --git a/pkg/compute/models/loadbalanceropenstackcachedlbbg.go b/pkg/compute/models/loadbalanceropenstackcachedlbbg.go index 5f2729d9a2..20886ca513 100644 --- a/pkg/compute/models/loadbalanceropenstackcachedlbbg.go +++ b/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 } diff --git a/pkg/compute/models/loadbalancerqcloudcachedlbb.go b/pkg/compute/models/loadbalancerqcloudcachedlbb.go index fa428b9b13..af415caabd 100644 --- a/pkg/compute/models/loadbalancerqcloudcachedlbb.go +++ b/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 } diff --git a/pkg/compute/models/loadbalancerqcloudcachedlbbg.go b/pkg/compute/models/loadbalancerqcloudcachedlbbg.go index 642ebeeaa0..2693f3277c 100644 --- a/pkg/compute/models/loadbalancerqcloudcachedlbbg.go +++ b/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 } diff --git a/pkg/compute/models/loadbalancers.go b/pkg/compute/models/loadbalancers.go index a852ee83a6..11edee5fdd 100644 --- a/pkg/compute/models/loadbalancers.go +++ b/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) diff --git a/pkg/compute/models/natdtable.go b/pkg/compute/models/natdtable.go index 56f8c6d41a..da1d9e0e58 100644 --- a/pkg/compute/models/natdtable.go +++ b/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) diff --git a/pkg/compute/models/natgateways.go b/pkg/compute/models/natgateways.go index 5b243a78b3..25bb589896 100644 --- a/pkg/compute/models/natgateways.go +++ b/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() diff --git a/pkg/compute/models/natstable.go b/pkg/compute/models/natstable.go index ebcaee2ebb..e61a8d6523 100644 --- a/pkg/compute/models/natstable.go +++ b/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) diff --git a/pkg/compute/models/networkinterfacenetwork.go b/pkg/compute/models/networkinterfacenetwork.go index 9dbb97da8e..b7d9471ed9 100644 --- a/pkg/compute/models/networkinterfacenetwork.go +++ b/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{} diff --git a/pkg/compute/models/networkinterfaces.go b/pkg/compute/models/networkinterfaces.go index 1b48de39cc..f85e5788de 100644 --- a/pkg/compute/models/networkinterfaces.go +++ b/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()) diff --git a/pkg/compute/models/networks.go b/pkg/compute/models/networks.go index 2dc8821112..709b9888d8 100644 --- a/pkg/compute/models/networks.go +++ b/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 } diff --git a/pkg/compute/models/routetable_routesets.go b/pkg/compute/models/routetable_routesets.go index f67bfdccbc..16aad71c6f 100644 --- a/pkg/compute/models/routetable_routesets.go +++ b/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 } diff --git a/pkg/compute/models/routetables.go b/pkg/compute/models/routetables.go index 9c4e8870bc..39dd83e213 100644 --- a/pkg/compute/models/routetables.go +++ b/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 } diff --git a/pkg/compute/models/secgroupcache.go b/pkg/compute/models/secgroupcache.go index 103de1f2dd..70148374fe 100644 --- a/pkg/compute/models/secgroupcache.go +++ b/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{} diff --git a/pkg/compute/models/secgroups.go b/pkg/compute/models/secgroups.go index fcd9b67399..fadcc44b28 100644 --- a/pkg/compute/models/secgroups.go +++ b/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") } diff --git a/pkg/compute/models/skus.go b/pkg/compute/models/skus.go index 17cf0b8222..8fe103e740 100644 --- a/pkg/compute/models/skus.go +++ b/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{} diff --git a/pkg/compute/models/snapshotpolicy.go b/pkg/compute/models/snapshotpolicy.go index e90ece2e34..4e3b802eb2 100644 --- a/pkg/compute/models/snapshotpolicy.go +++ b/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()) diff --git a/pkg/compute/models/snapshotpolicydisks.go b/pkg/compute/models/snapshotpolicydisks.go index d5e4c51070..e49eb43387 100644 --- a/pkg/compute/models/snapshotpolicydisks.go +++ b/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 { diff --git a/pkg/compute/models/snapshots.go b/pkg/compute/models/snapshots.go index ddda9b41ea..befae684ce 100644 --- a/pkg/compute/models/snapshots.go +++ b/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) diff --git a/pkg/compute/models/storagecaches.go b/pkg/compute/models/storagecaches.go index 157743f802..26c44deb84 100644 --- a/pkg/compute/models/storagecaches.go +++ b/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 } diff --git a/pkg/compute/models/storages.go b/pkg/compute/models/storages.go index 6077f23faa..80cd39f01f 100644 --- a/pkg/compute/models/storages.go +++ b/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()) diff --git a/pkg/compute/models/vpcs.go b/pkg/compute/models/vpcs.go index a78cf25aef..74d40341c5 100644 --- a/pkg/compute/models/vpcs.go +++ b/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") } diff --git a/pkg/compute/models/wires.go b/pkg/compute/models/wires.go index 525f06b23c..f746176527 100644 --- a/pkg/compute/models/wires.go +++ b/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 { diff --git a/pkg/compute/models/zones.go b/pkg/compute/models/zones.go index e3e36ffbba..bc25274ad4 100644 --- a/pkg/compute/models/zones.go +++ b/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()) diff --git a/pkg/compute/regiondrivers/kvm.go b/pkg/compute/regiondrivers/kvm.go index 75565fa450..4bddca1375 100644 --- a/pkg/compute/regiondrivers/kvm.go +++ b/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 } diff --git a/pkg/compute/regiondrivers/managedvirtual.go b/pkg/compute/regiondrivers/managedvirtual.go index 42523e4c13..1eef2370e2 100644 --- a/pkg/compute/regiondrivers/managedvirtual.go +++ b/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 { diff --git a/pkg/compute/tasks/baremetal_sync_status_task.go b/pkg/compute/tasks/baremetal_sync_status_task.go index 81b72a7e35..ad57b28266 100644 --- a/pkg/compute/tasks/baremetal_sync_status_task.go +++ b/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) diff --git a/pkg/compute/tasks/guest_batch_create_task.go b/pkg/compute/tasks/guest_batch_create_task.go index f4fe1549c6..513bb6f60f 100644 --- a/pkg/compute/tasks/guest_batch_create_task.go +++ b/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) } diff --git a/pkg/compute/tasks/host_import_libvirt_servers_task.go b/pkg/compute/tasks/host_import_libvirt_servers_task.go index dac0a4e548..4ca8950bf0 100644 --- a/pkg/compute/tasks/host_import_libvirt_servers_task.go +++ b/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 } diff --git a/pkg/image/models/image_guest.go b/pkg/image/models/image_guest.go index 9b782ca230..fcfe1aa8ed 100644 --- a/pkg/image/models/image_guest.go +++ b/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") } diff --git a/pkg/keystone/models/identity_provider.go b/pkg/keystone/models/identity_provider.go index e74dc159c4..6585b22f8d 100644 --- a/pkg/keystone/models/identity_provider.go +++ b/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") } diff --git a/pkg/keystone/models/projects.go b/pkg/keystone/models/projects.go index 83316dcc65..8dbf0f0765 100644 --- a/pkg/keystone/models/projects.go +++ b/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") } diff --git a/pkg/monitor/models/alertdashboard.go b/pkg/monitor/models/alertdashboard.go index 8f732dcecb..3a37f46a90 100644 --- a/pkg/monitor/models/alertdashboard.go +++ b/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 } diff --git a/pkg/monitor/models/alertpannel.go b/pkg/monitor/models/alertpannel.go index 21cc5b7fae..336ef661af 100644 --- a/pkg/monitor/models/alertpannel.go +++ b/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 } diff --git a/pkg/monitor/models/commonalert.go b/pkg/monitor/models/commonalert.go index 90c0f9beca..2e73373e8d 100644 --- a/pkg/monitor/models/commonalert.go +++ b/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 } diff --git a/pkg/monitor/models/meteralert.go b/pkg/monitor/models/meteralert.go index c21585d820..3dfd7bf291 100644 --- a/pkg/monitor/models/meteralert.go +++ b/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 } diff --git a/pkg/monitor/models/nodealert.go b/pkg/monitor/models/nodealert.go index 55ae2ae9da..21fe7b5ae2 100644 --- a/pkg/monitor/models/nodealert.go +++ b/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 } diff --git a/pkg/monitor/models/notification.go b/pkg/monitor/models/notification.go index db9cc813b5..5d0e125f0d 100644 --- a/pkg/monitor/models/notification.go +++ b/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) } diff --git a/pkg/notify/models/notification.go b/pkg/notify/models/notification.go index 8e3b8d74dc..8e349b5040 100644 --- a/pkg/notify/models/notification.go +++ b/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) }