update usages

pkg/compute/models/guests.go

@@ -378,8 +378,8 @@ func (manager *SGuestManager) ListItemFilter(ctx context.Context, q *sqlchemy.SQ
 		if count > 0 {
 			sgq := guestdisks.Query(guestdisks.Field("guest_id")).
 				Filter(sqlchemy.AND(
-					sqlchemy.Equals(guestdisks.Field("disk_id"), disk.Id),
-					sqlchemy.IsFalse(guestdisks.Field("deleted"))))
+				sqlchemy.Equals(guestdisks.Field("disk_id"), disk.Id),
+				sqlchemy.IsFalse(guestdisks.Field("deleted"))))
 			q = q.Filter(sqlchemy.In(q.Field("id"), sgq))
 		} else {
 			hosts := HostManager.Query().SubQuery()
@@ -387,11 +387,11 @@ func (manager *SGuestManager) ListItemFilter(ctx context.Context, q *sqlchemy.SQ
 			storages := StorageManager.Query().SubQuery()
 			sq := hosts.Query(hosts.Field("id")).
 				Join(hoststorages, sqlchemy.AND(
-					sqlchemy.Equals(hoststorages.Field("host_id"), hosts.Field("id")),
-					sqlchemy.IsFalse(hoststorages.Field("deleted")))).
+				sqlchemy.Equals(hoststorages.Field("host_id"), hosts.Field("id")),
+				sqlchemy.IsFalse(hoststorages.Field("deleted")))).
 				Join(storages, sqlchemy.AND(
-					sqlchemy.Equals(storages.Field("id"), hoststorages.Field("storage_id")),
-					sqlchemy.IsFalse(storages.Field("deleted")))).
+				sqlchemy.Equals(storages.Field("id"), hoststorages.Field("storage_id")),
+				sqlchemy.IsFalse(storages.Field("deleted")))).
 				Filter(sqlchemy.Equals(storages.Field("id"), disk.StorageId)).SubQuery()
 			q = q.In("host_id", sq)
 		}
@@ -445,8 +445,8 @@ func (manager *SGuestManager) ListItemFilter(ctx context.Context, q *sqlchemy.SQ
 		isodev := IsolatedDeviceManager.Query().SubQuery()
 		sgq := isodev.Query(isodev.Field("guest_id")).
 			Filter(sqlchemy.AND(
-				sqlchemy.IsNotNull(isodev.Field("guest_id")),
-				sqlchemy.Startswith(isodev.Field("dev_type"), "GPU")))
+			sqlchemy.IsNotNull(isodev.Field("guest_id")),
+			sqlchemy.Startswith(isodev.Field("dev_type"), "GPU")))
 		showGpu := utils.ToBool(gpu)
 		cond := sqlchemy.NotIn
 		if showGpu {
@@ -1255,7 +1255,7 @@ func (manager *SGuestManager) ListItemExportKeys(ctx context.Context, q *sqlchem
 		cloudregionQuery := CloudregionManager.Query("id", "name").SubQuery()
 		hostQuery.LeftJoin(zoneQuery, sqlchemy.Equals(hostQuery.Field("zone_id"), zoneQuery.Field("id"))).
 			LeftJoin(cloudregionQuery, sqlchemy.OR(sqlchemy.Equals(cloudregionQuery.Field("id"),
-				zoneQuery.Field("cloudregion_id")), sqlchemy.Equals(cloudregionQuery.Field("id"), "default")))
+			zoneQuery.Field("cloudregion_id")), sqlchemy.Equals(cloudregionQuery.Field("id"), "default")))
 		hostQuery.AppendField(cloudregionQuery.Field("name", "region"))
 		hostSubQuery := hostQuery.SubQuery()
 		q.LeftJoin(hostSubQuery, sqlchemy.Equals(q.Field("host_id"), hostSubQuery.Field("id")))
@@ -2160,14 +2160,15 @@ func filterGuestByRange(q *sqlchemy.SQuery, rangeObj db.IStandaloneModel, hostTy
 }
 
 type SGuestCountStat struct {
-	TotalGuestCount     int
-	TotalCpuCount       int
-	TotalMemSize        int
-	TotalDiskSize       int
-	TotalIsolatedCount  int
-	TotalBackupCpuCount int
-	TotalBackupMemSize  int
-	TotalBackupDiskSize int
+	TotalGuestCount       int
+	TotalCpuCount         int
+	TotalMemSize          int
+	TotalDiskSize         int
+	TotalIsolatedCount    int
+	TotalBackupGuestCount int
+	TotalBackupCpuCount   int
+	TotalBackupMemSize    int
+	TotalBackupDiskSize   int
 }
 
 func totalGuestResourceCount(
@@ -2186,12 +2187,17 @@ func totalGuestResourceCount(
 	disks := DiskManager.Query().SubQuery()
 
 	diskQuery := guestdisks.Query(guestdisks.Field("guest_id"), sqlchemy.SUM("guest_disk_size", disks.Field("disk_size")))
-	diskQuery = diskQuery.Join(disks, sqlchemy.AND(sqlchemy.Equals(guestdisks.Field("disk_id"), disks.Field("id")),
-		sqlchemy.IsFalse(disks.Field("deleted"))))
+	diskQuery = diskQuery.Join(disks, sqlchemy.Equals(guestdisks.Field("disk_id"), disks.Field("id")))
 	diskQuery = diskQuery.GroupBy(guestdisks.Field("guest_id"))
-
 	diskSubQuery := diskQuery.SubQuery()
-	diskBackupSubQuery := diskQuery.IsNotEmpty("backup_storage_id").SubQuery()
+
+	backupDiskQuery := guestdisks.Query(guestdisks.Field("guest_id"), sqlchemy.SUM("guest_disk_size", disks.Field("disk_size")))
+	backupDiskQuery = backupDiskQuery.LeftJoin(disks, sqlchemy.Equals(guestdisks.Field("disk_id"), disks.Field("id")))
+	backupDiskQuery = backupDiskQuery.Filter(sqlchemy.IsNotEmpty(disks.Field("backup_storage_id")))
+	backupDiskQuery = backupDiskQuery.GroupBy(guestdisks.Field("guest_id"))
+
+	diskBackupSubQuery := backupDiskQuery.SubQuery()
+	// diskBackupSubQuery := diskQuery.IsNotEmpty("backup_storage_id").SubQuery()
 
 	isolated := IsolatedDeviceManager.Query().SubQuery()
 
@@ -2202,7 +2208,11 @@ func totalGuestResourceCount(
 	isoDevSubQuery := isoDevQuery.SubQuery()
 
 	guests := GuestManager.Query().SubQuery()
-	guestBackupSubQuery := GuestManager.Query("id", "vcpu_count", "vmem_size").IsNotEmpty("backup_host_id").SubQuery()
+	guestBackupSubQuery := GuestManager.Query(
+		"id",
+		"vcpu_count",
+		"vmem_size",
+	).IsNotEmpty("backup_host_id").SubQuery()
 
 	q := guests.Query(sqlchemy.COUNT("total_guest_count"),
 		sqlchemy.SUM("total_cpu_count", guests.Field("vcpu_count")),
@@ -2211,10 +2221,13 @@ func totalGuestResourceCount(
 		sqlchemy.SUM("total_isolated_count", isoDevSubQuery.Field("device_sum")),
 		sqlchemy.SUM("total_backup_disk_size", diskBackupSubQuery.Field("guest_disk_size")),
 		sqlchemy.SUM("total_backup_cpu_count", guestBackupSubQuery.Field("vcpu_count")),
-		sqlchemy.SUM("total_backup_mem_size", guestBackupSubQuery.Field("vmem_size")))
+		sqlchemy.SUM("total_backup_mem_size", guestBackupSubQuery.Field("vmem_size")),
+		sqlchemy.COUNT("total_backup_guest_count", guestBackupSubQuery.Field("id")),
+	)
+
+	q = q.LeftJoin(guestBackupSubQuery, sqlchemy.Equals(guestBackupSubQuery.Field("id"), guests.Field("id")))
 
 	q = q.LeftJoin(diskSubQuery, sqlchemy.Equals(diskSubQuery.Field("guest_id"), guests.Field("id")))
-	q = q.LeftJoin(guestBackupSubQuery, sqlchemy.Equals(guestBackupSubQuery.Field("id"), q.Field("id")))
 	q = q.LeftJoin(diskBackupSubQuery, sqlchemy.Equals(diskBackupSubQuery.Field("guest_id"), guests.Field("id")))
 
 	q = q.LeftJoin(isoDevSubQuery, sqlchemy.Equals(isoDevSubQuery.Field("guest_id"), guests.Field("id")))
@@ -3263,7 +3276,7 @@ func (manager *SGuestManager) GetIpInProjectWithName(projectId, name string, isE
 				sqlchemy.IsFalse(guests.Field("pending_deleted"))),
 			sqlchemy.IsFalse(guests.Field("deleted")))).
 		Join(networks, sqlchemy.AND(sqlchemy.Equals(networks.Field("id"), guestnics.Field("network_id")),
-			sqlchemy.IsFalse(networks.Field("deleted")))).
+		sqlchemy.IsFalse(networks.Field("deleted")))).
 		Filter(sqlchemy.Equals(guests.Field("name"), name)).
 		Filter(sqlchemy.NotEquals(guestnics.Field("ip_addr"), "")).
 		Filter(sqlchemy.IsNotNull(guestnics.Field("ip_addr"))).
@@ -3306,7 +3319,7 @@ func (manager *SGuestManager) getIpsByExit(ips []string, isExitOnly bool) []stri
 }
 
 func (manager *SGuestManager) getExpiredPendingDeleteGuests() []SGuest {
-	deadline := time.Now().Add(time.Duration(options.Options.PendingDeleteExpireSeconds*-1) * time.Second)
+	deadline := time.Now().Add(time.Duration(options.Options.PendingDeleteExpireSeconds * -1) * time.Second)
 
 	q := manager.Query()
 	q = q.IsTrue("pending_deleted").LT("pending_deleted_at", deadline).Limit(options.Options.PendingDeleteMaxCleanBatchSize)
@@ -3332,7 +3345,7 @@ func (manager *SGuestManager) CleanPendingDeleteServers(ctx context.Context, use
 }
 
 func (manager *SGuestManager) getExpiredPrepaidGuests() []SGuest {
-	deadline := time.Now().Add(time.Duration(options.Options.PrepaidExpireCheckSeconds*-1) * time.Second)
+	deadline := time.Now().Add(time.Duration(options.Options.PrepaidExpireCheckSeconds * -1) * time.Second)
 
 	q := manager.Query()
 	q = q.Equals("billing_type", BILLING_TYPE_PREPAID).LT("expired_at", deadline).Limit(options.Options.ExpiredPrepaidMaxCleanBatchSize)

pkg/compute/models/host_recycle.go

@@ -16,6 +16,8 @@ import (
 	"yunion.io/x/onecloud/pkg/httperrors"
 	"yunion.io/x/onecloud/pkg/mcclient"
 	"yunion.io/x/onecloud/pkg/util/logclient"
+	"github.com/golang-plus/errors"
+	"yunion.io/x/onecloud/pkg/cloudprovider"
 )
 
 func (self *SHost) GetResourceType() string {
@@ -174,15 +176,57 @@ func (self *SGuest) doPrepaidRecycleNoLock(ctx context.Context, userCred mcclien
 		}
 	}
 
+	storageSize := 0
+	var externalId string
 	for i := 0; i < len(guestdisks); i += 1 {
-		err = fakeHost.Attach2Storage(ctx, userCred, guestdisks[i].GetDisk().GetStorage(), "")
-		if err != nil {
-			log.Errorf("fail to addStorage %d: %s", i, err)
-			fakeHost.RealDelete(ctx, userCred)
-			return err
+		disk :=  guestdisks[i].GetDisk()
+		storage := disk.GetStorage()
+		if disk.BillingType == BILLING_TYPE_PREPAID {
+			storageSize += disk.DiskSize
+			if len(externalId) == 0 {
+				externalId = storage.ExternalId
+			} else {
+				if externalId != storage.ExternalId {
+					msg := "inconsistent storage !!!!"
+					log.Errorf(msg)
+					return errors.New(msg)
+				}
+			}
 		}
 	}
 
+	sysStorage := guestdisks[0].GetDisk().GetStorage()
+
+	fakeStorage := SStorage{}
+	fakeStorage.SetModelManager(StorageManager)
+
+	fakeStorage.Name = fmt.Sprintf("%s-storage", self.Name)
+	fakeStorage.Capacity = storageSize
+	fakeStorage.StorageType = STORAGE_LOCAL
+	fakeStorage.MediumType = sysStorage.MediumType
+	fakeStorage.Cmtbound = 1.0
+	fakeStorage.ZoneId = fakeHost.ZoneId
+	fakeStorage.StoragecacheId = sysStorage.StoragecacheId
+	fakeStorage.Enabled = true
+	fakeStorage.Status = STORAGE_ONLINE
+	fakeStorage.Description = "fake storage for prepaid vm recycling"
+	fakeStorage.IsEmulated = true
+	fakeStorage.ManagerId = sysStorage.ManagerId
+	fakeStorage.ExternalId = externalId
+
+	err = StorageManager.TableSpec().Insert(&fakeStorage)
+	if err != nil {
+		log.Errorf("fail to insert fake storage %s", err)
+		return err
+	}
+
+	err = fakeHost.Attach2Storage(ctx, userCred, &fakeStorage, "")
+	if err != nil {
+		log.Errorf("fail to add fake storage: %s", err)
+		fakeHost.RealDelete(ctx, userCred)
+		return err
+	}
+
 	_, err = self.GetModelManager().TableSpec().Update(self, func() error {
 		// clear billing information
 		self.BillingType = BILLING_TYPE_POSTPAID
@@ -199,6 +243,25 @@ func (self *SGuest) doPrepaidRecycleNoLock(ctx context.Context, userCred mcclien
 		return err
 	}
 
+	for i := 0; i < len(guestdisks); i += 1 {
+		disk := guestdisks[i].GetDisk()
+
+		if disk.BillingType == BILLING_TYPE_PREPAID {
+			_, err = disk.GetModelManager().TableSpec().Update(disk, func() error {
+				disk.BillingType = BILLING_TYPE_POSTPAID
+				disk.BillingCycle = ""
+				disk.ExpiredAt = time.Time{}
+				disk.StorageId = fakeStorage.Id
+				return nil
+			})
+			if err != nil {
+				log.Errorf("clear billing information for %d %s disk fail: %s", i, disk.DiskType, err)
+				fakeHost.RealDelete(ctx, userCred)
+				return err
+			}
+		}
+	}
+
 	return nil
 }
 
@@ -268,9 +331,20 @@ func (self *SHost) PerformUndoPrepaidRecycle(ctx context.Context, userCred mccli
 	return nil, nil
 }
 
+func findIdiskById(idisks []cloudprovider.ICloudDisk, uuid string) cloudprovider.ICloudDisk {
+	for i := 0; i < len(idisks); i += 1 {
+		if idisks[i].GetGlobalId() == uuid {
+			return idisks[i]
+		}
+	}
+	return nil
+}
+
 func doUndoPrepaidRecycle(ctx context.Context, userCred mcclient.TokenCredential, host *SHost, server *SGuest) error {
 	if host.RealExternalId != server.ExternalId {
-		return fmt.Errorf("host and server external id not match!!!!")
+		msg := "host and server external id not match!!!!"
+		log.Errorf(msg)
+		return errors.New(msg)
 	}
 
 	q := HostManager.Query()
@@ -281,10 +355,14 @@ func doUndoPrepaidRecycle(ctx context.Context, userCred mcclient.TokenCredential
 	oHostCnt := q.Count()
 
 	if oHostCnt == 0 {
-		return fmt.Errorf("orthordox host not found???")
+		msg := "orthordox host not found???"
+		log.Errorf(msg)
+		return errors.New(msg)
 	}
 	if oHostCnt > 1 {
-		return fmt.Errorf("more than 1 (%d) orthordox host found???", oHostCnt)
+		msg := fmt.Sprintf("more than 1 (%d) orthordox host found???", oHostCnt)
+		log.Errorf(msg)
+		return errors.New(msg)
 	}
 
 	oHost := SHost{}
@@ -292,7 +370,30 @@ func doUndoPrepaidRecycle(ctx context.Context, userCred mcclient.TokenCredential
 
 	err := q.First(&oHost)
 	if err != nil {
-		return fmt.Errorf("fail to query orthordox host %s", err)
+		msg := fmt.Sprintf("fail to query orthordox host %s", err)
+		log.Errorf(msg)
+		return errors.New(msg)
+	}
+
+	iHost, err := oHost.GetIHost()
+	if err != nil {
+		msg := fmt.Sprint("fail to find ihost %s", err)
+		log.Errorf(msg)
+		return errors.New(msg)
+	}
+
+	iVM, err := iHost.GetIVMById(server.ExternalId)
+	if err != nil {
+		msg := fmt.Sprintf("fail to GetIVMById %s", err)
+		log.Errorf(msg)
+		return errors.New(msg)
+	}
+
+	idisks, err := iVM.GetIDisks()
+	if err != nil {
+		msg := fmt.Sprintf("iVM.GetIDisks fail %s", err)
+		log.Errorf(msg)
+		return errors.New(msg)
 	}
 
 	_, err = server.GetModelManager().TableSpec().Update(server, func() error {
@@ -309,6 +410,46 @@ func doUndoPrepaidRecycle(ctx context.Context, userCred mcclient.TokenCredential
 		return err
 	}
 
+	guestdisks := server.GetDisks()
+
+	for i := 0; i < len(guestdisks); i += 1 {
+		disk := guestdisks[i].GetDisk()
+		storage := disk.GetStorage()
+		idisk := findIdiskById(idisks, disk.ExternalId)
+		if idisk == nil {
+			msg := fmt.Sprintf("fail to find idisk by ID %s: %s", disk.ExternalId, err)
+			log.Errorf(msg)
+			return errors.New(msg)
+		}
+		istorage, err := idisk.GetIStorage()
+		if err != nil {
+			log.Errorf("idisk.GetIStorage fail %s", err)
+			return err
+		}
+
+		oStorageObj, err := StorageManager.FetchByExternalId(istorage.GetGlobalId())
+		if err != nil {
+			log.Errorf("StorageManager.FetchByExternalId fail %s", err)
+			return err
+		}
+
+		oStorage := oStorageObj.(*SStorage)
+
+		if storage.StorageType == STORAGE_LOCAL {
+			_, err = disk.GetModelManager().TableSpec().Update(disk, func() error {
+				disk.BillingType = BILLING_TYPE_PREPAID
+				disk.BillingCycle = host.BillingCycle
+				disk.ExpiredAt = host.ExpiredAt
+				disk.StorageId = oStorage.Id
+				return nil
+			})
+			if err != nil {
+				log.Errorf("fail to recover prepaid disk info %s", err)
+				return err
+			}
+		}
+	}
+
 	err = host.RealDelete(ctx, userCred)
 	if err != nil {
 		log.Errorf("fail to delete fake host")
@@ -398,11 +539,11 @@ func (host *SHost) SetGuestCreateNetworkAndDiskParams(ctx context.Context, userC
 	params.Set(fmt.Sprintf("net.%d", netIdx), jsonutils.JSONNull)
 
 	for i := 0; i < len(idisks); i += 1 {
-		istorage, err := idisks[i].GetIStorage()
+		/*istorage, err := idisks[i].GetIStorage()
 		if err != nil {
 			log.Errorf("idisks[i].GetIStorage fail %s", err)
 			return nil, err
-		}
+		}*/
 
 		key := fmt.Sprintf("disk.%d", i)
 		jsonConf, _ := params.Get(key)
@@ -413,10 +554,10 @@ func (host *SHost) SetGuestCreateNetworkAndDiskParams(ctx context.Context, userC
 				return nil, err
 			}
 			conf.SizeMb = idisks[i].GetDiskSizeMB()
-			conf.Backend = istorage.GetStorageType()
+			conf.Backend = STORAGE_LOCAL
 			params.Set(key, jsonutils.Marshal(conf))
 		} else {
-			strConf := fmt.Sprintf("%s:%d", istorage.GetStorageType(), idisks[i].GetDiskSizeMB())
+			strConf := fmt.Sprintf("%s:%d", STORAGE_LOCAL, idisks[i].GetDiskSizeMB())
 			conf, err := parseDiskInfo(ctx, userCred, jsonutils.NewString(strConf))
 			if err != nil {
 				return nil, err

pkg/compute/models/storages.go

@@ -857,7 +857,7 @@ type StoragesCapacityStat struct {
 	Capacity         int64
 	CapacityVirtual  float64
 	CapacityUsed     int64
-	CapacityUnread   int64
+	CapacityUnready  int64
 	AttachedCapacity int64
 	DetachedCapacity int64
 }
@@ -891,7 +891,7 @@ func (manager *SStorageManager) calculateCapacity(q *sqlchemy.SQuery) StoragesCa
 		Capacity:         tCapa,
 		CapacityVirtual:  tVCapa,
 		CapacityUsed:     tUsed,
-		CapacityUnread:   tFailed,
+		CapacityUnready:  tFailed,
 		AttachedCapacity: atCapa,
 		DetachedCapacity: dtCapa,
 	}

pkg/compute/usages/handler.go

@@ -207,8 +207,6 @@ func getAdminGeneralUsage(userCred mcclient.TokenCredential, rangeObj db.IStanda
 		count.Add("cpu.virtual", host.GetVirtualCPUCount())
 	}
 
-	prepaidHostEnabledUsage := HostEnabledUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers)
-
 	guestRunningUsage := GuestRunningUsage("all.running_servers", nil, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers)
 	runningMem := guestRunningUsage.Get("all.running_servers.memory").(int)
 	runningCpu := guestRunningUsage.Get("all.running_servers.cpu").(int)
@@ -230,37 +228,48 @@ func getAdminGeneralUsage(userCred mcclient.TokenCredential, rangeObj db.IStanda
 	count.Add("all.cpu_commit_rate.running", runningCpuCmtRate)
 
 	storageUsage := StorageUsage("", rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers)
-	storageCmtRate := 0.0
-	disksSize := storageUsage.Get("all.disks").(int64)
-	storageSize := storageUsage.Get("storages").(int64)
-	if storageSize > 0 {
-		storageCmtRate = utils.FloatRound(float64(disksSize)/float64(storageSize), 2)
-	}
-	count.Add("storages_commit_rate", storageCmtRate)
-
-	prepaidStorageUsage := StorageUsage("prepaid_pool", rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers)
 
 	count.Include(
 		HostAllUsage("", userCred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
 		HostAllUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		HostAllUsage("any_pool", userCred, rangeObj, hostTypes, nil, providers),
+
 		hostEnabledUsage,
-		prepaidHostEnabledUsage,
+		HostEnabledUsage("prepaid_pool", userCred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		HostEnabledUsage("any_pool", userCred, rangeObj, hostTypes, nil, providers),
+
 		BaremetalUsage(userCred, rangeObj, hostTypes, providers),
+
 		storageUsage,
-		prepaidStorageUsage,
+		StorageUsage("prepaid_pool", rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		StorageUsage("any_pool", rangeObj, hostTypes, nil, providers),
+
 		GuestNormalUsage("all.servers", nil, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
 		GuestNormalUsage("all.servers.prepaid_pool", nil, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestNormalUsage("all.servers.any_pool", nil, rangeObj, hostTypes, nil, providers),
+
 		GuestPendingDeleteUsage("all.pending_delete_servers", nil, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
 		GuestPendingDeleteUsage("all.pending_delete_servers.prepaid_pool", nil, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestPendingDeleteUsage("all.pending_delete_servers.any_pool", nil, rangeObj, hostTypes, nil, providers),
+
 		GuestReadyUsage("all.ready_servers", nil, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
 		GuestReadyUsage("all.ready_servers.prepaid_pool", nil, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestReadyUsage("all.ready_servers.any_pool", nil, rangeObj, hostTypes, nil, providers),
+
 		guestRunningUsage,
 		GuestRunningUsage("all.running_servers.prepaid_pool", nil, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestRunningUsage("all.running_servers.any_pool", nil, rangeObj, hostTypes, nil, providers),
+
 		containerRunningUsage,
+
 		IsolatedDeviceUsage("", rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
 		IsolatedDeviceUsage("prepaid_pool", rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		IsolatedDeviceUsage("any_pool", rangeObj, hostTypes, nil, providers),
+
 		WireUsage(rangeObj, hostTypes, providers),
+
 		EipUsage("", rangeObj, providers),
+
 		SnapshotUsage("", rangeObj, providers),
 	)
 
@@ -269,16 +278,6 @@ func getAdminGeneralUsage(userCred mcclient.TokenCredential, rangeObj db.IStanda
 
 func getCommonGeneralUsage(cred mcclient.TokenCredential, rangeObj db.IStandaloneModel, hostTypes []string, providers []string) (count Usage, err error) {
 	guestNormalUsage := GuestNormalUsage("servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers)
-	prepaidGuestNormalUsage := GuestNormalUsage("servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers)
-
-	guestRunningUsage := GuestRunningUsage("running_servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers)
-	prepaidGuestRunningUsage := GuestRunningUsage("running_servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers)
-
-	guestPendingDeleteUsage := GuestPendingDeleteUsage("pending_delete_servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers)
-	prepaidGuestPendingDeleteUsage := GuestPendingDeleteUsage("pending_delete_servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers)
-
-	guestReadyUsage := GuestReadyUsage("ready_servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers)
-	prepaidGuestReadyUsage := GuestReadyUsage("ready_servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers)
 
 	containerUsage := containerUsage("containers", cred, rangeObj, hostTypes, nil, providers)
 
@@ -287,16 +286,20 @@ func getCommonGeneralUsage(cred mcclient.TokenCredential, rangeObj db.IStandalon
 	snapshotUsage := SnapshotUsage(cred.GetProjectId(), rangeObj, providers)
 
 	count = guestNormalUsage.Include(
-		prepaidGuestNormalUsage,
+		GuestNormalUsage("servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestNormalUsage("servers.any_pool", cred, rangeObj, hostTypes, nil, providers),
 
-		guestRunningUsage,
-		prepaidGuestRunningUsage,
+		GuestRunningUsage("running_servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
+		GuestRunningUsage("running_servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestRunningUsage("running_servers.any_pool", cred, rangeObj, hostTypes, nil, providers),
 
-		guestPendingDeleteUsage,
-		prepaidGuestPendingDeleteUsage,
+		GuestPendingDeleteUsage("pending_delete_servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
+		GuestPendingDeleteUsage("pending_delete_servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestPendingDeleteUsage("pending_delete_servers.any_pool", cred, rangeObj, hostTypes, nil, providers),
 
-		guestReadyUsage,
-		prepaidGuestReadyUsage,
+		GuestReadyUsage("ready_servers", cred, rangeObj, hostTypes, []string{models.HostResourceTypeShared}, providers),
+		GuestReadyUsage("ready_servers.prepaid_pool", cred, rangeObj, hostTypes, []string{models.HostResourceTypePrepaidRecycle}, providers),
+		GuestReadyUsage("ready_servers.any_pool", cred, rangeObj, hostTypes, nil, providers),
 
 		containerUsage,
 
@@ -402,9 +405,16 @@ func StorageUsage(prefix string, rangeObj db.IStandaloneModel, hostTypes []strin
 	count[sPrefix] = result.Capacity
 	count[fmt.Sprintf("%s.virtual", sPrefix)] = result.CapacityVirtual
 	count[dPrefix] = result.CapacityUsed
-	count[fmt.Sprintf("%s.unready", dPrefix)] = result.CapacityUnread
+	count[fmt.Sprintf("%s.unready", dPrefix)] = result.CapacityUnready
 	count[fmt.Sprintf("%s.attached", dPrefix)] = result.AttachedCapacity
 	count[fmt.Sprintf("%s.detached", dPrefix)] = result.DetachedCapacity
+
+	storageCmtRate := 0.0
+	if result.Capacity > 0 {
+		storageCmtRate = utils.FloatRound(float64(result.CapacityUsed)/float64(result.Capacity), 2)
+	}
+	count[fmt.Sprintf("%s.commit_rate", sPrefix)] = storageCmtRate
+
 	return count
 }
 
@@ -513,6 +523,11 @@ func guestHypervisorsUsage(
 	count[fmt.Sprintf("%s.disk", prefix)] = guest.TotalDiskSize
 	count[fmt.Sprintf("%s.isolated_devices", prefix)] = guest.TotalIsolatedCount
 
+	count[fmt.Sprintf("%s.ha", prefix)] = guest.TotalBackupGuestCount
+	count[fmt.Sprintf("%s.ha.cpu", prefix)] = guest.TotalBackupCpuCount
+	count[fmt.Sprintf("%s.ha.memory", prefix)] = guest.TotalBackupMemSize
+	count[fmt.Sprintf("%s.ha.disk", prefix)] = guest.TotalBackupDiskSize
+
 	return count
 }