diff --git a/pkg/compute/models/cloudproviderregions.go b/pkg/compute/models/cloudproviderregions.go index 2b7651aab7..de84ba62c9 100644 --- a/pkg/compute/models/cloudproviderregions.go +++ b/pkg/compute/models/cloudproviderregions.go @@ -349,12 +349,46 @@ func (self *SCloudproviderregion) cancelStartingSync(userCred mcclient.TokenCred return nil } -type SSyncResultSet map[string]*compare.SyncResult +type SyncResult struct { + RequestCost string + rc time.Duration + SqlCost string + sc time.Duration + compare.SyncResult +} + +type SSyncResultSet map[string]*SyncResult + +func (set SSyncResultSet) AddRequestCost(manager db.IModelManager) func() { + start := time.Now() + key := manager.KeywordPlural() + if _, ok := set[key]; !ok { + set[key] = &SyncResult{} + } + res := set[key] + return func() { + res.rc += time.Since(start) + res.RequestCost = res.rc.String() + } +} + +func (set SSyncResultSet) AddSqlCost(manager db.IModelManager) func() { + start := time.Now() + key := manager.KeywordPlural() + if _, ok := set[key]; !ok { + set[key] = &SyncResult{} + } + res := set[key] + return func() { + res.sc += time.Since(start) + res.SqlCost = res.sc.String() + } +} func (set SSyncResultSet) Add(manager db.IModelManager, result compare.SyncResult) { key := manager.KeywordPlural() if _, ok := set[key]; !ok { - set[key] = &compare.SyncResult{} + set[key] = &SyncResult{} } res := set[key] res.AddCnt += result.AddCnt diff --git a/pkg/compute/models/cloudsync.go b/pkg/compute/models/cloudsync.go index e0701bc8ae..c7d4705404 100644 --- a/pkg/compute/models/cloudsync.go +++ b/pkg/compute/models/cloudsync.go @@ -89,13 +89,19 @@ func isInCache(pairs []sStoragecacheSyncPair, localCacheId string) bool { } func syncRegionQuotas(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, driver cloudprovider.ICloudProvider, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - quotas, err := remoteRegion.GetICloudQuotas() + quotas, err := func() ([]cloudprovider.ICloudQuota, error) { + defer syncResults.AddRequestCost(CloudproviderQuotaManager)() + return remoteRegion.GetICloudQuotas() + }() if err != nil { msg := fmt.Sprintf("GetICloudQuotas for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - result := CloudproviderQuotaManager.SyncQuotas(ctx, userCred, provider.GetOwnerId(), provider, localRegion, api.CLOUD_PROVIDER_QUOTA_RANGE_CLOUDREGION, quotas) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(CloudproviderQuotaManager)() + return CloudproviderQuotaManager.SyncQuotas(ctx, userCred, provider.GetOwnerId(), provider, localRegion, api.CLOUD_PROVIDER_QUOTA_RANGE_CLOUDREGION, quotas) + }() syncResults.Add(CloudproviderQuotaManager, result) msg := result.Result() notes := fmt.Sprintf("SyncQuotas for region %s result: %s", localRegion.Name, msg) @@ -107,13 +113,19 @@ func syncRegionQuotas(ctx context.Context, userCred mcclient.TokenCredential, sy } func syncRegionZones(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) ([]SZone, []cloudprovider.ICloudZone, error) { - zones, err := remoteRegion.GetIZones() + zones, err := func() ([]cloudprovider.ICloudZone, error) { + defer syncResults.AddRequestCost(ZoneManager)() + return remoteRegion.GetIZones() + }() if err != nil { msg := fmt.Sprintf("GetZones for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return nil, nil, err } - localZones, remoteZones, result := ZoneManager.SyncZones(ctx, userCred, localRegion, zones) + localZones, remoteZones, result := func() ([]SZone, []cloudprovider.ICloudZone, compare.SyncResult) { + defer syncResults.AddSqlCost(ZoneManager)() + return ZoneManager.SyncZones(ctx, userCred, localRegion, zones) + }() syncResults.Add(ZoneManager, result) msg := result.Result() notes := fmt.Sprintf("SyncZones for region %s result: %s", localRegion.Name, msg) @@ -169,14 +181,20 @@ func syncRegionSkus(ctx context.Context, userCred mcclient.TokenCredential, loca } func syncRegionEips(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - eips, err := remoteRegion.GetIEips() + eips, err := func() ([]cloudprovider.ICloudEIP, error) { + defer syncResults.AddRequestCost(ElasticipManager)() + return remoteRegion.GetIEips() + }() if err != nil { msg := fmt.Sprintf("GetIEips for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - result := ElasticipManager.SyncEips(ctx, userCred, provider, localRegion, eips, provider.GetOwnerId()) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(ElasticipManager)() + return ElasticipManager.SyncEips(ctx, userCred, provider, localRegion, eips, provider.GetOwnerId()) + }() syncResults.Add(ElasticipManager, result) @@ -189,14 +207,20 @@ func syncRegionEips(ctx context.Context, userCred mcclient.TokenCredential, sync } func syncRegionBuckets(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) { - buckets, err := remoteRegion.GetIBuckets() + buckets, err := func() ([]cloudprovider.ICloudBucket, error) { + defer syncResults.AddRequestCost(BucketManager)() + return remoteRegion.GetIBuckets() + }() if err != nil { msg := fmt.Sprintf("GetIBuckets for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - result := BucketManager.syncBuckets(ctx, userCred, provider, localRegion, buckets) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(BucketManager)() + return BucketManager.syncBuckets(ctx, userCred, provider, localRegion, buckets) + }() syncResults.Add(BucketManager, result) @@ -211,14 +235,20 @@ func syncRegionBuckets(ctx context.Context, userCred mcclient.TokenCredential, s } func syncRegionVPCs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - vpcs, err := remoteRegion.GetIVpcs() + vpcs, err := func() ([]cloudprovider.ICloudVpc, error) { + defer syncResults.AddRequestCost(VpcManager)() + return remoteRegion.GetIVpcs() + }() if err != nil { msg := fmt.Sprintf("GetVpcs for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - localVpcs, remoteVpcs, result := VpcManager.SyncVPCs(ctx, userCred, provider, localRegion, vpcs) + localVpcs, remoteVpcs, result := func() ([]SVpc, []cloudprovider.ICloudVpc, compare.SyncResult) { + defer syncResults.AddSqlCost(VpcManager)() + return VpcManager.SyncVPCs(ctx, userCred, provider, localRegion, vpcs) + }() syncResults.Add(VpcManager, result) @@ -252,7 +282,10 @@ func syncRegionVPCs(ctx context.Context, userCred mcclient.TokenCredential, sync } func syncRegionAccessGroups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - accessGroups, err := remoteRegion.GetICloudAccessGroups() + accessGroups, err := func() ([]cloudprovider.ICloudAccessGroup, error) { + defer syncResults.AddRequestCost(AccessGroupManager)() + return remoteRegion.GetICloudAccessGroups() + }() if err != nil { if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported { return @@ -261,13 +294,19 @@ func syncRegionAccessGroups(ctx context.Context, userCred mcclient.TokenCredenti return } - result := localRegion.SyncAccessGroups(ctx, userCred, provider, accessGroups) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(AccessGroupManager)() + return localRegion.SyncAccessGroups(ctx, userCred, provider, accessGroups) + }() syncResults.Add(AccessGroupCacheManager, result) log.Infof("Sync Access Group Caches for region %s result: %s", localRegion.Name, result.Result()) } func syncRegionFileSystems(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - filesystems, err := remoteRegion.GetICloudFileSystems() + filesystems, err := func() ([]cloudprovider.ICloudFileSystem, error) { + defer syncResults.AddRequestCost(FileSystemManager)() + return remoteRegion.GetICloudFileSystems() + }() if err != nil { if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported { return @@ -276,7 +315,10 @@ func syncRegionFileSystems(ctx context.Context, userCred mcclient.TokenCredentia return } - localFSs, removeFSs, result := localRegion.SyncFileSystems(ctx, userCred, provider, filesystems) + localFSs, removeFSs, result := func() ([]SFileSystem, []cloudprovider.ICloudFileSystem, compare.SyncResult) { + defer syncResults.AddSqlCost(FileSystemManager)() + return localRegion.SyncFileSystems(ctx, userCred, provider, filesystems) + }() syncResults.Add(FileSystemManager, result) log.Infof("Sync FileSystem for region %s result: %s", localRegion.Name, result.Result()) @@ -309,7 +351,10 @@ func syncFileSystemMountTargets(ctx context.Context, userCred mcclient.TokenCred } func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) { - peerConnections, err := remoteVpc.GetICloudVpcPeeringConnections() + peerConnections, err := func() ([]cloudprovider.ICloudVpcPeeringConnection, error) { + defer syncResults.AddRequestCost(VpcPeeringConnectionManager)() + return remoteVpc.GetICloudVpcPeeringConnections() + }() if err != nil { if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported { return @@ -318,10 +363,16 @@ func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredenti return } - result := localVpc.SyncVpcPeeringConnections(ctx, userCred, peerConnections) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(VpcPeeringConnectionManager)() + return localVpc.SyncVpcPeeringConnections(ctx, userCred, peerConnections) + }() syncResults.Add(VpcPeeringConnectionManager, result) - accepterPeerings, err := remoteVpc.GetICloudAccepterVpcPeeringConnections() + accepterPeerings, err := func() ([]cloudprovider.ICloudVpcPeeringConnection, error) { + defer syncResults.AddRequestCost(VpcPeeringConnectionManager)() + return remoteVpc.GetICloudAccepterVpcPeeringConnections() + }() if err != nil { if errors.Cause(err) == cloudprovider.ErrNotImplemented || errors.Cause(err) == cloudprovider.ErrNotSupported { return @@ -329,7 +380,10 @@ func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredenti log.Errorf("GetICloudVpcPeeringConnections for vpc %s failed %v", localVpc.Name, err) return } - backSyncResult := localVpc.BackSycVpcPeeringConnectionsVpc(accepterPeerings) + backSyncResult := func() compare.SyncResult { + defer syncResults.AddSqlCost(VpcPeeringConnectionManager)() + return localVpc.BackSycVpcPeeringConnectionsVpc(accepterPeerings) + }() syncResults.Add(VpcPeeringConnectionManager, backSyncResult) log.Infof("SyncVpcPeeringConnections for vpc %s result: %s", localVpc.Name, result.Result()) @@ -339,14 +393,20 @@ func syncVpcPeerConnections(ctx context.Context, userCred mcclient.TokenCredenti } func syncVpcSecGroup(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) { - secgroups, err := remoteVpc.GetISecurityGroups() + secgroups, err := func() ([]cloudprovider.ICloudSecurityGroup, error) { + defer syncResults.AddRequestCost(SecurityGroupManager)() + return remoteVpc.GetISecurityGroups() + }() if err != nil { msg := fmt.Sprintf("GetISecurityGroups for vpc %s failed %s", remoteVpc.GetId(), err) log.Errorf(msg) return } - _, _, result := SecurityGroupCacheManager.SyncSecurityGroupCaches(ctx, userCred, provider, secgroups, localVpc) + _, _, result := func() ([]SSecurityGroup, []cloudprovider.ICloudSecurityGroup, compare.SyncResult) { + defer syncResults.AddSqlCost(SecurityGroupManager)() + return SecurityGroupCacheManager.SyncSecurityGroupCaches(ctx, userCred, provider, secgroups, localVpc) + }() syncResults.Add(SecurityGroupCacheManager, result) msg := result.Result() @@ -358,13 +418,19 @@ func syncVpcSecGroup(ctx context.Context, userCred mcclient.TokenCredential, syn } func syncVpcRouteTables(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) { - routeTables, err := remoteVpc.GetIRouteTables() + routeTables, err := func() ([]cloudprovider.ICloudRouteTable, error) { + defer syncResults.AddRequestCost(RouteTableManager)() + return remoteVpc.GetIRouteTables() + }() if err != nil { msg := fmt.Sprintf("GetIRouteTables for vpc %s failed %s", remoteVpc.GetId(), err) log.Errorf(msg) return } - localRouteTables, remoteRouteTables, result := RouteTableManager.SyncRouteTables(ctx, userCred, localVpc, routeTables, provider) + localRouteTables, remoteRouteTables, result := func() ([]SRouteTable, []cloudprovider.ICloudRouteTable, compare.SyncResult) { + defer syncResults.AddSqlCost(RouteTableManager)() + return RouteTableManager.SyncRouteTables(ctx, userCred, localVpc, routeTables, provider) + }() syncResults.Add(RouteTableManager, result) @@ -389,13 +455,19 @@ func syncVpcRouteTables(ctx context.Context, userCred mcclient.TokenCredential, } func syncVpcNatgateways(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) { - natGateways, err := remoteVpc.GetINatGateways() + natGateways, err := func() ([]cloudprovider.ICloudNatGateway, error) { + defer syncResults.AddRequestCost(NatGatewayManager)() + return remoteVpc.GetINatGateways() + }() if err != nil { msg := fmt.Sprintf("GetINatGateways for vpc %s failed %s", remoteVpc.GetId(), err) log.Errorf(msg) return } - localNatGateways, remoteNatGateways, result := NatGatewayManager.SyncNatGateways(ctx, userCred, provider.GetOwnerId(), provider, localVpc, natGateways) + localNatGateways, remoteNatGateways, result := func() ([]SNatGateway, []cloudprovider.ICloudNatGateway, compare.SyncResult) { + defer syncResults.AddSqlCost(NatGatewayManager)() + return NatGatewayManager.SyncNatGateways(ctx, userCred, provider.GetOwnerId(), provider, localVpc, natGateways) + }() syncResults.Add(NatGatewayManager, result) @@ -471,13 +543,27 @@ func syncNatSTable(ctx context.Context, userCred mcclient.TokenCredential, provi } func syncVpcWires(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localVpc *SVpc, remoteVpc cloudprovider.ICloudVpc, syncRange *SSyncRange) { - wires, err := remoteVpc.GetIWires() + wires, err := func() ([]cloudprovider.ICloudWire, error) { + defer func() { + if syncResults != nil { + syncResults.AddRequestCost(WireManager)() + } + }() + return remoteVpc.GetIWires() + }() if err != nil { msg := fmt.Sprintf("GetIWires for vpc %s failed %s", remoteVpc.GetId(), err) log.Errorf(msg) return } - localWires, remoteWires, result := WireManager.SyncWires(ctx, userCred, localVpc, wires, provider) + localWires, remoteWires, result := func() ([]SWire, []cloudprovider.ICloudWire, compare.SyncResult) { + defer func() { + if syncResults != nil { + syncResults.AddSqlCost(WireManager)() + } + }() + return WireManager.SyncWires(ctx, userCred, localVpc, wires, provider) + }() if syncResults != nil { syncResults.Add(WireManager, result) @@ -505,13 +591,27 @@ func syncVpcWires(ctx context.Context, userCred mcclient.TokenCredential, syncRe } func syncWireNetworks(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localWire *SWire, remoteWire cloudprovider.ICloudWire, syncRange *SSyncRange) { - nets, err := remoteWire.GetINetworks() + nets, err := func() ([]cloudprovider.ICloudNetwork, error) { + defer func() { + if syncResults != nil { + syncResults.AddRequestCost(NetworkManager)() + } + }() + return remoteWire.GetINetworks() + }() if err != nil { msg := fmt.Sprintf("GetINetworks for wire %s failed %s", remoteWire.GetId(), err) log.Errorf(msg) return } - _, _, result := NetworkManager.SyncNetworks(ctx, userCred, localWire, nets, provider) + _, _, result := func() ([]SNetwork, []cloudprovider.ICloudNetwork, compare.SyncResult) { + defer func() { + if syncResults != nil { + syncResults.AddSqlCost(NetworkManager)() + } + }() + return NetworkManager.SyncNetworks(ctx, userCred, localWire, nets, provider) + }() if syncResults != nil { syncResults.Add(NetworkManager, result) @@ -528,13 +628,19 @@ func syncWireNetworks(ctx context.Context, userCred mcclient.TokenCredential, sy } func syncZoneStorages(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localZone *SZone, remoteZone cloudprovider.ICloudZone, syncRange *SSyncRange, storageCachePairs []sStoragecacheSyncPair) []sStoragecacheSyncPair { - storages, err := remoteZone.GetIStorages() + storages, err := func() ([]cloudprovider.ICloudStorage, error) { + defer syncResults.AddRequestCost(StorageManager)() + return remoteZone.GetIStorages() + }() if err != nil { msg := fmt.Sprintf("GetIStorages for zone %s failed %s", remoteZone.GetName(), err) log.Errorf(msg) return nil } - localStorages, remoteStorages, result := StorageManager.SyncStorages(ctx, userCred, provider, localZone, storages) + localStorages, remoteStorages, result := func() ([]SStorage, []cloudprovider.ICloudStorage, compare.SyncResult) { + defer syncResults.AddSqlCost(StorageManager)() + return StorageManager.SyncStorages(ctx, userCred, provider, localZone, storages) + }() syncResults.Add(StorageManager, result) @@ -597,13 +703,19 @@ func syncStorageCaches(ctx context.Context, userCred mcclient.TokenCredential, p } func syncStorageDisks(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localStorage *SStorage, remoteStorage cloudprovider.ICloudStorage, syncRange *SSyncRange) { - disks, err := remoteStorage.GetIDisks() + disks, err := func() ([]cloudprovider.ICloudDisk, error) { + defer syncResults.AddRequestCost(DiskManager)() + return remoteStorage.GetIDisks() + }() if err != nil { msg := fmt.Sprintf("GetIDisks for storage %s failed %s", remoteStorage.GetName(), err) log.Errorf(msg) return } - _, _, result := DiskManager.SyncDisks(ctx, userCred, driver, localStorage, disks, provider.GetOwnerId()) + _, _, result := func() ([]SDisk, []cloudprovider.ICloudDisk, compare.SyncResult) { + defer syncResults.AddSqlCost(DiskManager)() + return DiskManager.SyncDisks(ctx, userCred, driver, localStorage, disks, provider.GetOwnerId()) + }() syncResults.Add(DiskManager, result) @@ -618,13 +730,19 @@ func syncStorageDisks(ctx context.Context, userCred mcclient.TokenCredential, sy } func syncZoneHosts(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localZone *SZone, remoteZone cloudprovider.ICloudZone, syncRange *SSyncRange, storageCachePairs []sStoragecacheSyncPair) []sStoragecacheSyncPair { - hosts, err := remoteZone.GetIHosts() + hosts, err := func() ([]cloudprovider.ICloudHost, error) { + defer syncResults.AddRequestCost(HostManager)() + return remoteZone.GetIHosts() + }() if err != nil { msg := fmt.Sprintf("GetIHosts for zone %s failed %s", remoteZone.GetName(), err) log.Errorf(msg) return nil } - localHosts, remoteHosts, result := HostManager.SyncHosts(ctx, userCred, provider, localZone, hosts) + localHosts, remoteHosts, result := func() ([]SHost, []cloudprovider.ICloudHost, compare.SyncResult) { + defer syncResults.AddSqlCost(HostManager)() + return HostManager.SyncHosts(ctx, userCred, provider, localZone, hosts) + }() syncResults.Add(HostManager, result) @@ -659,15 +777,21 @@ func syncZoneHosts(ctx context.Context, userCred mcclient.TokenCredential, syncR } func syncHostStorages(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localHost *SHost, remoteHost cloudprovider.ICloudHost, storageCachePairs []sStoragecacheSyncPair) []sStoragecacheSyncPair { - storages, err := remoteHost.GetIStorages() + storages, err := func() ([]cloudprovider.ICloudStorage, error) { + defer syncResults.AddRequestCost(HoststorageManager)() + return remoteHost.GetIStorages() + }() if err != nil { msg := fmt.Sprintf("GetIStorages for host %s failed %s", remoteHost.GetName(), err) log.Errorf(msg) return nil } - localStorages, remoteStorages, result := localHost.SyncHostStorages(ctx, userCred, storages, provider) + localStorages, remoteStorages, result := func() ([]SStorage, []cloudprovider.ICloudStorage, compare.SyncResult) { + defer syncResults.AddSqlCost(HoststorageManager)() + return localHost.SyncHostStorages(ctx, userCred, storages, provider) + }() - syncResults.Add(StorageManager, result) + syncResults.Add(HoststorageManager, result) msg := result.Result() notes := fmt.Sprintf("SyncHostStorages for host %s result: %s", localHost.Name, msg) @@ -692,16 +816,30 @@ func syncHostStorages(ctx context.Context, userCred mcclient.TokenCredential, sy } func syncHostWires(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localHost *SHost, remoteHost cloudprovider.ICloudHost) { - wires, err := remoteHost.GetIWires() + wires, err := func() ([]cloudprovider.ICloudWire, error) { + defer func() { + if syncResults != nil { + syncResults.AddRequestCost(HostwireManager)() + } + }() + return remoteHost.GetIWires() + }() if err != nil { msg := fmt.Sprintf("GetIWires for host %s failed %s", remoteHost.GetName(), err) log.Errorf(msg) return } - result := localHost.SyncHostWires(ctx, userCred, wires) + result := func() compare.SyncResult { + defer func() { + if syncResults != nil { + syncResults.AddSqlCost(HostwireManager)() + } + }() + return localHost.SyncHostWires(ctx, userCred, wires) + }() if syncResults != nil { - syncResults.Add(WireManager, result) + syncResults.Add(HostwireManager, result) } msg := result.Result() @@ -715,13 +853,20 @@ func syncHostWires(ctx context.Context, userCred mcclient.TokenCredential, syncR } func syncHostVMs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, driver cloudprovider.ICloudProvider, localHost *SHost, remoteHost cloudprovider.ICloudHost, syncRange *SSyncRange) { - vms, err := remoteHost.GetIVMs() + vms, err := func() ([]cloudprovider.ICloudVM, error) { + defer syncResults.AddRequestCost(GuestManager)() + return remoteHost.GetIVMs() + }() if err != nil { msg := fmt.Sprintf("GetIVMs for host %s failed %s", remoteHost.GetName(), err) log.Errorf(msg) return } - syncVMPairs, result := localHost.SyncHostVMs(ctx, userCred, driver, vms, provider.GetOwnerId()) + + syncVMPairs, result := func() ([]SGuestSyncResult, compare.SyncResult) { + defer syncResults.AddSqlCost(GuestManager)() + return localHost.SyncHostVMs(ctx, userCred, driver, vms, provider.GetOwnerId()) + }() syncResults.Add(GuestManager, result) @@ -747,14 +892,9 @@ func syncHostVMs(ctx context.Context, userCred mcclient.TokenCredential, syncRes } syncVMPeripherals(ctx, userCred, syncVMPairs[i].Local, syncVMPairs[i].Remote, localHost, provider, driver) - // syncMetadata(ctx, userCred, syncVMPairs[i].Local, syncVMPairs[i].Remote) - // syncVMNics(ctx, userCred, provider, localHost, syncVMPairs[i].Local, syncVMPairs[i].Remote) - // syncVMDisks(ctx, userCred, provider, driver, localHost, syncVMPairs[i].Local, syncVMPairs[i].Remote, syncRange) - // syncVMEip(ctx, userCred, provider, syncVMPairs[i].Local, syncVMPairs[i].Remote) - // syncVMSecgroups(ctx, userCred, provider, syncVMPairs[i].Local, syncVMPairs[i].Remote) - }() } + } func syncVMPeripherals(ctx context.Context, userCred mcclient.TokenCredential, local *SGuest, remote cloudprovider.ICloudVM, host *SHost, provider *SCloudprovider, driver cloudprovider.ICloudProvider) { @@ -869,13 +1009,19 @@ func syncSkusFromPrivateCloud(ctx context.Context, userCred mcclient.TokenCreden } func syncRegionDBInstances(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - instances, err := remoteRegion.GetIDBInstances() + instances, err := func() ([]cloudprovider.ICloudDBInstance, error) { + defer syncResults.AddRequestCost(DBInstanceManager)() + return remoteRegion.GetIDBInstances() + }() if err != nil { msg := fmt.Sprintf("GetIDBInstances for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - localInstances, remoteInstances, result := DBInstanceManager.SyncDBInstances(ctx, userCred, provider.GetOwnerId(), provider, localRegion, instances) + localInstances, remoteInstances, result := func() ([]SDBInstance, []cloudprovider.ICloudDBInstance, compare.SyncResult) { + defer syncResults.AddSqlCost(DBInstanceManager)() + return DBInstanceManager.SyncDBInstances(ctx, userCred, provider.GetOwnerId(), provider, localRegion, instances) + }() syncResults.Add(DBInstanceManager, result) DBInstanceManager.SyncDBInstanceMasterId(ctx, userCred, provider, instances) @@ -898,6 +1044,7 @@ func syncRegionDBInstances(ctx context.Context, userCred mcclient.TokenCredentia syncDBInstanceResource(ctx, userCred, syncResults, &localInstances[i], remoteInstances[i]) }() } + } func syncDBInstanceResource(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SDBInstance, remoteInstance cloudprovider.ICloudDBInstance) { @@ -998,12 +1145,19 @@ func syncDBInstanceParameters(ctx context.Context, userCred mcclient.TokenCreden } func syncRegionDBInstanceBackups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) error { - backups, err := remoteRegion.GetIDBInstanceBackups() + backups, err := func() ([]cloudprovider.ICloudDBInstanceBackup, error) { + defer syncResults.AddRequestCost(DBInstanceBackupManager)() + return remoteRegion.GetIDBInstanceBackups() + }() if err != nil { return errors.Wrapf(err, "GetIDBInstanceBackups") } - result := DBInstanceBackupManager.SyncDBInstanceBackups(ctx, userCred, provider, nil, localRegion, backups) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(DBInstanceBackupManager)() + return DBInstanceBackupManager.SyncDBInstanceBackups(ctx, userCred, provider, nil, localRegion, backups) + }() + syncResults.Add(DBInstanceBackupManager, result) msg := result.Result() @@ -1012,7 +1166,6 @@ func syncRegionDBInstanceBackups(ctx context.Context, userCred mcclient.TokenCre return result.AllError() } return nil - } func syncDBInstanceDatabases(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SDBInstance, remoteInstance cloudprovider.ICloudDBInstance) error { @@ -1084,13 +1237,21 @@ func syncDBInstanceAccountPrivileges(ctx context.Context, userCred mcclient.Toke } func syncWafIPSets(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - ipSets, err := remoteRegion.GetICloudWafIPSets() + ipSets, err := func() ([]cloudprovider.ICloudWafIPSet, error) { + defer syncResults.AddRequestCost(WafIPSetManager)() + return remoteRegion.GetICloudWafIPSets() + }() if err != nil { msg := fmt.Sprintf("GetICloudWafIPSets for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - result := localRegion.SyncWafIPSets(ctx, userCred, provider, ipSets) + + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(WafIPSetManager)() + return localRegion.SyncWafIPSets(ctx, userCred, provider, ipSets) + }() + syncResults.Add(WafIPSetManager, result) log.Infof("SyncWafIPSets for region %s result: %s", localRegion.Name, result.Result()) if result.IsError() { @@ -1100,13 +1261,19 @@ func syncWafIPSets(ctx context.Context, userCred mcclient.TokenCredential, syncR } func syncWafRegexSets(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - rSets, err := remoteRegion.GetICloudWafRegexSets() + rSets, err := func() ([]cloudprovider.ICloudWafRegexSet, error) { + defer syncResults.AddRequestCost(WafRegexSetManager)() + return remoteRegion.GetICloudWafRegexSets() + }() if err != nil { msg := fmt.Sprintf("GetICloudWafRegexSets for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - result := localRegion.SyncWafRegexSets(ctx, userCred, provider, rSets) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(WafRegexSetManager)() + return localRegion.SyncWafRegexSets(ctx, userCred, provider, rSets) + }() syncResults.Add(WafRegexSetManager, result) log.Infof("SyncWafRegexSets for region %s result: %s", localRegion.Name, result.Result()) if result.IsError() { @@ -1116,14 +1283,20 @@ func syncWafRegexSets(ctx context.Context, userCred mcclient.TokenCredential, sy } func syncMongoDBs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - dbs, err := remoteRegion.GetICloudMongoDBs() + dbs, err := func() ([]cloudprovider.ICloudMongoDB, error) { + defer syncResults.AddRequestCost(MongoDBManager)() + return remoteRegion.GetICloudMongoDBs() + }() if err != nil { msg := fmt.Sprintf("GetICloudMongoDBs for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - _, _, result := localRegion.SyncMongoDBs(ctx, userCred, provider, dbs) + _, _, result := func() ([]SMongoDB, []cloudprovider.ICloudMongoDB, compare.SyncResult) { + defer syncResults.AddSqlCost(MongoDBManager)() + return localRegion.SyncMongoDBs(ctx, userCred, provider, dbs) + }() syncResults.Add(MongoDBManager, result) msg := result.Result() log.Infof("SyncMongoDBs for region %s result: %s", localRegion.Name, msg) @@ -1135,14 +1308,20 @@ func syncMongoDBs(ctx context.Context, userCred mcclient.TokenCredential, syncRe } func syncElasticSearchs(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - iEss, err := remoteRegion.GetIElasticSearchs() + iEss, err := func() ([]cloudprovider.ICloudElasticSearch, error) { + defer syncResults.AddRequestCost(ElasticSearchManager)() + return remoteRegion.GetIElasticSearchs() + }() if err != nil { msg := fmt.Sprintf("GetIElasticSearchs for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - result := localRegion.SyncElasticSearchs(ctx, userCred, provider, iEss) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(ElasticSearchManager)() + return localRegion.SyncElasticSearchs(ctx, userCred, provider, iEss) + }() syncResults.Add(ElasticSearchManager, result) msg := result.Result() log.Infof("SyncElasticSearchs for region %s result: %s", localRegion.Name, msg) @@ -1153,14 +1332,20 @@ func syncElasticSearchs(ctx context.Context, userCred mcclient.TokenCredential, } func syncKafkas(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - iKafkas, err := remoteRegion.GetICloudKafkas() + iKafkas, err := func() ([]cloudprovider.ICloudKafka, error) { + defer syncResults.AddRequestCost(KafkaManager)() + return remoteRegion.GetICloudKafkas() + }() if err != nil { msg := fmt.Sprintf("GetICloudKafkas for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - result := localRegion.SyncKafkas(ctx, userCred, provider, iKafkas) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(KafkaManager)() + return localRegion.SyncKafkas(ctx, userCred, provider, iKafkas) + }() syncResults.Add(KafkaManager, result) msg := result.Result() log.Infof("SyncKafkas for region %s result: %s", localRegion.Name, msg) @@ -1171,14 +1356,19 @@ func syncKafkas(ctx context.Context, userCred mcclient.TokenCredential, syncResu } func syncApps(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - log.Infof("try to syncApps") - iApps, err := remoteRegion.GetICloudApps() + iApps, err := func() ([]cloudprovider.ICloudApp, error) { + defer syncResults.AddRequestCost(AppManager)() + return remoteRegion.GetICloudApps() + }() if err != nil { msg := fmt.Sprintf("GetICloudApps for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - result := localRegion.SyncApps(ctx, userCred, provider, iApps) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(AppManager)() + return localRegion.SyncApps(ctx, userCred, provider, iApps) + }() syncResults.Add(AppManager, result) msg := result.Result() log.Infof("SyncApps for region %s result: %s", localRegion.Name, msg) @@ -1189,14 +1379,20 @@ func syncApps(ctx context.Context, userCred mcclient.TokenCredential, syncResult } func syncWafInstances(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion) error { - wafIns, err := remoteRegion.GetICloudWafInstances() + wafIns, err := func() ([]cloudprovider.ICloudWafInstance, error) { + defer syncResults.AddRequestCost(WafInstanceManager)() + return remoteRegion.GetICloudWafInstances() + }() if err != nil { msg := fmt.Sprintf("GetICloudWafInstances for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return err } - localWafs, remoteWafs, result := localRegion.SyncWafInstances(ctx, userCred, provider, wafIns) + localWafs, remoteWafs, result := func() ([]SWafInstance, []cloudprovider.ICloudWafInstance, compare.SyncResult) { + defer syncResults.AddSqlCost(WafInstanceManager)() + return localRegion.SyncWafInstances(ctx, userCred, provider, wafIns) + }() syncResults.Add(WafInstanceManager, result) msg := result.Result() log.Infof("SyncWafInstances for region %s result: %s", localRegion.Name, msg) @@ -1225,13 +1421,19 @@ func syncWafInstances(ctx context.Context, userCred mcclient.TokenCredential, sy } func syncWafRules(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localWaf *SWafInstance, remoteWafs cloudprovider.ICloudWafInstance) error { - rules, err := remoteWafs.GetRules() + rules, err := func() ([]cloudprovider.ICloudWafRule, error) { + defer syncResults.AddRequestCost(WafRuleManager)() + return remoteWafs.GetRules() + }() if err != nil { msg := fmt.Sprintf("GetRules for waf instance %s failed %s", localWaf.Name, err) log.Errorf(msg) return err } - result := localWaf.SyncWafRules(ctx, userCred, rules) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(WafRuleManager)() + return localWaf.SyncWafRules(ctx, userCred, rules) + }() syncResults.Add(WafRuleManager, result) msg := result.Result() log.Infof("SyncWafRules for waf %s result: %s", localWaf.Name, msg) @@ -1242,14 +1444,20 @@ func syncWafRules(ctx context.Context, userCred mcclient.TokenCredential, syncRe } func syncRegionSnapshots(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - snapshots, err := remoteRegion.GetISnapshots() + snapshots, err := func() ([]cloudprovider.ICloudSnapshot, error) { + defer syncResults.AddRequestCost(SnapshotManager)() + return remoteRegion.GetISnapshots() + }() if err != nil { msg := fmt.Sprintf("GetISnapshots for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - result := SnapshotManager.SyncSnapshots(ctx, userCred, provider, localRegion, snapshots, provider.GetOwnerId()) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(SnapshotManager)() + return SnapshotManager.SyncSnapshots(ctx, userCred, provider, localRegion, snapshots, provider.GetOwnerId()) + }() syncResults.Add(SnapshotManager, result) @@ -1262,14 +1470,19 @@ func syncRegionSnapshots(ctx context.Context, userCred mcclient.TokenCredential, } func syncRegionSnapshotPolicies(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - snapshotPolicies, err := remoteRegion.GetISnapshotPolicies() + snapshotPolicies, err := func() ([]cloudprovider.ICloudSnapshotPolicy, error) { + defer syncResults.AddRequestCost(SnapshotPolicyManager)() + return remoteRegion.GetISnapshotPolicies() + }() if err != nil { log.Errorf("GetISnapshotPolicies for region %s failed %s", remoteRegion.GetName(), err) return } - result := SnapshotPolicyManager.SyncSnapshotPolicies( - ctx, userCred, provider, localRegion, snapshotPolicies, provider.GetOwnerId()) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(SnapshotPolicyManager)() + return SnapshotPolicyManager.SyncSnapshotPolicies(ctx, userCred, provider, localRegion, snapshotPolicies, provider.GetOwnerId()) + }() syncResults.Add(SnapshotPolicyManager, result) msg := result.Result() log.Infof("SyncSnapshotPolicies for region %s result: %s", localRegion.Name, msg) @@ -1279,14 +1492,20 @@ func syncRegionSnapshotPolicies(ctx context.Context, userCred mcclient.TokenCred } func syncRegionNetworkInterfaces(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - networkInterfaces, err := remoteRegion.GetINetworkInterfaces() + networkInterfaces, err := func() ([]cloudprovider.ICloudNetworkInterface, error) { + defer syncResults.AddRequestCost(NetworkInterfaceManager)() + return remoteRegion.GetINetworkInterfaces() + }() if err != nil { msg := fmt.Sprintf("GetINetworkInterfaces for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - localInterfaces, remoteInterfaces, result := NetworkInterfaceManager.SyncNetworkInterfaces(ctx, userCred, provider, localRegion, networkInterfaces) + localInterfaces, remoteInterfaces, result := func() ([]SNetworkInterface, []cloudprovider.ICloudNetworkInterface, compare.SyncResult) { + defer syncResults.AddSqlCost(NetworkInterfaceManager)() + return NetworkInterfaceManager.SyncNetworkInterfaces(ctx, userCred, provider, localRegion, networkInterfaces) + }() syncResults.Add(NetworkInterfaceManager, result) msg := result.Result() @@ -1443,9 +1662,12 @@ func syncPublicCloudProviderInfo( for i := range storageCachePairs { // always sync private cloud cached images if storageCachePairs[i].isNew || syncRange.DeepSync || !driver.GetFactory().IsPublicCloud() { - result := storageCachePairs[i].syncCloudImages(ctx, userCred) + result := func() compare.SyncResult { + defer syncResults.AddRequestCost(CachedimageManager)() + return storageCachePairs[i].syncCloudImages(ctx, userCred) + }() - syncResults.Add(StoragecachedimageManager, result) + syncResults.Add(CachedimageManager, result) msg := result.Result() log.Infof("syncCloudImages result: %s", msg) @@ -1553,14 +1775,20 @@ func syncOnPremiseCloudProviderInfo( var storageCachePairs []sStoragecacheSyncPair if cloudprovider.IsSupportCompute(driver) { storageCachePairs = syncOnPremiseCloudProviderStorage(ctx, userCred, syncResults, provider, iregion, driver, syncRange) - ihosts, err := iregion.GetIHosts() + ihosts, err := func() ([]cloudprovider.ICloudHost, error) { + defer syncResults.AddRequestCost(HostManager)() + return iregion.GetIHosts() + }() if err != nil { msg := fmt.Sprintf("GetIHosts for provider %s failed %s", provider.GetName(), err) log.Errorf(msg) return err } - localHosts, remoteHosts, result := HostManager.SyncHosts(ctx, userCred, provider, nil, ihosts) + localHosts, remoteHosts, result := func() ([]SHost, []cloudprovider.ICloudHost, compare.SyncResult) { + defer syncResults.AddSqlCost(HostManager)() + return HostManager.SyncHosts(ctx, userCred, provider, nil, ihosts) + }() syncResults.Add(HostManager, result) @@ -1587,8 +1815,12 @@ func syncOnPremiseCloudProviderInfo( for i := range storageCachePairs { // alway sync on-premise cached images // if storageCachePairs[i].isNew || syncRange.DeepSync { - result := storageCachePairs[i].syncCloudImages(ctx, userCred) - syncResults.Add(StoragecachedimageManager, result) + result := func() compare.SyncResult { + defer syncResults.AddRequestCost(CachedimageManager)() + return storageCachePairs[i].syncCloudImages(ctx, userCred) + }() + + syncResults.Add(CachedimageManager, result) msg := result.Result() log.Infof("syncCloudImages for stroagecache %s result: %s", storageCachePairs[i].local.GetId(), msg) // } @@ -1603,20 +1835,27 @@ func syncOnPremiseHostWires(ctx context.Context, userCred mcclient.TokenCredenti if provider.Provider != api.CLOUD_PROVIDER_VMWARE { return } - result := localHost.SyncEsxiHostWires(ctx, userCred, remoteHost) - if syncResults != nil { - syncResults.Add(HostManager, result) - } + func() { + defer func() { + if syncResults != nil { + syncResults.AddSqlCost(HostwireManager)() + } + }() + result := localHost.SyncEsxiHostWires(ctx, userCred, remoteHost) + if syncResults != nil { + syncResults.Add(HostwireManager, result) + } - msg := result.Result() - notes := fmt.Sprintf("SyncEsxiHostWires for host %s result: %s", localHost.Name, msg) - if result.IsError() { - log.Errorf(notes) - return - } else { - log.Infof(notes) - } - db.OpsLog.LogEvent(provider, db.ACT_SYNC_HOST_COMPLETE, msg, userCred) + msg := result.Result() + notes := fmt.Sprintf("SyncEsxiHostWires for host %s result: %s", localHost.Name, msg) + if result.IsError() { + log.Errorf(notes) + return + } else { + log.Infof(notes) + } + db.OpsLog.LogEvent(provider, db.ACT_SYNC_HOST_COMPLETE, msg, userCred) + }() } func syncHostNics(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, localHost *SHost, remoteHost cloudprovider.ICloudHost) { diff --git a/pkg/compute/models/cloudsyncelasticcache.go b/pkg/compute/models/cloudsyncelasticcache.go index a760d61a55..5e70596576 100644 --- a/pkg/compute/models/cloudsyncelasticcache.go +++ b/pkg/compute/models/cloudsyncelasticcache.go @@ -21,6 +21,7 @@ import ( "github.com/pkg/errors" "yunion.io/x/log" + "yunion.io/x/pkg/util/compare" "yunion.io/x/onecloud/pkg/cloudcommon/db" "yunion.io/x/onecloud/pkg/cloudcommon/db/lockman" @@ -29,14 +30,20 @@ import ( ) func syncElasticcaches(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - extCacheDBs, err := remoteRegion.GetIElasticcaches() + extCacheDBs, err := func() ([]cloudprovider.ICloudElasticcache, error) { + defer syncResults.AddRequestCost(ElasticcacheManager)() + return remoteRegion.GetIElasticcaches() + }() if err != nil { msg := fmt.Sprintf("GetIElasticcaches for region %s failed %s", remoteRegion.GetName(), err) log.Errorf(msg) return } - localInstances, remoteInstances, result := ElasticcacheManager.SyncElasticcaches(ctx, userCred, provider.GetOwnerId(), provider, localRegion, extCacheDBs) + localInstances, remoteInstances, result := func() ([]SElasticcache, []cloudprovider.ICloudElasticcache, compare.SyncResult) { + defer syncResults.AddSqlCost(ElasticcacheManager)() + return ElasticcacheManager.SyncElasticcaches(ctx, userCred, provider.GetOwnerId(), provider, localRegion, extCacheDBs) + }() syncResults.Add(ElasticcacheManager, result) @@ -61,43 +68,58 @@ func syncElasticcaches(ctx context.Context, userCred mcclient.TokenCredential, s } func syncElasticcacheParameters(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) { - parameters, err := remoteInstance.GetICloudElasticcacheParameters() + parameters, err := func() ([]cloudprovider.ICloudElasticcacheParameter, error) { + defer syncResults.AddRequestCost(ElasticcacheParameterManager)() + return remoteInstance.GetICloudElasticcacheParameters() + }() if err != nil { msg := fmt.Sprintf("GetIElasticcacheParameters for dbinstance %s failed %s", remoteInstance.GetName(), err) log.Errorf(msg) return } - result := ElasticcacheParameterManager.SyncElasticcacheParameters(ctx, userCred, localInstance, parameters) - syncResults.Add(ElasticcacheParameterManager, result) + func() { + defer syncResults.AddSqlCost(ElasticcacheParameterManager)() + result := ElasticcacheParameterManager.SyncElasticcacheParameters(ctx, userCred, localInstance, parameters) + syncResults.Add(ElasticcacheParameterManager, result) - msg := result.Result() - log.Infof("SyncElasticcacheParameters for dbinstance %s result: %s", localInstance.Name, msg) - if result.IsError() { - return - } + msg := result.Result() + log.Infof("SyncElasticcacheParameters for dbinstance %s result: %s", localInstance.Name, msg) + if result.IsError() { + return + } + }() } func syncElasticcacheAccounts(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) { - accounts, err := remoteInstance.GetICloudElasticcacheAccounts() + accounts, err := func() ([]cloudprovider.ICloudElasticcacheAccount, error) { + defer syncResults.AddRequestCost(ElasticcacheAccountManager)() + return remoteInstance.GetICloudElasticcacheAccounts() + }() if err != nil { msg := fmt.Sprintf("GetIElasticcacheAccounts for dbinstance %s failed %s", remoteInstance.GetName(), err) log.Errorf(msg) return } - result := ElasticcacheAccountManager.SyncElasticcacheAccounts(ctx, userCred, localInstance, accounts) - syncResults.Add(ElasticcacheAccountManager, result) + func() { + defer syncResults.AddSqlCost(ElasticcacheAccountManager)() + result := ElasticcacheAccountManager.SyncElasticcacheAccounts(ctx, userCred, localInstance, accounts) + syncResults.Add(ElasticcacheAccountManager, result) - msg := result.Result() - log.Infof("SyncElasticcacheAccounts for dbinstance %s result: %s", localInstance.Name, msg) - if result.IsError() { - return - } + msg := result.Result() + log.Infof("SyncElasticcacheAccounts for dbinstance %s result: %s", localInstance.Name, msg) + if result.IsError() { + return + } + }() } func syncElasticcacheAcls(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) { - acls, err := remoteInstance.GetICloudElasticcacheAcls() + acls, err := func() ([]cloudprovider.ICloudElasticcacheAcl, error) { + defer syncResults.AddRequestCost(ElasticcacheAclManager)() + return remoteInstance.GetICloudElasticcacheAcls() + }() if err != nil { msg := fmt.Sprintf("GetIElasticcacheAcls for dbinstance %s failed %s", remoteInstance.GetName(), err) if errors.Cause(err) == cloudprovider.ErrNotSupported { @@ -108,36 +130,48 @@ func syncElasticcacheAcls(ctx context.Context, userCred mcclient.TokenCredential return } - result := ElasticcacheAclManager.SyncElasticcacheAcls(ctx, userCred, localInstance, acls) - syncResults.Add(ElasticcacheAclManager, result) + func() { + defer syncResults.AddSqlCost(ElasticcacheAclManager)() + result := ElasticcacheAclManager.SyncElasticcacheAcls(ctx, userCred, localInstance, acls) + syncResults.Add(ElasticcacheAclManager, result) - msg := result.Result() - log.Infof("SyncElasticcacheAcls for dbinstance %s result: %s", localInstance.Name, msg) - if result.IsError() { - return - } + msg := result.Result() + log.Infof("SyncElasticcacheAcls for dbinstance %s result: %s", localInstance.Name, msg) + if result.IsError() { + return + } + }() } func syncElasticcacheBackups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) { - backups, err := remoteInstance.GetICloudElasticcacheBackups() + backups, err := func() ([]cloudprovider.ICloudElasticcacheBackup, error) { + defer syncResults.AddRequestCost(ElasticcacheBackupManager)() + return remoteInstance.GetICloudElasticcacheBackups() + }() if err != nil { msg := fmt.Sprintf("GetIElasticcacheBackups for dbinstance %s failed %s", remoteInstance.GetName(), err) log.Errorf(msg) return } - result := ElasticcacheBackupManager.SyncElasticcacheBackups(ctx, userCred, localInstance, backups) - syncResults.Add(ElasticcacheBackupManager, result) + func() { + defer syncResults.AddSqlCost(ElasticcacheBackupManager)() + result := ElasticcacheBackupManager.SyncElasticcacheBackups(ctx, userCred, localInstance, backups) + syncResults.Add(ElasticcacheBackupManager, result) - msg := result.Result() - log.Infof("SyncElasticcacheBackups for dbinstance %s result: %s", localInstance.Name, msg) - if result.IsError() { - return - } + msg := result.Result() + log.Infof("SyncElasticcacheBackups for dbinstance %s result: %s", localInstance.Name, msg) + if result.IsError() { + return + } + }() } func syncElasticcacheSecgroups(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, localInstance *SElasticcache, remoteInstance cloudprovider.ICloudElasticcache) { - secgroupIds, err := remoteInstance.GetSecurityGroupIds() + secgroupIds, err := func() ([]string, error) { + defer syncResults.AddRequestCost(ElasticcachesecgroupManager)() + return remoteInstance.GetSecurityGroupIds() + }() if err != nil { msg := fmt.Sprintf("Elasticcache.GetSecurityGroupIds for dbinstance %s failed %s", remoteInstance.GetName(), err) if errors.Cause(err) == cloudprovider.ErrNotSupported { @@ -148,12 +182,15 @@ func syncElasticcacheSecgroups(ctx context.Context, userCred mcclient.TokenCrede return } - result := localInstance.SyncElasticcacheSecgroups(ctx, userCred, secgroupIds) - syncResults.Add(ElasticcachesecgroupManager, result) + func() { + defer syncResults.AddSqlCost(ElasticcachesecgroupManager)() + result := localInstance.SyncElasticcacheSecgroups(ctx, userCred, secgroupIds) + syncResults.Add(ElasticcachesecgroupManager, result) - msg := result.Result() - log.Infof("SyncElasticcacheSecgroups for dbinstance %s result: %s", localInstance.Name, msg) - if result.IsError() { - return - } + msg := result.Result() + log.Infof("SyncElasticcacheSecgroups for dbinstance %s result: %s", localInstance.Name, msg) + if result.IsError() { + return + } + }() } diff --git a/pkg/compute/models/cloudsyncelb.go b/pkg/compute/models/cloudsyncelb.go index b4df74da69..250f64b257 100644 --- a/pkg/compute/models/cloudsyncelb.go +++ b/pkg/compute/models/cloudsyncelb.go @@ -19,6 +19,7 @@ import ( "fmt" "yunion.io/x/log" + "yunion.io/x/pkg/util/compare" "yunion.io/x/onecloud/pkg/cloudcommon/db" "yunion.io/x/onecloud/pkg/cloudcommon/db/lockman" @@ -27,13 +28,19 @@ import ( ) func syncRegionLoadbalancerCertificates(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - certificates, err := remoteRegion.GetILoadBalancerCertificates() + certificates, err := func() ([]cloudprovider.ICloudLoadbalancerCertificate, error) { + defer syncResults.AddRequestCost(LoadbalancerCertificateManager)() + return remoteRegion.GetILoadBalancerCertificates() + }() if err != nil { msg := fmt.Sprintf("GetILoadBalancerCertificates for region %s failed %s", remoteRegion.GetName(), err) log.Errorln(msg) return } - result := CachedLoadbalancerCertificateManager.SyncLoadbalancerCertificates(ctx, userCred, provider, localRegion, certificates, syncRange) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(LoadbalancerCertificateManager)() + return CachedLoadbalancerCertificateManager.SyncLoadbalancerCertificates(ctx, userCred, provider, localRegion, certificates, syncRange) + }() syncResults.Add(CachedLoadbalancerCertificateManager, result) @@ -45,13 +52,19 @@ func syncRegionLoadbalancerCertificates(ctx context.Context, userCred mcclient.T } func syncRegionLoadbalancerAcls(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - acls, err := remoteRegion.GetILoadBalancerAcls() + acls, err := func() ([]cloudprovider.ICloudLoadbalancerAcl, error) { + defer syncResults.AddRequestCost(LoadbalancerAclManager)() + return remoteRegion.GetILoadBalancerAcls() + }() if err != nil { msg := fmt.Sprintf("GetILoadBalancerAcls for region %s failed %s", remoteRegion.GetName(), err) log.Errorln(msg) return } - result := CachedLoadbalancerAclManager.SyncLoadbalancerAcls(ctx, userCred, provider, localRegion, acls, syncRange) + result := func() compare.SyncResult { + defer syncResults.AddSqlCost(LoadbalancerAclManager)() + return CachedLoadbalancerAclManager.SyncLoadbalancerAcls(ctx, userCred, provider, localRegion, acls, syncRange) + }() syncResults.Add(CachedLoadbalancerAclManager, result) @@ -63,42 +76,49 @@ func syncRegionLoadbalancerAcls(ctx context.Context, userCred mcclient.TokenCred } func syncRegionLoadbalancers(ctx context.Context, userCred mcclient.TokenCredential, syncResults SSyncResultSet, provider *SCloudprovider, localRegion *SCloudregion, remoteRegion cloudprovider.ICloudRegion, syncRange *SSyncRange) { - lbs, err := remoteRegion.GetILoadBalancers() + lbs, err := func() ([]cloudprovider.ICloudLoadbalancer, error) { + defer syncResults.AddRequestCost(LoadbalancerManager)() + return remoteRegion.GetILoadBalancers() + }() if err != nil { msg := fmt.Sprintf("GetILoadBalancers for region %s failed %s", remoteRegion.GetName(), err) log.Errorln(msg) return } - localLbs, remoteLbs, result := LoadbalancerManager.SyncLoadbalancers(ctx, userCred, provider, localRegion, lbs, syncRange) + func() { + defer syncResults.AddSqlCost(LoadbalancerManager)() - syncResults.Add(LoadbalancerManager, result) + localLbs, remoteLbs, result := LoadbalancerManager.SyncLoadbalancers(ctx, userCred, provider, localRegion, lbs, syncRange) - msg := result.Result() - log.Infof("SyncLoadbalancers for region %s result: %s", localRegion.Name, msg) - if result.IsError() { - return - } - db.OpsLog.LogEvent(provider, db.ACT_SYNC_LB_COMPLETE, msg, userCred) - // 同步未关联负载均衡的后端服务器组 - regionDriver := localRegion.GetDriver() - if regionDriver == nil { - msg := fmt.Sprintf("GetRegionDriver %s failed", localRegion.GetName()) - log.Errorln(msg) - return - } + syncResults.Add(LoadbalancerManager, result) - regionDriver.RequestPullRegionLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, localRegion, remoteRegion, syncRange) + msg := result.Result() + log.Infof("SyncLoadbalancers for region %s result: %s", localRegion.Name, msg) + if result.IsError() { + return + } + db.OpsLog.LogEvent(provider, db.ACT_SYNC_LB_COMPLETE, msg, userCred) + // 同步未关联负载均衡的后端服务器组 + regionDriver := localRegion.GetDriver() + if regionDriver == nil { + msg := fmt.Sprintf("GetRegionDriver %s failed", localRegion.GetName()) + log.Errorln(msg) + return + } - for i := 0; i < len(localLbs); i++ { - func() { - lockman.LockObject(ctx, &localLbs[i]) - defer lockman.ReleaseObject(ctx, &localLbs[i]) + regionDriver.RequestPullRegionLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, localRegion, remoteRegion, syncRange) - syncLoadbalancerEip(ctx, userCred, provider, &localLbs[i], remoteLbs[i]) - regionDriver.RequestPullLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange) - syncLoadbalancerListeners(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange) - }() - } + for i := 0; i < len(localLbs); i++ { + func() { + lockman.LockObject(ctx, &localLbs[i]) + defer lockman.ReleaseObject(ctx, &localLbs[i]) + + syncLoadbalancerEip(ctx, userCred, provider, &localLbs[i], remoteLbs[i]) + regionDriver.RequestPullLoadbalancerBackendGroup(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange) + syncLoadbalancerListeners(ctx, userCred, syncResults, provider, &localLbs[i], remoteLbs[i], syncRange) + }() + } + }() } func syncLoadbalancerEip(ctx context.Context, userCred mcclient.TokenCredential, provider *SCloudprovider, localLb *SLoadbalancer, remoteLb cloudprovider.ICloudLoadbalancer) {