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

package services

import (
	"context"
	"fmt"

	"gitlink.org.cn/cloudream/common/pkgs/ioswitch/exec"
	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
	}

	rootJPath := clitypes.PathFromJcsPathString(rootPath)

	var pinned []clitypes.ObjectID
	plans := exec.NewPlanBuilder()
	for _, obj := range details {
		strg, err := svc.StrategySelector.Select(strategy.Request{
			Detail:       obj,
			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(obj.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, obj.Object.ObjectID)
		}

		err = parser.Parse(ft, plans)
		if err != nil {
			return fmt.Errorf("parse plan: %w", 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()

	// 记录访问统计
	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
	}

	return nil
}