111 lines
3 KiB
Go
111 lines
3 KiB
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) {
|
|
bucketName := make([]byte, bucketKeySize)
|
|
bucketName = objectToExpirationEpochBucketName(addr.Container(), bucketName)
|
|
b := tx.Bucket(bucketName)
|
|
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
|
|
}
|