fix: usage query support brands

pkg/compute/models/cloudproviders.go

@@ -127,18 +127,18 @@ func (self *SCloudprovider) ValidateDeleteCondition(ctx context.Context) error {
 }
 
 func (manager *SCloudproviderManager) GetPublicProviderIdsQuery() *sqlchemy.SSubQuery {
-	return manager.GetProviderIdsQuery(tristate.True, tristate.None)
+	return manager.GetProviderIdsQuery(tristate.True, tristate.None, nil, nil)
 }
 
 func (manager *SCloudproviderManager) GetPrivateProviderIdsQuery() *sqlchemy.SSubQuery {
-	return manager.GetProviderIdsQuery(tristate.False, tristate.False)
+	return manager.GetProviderIdsQuery(tristate.False, tristate.False, nil, nil)
 }
 
 func (manager *SCloudproviderManager) GetOnPremiseProviderIdsQuery() *sqlchemy.SSubQuery {
-	return manager.GetProviderIdsQuery(tristate.None, tristate.True)
+	return manager.GetProviderIdsQuery(tristate.None, tristate.True, nil, nil)
 }
 
-func (manager *SCloudproviderManager) GetProviderIdsQuery(isPublic tristate.TriState, isOnPremise tristate.TriState) *sqlchemy.SSubQuery {
+func (manager *SCloudproviderManager) GetProviderIdsQuery(isPublic tristate.TriState, isOnPremise tristate.TriState, providers []string, brands []string) *sqlchemy.SSubQuery {
 	q := manager.Query("id")
 	account := CloudaccountManager.Query().SubQuery()
 	q = q.Join(account, sqlchemy.Equals(
@@ -154,9 +154,51 @@ func (manager *SCloudproviderManager) GetProviderIdsQuery(isPublic tristate.TriS
 	} 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))
+	}
 	return q.SubQuery()
 }
 
+func CloudProviderFilter(q *sqlchemy.SQuery, managerIdField sqlchemy.IQueryField, providers []string, brands []string, cloudEnv string) *sqlchemy.SQuery {
+	if len(cloudEnv) == 0 && len(providers) == 0 && len(brands) == 0 {
+		return q
+	}
+	isPublic := tristate.None
+	isOnPremise := tristate.None
+	includeOneCloud := false
+	switch cloudEnv {
+	case api.CLOUD_ENV_PUBLIC_CLOUD:
+		isPublic = tristate.True
+	case api.CLOUD_ENV_PRIVATE_CLOUD:
+		isPublic = tristate.False
+		isOnPremise = tristate.False
+	case api.CLOUD_ENV_ON_PREMISE:
+		isOnPremise = tristate.True
+		includeOneCloud = true
+	default:
+		includeOneCloud = true
+	}
+	if includeOneCloud && len(providers) > 0 && !utils.IsInStringArray(api.CLOUD_PROVIDER_ONECLOUD, providers) {
+		includeOneCloud = false
+	}
+	if includeOneCloud && len(brands) > 0 && !utils.IsInStringArray(api.CLOUD_PROVIDER_ONECLOUD, brands) {
+		includeOneCloud = false
+	}
+	subq := CloudproviderManager.GetProviderIdsQuery(isPublic, isOnPremise, providers, brands)
+	if includeOneCloud {
+		return q.Filter(sqlchemy.OR(
+			sqlchemy.In(managerIdField, subq),
+			sqlchemy.IsNullOrEmpty(managerIdField),
+		))
+	} else {
+		return q.Filter(sqlchemy.In(managerIdField, subq))
+	}
+}
+
 func (self *SCloudprovider) CleanSchedCache() {
 	hosts := []SHost{}
 	q := HostManager.Query().Equals("manager_id", self.Id)

pkg/compute/models/elasticips.go

@@ -1075,35 +1075,8 @@ func (u EipUsage) Total() int {
 	return u.PublicIPCount + u.EIPCount
 }
 
-func (manager *SElasticipManager) usageQByProvider(q *sqlchemy.SQuery, providers []string) *sqlchemy.SQuery {
-	if len(providers) == 0 {
-		return q
-	}
-	cloudproviders := CloudproviderManager.Query().SubQuery()
-	subq := cloudproviders.Query(cloudproviders.Field("id")).In("provider", providers).SubQuery()
-	q = q.Filter(sqlchemy.In(q.Field("manager_id"), subq))
-	return q
-}
-
-func (manager *SElasticipManager) usageQByCloudEnv(q *sqlchemy.SQuery, cloudEnv string) *sqlchemy.SQuery {
-	if len(cloudEnv) == 0 {
-		return q
-	}
-
-	switch cloudEnv {
-	case api.CLOUD_ENV_PUBLIC_CLOUD:
-		q = q.Filter(sqlchemy.In(q.Field("manager_id"), CloudproviderManager.GetPublicProviderIdsQuery()))
-	case api.CLOUD_ENV_PRIVATE_CLOUD:
-		q = q.Filter(sqlchemy.In(q.Field("manager_id"), CloudproviderManager.GetPrivateProviderIdsQuery()))
-	case api.CLOUD_ENV_ON_PREMISE:
-		q = q.Filter(
-			sqlchemy.OR(
-				sqlchemy.In(q.Field("manager_id"), CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-				sqlchemy.IsNullOrEmpty(q.Field("manager_id")),
-			),
-		)
-	}
-	return q
+func (manager *SElasticipManager) usageQByCloudEnv(q *sqlchemy.SQuery, providers []string, brands []string, cloudEnv string) *sqlchemy.SQuery {
+	return CloudProviderFilter(q, q.Field("manager_id"), providers, brands, cloudEnv)
 }
 
 func (manager *SElasticipManager) usageQByRange(q *sqlchemy.SQuery, rangeObj db.IStandaloneModel) *sqlchemy.SQuery {
@@ -1138,21 +1111,20 @@ func (manager *SElasticipManager) usageQByRange(q *sqlchemy.SQuery, rangeObj db.
 	return q
 }
 
-func (manager *SElasticipManager) usageQ(q *sqlchemy.SQuery, rangeObj db.IStandaloneModel, providers []string, cloudEnv string) *sqlchemy.SQuery {
+func (manager *SElasticipManager) usageQ(q *sqlchemy.SQuery, rangeObj db.IStandaloneModel, providers []string, brands []string, cloudEnv string) *sqlchemy.SQuery {
 	q = manager.usageQByRange(q, rangeObj)
-	q = manager.usageQByProvider(q, providers)
-	q = manager.usageQByCloudEnv(q, cloudEnv)
+	q = manager.usageQByCloudEnv(q, providers, brands, cloudEnv)
 	return q
 }
 
-func (manager *SElasticipManager) TotalCount(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, cloudEnv string) EipUsage {
+func (manager *SElasticipManager) TotalCount(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, brands []string, cloudEnv string) EipUsage {
 	usage := EipUsage{}
 	q1 := manager.Query().Equals("mode", api.EIP_MODE_INSTANCE_PUBLICIP)
-	q1 = manager.usageQ(q1, rangeObj, providers, cloudEnv)
+	q1 = manager.usageQ(q1, rangeObj, providers, brands, cloudEnv)
 	q2 := manager.Query().Equals("mode", api.EIP_MODE_STANDALONE_EIP)
-	q2 = manager.usageQ(q2, rangeObj, providers, cloudEnv)
+	q2 = manager.usageQ(q2, rangeObj, providers, brands, cloudEnv)
 	q3 := manager.Query().Equals("mode", api.EIP_MODE_STANDALONE_EIP).IsNotEmpty("associate_id")
-	q3 = manager.usageQ(q3, rangeObj, providers, cloudEnv)
+	q3 = manager.usageQ(q3, rangeObj, providers, brands, cloudEnv)
 	switch scope {
 	case rbacutils.ScopeSystem:
 		// do nothing

pkg/compute/models/guests.go

@@ -2136,9 +2136,9 @@ func (manager *SGuestManager) TotalCount(
 	rangeObj db.IStandaloneModel,
 	status []string, hypervisors []string,
 	includeSystem bool, pendingDelete bool,
-	hostTypes []string, resourceTypes []string, providers []string, cloudEnv string,
+	hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string,
 ) SGuestCountStat {
-	return totalGuestResourceCount(scope, ownerId, rangeObj, status, hypervisors, includeSystem, pendingDelete, hostTypes, resourceTypes, providers, cloudEnv)
+	return totalGuestResourceCount(scope, ownerId, rangeObj, status, hypervisors, includeSystem, pendingDelete, hostTypes, resourceTypes, providers, brands, cloudEnv)
 }
 
 func (self *SGuest) detachNetworks(ctx context.Context, userCred mcclient.TokenCredential, gns []SGuestnetwork, reserve bool, deploy bool) error {
@@ -2548,14 +2548,14 @@ func (self *SGuest) SyncVMDisks(ctx context.Context, userCred mcclient.TokenCred
 	return result
 }
 
-func filterGuestByRange(q *sqlchemy.SQuery, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) *sqlchemy.SQuery {
+func filterGuestByRange(q *sqlchemy.SQuery, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) *sqlchemy.SQuery {
 	hosts := HostManager.Query().SubQuery()
 
 	q = q.Join(hosts, sqlchemy.Equals(hosts.Field("id"), q.Field("host_id")))
 	//q = q.Filter(sqlchemy.IsTrue(hosts.Field("enabled")))
 	// q = q.Filter(sqlchemy.Equals(hosts.Field("host_status"), HOST_ONLINE))
 
-	q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, cloudEnv, rangeObj)
+	q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, brands, cloudEnv, rangeObj)
 	return q
 }
 
@@ -2581,7 +2581,7 @@ func totalGuestResourceCount(
 	pendingDelete bool,
 	hostTypes []string,
 	resourceTypes []string,
-	providers []string, cloudEnv string,
+	providers []string, brands []string, cloudEnv string,
 ) SGuestCountStat {
 
 	guestdisks := GuestdiskManager.Query().SubQuery()
@@ -2633,7 +2633,7 @@ func totalGuestResourceCount(
 
 	q = q.LeftJoin(isoDevSubQuery, sqlchemy.Equals(isoDevSubQuery.Field("guest_id"), guests.Field("id")))
 
-	q = filterGuestByRange(q, rangeObj, hostTypes, resourceTypes, providers, cloudEnv)
+	q = filterGuestByRange(q, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv)
 
 	switch scope {
 	case rbacutils.ScopeSystem:

pkg/compute/models/hosts.go

@@ -2013,7 +2013,7 @@ func (manager *SHostManager) totalCountQ(
 	hostStatus, status string,
 	hostTypes []string,
 	resourceTypes []string,
-	providers []string, cloudEnv string,
+	providers []string, brands []string, cloudEnv string,
 	enabled, isBaremetal tristate.TriState,
 ) *sqlchemy.SQuery {
 	hosts := manager.Query().SubQuery()
@@ -2055,7 +2055,7 @@ func (manager *SHostManager) totalCountQ(
 		}
 		q = q.Filter(cond(hosts.Field("is_baremetal")))
 	}
-	q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, cloudEnv, rangeObj)
+	q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, brands, cloudEnv, rangeObj)
 	return q
 }
 
@@ -2138,10 +2138,10 @@ func (manager *SHostManager) TotalCount(
 	hostStatus, status string,
 	hostTypes []string,
 	resourceTypes []string,
-	providers []string, cloudEnv string,
+	providers []string, brands []string, cloudEnv string,
 	enabled, isBaremetal tristate.TriState,
 ) HostsCountStat {
-	return manager.calculateCount(manager.totalCountQ(userCred, rangeObj, hostStatus, status, hostTypes, resourceTypes, providers, cloudEnv, enabled, isBaremetal))
+	return manager.calculateCount(manager.totalCountQ(userCred, rangeObj, hostStatus, status, hostTypes, resourceTypes, providers, brands, cloudEnv, enabled, isBaremetal))
 }
 
 /*

pkg/compute/models/isolated_devices.go

@@ -405,7 +405,7 @@ func (manager *SIsolatedDeviceManager) ReleaseDevicesOfGuest(ctx context.Context
 
 func (manager *SIsolatedDeviceManager) totalCountQ(
 	devType []string, hostTypes []string,
-	resourceTypes []string, providers []string, cloudEnv string,
+	resourceTypes []string, providers []string, brands []string, cloudEnv string,
 	rangeObj db.IStandaloneModel,
 ) *sqlchemy.SQuery {
 	hosts := HostManager.Query().SubQuery()
@@ -415,7 +415,7 @@ func (manager *SIsolatedDeviceManager) totalCountQ(
 	if len(devType) != 0 {
 		q = q.Filter(sqlchemy.In(devs.Field("dev_type"), devType))
 	}
-	return AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, cloudEnv, rangeObj)
+	return AttachUsageQuery(q, hosts, hostTypes, resourceTypes, providers, brands, cloudEnv, rangeObj)
 }
 
 type IsolatedDeviceCountStat struct {
@@ -423,17 +423,17 @@ type IsolatedDeviceCountStat struct {
 	Gpus    int
 }
 
-func (manager *SIsolatedDeviceManager) totalCount(devType, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string, rangeObj db.IStandaloneModel) (int, error) {
-	return manager.totalCountQ(devType, hostTypes, resourceTypes, providers, cloudEnv, rangeObj).CountWithError()
+func (manager *SIsolatedDeviceManager) totalCount(devType, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string, rangeObj db.IStandaloneModel) (int, error) {
+	return manager.totalCountQ(devType, hostTypes, resourceTypes, providers, brands, cloudEnv, rangeObj).CountWithError()
 }
 
-func (manager *SIsolatedDeviceManager) TotalCount(hostType []string, resourceTypes []string, providers []string, cloudEnv string, rangeObj db.IStandaloneModel) (IsolatedDeviceCountStat, error) {
+func (manager *SIsolatedDeviceManager) TotalCount(hostType []string, resourceTypes []string, providers []string, brands []string, cloudEnv string, rangeObj db.IStandaloneModel) (IsolatedDeviceCountStat, error) {
 	stat := IsolatedDeviceCountStat{}
-	devCnt, err := manager.totalCount(nil, hostType, resourceTypes, providers, cloudEnv, rangeObj)
+	devCnt, err := manager.totalCount(nil, hostType, resourceTypes, providers, brands, cloudEnv, rangeObj)
 	if err != nil {
 		return stat, err
 	}
-	gpuCnt, err := manager.totalCount(VALID_GPU_TYPES, hostType, resourceTypes, providers, cloudEnv, rangeObj)
+	gpuCnt, err := manager.totalCount(VALID_GPU_TYPES, hostType, resourceTypes, providers, brands, cloudEnv, rangeObj)
 	if err != nil {
 		return stat, err
 	}

pkg/compute/models/networks.go

@@ -682,7 +682,7 @@ func (manager *SNetworkManager) GetOnPremiseNetworkOfIP(ipAddr string, serverTyp
 	return nil, sql.ErrNoRows
 }
 
-func (manager *SNetworkManager) allNetworksQ(providers []string, cloudEnv string, rangeObj db.IStandaloneModel) *sqlchemy.SQuery {
+func (manager *SNetworkManager) allNetworksQ(providers []string, brands []string, cloudEnv string, rangeObj db.IStandaloneModel) *sqlchemy.SQuery {
 	networks := manager.Query().SubQuery()
 	hostwires := HostwireManager.Query().SubQuery()
 	hosts := HostManager.Query().SubQuery()
@@ -693,11 +693,11 @@ func (manager *SNetworkManager) allNetworksQ(providers []string, cloudEnv string
 	q = q.Filter(sqlchemy.OR(
 		sqlchemy.Equals(hosts.Field("host_type"), api.HOST_TYPE_BAREMETAL),
 		sqlchemy.Equals(hosts.Field("host_status"), api.HOST_ONLINE)))
-	return AttachUsageQuery(q, hosts, nil, nil, providers, cloudEnv, rangeObj)
+	return AttachUsageQuery(q, hosts, nil, nil, providers, brands, cloudEnv, rangeObj)
 }
 
-func (manager *SNetworkManager) totalPortCountQ(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, providers []string, cloudEnv string, rangeObj db.IStandaloneModel) *sqlchemy.SQuery {
-	q := manager.allNetworksQ(providers, cloudEnv, rangeObj)
+func (manager *SNetworkManager) totalPortCountQ(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, providers []string, brands []string, cloudEnv string, rangeObj db.IStandaloneModel) *sqlchemy.SQuery {
+	q := manager.allNetworksQ(providers, brands, cloudEnv, rangeObj)
 	switch scope {
 	case rbacutils.ScopeSystem:
 	case rbacutils.ScopeDomain:
@@ -716,11 +716,11 @@ type NetworkPortStat struct {
 func (manager *SNetworkManager) TotalPortCount(
 	scope rbacutils.TRbacScope,
 	userCred mcclient.IIdentityProvider,
-	providers []string, cloudEnv string,
+	providers []string, brands []string, cloudEnv string,
 	rangeObj db.IStandaloneModel,
 ) NetworkPortStat {
 	nets := make([]SNetwork, 0)
-	err := manager.totalPortCountQ(scope, userCred, providers, cloudEnv, rangeObj).All(&nets)
+	err := manager.totalPortCountQ(scope, userCred, providers, brands, cloudEnv, rangeObj).All(&nets)
 	if err != nil {
 		log.Errorf("TotalPortCount: %v", err)
 	}

pkg/compute/models/quotas.go

@@ -96,9 +96,9 @@ func (self *SQuota) FetchUsage(ctx context.Context, scope rbacutils.TRbacScope,
 	// net := WireManager.TotalCount(nil, nil, nil, "", scope, ownerId)
 	hypervisors := sets.NewString(api.HYPERVISORS...)
 	hypervisors.Delete(api.HYPERVISOR_CONTAINER)
-	guest := totalGuestResourceCount(scope, ownerId, nil, nil, hypervisors.List(), false, false, nil, nil, nil, "")
-	eipUsage := ElasticipManager.TotalCount(scope, ownerId, nil, nil, "")
-	snapshotCount, _ := TotalSnapshotCount(scope, ownerId, nil, nil, "")
+	guest := totalGuestResourceCount(scope, ownerId, nil, nil, hypervisors.List(), false, false, nil, nil, nil, nil, "")
+	eipUsage := ElasticipManager.TotalCount(scope, ownerId, nil, nil, nil, "")
+	snapshotCount, _ := TotalSnapshotCount(scope, ownerId, nil, nil, nil, "")
 	// XXX
 	// keypair belongs to user
 	// keypair := totalKeypairCount(projectId)

pkg/compute/models/snapshots.go

@@ -591,7 +591,7 @@ func (self *SSnapshot) Delete(ctx context.Context, userCred mcclient.TokenCreden
 	return nil
 }
 
-func TotalSnapshotCount(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, cloudEnv string) (int, error) {
+func TotalSnapshotCount(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, brands []string, cloudEnv string) (int, error) {
 	q := SnapshotManager.Query()
 
 	switch scope {
@@ -614,28 +614,8 @@ func TotalSnapshotCount(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityPr
 			q = q.Filter(sqlchemy.Equals(q.Field("cloudregion_id"), rangeObj.GetId()))
 		}
 	}
-	if len(providers) > 0 {
-		cloudproviders := CloudproviderManager.Query().SubQuery()
-		subq := cloudproviders.Query(cloudproviders.Field("id"))
-		subq = subq.In("provider", providers)
-		q = q.In("manager_id", subq.SubQuery())
-	}
 
-	if len(cloudEnv) > 0 {
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			q = q.Filter(sqlchemy.In(q.Field("manager_id"), CloudproviderManager.GetPublicProviderIdsQuery()))
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			q = q.Filter(sqlchemy.In(q.Field("manager_id"), CloudproviderManager.GetPrivateProviderIdsQuery()))
-		case api.CLOUD_ENV_ON_PREMISE:
-			q = q.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(q.Field("manager_id"), CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(q.Field("manager_id")),
-				),
-			)
-		}
-	}
+	q = CloudProviderFilter(q, q.Field("manager_id"), providers, brands, cloudEnv)
 
 	q = q.Equals("fake_deleted", false)
 	return q.CountWithError()

pkg/compute/models/storages.go

@@ -812,7 +812,7 @@ func (manager *SStorageManager) disksFailedQ() *sqlchemy.SSubQuery {
 
 func (manager *SStorageManager) totalCapacityQ(
 	rangeObj db.IStandaloneModel, hostTypes []string,
-	resourceTypes []string, providers []string, cloudEnv string,
+	resourceTypes []string, providers []string, brands []string, cloudEnv string,
 ) *sqlchemy.SQuery {
 	stmt := manager.disksReadyQ()
 	stmt2 := manager.disksFailedQ()
@@ -842,31 +842,10 @@ func (manager *SStorageManager) totalCapacityQ(
 		q = q.Filter(sqlchemy.IsTrue(hosts.Field("enabled")))
 		q = q.Filter(sqlchemy.Equals(hosts.Field("host_status"), api.HOST_ONLINE))
 
-		q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, nil, "", rangeObj)
+		q = AttachUsageQuery(q, hosts, hostTypes, resourceTypes, nil, nil, "", rangeObj)
 	}
 
-	if len(providers) > 0 {
-		cloudproviders := CloudproviderManager.Query().SubQuery()
-		subq := cloudproviders.Query(cloudproviders.Field("id"))
-		subq = subq.Filter(sqlchemy.In(cloudproviders.Field("provider"), providers))
-		q = q.Filter(sqlchemy.In(storages.Field("manager_id"), subq.SubQuery()))
-	}
-
-	if len(cloudEnv) > 0 {
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			q = q.Filter(sqlchemy.In(storages.Field("manager_id"), CloudproviderManager.GetPublicProviderIdsQuery()))
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			q = q.Filter(sqlchemy.In(storages.Field("manager_id"), CloudproviderManager.GetPrivateProviderIdsQuery()))
-		case api.CLOUD_ENV_ON_PREMISE:
-			q = q.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(storages.Field("manager_id"), CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(storages.Field("manager_id")),
-				),
-			)
-		}
-	}
+	q = CloudProviderFilter(q, storages.Field("manager_id"), providers, brands, cloudEnv)
 
 	return q
 }
@@ -925,8 +904,8 @@ func (manager *SStorageManager) calculateCapacity(q *sqlchemy.SQuery) StoragesCa
 	}
 }
 
-func (manager *SStorageManager) TotalCapacity(rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) StoragesCapacityStat {
-	res1 := manager.calculateCapacity(manager.totalCapacityQ(rangeObj, hostTypes, resourceTypes, providers, cloudEnv))
+func (manager *SStorageManager) TotalCapacity(rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) StoragesCapacityStat {
+	res1 := manager.calculateCapacity(manager.totalCapacityQ(rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv))
 	return res1
 }
 

pkg/compute/models/usage.go

@@ -27,7 +27,7 @@ func AttachUsageQuery(
 	hosts *sqlchemy.SSubQuery,
 	hostTypes []string,
 	resourceTypes []string,
-	providers []string, cloudEnv string,
+	providers []string, brands []string, cloudEnv string,
 	rangeObj db.IStandaloneModel,
 ) *sqlchemy.SQuery {
 	if len(hostTypes) > 0 {
@@ -43,26 +43,9 @@ func AttachUsageQuery(
 			q = q.Filter(sqlchemy.In(hosts.Field("resource_type"), resourceTypes))
 		}
 	}
-	if len(providers) > 0 {
-		cloudproviders := CloudproviderManager.Query().SubQuery()
-		subq := cloudproviders.Query(cloudproviders.Field("id")).In("provider", providers).SubQuery()
-		q = q.Filter(sqlchemy.In(hosts.Field("manager_id"), subq))
-	}
-	if len(cloudEnv) > 0 {
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			q = q.Filter(sqlchemy.In(hosts.Field("manager_id"), CloudproviderManager.GetPublicProviderIdsQuery()))
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			q = q.Filter(sqlchemy.In(hosts.Field("manager_id"), CloudproviderManager.GetPrivateProviderIdsQuery()))
-		case api.CLOUD_ENV_ON_PREMISE:
-			q = q.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(hosts.Field("manager_id"), CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(hosts.Field("manager_id")),
-				),
-			)
-		}
-	}
+
+	q = CloudProviderFilter(q, hosts.Field("manager_id"), providers, brands, cloudEnv)
+
 	if rangeObj == nil {
 		return q
 	}

pkg/compute/models/wires.go

@@ -345,7 +345,7 @@ func filterByScopeOwnerId(q *sqlchemy.SQuery, scope rbacutils.TRbacScope, ownerI
 	return q
 }
 
-func (manager *SWireManager) totalCountQ(rangeObj db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) *sqlchemy.SQuery {
+func (manager *SWireManager) totalCountQ(rangeObj db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) *sqlchemy.SQuery {
 	guests := GuestManager.Query().SubQuery()
 	hosts := HostManager.Query().SubQuery()
 	groups := GroupManager.Query().SubQuery()
@@ -432,35 +432,15 @@ func (manager *SWireManager) totalCountQ(rangeObj db.IStandaloneModel, hostTypes
 		sq := hostwires.Query(hostwires.Field("wire_id"))
 		sq = sq.Join(hosts, sqlchemy.Equals(hosts.Field("id"), hostwires.Field("host_id")))
 		sq = sq.Filter(sqlchemy.IsTrue(hosts.Field("enabled")))
-		sq = AttachUsageQuery(sq, hosts, hostTypes, nil, nil, "", rangeObj)
+		sq = AttachUsageQuery(sq, hosts, hostTypes, nil, nil, nil, "", rangeObj)
 		q = q.Filter(sqlchemy.In(wires.Field("id"), sq.Distinct()))
 	}
 
-	if len(providers) > 0 {
+	if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 {
 		vpcs := VpcManager.Query().SubQuery()
-		cloudproviders := CloudproviderManager.Query().SubQuery()
-		subq := vpcs.Query(vpcs.Field("id"))
-		subq = subq.Join(cloudproviders, sqlchemy.Equals(vpcs.Field("manager_id"), cloudproviders.Field("id")))
-		subq = subq.Filter(sqlchemy.In(cloudproviders.Field("provider"), providers))
-		q = q.Filter(sqlchemy.In(wires.Field("vpc_id"), subq.SubQuery()))
-	}
 
-	if len(cloudEnv) > 0 {
-		vpcs := VpcManager.Query().SubQuery()
 		subq := vpcs.Query(vpcs.Field("id"))
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			subq = subq.In("manager_id", CloudproviderManager.GetPublicProviderIdsQuery())
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			subq = subq.In("manager_id", CloudproviderManager.GetPrivateProviderIdsQuery())
-		case api.CLOUD_ENV_ON_PREMISE:
-			subq = subq.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(vpcs.Field("manager_id"), CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(vpcs.Field("manager_id")),
-				),
-			)
-		}
+		subq = CloudProviderFilter(subq, vpcs.Field("manager_id"), providers, brands, cloudEnv)
 		q = q.Filter(sqlchemy.In(wires.Field("vpc_id"), subq.SubQuery()))
 	}
 
@@ -481,9 +461,9 @@ func (wstat WiresCountStat) NicCount() int {
 	return wstat.GuestNicCount + wstat.HostNicCount + wstat.ReservedCount + wstat.GroupNicCount + wstat.LbNicCount
 }
 
-func (manager *SWireManager) TotalCount(rangeObj db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) WiresCountStat {
+func (manager *SWireManager) TotalCount(rangeObj db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string, scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider) WiresCountStat {
 	stat := WiresCountStat{}
-	err := manager.totalCountQ(rangeObj, hostTypes, providers, cloudEnv, scope, ownerId).First(&stat)
+	err := manager.totalCountQ(rangeObj, hostTypes, providers, brands, cloudEnv, scope, ownerId).First(&stat)
 	if err != nil {
 		log.Errorf("Wire total count: %v", err)
 	}

pkg/compute/usages/handler.go

@@ -19,14 +19,12 @@ import (
 	"fmt"
 	"net/http"
 
-	"github.com/pkg/errors"
-
 	json "yunion.io/x/jsonutils"
 	"yunion.io/x/log"
+	"yunion.io/x/pkg/errors"
 	"yunion.io/x/pkg/tristate"
 	"yunion.io/x/pkg/util/sets"
 	"yunion.io/x/pkg/utils"
-	"yunion.io/x/sqlchemy"
 
 	api "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/appctx"
@@ -65,7 +63,7 @@ func (u Usage) Include(nus ...Usage) Usage {
 	return u
 }
 
-type objUsageFunc func(rbacutils.TRbacScope, mcclient.IIdentityProvider, db.IStandaloneModel, []string, []string, string) (Usage, error)
+type objUsageFunc func(rbacutils.TRbacScope, mcclient.IIdentityProvider, db.IStandaloneModel, []string, []string, []string, string) (Usage, error)
 
 func getRangeObjId(ctx context.Context) (string, error) {
 	params := appctx.AppContextParams(ctx)
@@ -111,8 +109,9 @@ func rangeObjHandler(
 		hostTypes := json.GetQueryStringArray(query, "host_type")
 		// resourceTypes := json.GetQueryStringArray(query, "resource_type")
 		providers := json.GetQueryStringArray(query, "provider")
+		brands := json.GetQueryStringArray(query, "brand")
 		cloudEnv, _ := query.GetString("cloud_env")
-		usage, err := reporter(scope, ownerId, obj, hostTypes, providers, cloudEnv)
+		usage, err := reporter(scope, ownerId, obj, hostTypes, providers, brands, cloudEnv)
 		if err != nil {
 			httperrors.GeneralServerError(w, err)
 			return
@@ -162,45 +161,45 @@ func getQuery(r *http.Request) json.JSONObject {
 	return query
 }
 
-func ReportHostUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, host db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, host, hostTypes, providers, cloudEnv)
+func ReportHostUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, host db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, host, hostTypes, providers, brands, cloudEnv)
 }
 
-func ReportWireUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, wire db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, wire, hostTypes, providers, cloudEnv)
+func ReportWireUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, wire db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, wire, hostTypes, providers, brands, cloudEnv)
 }
 
-func ReportCloudAccountUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, account db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, account, hostTypes, providers, cloudEnv)
+func ReportCloudAccountUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, account db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, account, hostTypes, providers, brands, cloudEnv)
 }
 
-func ReportCloudProviderUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, provider db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, provider, hostTypes, providers, cloudEnv)
+func ReportCloudProviderUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, provider db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, provider, hostTypes, providers, brands, cloudEnv)
 }
 
-func ReportSchedtagUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, schedtag db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, schedtag, hostTypes, providers, cloudEnv)
+func ReportSchedtagUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, schedtag db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, schedtag, hostTypes, providers, brands, cloudEnv)
 }
 
-func ReportZoneUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, zone db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, zone, hostTypes, providers, cloudEnv)
+func ReportZoneUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, zone db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, zone, hostTypes, providers, brands, cloudEnv)
 }
 
-func ReportCloudRegionUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, cloudRegion db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (Usage, error) {
-	return ReportGeneralUsage(scope, userCred, cloudRegion, hostTypes, providers, cloudEnv)
+func ReportCloudRegionUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, cloudRegion db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (Usage, error) {
+	return ReportGeneralUsage(scope, userCred, cloudRegion, hostTypes, providers, brands, cloudEnv)
 }
 
-func getAdminGeneralUsage(userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (count Usage, err error) {
-	count = RegionUsage(providers, cloudEnv)
-	zone := ZoneUsage(providers, cloudEnv)
+func getAdminGeneralUsage(userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (count Usage, err error) {
+	count = RegionUsage(providers, brands, cloudEnv)
+	zone := ZoneUsage(providers, brands, cloudEnv)
 	count.Include(zone)
-	vpc := VpcUsage(providers, cloudEnv)
+	vpc := VpcUsage(providers, brands, cloudEnv)
 	count.Include(vpc)
 
 	var pmemTotal float64
 	var pcpuTotal float64
 
-	hostEnabledUsage := HostEnabledUsage("", userCred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv)
+	hostEnabledUsage := HostEnabledUsage("", userCred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv)
 	pmemTotal = float64(hostEnabledUsage.Get("enabled_hosts.memory").(int64))
 	pcpuTotal = float64(hostEnabledUsage.Get("enabled_hosts.cpu").(int64))
 	if rangeObj != nil && rangeObj.Keyword() == "host" {
@@ -213,11 +212,11 @@ func getAdminGeneralUsage(userCred mcclient.IIdentityProvider, rangeObj db.IStan
 		count.Add("cpu.virtual", host.GetVirtualCPUCount())
 	}
 
-	guestRunningUsage := GuestRunningUsage("all.running_servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv)
+	guestRunningUsage := GuestRunningUsage("all.running_servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv)
 	runningMem := guestRunningUsage.Get("all.running_servers.memory").(int)
 	runningCpu := guestRunningUsage.Get("all.running_servers.cpu").(int)
 
-	containerRunningUsage := containerUsage("all.containers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, cloudEnv)
+	containerRunningUsage := containerUsage("all.containers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, brands, cloudEnv)
 	containerRunningMem := containerRunningUsage.Get("all.containers.memory").(int)
 	containerRunningCpu := containerRunningUsage.Get("all.containers.cpu").(int)
 	runningMem += containerRunningMem
@@ -233,83 +232,83 @@ func getAdminGeneralUsage(userCred mcclient.IIdentityProvider, rangeObj db.IStan
 	count.Add("all.memory_commit_rate.running", runningMemCmtRate)
 	count.Add("all.cpu_commit_rate.running", runningCpuCmtRate)
 
-	storageUsage := StorageUsage("", rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv)
+	storageUsage := StorageUsage("", rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv)
 
 	count.Include(
-		HostAllUsage("", userCred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		HostAllUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		HostAllUsage("any_pool", userCred, rangeObj, hostTypes, nil, providers, cloudEnv),
+		HostAllUsage("", userCred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		HostAllUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		HostAllUsage("any_pool", userCred, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
 		hostEnabledUsage,
-		HostEnabledUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		HostEnabledUsage("any_pool", userCred, rangeObj, hostTypes, nil, providers, cloudEnv),
+		HostEnabledUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		HostEnabledUsage("any_pool", userCred, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		BaremetalUsage(userCred, rangeObj, hostTypes, providers, cloudEnv),
+		BaremetalUsage(userCred, rangeObj, hostTypes, providers, brands, cloudEnv),
 
 		storageUsage,
-		StorageUsage("prepaid_pool", rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		StorageUsage("any_pool", rangeObj, hostTypes, nil, providers, cloudEnv),
+		StorageUsage("prepaid_pool", rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		StorageUsage("any_pool", rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		GuestNormalUsage("all.servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		GuestNormalUsage("all.servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestNormalUsage("all.servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestNormalUsage("all.servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		GuestNormalUsage("all.servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestNormalUsage("all.servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		GuestPendingDeleteUsage("all.pending_delete_servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		GuestPendingDeleteUsage("all.pending_delete_servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestPendingDeleteUsage("all.pending_delete_servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestPendingDeleteUsage("all.pending_delete_servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		GuestPendingDeleteUsage("all.pending_delete_servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestPendingDeleteUsage("all.pending_delete_servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		GuestReadyUsage("all.ready_servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		GuestReadyUsage("all.ready_servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestReadyUsage("all.ready_servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestReadyUsage("all.ready_servers", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		GuestReadyUsage("all.ready_servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestReadyUsage("all.ready_servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
 		guestRunningUsage,
-		GuestRunningUsage("all.running_servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestRunningUsage("all.running_servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestRunningUsage("all.running_servers.prepaid_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestRunningUsage("all.running_servers.any_pool", rbacutils.ScopeSystem, nil, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
 		containerRunningUsage,
 
-		IsolatedDeviceUsage("", rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		IsolatedDeviceUsage("prepaid_pool", rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		IsolatedDeviceUsage("any_pool", rangeObj, hostTypes, nil, providers, cloudEnv),
+		IsolatedDeviceUsage("", rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		IsolatedDeviceUsage("prepaid_pool", rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		IsolatedDeviceUsage("any_pool", rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		WireUsage(rangeObj, hostTypes, providers, cloudEnv),
+		WireUsage(rangeObj, hostTypes, providers, brands, cloudEnv),
 
-		EipUsage(rbacutils.ScopeSystem, nil, rangeObj, providers, cloudEnv),
+		EipUsage(rbacutils.ScopeSystem, nil, rangeObj, providers, brands, cloudEnv),
 
-		SnapshotUsage(rbacutils.ScopeSystem, nil, rangeObj, providers, cloudEnv),
+		SnapshotUsage(rbacutils.ScopeSystem, nil, rangeObj, providers, brands, cloudEnv),
 	)
 
 	return
 }
 
-func getCommonGeneralUsage(scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (count Usage, err error) {
-	guestNormalUsage := GuestNormalUsage("servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv)
+func getCommonGeneralUsage(scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (count Usage, err error) {
+	guestNormalUsage := GuestNormalUsage("servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv)
 
-	containerUsage := containerUsage("containers", scope, cred, rangeObj, hostTypes, nil, providers, cloudEnv)
+	containerUsage := containerUsage("containers", scope, cred, rangeObj, hostTypes, nil, providers, brands, cloudEnv)
 
-	eipUsage := EipUsage(scope, cred, rangeObj, providers, cloudEnv)
+	eipUsage := EipUsage(scope, cred, rangeObj, providers, brands, cloudEnv)
 
-	snapshotUsage := SnapshotUsage(scope, cred, rangeObj, providers, cloudEnv)
+	snapshotUsage := SnapshotUsage(scope, cred, rangeObj, providers, brands, cloudEnv)
 
 	count = guestNormalUsage.Include(
-		GuestNormalUsage("servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestNormalUsage("servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestNormalUsage("servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestNormalUsage("servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		GuestRunningUsage("running_servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		GuestRunningUsage("running_servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestRunningUsage("running_servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestRunningUsage("running_servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		GuestRunningUsage("running_servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestRunningUsage("running_servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		GuestPendingDeleteUsage("pending_delete_servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		GuestPendingDeleteUsage("pending_delete_servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestPendingDeleteUsage("pending_delete_servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestPendingDeleteUsage("pending_delete_servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		GuestPendingDeleteUsage("pending_delete_servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestPendingDeleteUsage("pending_delete_servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
-		GuestReadyUsage("ready_servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, cloudEnv),
-		GuestReadyUsage("ready_servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, cloudEnv),
-		GuestReadyUsage("ready_servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, cloudEnv),
+		GuestReadyUsage("ready_servers", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypeShared}, providers, brands, cloudEnv),
+		GuestReadyUsage("ready_servers.prepaid_pool", scope, cred, rangeObj, hostTypes, []string{api.HostResourceTypePrepaidRecycle}, providers, brands, cloudEnv),
+		GuestReadyUsage("ready_servers.any_pool", scope, cred, rangeObj, hostTypes, nil, providers, brands, cloudEnv),
 
 		containerUsage,
 
-		NetworkUsage(scope, cred, providers, cloudEnv, rangeObj),
+		NetworkUsage(scope, cred, providers, brands, cloudEnv, rangeObj),
 
 		eipUsage,
 
@@ -318,25 +317,25 @@ func getCommonGeneralUsage(scope rbacutils.TRbacScope, cred mcclient.IIdentityPr
 	return
 }
 
-func ReportGeneralUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) (count Usage, err error) {
+func ReportGeneralUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) (count Usage, err error) {
 	count = make(map[string]interface{})
 
 	if scope == rbacutils.ScopeSystem {
-		count, err = getAdminGeneralUsage(userCred, rangeObj, hostTypes, providers, cloudEnv)
+		count, err = getAdminGeneralUsage(userCred, rangeObj, hostTypes, providers, brands, cloudEnv)
 		if err != nil {
 			return
 		}
 	}
 
 	if scope.HigherEqual(rbacutils.ScopeDomain) {
-		commonUsage, err := getCommonGeneralUsage(rbacutils.ScopeDomain, userCred, rangeObj, hostTypes, providers, cloudEnv)
+		commonUsage, err := getCommonGeneralUsage(rbacutils.ScopeDomain, userCred, rangeObj, hostTypes, providers, brands, cloudEnv)
 		if err == nil {
 			count.Include(commonUsage)
 		}
 	}
 
 	if scope.HigherEqual(rbacutils.ScopeProject) {
-		commonUsage, err := getCommonGeneralUsage(rbacutils.ScopeProject, userCred, rangeObj, hostTypes, providers, cloudEnv)
+		commonUsage, err := getCommonGeneralUsage(rbacutils.ScopeProject, userCred, rangeObj, hostTypes, providers, brands, cloudEnv)
 		if err == nil {
 			count.Include(commonUsage)
 		}
@@ -344,83 +343,38 @@ func ReportGeneralUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityP
 	return
 }
 
-func RegionUsage(providers []string, cloudEnv string) Usage {
+func RegionUsage(providers []string, brands []string, cloudEnv string) Usage {
 	q := models.CloudregionManager.Query()
-	if len(providers) > 0 {
-		q = q.In("provider", providers)
-	}
-	if len(cloudEnv) > 0 {
+
+	if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 {
 		subq := models.VpcManager.Query("cloudregion_id")
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			subq = subq.In("manager_id", models.CloudproviderManager.GetPublicProviderIdsQuery())
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			subq = subq.In("manager_id", models.CloudproviderManager.GetPrivateProviderIdsQuery())
-		case api.CLOUD_ENV_ON_PREMISE:
-			subq = subq.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(subq.Field("manager_id"), models.CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(subq.Field("manager_id")),
-				),
-			)
-		}
+		subq = models.CloudProviderFilter(subq, subq.Field("manager_id"), providers, brands, cloudEnv)
 		q = q.In("id", subq.SubQuery())
 	}
+
 	count := make(map[string]interface{})
 	count["regions"], _ = q.CountWithError()
 	return count
 }
 
-func ZoneUsage(providers []string, cloudEnv string) Usage {
-	regions := models.CloudregionManager.Query().SubQuery()
-	subq := regions.Query(regions.Field("id"))
-	if len(providers) > 0 {
-		subq = subq.In("provider", providers)
-	}
-	q := models.ZoneManager.Query().In("cloudregion_id", subq.SubQuery())
-	if len(cloudEnv) > 0 {
+func ZoneUsage(providers []string, brands []string, cloudEnv string) Usage {
+	q := models.ZoneManager.Query()
+
+	if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 {
 		subq := models.HostManager.Query("zone_id")
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			subq = subq.In("manager_id", models.CloudproviderManager.GetPublicProviderIdsQuery())
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			subq = subq.In("manager_id", models.CloudproviderManager.GetPrivateProviderIdsQuery())
-		case api.CLOUD_ENV_ON_PREMISE:
-			subq = subq.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(subq.Field("manager_id"), models.CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(subq.Field("manager_id")),
-				),
-			)
-		}
+		subq = models.CloudProviderFilter(subq, subq.Field("manager_id"), providers, brands, cloudEnv)
 		q = q.In("id", subq.SubQuery())
 	}
+
 	count := make(map[string]interface{})
 	count["zones"], _ = q.CountWithError()
 	return count
 }
 
-func VpcUsage(providers []string, cloudEnv string) Usage {
-	regions := models.CloudregionManager.Query().SubQuery()
-	subq := regions.Query(regions.Field("id"))
-	if len(providers) > 0 {
-		subq = subq.In("provider", providers)
-	}
-	q := models.VpcManager.Query().In("cloudregion_id", subq.SubQuery())
-	if len(cloudEnv) > 0 {
-		switch cloudEnv {
-		case api.CLOUD_ENV_PUBLIC_CLOUD:
-			q = q.Filter(sqlchemy.In(q.Field("manager_id"), models.CloudproviderManager.GetPublicProviderIdsQuery()))
-		case api.CLOUD_ENV_PRIVATE_CLOUD:
-			q = q.Filter(sqlchemy.In(q.Field("manager_id"), models.CloudproviderManager.GetPrivateProviderIdsQuery()))
-		case api.CLOUD_ENV_ON_PREMISE:
-			q = q.Filter(
-				sqlchemy.OR(
-					sqlchemy.In(q.Field("manager_id"), models.CloudproviderManager.GetOnPremiseProviderIdsQuery()),
-					sqlchemy.IsNullOrEmpty(q.Field("manager_id")),
-				),
-			)
-		}
+func VpcUsage(providers []string, brands []string, cloudEnv string) Usage {
+	q := models.VpcManager.Query()
+	if len(providers) > 0 || len(brands) > 0 || len(cloudEnv) > 0 {
+		q = models.CloudProviderFilter(q, q.Field("manager_id"), providers, brands, cloudEnv)
 	}
 
 	count := make(map[string]interface{})
@@ -428,7 +382,7 @@ func VpcUsage(providers []string, cloudEnv string) Usage {
 	return count
 }
 
-func StorageUsage(prefix string, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
+func StorageUsage(prefix string, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	sPrefix := "storages"
 	dPrefix := "all.disks"
 	if len(prefix) > 0 {
@@ -436,7 +390,7 @@ func StorageUsage(prefix string, rangeObj db.IStandaloneModel, hostTypes []strin
 		dPrefix = fmt.Sprintf("%s.%s", dPrefix, prefix)
 	}
 	count := make(map[string]interface{})
-	result := models.StorageManager.TotalCapacity(rangeObj, hostTypes, resourceTypes, providers, cloudEnv)
+	result := models.StorageManager.TotalCapacity(rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv)
 	count[sPrefix] = result.Capacity
 	count[fmt.Sprintf("%s.virtual", sPrefix)] = result.CapacityVirtual
 	count[dPrefix] = result.CapacityUsed
@@ -453,9 +407,9 @@ func StorageUsage(prefix string, rangeObj db.IStandaloneModel, hostTypes []strin
 	return count
 }
 
-func WireUsage(rangeObj db.IStandaloneModel, hostTypes []string, providers []string, cloudEnv string) Usage {
+func WireUsage(rangeObj db.IStandaloneModel, hostTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	count := make(map[string]interface{})
-	result := models.WireManager.TotalCount(rangeObj, hostTypes, providers, cloudEnv, rbacutils.ScopeSystem, nil)
+	result := models.WireManager.TotalCount(rangeObj, hostTypes, providers, brands, cloudEnv, rbacutils.ScopeSystem, nil)
 	count["wires"] = result.WiresCount
 	count["networks"] = result.NetCount
 	count["all.nics.guest"] = result.GuestNicCount
@@ -467,36 +421,36 @@ func WireUsage(rangeObj db.IStandaloneModel, hostTypes []string, providers []str
 	return count
 }
 
-func NetworkUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, providers []string, cloudEnv string, rangeObj db.IStandaloneModel) Usage {
+func NetworkUsage(scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, providers []string, brands []string, cloudEnv string, rangeObj db.IStandaloneModel) Usage {
 	count := make(map[string]interface{})
-	ret := models.NetworkManager.TotalPortCount(scope, userCred, providers, cloudEnv, rangeObj)
+	ret := models.NetworkManager.TotalPortCount(scope, userCred, providers, brands, cloudEnv, rangeObj)
 	count["ports"] = ret.Count
 	count["ports_exit"] = ret.CountExt
 	return count
 }
 
 func HostAllUsage(pref string, userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel,
-	hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
+	hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	prefix := "hosts"
 	if len(pref) > 0 {
 		prefix = fmt.Sprintf("%s.%s", prefix, pref)
 	}
-	return hostUsage(userCred, prefix, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, tristate.None, tristate.None)
+	return hostUsage(userCred, prefix, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, tristate.None, tristate.None)
 }
 
 func HostEnabledUsage(pref string, userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel,
-	hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
+	hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	prefix := "enabled_hosts"
 	if len(pref) > 0 {
 		prefix = fmt.Sprintf("%s.%s", prefix, pref)
 	}
-	return hostUsage(userCred, prefix, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, tristate.True, tristate.None)
+	return hostUsage(userCred, prefix, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, tristate.True, tristate.None)
 }
 
 func BaremetalUsage(userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel,
-	hostTypes []string, providers []string, cloudEnv string) Usage {
+	hostTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	prefix := "baremetals"
-	count := hostUsage(userCred, prefix, rangeObj, hostTypes, nil, providers, cloudEnv, tristate.None, tristate.True)
+	count := hostUsage(userCred, prefix, rangeObj, hostTypes, nil, providers, brands, cloudEnv, tristate.None, tristate.True)
 	delete(count, fmt.Sprintf("%s.memory.virtual", prefix))
 	delete(count, fmt.Sprintf("%s.cpu.virtual", prefix))
 	return count
@@ -505,12 +459,12 @@ func BaremetalUsage(userCred mcclient.IIdentityProvider, rangeObj db.IStandalone
 func hostUsage(
 	userCred mcclient.IIdentityProvider, prefix string,
 	rangeObj db.IStandaloneModel, hostTypes []string,
-	resourceTypes []string, providers []string, cloudEnv string,
+	resourceTypes []string, providers []string, brands []string, cloudEnv string,
 	enabled, isBaremetal tristate.TriState,
 ) Usage {
 	count := make(map[string]interface{})
 
-	result := models.HostManager.TotalCount(userCred, rangeObj, "", "", hostTypes, resourceTypes, providers, cloudEnv, enabled, isBaremetal)
+	result := models.HostManager.TotalCount(userCred, rangeObj, "", "", hostTypes, resourceTypes, providers, brands, cloudEnv, enabled, isBaremetal)
 	count[prefix] = result.Count
 	count[fmt.Sprintf("%s.memory", prefix)] = result.Memory
 	count[fmt.Sprintf("%s.cpu", prefix)] = result.CPU
@@ -520,20 +474,20 @@ func hostUsage(
 	return count
 }
 
-func GuestNormalUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
-	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, nil, false)
+func GuestNormalUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
+	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, nil, false)
 }
 
-func GuestPendingDeleteUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
-	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, nil, true)
+func GuestPendingDeleteUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
+	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, nil, true)
 }
 
-func GuestRunningUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
-	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, []string{api.VM_RUNNING}, false)
+func GuestRunningUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
+	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, []string{api.VM_RUNNING}, false)
 }
 
-func GuestReadyUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
-	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, []string{api.VM_READY}, false)
+func GuestReadyUsage(prefix string, scope rbacutils.TRbacScope, cred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
+	return guestUsage(prefix, scope, cred, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, []string{api.VM_READY}, false)
 }
 
 func guestHypervisorsUsage(
@@ -541,13 +495,13 @@ func guestHypervisorsUsage(
 	scope rbacutils.TRbacScope,
 	ownerId mcclient.IIdentityProvider,
 	rangeObj db.IStandaloneModel,
-	hostTypes []string, resourceTypes []string, providers []string, cloudEnv string,
+	hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string,
 	status, hypervisors []string,
 	pendingDelete bool,
 ) Usage {
 	// temporarily hide system resources
 	// XXX needs more work later
-	guest := models.GuestManager.TotalCount(scope, ownerId, rangeObj, status, hypervisors, false, pendingDelete, hostTypes, resourceTypes, providers, cloudEnv)
+	guest := models.GuestManager.TotalCount(scope, ownerId, rangeObj, status, hypervisors, false, pendingDelete, hostTypes, resourceTypes, providers, brands, cloudEnv)
 	count := make(map[string]interface{})
 	count[prefix] = guest.TotalGuestCount
 	count[fmt.Sprintf("%s.cpu", prefix)] = guest.TotalCpuCount
@@ -569,25 +523,25 @@ func guestHypervisorsUsage(
 }
 
 func guestUsage(prefix string, scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel,
-	hostTypes []string, resourceTypes []string, providers []string, cloudEnv string,
+	hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string,
 	status []string, pendingDelete bool) Usage {
 	hypervisors := sets.NewString(api.HYPERVISORS...)
 	hypervisors.Delete(api.HYPERVISOR_CONTAINER)
-	return guestHypervisorsUsage(prefix, scope, userCred, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, status, hypervisors.List(), pendingDelete)
+	return guestHypervisorsUsage(prefix, scope, userCred, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, status, hypervisors.List(), pendingDelete)
 }
 
 func containerUsage(prefix string, scope rbacutils.TRbacScope, userCred mcclient.IIdentityProvider, rangeObj db.IStandaloneModel,
-	hostTypes []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
+	hostTypes []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	hypervisors := []string{api.HYPERVISOR_CONTAINER}
-	return guestHypervisorsUsage(prefix, scope, userCred, rangeObj, hostTypes, resourceTypes, providers, cloudEnv, nil, hypervisors, false)
+	return guestHypervisorsUsage(prefix, scope, userCred, rangeObj, hostTypes, resourceTypes, providers, brands, cloudEnv, nil, hypervisors, false)
 }
 
-func IsolatedDeviceUsage(pref string, rangeObj db.IStandaloneModel, hostType []string, resourceTypes []string, providers []string, cloudEnv string) Usage {
+func IsolatedDeviceUsage(pref string, rangeObj db.IStandaloneModel, hostType []string, resourceTypes []string, providers []string, brands []string, cloudEnv string) Usage {
 	prefix := "isolated_devices"
 	if len(pref) > 0 {
 		prefix = fmt.Sprintf("%s.%s", prefix, pref)
 	}
-	ret, _ := models.IsolatedDeviceManager.TotalCount(hostType, resourceTypes, providers, cloudEnv, rangeObj)
+	ret, _ := models.IsolatedDeviceManager.TotalCount(hostType, resourceTypes, providers, brands, cloudEnv, rangeObj)
 	count := make(map[string]interface{})
 	count[prefix] = ret.Devices
 	return count
@@ -601,9 +555,9 @@ func getKey(projectId, key string) string {
 	}
 }
 
-func EipUsage(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, cloudEnv string) Usage {
+func EipUsage(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, brands []string, cloudEnv string) Usage {
 	projectId := mcclient.OwnerIdString(ownerId, scope)
-	eipUsage := models.ElasticipManager.TotalCount(scope, ownerId, rangeObj, providers, cloudEnv)
+	eipUsage := models.ElasticipManager.TotalCount(scope, ownerId, rangeObj, providers, brands, cloudEnv)
 	count := make(map[string]interface{})
 	count[getKey(projectId, "eip")] = eipUsage.Total()
 	count[getKey(projectId, "eip.public_ip")] = eipUsage.PublicIPCount
@@ -613,9 +567,9 @@ func EipUsage(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, ra
 	return count
 }
 
-func SnapshotUsage(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, cloudEnv string) Usage {
+func SnapshotUsage(scope rbacutils.TRbacScope, ownerId mcclient.IIdentityProvider, rangeObj db.IStandaloneModel, providers []string, brands []string, cloudEnv string) Usage {
 	projectId := mcclient.OwnerIdString(ownerId, scope)
-	cnt, _ := models.TotalSnapshotCount(scope, ownerId, rangeObj, providers, cloudEnv)
+	cnt, _ := models.TotalSnapshotCount(scope, ownerId, rangeObj, providers, brands, cloudEnv)
 	count := make(map[string]interface{})
 	count[getKey(projectId, "snapshot")] = cnt
 	return count