From 4f474ad8b215932eec5d0c912764f013e5cee253 Mon Sep 17 00:00:00 2001 From: Qiu Jian Date: Mon, 8 Mar 2021 11:48:13 +0800 Subject: [PATCH] fix(region): network eip stats not correct --- pkg/apis/compute/cloudaccount_const.go | 44 ++++++ pkg/compute/models/cloudproviders.go | 10 +- pkg/compute/models/hosts.go | 2 +- pkg/compute/models/reservedips.go | 4 +- pkg/compute/models/wires.go | 209 +++++++++++++++++++------ pkg/compute/usages/handler.go | 12 +- 6 files changed, 218 insertions(+), 63 deletions(-) diff --git a/pkg/apis/compute/cloudaccount_const.go b/pkg/apis/compute/cloudaccount_const.go index 33cfcb6d20..5723c46e63 100644 --- a/pkg/apis/compute/cloudaccount_const.go +++ b/pkg/apis/compute/cloudaccount_const.go @@ -109,6 +109,50 @@ var ( CLOUD_PROVIDER_GOOGLE, CLOUD_PROVIDER_CTYUN, } + + CLOUD_PROVIDER_HOST_TYPE_MAP = map[string][]string{ + CLOUD_PROVIDER_ONECLOUD: []string{ + HOST_TYPE_KVM, + HOST_TYPE_BAREMETAL, + HOST_TYPE_HYPERVISOR, + }, + CLOUD_PROVIDER_VMWARE: []string{ + HOST_TYPE_ESXI, + }, + CLOUD_PROVIDER_ALIYUN: []string{ + HOST_TYPE_ALIYUN, + }, + CLOUD_PROVIDER_APSARA: []string{ + HOST_TYPE_APSARA, + }, + CLOUD_PROVIDER_QCLOUD: []string{ + HOST_TYPE_QCLOUD, + }, + CLOUD_PROVIDER_AZURE: []string{ + HOST_TYPE_AZURE, + }, + CLOUD_PROVIDER_AWS: []string{ + HOST_TYPE_AWS, + }, + CLOUD_PROVIDER_HUAWEI: []string{ + HOST_TYPE_HUAWEI, + }, + CLOUD_PROVIDER_OPENSTACK: []string{ + HOST_TYPE_OPENSTACK, + }, + CLOUD_PROVIDER_UCLOUD: []string{ + HOST_TYPE_UCLOUD, + }, + CLOUD_PROVIDER_ZSTACK: []string{ + HOST_TYPE_ZSTACK, + }, + CLOUD_PROVIDER_GOOGLE: []string{ + HOST_TYPE_GOOGLE, + }, + CLOUD_PROVIDER_CTYUN: []string{ + HOST_TYPE_CTYUN, + }, + } ) const ( diff --git a/pkg/compute/models/cloudproviders.go b/pkg/compute/models/cloudproviders.go index 743d7d4315..35b37fb762 100644 --- a/pkg/compute/models/cloudproviders.go +++ b/pkg/compute/models/cloudproviders.go @@ -181,11 +181,11 @@ func (manager *SCloudproviderManager) GetProviderFieldQuery(field string, isPubl } else if isOnPremise.IsFalse() { q = q.Filter(sqlchemy.IsFalse(account.Field("is_on_premise"))) } - if len(providers) > 0 { - q = q.Filter(sqlchemy.In(account.Field("provider"), providers)) - } - if len(brands) > 0 { - q = q.Filter(sqlchemy.In(account.Field("brand"), brands)) + if len(providers) > 0 || len(brands) > 0 { + q = q.Filter(sqlchemy.OR( + sqlchemy.In(account.Field("provider"), providers), + sqlchemy.In(account.Field("brand"), brands), + )) } return q.SubQuery() } diff --git a/pkg/compute/models/hosts.go b/pkg/compute/models/hosts.go index 4e9bd1c9c8..313b1b3092 100644 --- a/pkg/compute/models/hosts.go +++ b/pkg/compute/models/hosts.go @@ -2578,7 +2578,7 @@ func (manager *SHostManager) totalCountQ( iq.Field("isolated_reserved_storage"), ) q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, brands, cloudEnv, rangeObjs) - log.Debugf("hostCount: %s", q.String()) + // log.Debugf("hostCount: %s", q.String()) return q } diff --git a/pkg/compute/models/reservedips.go b/pkg/compute/models/reservedips.go index 5e89d5914c..e7a70e5b79 100644 --- a/pkg/compute/models/reservedips.go +++ b/pkg/compute/models/reservedips.go @@ -167,8 +167,8 @@ func (manager *SReservedipManager) GetReservedIP(network *SNetwork, ip string) * func (manager *SReservedipManager) GetReservedIPs(network *SNetwork) []SReservedip { rips := make([]SReservedip, 0) - now := time.Now().UTC() - q := manager.Query().Equals("network_id", network.Id).GT("expired_at", now) + q := manager.Query().Equals("network_id", network.Id) + q = filterExpiredReservedIps(q) err := db.FetchModelObjects(manager, q, &rips) if err != nil { log.Errorf("GetReservedIPs fail: %s", err) diff --git a/pkg/compute/models/wires.go b/pkg/compute/models/wires.go index 151e6c4840..f5c528258c 100644 --- a/pkg/compute/models/wires.go +++ b/pkg/compute/models/wires.go @@ -468,32 +468,57 @@ func (manager *SWireManager) newFromCloudWire(ctx context.Context, userCred mccl return &wire, nil } -func filterByScopeOwnerId(q *sqlchemy.SQuery, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) *sqlchemy.SQuery { +func filterByScopeOwnerId(q *sqlchemy.SQuery, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, domainResource bool) *sqlchemy.SQuery { switch scope { case rbacutils.ScopeSystem: case rbacutils.ScopeDomain: q = q.Equals("domain_id", ownerId.GetProjectDomainId()) case rbacutils.ScopeProject: - q = q.Equals("tenant_id", ownerId.GetProjectId()) + if domainResource { + q = q.Equals("domain_id", ownerId.GetProjectId()) + } else { + q = q.Equals("tenant_id", ownerId.GetProjectId()) + } } return q } +func fixVmwareProvider(providers []string) (bool, []string) { + findVmware := false + findOnecloud := false + newp := make([]string, 0) + for _, p := range providers { + if p == api.CLOUD_PROVIDER_VMWARE { + findVmware = true + } else { + if p == api.CLOUD_PROVIDER_ONECLOUD { + findOnecloud = true + } + newp = append(newp, p) + } + } + if findVmware && !findOnecloud { + newp = append(newp, api.CLOUD_PROVIDER_ONECLOUD) + } + return findVmware, newp +} + func (manager *SWireManager) totalCountQ( rangeObjs []db.IStandaloneModel, - hostTypes []string, + hostTypes []string, hostProviders, hostBrands []string, providers []string, brands []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, ) *sqlchemy.SQuery { - guestsQ := filterByScopeOwnerId(GuestManager.Query(), scope, ownerId) + guestsQ := filterByScopeOwnerId(GuestManager.Query(), scope, ownerId, false) guests := guestsQ.SubQuery() + // hosts no filter, for guest networks hostsQ := HostManager.Query() if len(hostTypes) > 0 { hostsQ = hostsQ.In("host_type", hostTypes) } - if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 { + if len(hostProviders) > 0 || len(hostBrands) > 0 || len(cloudEnv) > 0 { hostsQ = CloudProviderFilter(hostsQ, hostsQ.Field("manager_id"), providers, brands, cloudEnv) } if len(rangeObjs) > 0 { @@ -501,9 +526,23 @@ func (manager *SWireManager) totalCountQ( } hosts := hostsQ.SubQuery() - groups := filterByScopeOwnerId(GroupManager.Query(), scope, ownerId).SubQuery() + // hosts filter by owner, for host networks + hostsQ2 := HostManager.Query() + hostsQ2 = filterByScopeOwnerId(hostsQ2, scope, ownerId, true) + if len(hostTypes) > 0 { + hostsQ2 = hostsQ2.In("host_type", hostTypes) + } + if len(hostProviders) > 0 || len(hostBrands) > 0 || len(cloudEnv) > 0 { + hostsQ2 = CloudProviderFilter(hostsQ2, hostsQ2.Field("manager_id"), providers, brands, cloudEnv) + } + if len(rangeObjs) > 0 { + hostsQ2 = RangeObjectsFilter(hostsQ2, rangeObjs, nil, hostsQ.Field("zone_id"), hostsQ.Field("manager_id"), hostsQ.Field("id"), nil) + } + hosts2 := hostsQ2.SubQuery() - lbsQ := filterByScopeOwnerId(LoadbalancerManager.Query(), scope, ownerId) + groups := filterByScopeOwnerId(GroupManager.Query(), scope, ownerId, false).SubQuery() + + lbsQ := filterByScopeOwnerId(LoadbalancerManager.Query(), scope, ownerId, false) if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 { lbsQ = CloudProviderFilter(lbsQ, lbsQ.Field("manager_id"), providers, brands, cloudEnv) } @@ -512,7 +551,7 @@ func (manager *SWireManager) totalCountQ( } lbs := lbsQ.SubQuery() - dbsQ := filterByScopeOwnerId(DBInstanceManager.Query(), scope, ownerId) + dbsQ := filterByScopeOwnerId(DBInstanceManager.Query(), scope, ownerId, false) if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 { dbsQ = CloudProviderFilter(dbsQ, dbsQ.Field("manager_id"), providers, brands, cloudEnv) } @@ -536,14 +575,8 @@ func (manager *SWireManager) totalCountQ( hNics.Field("network_id"), sqlchemy.COUNT("hnic_count"), ) - hNicQ = hNicQ.Join(hosts, sqlchemy.Equals(hNics.Field("baremetal_id"), hosts.Field("id"))) - hNicQ = hNicQ.Filter(sqlchemy.IsTrue(hosts.Field("enabled"))) - - revIps := ReservedipManager.Query().SubQuery() - revQ := revIps.Query( - revIps.Field("network_id"), - sqlchemy.COUNT("rnic_count"), - ) + hNicQ = hNicQ.Join(hosts2, sqlchemy.Equals(hNics.Field("baremetal_id"), hosts2.Field("id"))) + hNicQ = hNicQ.Filter(sqlchemy.IsTrue(hosts2.Field("enabled"))) groupNics := GroupnetworkManager.Query().SubQuery() grpNicQ := groupNics.Query( @@ -560,7 +593,8 @@ func (manager *SWireManager) totalCountQ( lbNicQ = lbNicQ.Join(lbs, sqlchemy.Equals(lbs.Field("id"), lbNics.Field("loadbalancer_id"))) lbNicQ = lbNicQ.Filter(sqlchemy.IsFalse(lbs.Field("pending_deleted"))) - eipNics := ElasticipManager.Query().IsNotEmpty("network_id").SubQuery() + eipNicsQ := ElasticipManager.Query().IsNotEmpty("network_id") + eipNics := filterByScopeOwnerId(eipNicsQ, scope, ownerId, false).SubQuery() eipNicQ := eipNics.Query( eipNics.Field("network_id"), sqlchemy.COUNT("eipnic_count"), @@ -573,6 +607,7 @@ func (manager *SWireManager) totalCountQ( } netifsQ := NetworkInterfaceManager.Query() + netifsQ = filterByScopeOwnerId(netifsQ, scope, ownerId, true) if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 { netifsQ = CloudProviderFilter(netifsQ, netifsQ.Field("manager_id"), providers, brands, cloudEnv) } @@ -597,67 +632,98 @@ func (manager *SWireManager) totalCountQ( gNicSQ := gNicQ.GroupBy(gNics.Field("network_id")).SubQuery() hNicSQ := hNicQ.GroupBy(hNics.Field("network_id")).SubQuery() - revSQ := revQ.GroupBy(revIps.Field("network_id")).SubQuery() grpNicSQ := grpNicQ.GroupBy(groupNics.Field("network_id")).SubQuery() lbNicSQ := lbNicQ.GroupBy(lbNics.Field("network_id")).SubQuery() eipNicSQ := eipNicQ.GroupBy(eipNics.Field("network_id")).SubQuery() netifNicSQ := netifNicQ.GroupBy(netifNics.Field("network_id")).SubQuery() dbNicSQ := dbNicQ.GroupBy(dbNics.Field("network_id")).SubQuery() - networks := filterByScopeOwnerId(NetworkManager.Query(), scope, ownerId).SubQuery() + networks := NetworkManager.Query().SubQuery() netQ := networks.Query( - networks.Field("wire_id"), - sqlchemy.COUNT("id").Label("net_count"), - sqlchemy.SUM("gnic_count", gNicSQ.Field("gnic_count")), - sqlchemy.SUM("pending_deleted_gnic_count", gNicSQ.Field("pending_deleted_gnic_count")), - sqlchemy.SUM("hnic_count", hNicSQ.Field("hnic_count")), - sqlchemy.SUM("rev_count", revSQ.Field("rnic_count")), - sqlchemy.SUM("grpnic_count", grpNicSQ.Field("grpnic_count")), - sqlchemy.SUM("lbnic_count", lbNicSQ.Field("lbnic_count")), - sqlchemy.SUM("eipnic_count", eipNicSQ.Field("eipnic_count")), - sqlchemy.SUM("netifnic_count", netifNicSQ.Field("netifnic_count")), - sqlchemy.SUM("dbnic_count", dbNicSQ.Field("dbnic_count")), + sqlchemy.SUM("guest_nic_count", gNicSQ.Field("gnic_count")), + sqlchemy.SUM("pending_deleted_guest_nic_count", gNicSQ.Field("pending_deleted_gnic_count")), + sqlchemy.SUM("host_nic_count", hNicSQ.Field("hnic_count")), + sqlchemy.SUM("group_nic_count", grpNicSQ.Field("grpnic_count")), + sqlchemy.SUM("lb_nic_count", lbNicSQ.Field("lbnic_count")), + sqlchemy.SUM("eip_nic_count", eipNicSQ.Field("eipnic_count")), + sqlchemy.SUM("netif_nic_count", netifNicSQ.Field("netifnic_count")), + sqlchemy.SUM("db_nic_count", dbNicSQ.Field("dbnic_count")), ) netQ = netQ.LeftJoin(gNicSQ, sqlchemy.Equals(gNicSQ.Field("network_id"), networks.Field("id"))) netQ = netQ.LeftJoin(hNicSQ, sqlchemy.Equals(hNicSQ.Field("network_id"), networks.Field("id"))) - netQ = netQ.LeftJoin(revSQ, sqlchemy.Equals(revSQ.Field("network_id"), networks.Field("id"))) netQ = netQ.LeftJoin(grpNicSQ, sqlchemy.Equals(grpNicSQ.Field("network_id"), networks.Field("id"))) netQ = netQ.LeftJoin(lbNicSQ, sqlchemy.Equals(lbNicSQ.Field("network_id"), networks.Field("id"))) netQ = netQ.LeftJoin(eipNicSQ, sqlchemy.Equals(eipNicSQ.Field("network_id"), networks.Field("id"))) netQ = netQ.LeftJoin(netifNicSQ, sqlchemy.Equals(netifNicSQ.Field("network_id"), networks.Field("id"))) netQ = netQ.LeftJoin(dbNicSQ, sqlchemy.Equals(dbNicSQ.Field("network_id"), networks.Field("id"))) - netQ = netQ.GroupBy(networks.Field("wire_id")) - netSQ := netQ.SubQuery() + return netQ +} + +func (manager *SWireManager) totalCountQ2( + rangeObjs []db.IStandaloneModel, + hostTypes []string, + providers []string, brands []string, cloudEnv string, + scope rbacutils.TRbacScope, + ownerId mcclient.IIdentityProvider, +) *sqlchemy.SQuery { + revIps := filterExpiredReservedIps(ReservedipManager.Query()).SubQuery() + revQ := revIps.Query( + revIps.Field("network_id"), + sqlchemy.COUNT("rnic_count"), + ) + + revSQ := revQ.GroupBy(revIps.Field("network_id")).SubQuery() + + ownerNetworks := filterByScopeOwnerId(NetworkManager.Query(), scope, ownerId, false).SubQuery() + ownerNetQ := ownerNetworks.Query( + ownerNetworks.Field("wire_id"), + sqlchemy.COUNT("id").Label("net_count"), + sqlchemy.SUM("rev_count", revSQ.Field("rnic_count")), + ) + ownerNetQ = ownerNetQ.LeftJoin(revSQ, sqlchemy.Equals(revSQ.Field("network_id"), ownerNetworks.Field("id"))) + ownerNetQ = ownerNetQ.GroupBy(ownerNetworks.Field("wire_id")) + ownerNetSQ := ownerNetQ.SubQuery() wires := WireManager.Query().SubQuery() + q := wires.Query( + sqlchemy.SUM("net_count", ownerNetSQ.Field("net_count")), + sqlchemy.SUM("reserved_count", ownerNetSQ.Field("rev_count")), + ) + q = q.LeftJoin(ownerNetSQ, sqlchemy.Equals(wires.Field("id"), ownerNetSQ.Field("wire_id"))) + return filterWiresCountQuery(q, hostTypes, providers, brands, cloudEnv, rangeObjs) +} + +func (manager *SWireManager) totalCountQ3( + rangeObjs []db.IStandaloneModel, + hostTypes []string, + providers []string, brands []string, cloudEnv string, + scope rbacutils.TRbacScope, + ownerId mcclient.IIdentityProvider, +) *sqlchemy.SQuery { + wires := filterByScopeOwnerId(WireManager.Query(), scope, ownerId, true).SubQuery() q := wires.Query( sqlchemy.COUNT("id").Label("wires_count"), sqlchemy.SUM("emulated_wires_count", wires.Field("is_emulated")), - sqlchemy.SUM("net_count", netSQ.Field("net_count")), - sqlchemy.SUM("guest_nic_count", netSQ.Field("gnic_count")), - sqlchemy.SUM("pending_deleted_guest_nic_count", netSQ.Field("pending_deleted_gnic_count")), - sqlchemy.SUM("host_nic_count", netSQ.Field("hnic_count")), - sqlchemy.SUM("reserved_count", netSQ.Field("rev_count")), - sqlchemy.SUM("group_nic_count", netSQ.Field("grpnic_count")), - sqlchemy.SUM("lb_nic_count", netSQ.Field("lbnic_count")), - sqlchemy.SUM("eip_nic_count", netSQ.Field("eipnic_count")), - sqlchemy.SUM("netif_nic_count", netSQ.Field("netifnic_count")), - sqlchemy.SUM("db_nic_count", netSQ.Field("dbnic_count")), ) - q = q.LeftJoin(netSQ, sqlchemy.Equals(wires.Field("id"), netSQ.Field("wire_id"))) + return filterWiresCountQuery(q, hostTypes, providers, brands, cloudEnv, rangeObjs) +} +func filterWiresCountQuery(q *sqlchemy.SQuery, hostTypes, providers, brands []string, cloudEnv string, rangeObjs []db.IStandaloneModel) *sqlchemy.SQuery { if len(hostTypes) > 0 { hostwires := HostwireManager.Query().SubQuery() hosts := HostManager.Query().SubQuery() - q = q.Join(hostwires, sqlchemy.Equals(q.Field("id"), hostwires.Field("wire_id"))) - q = q.Join(hosts, sqlchemy.Equals(hostwires.Field("host_id"), hosts.Field("id"))) - q = q.Filter(sqlchemy.In(hosts.Field("host_type"), hostTypes)) + hostWireQ := hostwires.Query(hostwires.Field("wire_id")) + hostWireQ = hostWireQ.Join(hosts, sqlchemy.Equals(hostWireQ.Field("host_id"), hosts.Field("id"))) + hostWireQ = hostWireQ.Filter(sqlchemy.In(hosts.Field("host_type"), hostTypes)) + hostWireQ = hostWireQ.GroupBy(hostwires.Field("wire_id")) + hostWireSQ := hostWireQ.SubQuery() + + q = q.Join(hostWireSQ, sqlchemy.Equals(hostWireSQ.Field("wire_id"), q.Field("id"))) } if len(rangeObjs) > 0 || len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 { vpcs := VpcManager.Query().SubQuery() - q = q.Join(vpcs, sqlchemy.Equals(q.Field("vpc_id"), vpcs.Field("id"))) q = CloudProviderFilter(q, vpcs.Field("manager_id"), providers, brands, cloudEnv) q = RangeObjectsFilter(q, rangeObjs, vpcs.Field("cloudregion_id"), q.Field("zone_id"), vpcs.Field("manager_id"), nil, nil) @@ -693,15 +759,60 @@ func (manager *SWireManager) TotalCount( scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, ) WiresCountStat { + vmwareP, hostProviders := fixVmwareProvider(providers) + vmwareB, hostBrands := fixVmwareProvider(brands) + + if vmwareP || vmwareB { + if !utils.IsInStringArray(api.HOST_TYPE_ESXI, hostTypes) { + hostTypes = append(hostTypes, api.HOST_TYPE_ESXI) + } + } else { + if utils.IsInStringArray(api.HOST_TYPE_ESXI, hostTypes) { + providers = append(providers, api.CLOUD_PROVIDER_VMWARE) + brands = append(brands, api.CLOUD_PROVIDER_VMWARE) + } + } + if len(hostTypes) > 0 { + for _, p := range providers { + if hs, ok := api.CLOUD_PROVIDER_HOST_TYPE_MAP[p]; ok { + hostTypes = append(hostTypes, hs...) + } + } + for _, p := range brands { + if hs, ok := api.CLOUD_PROVIDER_HOST_TYPE_MAP[p]; ok { + hostTypes = append(hostTypes, hs...) + } + } + } + log.Debugf("providers: %#v hostProviders: %#v brands: %#v hostBrands: %#v hostTypes: %#v", providers, hostProviders, brands, hostBrands, hostTypes) + stat := WiresCountStat{} err := manager.totalCountQ( + rangeObjs, + hostTypes, hostProviders, hostBrands, + providers, brands, cloudEnv, + scope, ownerId, + ).First(&stat) + if err != nil { + log.Errorf("Wire total count: %v", err) + } + err = manager.totalCountQ2( rangeObjs, hostTypes, providers, brands, cloudEnv, scope, ownerId, ).First(&stat) if err != nil { - log.Errorf("Wire total count: %v", err) + log.Errorf("Wire total count 2: %v", err) + } + err = manager.totalCountQ3( + rangeObjs, + hostTypes, + providers, brands, cloudEnv, + scope, ownerId, + ).First(&stat) + if err != nil { + log.Errorf("Wire total count 2: %v", err) } return stat } diff --git a/pkg/compute/usages/handler.go b/pkg/compute/usages/handler.go index ba4fc64c33..de42686b70 100644 --- a/pkg/compute/usages/handler.go +++ b/pkg/compute/usages/handler.go @@ -377,7 +377,7 @@ func getDomainGeneralUsage(scope rbacutils.TRbacScope, cred mcclient.IIdentityPr BucketUsage(scope, cred, rangeObjs, providers, brands, cloudEnv), - nicsUsage("domain", rangeObjs, hostTypes, providers, brands, cloudEnv, scope, cred), + // nicsUsage("domain", rangeObjs, hostTypes, providers, brands, cloudEnv, scope, cred), SnapshotUsage(scope, cred, rangeObjs, providers, brands, cloudEnv), @@ -422,7 +422,7 @@ func getProjectGeneralUsage(scope rbacutils.TRbacScope, cred mcclient.IIdentityP DisksUsage(getKey(scope, "pending_delete_disks"), rangeObjs, hostTypes, nil, providers, brands, cloudEnv, scope, cred, true, false), DisksUsage(getKey(scope, "pending_delete_disks.system"), rangeObjs, hostTypes, nil, providers, brands, cloudEnv, scope, cred, true, true), - nicsUsage("", rangeObjs, hostTypes, providers, brands, cloudEnv, scope, cred), + // nicsUsage("", rangeObjs, hostTypes, providers, brands, cloudEnv, scope, cred), SnapshotUsage(scope, cred, rangeObjs, providers, brands, cloudEnv), @@ -458,14 +458,14 @@ func ReportGeneralUsage( } } - if scope.HigherEqual(rbacutils.ScopeDomain) { + if scope.HigherEqual(rbacutils.ScopeDomain) && len(userCred.GetProjectDomainId()) > 0 { commonUsage, err := getDomainGeneralUsage(rbacutils.ScopeDomain, userCred, rangeObjs, hostTypes, providers, brands, cloudEnv) if err == nil { count.Include(commonUsage) } } - if scope.HigherEqual(rbacutils.ScopeProject) { + if scope.HigherEqual(rbacutils.ScopeProject) && len(userCred.GetProjectId()) > 0 { commonUsage, err := getProjectGeneralUsage(rbacutils.ScopeProject, userCred, rangeObjs, hostTypes, providers, brands, cloudEnv) if err == nil { count.Include(commonUsage) @@ -646,7 +646,7 @@ func WireUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, return count } -func nicsUsage(prefix string, rangeObjs []db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) Usage { +/*func nicsUsage(prefix string, rangeObjs []db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) Usage { count := make(map[string]interface{}) result := models.WireManager.TotalCount(rangeObjs, hostTypes, providers, brands, cloudEnv, scope, ownerId) // including nics for pending_deleted guests @@ -659,7 +659,7 @@ func nicsUsage(prefix string, rangeObjs []db.IStandaloneModel, hostTypes []strin count[prefixKey(prefix, "nics.eip")] = result.EipNicCount count[prefixKey(prefix, "nics")] = result.GuestNicCount + result.GroupNicCount + result.LbNicCount + result.DbNicCount + result.EipNicCount return count -} +}*/ func prefixKey(prefix string, key string) string { if len(prefix) > 0 {