JCS-pub/common/pkgs/storage/pool/pool.go

package pool

import (
	"sync"

	"gitlink.org.cn/cloudream/common/pkgs/async"
	"gitlink.org.cn/cloudream/jcs-pub/common/pkgs/storage/factory"
	stgtypes "gitlink.org.cn/cloudream/jcs-pub/common/pkgs/storage/types"
	jcstypes "gitlink.org.cn/cloudream/jcs-pub/common/types"
)

type userSpace struct {
	detail *jcstypes.UserSpaceDetail
	store  stgtypes.ShardStore
}

func (u *userSpace) Drop() {
	if u.store != nil {
		u.store.Stop()
		u.store = nil
	}
}

type userSpaceKey struct {
	UserID      jcstypes.UserID
	UserSpaceID jcstypes.UserSpaceID
}

type Pool struct {
	spaces    map[userSpaceKey]*userSpace
	lock      sync.Mutex
	eventChan *stgtypes.StorageEventChan
}

func NewPool() *Pool {
	return &Pool{
		spaces:    make(map[userSpaceKey]*userSpace),
		eventChan: async.NewUnboundChannel[stgtypes.StorageEvent](),
	}
}

func (p *Pool) Drop(userID jcstypes.UserID, spaceID jcstypes.UserSpaceID) {
	p.lock.Lock()
	defer p.lock.Unlock()

	key := userSpaceKey{
		UserID:      userID,
		UserSpaceID: spaceID,
	}
	space := p.spaces[key]
	if space != nil {
		space.Drop()
	}

	delete(p.spaces, key)
}

func (p *Pool) GetShardStore(spaceDetail *jcstypes.UserSpaceDetail) (stgtypes.ShardStore, error) {
	p.lock.Lock()
	defer p.lock.Unlock()

	key := userSpaceKey{
		UserID:      spaceDetail.UserID,
		UserSpaceID: spaceDetail.UserSpace.UserSpaceID,
	}

	space := p.spaces[key]
	if space == nil {
		space = &userSpace{
			detail: spaceDetail,
		}
		p.spaces[key] = space
	}

	if space.detail.UserSpace.Revision != spaceDetail.UserSpace.Revision {
		space.Drop()
		space.detail = spaceDetail
	}

	if space.store == nil {
		bld := factory.GetBuilder(spaceDetail)
		store, err := bld.CreateShardStore(false)
		if err != nil {
			return nil, err
		}
		space.store = store
		store.Start(p.eventChan)
	}

	return space.store, nil
}

func (p *Pool) GetBaseStore(spaceDetail *jcstypes.UserSpaceDetail) (stgtypes.BaseStore, error) {
	return factory.GetBuilder(spaceDetail).CreateBaseStore(false)
}

func (p *Pool) GetMultiparter(spaceDetail *jcstypes.UserSpaceDetail) (stgtypes.Multiparter, error) {
	return factory.GetBuilder(spaceDetail).CreateMultiparter(false)
}

func (p *Pool) GetS2STransfer(spaceDetail *jcstypes.UserSpaceDetail) (stgtypes.S2STransfer, error) {
	return factory.GetBuilder(spaceDetail).CreateS2STransfer(false)
}

func (p *Pool) GetECMultiplier(spaceDetail *jcstypes.UserSpaceDetail) (stgtypes.ECMultiplier, error) {
	return factory.GetBuilder(spaceDetail).CreateECMultiplier(false)
}