frostfs-s3-gw/api/layer/cache.go

package layer

import (
	"github.com/nspcc-dev/neofs-s3-gw/api/cache"
	"github.com/nspcc-dev/neofs-s3-gw/api/data"
	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
	"github.com/nspcc-dev/neofs-sdk-go/user"
	"go.uber.org/zap"
)

type Cache struct {
	logger      *zap.Logger
	listsCache  *cache.ObjectsListCache
	objCache    *cache.ObjectsCache
	namesCache  *cache.ObjectsNameCache
	bucketCache *cache.BucketCache
	systemCache *cache.SystemCache
	accessCache *cache.AccessControlCache
}

// CachesConfig contains params for caches.
type CachesConfig struct {
	Logger        *zap.Logger
	Objects       *cache.Config
	ObjectsList   *cache.Config
	Names         *cache.Config
	Buckets       *cache.Config
	System        *cache.Config
	AccessControl *cache.Config
}

// DefaultCachesConfigs returns filled configs.
func DefaultCachesConfigs(logger *zap.Logger) *CachesConfig {
	return &CachesConfig{
		Logger:        logger,
		Objects:       cache.DefaultObjectsConfig(logger),
		ObjectsList:   cache.DefaultObjectsListConfig(logger),
		Names:         cache.DefaultObjectsNameConfig(logger),
		Buckets:       cache.DefaultBucketConfig(logger),
		System:        cache.DefaultSystemConfig(logger),
		AccessControl: cache.DefaultAccessControlConfig(logger),
	}
}

func NewCache(cfg *CachesConfig) *Cache {
	return &Cache{
		logger:      cfg.Logger,
		listsCache:  cache.NewObjectsListCache(cfg.ObjectsList),
		objCache:    cache.New(cfg.Objects),
		namesCache:  cache.NewObjectsNameCache(cfg.Names),
		bucketCache: cache.NewBucketCache(cfg.Buckets),
		systemCache: cache.NewSystemCache(cfg.System),
		accessCache: cache.NewAccessControlCache(cfg.AccessControl),
	}
}

func (c *Cache) GetBucket(name string) *data.BucketInfo {
	return c.bucketCache.Get(name)
}

func (c *Cache) PutBucket(bktInfo *data.BucketInfo) {
	if err := c.bucketCache.Put(bktInfo); err != nil {
		c.logger.Warn("couldn't put bucket info into cache",
			zap.String("bucket name", bktInfo.Name),
			zap.Stringer("bucket cid", bktInfo.CID),
			zap.Error(err))
	}
}

func (c *Cache) DeleteBucket(name string) {
	c.bucketCache.Delete(name)
}

func (c *Cache) CleanListCacheEntriesContainingObject(objectName string, cnrID cid.ID) {
	c.listsCache.CleanCacheEntriesContainingObject(objectName, cnrID)
}

func (c *Cache) DeleteObjectName(cnrID cid.ID, bktName, objName string) {
	c.namesCache.Delete(bktName + "/" + objName)
	c.listsCache.CleanCacheEntriesContainingObject(objName, cnrID)
}

func (c *Cache) DeleteObject(addr oid.Address) {
	c.objCache.Delete(addr)
}

func (c *Cache) GetObject(owner user.ID, addr oid.Address) *data.ExtendedObjectInfo {
	if !c.accessCache.Get(owner, addr.String()) {
		return nil
	}

	return c.objCache.GetObject(addr)
}

func (c *Cache) GetLastObject(owner user.ID, bktName, objName string) *data.ExtendedObjectInfo {
	addr := c.namesCache.Get(bktName + "/" + objName)
	if addr == nil {
		return nil
	}

	return c.GetObject(owner, *addr)
}

func (c *Cache) PutObject(owner user.ID, extObjInfo *data.ExtendedObjectInfo) {
	if err := c.objCache.PutObject(extObjInfo); err != nil {
		c.logger.Warn("couldn't add object to cache", zap.Error(err),
			zap.String("object_name", extObjInfo.ObjectInfo.Name), zap.String("bucket_name", extObjInfo.ObjectInfo.Bucket),
			zap.String("cid", extObjInfo.ObjectInfo.CID.EncodeToString()), zap.String("oid", extObjInfo.ObjectInfo.ID.EncodeToString()))
	}

	if err := c.accessCache.Put(owner, extObjInfo.ObjectInfo.Address().EncodeToString()); err != nil {
		c.logger.Warn("couldn't cache access control operation", zap.Error(err))
	}
}

func (c *Cache) PutObjectWithName(owner user.ID, extObjInfo *data.ExtendedObjectInfo) {
	c.PutObject(owner, extObjInfo)

	if err := c.namesCache.Put(extObjInfo.ObjectInfo.NiceName(), extObjInfo.ObjectInfo.Address()); err != nil {
		c.logger.Warn("couldn't put obj address to name cache",
			zap.String("obj nice name", extObjInfo.ObjectInfo.NiceName()),
			zap.Error(err))
	}
}

func (c *Cache) GetList(owner user.ID, key cache.ObjectsListKey) []*data.NodeVersion {
	if !c.accessCache.Get(owner, key.String()) {
		return nil
	}

	return c.listsCache.GetVersions(key)
}

func (c *Cache) PutList(owner user.ID, key cache.ObjectsListKey, list []*data.NodeVersion) {
	if err := c.listsCache.PutVersions(key, list); err != nil {
		c.logger.Warn("couldn't cache list of objects", zap.Error(err))
	}

	if err := c.accessCache.Put(owner, key.String()); err != nil {
		c.logger.Warn("couldn't cache access control operation", zap.Error(err))
	}
}

func (c *Cache) GetTagging(key string) map[string]string {
	return c.systemCache.GetTagging(key)
}

func (c *Cache) PutTagging(key string, tags map[string]string) {
	if err := c.systemCache.PutTagging(key, tags); err != nil {
		c.logger.Error("couldn't cache tags", zap.Error(err))
	}
}

func (c *Cache) DeleteTagging(key string) {
	c.systemCache.Delete(key)
}

func (c *Cache) GetLockInfo(key string) *data.LockInfo {
	return c.systemCache.GetLockInfo(key)
}

func (c *Cache) PutLockInfo(key string, lockInfo *data.LockInfo) {
	if err := c.systemCache.PutLockInfo(key, lockInfo); err != nil {
		c.logger.Error("couldn't cache lock info", zap.Error(err))
	}
}

func (c *Cache) GetSettings(bktInfo *data.BucketInfo) *data.BucketSettings {
	key := bktInfo.Name + bktInfo.SettingsObjectName()
	return c.systemCache.GetSettings(key)
}

func (c *Cache) PutSettings(bktInfo *data.BucketInfo, settings *data.BucketSettings) {
	key := bktInfo.Name + bktInfo.SettingsObjectName()
	if err := c.systemCache.PutSettings(key, settings); err != nil {
		c.logger.Warn("couldn't cache bucket settings", zap.String("bucket", bktInfo.Name), zap.Error(err))
	}
}

func (c *Cache) GetCORS(bkt *data.BucketInfo) *data.CORSConfiguration {
	return c.systemCache.GetCORS(bkt.Name + bkt.CORSObjectName())
}

func (c *Cache) PutCORS(bkt *data.BucketInfo, settings *data.CORSConfiguration) {
	if err := c.systemCache.PutCORS(bkt.Name+bkt.CORSObjectName(), settings); err != nil {
		c.logger.Warn("couldn't cache cors", zap.String("bucket", bkt.Name), zap.Error(err))
	}
}

func (c *Cache) DeleteCORS(bktInfo *data.BucketInfo) {
	c.systemCache.Delete(bktInfo.Name + bktInfo.CORSObjectName())
}

func (c *Cache) GetNotificationConfiguration(bktInfo *data.BucketInfo) *data.NotificationConfiguration {
	key := bktInfo.Name + bktInfo.NotificationConfigurationObjectName()
	return c.systemCache.GetNotificationConfiguration(key)
}

func (c *Cache) PutNotificationConfiguration(bktInfo *data.BucketInfo, configuration *data.NotificationConfiguration) {
	key := bktInfo.Name + bktInfo.NotificationConfigurationObjectName()
	if err := c.systemCache.PutNotificationConfiguration(key, configuration); err != nil {
		c.logger.Warn("couldn't cache notification configuration", zap.String("bucket", bktInfo.Name), zap.Error(err))
	}
}