aiforge/routers/repo/cloudbrain_statistic.go

package repo

import (
	"time"

	"code.gitea.io/gitea/models"
	"code.gitea.io/gitea/modules/context"
	"code.gitea.io/gitea/modules/log"
	"code.gitea.io/gitea/modules/timeutil"
)

func CloudbrainDurationStatistic() {
	log.Info("Generate Cloudbrain Duration statistic begin")
	// yesterday := time.Now().AddDate(0, 0, -1).Format("2006-01-02")
	// CloudbrainDurationStatisticHour(yesterday)
	log.Info("Generate Cloudbrain Duration statistic end")
}

func CloudbrainDurationStatisticHour(ctx *context.Context) {
	hourTime := time.Now().Hour()
	dateTime := time.Now().Format("2006-01-02 15:04:05")
	dayTime := time.Now().Format("2006-01-02")

	currentTime := time.Now()
	m, _ := time.ParseDuration("-1h")
	beginTime := currentTime.Add(m).Unix()
	endTime := currentTime.Unix()
	// fmt.Println(beginTime)

	ciTasks1, err := models.GetCloudbrainRunning()
	if err != nil {
		// ctx.ServerError("Get job failed:", err)
		log.Info("GetCloudbrainRunning err: %v", err)
		return
	}
	ciTasks2, err := models.GetCloudbrainCompleteByTime(beginTime, endTime)
	ciTasks := append(ciTasks1, ciTasks2...)
	log.Info("beginTime: %s", beginTime)
	log.Info("endTime: %s", endTime)
	if err != nil {
		// ctx.ServerError("Get job failed:", err)
		log.Info("GetCloudbrainCompleteByTime err: %v", err)
		return
	}
	models.LoadSpecs4CloudbrainInfo(ciTasks)
	log.Info("ciTasks here: %s", ciTasks)
	log.Info("count here: %s", len(ciTasks))
	cloudBrainCenterCodeAndCardTypeInfo := getcloudBrainCenterCodeAndCardTypeInfo(ciTasks, beginTime, endTime)
	for centerCode, CardTypeInfo := range cloudBrainCenterCodeAndCardTypeInfo {
		for cardType, cardDuration := range CardTypeInfo {
			cloudbrain, err := models.GetSpecByAiCenterCodeAndType(centerCode, cardType)
			if err != nil {
				log.Info("GetSpecByAiCenterCodeAndType err: %v", err)
				return
			}
			log.Info("cloudbrain: %s", cloudbrain)
			if cloudbrain != nil {
				totalUse := true
				totalCanUse := false
				if err := models.DeleteCloudbrainDurationStatisticHour(dayTime, hourTime, centerCode, cardType, totalUse, totalCanUse); err != nil {
					log.Error("DeleteCloudbrainDurationStatisticHour failed: %v", err.Error())
					return
				}
				cloudbrainDurationStat := models.CloudbrainDurationStatistic{
					DateTime:           dateTime,
					DayTime:            dayTime,
					HourTime:           hourTime,
					Cluster:            cloudbrain[0].Cluster,
					AiCenterName:       cloudbrain[0].AiCenterName,
					AiCenterCode:       centerCode,
					ComputeResource:    cloudbrain[0].ComputeResource,
					AccCardType:        cardType,
					CardsTotalDuration: cardDuration,
					CreatedTime:        timeutil.TimeStampNow(),
					TotalUse:           true,
					TotalCanUse:        false,
				}
				if _, err = models.InsertCloudbrainDurationStatistic(&cloudbrainDurationStat); err != nil {
					log.Error("Insert cloudbrainDurationStat failed: %v", err.Error())
				}
			}
		}

	}

	resourceQueues, err := models.GetCanUseCardInfo()
	if err != nil {
		log.Info("GetCanUseCardInfo err: %v", err)
		return
	}
	log.Info("resourceQueues here: %s", resourceQueues)
	for _, resourceQueue := range resourceQueues {
		totalUse := false
		totalCanUse := true
		if err := models.DeleteCloudbrainDurationStatisticHour(dayTime, hourTime, resourceQueue.AiCenterCode, resourceQueue.AccCardType, totalUse, totalCanUse); err != nil {
			log.Error("DeleteCloudbrainDurationStatisticHour failed: %v", err.Error())
			return
		}
		cardsTotalDuration := resourceQueue.CardsTotalNum * 1 * 60 * 60
		cloudbrainDurationStat := models.CloudbrainDurationStatistic{
			DateTime:           dateTime,
			DayTime:            dayTime,
			HourTime:           hourTime,
			Cluster:            resourceQueue.Cluster,
			AiCenterName:       resourceQueue.AiCenterName,
			AiCenterCode:       resourceQueue.AiCenterCode,
			ComputeResource:    resourceQueue.ComputeResource,
			AccCardType:        resourceQueue.AccCardType,
			CardsTotalDuration: cardsTotalDuration,
			CardsTotalNum:      resourceQueue.CardsTotalNum,
			CreatedTime:        timeutil.TimeStampNow(),
			TotalUse:           false,
			TotalCanUse:        true,
		}
		if _, err = models.InsertCloudbrainDurationStatistic(&cloudbrainDurationStat); err != nil {
			log.Error("Insert cloudbrainDurationStat failed: %v", err.Error())
		}
	}
	log.Info("finish summary cloudbrainDurationStat")
}

func getcloudBrainCenterCodeAndCardTypeInfo(ciTasks []*models.CloudbrainInfo, beginTime int64, endTime int64) map[string]map[string]int {
	var WorkServerNumber int
	var AccCardsNum int
	// cloudBrainCardRes := make(map[string]int)
	cloudBrainAiCenterCodeList := make(map[string]string)
	cloudBrainCardTypeList := make(map[string]string)
	cloudBrainCenterCodeAndCardType := make(map[string]map[string]int)
	for _, cloudbrain := range ciTasks {
		if _, ok := cloudBrainAiCenterCodeList[cloudbrain.Cloudbrain.Spec.AiCenterCode]; !ok {
			cloudBrainAiCenterCodeList[cloudbrain.Cloudbrain.Spec.AiCenterCode] = cloudbrain.Cloudbrain.Spec.AiCenterCode
		}

		if cloudbrain.Cloudbrain.StartTime == 0 {
			cloudbrain.Cloudbrain.StartTime = cloudbrain.Cloudbrain.CreatedUnix
		}
		if cloudbrain.Cloudbrain.EndTime == 0 {
			cloudbrain.Cloudbrain.EndTime = cloudbrain.Cloudbrain.UpdatedUnix
		}
		if cloudbrain.Cloudbrain.WorkServerNumber >= 1 {
			WorkServerNumber = cloudbrain.Cloudbrain.WorkServerNumber
		} else {
			WorkServerNumber = 1
		}
		if cloudbrain.Cloudbrain.Spec == nil {
			AccCardsNum = 1
		} else {
			AccCardsNum = cloudbrain.Cloudbrain.Spec.AccCardsNum
		}
		for k, _ := range cloudBrainAiCenterCodeList {
			if cloudBrainCenterCodeAndCardType[cloudBrainAiCenterCodeList[k]] == nil {
				cloudBrainCenterCodeAndCardType[cloudBrainAiCenterCodeList[k]] = make(map[string]int)
			}
			if cloudbrain.Cloudbrain.Spec.AiCenterCode == cloudBrainAiCenterCodeList[k] {
				if _, ok := cloudBrainCardTypeList[cloudbrain.Cloudbrain.Spec.AccCardType]; !ok {
					cloudBrainCardTypeList[cloudbrain.Cloudbrain.Spec.AccCardType] = cloudbrain.Cloudbrain.Spec.AccCardType
				}
				for i, _ := range cloudBrainCardTypeList {
					if cloudbrain.Cloudbrain.Spec.AccCardType == cloudBrainCardTypeList[i] {
						if cloudbrain.Cloudbrain.Status == string(models.ModelArtsRunning) {
							if int64(cloudbrain.Cloudbrain.StartTime) < beginTime {
								cloudBrainCenterCodeAndCardType[cloudBrainAiCenterCodeList[k]][cloudBrainCardTypeList[i]] += AccCardsNum * WorkServerNumber * (int(endTime) - int(beginTime))
							} else {
								cloudBrainCenterCodeAndCardType[cloudBrainAiCenterCodeList[k]][cloudBrainCardTypeList[i]] += AccCardsNum * WorkServerNumber * (int(endTime) - int(cloudbrain.Cloudbrain.StartTime))
							}
						} else {
							if int64(cloudbrain.Cloudbrain.StartTime) < beginTime && int64(cloudbrain.Cloudbrain.EndTime) < endTime {
								cloudBrainCenterCodeAndCardType[cloudBrainAiCenterCodeList[k]][cloudBrainCardTypeList[i]] += AccCardsNum * WorkServerNumber * (int(cloudbrain.Cloudbrain.EndTime) - int(beginTime))
							} else {
								cloudBrainCenterCodeAndCardType[cloudBrainAiCenterCodeList[k]][cloudBrainCardTypeList[i]] += AccCardsNum * WorkServerNumber * (int(cloudbrain.Cloudbrain.EndTime) - int(cloudbrain.Cloudbrain.StartTime))
							}
						}
					}
				}
			}
		}
	}

	return cloudBrainCenterCodeAndCardType
}