Merge pull request '解决云脑看板相关isuue' (#2985) from brainkanban into V20221019

Reviewed-on: https://git.openi.org.cn/OpenI/aiforge/pulls/2985
Reviewed-by: zouap <zouap@pcl.ac.cn>

models/cloudbrain.go

@@ -2281,8 +2281,7 @@ func CloudbrainAllStatic(opts *CloudbrainsOptions) ([]*CloudbrainInfo, int64, er
 	}
 	sess.OrderBy("cloudbrain.created_unix DESC")
 	cloudbrains := make([]*CloudbrainInfo, 0, setting.UI.IssuePagingNum)
-	if err := sess.Cols("status", "type", "job_type", "train_job_duration", "duration", "compute_resource",
-		"created_unix", "start_time", "end_time").Table(&Cloudbrain{}).Unscoped().Where(cond).
+	if err := sess.Table(&Cloudbrain{}).Unscoped().Where(cond).
 		Find(&cloudbrains); err != nil {
 		return nil, 0, fmt.Errorf("Find: %v", err)
 	}

models/cloudbrain_static.go

@@ -34,6 +34,7 @@ type TaskDetail struct {
 	CardDuration    string             `json:"CardDuration"`
 	AiCenter        string             `json:"AiCenter"`
 	FlavorName      string             `json:"FlavorName"`
+	WorkServerNum   int64              `json:"WorkServerNum"`
 	Spec            *Specification     `json:"Spec"`
 }
 
@@ -44,16 +45,45 @@ func GetTodayCreatorCount(beginTime time.Time, endTime time.Time) (int64, error)
 	return x.SQL(countSql).Count()
 }
 func GetTodayCloudbrainCount(beginTime time.Time, endTime time.Time) (int64, error) {
-	countSql := "SELECT count FROM  " +
+	countSql := "SELECT count(*) FROM  " +
 		"public.cloudbrain where created_unix >=" + strconv.FormatInt(beginTime.Unix(), 10) +
 		" and created_unix<=" + strconv.FormatInt(endTime.Unix(), 10)
 	return x.SQL(countSql).Count()
 }
+func GetTodayRunningCount(beginTime time.Time, endTime time.Time) (int64, error) {
+	countSql := "SELECT count(*) FROM  " +
+		"public.cloudbrain where created_unix >=" + strconv.FormatInt(beginTime.Unix(), 10) +
+		" and created_unix<=" + strconv.FormatInt(endTime.Unix(), 10) + " and (status='" + string(JobRunning) + "'" +
+		" or status='" + string(ModelArtsTrainJobInit) + "')"
+	return x.SQL(countSql).Count()
+}
+func GetTodayWaitingCount(beginTime time.Time, endTime time.Time) (int64, error) {
+	countSql := "SELECT count(*) FROM  " +
+		"public.cloudbrain where created_unix >=" + strconv.FormatInt(beginTime.Unix(), 10) +
+		" and created_unix<=" + strconv.FormatInt(endTime.Unix(), 10) + " and status='" + string(JobWaiting) + "'"
+	return x.SQL(countSql).Count()
+}
+
 func GetCreatorCount() (int64, error) {
 	countSql := "SELECT count(distinct user_id) FROM  public.cloudbrain"
 	return x.SQL(countSql).Count()
 }
 
+func GetCloudbrainTypeCount() ([]map[string]string, error) {
+	countSql := "SELECT type,count(*) num FROM public.cloudbrain group by type order by num desc"
+	return x.QueryString(countSql)
+}
+
+func GetCloudbrainStatusCount() ([]map[string]string, error) {
+	countSql := "SELECT status,count(*) num FROM public.cloudbrain group by status order by num desc"
+	return x.QueryString(countSql)
+}
+
+func GetCloudbrainTpyeDurationSum() ([]map[string]string, error) {
+	countSql := "SELECT type,sum(duration) FROM public.cloudbrain group by type order by sum(duration) desc"
+	return x.QueryString(countSql)
+}
+
 func GetRecordBeginTime() ([]*CloudbrainInfo, error) {
 	sess := x.NewSession()
 	defer sess.Close()

routers/admin/cloudbrains.go

@@ -98,8 +98,6 @@ func CloudBrains(ctx *context.Context) {
 		ciTasks[i].CanDebug = true
 		ciTasks[i].CanDel = true
 		ciTasks[i].Cloudbrain.ComputeResource = task.ComputeResource
-		ciTasks[i].Cloudbrain.AiCenter = repo.GetCloudbrainAiCenter(task.Cloudbrain, ctx)
-		ciTasks[i].Cloudbrain.Cluster = repo.GetCloudbrainCluster(task.Cloudbrain, ctx)
 	}
 
 	pager := context.NewPagination(int(count), setting.UI.IssuePagingNum, page, getTotalPage(count, setting.UI.IssuePagingNum))
@@ -179,6 +177,7 @@ func DownloadCloudBrains(ctx *context.Context) {
 			log.Warn("Can not get cloud brain info", err)
 			continue
 		}
+		models.LoadSpecs4CloudbrainInfo(pageRecords)
 		for _, record := range pageRecords {
 
 			for k, v := range allValues(row, record, ctx) {
@@ -208,8 +207,11 @@ func allValues(row int, rs *models.CloudbrainInfo, ctx *context.Context) map[str
 }
 
 func getCloudbrainCardType(rs *models.CloudbrainInfo) string {
-	_, cardType, _ := repo.GetCloudbrainCardNumAndType(rs.Cloudbrain)
-	return cardType
+	if rs.Cloudbrain.Spec != nil {
+		return rs.Cloudbrain.Spec.AccCardType
+	} else {
+		return ""
+	}
 }
 
 func getRepoPathName(rs *models.CloudbrainInfo) string {

routers/api/v1/api.go

@@ -590,6 +590,7 @@ func RegisterRoutes(m *macaron.Macaron) {
 			m.Get("/downloadAll", repo.DownloadCloudBrainBoard)
 			m.Group("/cloudbrain", func() {
 				m.Get("/overview", repo.GetAllCloudbrainsOverview)
+				m.Get("/overview_duration", repo.GetOverviewDuration)
 				m.Get("/distribution", repo.GetAllCloudbrainsPeriodDistribution)
 				m.Get("/trend", repo.GetAllCloudbrainsTrend)
 				m.Get("/trend_detail_data", repo.GetAllCloudbrainsTrendDetail)

routers/api/v1/repo/cloudbrain_dashboard.go

@@ -19,6 +19,7 @@ type DateCloudbrainNum struct {
 	CloudOneJobTypeRes        map[string]int `json:"cloudOneJobTypeRes"`
 	CloudTwoJobTypeRes        map[string]int `json:"cloudTwoJobTypeRes"`
 	IntelligentNetJobTypeRes  map[string]int `json:"intelligentNetJobTypeRes"`
+	CDCenterJobTypeRes        map[string]int `json:"cDCenterJobTypeRes"`
 	CloudBrainPeriodNum       map[int]int    `json:"cloudBrainPeriodNum"`
 	CloudBrainComputeResource map[string]int `json:"cloudBrainComputeResource"`
 }
@@ -53,20 +54,90 @@ func GetAllCloudbrainsOverview(ctx *context.Context) {
 		log.Error("Can not query todayCreatorCount.", err)
 		return
 	}
+	cloudbrainTypeCount, err := models.GetCloudbrainTypeCount()
+	log.Info("cloudbrainTypeCount:", cloudbrainTypeCount)
+	if err != nil {
+		log.Error("Can not query cloudbrainTypeCount.", err)
+		return
+	}
+
+	cloudbrainTpyeDurationSum, err := models.GetCloudbrainTpyeDurationSum()
+	log.Info("cloudbrainTpyeDurationSum:", cloudbrainTpyeDurationSum)
+	if err != nil {
+		log.Error("Can not query cloudbrainTpyeDurationSum.", err)
+		return
+	}
+
+	todayCloudbrainCount, err := models.GetTodayCloudbrainCount(beginTime, endTime)
+	log.Info("todayCloudbrainCount:", todayCloudbrainCount)
+	if err != nil {
+		log.Error("Can not query todayCloudbrainCount.", err)
+		return
+	}
+
+	todayRunningCount, err := models.GetTodayRunningCount(beginTime, endTime)
+	log.Info("todayRunningCount:", todayRunningCount)
+	if err != nil {
+		log.Error("Can not query todayRunningCount.", err)
+		return
+	}
+
+	todayWaitingCount, err := models.GetTodayWaitingCount(beginTime, endTime)
+	log.Info("todayWaittingCount:", todayWaitingCount)
+	if err != nil {
+		log.Error("Can not query todayWaitingCount.", err)
+		return
+	}
+
+	todayCompletedCount := todayCloudbrainCount - todayRunningCount - todayWaitingCount
+	log.Info("todayCompletedCount:", todayCompletedCount)
+
 	creatorCount, err := models.GetCreatorCount()
 	if err != nil {
 		log.Error("Can not query creatorCount.", err)
 		return
 	}
-	todayStatusResult := make(map[string]int)
-	cloudBrainNum := make(map[int]int)
-	cloudBrainOneDuration := int64(0)
-	cloudBrainTwoDuration := int64(0)
-	intelligentNetDuration := int64(0)
-	todayNewJobCount := 0
+
+	ctx.JSON(http.StatusOK, map[string]interface{}{
+		"recordBeginTime":     recordBeginTime,
+		"updateTime":          now.Unix(),
+		"todayCreatorCount":   todayCreatorCount,
+		"creatorCount":        creatorCount,
+		"todayRunningCount":   todayRunningCount,
+		"todayCompletedCount": todayCompletedCount,
+		"todayWaitingCount":   todayWaitingCount,
+		"todayNewJobCount":    todayCloudbrainCount,
+		"cloudbrainTypeCount": cloudbrainTypeCount,
+	})
+}
+func GetOverviewDuration(ctx *context.Context) {
+	recordCloudbrain, err := models.GetRecordBeginTime()
+	if err != nil {
+		log.Error("Can not get recordCloudbrain", err)
+		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
+		return
+	}
+	recordBeginTime := recordCloudbrain[0].Cloudbrain.CreatedUnix
+	now := time.Now()
+	endTime := now
 	page := 1
-	pagesize := 1000
+	pagesize := 10000
 	count := pagesize
+	worker_server_num := 1
+	cardNum := 1
+	durationAllSum := int64(0)
+	cardDuSum := int64(0)
+
+	cloudBrainOneCardDuSum := int64(0)
+	cloudBrainTwoCardDuSum := int64(0)
+	c2NetCardDuSum := int64(0)
+	cDNetCardDuSum := int64(0)
+
+	cloudBrainOneDuration := int64(0)
+	cloudBrainTwoDuration := int64(0)
+	c2NetDuration := int64(0)
+	cDCenterDuration := int64(0)
+
 	for count == pagesize && count != 0 {
 		cloudbrains, _, err := models.CloudbrainAllStatic(&models.CloudbrainsOptions{
 			ListOptions: models.ListOptions{
@@ -81,72 +152,53 @@ func GetAllCloudbrainsOverview(ctx *context.Context) {
 			ctx.ServerError("Get cloudbrains failed:", err)
 			return
 		}
+		models.LoadSpecs4CloudbrainInfo(cloudbrains)
 
 		for _, cloudbrain := range cloudbrains {
-			if int64(cloudbrain.Cloudbrain.CreatedUnix) >= beginTime.Unix() && int64(cloudbrain.Cloudbrain.CreatedUnix) < endTime.Unix() {
-				todayNewJobCount += 1
-				if _, ok := todayStatusResult[cloudbrain.Status]; !ok {
-					todayStatusResult[cloudbrain.Status] = 1
-				} else {
-					todayStatusResult[cloudbrain.Status] += 1
-				}
+			if cloudbrain.Cloudbrain.WorkServerNumber >= 1 {
+				worker_server_num = cloudbrain.Cloudbrain.WorkServerNumber
+			} else {
+				worker_server_num = 1
 			}
-
-			if _, ok := cloudBrainNum[cloudbrain.Cloudbrain.Type]; !ok {
-				cloudBrainNum[cloudbrain.Cloudbrain.Type] = 1
+			if cloudbrain.Cloudbrain.Spec == nil {
+				cardNum = 1
 			} else {
-				cloudBrainNum[cloudbrain.Cloudbrain.Type] += 1
+				cardNum = cloudbrain.Cloudbrain.Spec.AccCardsNum
 			}
-
+			duration := cloudbrain.Duration
+			durationSum := cloudbrain.Duration * int64(worker_server_num) * int64(cardNum)
 			if cloudbrain.Cloudbrain.Type == models.TypeCloudBrainOne {
-				cloudBrainOneDuration = cloudBrainOneDuration + cloudbrain.Cloudbrain.Duration
-			}
-			if cloudbrain.Cloudbrain.Type == models.TypeCloudBrainTwo {
-				cloudBrainTwoDuration = cloudBrainTwoDuration + cloudbrain.Cloudbrain.Duration
+				cloudBrainOneDuration += duration
+				cloudBrainOneCardDuSum += durationSum
+			} else if cloudbrain.Cloudbrain.Type == models.TypeCloudBrainTwo {
+				cloudBrainTwoDuration += duration
+				cloudBrainTwoCardDuSum += durationSum
+			} else if cloudbrain.Cloudbrain.Type == models.TypeC2Net {
+				c2NetDuration += duration
+				c2NetCardDuSum += durationSum
+			} else if cloudbrain.Cloudbrain.Type == models.TypeCDCenter {
+				cDCenterDuration += duration
+				cDNetCardDuSum += durationSum
 			}
-			if cloudbrain.Cloudbrain.Type == models.TypeC2Net {
-				intelligentNetDuration = intelligentNetDuration + cloudbrain.Cloudbrain.Duration
-			}
-
-		}
-		count = len(cloudbrains)
-		page += 1
-	}
 
-	statusNameList := []string{string(models.ModelArtsTrainJobCompleted), string(models.JobFailed), string(models.ModelArtsTrainJobInit),
-		string(models.JobRunning), string(models.ModelArtsStartFailed), string(models.JobStopped), string(models.JobSucceeded),
-		string(models.JobWaiting), string(models.ModelArtsTrainJobKilled)}
-	for _, v := range statusNameList {
-		if _, ok := todayStatusResult[v]; !ok {
-			todayStatusResult[v] = 0
-		}
-	}
-
-	cloudBrainTypeList := []int{0, 1, 2}
-	for _, v := range cloudBrainTypeList {
-		if _, ok := cloudBrainNum[v]; !ok {
-			cloudBrainNum[v] = 0
+			durationAllSum += duration
+			cardDuSum += durationSum
+			count = len(cloudbrains)
+			page += 1
 		}
 	}
-
-	todayRunningCount := todayStatusResult[string(models.JobRunning)]
-	todayCompletedCount := todayStatusResult[string(models.ModelArtsTrainJobCompleted)] + todayStatusResult[string(models.JobFailed)] +
-		todayStatusResult[string(models.ModelArtsStartFailed)] + todayStatusResult[string(models.JobStopped)] + todayStatusResult[string(models.JobSucceeded)] + todayStatusResult[string(models.ModelArtsTrainJobKilled)]
-	todayWaitingCount := todayStatusResult[string(models.ModelArtsTrainJobInit)] + todayStatusResult[string(models.JobWaiting)]
-
 	ctx.JSON(http.StatusOK, map[string]interface{}{
-		"recordBeginTime":        recordBeginTime,
-		"updateTime":             now.Unix(),
-		"cloudBrainNum":          cloudBrainNum,
-		"cloudBrainOneDuration":  cloudBrainOneDuration,
-		"cloudBrainTwoDuration":  cloudBrainTwoDuration,
-		"intelligentNetDuration": intelligentNetDuration,
-		"todayCreatorCount":      todayCreatorCount,
-		"creatorCount":           creatorCount,
-		"todayRunningCount":      todayRunningCount,
-		"todayCompletedCount":    todayCompletedCount,
-		"todayWaitingCount":      todayWaitingCount,
-		"todayNewJobCount":       todayNewJobCount,
+		"cloudBrainOneCardDuSum": cloudBrainOneCardDuSum,
+		"cloudBrainTwoCardDuSum": cloudBrainTwoCardDuSum,
+		"c2NetCardDuSum":         c2NetCardDuSum,
+		"cDNetCardDuSum":         cDNetCardDuSum,
+		"cardDuSum":              cardDuSum,
+
+		"cloudBrainOneDuration": cloudBrainOneDuration,
+		"cloudBrainTwoDuration": cloudBrainTwoDuration,
+		"c2NetDuration":         c2NetDuration,
+		"cDCenterDuration":      cDCenterDuration,
+		"durationSum":           durationAllSum,
 	})
 }
 
@@ -500,6 +552,7 @@ func GetAllCloudbrainsPeriodDistribution(ctx *context.Context) {
 	cloudOneJobTypeRes := make(map[string]int)
 	cloudTwoJobTypeRes := make(map[string]int)
 	intelligentNetJobTypeRes := make(map[string]int)
+	cDCenterJobTypeRes := make(map[string]int)
 	cloudBrainPeriodNum := make(map[int]int)
 	cloudBrainComputeResource := make(map[string]int)
 	beginTimeTemp := beginTime.Unix()
@@ -508,9 +561,9 @@ func GetAllCloudbrainsPeriodDistribution(ctx *context.Context) {
 	}
 
 	page := 1
-	pagesize := 1000
+	pagesize := 10000
 	count := pagesize
-	//Each time a maximum of 1000 pieces of data are detected to the memory, batch processing
+	//Each time a maximum of 10000 pieces of data are detected to the memory, batch processing
 	for count == pagesize && count != 0 {
 		cloudbrains, _, err := models.CloudbrainAllStatic(&models.CloudbrainsOptions{
 			ListOptions: models.ListOptions{
@@ -548,6 +601,13 @@ func GetAllCloudbrainsPeriodDistribution(ctx *context.Context) {
 					intelligentNetJobTypeRes[cloudbrain.JobType] += 1
 				}
 			}
+			if cloudbrain.Cloudbrain.Type == models.TypeCDCenter {
+				if _, ok := cDCenterJobTypeRes[cloudbrain.JobType]; !ok {
+					cDCenterJobTypeRes[cloudbrain.JobType] = 1
+				} else {
+					cDCenterJobTypeRes[cloudbrain.JobType] += 1
+				}
+			}
 
 			if _, ok := cloudBrainPeriodNum[cloudbrain.Cloudbrain.Type]; !ok {
 				cloudBrainPeriodNum[cloudbrain.Cloudbrain.Type] = 1
@@ -577,8 +637,11 @@ func GetAllCloudbrainsPeriodDistribution(ctx *context.Context) {
 		if _, ok := intelligentNetJobTypeRes[v]; !ok {
 			intelligentNetJobTypeRes[v] = 0
 		}
+		if _, ok := cDCenterJobTypeRes[v]; !ok {
+			cDCenterJobTypeRes[v] = 0
+		}
 	}
-	cloudBrainTypeList := []int{0, 1, 2}
+	cloudBrainTypeList := []int{0, 1, 2, 3}
 	for _, v := range cloudBrainTypeList {
 		if _, ok := cloudBrainPeriodNum[v]; !ok {
 			cloudBrainPeriodNum[v] = 0
@@ -592,77 +655,30 @@ func GetAllCloudbrainsPeriodDistribution(ctx *context.Context) {
 		}
 	}
 
-	cloudOneJobTypeRes["EVALUATION"] = cloudOneJobTypeRes[string(models.JobTypeBenchmark)] + cloudOneJobTypeRes[string(models.JobTypeSnn4imagenet)] + cloudOneJobTypeRes[string(models.JobTypeBrainScore)]
-	cloudTwoJobTypeRes["EVALUATION"] = cloudTwoJobTypeRes[string(models.JobTypeBenchmark)] + cloudTwoJobTypeRes[string(models.JobTypeSnn4imagenet)] + cloudTwoJobTypeRes[string(models.JobTypeBrainScore)]
-	intelligentNetJobTypeRes["EVALUATION"] = intelligentNetJobTypeRes[string(models.JobTypeBenchmark)] + intelligentNetJobTypeRes[string(models.JobTypeSnn4imagenet)] + intelligentNetJobTypeRes[string(models.JobTypeBrainScore)]
+	cloudOneJobTypeRes["EVALUATION"] = cloudBrainPeriodNum[0] - cloudOneJobTypeRes[string(models.JobTypeTrain)] - cloudOneJobTypeRes[string(models.JobTypeInference)] - cloudOneJobTypeRes[string(models.JobTypeDebug)]
+	cloudTwoJobTypeRes["EVALUATION"] = cloudBrainPeriodNum[1] - cloudTwoJobTypeRes[string(models.JobTypeTrain)] - cloudTwoJobTypeRes[string(models.JobTypeInference)] - cloudTwoJobTypeRes[string(models.JobTypeDebug)]
+	intelligentNetJobTypeRes["EVALUATION"] = cloudBrainPeriodNum[2] - intelligentNetJobTypeRes[string(models.JobTypeTrain)] - intelligentNetJobTypeRes[string(models.JobTypeInference)] - intelligentNetJobTypeRes[string(models.JobTypeDebug)]
+	cDCenterJobTypeRes["EVALUATION"] = cloudBrainPeriodNum[3] - cDCenterJobTypeRes[string(models.JobTypeTrain)] - cDCenterJobTypeRes[string(models.JobTypeInference)] - cDCenterJobTypeRes[string(models.JobTypeDebug)]
 	ctx.JSON(http.StatusOK, map[string]interface{}{
 		"cloudOneJobTypeRes":        cloudOneJobTypeRes,
 		"cloudTwoJobTypeRes":        cloudTwoJobTypeRes,
 		"intelligentNetJobTypeRes":  intelligentNetJobTypeRes,
+		"cDCenterJobTypeRes":        cDCenterJobTypeRes,
 		"cloudBrainPeriodNum":       cloudBrainPeriodNum,
 		"cloudBrainComputeResource": cloudBrainComputeResource,
 	})
 }
 
 func GetCloudbrainsStatusAnalysis(ctx *context.Context) {
-	recordCloudbrain, err := models.GetRecordBeginTime()
+	cloudbrainStatusCount, err := models.GetCloudbrainStatusCount()
+	log.Info("cloudbrainStatusCount:", cloudbrainStatusCount)
 	if err != nil {
-		log.Error("Can not get recordCloudbrain", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("repo.record_begintime_get_err"))
+		log.Error("Can not query cloudbrainStatusCount.", err)
 		return
 	}
-	recordBeginTime := recordCloudbrain[0].Cloudbrain.CreatedUnix
-	endTime := time.Now()
-	cloudBrainStatusResult := make(map[string]int)
-	cloudBrainStatusAnalysis := make(map[string]int)
-	totalCount := 0
-
-	page := 1
-	pagesize := 1000
-	count := pagesize
-	for count == pagesize && count != 0 {
-		cloudbrains, _, err := models.CloudbrainAllStatic(&models.CloudbrainsOptions{
-			ListOptions: models.ListOptions{
-				Page:     page,
-				PageSize: pagesize,
-			},
-			Type:          models.TypeCloudBrainAll,
-			BeginTimeUnix: int64(recordBeginTime),
-			EndTimeUnix:   endTime.Unix(),
-		})
-		if err != nil {
-			ctx.ServerError("Get cloudbrains failed:", err)
-			return
-		}
-		for _, cloudbrain := range cloudbrains {
-			if _, ok := cloudBrainStatusResult[cloudbrain.Status]; !ok {
-				cloudBrainStatusResult[cloudbrain.Status] = 1
-			} else {
-				cloudBrainStatusResult[cloudbrain.Status] += 1
-			}
-		}
-		count = len(cloudbrains)
-		totalCount = totalCount + count
-		page += 1
-	}
-
-	var jobStatuses []string
-	jobStatuses = append(jobStatuses, string(models.ModelArtsTrainJobWaiting), string(models.ModelArtsTrainJobFailed), string(models.ModelArtsRunning), string(models.ModelArtsTrainJobCompleted),
-		string(models.ModelArtsStarting), string(models.ModelArtsRestarting), string(models.ModelArtsStartFailed),
-		string(models.ModelArtsStopping), string(models.ModelArtsStopped), string(models.JobSucceeded))
-	jobStatusesCount := 0
-	for _, v := range jobStatuses {
-		if _, ok := cloudBrainStatusResult[v]; !ok {
-			cloudBrainStatusAnalysis[v] = 0
-		} else {
-			cloudBrainStatusAnalysis[v] = cloudBrainStatusResult[v]
-		}
-		jobStatusesCount = jobStatusesCount + cloudBrainStatusResult[v]
-	}
-	cloudBrainStatusAnalysis["OTHER"] = totalCount - jobStatusesCount
 
 	ctx.JSON(http.StatusOK, map[string]interface{}{
-		"cloudBrainStatusResult": cloudBrainStatusAnalysis,
+		"cloudbrainStatusCount": cloudbrainStatusCount,
 	})
 }
 
@@ -738,7 +754,6 @@ func GetCloudbrainsDetailData(ctx *context.Context) {
 	tasks := []models.TaskDetail{}
 	for i, task := range ciTasks {
 		ciTasks[i].Cloudbrain.ComputeResource = task.ComputeResource
-
 		var taskDetail models.TaskDetail
 		taskDetail.ID = ciTasks[i].Cloudbrain.ID
 		taskDetail.JobID = ciTasks[i].Cloudbrain.JobID
@@ -758,11 +773,12 @@ func GetCloudbrainsDetailData(ctx *context.Context) {
 			taskDetail.RepoName = ciTasks[i].Repo.OwnerName + "/" + ciTasks[i].Repo.Name
 			taskDetail.RepoAlias = ciTasks[i].Repo.OwnerName + "/" + ciTasks[i].Repo.Alias
 		}
-		taskDetail.CardNum, taskDetail.CardType, _ = repo.GetCloudbrainCardNumAndType(ciTasks[i].Cloudbrain)
+		if ciTasks[i].Cloudbrain.WorkServerNumber >= 1 {
+			taskDetail.WorkServerNum = int64(ciTasks[i].Cloudbrain.WorkServerNumber)
+		} else {
+			taskDetail.WorkServerNum = 1
+		}
 		taskDetail.CardDuration = repo.GetCloudbrainCardDuration(ciTasks[i].Cloudbrain)
-		taskDetail.AiCenter = repo.GetCloudbrainAiCenter(ciTasks[i].Cloudbrain, ctx)
-		taskDetail.FlavorName, _ = repo.GetCloudbrainFlavorName(ciTasks[i].Cloudbrain)
-
 		taskDetail.WaitTime = repo.GetCloudbrainWaitTime(ciTasks[i].Cloudbrain)
 
 		if ciTasks[i].Cloudbrain.DeletedAt != nilTime || ciTasks[i].Repo == nil {
@@ -787,17 +803,6 @@ func GetCloudbrainsDetailData(ctx *context.Context) {
 	})
 }
 
-func getCloudbrainAiCenter(task models.Cloudbrain, ctx *context.Context) string {
-	if task.Type == models.TypeCloudBrainOne {
-		return ctx.Tr("repo.cloudbrain1")
-	} else if task.Type == models.TypeCloudBrainTwo {
-		return ctx.Tr("repo.cloudbrain2")
-	} else if task.Type == models.TypeC2Net {
-		return task.AiCenter
-	}
-	return ""
-}
-
 func GetCloudbrainsCreateHoursData(ctx *context.Context) {
 	recordCloudbrain, err := models.GetRecordBeginTime()
 	if err != nil {
@@ -958,11 +963,12 @@ func GetRunningTop(ctx *context.Context) {
 	})
 }
 
-func getCloudbrainCount(beginTime time.Time, endTime time.Time, cloudbrains []*models.CloudbrainInfo) (map[string]int, map[string]int, map[string]int, map[int]int, map[string]int) {
+func getCloudbrainCount(beginTime time.Time, endTime time.Time, cloudbrains []*models.CloudbrainInfo) (map[string]int, map[string]int, map[string]int, map[string]int, map[int]int, map[string]int) {
 
 	cloudOneJobTypeRes := make(map[string]int)
 	cloudTwoJobTypeRes := make(map[string]int)
 	intelligentNetJobTypeRes := make(map[string]int)
+	cDCenterJobTypeRes := make(map[string]int)
 	cloudBrainPeriodNum := make(map[int]int)
 	cloudBrainComputeResource := make(map[string]int)
 	for _, cloudbrain := range cloudbrains {
@@ -1005,7 +1011,7 @@ func getCloudbrainCount(beginTime time.Time, endTime time.Time, cloudbrains []*m
 	}
 
 	jobTypeList := []string{"DEBUG", "BENCHMARK", "INFERENCE", "TRAIN", "SNN4IMAGENET", "BRAINSCORE"}
-	cloudBrainTypeList := []int{0, 1, 2}
+	cloudBrainTypeList := []int{0, 1, 2, 3}
 	for _, v := range jobTypeList {
 		if _, ok := cloudOneJobTypeRes[v]; !ok {
 			cloudOneJobTypeRes[v] = 0
@@ -1016,14 +1022,17 @@ func getCloudbrainCount(beginTime time.Time, endTime time.Time, cloudbrains []*m
 		if _, ok := intelligentNetJobTypeRes[v]; !ok {
 			intelligentNetJobTypeRes[v] = 0
 		}
+		if _, ok := cDCenterJobTypeRes[v]; !ok {
+			cDCenterJobTypeRes[v] = 0
+		}
 	}
 	for _, v := range cloudBrainTypeList {
 		if _, ok := cloudBrainPeriodNum[v]; !ok {
 			cloudBrainPeriodNum[v] = 0
 		}
 	}
-	cloudBrainPeriodNum[-1] = cloudBrainPeriodNum[0] + cloudBrainPeriodNum[1] + cloudBrainPeriodNum[2]
-	return cloudOneJobTypeRes, cloudTwoJobTypeRes, intelligentNetJobTypeRes, cloudBrainPeriodNum, cloudBrainComputeResource
+	cloudBrainPeriodNum[-1] = cloudBrainPeriodNum[0] + cloudBrainPeriodNum[1] + cloudBrainPeriodNum[2] + cloudBrainPeriodNum[3]
+	return cloudOneJobTypeRes, cloudTwoJobTypeRes, intelligentNetJobTypeRes, cDCenterJobTypeRes, cloudBrainPeriodNum, cloudBrainComputeResource
 }
 
 func getDayCloudbrainNum(beginTime time.Time, endTime time.Time) ([]DateCloudbrainNum, error) {
@@ -1040,12 +1049,13 @@ func getDayCloudbrainNum(beginTime time.Time, endTime time.Time) ([]DateCloudbra
 	}
 	dayCloudbrainNum := make([]DateCloudbrainNum, 0)
 	for endTimeTemp.Before(endTime) || endTimeTemp.Equal(endTime) {
-		cloudOneJobTypeRes, cloudTwoJobTypeRes, intelligentNetJobTypeRes, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(beginTime, endTimeTemp, cloudbrains)
+		cloudOneJobTypeRes, cloudTwoJobTypeRes, intelligentNetJobTypeRes, cDCenterJobTypeRes, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(beginTime, endTimeTemp, cloudbrains)
 		dayCloudbrainNum = append(dayCloudbrainNum, DateCloudbrainNum{
 			Date:                      beginTime.Format("2006/01/02"),
 			CloudOneJobTypeRes:        cloudOneJobTypeRes,
 			CloudTwoJobTypeRes:        cloudTwoJobTypeRes,
 			IntelligentNetJobTypeRes:  intelligentNetJobTypeRes,
+			CDCenterJobTypeRes:        cDCenterJobTypeRes,
 			CloudBrainPeriodNum:       cloudBrainPeriodNum,
 			CloudBrainComputeResource: cloudBrainComputeResource,
 		})
@@ -1075,12 +1085,13 @@ func getMonthCloudbrainNum(beginTime time.Time, endTime time.Time) ([]DateCloudb
 		return nil, err
 	}
 	for endTimeTemp.Before(endTime) || endTimeTemp.Equal(endTime) {
-		cloudOneJobTypeRes, cloudTwoJobTypeRes, intelligentNetJobTypeRes, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(beginTime, endTimeTemp, cloudbrains)
+		cloudOneJobTypeRes, cloudTwoJobTypeRes, intelligentNetJobTypeRes, cDCenterJobTypeRes, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(beginTime, endTimeTemp, cloudbrains)
 		monthCloudbrainNum = append(monthCloudbrainNum, DateCloudbrainNum{
 			Date:                      beginTime.Format("2006/01"),
 			CloudOneJobTypeRes:        cloudOneJobTypeRes,
 			CloudTwoJobTypeRes:        cloudTwoJobTypeRes,
 			IntelligentNetJobTypeRes:  intelligentNetJobTypeRes,
+			CDCenterJobTypeRes:        cDCenterJobTypeRes,
 			CloudBrainPeriodNum:       cloudBrainPeriodNum,
 			CloudBrainComputeResource: cloudBrainComputeResource,
 		})
@@ -1113,7 +1124,7 @@ func getDayCloudbrainInfo(beginTime time.Time, endTime time.Time) ([]DateCloudbr
 	dayCloudbrainInfo := make([]DateCloudbrainInfo, 0)
 	count := 0
 	for beginTime.Before(endTimeTemp) || beginTime.Equal(endTimeTemp) {
-		_, _, _, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(endTimeTemp, endTime, cloudbrains)
+		_, _, _, _, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(endTimeTemp, endTime, cloudbrains)
 		dayCloudbrainInfo = append(dayCloudbrainInfo, DateCloudbrainInfo{
 			Date:                      endTimeTemp.Format("2006/01/02"),
 			CloudBrainPeriodNum:       cloudBrainPeriodNum,
@@ -1144,7 +1155,7 @@ func getMonthCloudbrainInfo(beginTime time.Time, endTime time.Time) ([]DateCloud
 	dayCloudbrainInfo := make([]DateCloudbrainInfo, 0)
 	count := 0
 	for beginTime.Before(endTimeTemp) || beginTime.Equal(endTimeTemp) || (endTimeTemp.Before(beginTime) && beginTime.Before(endTime)) {
-		_, _, _, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(endTimeTemp, endTime, cloudbrains)
+		_, _, _, _, cloudBrainPeriodNum, cloudBrainComputeResource := getCloudbrainCount(endTimeTemp, endTime, cloudbrains)
 		dayCloudbrainInfo = append(dayCloudbrainInfo, DateCloudbrainInfo{
 			Date:                      endTimeTemp.Format("2006/01"),
 			CloudBrainPeriodNum:       cloudBrainPeriodNum,
@@ -1205,6 +1216,7 @@ func DownloadCloudBrainBoard(ctx *context.Context) {
 			log.Warn("Can not get cloud brain info", err)
 			continue
 		}
+		models.LoadSpecs4CloudbrainInfo(pageRecords)
 		for _, record := range pageRecords {
 
 			for k, v := range allCloudbrainValues(row, record, ctx) {
@@ -1235,10 +1247,9 @@ func allCloudbrainHeader(ctx *context.Context) map[string]string {
 		"H1": ctx.Tr("cloudbrain.card_duration"),
 		"I1": ctx.Tr("repo.modelarts.train_job.start_time"), "J1": ctx.Tr("repo.modelarts.train_job.end_time"),
 		"K1": ctx.Tr("repo.modelarts.computing_resources"), "L1": ctx.Tr("cloudbrain.card_type"),
-		"M1": ctx.Tr("repo.grampus.train_job.ai_center"), "N1": ctx.Tr("cloudbrain.resource_specification"),
-		"O1": ctx.Tr("repo.cloudbrain_creator"), "P1": ctx.Tr("repo.repo_name"), "Q1": ctx.Tr("repo.cloudbrain_task_name"),
-		"R1": ctx.Tr("repo.modelarts.deletetime")}
-
+		"M1": ctx.Tr("repo.modelarts.train_job.amount_of_compute_node"), "N1": ctx.Tr("repo.grampus.train_job.ai_center"),
+		"O1": ctx.Tr("cloudbrain.resource_specification"), "P1": ctx.Tr("repo.cloudbrain_creator"), "Q1": ctx.Tr("repo.repo_name"),
+		"R1": ctx.Tr("repo.cloudbrain_task_name"), "S1": ctx.Tr("repo.modelarts.deletetime")}
 }
 func allCloudbrainValues(row int, rs *models.CloudbrainInfo, ctx *context.Context) map[string]string {
 	return map[string]string{getCellName("A", row): rs.DisplayJobName, getCellName("B", row): getCloudbrainType(rs, ctx), getCellName("C", row): rs.Status, getCellName("D", row): rs.JobType,
@@ -1246,9 +1257,16 @@ func allCloudbrainValues(row int, rs *models.CloudbrainInfo, ctx *context.Contex
 		getCellName("G", row): rs.TrainJobDuration, getCellName("H", row): repo.GetCloudbrainCardDuration(rs.Cloudbrain),
 		getCellName("I", row): getBrainStartTime(rs),
 		getCellName("J", row): getBrainEndTime(rs), getCellName("K", row): rs.ComputeResource, getCellName("L", row): getCloudbrainCardType(rs),
-		getCellName("M", row): repo.GetCloudbrainAiCenter(rs.Cloudbrain, ctx), getCellName("N", row): getCloudbrainFlavorName(rs),
-		getCellName("O", row): rs.Name, getCellName("P", row): getBrainRepo(rs),
-		getCellName("Q", row): rs.JobName, getCellName("R", row): getBrainDeleteTime(rs),
+		getCellName("M", row): getWorkServerNum(rs), getCellName("N", row): repo.GetCloudbrainAiCenter(rs.Cloudbrain, ctx),
+		getCellName("O", row): getCloudbrainFlavorName(rs), getCellName("P", row): rs.Name,
+		getCellName("Q", row): getBrainRepo(rs), getCellName("R", row): rs.JobName, getCellName("S", row): getBrainDeleteTime(rs),
+	}
+}
+func getWorkServerNum(rs *models.CloudbrainInfo) string {
+	if rs.Cloudbrain.WorkServerNumber >= 1 {
+		return fmt.Sprint(rs.Cloudbrain.WorkServerNumber)
+	} else {
+		return "1"
 	}
 }
 func getBrainRepo(rs *models.CloudbrainInfo) string {
@@ -1287,11 +1305,14 @@ func getCloudbrainType(rs *models.CloudbrainInfo, ctx *context.Context) string {
 	}
 }
 func getCloudbrainCardType(rs *models.CloudbrainInfo) string {
-	_, cardType, _ := repo.GetCloudbrainCardNumAndType(rs.Cloudbrain)
-	return cardType
+	if rs.Cloudbrain.Spec != nil {
+		return rs.Cloudbrain.Spec.AccCardType
+	} else {
+		return ""
+	}
 }
 func getCloudbrainFlavorName(rs *models.CloudbrainInfo) string {
-	flavorName, _ := repo.GetCloudbrainFlavorName(rs.Cloudbrain)
+	flavorName := repo.GetCloudbrainFlavorName(rs.Cloudbrain)
 	return flavorName
 }
 

routers/repo/cloudbrain.go

@@ -2819,16 +2819,11 @@ func GetBenchmarkTypes(ctx *context.Context) *models.BenchmarkTypes {
 }
 
 func GetCloudbrainAiCenter(task models.Cloudbrain, ctx *context.Context) string {
-	if task.Type == models.TypeCloudBrainOne {
-		return ctx.Tr("repo.cloudbrain1")
-	} else if task.Type == models.TypeCloudBrainTwo {
-		return ctx.Tr("repo.cloudbrain2")
-	} else if task.Type == models.TypeCDCenter {
-		return ctx.Tr("repo.cdCenter")
-	} else if task.Type == models.TypeC2Net {
-		return getCutStringAiCenterByAiCenter(task.AiCenter)
+	if task.Spec != nil {
+		return task.Spec.AiCenterName
+	} else {
+		return ""
 	}
-	return ""
 }
 func getCutStringAiCenterByAiCenter(aiCenter string) string {
 	if aiCenter == "" {
@@ -2847,8 +2842,24 @@ func GetCloudbrainCluster(task models.Cloudbrain, ctx *context.Context) string {
 	return ""
 }
 func GetCloudbrainCardDuration(task models.Cloudbrain) string {
-	cardNum, _, _ := GetCloudbrainCardNumAndType(task)
-	cardDuration := models.ConvertDurationToStr(int64(cardNum) * task.Duration)
+	cardNum := int(0)
+	spec, err := resource.GetCloudbrainSpec(task.ID)
+	if err != nil {
+		log.Info("error:" + err.Error())
+		return ""
+	}
+	if spec != nil {
+		cardNum = spec.AccCardsNum
+	} else {
+		cardNum = 1
+	}
+	var workServerNumber int64
+	if task.WorkServerNumber >= 1 {
+		workServerNumber = int64(task.WorkServerNumber)
+	} else {
+		workServerNumber = 1
+	}
+	cardDuration := models.ConvertDurationToStr(workServerNumber * int64(cardNum) * task.Duration)
 	return cardDuration
 }
 func GetCloudbrainWaitTime(task models.Cloudbrain) string {
@@ -2875,114 +2886,12 @@ func GetCloudbrainWaitTime(task models.Cloudbrain) string {
 	}
 	return waitTime
 }
-
-func GetCloudbrainCardNumAndType(task models.Cloudbrain) (int, string, error) {
-	if !models.SpecsMapInitFlag {
-		models.InitCloudbrainOneResourceSpecMap()
-	}
-	if !models.GpuInfosMapInitFlag {
-		models.InitCloudbrainOneGpuInfoMap()
-	}
-	flavorName, err := GetCloudbrainFlavorName(task)
-	if err != nil {
-		return 0, "", nil
-	}
-	return getCardNumAndTypeByFlavorname(flavorName)
-}
-
-func getCardNumAndTypeByFlavorname(FlavorName string) (int, string, error) {
-	if FlavorName == "" {
-		return 0, "", nil
-	} else {
-		var beginIndex = strings.Index(FlavorName, ":")
-		var lastIndex = strings.LastIndex(FlavorName, ":")
-		var endIndex = strings.Index(FlavorName, "*")
-		if endIndex >= (beginIndex+1) && lastIndex >= (endIndex+1) {
-			cardNum, err := strconv.Atoi(strings.TrimSpace(FlavorName[beginIndex+1 : endIndex]))
-			if err != nil {
-				log.Error("strconv.Atoi failed: %v", err)
-				return 0, "", err
-			}
-			cardType := strings.TrimSpace(FlavorName[endIndex+1 : lastIndex])
-			return cardNum, cardType, err
-		}
-		return 0, "", nil
-	}
-}
-
-func GetCloudbrainFlavorName(task models.Cloudbrain) (string, error) {
-	if task.Type == models.TypeCloudBrainOne {
-		resourceSpec, gpuInfo, err := getCloudBrainOneResourceSpec(task)
-		if err != nil {
-			log.Info("getCloudBrainOneResourceSpec err:", err)
-			return "", err
-		} else {
-			if resourceSpec == nil || gpuInfo == nil {
-				err := errors.New("resourceSpec or gpuInfo is nil")
-				return "", err
-			} else {
-				CloudbrainOneFlavorName := "GPU:" + strconv.Itoa(resourceSpec.GpuNum) + "*Nvidia-" + gpuInfo.Value +
-					" | CPU:" + strconv.Itoa(resourceSpec.CpuNum) + "核" + strconv.Itoa(resourceSpec.MemMiB) + "MB"
-				return CloudbrainOneFlavorName, nil
-			}
-		}
-	} else if (task.Type == models.TypeCloudBrainTwo || task.Type == models.TypeC2Net || task.Type == models.TypeCDCenter) && task.FlavorName != "" {
-		replaceFlavorName := strings.ReplaceAll(task.FlavorName, "：", ":")
-		return replaceFlavorName, nil
-	} else if (task.Type == models.TypeCloudBrainTwo || task.Type == models.TypeCDCenter) && task.FlavorName == "" && task.FlavorCode != "" {
-		cloudbrainTwoFlavorName := getFlavorNameByFlavorCode(task.FlavorCode)
-		return cloudbrainTwoFlavorName, nil
-	} else if task.Type == models.TypeCloudBrainTwo && task.JobType == string(models.JobTypeDebug) && task.FlavorName == "" && task.FlavorCode == "" {
-		tasks, err := models.GetModelartsReDebugTaskByJobId(task.JobID)
-		if err != nil {
-			return "", err
-		}
-		if len(tasks) >= 1 {
-			return getFlavorNameByFlavorCode(tasks[0].FlavorCode), nil
-		}
-		return "", nil
-	}
-	return "", nil
-}
-
-func getCloudBrainOneResourceSpec(task models.Cloudbrain) (*models.ResourceSpec, *models.GpuInfo, error) {
-	gpuQueueDefault := "openidebug"
-	if task.GpuQueue != "" {
-		gpuQueueDefault = task.GpuQueue
-	}
-	if task.ResourceSpecId >= 0 {
-		if task.JobType == string(models.JobTypeTrain) {
-			if models.CloudbrainTrainResourceSpecsMap[task.ResourceSpecId] != nil {
-				return models.CloudbrainTrainResourceSpecsMap[task.ResourceSpecId], models.CloudbrainTrainGpuInfosMap[gpuQueueDefault], nil
-			} else {
-				return models.CloudbrainSpecialResourceSpecsMap[task.ResourceSpecId], models.CloudbrainSpecialGpuInfosMap[gpuQueueDefault], nil
-			}
-		} else if task.JobType == string(models.JobTypeDebug) {
-			if models.CloudbrainDebugResourceSpecsMap[task.ResourceSpecId] != nil {
-				return models.CloudbrainDebugResourceSpecsMap[task.ResourceSpecId], models.CloudbrainDebugGpuInfosMap[gpuQueueDefault], nil
-			} else {
-				return models.CloudbrainSpecialResourceSpecsMap[task.ResourceSpecId], models.CloudbrainSpecialGpuInfosMap[gpuQueueDefault], nil
-			}
-		} else if task.JobType == string(models.JobTypeInference) {
-			return models.CloudbrainInferenceResourceSpecsMap[task.ResourceSpecId], models.CloudbrainInferenceGpuInfosMap[gpuQueueDefault], nil
-		} else if task.JobType == string(models.JobTypeBenchmark) || task.JobType == string(models.JobTypeSnn4imagenet) || task.JobType == string(models.JobTypeBrainScore) {
-			return models.CloudbrainBenchmarkResourceSpecsMap[task.ResourceSpecId], models.CloudbrainBenchmarkGpuInfosMap[gpuQueueDefault], nil
-		}
+func GetCloudbrainFlavorName(task models.Cloudbrain) string {
+	if task.Spec != nil {
+		flavorName := task.Spec.ComputeResource + ":" + fmt.Sprint(task.Spec.AccCardsNum) + "*" + task.Spec.AccCardType +
+			",内存:" + strconv.FormatInt(int64(task.Spec.MemGiB), 10) + "GB,共享内存:" + strconv.FormatInt(int64(task.Spec.ShareMemGiB), 10) + "GB"
+		return flavorName
 	} else {
-		err := errors.New("ResourceSpecId is null")
-		return nil, nil, err
-	}
-	return nil, nil, nil
-}
-func getFlavorNameByFlavorCode(flavorCode string) string {
-	index := strings.LastIndex(flavorCode, ".")
-	cardNum, err := strconv.Atoi(strings.TrimSpace(flavorCode[index+1 : len(flavorCode)]))
-	if err != nil {
-		log.Error("strconv.Atoi failed: %v", err)
 		return ""
 	}
-	cloudbrainTwoFlavorName := "Ascend:" + strings.TrimSpace(flavorCode[index+1:len(flavorCode)]) +
-		"*Ascend-910(" + strconv.Itoa(cardNum*32) + "GB)|ARM:" + strconv.Itoa(cardNum*24) +
-		"核" + strconv.Itoa(cardNum*256) + "GB"
-	return cloudbrainTwoFlavorName
 }

routers/user/home.go

@@ -23,7 +23,6 @@ import (
 	"code.gitea.io/gitea/modules/modelarts"
 	"code.gitea.io/gitea/modules/setting"
 	"code.gitea.io/gitea/modules/util"
-	"code.gitea.io/gitea/routers/repo"
 	issue_service "code.gitea.io/gitea/services/issue"
 	pull_service "code.gitea.io/gitea/services/pull"
 
@@ -841,9 +840,6 @@ func Cloudbrains(ctx *context.Context) {
 		ciTasks[i].CanDebug = true
 		ciTasks[i].CanDel = true
 		ciTasks[i].Cloudbrain.ComputeResource = task.ComputeResource
-		ciTasks[i].Cloudbrain.AiCenter = repo.GetCloudbrainAiCenter(task.Cloudbrain, ctx)
-		ciTasks[i].Cloudbrain.Cluster = repo.GetCloudbrainCluster(task.Cloudbrain, ctx)
-
 	}
 
 	pager := context.NewPagination(int(count), setting.UI.IssuePagingNum, page, getTotalPage(count, setting.UI.IssuePagingNum))