frostfs-node/pkg/local_object_storage/metabase/list.go

package meta

import (
	"errors"
	"strings"

	cid "github.com/nspcc-dev/neofs-sdk-go/container/id"
	oid "github.com/nspcc-dev/neofs-sdk-go/object/id"
	"go.etcd.io/bbolt"
)

// ErrEndOfListing is returned from object listing with cursor
// when storage can't return any more objects after provided
// cursor. Use nil cursor object to start listing again.
var ErrEndOfListing = errors.New("end of object listing")

// Cursor is a type for continuous object listing.
type Cursor struct {
	bucketName     []byte
	inBucketOffset []byte
}

// ListPrm contains parameters for ListWithCursor operation.
type ListPrm struct {
	count  int
	cursor *Cursor
}

// WithCount sets maximum amount of addresses that ListWithCursor should return.
func (l *ListPrm) WithCount(count uint32) {
	l.count = int(count)
}

// WithCursor sets cursor for ListWithCursor operation. For initial request
// ignore this param or use nil value. For consecutive requests, use value
// from ListRes.
func (l *ListPrm) WithCursor(cursor *Cursor) {
	l.cursor = cursor
}

// ListRes contains values returned from ListWithCursor operation.
type ListRes struct {
	addrList []oid.Address
	cursor   *Cursor
}

// AddressList returns addresses selected by ListWithCursor operation.
func (l ListRes) AddressList() []oid.Address {
	return l.addrList
}

// Cursor returns cursor for consecutive listing requests.
func (l ListRes) Cursor() *Cursor {
	return l.cursor
}

// ListWithCursor lists physical objects available in metabase starting from
// cursor. Includes objects of all types. Does not include inhumed objects.
// Use cursor value from response for consecutive requests.
//
// Returns ErrEndOfListing if there are no more objects to return or count
// parameter set to zero.
func ListWithCursor(db *DB, count uint32, cursor *Cursor) ([]oid.Address, *Cursor, error) {
	var listPrm ListPrm
	listPrm.WithCount(count)
	listPrm.WithCursor(cursor)

	r, err := db.ListWithCursor(listPrm)
	if err != nil {
		return nil, nil, err
	}

	return r.AddressList(), r.Cursor(), nil
}

// ListWithCursor lists physical objects available in metabase starting from
// cursor. Includes objects of all types. Does not include inhumed objects.
// Use cursor value from response for consecutive requests.
//
// Returns ErrEndOfListing if there are no more objects to return or count
// parameter set to zero.
func (db *DB) ListWithCursor(prm ListPrm) (res ListRes, err error) {
	result := make([]oid.Address, 0, prm.count)

	err = db.boltDB.View(func(tx *bbolt.Tx) error {
		res.addrList, res.cursor, err = db.listWithCursor(tx, result, prm.count, prm.cursor)
		return err
	})

	return res, err
}

func (db *DB) listWithCursor(tx *bbolt.Tx, result []oid.Address, count int, cursor *Cursor) ([]oid.Address, *Cursor, error) {
	threshold := cursor == nil // threshold is a flag to ignore cursor
	var bucketName []byte

	c := tx.Cursor()
	name, _ := c.First()

	if !threshold {
		name, _ = c.Seek(cursor.bucketName)
	}

	var containerID cid.ID

loop:
	for ; name != nil; name, _ = c.Next() {
		postfix, ok := parseContainerIDWithPostfix(&containerID, name)
		if !ok {
			continue
		}

		switch postfix {
		case
			"",
			storageGroupPostfix,
			bucketNameSuffixLockers,
			tombstonePostfix:
		default:
			continue
		}

		prefix := containerID.EncodeToString() + "/"
		result, cursor = selectNFromBucket(tx, name, prefix, containerID, result, count, cursor, threshold)
		bucketName = name
		if len(result) >= count {
			break loop
		}

		// set threshold flag after first `selectNFromBucket` invocation
		// first invocation must look for cursor object
		threshold = true
	}

	if len(result) == 0 {
		return nil, nil, ErrEndOfListing
	}

	// new slice is much faster but less memory efficient
	// we need to copy, because bucketName exists during bbolt tx
	cursor.bucketName = make([]byte, len(bucketName))
	copy(cursor.bucketName, bucketName)

	return result, cursor, nil
}

// selectNFromBucket similar to selectAllFromBucket but uses cursor to find
// object to start selecting from. Ignores inhumed objects.
func selectNFromBucket(tx *bbolt.Tx,
	name []byte, // bucket name
	prefix string, // container ID prefix, optimization
	cnt cid.ID, // container ID
	to []oid.Address, // listing result
	limit int, // stop listing at `limit` items in result
	cursor *Cursor, // start from cursor object
	threshold bool, // ignore cursor and start immediately
) ([]oid.Address, *Cursor) {
	bkt := tx.Bucket(name)
	if bkt == nil {
		return to, cursor
	}

	if cursor == nil {
		cursor = new(Cursor)
	}

	count := len(to)
	c := bkt.Cursor()
	k, _ := c.First()

	offset := cursor.inBucketOffset

	if !threshold {
		c.Seek(offset)
		k, _ = c.Next() // we are looking for objects _after_ the cursor
	}

	addrRaw := make([]byte, len(prefix)+44)
	copy(addrRaw, prefix)

	for ; k != nil; k, _ = c.Next() {
		if count >= limit {
			break
		}

		var obj oid.ID
		if err := obj.DecodeString(string(k)); err != nil {
			break
		}

		offset = k
		addrRaw = append(addrRaw[:len(prefix)], k...)
		if inGraveyardWithKey(tx, addrRaw) > 0 {
			continue
		}

		var a oid.Address
		a.SetContainer(cnt)
		a.SetObject(obj)
		to = append(to, a)
		count++
	}

	// new slice is much faster but less memory efficient
	// we need to copy, because offset exists during bbolt tx
	cursor.inBucketOffset = make([]byte, len(offset))
	copy(cursor.inBucketOffset, offset)

	return to, cursor
}

func parseContainerIDWithPostfix(containerID *cid.ID, name []byte) (string, bool) {
	var (
		containerIDStr = string(name)
		postfix        string
	)

	ind := strings.Index(string(name), invalidBase58String)
	if ind > 0 {
		postfix = containerIDStr[ind:]
		containerIDStr = containerIDStr[:ind]
	}

	if err := containerID.DecodeString(containerIDStr); err != nil {
		return "", false
	}

	return postfix, true
}