JCS-pub/client/internal/services/user_space.go

package services

import (
	"context"
	"fmt"

	"github.com/samber/lo"
	"gitlink.org.cn/cloudream/common/pkgs/ioswitch/exec"
	"gitlink.org.cn/cloudream/common/pkgs/logger"
	clitypes "gitlink.org.cn/cloudream/jcs-pub/client/types"
	"gorm.io/gorm"

	"gitlink.org.cn/cloudream/jcs-pub/client/internal/db"
	"gitlink.org.cn/cloudream/jcs-pub/client/internal/downloader/strategy"
	cliapi "gitlink.org.cn/cloudream/jcs-pub/client/sdk/api/v1"
	"gitlink.org.cn/cloudream/jcs-pub/common/ecode"
	stgglb "gitlink.org.cn/cloudream/jcs-pub/common/globals"
	"gitlink.org.cn/cloudream/jcs-pub/common/pkgs/ioswitch2"
	"gitlink.org.cn/cloudream/jcs-pub/common/pkgs/ioswitch2/parser"
	"gitlink.org.cn/cloudream/jcs-pub/common/pkgs/publock/reqbuilder"
	"gitlink.org.cn/cloudream/jcs-pub/common/pkgs/storage/factory"
)

type UserSpaceService struct {
	*Service
}

func (svc *Service) UserSpaceSvc() *UserSpaceService {
	return &UserSpaceService{Service: svc}
}

func (svc *UserSpaceService) Get(userspaceID clitypes.UserSpaceID) (clitypes.UserSpace, error) {
	return svc.DB.UserSpace().GetByID(svc.DB.DefCtx(), userspaceID)
}

func (svc *UserSpaceService) GetByName(name string) (clitypes.UserSpace, error) {
	return svc.DB.UserSpace().GetByName(svc.DB.DefCtx(), name)
}

func (svc *UserSpaceService) GetAll() ([]clitypes.UserSpace, error) {
	return svc.DB.UserSpace().GetAll(svc.DB.DefCtx())
}

func (svc *UserSpaceService) Create(req cliapi.UserSpaceCreate) (*cliapi.UserSpaceCreateResp, *ecode.CodeError) {
	db2 := svc.DB
	space, err := db.DoTx01(db2, func(tx db.SQLContext) (clitypes.UserSpace, error) {
		space, err := db2.UserSpace().GetByName(tx, req.Name)
		if err == nil {
			return clitypes.UserSpace{}, gorm.ErrDuplicatedKey
		}
		if err != gorm.ErrRecordNotFound {
			return clitypes.UserSpace{}, err
		}

		space = clitypes.UserSpace{
			Name:       req.Name,
			Storage:    req.Storage,
			Credential: req.Credential,
			ShardStore: req.ShardStore,
			Features:   req.Features,
			WorkingDir: clitypes.PathFromJcsPathString(req.WorkingDir),
			Revision:   0,
		}
		err = db2.UserSpace().Create(tx, &space)
		if err != nil {
			return clitypes.UserSpace{}, err
		}
		return space, nil
	})
	if err == gorm.ErrDuplicatedKey {
		return nil, ecode.New(ecode.DataExists, "user space name already exists")
	}
	if err != nil {
		return nil, ecode.Newf(ecode.OperationFailed, "%v", err)
	}
	return &cliapi.UserSpaceCreateResp{UserSpace: space}, nil
}

func (svc *UserSpaceService) Update(req cliapi.UserSpaceUpdate) (*cliapi.UserSpaceUpdateResp, *ecode.CodeError) {
	db2 := svc.DB
	space, err := db.DoTx01(db2, func(tx db.SQLContext) (clitypes.UserSpace, error) {
		space, err := db2.UserSpace().GetByID(tx, req.UserSpaceID)
		if err != nil {
			return clitypes.UserSpace{}, err
		}

		if space.Name != req.Name {
			_, err = db2.UserSpace().GetByName(tx, req.Name)
			if err == nil {
				return clitypes.UserSpace{}, gorm.ErrDuplicatedKey
			}
			if err != gorm.ErrRecordNotFound {
				return clitypes.UserSpace{}, err
			}
		}

		space.Name = req.Name
		space.Credential = req.Credential
		space.Features = req.Features
		space.Revision += 1
		return space, db2.UserSpace().UpdateColumns(tx, space, "Name", "Credential", "Features", "Revision")
	})
	if err == gorm.ErrDuplicatedKey {
		return nil, ecode.New(ecode.DataExists, "user space name already exists")
	}
	if err != nil {
		return nil, ecode.Newf(ecode.OperationFailed, "%v", err)
	}

	// 通知元数据缓存无效
	svc.UserSpaceMeta.Drop([]clitypes.UserSpaceID{req.UserSpaceID})

	// 通知存储服务组件池停止组件。TODO 对于在Hub上运行的组件，需要一个机制去定时清理
	svc.StgPool.Drop(stgglb.UserID, space.UserSpaceID)

	// TODO 考虑加锁再进行操作

	return &cliapi.UserSpaceUpdateResp{UserSpace: space}, nil
}

func (svc *UserSpaceService) Delete(req cliapi.UserSpaceDelete) (*cliapi.UserSpaceDeleteResp, *ecode.CodeError) {
	db2 := svc.DB
	err := db2.DoTx(func(tx db.SQLContext) error {
		err := db2.UserSpace().DeleteByID(tx, req.UserSpaceID)
		if err != nil {
			return err
		}

		err = db2.ObjectBlock().DeleteByUserSpaceID(tx, req.UserSpaceID)
		if err != nil {
			return err
		}

		err = db2.PinnedObject().DeleteByUserSpaceID(tx, req.UserSpaceID)
		if err != nil {
			return err
		}

		err = db2.ObjectAccessStat().DeleteByUserSpaceID(tx, req.UserSpaceID)
		if err != nil {
			return err
		}

		err = db2.PackageAccessStat().DeleteByUserSpaceID(tx, req.UserSpaceID)
		if err != nil {
			return err
		}

		return nil
	})
	if err != nil {
		return nil, ecode.Newf(ecode.OperationFailed, "%v", err)
	}

	// 通知元数据缓存无效
	svc.UserSpaceMeta.Drop([]clitypes.UserSpaceID{req.UserSpaceID})

	// 通知存储服务组件池停止组件。TODO 对于在Hub上运行的组件，需要一个机制去定时清理
	svc.StgPool.Drop(stgglb.UserID, req.UserSpaceID)

	// TODO 考虑加锁再进行操作，并且增加机制打断已经在进行的操作。

	return &cliapi.UserSpaceDeleteResp{}, nil
}

func (svc *UserSpaceService) Test(req cliapi.UserSpaceTest) (*cliapi.UserSpaceTestResp, *ecode.CodeError) {
	detail := clitypes.UserSpaceDetail{
		UserID: stgglb.UserID,
		UserSpace: clitypes.UserSpace{
			Name:       "test",
			Storage:    req.Storage,
			Credential: req.Credential,
			WorkingDir: clitypes.PathFromJcsPathString(req.WorikingDir),
		},
	}
	blder := factory.GetBuilder(&detail)
	baseStore, err := blder.CreateBaseStore(false)
	if err != nil {
		return nil, ecode.Newf(ecode.OperationFailed, "%v", err)
	}

	err = baseStore.Test()
	if err != nil {
		return nil, ecode.Newf(ecode.OperationFailed, "%v", err)
	}

	return &cliapi.UserSpaceTestResp{}, nil
}

func (svc *UserSpaceService) DownloadPackage(packageID clitypes.PackageID, userspaceID clitypes.UserSpaceID, rootPath string) error {
	destStg := svc.UserSpaceMeta.Get(userspaceID)
	if destStg == nil {
		return fmt.Errorf("userspace not found: %d", userspaceID)
	}

	details, err := db.DoTx11(svc.DB, svc.DB.Object().GetPackageObjectDetails, packageID)
	if err != nil {
		return err
	}

	mutex, err := reqbuilder.NewBuilder().
		UserSpace().Buzy(userspaceID).
		MutexLock(svc.PubLock)
	if err != nil {
		return fmt.Errorf("acquire locks failed, err: %w", err)
	}
	defer mutex.Unlock()

	rootJPath := clitypes.PathFromJcsPathString(rootPath)

	dIndex := 0
	var pinned []clitypes.PinnedObject
	for dIndex < len(details) {
		plans := exec.NewPlanBuilder()
		for i := 0; i < 10 && dIndex < len(details); i++ {
			strg, err := svc.StrategySelector.Select(strategy.Request{
				Detail:       details[dIndex],
				DestLocation: destStg.UserSpace.Storage.GetLocation(),
			})
			if err != nil {
				return fmt.Errorf("select download strategy: %w", err)
			}

			ft := ioswitch2.NewFromTo()
			switch strg := strg.(type) {
			case *strategy.DirectStrategy:
				ft.AddFrom(ioswitch2.NewFromShardstore(strg.Detail.Object.FileHash, strg.UserSpace, ioswitch2.RawStream()))

			case *strategy.ECReconstructStrategy:
				for i, b := range strg.Blocks {
					ft.AddFrom(ioswitch2.NewFromShardstore(b.FileHash, strg.UserSpaces[i], ioswitch2.ECStream(b.Index)))
					ft.ECParam = &strg.Redundancy
				}
			default:
				return fmt.Errorf("unsupported download strategy: %T", strg)
			}

			objPath := clitypes.PathFromJcsPathString(details[dIndex].Object.Path)
			dstPath := rootJPath.ConcatNew(objPath)
			ft.AddTo(ioswitch2.NewToBaseStore(*destStg, dstPath))
			// 顺便保存到同存储服务的分片存储中
			// if destStg.UserSpace.ShardStore != nil {
			// 	ft.AddTo(ioswitch2.NewToShardStore(*destStg, ioswitch2.RawStream(), ""))
			// 	pinned = append(pinned, clitypes.PinnedObject{
			// 		ObjectID:    details[dIndex].Object.ObjectID,
			// 		UserSpaceID: destStg.UserSpace.UserSpaceID,
			// 		CreateTime:  time.Now(),
			// 	})
			// }

			err = parser.Parse(ft, plans)
			if err != nil {
				return fmt.Errorf("parse plan: %w", err)
			}
			dIndex++
		}

		// 记录访问统计
		for _, obj := range details {
			svc.AccessStat.AddAccessCounter(obj.Object.ObjectID, packageID, userspaceID, 1)
		}
		exeCtx := exec.NewExecContext()
		exec.SetValueByType(exeCtx, svc.StgPool)
		drv := plans.Execute(exeCtx)
		_, err = drv.Wait(context.Background())
		if err != nil {
			return err
		}

		err = svc.DB.DoTx(func(tx db.SQLContext) error {
			objIDs := make([]clitypes.ObjectID, len(pinned))
			for i, obj := range pinned {
				objIDs[i] = obj.ObjectID
			}

			avaiIDs, err := svc.DB.Object().BatchTestObjectID(tx, objIDs)
			if err != nil {
				return err
			}

			pinned = lo.Filter(pinned, func(p clitypes.PinnedObject, idx int) bool { return avaiIDs[p.ObjectID] })
			return svc.DB.PinnedObject().BatchTryCreate(svc.DB.DefCtx(), pinned)
		})
		if err != nil {
			logger.Warnf("create pinned objects: %v", err)
		}
	}

	return nil
}