725 lines
22 KiB
Go
725 lines
22 KiB
Go
package http
|
|
|
|
import (
|
|
"github.com/gin-gonic/gin"
|
|
"gitlink.org.cn/cloudream/common/consts/errorcode"
|
|
"gitlink.org.cn/cloudream/common/pkgs/logger"
|
|
sch "gitlink.org.cn/cloudream/common/sdks/pcmscheduler"
|
|
schsdk "gitlink.org.cn/cloudream/common/sdks/scheduler"
|
|
cdssdk "gitlink.org.cn/cloudream/common/sdks/storage"
|
|
uploadersdk "gitlink.org.cn/cloudream/common/sdks/uploader"
|
|
"gitlink.org.cn/cloudream/common/utils/serder"
|
|
schglb "gitlink.org.cn/cloudream/scheduler/common/globals"
|
|
schmod "gitlink.org.cn/cloudream/scheduler/common/models"
|
|
jobTask "gitlink.org.cn/cloudream/scheduler/schedulerMiddleware/internal/manager/task"
|
|
"io"
|
|
"net/http"
|
|
"strconv"
|
|
)
|
|
|
|
type JobSetService struct {
|
|
*Server
|
|
}
|
|
|
|
func (s *Server) JobSetSvc() *JobSetService {
|
|
return &JobSetService{
|
|
Server: s,
|
|
}
|
|
}
|
|
|
|
type JobSetSubmitResp struct {
|
|
JobSetID schsdk.JobSetID `json:"jobSetID"`
|
|
FilesUploadScheme schsdk.JobSetFilesUploadScheme `json:"filesUploadScheme"`
|
|
}
|
|
|
|
type JobSetSubmitReq struct {
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
JobSetInfo schsdk.JobSetInfo `json:"jobSetInfo" binding:"required"`
|
|
}
|
|
|
|
func (s *JobSetService) Submit(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.Submit")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
|
|
req, err := serder.JSONToObjectEx[JobSetSubmitReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
blockChainToken := ctx.Request.Header.Get("Authorization")
|
|
|
|
schScheme, uploadScheme, err := s.svc.JobSetSvc().PreScheduler(req.JobSetInfo)
|
|
if err != nil {
|
|
log.Warnf("pre-scheduling jobset: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "pre-scheduling jobset failed"))
|
|
return
|
|
}
|
|
|
|
jobsetID, err := s.svc.JobSetSvc().Submit(req.UserID, req.JobSetInfo, schScheme, blockChainToken)
|
|
if err != nil {
|
|
log.Warnf("submitting jobset: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "submit jobset failed"))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(JobSetSubmitResp{
|
|
JobSetID: *jobsetID,
|
|
FilesUploadScheme: *uploadScheme,
|
|
}))
|
|
}
|
|
|
|
type JobSetLocalFileUploadedReq struct {
|
|
JobSetID schsdk.JobSetID `json:"jobSetID" binding:"required"`
|
|
LocalPath string `json:"localPath" binding:"required"`
|
|
Error string `json:"error"`
|
|
PackageID cdssdk.PackageID `json:"packageID"`
|
|
ObjectIDs []cdssdk.ObjectID `json:"objectIDs"`
|
|
}
|
|
|
|
func (s *JobSetService) LocalFileUploaded(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.LocalFileUploaded")
|
|
|
|
var req JobSetLocalFileUploadedReq
|
|
if err := ctx.ShouldBindJSON(&req); err != nil {
|
|
log.Warnf("binding body: %s", err.Error())
|
|
ctx.JSON(http.StatusBadRequest, Failed(errorcode.BadArgument, "missing argument or invalid argument"))
|
|
return
|
|
}
|
|
|
|
s.svc.JobSetSvc().LocalFileUploaded(req.JobSetID, req.LocalPath, req.Error, req.PackageID, req.ObjectIDs)
|
|
|
|
ctx.JSON(http.StatusOK, OK(nil))
|
|
}
|
|
|
|
type UploadReq struct {
|
|
UserID cdssdk.UserID `json:"userID"`
|
|
UploadParams sch.UploadParams `json:"uploadParams"`
|
|
}
|
|
|
|
//type UploadResp struct {
|
|
// JobSetID schsdk.JobSetID `json:"jobSetID"`
|
|
// LocalPath string `json:"localPath"`
|
|
// StorageIDs []cdssdk.StorageID `json:"storageIDs"`
|
|
// BucketID cdssdk.BucketID `json:"bucketID"`
|
|
//}
|
|
|
|
func (s *JobSetService) Upload2(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.Upload")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[UploadReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
blockChainToken := ctx.Request.Header.Get("Authorization")
|
|
task := jobTask.NewJobTask[sch.TaskMessage]()
|
|
|
|
_, err = s.svc.JobSetSvc().Upload(req.UserID, req.UploadParams, blockChainToken, task)
|
|
if err != nil {
|
|
log.Warnf("uploading file: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "upload file failed, error: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
//ctx.JSON(http.StatusOK, OK("success"))
|
|
|
|
flusher, ok := ctx.Writer.(http.Flusher)
|
|
if !ok {
|
|
http.Error(ctx.Writer, "Streaming not supported", http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
ctx.Writer.Header().Set("Cache-Control", "no-cache")
|
|
ctx.Writer.Header().Set("Content-Type", "text/event-stream")
|
|
|
|
for {
|
|
fut := task.Receive()
|
|
receive := <-fut.Chan()
|
|
|
|
if receive.Value.Status == sch.FailedStatus || receive.Value.Status == sch.SuccessStatus {
|
|
//i := 1
|
|
data := "event: message\ndata: " + receive.Value.Message + "\n\n"
|
|
_, err = ctx.Writer.Write([]byte(data))
|
|
println(receive.Value.Message)
|
|
if err != nil {
|
|
break
|
|
}
|
|
flusher.Flush()
|
|
ctx.Writer.CloseNotify()
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
func (s *JobSetService) Upload(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.Upload")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[UploadReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
blockChainToken := ctx.Request.Header.Get("Authorization")
|
|
task := jobTask.NewJobTask[sch.TaskMessage]()
|
|
|
|
_, err = s.svc.JobSetSvc().Upload(req.UserID, req.UploadParams, blockChainToken, task)
|
|
if err != nil {
|
|
log.Warnf("uploading file: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "upload file failed, error: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
for {
|
|
fut := task.Receive()
|
|
receive := <-fut.Chan()
|
|
|
|
if receive.Value.Status == sch.FailedStatus {
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "upload file failed, error: "+receive.Value.Message))
|
|
return
|
|
}
|
|
|
|
if receive.Value.Status == sch.SuccessStatus {
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
type UploadStatusReq struct {
|
|
Operate string `json:"operate"`
|
|
ID int64 `json:"id"`
|
|
UserID cdssdk.UserID `json:"userID"`
|
|
PackageID cdssdk.PackageID `json:"packageID"`
|
|
DataType string `json:"dataType"`
|
|
}
|
|
|
|
func (s *JobSetService) UploadStatus(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.Upload")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[UploadStatusReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
key := strconv.FormatInt(int64(req.UserID), 10) + strconv.FormatInt(int64(req.PackageID), 10) + req.DataType
|
|
if req.Operate == sch.Query {
|
|
if val, ok := schglb.UploadCache[key]; ok {
|
|
ctx.JSON(http.StatusOK, OK(val))
|
|
return
|
|
} else {
|
|
ctx.JSON(http.StatusOK, OK([]schmod.UploadStatus{}))
|
|
return
|
|
}
|
|
} else if req.Operate == sch.Delete {
|
|
if val, ok := schglb.UploadCache[key]; ok {
|
|
for _, s := range val {
|
|
if s.ID == req.ID {
|
|
val = append(val[:s.ID], val[s.ID+1:]...)
|
|
schglb.UploadCache[key] = val
|
|
break
|
|
}
|
|
}
|
|
ctx.JSON(http.StatusOK, OK("ok"))
|
|
return
|
|
} else {
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "not found"))
|
|
return
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
type CreateFolderReq struct {
|
|
PackageID cdssdk.PackageID `json:"packageID"`
|
|
Path string `json:"path"`
|
|
}
|
|
|
|
func (s *JobSetService) CreateFolder(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[CreateFolderReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().CreateFolder(req.PackageID, req.Path)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type DeleteFileReq struct {
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
ObjectIDs []cdssdk.ObjectID `json:"objectIDs" binding:"required"`
|
|
}
|
|
|
|
func (s *JobSetService) DeleteFile(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.DeleteFile")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[DeleteFileReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().DeleteFile(req.UserID, req.ObjectIDs)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "delete file failed"))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type DeleteFolderReq struct {
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
PackageID cdssdk.PackageID `json:"packageID" binding:"required"`
|
|
Path string `json:"path" binding:"required"`
|
|
}
|
|
|
|
func (s *JobSetService) DeleteFolder(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.DeleteFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[DeleteFolderReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().DeleteFolder(req.UserID, req.PackageID, req.Path)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "delete folder failed"))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type QueryUploadedReq struct {
|
|
QueryParams sch.QueryData `json:"queryParams" binding:"required"`
|
|
}
|
|
|
|
type QueryUploadedResp struct {
|
|
TotalPages int `json:"totalPages"`
|
|
TotalCount int `json:"totalCount"`
|
|
CurrentPage int `json:"currentPage"`
|
|
PageSize int `json:"pageSize"`
|
|
UploadedDatas []uploadersdk.Package `json:"uploadedDatas"`
|
|
}
|
|
|
|
func (s *JobSetService) QueryUploaded(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.QueryUploaded")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[QueryUploadedReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
uploadedDatas, totalPages, totalCount, err := s.svc.JobSetSvc().QueryUploaded(req.QueryParams)
|
|
if err != nil {
|
|
log.Warnf("getting service list: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "get upload data list failed, error: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(QueryUploadedResp{
|
|
TotalPages: totalPages,
|
|
TotalCount: totalCount,
|
|
CurrentPage: req.QueryParams.CurrentPage,
|
|
PageSize: req.QueryParams.PageSize,
|
|
UploadedDatas: uploadedDatas,
|
|
}))
|
|
}
|
|
|
|
type BindingReq struct {
|
|
ID uploadersdk.DataID `json:"ID"`
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
Info sch.DataBinding `json:"info" binding:"required"`
|
|
}
|
|
|
|
func (s *JobSetService) Binding(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.Binding")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[BindingReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().DataBinding(req.ID, req.UserID, req.Info)
|
|
if err != nil {
|
|
log.Warnf("getting service list: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "binding data failed, error: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type RemoveBindingReq struct {
|
|
PackageIDs []cdssdk.PackageID `json:"packageIDs"`
|
|
BindingIDs []int64 `json:"bindingIDs"`
|
|
}
|
|
|
|
func (s *JobSetService) RemoveBinding(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.Binding")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[RemoveBindingReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().RemoveBinding(req.PackageIDs, req.BindingIDs)
|
|
if err != nil {
|
|
log.Warnf("getting service list: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "remove binding failed, error: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type QueryBindingReq struct {
|
|
DataType string `json:"dataType" binding:"required"`
|
|
Param sch.QueryBindingDataParam `json:"param" binding:"required"`
|
|
Filters sch.QueryBindingFilters `json:"filters"`
|
|
}
|
|
|
|
type QueryBindingResp struct {
|
|
Datas []uploadersdk.BindingDetail `json:"datas"`
|
|
}
|
|
|
|
func (s *JobSetService) QueryBinding(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.QueryBinding")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[QueryBindingReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
details, err := s.svc.JobSetSvc().QueryBinding(req.DataType, req.Param, req.Filters)
|
|
if err != nil {
|
|
log.Warnf("getting service list: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "binding data failed, error: "+err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(QueryBindingResp{
|
|
Datas: details,
|
|
}))
|
|
}
|
|
|
|
type PackageCreate struct {
|
|
UserID cdssdk.UserID `json:"userID"`
|
|
Name string `json:"name"`
|
|
DataType string `json:"dataType"`
|
|
UploadPriority sch.UploadPriority `json:"uploadPriority"`
|
|
}
|
|
|
|
func (s *JobSetService) CreatePackage(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[PackageCreate](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().CreatePackage(req.UserID, req.Name, req.DataType, req.UploadPriority)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type PackageDelete struct {
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
PackageID cdssdk.PackageID `json:"packageID" binding:"required"`
|
|
}
|
|
|
|
func (s *JobSetService) DeletePackage(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[PackageDelete](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
err = s.svc.JobSetSvc().DeletePackage(req.UserID, req.PackageID)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK("success"))
|
|
}
|
|
|
|
type QueryResourceReq struct {
|
|
QueryResource sch.ResourceRange `json:"queryResource"`
|
|
}
|
|
|
|
type QueryResourceResp struct {
|
|
Resource []sch.ClusterDetail `json:"resource"`
|
|
}
|
|
|
|
func (s *JobSetService) QueryResource(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[QueryResourceReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
resource, err := s.svc.JobSetSvc().QueryResource(req.QueryResource)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(QueryResourceResp{
|
|
Resource: resource,
|
|
}))
|
|
}
|
|
|
|
type QueryResourceRangeReq struct {
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
}
|
|
|
|
type QueryResourceRangeResp struct {
|
|
ResourceRanges []sch.ResourceRange `json:"resourceRanges"`
|
|
}
|
|
|
|
func (s *JobSetService) ResourceRange(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[QueryResourceRangeReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
println(req.UserID)
|
|
|
|
resource, err := s.svc.JobSetSvc().ResourceRange()
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(QueryResourceRangeResp{
|
|
ResourceRanges: resource,
|
|
}))
|
|
}
|
|
|
|
type QueryImagesReq struct {
|
|
IDs []int64 `json:"ids" binding:"required"`
|
|
}
|
|
|
|
type QueryImagesResp struct {
|
|
Images []sch.ClusterImage `json:"images"`
|
|
}
|
|
|
|
func (s *JobSetService) QueryImages(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[QueryImagesReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
images, err := s.svc.JobSetSvc().QueryImages(req.IDs)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(QueryImagesResp{
|
|
Images: images,
|
|
}))
|
|
}
|
|
|
|
type UpdateCodeReq struct {
|
|
UserID cdssdk.UserID `json:"userID" binding:"required"`
|
|
BucketID cdssdk.BucketID `json:"bucketID" binding:"required"`
|
|
PackageID cdssdk.PackageID `json:"packageID" binding:"required"`
|
|
PackageName string `json:"packageName" binding:"required"`
|
|
//Version int64 `json:"version" binding:"required"`
|
|
}
|
|
|
|
type UpdateCodeResp struct {
|
|
Package cdssdk.Package `json:"newPackage"`
|
|
}
|
|
|
|
func (s *JobSetService) UpdateCode(ctx *gin.Context) {
|
|
log := logger.WithField("HTTP", "JobSet.CreateFolder")
|
|
|
|
bodyData, err := io.ReadAll(ctx.Request.Body)
|
|
if err != nil {
|
|
log.Warnf("reading request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "read request body failed"))
|
|
return
|
|
}
|
|
req, err := serder.JSONToObjectEx[UpdateCodeReq](bodyData)
|
|
if err != nil {
|
|
log.Warnf("parsing request body: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, "parse request body failed"))
|
|
return
|
|
}
|
|
|
|
pkg, err := s.svc.JobSetSvc().UpdateCode(req.UserID, req.BucketID, req.PackageID, req.PackageName)
|
|
|
|
if err != nil {
|
|
log.Warnf("creating folder: %s", err.Error())
|
|
ctx.JSON(http.StatusOK, Failed(errorcode.OperationFailed, err.Error()))
|
|
return
|
|
}
|
|
|
|
ctx.JSON(http.StatusOK, OK(UpdateCodeResp{
|
|
Package: *pkg,
|
|
}))
|
|
}
|