package meta import ( "context" "fmt" "time" objectV2 "git.frostfs.info/TrueCloudLab/frostfs-api-go/v2/object" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/internal/metaerr" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/util/logicerr" "git.frostfs.info/TrueCloudLab/frostfs-observability/tracing" apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status" cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id" objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object" oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id" "go.etcd.io/bbolt" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" ) // ExistsPrm groups the parameters of Exists operation. type ExistsPrm struct { addr oid.Address } // ExistsRes groups the resulting values of Exists operation. type ExistsRes struct { exists bool } var ErrLackSplitInfo = logicerr.New("no split info on parent object") // SetAddress is an Exists option to set object checked for existence. func (p *ExistsPrm) SetAddress(addr oid.Address) { p.addr = addr } // Exists returns the fact that the object is in the metabase. func (p ExistsRes) Exists() bool { return p.exists } // Exists returns ErrAlreadyRemoved if addr was marked as removed. Otherwise it // returns true if addr is in primary index or false if it is not. // // Returns an error of type apistatus.ObjectAlreadyRemoved if object has been placed in graveyard. // Returns the object.ErrObjectIsExpired if the object is presented but already expired. func (db *DB) Exists(ctx context.Context, prm ExistsPrm) (res ExistsRes, err error) { var ( startedAt = time.Now() success = false ) defer func() { db.metrics.AddMethodDuration("Exists", time.Since(startedAt), success) }() _, span := tracing.StartSpanFromContext(ctx, "metabase.Exists", trace.WithAttributes( attribute.String("address", prm.addr.EncodeToString()), )) defer span.End() db.modeMtx.RLock() defer db.modeMtx.RUnlock() if db.mode.NoMetabase() { return res, ErrDegradedMode } currEpoch := db.epochState.CurrentEpoch() err = db.boltDB.View(func(tx *bbolt.Tx) error { res.exists, err = db.exists(tx, prm.addr, currEpoch) return err }) success = err == nil return res, metaerr.Wrap(err) } func (db *DB) exists(tx *bbolt.Tx, addr oid.Address, currEpoch uint64) (exists bool, err error) { // check graveyard and object expiration first switch objectStatus(tx, addr, currEpoch) { case 1: return false, logicerr.Wrap(apistatus.ObjectNotFound{}) case 2: return false, logicerr.Wrap(apistatus.ObjectAlreadyRemoved{}) case 3: return false, ErrObjectIsExpired } objKey := objectKey(addr.Object(), make([]byte, objectKeySize)) cnr := addr.Container() key := make([]byte, bucketKeySize) // if graveyard is empty, then check if object exists in primary bucket if inBucket(tx, primaryBucketName(cnr, key), objKey) { return true, nil } // if primary bucket is empty, then check if object exists in parent bucket if inBucket(tx, parentBucketName(cnr, key), objKey) { splitInfo, err := getSplitInfo(tx, cnr, objKey) if err != nil { return false, err } return false, logicerr.Wrap(objectSDK.NewSplitInfoError(splitInfo)) } // if parent bucket is empty, then check if object exists in typed buckets return firstIrregularObjectType(tx, cnr, objKey) != objectSDK.TypeRegular, nil } // objectStatus returns: // - 0 if object is available; // - 1 if object with GC mark; // - 2 if object is covered with tombstone; // - 3 if object is expired. func objectStatus(tx *bbolt.Tx, addr oid.Address, currEpoch uint64) uint8 { // locked object could not be removed/marked with GC/expired if objectLocked(tx, addr.Container(), addr.Object()) { return 0 } // we check only if the object is expired in the current // epoch since it is considered the only corner case: the // GC is expected to collect all the objects that have // expired previously for less than the one epoch duration expired := isExpiredWithAttribute(tx, objectV2.SysAttributeExpEpoch, addr, currEpoch) if !expired { expired = isExpiredWithAttribute(tx, objectV2.SysAttributeExpEpochNeoFS, addr, currEpoch) } if expired { return 3 } graveyardBkt := tx.Bucket(graveyardBucketName) garbageBkt := tx.Bucket(garbageBucketName) addrKey := addressKey(addr, make([]byte, addressKeySize)) return inGraveyardWithKey(addrKey, graveyardBkt, garbageBkt) } func inGraveyardWithKey(addrKey []byte, graveyard, garbageBCK *bbolt.Bucket) uint8 { if graveyard == nil { // incorrect metabase state, does not make // sense to check garbage bucket return 0 } val := graveyard.Get(addrKey) if val == nil { if garbageBCK == nil { // incorrect node state return 0 } val = garbageBCK.Get(addrKey) if val != nil { // object has been marked with GC return 1 } // neither in the graveyard // nor was marked with GC mark return 0 } // object in the graveyard return 2 } // inBucket checks if key <key> is present in bucket <name>. func inBucket(tx *bbolt.Tx, name, key []byte) bool { bkt := tx.Bucket(name) if bkt == nil { return false } // using `get` as `exists`: https://github.com/boltdb/bolt/issues/321 val := bkt.Get(key) return len(val) != 0 } // getSplitInfo returns SplitInfo structure from root index. Returns error // if there is no `key` record in root index. func getSplitInfo(tx *bbolt.Tx, cnr cid.ID, key []byte) (*objectSDK.SplitInfo, error) { bucketName := rootBucketName(cnr, make([]byte, bucketKeySize)) rawSplitInfo := getFromBucket(tx, bucketName, key) if len(rawSplitInfo) == 0 { return nil, ErrLackSplitInfo } splitInfo := objectSDK.NewSplitInfo() err := splitInfo.Unmarshal(rawSplitInfo) if err != nil { return nil, fmt.Errorf("can't unmarshal split info from root index: %w", err) } return splitInfo, nil }