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

package meta

import (
	"context"
	"encoding/binary"
	"errors"
	"strconv"
	"time"

	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/internal/metaerr"
	"git.frostfs.info/TrueCloudLab/frostfs-observability/tracing"
	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
	"go.etcd.io/bbolt"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/trace"
)

var errInvalidEpochValueLength = errors.New("could not parse expiration epoch: invalid data length")

// FilterExpired return expired items from addresses.
// Address considered expired if metabase does contain information about expiration and
// expiration epoch is less than epoch.
func (db *DB) FilterExpired(ctx context.Context, epoch uint64, addresses []oid.Address) ([]oid.Address, error) {
	var (
		startedAt = time.Now()
		success   = true
	)
	defer func() {
		db.metrics.AddMethodDuration("FilterExpired", time.Since(startedAt), success)
	}()

	_, span := tracing.StartSpanFromContext(ctx, "metabase.FilterExpired",
		trace.WithAttributes(
			attribute.String("epoch", strconv.FormatUint(epoch, 10)),
			attribute.Int("addr_count", len(addresses)),
		))
	defer span.End()

	db.modeMtx.RLock()
	defer db.modeMtx.RUnlock()

	if db.mode.NoMetabase() {
		return nil, ErrDegradedMode
	}

	result := make([]oid.Address, 0, len(addresses))
	containerIDToObjectIDs := make(map[cid.ID][]oid.ID)
	for _, addr := range addresses {
		containerIDToObjectIDs[addr.Container()] = append(containerIDToObjectIDs[addr.Container()], addr.Object())
	}

	err := db.boltDB.View(func(tx *bbolt.Tx) error {
		for containerID, objectIDs := range containerIDToObjectIDs {
			select {
			case <-ctx.Done():
				return ErrInterruptIterator
			default:
			}

			expired, err := selectExpiredObjects(tx, epoch, containerID, objectIDs)
			if err != nil {
				return err
			}
			result = append(result, expired...)
		}
		return nil
	})
	if err != nil {
		return nil, metaerr.Wrap(err)
	}
	success = true
	return result, nil
}

func isExpired(tx *bbolt.Tx, addr oid.Address, currEpoch uint64) (bool, error) {
	return isExpiredWithCache(nil, tx, addr, currEpoch)
}

func isExpiredWithCache(bc *bucketCache, tx *bbolt.Tx, addr oid.Address, currEpoch uint64) (bool, error) {
	b := getExpiredBucket(bc, tx, addr.Container())
	if b == nil {
		return false, nil
	}
	key := make([]byte, objectKeySize)
	addr.Object().Encode(key)
	val := b.Get(key)
	if len(val) == 0 {
		return false, nil
	}
	if len(val) != epochSize {
		return false, errInvalidEpochValueLength
	}
	expEpoch := binary.LittleEndian.Uint64(val)
	return expEpoch < currEpoch, nil
}

func selectExpiredObjects(tx *bbolt.Tx, epoch uint64, containerID cid.ID, objectIDs []oid.ID) ([]oid.Address, error) {
	result := make([]oid.Address, 0)
	var addr oid.Address
	addr.SetContainer(containerID)
	for _, objID := range objectIDs {
		addr.SetObject(objID)
		expired, err := isExpired(tx, addr, epoch)
		if err != nil {
			return nil, err
		}
		if expired {
			result = append(result, addr)
		}
	}
	return result, nil
}