[#236] api: Refactor caches: ObjectsList, Objects

Move ObjectsList from layer to cache package
Rename object_cache.go to objects.go

Signed-off-by: Angira Kekteeva <kira@nspcc.ru>

api/cache/objectslist.go

@@ -0,0 +1,104 @@
+package cache
+
+import (
+	"sync"
+	"time"
+
+	cid "github.com/nspcc-dev/neofs-api-go/pkg/container/id"
+	"github.com/nspcc-dev/neofs-s3-gw/api"
+)
+
+/*
+	This is an implementation of a cache for ListObjectsV2/V1 which we can return to users when we receive a ListObjects
+	request.
+
+	The cache is a map which has a key: ObjectsListKey struct and a value: list of objects. After putting a record we
+	start a timer (via time.AfterFunc) that removes the record after DefaultObjectsListCacheLifetime value.
+
+	When we get a request from the user we just try to find the suitable and non-expired cache and then we return
+	the list of objects. Otherwise we send the request to NeoFS.
+*/
+
+// ObjectsListCache provides interface for cache of ListObjectsV2 in a layer struct.
+type (
+	ObjectsListCache interface {
+		Get(key ObjectsListKey) []*api.ObjectInfo
+		Put(key ObjectsListKey, objects []*api.ObjectInfo)
+	}
+)
+
+// DefaultObjectsListCacheLifetime is a default lifetime of entries in cache of ListObjects.
+const DefaultObjectsListCacheLifetime = time.Second * 60
+
+const (
+	// ListObjectsMethod is used to mark a cache entry for ListObjectsV1/V2.
+	ListObjectsMethod = "listObjects"
+	// ListVersionsMethod is used to mark a cache entry for ListObjectVersions.
+	ListVersionsMethod = "listVersions"
+)
+
+type (
+	// ListObjectsCache contains cache for ListObjects and ListObjectVersions.
+	ListObjectsCache struct {
+		cacheLifetime time.Duration
+		caches        map[ObjectsListKey]objectsListEntry
+		mtx           sync.RWMutex
+	}
+	objectsListEntry struct {
+		list []*api.ObjectInfo
+	}
+	// ObjectsListKey is a key to find a ObjectsListCache's entry.
+	ObjectsListKey struct {
+		Method    string
+		Key       string
+		Delimiter string
+		Prefix    string
+	}
+)
+
+// NewObjectsListCache is a constructor which creates an object of ListObjectsCache with given lifetime of entries.
+func NewObjectsListCache(lifetime time.Duration) *ListObjectsCache {
+	return &ListObjectsCache{
+		caches:        make(map[ObjectsListKey]objectsListEntry),
+		cacheLifetime: lifetime,
+	}
+}
+
+// Get return list of ObjectInfo.
+func (l *ListObjectsCache) Get(key ObjectsListKey) []*api.ObjectInfo {
+	l.mtx.RLock()
+	defer l.mtx.RUnlock()
+	if val, ok := l.caches[key]; ok {
+		return val.list
+	}
+	return nil
+}
+
+// Put put a list of objects to cache.
+func (l *ListObjectsCache) Put(key ObjectsListKey, objects []*api.ObjectInfo) {
+	if len(objects) == 0 {
+		return
+	}
+	var c objectsListEntry
+	l.mtx.Lock()
+	defer l.mtx.Unlock()
+	c.list = objects
+	l.caches[key] = c
+	time.AfterFunc(l.cacheLifetime, func() {
+		l.mtx.Lock()
+		delete(l.caches, key)
+		l.mtx.Unlock()
+	})
+}
+
+// CreateObjectsListCacheKey returns ObjectsListKey with given CID, method, prefix, and delimiter.
+func CreateObjectsListCacheKey(cid *cid.ID, method, prefix, delimiter string) (ObjectsListKey, error) {
+	p := ObjectsListKey{
+		Method:    method,
+		Key:       cid.String(),
+		Delimiter: delimiter,
+		Prefix:    prefix,
+	}
+
+	return p, nil
+}