package shard import ( "context" "fmt" "git.frostfs.info/TrueCloudLab/frostfs-node/internal/logs" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/common" meta "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/metabase" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/util/logicerr" "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/writecache" tracingPkg "git.frostfs.info/TrueCloudLab/frostfs-node/pkg/tracing" "git.frostfs.info/TrueCloudLab/frostfs-observability/tracing" "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client" apistatus "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client/status" objectSDK "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object" oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/trace" "go.uber.org/zap" ) // storFetcher is a type to unify object fetching mechanism in `fetchObjectData` // method. It represents generalization of `getSmall` and `getBig` methods. type storFetcher = func(stor *blobstor.BlobStor, id []byte) (*objectSDK.Object, error) // GetPrm groups the parameters of Get operation. type GetPrm struct { addr oid.Address skipMeta bool skipEvacCheck bool } // GetRes groups the resulting values of Get operation. type GetRes struct { obj *objectSDK.Object hasMeta bool } // SetAddress is a Get option to set the address of the requested object. // // Option is required. func (p *GetPrm) SetAddress(addr oid.Address) { p.addr = addr } // SetIgnoreMeta is a Get option try to fetch object from blobstor directly, // without accessing metabase. func (p *GetPrm) SetIgnoreMeta(ignore bool) { p.skipMeta = ignore } // SkipEvacCheck is a Get option which instruct to skip check is evacuation in progress. func (p *GetPrm) SkipEvacCheck(val bool) { p.skipEvacCheck = val } // Object returns the requested object. func (r GetRes) Object() *objectSDK.Object { return r.obj } // HasMeta returns true if info about the object was found in the metabase. func (r GetRes) HasMeta() bool { return r.hasMeta } // Get reads an object from shard. // // Returns any error encountered that // did not allow to completely read the object part. // // Returns an error of type apistatus.ObjectNotFound if the requested object is missing in shard. // Returns an error of type apistatus.ObjectAlreadyRemoved if the requested object has been marked as removed in shard. // Returns the object.ErrObjectIsExpired if the object is presented but already expired. // Returns the ErrShardDisabled if the shard is disabled. func (s *Shard) Get(ctx context.Context, prm GetPrm) (GetRes, error) { ctx, span := tracing.StartSpanFromContext(ctx, "Shard.Get", trace.WithAttributes( attribute.String("shard_id", s.ID().String()), attribute.String("address", prm.addr.EncodeToString()), attribute.Bool("skip_meta", prm.skipMeta), )) defer span.End() s.m.RLock() defer s.m.RUnlock() if s.info.Mode.Disabled() { return GetRes{}, ErrShardDisabled } if s.info.EvacuationInProgress && !prm.skipEvacCheck { return GetRes{}, logicerr.Wrap(new(apistatus.ObjectNotFound)) } cb := func(stor *blobstor.BlobStor, id []byte) (*objectSDK.Object, error) { var getPrm common.GetPrm getPrm.Address = prm.addr getPrm.StorageID = id res, err := stor.Get(ctx, getPrm) if err != nil { return nil, err } return res.Object, nil } wc := func(c writecache.Cache) (*objectSDK.Object, error) { return c.Get(ctx, prm.addr) } skipMeta := prm.skipMeta || s.info.Mode.NoMetabase() obj, hasMeta, err := s.fetchObjectData(ctx, prm.addr, skipMeta, cb, wc) return GetRes{ obj: obj, hasMeta: hasMeta, }, err } // emptyStorageID is an empty storageID that indicates that // an object is big (and is stored in an FSTree, not in a blobovnicza). var emptyStorageID = make([]byte, 0) // fetchObjectData looks through writeCache and blobStor to find object. func (s *Shard) fetchObjectData(ctx context.Context, addr oid.Address, skipMeta bool, cb storFetcher, wc func(w writecache.Cache) (*objectSDK.Object, error)) (*objectSDK.Object, bool, error) { var ( mErr error mRes meta.ExistsRes ) if !skipMeta { var mPrm meta.ExistsPrm mPrm.SetAddress(addr) mRes, mErr = s.metaBase.Exists(ctx, mPrm) if mErr != nil && !s.info.Mode.NoMetabase() { return nil, false, mErr } if !mRes.Exists() { return nil, false, logicerr.Wrap(new(apistatus.ObjectNotFound)) } } else { s.log.Warn(logs.ShardFetchingObjectWithoutMeta, zap.Stringer("addr", addr)) } if s.hasWriteCache() { res, err := wc(s.writeCache) if err == nil || IsErrOutOfRange(err) { return res, false, err } if client.IsErrObjectNotFound(err) { s.log.Debug(logs.ShardObjectIsMissingInWritecache, zap.Stringer("addr", addr), zap.Bool("skip_meta", skipMeta), zap.String("trace_id", tracingPkg.GetTraceID(ctx))) } else { s.log.Error(logs.ShardFailedToFetchObjectFromWritecache, zap.Error(err), zap.Stringer("addr", addr), zap.Bool("skip_meta", skipMeta), zap.String("trace_id", tracingPkg.GetTraceID(ctx))) } } if skipMeta || mErr != nil { res, err := cb(s.blobStor, nil) return res, false, err } var mPrm meta.StorageIDPrm mPrm.SetAddress(addr) mExRes, err := s.metaBase.StorageID(ctx, mPrm) if err != nil { return nil, true, fmt.Errorf("can't fetch blobovnicza id from metabase: %w", err) } storageID := mExRes.StorageID() if storageID == nil { // `nil` storageID returned without any error // means that object is big, `cb` expects an // empty (but non-nil) storageID in such cases storageID = emptyStorageID } res, err := cb(s.blobStor, storageID) return res, true, err }