models/cloudbrain.go

@@ -473,32 +473,33 @@ type GetImagesPayload struct {
 
 type CloudbrainsOptions struct {
 	ListOptions
-	RepoID           int64 // include all repos if empty
-	UserID           int64
-	JobID            string
-	SortType         string
-	CloudbrainIDs    []int64
-	JobStatus        []string
-	JobStatusNot     bool
-	Keyword          string
-	Type             int
-	JobTypes         []string
-	VersionName      string
-	IsLatestVersion  string
-	JobTypeNot       bool
-	NeedRepoInfo     bool
-	RepoIDList       []int64
-	BeginTime        time.Time
-	EndTime          time.Time
-	ComputeResource  string
-	BeginTimeUnix    int64
-	EndTimeUnix      int64
-	AiCenter         string
-	NeedDeleteInfo   string
-	Cluster          string
-	AccCardType      string
-	AccCardsNum      int
-	WorkServerNumber int
+	RepoID            int64 // include all repos if empty
+	UserID            int64
+	JobID             string
+	SortType          string
+	CloudbrainIDs     []int64
+	JobStatus         []string
+	JobStatusNot      bool
+	Keyword           string
+	Type              int
+	JobTypes          []string
+	VersionName       string
+	IsLatestVersion   string
+	JobTypeNot        bool
+	NeedRepoInfo      bool
+	RepoIDList        []int64
+	BeginTime         time.Time
+	EndTime           time.Time
+	ComputeResource   string
+	BeginTimeUnix     int64
+	EndTimeUnix       int64
+	DateBeginTimeUnix int64
+	AiCenter          string
+	NeedDeleteInfo    string
+	Cluster           string
+	AccCardType       string
+	AccCardsNum       int
+	WorkServerNumber  int
 }
 
 type TaskPod struct {
@@ -2564,6 +2565,12 @@ func CloudbrainAllStatic(opts *CloudbrainsOptions) ([]*CloudbrainInfo, int64, er
 			builder.And(builder.Gte{"cloudbrain.created_unix": opts.BeginTimeUnix}, builder.Lte{"cloudbrain.created_unix": opts.EndTimeUnix}),
 		)
 	}
+	if opts.DateBeginTimeUnix > 0 || len(opts.JobStatus) > 0 {
+		cond = cond.And(builder.Or(
+			builder.Gte{"cloudbrain.end_time": opts.DateBeginTimeUnix},
+			builder.In("cloudbrain.status", opts.JobStatus),
+		))
+	}
 	var count int64
 	var err error
 	count, err = sess.Unscoped().Where(cond).Count(new(Cloudbrain))

models/cloudbrain_static.go

@@ -6,7 +6,6 @@ import (
 
 	"code.gitea.io/gitea/modules/log"
 	"code.gitea.io/gitea/modules/timeutil"
-	"code.gitea.io/gitea/modules/util"
 	"xorm.io/builder"
 )
 
@@ -234,57 +233,42 @@ func GetRunningTop() ([]*CloudbrainInfo, error) {
 	return cloudbrains, nil
 }
 
-func getCreatePeriodCount(dateBeginTime string, dateEndTime string, hourBeginTime string, hourEndTime string) (int64, error) {
-	countSql := "SELECT count(*) FROM  " +
-		"public.cloudbrain where to_char(to_timestamp(created_unix), 'YYYY-MM-DD') >= '" + dateBeginTime +
-		"' and to_char(to_timestamp(created_unix), 'YYYY-MM-DD') < '" + dateEndTime +
-		"' and to_char(to_timestamp(created_unix), 'HH24:MI:SS') >= '" + hourBeginTime +
-		"' and to_char(to_timestamp(created_unix), 'HH24:MI:SS') < '" + hourEndTime + "'"
-	return x.SQL(countSql).Count()
-}
-
-//SELECT * FROM xxx WHERE NOT ((endTime < hourBeginTime) OR (startTime > hourEndTime))
-func getRunPeriodCount(dateBeginTime string, dateEndTime string, hourBeginTime string, hourEndTime string) (int64, error) {
-	countSql := "SELECT count(*) FROM  " +
-		"public.cloudbrain where not ((to_char(to_timestamp(start_time), ' HH24:MI:SS') > '" + hourEndTime +
-		"') or (to_char(to_timestamp(end_time), 'HH24:MI:SS') < '" + hourBeginTime + "'))" +
-		" and (to_char(to_timestamp(start_time), 'YYYY-MM-DD') >= '" + dateBeginTime +
-		"' and to_char(to_timestamp(start_time), 'YYYY-MM-DD') < '" + dateEndTime + "')"
-	return x.SQL(countSql).Count()
-
+func GetCreateHourPeriodCount(cloudbrains []*CloudbrainInfo, dateBeginTime time.Time, dateEndTime time.Time) (map[string]int64, error) {
+	var createHourPeriodCount = make(map[string]int64)
+	for _, cloudbrain := range cloudbrains {
+		if cloudbrain.StartTime != 0 && cloudbrain.EndTime == 0 {
+			cloudbrain.EndTime = timeutil.TimeStamp(time.Now().Unix())
+		}
+		hourBeginTime := dateBeginTime.Unix()
+		hourEndTime := hourBeginTime + int64(3600)
+		for hour := 0; hour < 24; hour++ {
+			if int64(cloudbrain.Cloudbrain.CreatedUnix) >= hourBeginTime && int64(cloudbrain.Cloudbrain.CreatedUnix) < hourEndTime {
+				createHourPeriodCount[strconv.Itoa(hour)] = createHourPeriodCount[strconv.Itoa(hour)] + 1
+			}
+			hourBeginTime = hourEndTime
+			hourEndTime = hourEndTime + int64(3600)
+		}
+	}
+	return createHourPeriodCount, nil
 }
 
-func GetCreateHourPeriodCount(dateBeginTime string, dateEndTime string) (map[string]interface{}, error) {
-	//0 to 23 for each hour,
-	dateHourMap := make(map[string]interface{})
-	var slice = []int64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}
-	for key, value := range slice {
-		hourBeginHour := util.AddZero(value) + ":00:00"
-		hourEndHour := util.AddZero(value+1) + ":00:00"
-		cout, err := getCreatePeriodCount(dateBeginTime, dateEndTime, hourBeginHour, hourEndHour)
-		if err != nil {
-			log.Error("Can not query getCreatePeriodCount.", err)
-			return nil, nil
+func GetRunHourPeriodCount(cloudbrains []*CloudbrainInfo, dateBeginTime time.Time, dateEndTime time.Time) (map[string]int64, error) {
+	var runHourPeriodCount = make(map[string]int64)
+	for _, cloudbrain := range cloudbrains {
+		if cloudbrain.StartTime != 0 && cloudbrain.EndTime == 0 {
+			cloudbrain.EndTime = timeutil.TimeStamp(time.Now().Unix())
 		}
-		dateHourMap[strconv.Itoa(key)] = cout
-	}
-	return dateHourMap, nil
-}
-
-func GetRunHourPeriodCount(dateBeginTime string, dateEndTime string) (map[string]interface{}, error) {
-	dateHourMap := make(map[string]interface{})
-	var slice = []int64{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}
-	for key, value := range slice {
-		hourBeginHour := util.AddZero(value) + ":00:00"
-		hourEndHour := util.AddZero(value+1) + ":00:00"
-		cout, err := getRunPeriodCount(dateBeginTime, dateEndTime, hourBeginHour, hourEndHour)
-		if err != nil {
-			log.Error("Can not query getRunPeriodCount.", err)
-			return nil, nil
+		hourBeginTime := dateBeginTime.Unix()
+		hourEndTime := hourBeginTime + int64(3600)
+		for hour := 0; hour < 24; hour++ {
+			if cloudbrain.StartTime.AsTime().Unix() < hourEndTime && cloudbrain.EndTime.AsTime().Unix() > hourBeginTime {
+				runHourPeriodCount[strconv.Itoa(hour)] = runHourPeriodCount[strconv.Itoa(hour)] + 1
+			}
+			hourBeginTime = hourEndTime
+			hourEndTime = hourEndTime + int64(3600)
 		}
-		dateHourMap[strconv.Itoa(key)] = cout
 	}
-	return dateHourMap, nil
+	return runHourPeriodCount, nil
 }
 
 func GetCloudbrainRunning() ([]*CloudbrainInfo, error) {

routers/api/v1/repo/cloudbrain_dashboard.go

@@ -868,15 +868,16 @@ func GetCloudbrainsCreateHoursData(ctx *context.Context) {
 	endTimeStr := ctx.QueryTrim("endTime")
 	var beginTime time.Time
 	var endTime time.Time
-	createHourPeriodCount := make(map[string]interface{})
 	if queryType != "" {
 		if queryType == "all" {
 			beginTime = recordBeginTime
+			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
 			endTime = now.AddDate(0, 0, 1)
 			endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
 		} else if queryType == "today" {
 			beginTime = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
-			endTime = now.AddDate(0, 0, 1)
+			endTime = beginTime.AddDate(0, 0, 1)
+			endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
 		} else if queryType == "yesterday" {
 			beginTime = now.AddDate(0, 0, -1)
 			beginTime = time.Date(beginTime.Year(), beginTime.Month(), beginTime.Day(), 0, 0, 0, 0, now.Location())
@@ -933,26 +934,90 @@ func GetCloudbrainsCreateHoursData(ctx *context.Context) {
 			endTime = time.Date(endTime.Year(), endTime.Month(), endTime.Day(), 0, 0, 0, 0, now.Location())
 		}
 	}
-	dateBeginTime := beginTime.Format("2006-01-02")
-	dateEndTime := endTime.Format("2006-01-02")
-	createHourPeriodCount, err = models.GetCreateHourPeriodCount(dateBeginTime, dateEndTime)
-	if err != nil {
-		log.Error("Can not query hourPeriodCount.", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("hourPeriodCount_get_error"))
-		return
+	runPeriodCount := make(map[string]int64)
+	createPeriodCount := make(map[string]int64)
+	page := 1
+	pagesize := 10000
+	createCounts := pagesize
+	//Each time a maximum of 10000 pieces of data are detected to the memory, batch processing
+	for createCounts == pagesize && createCounts != 0 {
+		createCloudbrains, _, err := models.CloudbrainAllStatic(&models.CloudbrainsOptions{
+			ListOptions: models.ListOptions{
+				Page:     page,
+				PageSize: pagesize,
+			},
+			Type:          models.TypeCloudBrainAll,
+			BeginTimeUnix: beginTime.Unix(),
+			EndTimeUnix:   endTime.Unix(),
+		})
+		if err != nil {
+			log.Error("Can not query cloudbrain.", err)
+			ctx.Error(http.StatusBadRequest, ctx.Tr("cloudbrain_get_error"))
+			return
+		}
+		dateBegin := endTime.AddDate(0, 0, -1)
+		dateEnd := endTime
+		for beginTime.Before(dateBegin) || beginTime.Equal(dateBegin) {
+			createHourPeriodCount, err := models.GetCreateHourPeriodCount(createCloudbrains, dateBegin, dateEnd)
+			if err != nil {
+				log.Error("Can not query runHourPeriodCount.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("runHourPeriodCount_get_error"))
+				return
+			}
+			var slice = []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"}
+			for _, v := range slice {
+				createPeriodCount[v] = createPeriodCount[v] + createHourPeriodCount[v]
+			}
+			dateEnd = dateBegin
+			dateBegin = dateEnd.AddDate(0, 0, -1)
+		}
+		createCounts = len(createCloudbrains)
+		page += 1
 	}
-
-	runHourPeriodCount, err := models.GetRunHourPeriodCount(dateBeginTime, dateEndTime)
-	if err != nil {
-		log.Error("Can not query runHourPeriodCount.", err)
-		ctx.Error(http.StatusBadRequest, ctx.Tr("runHourPeriodCount_get_error"))
-		return
+	runPage := 1
+	runCounts := pagesize
+	for runCounts == pagesize && runCounts != 0 {
+		var jobStatuses []string
+		jobStatuses = append(jobStatuses, string(models.JobRunning))
+		runCloudbrains, _, err := models.CloudbrainAllStatic(&models.CloudbrainsOptions{
+			ListOptions: models.ListOptions{
+				Page:     runPage,
+				PageSize: pagesize,
+			},
+			Type:              models.TypeCloudBrainAll,
+			DateBeginTimeUnix: beginTime.Unix(),
+			JobStatus:         jobStatuses,
+		})
+		if err != nil {
+			log.Error("Can not query cloudbrain.", err)
+			ctx.Error(http.StatusBadRequest, ctx.Tr("cloudbrain_get_error"))
+			return
+		}
+		dateBegin := endTime.AddDate(0, 0, -1)
+		dateEnd := endTime
+		for beginTime.Before(dateBegin) || beginTime.Equal(dateBegin) {
+			runHourPeriodCount, err := models.GetRunHourPeriodCount(runCloudbrains, dateBegin, dateEnd)
+			if err != nil {
+				log.Error("Can not query runHourPeriodCount.", err)
+				ctx.Error(http.StatusBadRequest, ctx.Tr("runHourPeriodCount_get_error"))
+				return
+			}
+			var slice = []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23"}
+			for _, v := range slice {
+				runPeriodCount[v] = runPeriodCount[v] + runHourPeriodCount[v]
+			}
+			dateEnd = dateBegin
+			dateBegin = dateEnd.AddDate(0, 0, -1)
+		}
+		runCounts = len(runCloudbrains)
+		runPage += 1
 	}
+
 	ctx.JSON(http.StatusOK, map[string]interface{}{
 		"recordBeginTime":       recordCloudbrain[0].Cloudbrain.CreatedUnix,
 		"updateTime":            now.Unix(),
-		"createHourPeriodCount": createHourPeriodCount,
-		"runHourPeriodCount":    runHourPeriodCount,
+		"createHourPeriodCount": createPeriodCount,
+		"runHourPeriodCount":    runPeriodCount,
 	})
 
 }