JCS-pub/client/internal/http/v1/object.go

package http

import (
	"fmt"
	"io"
	"mime"
	"mime/multipart"
	"net/http"
	"net/url"
	"path"
	"path/filepath"

	"github.com/gin-gonic/gin"
	"gitlink.org.cn/cloudream/common/pkgs/logger"
	"gitlink.org.cn/cloudream/common/utils/http2"
	"gitlink.org.cn/cloudream/common/utils/math2"
	"gitlink.org.cn/cloudream/common/utils/serder"
	"gitlink.org.cn/cloudream/jcs-pub/client/internal/downloader"
	"gitlink.org.cn/cloudream/jcs-pub/client/internal/http/types"
	cliapi "gitlink.org.cn/cloudream/jcs-pub/client/sdk/api/v1"
	clitypes "gitlink.org.cn/cloudream/jcs-pub/client/types"
	"gitlink.org.cn/cloudream/jcs-pub/common/ecode"
)

type ObjectService struct {
	*Server
}

func (s *Server) Object() *ObjectService {
	return &ObjectService{
		Server: s,
	}
}

func (s *ObjectService) ListByPath(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.ListByPath")

	var req cliapi.ObjectListByPath
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, err := s.svc.ObjectSvc().GetByPath(req)
	if err != nil {
		log.Warnf("listing objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("listing objects: %v", err)))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(resp))
}

func (s *ObjectService) ListByIDs(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.ListByIDs")

	var req cliapi.ObjectListByIDs
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	objs, err := s.svc.ObjectSvc().GetByIDs(req.ObjectIDs)
	if err != nil {
		log.Warnf("listing objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("listing objects: %v", err)))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectListByIDsResp{Objects: objs}))
}

func (s *ObjectService) Upload(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.Upload")

	contType := ctx.GetHeader("Content-Type")

	mtype, params, err := mime.ParseMediaType(contType)
	if err != nil {
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "parse content-type: %v", err))
		return
	}
	if mtype != http2.ContentTypeMultiPart {
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "content-type %v not supported", mtype))
		return
	}

	boundary := params["boundary"]
	if boundary == "" {
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "missing boundary in content-type"))
		return
	}

	mr := multipart.NewReader(ctx.Request.Body, boundary)

	p, err := mr.NextPart()
	if err != nil {
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "read next part: %v", err))
		return
	}

	var info cliapi.ObjectUploadInfo
	err = serder.JSONToObjectStream(p, &info)
	if err != nil {
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "parse upload info: %v", err))
		return
	}

	if info.PackageID == 0 {
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "missing packageID in upload info"))
		return
	}

	copyToPath := make([]clitypes.JPath, 0, len(info.CopyToPath))
	for _, p := range info.CopyToPath {
		copyToPath = append(copyToPath, clitypes.PathFromJcsPathString(p))
	}

	up, err := s.svc.Uploader.BeginUpdate(info.PackageID, info.Affinity, info.CopyTo, copyToPath)
	if err != nil {
		log.Warnf("begin update: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("begin update: %v", err)))
		return
	}
	defer up.Abort()

	var pathes []string

	for {
		file, err := mr.NextPart()
		if err == io.EOF {
			break
		}
		if err != nil {
			log.Warnf("read next part: %s", err.Error())
			ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("read next part: %v", err)))
			return
		}

		path, err := url.PathUnescape(file.FileName())
		if err != nil {
			log.Warnf("unescape filename: %s", err.Error())
			ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("unescape filename %v: %v", file.FileName(), err)))
			return
		}
		path = filepath.ToSlash(path)

		err = up.Upload(clitypes.PathFromJcsPathString(path), file)
		if err != nil {
			log.Warnf("uploading file: %s", err.Error())
			ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("uploading file %v: %v", file.FileName(), err)))
			return
		}
		pathes = append(pathes, path)
	}

	ret, err := up.Commit()
	if err != nil {
		log.Warnf("commit update: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("commit update: %v", err)))
		return
	}

	uploadeds := make([]clitypes.Object, len(pathes))
	for i := range pathes {
		uploadeds[i] = ret.Objects[pathes[i]]
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectUploadResp{Uploadeds: uploadeds}))
}

func (s *ObjectService) Download(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.Download")

	var req cliapi.ObjectDownload
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	off := req.Offset
	len := int64(-1)
	if req.Length != nil {
		len = *req.Length
	}

	file, err := s.svc.ObjectSvc().Download(downloader.DownloadReqeust{
		ObjectID: req.ObjectID,
		Offset:   off,
		Length:   len,
	})
	if err != nil {
		log.Warnf("downloading object: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "download object failed"))
		return
	}
	if file.File == nil {
		log.Warnf("object not found: %d", req.ObjectID)
		ctx.JSON(http.StatusOK, types.Failed(ecode.DataNotFound, "object not found"))
		return
	}
	defer file.File.Close()

	ctx.Header("Content-Disposition", "attachment; filename="+url.PathEscape(path.Base(file.Object.Path)))
	ctx.Header("Content-Type", "application/octet-stream")
	ctx.Header("Content-Transfer-Encoding", "binary")

	n, err := io.Copy(ctx.Writer, file.File)
	if err != nil {
		log.Warnf("copying file: %s", err.Error())
	}

	// TODO 当client不在某个代理节点上时如何处理？
	if s.cfg.UserSpaceID > 0 {
		s.svc.AccessStat.AddAccessCounter(file.Object.ObjectID, file.Object.PackageID, s.cfg.UserSpaceID, math2.DivOrDefault(float64(n), float64(file.Object.Size), 1))
	}
}

func (s *ObjectService) DownloadByPath(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.DownloadByPath")

	var req cliapi.ObjectDownloadByPath
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, err := s.svc.ObjectSvc().GetByPath(cliapi.ObjectListByPath{
		PackageID: req.PackageID, Path: req.Path,
	})
	if err != nil {
		log.Warnf("getting object by path: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "get object by path failed"))
		return
	}

	if len(resp.Objects) == 0 {
		log.Warnf("object not found: %s", req.Path)
		ctx.JSON(http.StatusOK, types.Failed(ecode.DataNotFound, "object not found"))
		return
	}

	off := req.Offset
	len := int64(-1)
	if req.Length != nil {
		len = *req.Length
	}

	file, err := s.svc.ObjectSvc().Download(downloader.DownloadReqeust{
		ObjectID: resp.Objects[0].ObjectID,
		Offset:   off,
		Length:   len,
	})
	if err != nil {
		log.Warnf("downloading object: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "download object failed"))
		return
	}
	defer file.File.Close()

	ctx.Header("Content-Disposition", "attachment; filename="+url.PathEscape(path.Base(file.Object.Path)))
	ctx.Header("Content-Type", "application/octet-stream")
	ctx.Header("Content-Transfer-Encoding", "binary")

	n, err := io.Copy(ctx.Writer, file.File)
	if err != nil {
		log.Warnf("copying file: %s", err.Error())
	}

	if s.cfg.UserSpaceID > 0 {
		s.svc.AccessStat.AddAccessCounter(file.Object.ObjectID, file.Object.PackageID, s.cfg.UserSpaceID, math2.DivOrDefault(float64(n), float64(file.Object.Size), 1))
	}
}

func (s *ObjectService) UpdateInfo(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.UpdateInfo")

	var req cliapi.ObjectUpdateInfo
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	sucs, err := s.svc.ObjectSvc().UpdateInfo(req.Updatings)
	if err != nil {
		log.Warnf("updating objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "update objects failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectUpdateInfoResp{Successes: sucs}))
}

func (s *ObjectService) UpdateInfoByPath(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.UpdateInfoByPath")

	var req cliapi.ObjectUpdateInfoByPath
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, err := s.svc.ObjectSvc().GetByPath(cliapi.ObjectListByPath{
		PackageID: req.PackageID, Path: req.Path,
	})
	if err != nil {
		log.Warnf("getting object by path: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "get object by path failed"))
		return
	}
	if len(resp.Objects) == 0 {
		log.Warnf("object not found: %s", req.Path)
		ctx.JSON(http.StatusOK, types.Failed(ecode.DataNotFound, "object not found"))
		return
	}

	sucs, err := s.svc.ObjectSvc().UpdateInfo([]cliapi.UpdatingObject{{
		ObjectID:   resp.Objects[0].ObjectID,
		UpdateTime: req.UpdateTime,
	}})
	if err != nil {
		log.Warnf("updating objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "update objects failed"))
		return
	}
	if len(sucs) == 0 {
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectUpdateInfoByPathResp{}))
}

func (s *ObjectService) Move(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.Move")

	var req cliapi.ObjectMove
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	sucs, err := s.svc.ObjectSvc().Move(req.Movings)
	if err != nil {
		log.Warnf("moving objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "move objects failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectMoveResp{Successes: sucs}))
}

func (s *ObjectService) Delete(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.Delete")

	var req cliapi.ObjectDelete
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	err := s.svc.ObjectSvc().Delete(req.ObjectIDs)
	if err != nil {
		log.Warnf("deleting objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "delete objects failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(nil))
}

func (s *ObjectService) DeleteByPath(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.DeleteByPath")

	var req cliapi.ObjectDeleteByPath
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, err := s.svc.ObjectSvc().GetByPath(cliapi.ObjectListByPath{
		PackageID: req.PackageID, Path: req.Path,
	})
	if err != nil {
		log.Warnf("getting object by path: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "get object by path failed"))
		return
	}
	if len(resp.Objects) == 0 {
		ctx.JSON(http.StatusOK, types.OK(nil))
		return
	}

	err = s.svc.ObjectSvc().Delete([]clitypes.ObjectID{resp.Objects[0].ObjectID})
	if err != nil {
		log.Warnf("deleting objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "delete objects failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(nil))
}

func (s *ObjectService) Clone(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.Clone")

	var req cliapi.ObjectClone
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	objs, err := s.svc.ObjectSvc().Clone(req.Clonings)
	if err != nil {
		log.Warnf("cloning object: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "clone object failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectCloneResp{Objects: objs}))
}

func (s *ObjectService) GetPackageObjects(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.GetPackageObjects")

	var req cliapi.ObjectGetPackageObjects
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	objs, err := s.svc.ObjectSvc().GetPackageObjects(req.PackageID)
	if err != nil {
		log.Warnf("getting package objects: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "get package object failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectGetPackageObjectsResp{Objects: objs}))
}

func (s *ObjectService) NewMultipartUpload(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.NewMultipartUpload")

	var req cliapi.ObjectNewMultipartUpload
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	obj, err := s.svc.ObjectSvc().NewMultipartUploadObject(req.PackageID, req.Path)
	if err != nil {
		log.Warnf("new multipart upload object: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "new multipart upload object failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectNewMultipartUploadResp{Object: obj}))
}

type ObjectUploadPartReq struct {
	Info cliapi.ObjectUploadPartInfo `form:"info" binding:"required"`
	File *multipart.FileHeader       `form:"file"`
}

func (s *ObjectService) UploadPart(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.UploadPart")

	var req ObjectUploadPartReq
	if err := ctx.ShouldBind(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	file, err := req.File.Open()
	if err != nil {
		log.Warnf("open file: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "open file failed"))
		return
	}
	defer file.Close()

	err = s.svc.Uploader.UploadPart(req.Info.ObjectID, req.Info.Index, file)
	if err != nil {
		log.Warnf("uploading part: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("upload part: %v", err)))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectUploadPartResp{}))
}

func (s *ObjectService) CompleteMultipartUpload(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Object.CompleteMultipartUpload")

	var req cliapi.ObjectCompleteMultipartUpload
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	obj, err := s.svc.ObjectSvc().CompleteMultipartUpload(req.ObjectID, req.Indexes)
	if err != nil {
		log.Warnf("completing multipart upload: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("complete multipart upload: %v", err)))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.ObjectCompleteMultipartUploadResp{Object: obj}))
}