#2701

update

models/cloudbrain.go

@@ -193,6 +193,7 @@ type Cloudbrain struct {
 	BenchmarkTypeRankLink string      `xorm:"-"`
 	StartTime             timeutil.TimeStamp
 	EndTime               timeutil.TimeStamp
+	Spec                  *Specification `xorm:"-"`
 }
 
 func (task *Cloudbrain) ComputeAndSetDuration() {
@@ -1656,11 +1657,24 @@ func CloudbrainsVersionList(opts *CloudbrainsOptions) ([]*CloudbrainInfo, int, e
 }
 
 func CreateCloudbrain(cloudbrain *Cloudbrain) (err error) {
+	session := x.NewSession()
+	defer session.Close()
+
+	err = session.Begin()
 	cloudbrain.TrainJobDuration = DURATION_STR_ZERO
-	if _, err = x.NoAutoTime().Insert(cloudbrain); err != nil {
+	if _, err = session.NoAutoTime().InsertOne(cloudbrain); err != nil {
+		session.Rollback()
 		return err
 	}
 
+	if cloudbrain.Spec != nil {
+		if _, err = session.Insert(NewCloudBrainSpec(cloudbrain.ID, *cloudbrain.Spec)); err != nil {
+			session.Rollback()
+			return err
+		}
+	}
+	session.Commit()
+
 	go IncreaseDatasetUseCount(cloudbrain.Uuid)
 	return nil
 }

models/cloudbrain_spec.go

@@ -0,0 +1,85 @@
+package models
+
+import (
+	"code.gitea.io/gitea/modules/timeutil"
+)
+
+type CloudbrainSpec struct {
+	CloudbrainID    int64 `xorm:"pk"`
+	SpecId          int64 `xorm:"index"`
+	SourceSpecId    string
+	AccCardsNum     int
+	AccCardType     string
+	CpuCores        int
+	MemGiB          float32
+	GPUMemGiB       float32
+	ShareMemGiB     float32
+	ComputeResource string
+	UnitPrice       int
+	QueueId         int64
+	QueueCode       string
+	Cluster         string
+	AiCenterCode    string
+	AiCenterName    string
+	IsExclusive     bool
+	ExclusiveOrg    string
+	CreatedTime     timeutil.TimeStamp `xorm:"created"`
+	UpdatedTime     timeutil.TimeStamp `xorm:"updated"`
+}
+
+func (s CloudbrainSpec) ConvertToSpecification() *Specification {
+	return &Specification{
+		ID:              s.SpecId,
+		SourceSpecId:    s.SourceSpecId,
+		AccCardsNum:     s.AccCardsNum,
+		AccCardType:     s.AccCardType,
+		CpuCores:        s.CpuCores,
+		MemGiB:          s.MemGiB,
+		GPUMemGiB:       s.GPUMemGiB,
+		ShareMemGiB:     s.ShareMemGiB,
+		ComputeResource: s.ComputeResource,
+		UnitPrice:       s.UnitPrice,
+		QueueId:         s.QueueId,
+		QueueCode:       s.QueueCode,
+		Cluster:         s.Cluster,
+		AiCenterCode:    s.AiCenterCode,
+		AiCenterName:    s.AiCenterName,
+		IsExclusive:     s.IsExclusive,
+		ExclusiveOrg:    s.ExclusiveOrg,
+	}
+}
+
+func NewCloudBrainSpec(cloudbrainId int64, s Specification) CloudbrainSpec {
+	return CloudbrainSpec{
+		CloudbrainID:    cloudbrainId,
+		SpecId:          s.ID,
+		SourceSpecId:    s.SourceSpecId,
+		AccCardsNum:     s.AccCardsNum,
+		AccCardType:     s.AccCardType,
+		CpuCores:        s.CpuCores,
+		MemGiB:          s.MemGiB,
+		GPUMemGiB:       s.GPUMemGiB,
+		ShareMemGiB:     s.ShareMemGiB,
+		ComputeResource: s.ComputeResource,
+		UnitPrice:       s.UnitPrice,
+		QueueId:         s.QueueId,
+		QueueCode:       s.QueueCode,
+		Cluster:         s.Cluster,
+		AiCenterCode:    s.AiCenterCode,
+		AiCenterName:    s.AiCenterName,
+		IsExclusive:     s.IsExclusive,
+		ExclusiveOrg:    s.ExclusiveOrg,
+	}
+}
+
+func InsertCloudbrainSpec(c CloudbrainSpec) (int64, error) {
+	return x.Insert(&c)
+}
+
+func GetCloudbrainSpecByID(cloudbrainId int64) (*CloudbrainSpec, error) {
+	r := &CloudbrainSpec{}
+	if _, err := x.Where("cloudbrain_id = ?", cloudbrainId).Get(r); err != nil {
+		return nil, err
+	}
+	return r, nil
+}

models/models.go

@@ -150,6 +150,7 @@ func init() {
 		new(ResourceScene),
 		new(ResourceSceneSpec),
 		new(AdminOperateLog),
+		new(CloudbrainSpec),
 	)
 
 	tablesStatistic = append(tablesStatistic,

modules/cloudbrain/cloudbrain.go

@@ -365,6 +365,7 @@ func GenerateTask(req GenerateCloudBrainTaskReq) error {
 		CreatedUnix:          createTime,
 		UpdatedUnix:          createTime,
 		CommitID:             req.CommitID,
+		Spec:                 req.Spec,
 	})
 
 	if err != nil {
@@ -376,6 +377,7 @@ func GenerateTask(req GenerateCloudBrainTaskReq) error {
 		log.Error("GetCloudbrainByJobID failed: %v", err.Error())
 		return err
 	}
+
 	stringId := strconv.FormatInt(task.ID, 10)
 
 	if IsBenchmarkJob(req.JobType) {

routers/repo/cloudbrain.go

@@ -743,128 +743,13 @@ func cloudBrainShow(ctx *context.Context, tpName base.TplName, jobType models.Jo
 		ctx.NotFound(ctx.Req.URL.RequestURI(), nil)
 		return
 	}
-	hasSpec := false
-	if task.JobType == string(models.JobTypeTrain) {
-		if cloudbrain.TrainResourceSpecs == nil {
-			json.Unmarshal([]byte(setting.TrainResourceSpecs), &cloudbrain.TrainResourceSpecs)
-		}
-
-		for _, tmp := range cloudbrain.TrainResourceSpecs.ResourceSpec {
-			if tmp.Id == task.ResourceSpecId {
-				hasSpec = true
-				ctx.Data["GpuNum"] = tmp.GpuNum
-				ctx.Data["CpuNum"] = tmp.CpuNum
-				ctx.Data["MemMiB"] = tmp.MemMiB
-				ctx.Data["ShareMemMiB"] = tmp.ShareMemMiB
-				break
-			}
-		}
-
-	} else if task.JobType == string(models.JobTypeInference) {
-		if cloudbrain.InferenceResourceSpecs == nil {
-			json.Unmarshal([]byte(setting.InferenceResourceSpecs), &cloudbrain.InferenceResourceSpecs)
-		}
-		for _, tmp := range cloudbrain.InferenceResourceSpecs.ResourceSpec {
-			if tmp.Id == task.ResourceSpecId {
-				hasSpec = true
-				ctx.Data["GpuNum"] = tmp.GpuNum
-				ctx.Data["CpuNum"] = tmp.CpuNum
-				ctx.Data["MemMiB"] = tmp.MemMiB
-				ctx.Data["ShareMemMiB"] = tmp.ShareMemMiB
-				break
-			}
-		}
-	} else {
-		if cloudbrain.ResourceSpecs == nil {
-			json.Unmarshal([]byte(setting.ResourceSpecs), &cloudbrain.ResourceSpecs)
-		}
-		for _, tmp := range cloudbrain.ResourceSpecs.ResourceSpec {
-			if tmp.Id == task.ResourceSpecId {
-				hasSpec = true
-				ctx.Data["GpuNum"] = tmp.GpuNum
-				ctx.Data["CpuNum"] = tmp.CpuNum
-				ctx.Data["MemMiB"] = tmp.MemMiB
-				ctx.Data["ShareMemMiB"] = tmp.ShareMemMiB
-				break
-
-			}
-		}
-	}
-
-	if !hasSpec && cloudbrain.SpecialPools != nil {
-
-		for _, specialPool := range cloudbrain.SpecialPools.Pools {
-
-			if specialPool.ResourceSpec != nil {
-
-				for _, spec := range specialPool.ResourceSpec {
-					if task.ResourceSpecId == spec.Id {
-						ctx.Data["GpuNum"] = spec.GpuNum
-						ctx.Data["CpuNum"] = spec.CpuNum
-						ctx.Data["MemMiB"] = spec.MemMiB
-						ctx.Data["ShareMemMiB"] = spec.ShareMemMiB
-						break
-					}
-				}
-			}
-		}
+	prepareSpec4Show(ctx, task)
+	if ctx.Written() {
+		return
 	}
 
 	if result != nil {
 		jobRes, _ := models.ConvertToJobResultPayload(result.Payload)
-		jobRes.Resource.Memory = strings.ReplaceAll(jobRes.Resource.Memory, "Mi", "MB")
-		spec := "GPU数：" + strconv.Itoa(jobRes.Resource.NvidiaComGpu) + "，CPU数：" + strconv.Itoa(jobRes.Resource.CPU) + "，内存(MB):" + jobRes.Resource.Memory
-		ctx.Data["resource_spec"] = spec
-		if task.JobType == string(models.JobTypeTrain) {
-			if trainGpuInfos == nil {
-				json.Unmarshal([]byte(setting.TrainGpuTypes), &trainGpuInfos)
-			}
-			for _, resourceType := range trainGpuInfos.GpuInfo {
-				if resourceType.Queue == jobRes.Config.GpuType {
-					ctx.Data["resource_type"] = resourceType.Value
-				}
-			}
-
-		} else if task.JobType == string(models.JobTypeInference) {
-			if inferenceGpuInfos == nil {
-				json.Unmarshal([]byte(setting.InferenceGpuTypes), &inferenceGpuInfos)
-			}
-			for _, resourceType := range inferenceGpuInfos.GpuInfo {
-				if resourceType.Queue == jobRes.Config.GpuType {
-					ctx.Data["resource_type"] = resourceType.Value
-				}
-			}
-		} else if cloudbrain.IsBenchmarkJob(task.JobType) {
-			if benchmarkGpuInfos == nil {
-				json.Unmarshal([]byte(setting.BenchmarkGpuTypes), &benchmarkGpuInfos)
-			}
-
-			for _, resourceType := range benchmarkGpuInfos.GpuInfo {
-				if resourceType.Queue == jobRes.Config.GpuType {
-					ctx.Data["resource_type"] = resourceType.Value
-				}
-			}
-
-		} else {
-			if gpuInfos == nil {
-				json.Unmarshal([]byte(setting.GpuTypes), &gpuInfos)
-			}
-			for _, resourceType := range gpuInfos.GpuInfo {
-				if resourceType.Queue == jobRes.Config.GpuType {
-					ctx.Data["resource_type"] = resourceType.Value
-				}
-			}
-		}
-
-		if cloudbrain.SpecialPools != nil {
-			for _, specialPool := range cloudbrain.SpecialPools.Pools {
-				for _, resourceType := range specialPool.Pool {
-					if resourceType.Queue == jobRes.Config.GpuType {
-						ctx.Data["resource_type"] = resourceType.Value
-					}
-				}
-			}
-		}
 		taskRoles := jobRes.TaskRoles
 		taskRes, _ := models.ConvertToTaskPod(taskRoles[cloudbrain.SubTaskName].(map[string]interface{}))
 		ctx.Data["taskRes"] = taskRes
@@ -988,6 +873,86 @@ func CloudBrainDebug(ctx *context.Context) {
 	ctx.Redirect(debugUrl)
 }
 
+func prepareSpec4Show(ctx *context.Context, task *models.Cloudbrain) {
+	s, err := resource.GetCloudbrainSpec(task.ID)
+	if err != nil {
+		log.Info("error:" + err.Error())
+		ctx.NotFound(ctx.Req.URL.RequestURI(), nil)
+		return
+	}
+
+	ctx.Data["Spec"] = s
+}
+
+func oldPrepareSpec4Show(ctx *context.Context, task *models.Cloudbrain) {
+	hasSpec := false
+	if task.JobType == string(models.JobTypeTrain) {
+		if cloudbrain.TrainResourceSpecs == nil {
+			json.Unmarshal([]byte(setting.TrainResourceSpecs), &cloudbrain.TrainResourceSpecs)
+		}
+
+		for _, tmp := range cloudbrain.TrainResourceSpecs.ResourceSpec {
+			if tmp.Id == task.ResourceSpecId {
+				hasSpec = true
+				ctx.Data["GpuNum"] = tmp.GpuNum
+				ctx.Data["CpuNum"] = tmp.CpuNum
+				ctx.Data["MemMiB"] = tmp.MemMiB
+				ctx.Data["ShareMemMiB"] = tmp.ShareMemMiB
+				break
+			}
+		}
+
+	} else if task.JobType == string(models.JobTypeInference) {
+		if cloudbrain.InferenceResourceSpecs == nil {
+			json.Unmarshal([]byte(setting.InferenceResourceSpecs), &cloudbrain.InferenceResourceSpecs)
+		}
+		for _, tmp := range cloudbrain.InferenceResourceSpecs.ResourceSpec {
+			if tmp.Id == task.ResourceSpecId {
+				hasSpec = true
+				ctx.Data["GpuNum"] = tmp.GpuNum
+				ctx.Data["CpuNum"] = tmp.CpuNum
+				ctx.Data["MemMiB"] = tmp.MemMiB
+				ctx.Data["ShareMemMiB"] = tmp.ShareMemMiB
+				break
+			}
+		}
+	} else {
+		if cloudbrain.ResourceSpecs == nil {
+			json.Unmarshal([]byte(setting.ResourceSpecs), &cloudbrain.ResourceSpecs)
+		}
+		for _, tmp := range cloudbrain.ResourceSpecs.ResourceSpec {
+			if tmp.Id == task.ResourceSpecId {
+				hasSpec = true
+				ctx.Data["GpuNum"] = tmp.GpuNum
+				ctx.Data["CpuNum"] = tmp.CpuNum
+				ctx.Data["MemMiB"] = tmp.MemMiB
+				ctx.Data["ShareMemMiB"] = tmp.ShareMemMiB
+				break
+
+			}
+		}
+	}
+
+	if !hasSpec && cloudbrain.SpecialPools != nil {
+
+		for _, specialPool := range cloudbrain.SpecialPools.Pools {
+
+			if specialPool.ResourceSpec != nil {
+
+				for _, spec := range specialPool.ResourceSpec {
+					if task.ResourceSpecId == spec.Id {
+						ctx.Data["GpuNum"] = spec.GpuNum
+						ctx.Data["CpuNum"] = spec.CpuNum
+						ctx.Data["MemMiB"] = spec.MemMiB
+						ctx.Data["ShareMemMiB"] = spec.ShareMemMiB
+						break
+					}
+				}
+			}
+		}
+	}
+}
+
 func CloudBrainCommitImageShow(ctx *context.Context) {
 	ctx.Data["PageIsCloudBrain"] = true
 	ctx.Data["Type"] = ctx.Cloudbrain.Type

services/cloudbrain/resource/resource_specification.go

@@ -230,3 +230,43 @@ func GetAndCheckSpec(userId int64, specId int64, opts models.FindSpecsOptions) (
 	}
 	return r[0], nil
 }
+
+func InsertCloudbrainSpec(cloudbrainId int64, s *models.Specification) error {
+	c := models.CloudbrainSpec{
+		CloudbrainID:    cloudbrainId,
+		SpecId:          s.ID,
+		SourceSpecId:    s.SourceSpecId,
+		AccCardsNum:     s.AccCardsNum,
+		AccCardType:     s.AccCardType,
+		CpuCores:        s.CpuCores,
+		MemGiB:          s.MemGiB,
+		GPUMemGiB:       s.GPUMemGiB,
+		ShareMemGiB:     s.ShareMemGiB,
+		ComputeResource: s.ComputeResource,
+		UnitPrice:       s.UnitPrice,
+		QueueId:         s.QueueId,
+		QueueCode:       s.QueueCode,
+		Cluster:         s.Cluster,
+		AiCenterCode:    s.AiCenterCode,
+		AiCenterName:    s.AiCenterName,
+		IsExclusive:     s.IsExclusive,
+		ExclusiveOrg:    s.ExclusiveOrg,
+	}
+	_, err := models.InsertCloudbrainSpec(c)
+	if err != nil {
+		log.Error("InsertCloudbrainSpec error.CloudbrainSpec=%v. err=%v", c, err)
+		return err
+	}
+	return nil
+}
+
+func GetCloudbrainSpec(cloudbrainId int64) (*models.Specification, error) {
+	c, err := models.GetCloudbrainSpecByID(cloudbrainId)
+	if err != nil {
+		return nil, err
+	}
+	if c == nil {
+		return nil, nil
+	}
+	return c.ConvertToSpecification(), nil
+}